Feature delivery

Hand a brief to a team and get back an approved change with the evidence beside it. This file has a Claude seat write a requirements note, a Codex seat implement it, runs the test with Node, has a Claude reviewer read the result, and has a final Claude seat write the approval. The reviewer can send the work back to the implementer, once.

npm install @obversa/runtime @obversa/teams @obversa/engine-claude-cli @obversa/engine-codex

The file

import { ClaudeCliEngine } from '@obversa/engine-claude-cli';
import { CodexEngine } from '@obversa/engine-codex';
import { run } from '@obversa/runtime';
import { featureDelivery } from '@obversa/teams';

const workspace = process.cwd();
const analyse = {
  engine: new ClaudeCliEngine({
    defaultModel: 'claude-sonnet-4-5',
    permissionMode: 'bypassPermissions',
  }),
  identity: {
    adapter: 'claude-cli',
    provider: 'anthropic',
    modelFamily: 'claude',
    model: 'claude-sonnet-4-5',
  },
};
const implement = {
  engine: new CodexEngine({
    defaultModel: 'gpt-5.6-luna',
    permissionMode: 'bypassPermissions',
  }),
  identity: {
    adapter: 'codex',
    provider: 'openai',
    modelFamily: 'gpt',
    model: 'gpt-5.6-luna',
  },
};
const reviewer = {
  engine: new ClaudeCliEngine({
    defaultModel: 'claude-sonnet-4-5',
    permissionMode: 'bypassPermissions',
  }),
  identity: {
    adapter: 'claude-cli',
    provider: 'anthropic',
    modelFamily: 'claude',
    model: 'claude-sonnet-4-5',
  },
};
const approve = {
  engine: new ClaudeCliEngine({
    defaultModel: 'claude-sonnet-4-5',
    permissionMode: 'bypassPermissions',
  }),
  identity: {
    adapter: 'claude-cli',
    provider: 'anthropic',
    modelFamily: 'claude',
    model: 'claude-sonnet-4-5',
  },
};

const team = featureDelivery({
  brief: 'Deliver a pure triple(value) function in src/triple.mjs with a Node test in test/triple.test.mjs.',
  workspace,
  files: ['src/triple.mjs', 'test/triple.test.mjs'],
  test: { command: 'node', args: ['--test', 'test/triple.test.mjs'] },
  analyse,
  implement,
  reviewers: [{ name: 'correctness', seat: reviewer }],
  reviewThreshold: 1,
  approve,
});

const result = await run(team, { cwd: workspace });
console.log(JSON.stringify(result.outcome, null, 2));

What a run printed

From one real run of this file.

{
  "status": "pass",
  "summary": "dag \"feature-delivery\": all 5 node(s) green",
  "data": {
    "analyse": {
      "status": "pass",
      "summary": "Requirements extracted from work brief and documented in team-output/brief.md. Identified 4 core requirements: pure triple(value) function, source location (src/triple.mjs), Node test implementation, and test location (test/triple.test.mjs)."
    },
    "implement": {
      "status": "pass",
      "summary": "Implemented pure triple(value) with finite-number validation and added Node tests for numeric and invalid inputs."
    },
    "test": {
      "status": "pass",
      "summary": "`node` exited 0"
    },
    "review": {
      "status": "pass",
      "summary": "Review panel: 1/1 reviewer(s) cleared.",
      "data": {
        "findings": [],
        "escalatedFindings": [],
        "errors": [],
        "results": [
          {
            "kind": "verdict",
            "name": "correctness",
            "met": true,
            "reason": "Implementation is correct. The triple function is pure, properly validates inputs, and correctly multiplies finite numbers by 3. Tests comprehensively verify both valid inputs and error cases."
          }
        ],
        "passed": 1,
        "required": 1,
        "severityCounts": {}
      }
    },
    "approve": {
      "status": "pass",
      "summary": "Implementation meets all requirements. The triple function is pure, correctly multiplies finite numbers by 3, properly validates inputs, and has comprehensive passing tests (2/2). Ready to ship."
    }
  }
}

