agent-work-layer 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.2.0 — 2026-10-09
+
+### Breaking
+
+- The MCP server moved to a new package, `agent-work-layer-mcp`, so installing `agent-work-layer` no longer downloads the MCP SDK and zod (7 packages instead of 97).
+  - `npx -y agent-work-layer desk` → `npx -y agent-work-layer-mcp` (same flags and environment variables).
+  - `import { createDeskServer } from "agent-work-layer/mcp"` → `from "agent-work-layer-mcp"`.
+  - `awl desk` now exits with code 2 and prints the new command.
+
+### Added
+
+- Spec v0.2: optional `handoff` on Work Orders and Work Reports: decisions made, approaches tried, open questions and next step, so a job can move to another worker without starting over (SPEC.md §4.4). The MCP tools accept it too.
+- `agent-work-layer/validate`: types, schemas and every check, with no Node built-ins. Runs in browsers, Deno and Bun.
+- `ORDER_SPECS` and `REPORT_SPECS`: every spec version this package reads.
+- `awl new order` and `awl new report` print starter documents that validate together as printed (#7, thanks @brunnojob).
+- SPEC.md §13, Related work: Agent Contracts, A2A tasks, the IETF WIMSE cross-org delegation draft and KYA-OS / MCP-I.
+
+### Changed
+
+- The repository is now an npm workspace: the core is in `packages/core`, the MCP server in `packages/mcp`. Published package contents are unchanged by this.
+
+- The desk writes `awl/work-order@0.2` and `awl/work-report@0.2`. Documents marked `@0.1` are still accepted, so stored orders keep working.
+- Schemas and the version number are built into the code (`packages/core/src/generated.ts`) instead of read from disk at startup.
+
 ## 0.1.1 — 2026-10-09
 
 - Package metadata now links to the GitHub repository, homepage and issue tracker.

package/README.md

@@ -1,6 +1,6 @@
 # agent-work-layer
 
-**Work Orders and Work Reports for AI agents.** A typed SDK, validator, lifecycle engine and MCP server for handing work from one agent to another, with checkable results.
+**Work Orders and Work Reports for AI agents.** A typed SDK, validator and lifecycle engine for handing work from one agent to another, with checkable results. The MCP server is a separate package, [`agent-work-layer-mcp`](packages/mcp/).
 
 [![npm](https://img.shields.io/npm/v/agent-work-layer.svg)](https://www.npmjs.com/package/agent-work-layer)
 [![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
@@ -25,9 +25,13 @@ More diagrams: [message sequence](docs/sequence.svg) · [lifecycle](docs/lifecyc
 
 ## Install
 
-```sh
-npm install agent-work-layer
-```
+Install only the part you use:
+
+| You want to… | Install | Packages |
+|---|---|---|
+| Validate orders and reports, or run a desk in your code | `npm install agent-work-layer` | 7 |
+| Validate in a browser, Deno or Bun | `npm install agent-work-layer`, then import `agent-work-layer/validate` | 7 |
+| Connect agent sessions (e.g. Claude Code) through MCP | `npx -y agent-work-layer-mcp` ([setup](#run-as-an-mcp-server)) | ~100 |
 
 Node.js 20.11 or later. ESM only. Types included.
 
@@ -84,6 +88,28 @@ The desk enforces the spec as you go:
 - Cost within budget and finishing before the deadline. Going over either expires the order.
 - Sub-orders can only narrow their parent's authority.
 
+### Hand off unfinished work
+
+When a worker fails, gets blocked or is cancelled, it can say what the next worker should know. The manager passes that along in the next order:
+
+```ts
+await desk.submitReport(order.id, {
+  status: "failed",
+  error: "Export runs out of memory on files over 2 GB",
+  handoff: {
+    decisions: [{ text: "Stream rows instead of buffering", why: "Memory limit" }],
+    tried: [{ text: "xlsx library", result: "Too slow on large files" }],
+    next_step: "Add tests for null cells",
+  },
+  /* result, evidence, cost, tools_used */
+}, "agent:researcher");
+
+const { handoff } = (await desk.get(order.id)).reports.at(-1)!;
+await desk.create({ ...nextJob, to: "agent:other-worker", handoff }, "agent:manager");
+```
+
+`context` lists what to read; `handoff` says what was decided and already tried. See [SPEC.md §4.4](SPEC.md#44-handoff).
+
 ## Validate documents
 
 ```ts
@@ -98,23 +124,27 @@ Every finding carries the rule id from [SPEC.md §7](SPEC.md#7-checks). `invalid
 
 The JSON Schemas are exported too: `workOrderSchema`, `workReportSchema`, or `agent-work-layer/schemas/work-order.schema.json`.
 
+`agent-work-layer/validate` has the same checks, types and schemas without the desk. It imports nothing from Node, so it runs in browsers, Deno and Bun. (Cloudflare Workers are not supported: the validator compiles schemas to code at runtime, which Workers block.)
+
 ## Run as an MCP server
 
+The server lives in its own package, [`agent-work-layer-mcp`](packages/mcp/), so people who only validate documents don't download the MCP SDK.
+
 Each agent session runs its own desk process. Sessions share one folder, and each is locked to one identity, so a worker cannot approve its own work.
 
 ```sh
 # Claude Code: a manager session and a worker session, each added in its own project folder
-claude mcp add awl -e AWL_STORE="$HOME/.awl" -e AWL_ACTOR=agent:manager -- npx -y agent-work-layer desk
-claude mcp add awl -e AWL_STORE="$HOME/.awl" -e AWL_ACTOR=agent:worker  -- npx -y agent-work-layer desk
+claude mcp add awl -e AWL_STORE="$HOME/.awl" -e AWL_ACTOR=agent:manager -- npx -y agent-work-layer-mcp
+claude mcp add awl -e AWL_STORE="$HOME/.awl" -e AWL_ACTOR=agent:worker  -- npx -y agent-work-layer-mcp
 ```
 
 Tools: `create_work_order`, `list_work_orders`, `get_work_order`, `accept_work_order`, `decline_work_order`, `start_work_order`, `submit_work_report`, `answer_question`, `review_work_report`, `cancel_work_order`, `wait_for_update`.
 
-To embed the server in your own process or transport:
+To embed the server in your own process or transport (`npm install agent-work-layer agent-work-layer-mcp`):
 
 ```ts
 import { WorkDesk, FileStore } from "agent-work-layer";
-import { createDeskServer } from "agent-work-layer/mcp";
+import { createDeskServer } from "agent-work-layer-mcp";
 
 const server = createDeskServer({ desk: new WorkDesk({ store: new FileStore("./.awl") }), actor: "agent:manager" });
 await server.connect(transport);
@@ -123,13 +153,21 @@ await server.connect(transport);
 ## CLI
 
 ```sh
+npx agent-work-layer new order > order.json
+npx agent-work-layer new report > report.json
 npx agent-work-layer validate order.json report.json      # exit 1 on invalid, prints rule ids
 npx agent-work-layer validate child.json --parent order.json
 npx agent-work-layer validate order.json report.json --json
 npx agent-work-layer schema order
-npx agent-work-layer desk --store ./.awl --actor agent:worker
+npx -y agent-work-layer-mcp --store ./.awl --actor agent:worker   # the MCP desk (was "awl desk" before 0.2)
 ```
 
+`new order` starts with one criterion, a USD 1 budget, no allowed tools and a
+deadline one hour after creation. `new report` starts as `blocked`, with a question
+and no evidence of completed work. Both templates validate together as printed.
+Replace the placeholder goal, identities, criterion and report contents before
+using them; keep the report's `order_id` equal to the order's `id`.
+
 ## Lifecycle
 
 ```
@@ -160,7 +198,8 @@ Any active state ──cancel──▶ cancelled   ·   deadline or budget excee
 | `toolAllowed`, `patternCovered` | Tool pattern matching |
 | `nextState`, `allowedActions`, `STATES`, `ROLE_FOR`, `isTerminal` | The state machine |
 | `AwlError`, `isAwlError` | Typed errors with `code` and `findings` |
-| `createDeskServer` (from `agent-work-layer/mcp`) | MCP server for a desk |
+| `ORDER_SPEC`, `REPORT_SPEC`, `ORDER_SPECS`, `REPORT_SPECS` | The spec version written, and every version read |
+| `createDeskServer` (from `agent-work-layer-mcp`) | MCP server for a desk |
 
 `WorkDesk` options: `store`, `clock` (for tests), `newId`, `onEvent(event, record)` (webhooks, logging, metrics).
 
@@ -187,13 +226,16 @@ The desk trusts the `actor` it is given. In production, derive the actor from au
 
 ## Development
 
+The repo is an npm workspace with two packages: the core in [`packages/core`](packages/core/) and the MCP server in [`packages/mcp`](packages/mcp/). The spec, schemas and examples stay at the root; the core copies them in when it is packed.
+
 ```sh
 npm install
-npm test               # unit, integration and end-to-end tests
+npm test               # core and MCP tests (builds the core first)
 npm run test:coverage
 npm run typecheck
-npm run test:package   # builds, packs, installs the tarball in a clean project and uses it
+npm run test:package   # packs both packages, installs them in clean projects and uses them
 npm run check          # all of the above; runs automatically before npm publish
+npm run generate       # after editing schemas/*.json: refreshes packages/core/src/generated.ts
 ```
 
 ## Contributing

package/SPEC.md

@@ -1,6 +1,6 @@
-# Agent Work Layer (AWL) — Specification v0.1 (draft)
+# Agent Work Layer (AWL) — Specification v0.2 (draft)
 
-Status: draft · Date: 2026-10-09
+Status: draft · Date: 2026-10-09 · Changes from v0.1: the optional `handoff` field (§4.4); readers accept both versions (§11); related work (§13).
 
 ## 1. Purpose
 
@@ -39,7 +39,7 @@ The key words MUST, SHOULD and MAY are used as in RFC 2119.
 
 | Field          | Req | Type                | Meaning |
 |----------------|-----|---------------------|---------|
-| `spec`         | yes | `"awl/work-order@0.1"` | Format and version. |
+| `spec`         | yes | `"awl/work-order@0.2"` | Format and version. Readers also accept `@0.1` (§11). |
 | `id`           | yes | string              | Unique job id, set by the desk or manager. |
 | `created_at`   | yes | timestamp           | When the order was issued. |
 | `from`         | yes | agent ref           | The manager. |
@@ -52,6 +52,7 @@ The key words MUST, SHOULD and MAY are used as in RFC 2119.
 | `escalate_to`  | no  | agent ref           | Who to ask when blocked. Default: `from`. |
 | `inputs`       | no  | object              | Structured inputs for the job. |
 | `context`      | no  | array of `{uri, note?}` | Pointers to material the worker should read. |
+| `handoff`      | no  | Handoff (§4.4)      | What earlier work on this job established. |
 | `output_schema`| no  | JSON Schema         | Shape that `result.output` MUST match when done. |
 | `parent_id`    | no  | string              | Set when this order was split from a larger one (§8). |
 | `metadata`     | no  | object              | Free-form; ignored by checks. |
@@ -77,11 +78,35 @@ A Budget is an object with at least one of these units. Cost (in the report) use
 A tool is named `<server>/<tool>`, where `<server>` is the MCP server name as the worker knows it.
 Patterns: `server/tool` (exactly one tool), `server/*` (every tool on that server), `*` (any tool).
 
+### 4.4 Handoff
+
+When a job moves from one worker to another (after a failure, a cancellation or a block), the next worker should not start from nothing. `context` says what to read; `handoff` says what was decided, what was already tried, and where things stand.
+
+```json
+"handoff": {
+  "summary": "Parser done; export fails on files over 2 GB",
+  "decisions": [{ "text": "Stream rows instead of buffering", "why": "Memory limit" }],
+  "tried": [{ "text": "xlsx library", "result": "Too slow on large files" }],
+  "open_questions": ["Quote style for commas?"],
+  "next_step": "Add tests for null cells"
+}
+```
+
+| Field            | Type                          | Meaning |
+|------------------|-------------------------------|---------|
+| `summary`        | string                        | Where the work stands. |
+| `decisions`      | array of `{text, why?}`       | Choices already made, and why. The next worker SHOULD keep them unless it has a reason not to. |
+| `tried`          | array of `{text, result?}`    | Approaches already attempted and what happened, so they are not repeated. |
+| `open_questions` | array of string               | Questions still unanswered. |
+| `next_step`      | string                        | The most useful thing to do next. |
+
+Every field is optional, but a handoff MUST NOT be empty. A Work Report MAY carry a handoff (§5); a worker SHOULD include one when it reports `failed` or `blocked`. A manager reissuing the job MAY copy it, edited or not, into the new order. Handoff content is the previous worker's account, not verified fact; it is not checked against evidence.
+
 ## 5. Work Report
 
 | Field         | Req | Type                    | Meaning |
 |---------------|-----|-------------------------|---------|
-| `spec`        | yes | `"awl/work-report@0.1"` | Format and version. |
+| `spec`        | yes | `"awl/work-report@0.2"` | Format and version. Readers also accept `@0.1` (§11). |
 | `order_id`    | yes | string                  | The order this answers. |
 | `from`        | yes | agent ref               | The worker. |
 | `status`      | yes | `done` \| `blocked` \| `failed` | Outcome of this attempt. |
@@ -94,6 +119,7 @@ Patterns: `server/tool` (exactly one tool), `server/*` (every tool on that serve
 | `attempt`     | no  | integer ≥ 1             | 1 for the first report, +1 after each rework. |
 | `questions`   | no  | array of string         | Open questions. Required when `blocked`. |
 | `error`       | no  | string                  | What went wrong. Required when `failed`. |
+| `handoff`     | no  | Handoff (§4.4)          | What whoever continues this job should know. |
 | `metadata`    | no  | object                  | Free-form. |
 
 ### 5.1 Evidence
@@ -184,7 +210,7 @@ A desk MUST reject a child order that breaks C1–C3. The parent's reported cost
 How AWL documents travel. A desk MAY support several.
 
 - **Files**: `<id>.order.json` and `<id>.report.json` side by side. Good for tests and audit archives.
-- **MCP**: a desk exposed as an MCP server with tools such as `create_work_order`, `submit_work_report` and `review_work_report`. The reference implementation in this repo works this way.
+- **MCP**: a desk exposed as an MCP server with tools such as `create_work_order`, `submit_work_report` and `review_work_report`. The reference implementation is the `agent-work-layer-mcp` package in this repo.
 - **A2A**: the document travels as a data part of an A2A message with the AWL media type. The A2A task id SHOULD be stored in `metadata.a2a_task_id`.
 
 ## 10. Security
@@ -197,8 +223,21 @@ How AWL documents travel. A desk MAY support several.
 
 `spec` carries the version. Minor versions (0.x) may add optional fields only. Readers MUST reject a major version they do not know.
 
+A v0.2 reader MUST accept documents marked `@0.1` and `@0.2`, and MUST reject any other version. A v0.2 writer marks new documents `@0.2`. Every v0.1 document is a valid v0.2 document once its version is accepted.
+
 ## 12. Planned for later versions
 
 - Delegation Pass: a signed, standalone grant of budget, tools and time.
 - Track record: an aggregate of approved reports per worker.
 - Streaming progress events while `working`.
+
+## 13. Related work
+
+AWL overlaps with these efforts and is meant to work alongside them.
+
+| Work | What it covers | How AWL relates |
+|------|----------------|-----------------|
+| Agent Contracts (Ye and Tan, 2026, [arXiv:2601.08815](https://arxiv.org/abs/2601.08815)) | A formal model of resource-bounded agents: budgets, deadlines, weighted success criteria, and sub-contracts whose budgets may not exceed the parent's. | Close in intent. AWL is a wire format (JSON documents, JSON Schemas, numbered checks) with evidence per criterion, separate manager and worker roles, and review. Its sub-order rules (§8) are the same conservation idea. |
+| A2A tasks ([a2a-protocol.org](https://a2a-protocol.org)) | Task lifecycle and message transport between agents. | AWL describes the job and its proof; the A2A binding (§9) carries AWL documents inside A2A messages. |
+| IETF [draft-reece-wimse-cross-org-delegation](https://datatracker.ietf.org/doc/draft-reece-wimse-cross-org-delegation/) | Requirements for authority that can only narrow at each delegation hop, verifiable across organizations. | Same principle as §8. Input for the planned Delegation Pass (§12). |
+| KYA-OS / MCP-I ([@kya-os/mcp](https://www.npmjs.com/package/@kya-os/mcp)) | Agent identity, delegation credentials and verifiable audit for MCP servers. | Identifies the actor, not the job. A desk can use such credentials to meet §10's requirement to authenticate `actor`. |

package/dist/cli.js

@@ -1,21 +1,18 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { WorkDesk } from "./desk.js";
-import { createDeskServer } from "./mcp.js";
-import { FileStore } from "./store.js";
 import { hasInvalid, validateChildOrder, validateOrder, validateReport, workOrderSchema, workReportSchema } from "./validate.js";
+import { ORDER_SPEC, REPORT_SPEC } from "./types.js";
 import { VERSION } from "./version.js";
 const HELP = `awl ${VERSION} — Agent Work Layer
 
 Usage:
   awl validate <order.json> [report.json] [--parent <parent-order.json>] [--json]
-  awl desk [--store <dir>] [--actor <agent-ref>]     Run the desk as an MCP server on stdio
   awl schema <order|report>                          Print a JSON Schema
+  awl new <order|report>                             Print a starter document
   awl --version | --help
 
-Environment for "awl desk": AWL_STORE (default ./.awl), AWL_ACTOR.
+The MCP desk server is a separate package: npx -y agent-work-layer-mcp
 Exit codes: 0 ok, 1 invalid document, 2 usage or file error.`;
 function readJson(path) {
     try {
@@ -27,6 +24,38 @@ function readJson(path) {
 }
 class UsageError extends Error {
 }
+function newDocument(args) {
+    const [which] = args;
+    if (args.length !== 1 || (which !== "order" && which !== "report")) {
+        throw new UsageError('new needs "order" or "report"');
+    }
+    const now = new Date();
+    const document = which === "order" ? {
+        spec: ORDER_SPEC,
+        id: "wo_example",
+        created_at: now.toISOString(),
+        from: "agent:manager",
+        to: "agent:worker",
+        goal: "Replace with the work to be done",
+        criteria: [{ id: "c1", text: "Replace with a checkable acceptance criterion" }],
+        budget: { usd: 1 },
+        deadline: new Date(now.getTime() + 3_600_000).toISOString(),
+        tools: [],
+    } : {
+        spec: REPORT_SPEC,
+        order_id: "wo_example",
+        from: "agent:worker",
+        status: "blocked",
+        result: { summary: "Replace with the work performed so far" },
+        evidence: [],
+        cost: { usd: 0 },
+        finished_at: now.toISOString(),
+        tools_used: [],
+        questions: ["What work should be completed for criterion c1?"],
+    };
+    console.log(JSON.stringify(document, null, 2));
+    return 0;
+}
 function validate(args) {
     const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { parent: { type: "string" }, json: { type: "boolean" } } });
     const [orderPath, reportPath] = positionals;
@@ -58,20 +87,15 @@ function validate(args) {
     }
     return failed ? 1 : 0;
 }
-async function desk(args) {
-    const { values } = parseArgs({ args, options: { store: { type: "string" }, actor: { type: "string" } } });
-    const store = new FileStore(values.store ?? process.env.AWL_STORE ?? ".awl");
-    const server = createDeskServer({ desk: new WorkDesk({ store }), actor: values.actor ?? process.env.AWL_ACTOR });
-    await server.connect(new StdioServerTransport());
-}
-async function main(argv) {
+function main(argv) {
     const [command, ...rest] = argv;
     switch (command) {
+        case "new":
+            return newDocument(rest);
         case "validate":
             return validate(rest);
         case "desk":
-            await desk(rest);
-            return undefined; // keep running
+            throw new UsageError('"awl desk" moved to its own package in 0.2.0. Run: npx -y agent-work-layer-mcp --store <dir> --actor <agent-ref>');
         case "schema": {
             const which = rest[0];
             if (which !== "order" && which !== "report")
@@ -92,10 +116,10 @@ async function main(argv) {
             throw new UsageError(`unknown command "${command}"`);
     }
 }
-main(process.argv.slice(2)).then((code) => {
-    if (code !== undefined)
-        process.exitCode = code;
-}, (e) => {
+try {
+    process.exitCode = main(process.argv.slice(2));
+}
+catch (e) {
     console.error(e instanceof UsageError ? `awl: ${e.message}\n\n${HELP}` : e);
     process.exitCode = 2;
-});
+}

package/dist/generated.d.ts

@@ -0,0 +1,6 @@
+/** This package's version. */
+export declare const VERSION: string;
+/** The Work Order JSON Schema (schemas/work-order.schema.json). */
+export declare const workOrderSchema: Record<string, unknown>;
+/** The Work Report JSON Schema (schemas/work-report.schema.json). */
+export declare const workReportSchema: Record<string, unknown>;

package/dist/generated.js

@@ -0,0 +1,453 @@
+// Generated by scripts/generate.ts from package.json and schemas/*.json. Do not edit.
+/** This package's version. */
+export const VERSION = "0.2.0";
+/** The Work Order JSON Schema (schemas/work-order.schema.json). */
+export const workOrderSchema = {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://awl.dev/schemas/work-order-0.2.json",
+    "title": "AWL Work Order v0.2",
+    "type": "object",
+    "required": [
+        "spec",
+        "id",
+        "created_at",
+        "from",
+        "to",
+        "goal",
+        "criteria",
+        "budget",
+        "deadline",
+        "tools"
+    ],
+    "properties": {
+        "spec": {
+            "enum": [
+                "awl/work-order@0.1",
+                "awl/work-order@0.2"
+            ]
+        },
+        "id": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 128
+        },
+        "created_at": {
+            "type": "string",
+            "format": "date-time"
+        },
+        "from": {
+            "$ref": "#/$defs/agentRef"
+        },
+        "to": {
+            "$ref": "#/$defs/agentRef"
+        },
+        "goal": {
+            "type": "string",
+            "minLength": 1
+        },
+        "criteria": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": [
+                    "id",
+                    "text"
+                ],
+                "properties": {
+                    "id": {
+                        "type": "string",
+                        "minLength": 1,
+                        "maxLength": 64
+                    },
+                    "text": {
+                        "type": "string",
+                        "minLength": 1
+                    }
+                },
+                "additionalProperties": false
+            }
+        },
+        "budget": {
+            "$ref": "#/$defs/amounts",
+            "minProperties": 1
+        },
+        "deadline": {
+            "type": "string",
+            "format": "date-time"
+        },
+        "tools": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/toolPattern"
+            }
+        },
+        "escalate_to": {
+            "$ref": "#/$defs/agentRef"
+        },
+        "inputs": {
+            "type": "object"
+        },
+        "context": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": [
+                    "uri"
+                ],
+                "properties": {
+                    "uri": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "note": {
+                        "type": "string"
+                    }
+                },
+                "additionalProperties": false
+            }
+        },
+        "handoff": {
+            "$ref": "#/$defs/handoff"
+        },
+        "output_schema": {
+            "type": "object"
+        },
+        "parent_id": {
+            "type": "string",
+            "minLength": 1
+        },
+        "metadata": {
+            "type": "object"
+        }
+    },
+    "patternProperties": {
+        "^x-": {}
+    },
+    "additionalProperties": false,
+    "$defs": {
+        "agentRef": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 512
+        },
+        "toolPattern": {
+            "type": "string",
+            "pattern": "^(\\*|[A-Za-z0-9_.-]+/(\\*|[A-Za-z0-9_.-]+))$"
+        },
+        "amounts": {
+            "type": "object",
+            "properties": {
+                "usd": {
+                    "type": "number",
+                    "minimum": 0
+                },
+                "tokens": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "tool_calls": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "seconds": {
+                    "type": "number",
+                    "minimum": 0
+                }
+            },
+            "additionalProperties": false
+        },
+        "handoff": {
+            "type": "object",
+            "minProperties": 1,
+            "properties": {
+                "summary": {
+                    "type": "string",
+                    "minLength": 1
+                },
+                "decisions": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "text"
+                        ],
+                        "properties": {
+                            "text": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "why": {
+                                "type": "string"
+                            }
+                        },
+                        "additionalProperties": false
+                    }
+                },
+                "tried": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "text"
+                        ],
+                        "properties": {
+                            "text": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "result": {
+                                "type": "string"
+                            }
+                        },
+                        "additionalProperties": false
+                    }
+                },
+                "open_questions": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "minLength": 1
+                    }
+                },
+                "next_step": {
+                    "type": "string",
+                    "minLength": 1
+                }
+            },
+            "additionalProperties": false
+        }
+    }
+};
+/** The Work Report JSON Schema (schemas/work-report.schema.json). */
+export const workReportSchema = {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://awl.dev/schemas/work-report-0.2.json",
+    "title": "AWL Work Report v0.2",
+    "type": "object",
+    "required": [
+        "spec",
+        "order_id",
+        "from",
+        "status",
+        "result",
+        "evidence",
+        "cost",
+        "finished_at",
+        "tools_used"
+    ],
+    "properties": {
+        "spec": {
+            "enum": [
+                "awl/work-report@0.1",
+                "awl/work-report@0.2"
+            ]
+        },
+        "order_id": {
+            "type": "string",
+            "minLength": 1
+        },
+        "from": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 512
+        },
+        "status": {
+            "enum": [
+                "done",
+                "blocked",
+                "failed"
+            ]
+        },
+        "result": {
+            "type": "object",
+            "required": [
+                "summary"
+            ],
+            "properties": {
+                "summary": {
+                    "type": "string"
+                },
+                "output": {},
+                "artifacts": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "uri"
+                        ],
+                        "properties": {
+                            "uri": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "media_type": {
+                                "type": "string"
+                            },
+                            "note": {
+                                "type": "string"
+                            }
+                        },
+                        "additionalProperties": false
+                    }
+                }
+            },
+            "additionalProperties": false
+        },
+        "evidence": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": [
+                    "criterion",
+                    "type"
+                ],
+                "properties": {
+                    "criterion": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "type": {
+                        "enum": [
+                            "tool_call",
+                            "artifact",
+                            "citation",
+                            "note"
+                        ]
+                    },
+                    "ref": {
+                        "type": "string"
+                    },
+                    "note": {
+                        "type": "string"
+                    }
+                },
+                "additionalProperties": false
+            }
+        },
+        "cost": {
+            "type": "object",
+            "properties": {
+                "usd": {
+                    "type": "number",
+                    "minimum": 0
+                },
+                "tokens": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "tool_calls": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "seconds": {
+                    "type": "number",
+                    "minimum": 0
+                }
+            },
+            "additionalProperties": false
+        },
+        "started_at": {
+            "type": "string",
+            "format": "date-time"
+        },
+        "finished_at": {
+            "type": "string",
+            "format": "date-time"
+        },
+        "tools_used": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "pattern": "^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$"
+            }
+        },
+        "attempt": {
+            "type": "integer",
+            "minimum": 1
+        },
+        "questions": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "minLength": 1
+            }
+        },
+        "error": {
+            "type": "string",
+            "minLength": 1
+        },
+        "handoff": {
+            "$ref": "#/$defs/handoff"
+        },
+        "metadata": {
+            "type": "object"
+        }
+    },
+    "patternProperties": {
+        "^x-": {}
+    },
+    "additionalProperties": false,
+    "$defs": {
+        "handoff": {
+            "type": "object",
+            "minProperties": 1,
+            "properties": {
+                "summary": {
+                    "type": "string",
+                    "minLength": 1
+                },
+                "decisions": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "text"
+                        ],
+                        "properties": {
+                            "text": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "why": {
+                                "type": "string"
+                            }
+                        },
+                        "additionalProperties": false
+                    }
+                },
+                "tried": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "text"
+                        ],
+                        "properties": {
+                            "text": {
+                                "type": "string",
+                                "minLength": 1
+                            },
+                            "result": {
+                                "type": "string"
+                            }
+                        },
+                        "additionalProperties": false
+                    }
+                },
+                "open_questions": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "minLength": 1
+                    }
+                },
+                "next_step": {
+                    "type": "string",
+                    "minLength": 1
+                }
+            },
+            "additionalProperties": false
+        }
+    }
+};

package/dist/types.d.ts

@@ -1,6 +1,10 @@
-/** Document types for AWL v0.1. Field meanings are defined in SPEC.md §4 and §5. */
-export declare const ORDER_SPEC = "awl/work-order@0.1";
-export declare const REPORT_SPEC = "awl/work-report@0.1";
+/** Document types for AWL v0.2. Field meanings are defined in SPEC.md §4 and §5. */
+/** The spec version this package writes. */
+export declare const ORDER_SPEC = "awl/work-order@0.2";
+export declare const REPORT_SPEC = "awl/work-report@0.2";
+/** Every spec version this package reads (SPEC.md §11). */
+export declare const ORDER_SPECS: readonly ["awl/work-order@0.1", "awl/work-order@0.2"];
+export declare const REPORT_SPECS: readonly ["awl/work-report@0.1", "awl/work-report@0.2"];
 /** An Agent Card URL, an agent name, or `human:<id>`. */
 export type AgentRef = string;
 /** Budget and cost units (SPEC.md §4.2). */
@@ -15,8 +19,22 @@ export interface ContextRef {
     uri: string;
     note?: string;
 }
+/** What the next worker should know: decisions, dead ends and where work stands (SPEC.md §4.4). */
+export interface Handoff {
+    summary?: string;
+    decisions?: {
+        text: string;
+        why?: string;
+    }[];
+    tried?: {
+        text: string;
+        result?: string;
+    }[];
+    open_questions?: string[];
+    next_step?: string;
+}
 export interface WorkOrder {
-    spec: typeof ORDER_SPEC;
+    spec: (typeof ORDER_SPECS)[number];
     id: string;
     created_at: string;
     from: AgentRef;
@@ -30,6 +48,7 @@ export interface WorkOrder {
     escalate_to?: AgentRef;
     inputs?: Record<string, unknown>;
     context?: ContextRef[];
+    handoff?: Handoff;
     output_schema?: Record<string, unknown>;
     parent_id?: string;
     metadata?: Record<string, unknown>;
@@ -54,7 +73,7 @@ export interface WorkResult {
     artifacts?: Artifact[];
 }
 export interface WorkReport {
-    spec: typeof REPORT_SPEC;
+    spec: (typeof REPORT_SPECS)[number];
     order_id: string;
     from: AgentRef;
     status: ReportStatus;
@@ -68,6 +87,7 @@ export interface WorkReport {
     attempt?: number;
     questions?: string[];
     error?: string;
+    handoff?: Handoff;
     metadata?: Record<string, unknown>;
     [extension: `x-${string}`]: unknown;
 }

package/dist/types.js

@@ -1,5 +1,9 @@
-/** Document types for AWL v0.1. Field meanings are defined in SPEC.md §4 and §5. */
-export const ORDER_SPEC = "awl/work-order@0.1";
-export const REPORT_SPEC = "awl/work-report@0.1";
+/** Document types for AWL v0.2. Field meanings are defined in SPEC.md §4 and §5. */
+/** The spec version this package writes. */
+export const ORDER_SPEC = "awl/work-order@0.2";
+export const REPORT_SPEC = "awl/work-report@0.2";
+/** Every spec version this package reads (SPEC.md §11). */
+export const ORDER_SPECS = ["awl/work-order@0.1", ORDER_SPEC];
+export const REPORT_SPECS = ["awl/work-report@0.1", REPORT_SPEC];
 /** Budget and cost units (SPEC.md §4.2). */
 export const UNITS = ["usd", "tokens", "tool_calls", "seconds"];

package/dist/validate.d.ts

@@ -1,7 +1,7 @@
+import { workOrderSchema, workReportSchema } from "./generated.ts";
 import type { Finding, WorkOrder, WorkReport } from "./types.ts";
 /** The JSON Schemas shipped with this package. */
-export declare const workOrderSchema: Record<string, unknown>;
-export declare const workReportSchema: Record<string, unknown>;
+export { workOrderSchema, workReportSchema };
 /** Does a concrete tool name (`server/tool`) match one of the allowed patterns? */
 export declare function toolAllowed(tool: string, patterns: readonly string[]): boolean;
 /** Is everything a child pattern allows also allowed by the parent's patterns? */

package/dist/validate.js

@@ -1,7 +1,8 @@
-// Checks from SPEC.md §7 (orders and reports) and §8 (sub-orders).
-import { readFileSync } from "node:fs";
+// Checks from SPEC.md §7 (orders and reports) and §8 (sub-orders). No Node built-ins here:
+// the validator also runs in browsers, Deno and Bun (see src/validator.ts).
 import Ajv2020Module from "ajv/dist/2020.js";
 import addFormatsModule from "ajv-formats";
+import { workOrderSchema, workReportSchema } from "./generated.js";
 import { UNITS } from "./types.js";
 // ajv and ajv-formats are CommonJS; their classes live on `.default` under NodeNext.
 const Ajv2020 = Ajv2020Module.default;
@@ -11,10 +12,8 @@ function newAjv() {
     addFormats(ajv);
     return ajv;
 }
-const loadSchema = (file) => JSON.parse(readFileSync(new URL(`../schemas/${file}`, import.meta.url), "utf8"));
 /** The JSON Schemas shipped with this package. */
-export const workOrderSchema = loadSchema("work-order.schema.json");
-export const workReportSchema = loadSchema("work-report.schema.json");
+export { workOrderSchema, workReportSchema };
 const ajv = newAjv();
 const orderShape = ajv.compile(workOrderSchema);
 const reportShape = ajv.compile(workReportSchema);

package/dist/validator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validation only: document types, JSON Schemas and every check in SPEC.md §7–§8.
+ * Imports no Node built-ins, so it runs in browsers, Deno and Bun.
+ * @packageDocumentation
+ */
+export * from "./types.ts";
+export { validateOrder, validateReport, validateChildOrder, hasInvalid, isWorkOrder, isWorkReport, toolAllowed, patternCovered, workOrderSchema, workReportSchema, } from "./validate.ts";

package/dist/validator.js

@@ -0,0 +1,7 @@
+/**
+ * Validation only: document types, JSON Schemas and every check in SPEC.md §7–§8.
+ * Imports no Node built-ins, so it runs in browsers, Deno and Bun.
+ * @packageDocumentation
+ */
+export * from "./types.js";
+export { validateOrder, validateReport, validateChildOrder, hasInvalid, isWorkOrder, isWorkReport, toolAllowed, patternCovered, workOrderSchema, workReportSchema, } from "./validate.js";

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-/** This package's version, read from package.json. */
-export declare const VERSION: string;
+/** This package's version, from package.json (written into src/generated.ts at build time). */
+export { VERSION } from "./generated.ts";

package/dist/version.js

@@ -1,3 +1,2 @@
-import { readFileSync } from "node:fs";
-/** This package's version, read from package.json. */
-export const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+/** This package's version, from package.json (written into src/generated.ts at build time). */
+export { VERSION } from "./generated.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-work-layer",
-  "version": "0.1.1",
-  "description": "Work Orders and Work Reports for AI agents: a typed SDK, validator, lifecycle desk and MCP server.",
+  "version": "0.2.0",
+  "description": "Work Orders and Work Reports for AI agents: a typed SDK, validator and lifecycle desk. The MCP server is in agent-work-layer-mcp.",
   "keywords": [
     "ai",
     "agents",
@@ -26,9 +26,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./mcp": {
-      "types": "./dist/mcp.d.ts",
-      "import": "./dist/mcp.js"
+    "./validate": {
+      "types": "./dist/validator.d.ts",
+      "import": "./dist/validator.js"
     },
     "./schemas/work-order.schema.json": "./schemas/work-order.schema.json",
     "./schemas/work-report.schema.json": "./schemas/work-report.schema.json",
@@ -40,28 +40,25 @@
   "files": [
     "dist",
     "schemas",
+    "README.md",
+    "LICENSE",
     "SPEC.md",
     "CHANGELOG.md"
   ],
   "sideEffects": false,
   "scripts": {
+    "generate": "node scripts/generate.ts",
     "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "node --test \"test/**/*.test.ts\"",
     "test:coverage": "node --test --experimental-test-coverage --test-coverage-include=\"src/**\" \"test/**/*.test.ts\"",
-    "test:package": "npm run build && node scripts/package-smoke.ts",
-    "check": "npm run typecheck && npm test && npm run test:package",
-    "prepublishOnly": "npm run check"
+    "version": "node scripts/generate.ts",
+    "prepack": "cp ../../README.md ../../LICENSE ../../SPEC.md ../../CHANGELOG.md . && rm -rf schemas && cp -R ../../schemas schemas",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.32.1",
     "ajv": "^8.20.0",
-    "ajv-formats": "^3.0.1",
-    "zod": "^3.25.76"
-  },
-  "devDependencies": {
-    "@types/node": "^22.20.5",
-    "typescript": "^7.0.2"
+    "ajv-formats": "^3.0.1"
   },
   "publishConfig": {
     "access": "public"

package/schemas/work-order.schema.json

@@ -1,11 +1,11 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://awl.dev/schemas/work-order-0.1.json",
-  "title": "AWL Work Order v0.1",
+  "$id": "https://awl.dev/schemas/work-order-0.2.json",
+  "title": "AWL Work Order v0.2",
   "type": "object",
   "required": ["spec", "id", "created_at", "from", "to", "goal", "criteria", "budget", "deadline", "tools"],
   "properties": {
-    "spec": { "const": "awl/work-order@0.1" },
+    "spec": { "enum": ["awl/work-order@0.1", "awl/work-order@0.2"] },
     "id": { "type": "string", "minLength": 1, "maxLength": 128 },
     "created_at": { "type": "string", "format": "date-time" },
     "from": { "$ref": "#/$defs/agentRef" },
@@ -38,6 +38,7 @@
         "additionalProperties": false
       }
     },
+    "handoff": { "$ref": "#/$defs/handoff" },
     "output_schema": { "type": "object" },
     "parent_id": { "type": "string", "minLength": 1 },
     "metadata": { "type": "object" }
@@ -56,6 +57,34 @@
         "seconds": { "type": "number", "minimum": 0 }
       },
       "additionalProperties": false
+    },
+    "handoff": {
+      "type": "object",
+      "minProperties": 1,
+      "properties": {
+        "summary": { "type": "string", "minLength": 1 },
+        "decisions": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["text"],
+            "properties": { "text": { "type": "string", "minLength": 1 }, "why": { "type": "string" } },
+            "additionalProperties": false
+          }
+        },
+        "tried": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["text"],
+            "properties": { "text": { "type": "string", "minLength": 1 }, "result": { "type": "string" } },
+            "additionalProperties": false
+          }
+        },
+        "open_questions": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+        "next_step": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
     }
   }
 }