The analyse step wrote team-output/brief.md:

# Work Brief Requirements

## Requirements

1. **Function Implementation**
   - Create a function named `triple`
   - Function accepts a `value` parameter
   - Function must be pure (deterministic, no side effects, same input always produces same output)

2. **Source File Location**
   - File path: `src/triple.mjs`

3. **Test Implementation**
   - Create a Node test for the `triple` function
   - Test must verify the function's behavior

4. **Test File Location**
   - File path: `test/triple.test.mjs`

The implementer wrote src/triple.mjs:

export function triple(value) {
  if (typeof value !== 'number' || !Number.isFinite(value)) {
    throw new TypeError('value must be a finite number');
  }

  return value * 3;
}

and test/triple.test.mjs:

import test from 'node:test';
import assert from 'node:assert/strict';
import { triple } from '../src/triple.mjs';

test('triple multiplies finite numbers by three', () => {
  assert.strictEqual(triple(4), 12);
  assert.strictEqual(triple(0), 0);
  assert.strictEqual(triple(-2.5), -7.5);
});

test('triple rejects values that are not finite numbers', () => {
  for (const value of [undefined, null, '4', {}, NaN, Infinity]) {
    assert.throws(() => triple(value), TypeError);
  }
});

The approve step wrote team-output/approval.md:

# Approval

**Status:** ✅ Ready to ship

## Summary

The `triple` function implementation meets all brief requirements and is ready for production:

- **Pure function**: Deterministic, no side effects, consistent output for same input
- **Correct behavior**: Multiplies finite numbers by 3 as specified
- **Robust validation**: Properly rejects non-finite and non-number inputs with TypeError
- **Comprehensive tests**: All tests pass (2/2), covering both valid cases and error handling

## Evidence

1. **Implementation correctness**: Function correctly returns `value * 3` for all finite numbers
2. **Test coverage**: Tests verify positive (4→12), zero (0→0), and negative (-2.5→-7.5) cases
3. **Error handling**: Validation correctly rejects undefined, null, strings, objects, NaN, and Infinity
4. **Review verification**: Correctness review passed with no findings
5. **Test execution**: All tests pass with 100% success rate

## Recommendation

**Ship immediately.** No changes required.

The team’s shape

step	does	done when
analyse	Turn the brief into a delivery note the later steps can read.	The delivery note is in the workspace and names each requirement.
implement	Build the change from the delivery note, taking the last review into account.	The code and its test cover every requirement in the note.
test	Run the test command against the change.	The test command exits 0.
review	Have the reviewers read the change and the test result and count the acceptances.	At least the threshold number of reviewers have accepted.
approve	Record that the change is ready to ship.	An approval note is in the workspace.

Each step needs the one before it. A review below reviewThreshold is a revision request aimed at implement; the implementer runs again with the findings, then the test and the review run again with it.

Gotchas

The analyse step writes the note and nothing else. The package compares the expected files before and after the analyse step, and fails it by name if the seat wrote or changed any of them, because a plan written after the code is not a plan. Files that were already in the workspace before the run are left alone.
The implementer and every reviewer are different model families. The analyse and approve seats are free to share a family with either.
The approval is a file, not a status. team-output/approval.md is what the approve step must leave behind, and the step fails when it is missing or empty.
A writing seat can write anywhere the process can. The files above start their Claude and Codex seats with permission prompts off, which is what lets a model write files. Run them in a directory you are willing to let a model change, and give a reviewing seat a read-only mode if its plugin has one.

Source

The file is examples/teams/feature-delivery.ts. The teams package page lists every input.

Start

Concepts

Examples

Reviewing

Recording runs

Driving runs

Writing workflow shapes

Memory

Workspace

Core packages

Plugins

Feature delivery

The file

What a run printed

The team’s shape

Gotchas

Source

​The file

​What a run printed

​The team’s shape

​Gotchas

​Source

The file

What a run printed

The team’s shape

Gotchas

Source