package/schemas/work-report.schema.json

@@ -1,11 +1,11 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://awl.dev/schemas/work-report-0.1.json",
-  "title": "AWL Work Report v0.1",
+  "$id": "https://awl.dev/schemas/work-report-0.2.json",
+  "title": "AWL Work Report v0.2",
   "type": "object",
   "required": ["spec", "order_id", "from", "status", "result", "evidence", "cost", "finished_at", "tools_used"],
   "properties": {
-    "spec": { "const": "awl/work-report@0.1" },
+    "spec": { "enum": ["awl/work-report@0.1", "awl/work-report@0.2"] },
     "order_id": { "type": "string", "minLength": 1 },
     "from": { "type": "string", "minLength": 1, "maxLength": 512 },
     "status": { "enum": ["done", "blocked", "failed"] },
@@ -61,8 +61,39 @@
     "attempt": { "type": "integer", "minimum": 1 },
     "questions": { "type": "array", "items": { "type": "string", "minLength": 1 } },
     "error": { "type": "string", "minLength": 1 },
+    "handoff": { "$ref": "#/$defs/handoff" },
     "metadata": { "type": "object" }
   },
   "patternProperties": { "^x-": {} },
-  "additionalProperties": false
+  "additionalProperties": false,
+  "$defs": {
+    "handoff": {
+      "type": "object",
+      "minProperties": 1,
+      "properties": {
+        "summary": { "type": "string", "minLength": 1 },
+        "decisions": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["text"],
+            "properties": { "text": { "type": "string", "minLength": 1 }, "why": { "type": "string" } },
+            "additionalProperties": false
+          }
+        },
+        "tried": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["text"],
+            "properties": { "text": { "type": "string", "minLength": 1 }, "result": { "type": "string" } },
+            "additionalProperties": false
+          }
+        },
+        "open_questions": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+        "next_step": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    }
+  }
 }

package/dist/mcp.d.ts

@@ -1,13 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { WorkDesk } from "./desk.ts";
-export interface DeskServerOptions {
-    desk: WorkDesk;
-    /**
-     * Fixes who this server acts as. When set, tools act as this identity and refuse any
-     * other `actor` argument, so a worker session cannot approve its own work.
-     */
-    actor?: string;
-    name?: string;
-}
-/** Builds an MCP server exposing the desk's operations as tools. Connect it to any transport. */
-export declare function createDeskServer({ desk, actor: sessionActor, name }: DeskServerOptions): McpServer;

package/dist/mcp.js

@@ -1,116 +0,0 @@
-// The desk as an MCP server (SPEC.md §9, MCP binding).
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { AwlError } from "./errors.js";
-import { STATES } from "./lifecycle.js";
-import { summarize } from "./desk.js";
-import { VERSION } from "./version.js";
-const amounts = z
-    .object({
-    usd: z.number().min(0).optional(),
-    tokens: z.number().int().min(0).optional(),
-    tool_calls: z.number().int().min(0).optional(),
-    seconds: z.number().min(0).optional(),
-})
-    .strict();
-const actorArg = z.string().optional().describe("Who is acting. Omit to use this session's identity.");
-const idArg = z.string().describe("Work order id");
-const view = (r) => ({ ...summarize(r), order: r.order, latest_report: r.reports.at(-1) ?? null, findings: r.findings, events: r.events });
-/** Drops keys whose value is undefined so they don't reach JSON Schema validation. */
-const defined = (o) => JSON.parse(JSON.stringify(o));
-async function respond(fn) {
-    try {
-        const value = await fn();
-        return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
-    }
-    catch (e) {
-        const body = e instanceof AwlError ? e.toJSON() : { code: "INTERNAL", message: String(e) };
-        return { isError: true, content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
-    }
-}
-/** Builds an MCP server exposing the desk's operations as tools. Connect it to any transport. */
-export function createDeskServer({ desk, actor: sessionActor, name = "awl-work-desk" }) {
-    const server = new McpServer({ name, version: VERSION });
-    const who = (arg) => {
-        if (sessionActor && arg && arg !== sessionActor)
-            throw new AwlError("FORBIDDEN", `this session acts as "${sessionActor}", not "${arg}"`);
-        const actor = arg ?? sessionActor;
-        if (!actor)
-            throw new AwlError("BAD_REQUEST", 'no actor: pass "actor" or start the desk with an identity');
-        return actor;
-    };
-    server.registerTool("create_work_order", {
-        description: "Issue a Work Order to a worker agent. Every criterion must be provable with evidence. " +
-            "Set parent_id to split your own order into a sub-order; it may only narrow budget, tools and deadline.",
-        inputSchema: {
-            actor: actorArg,
-            to: z.string().describe("Worker agent reference (Agent Card URL or name)"),
-            goal: z.string().describe("What to achieve, in plain language"),
-            criteria: z.array(z.object({ id: z.string(), text: z.string() })).min(1).describe("How done will be judged"),
-            budget: amounts.describe("Upper limits; set at least one unit"),
-            deadline: z.string().describe("RFC 3339 timestamp"),
-            tools: z.array(z.string()).describe('Allowed tools: "server/tool", "server/*" or "*"'),
-            escalate_to: z.string().optional(),
-            inputs: z.record(z.any()).optional(),
-            context: z.array(z.object({ uri: z.string(), note: z.string().optional() })).optional(),
-            output_schema: z.record(z.any()).optional().describe("JSON Schema that result.output must match"),
-            parent_id: z.string().optional(),
-            id: z.string().optional().describe("Optional explicit id"),
-            metadata: z.record(z.any()).optional(),
-        },
-    }, async ({ actor, ...input }) => respond(async () => view(await desk.create(defined(input), who(actor)))));
-    server.registerTool("list_work_orders", {
-        description: "List work orders. Workers: filter by to=<yourself> and state=offered to find new jobs.",
-        inputSchema: {
-            to: z.string().optional(),
-            from: z.string().optional(),
-            state: z.enum(STATES).optional(),
-            parent_id: z.string().optional(),
-        },
-    }, async (filter) => respond(() => desk.list(defined(filter))));
-    server.registerTool("get_work_order", { description: "Full order, current state, latest report, check findings and event log.", inputSchema: { id: idArg } }, async ({ id }) => respond(async () => view(await desk.get(id))));
-    server.registerTool("accept_work_order", { description: "Worker accepts an offered order.", inputSchema: { id: idArg, actor: actorArg } }, async ({ id, actor }) => respond(async () => view(await desk.accept(id, who(actor)))));
-    server.registerTool("decline_work_order", { description: "Worker declines an offered order.", inputSchema: { id: idArg, actor: actorArg, reason: z.string().optional() } }, async ({ id, actor, reason }) => respond(async () => view(await desk.decline(id, who(actor), reason))));
-    server.registerTool("start_work_order", { description: "Worker starts an accepted order.", inputSchema: { id: idArg, actor: actorArg } }, async ({ id, actor }) => respond(async () => view(await desk.start(id, who(actor)))));
-    server.registerTool("submit_work_report", {
-        description: "Worker reports on an order. done needs evidence for every criterion; blocked needs questions; failed needs error. " +
-            "A rejected report returns the failed checks so you can fix it and resubmit.",
-        inputSchema: {
-            id: idArg,
-            actor: actorArg,
-            status: z.enum(["done", "blocked", "failed"]),
-            result: z.object({
-                summary: z.string(),
-                output: z.any().optional(),
-                artifacts: z.array(z.object({ uri: z.string(), media_type: z.string().optional(), note: z.string().optional() })).optional(),
-            }),
-            evidence: z.array(z.object({
-                criterion: z.string(),
-                type: z.enum(["tool_call", "artifact", "citation", "note"]),
-                ref: z.string().optional(),
-                note: z.string().optional(),
-            })),
-            cost: amounts,
-            tools_used: z.array(z.string()).describe('Exact tool names called, as "server/tool"'),
-            started_at: z.string().optional(),
-            finished_at: z.string().optional(),
-            questions: z.array(z.string()).optional(),
-            error: z.string().optional(),
-            metadata: z.record(z.any()).optional(),
-        },
-    }, async ({ id, actor, ...input }) => respond(async () => {
-        const { record, findings } = await desk.submitReport(id, defined(input), who(actor));
-        return { ...summarize(record), findings };
-    }));
-    server.registerTool("answer_question", { description: "Manager or escalation contact answers a blocked worker; the order returns to working.", inputSchema: { id: idArg, actor: actorArg, answer: z.string() } }, async ({ id, actor, answer }) => respond(async () => view(await desk.answer(id, who(actor), answer))));
-    server.registerTool("review_work_report", {
-        description: "Manager approves a submitted report, or sends it back for rework with a reason.",
-        inputSchema: { id: idArg, actor: actorArg, decision: z.enum(["approve", "rework"]), reason: z.string().optional() },
-    }, async ({ id, actor, decision, reason }) => respond(async () => view(await desk.review(id, who(actor), decision, reason))));
-    server.registerTool("cancel_work_order", { description: "Manager cancels an order that is not finished.", inputSchema: { id: idArg, actor: actorArg, reason: z.string().optional() } }, async ({ id, actor, reason }) => respond(async () => view(await desk.cancel(id, who(actor), reason))));
-    server.registerTool("wait_for_update", {
-        description: "Wait until the order changes after since_seq (up to timeout_s seconds). Use it to follow a job live.",
-        inputSchema: { id: idArg, since_seq: z.number().int().min(0), timeout_s: z.number().min(1).max(55).optional() },
-    }, async ({ id, since_seq, timeout_s }, extra) => respond(async () => view(await desk.waitForChange(id, since_seq, { timeoutMs: (timeout_s ?? 25) * 1000, signal: extra.signal }))));
-    return server;
-}