wicked-crew 0.7.0 → 0.7.2

package/README.md

@@ -0,0 +1,103 @@
+# wicked-crew
+
+**The harness for your agent harnesses** — run the coding-agent CLIs you already use as governed
+workers through durable, multi-agent workflows. Intent in, verified work out: the evaluator is
+structurally not the creator, gates are deny-dominates, and "done" is re-derived from evidence
+instead of asserted.
+
+Local-first: loopback only, no accounts, no billing, no model reselling. Crew drives the agents
+*you* already pay for, on *your* auth and *your* plan.
+
+## Install
+
+Requires Node.js ≥ 22 and at least one coding-agent CLI on your machine (e.g. Claude Code, Codex).
+
+```bash
+npm install -g wicked-crew
+wicked-crew serve
+```
+
+Or without installing:
+
+```bash
+npx wicked-crew serve
+```
+
+Or use the family installer — [`npx wicked-installer`](https://www.npmjs.com/package/wicked-installer)
+installs/updates the whole wicked-\* family, crew included.
+
+`serve` starts the daemon on `http://127.0.0.1:7701` (override with `--port` or `CREW_PORT`) and
+serves the bundled **wicked-studio** browser console same-origin — open the URL and you have the
+control room: launch and steer runs, answer human gates, browse projects and evidence, watch live
+engine events. Durable state (runs, evidence, event log) lives in `~/.wicked-crew/` (`--db`
+overrides).
+
+## Quickstart
+
+```bash
+# 1. Start the daemon (leave it running)
+wicked-crew serve
+
+# 2. Launch a governed run — from the console at http://127.0.0.1:7701,
+#    or headless over the API:
+curl -X POST http://127.0.0.1:7701/api/v1/runs \
+     -H 'content-type: application/json' \
+     -d '{"problem": "Add input validation to the signup form", "workflow": "feature"}'
+
+# 3. Watch it move through the workflow's phases; approve or reject at the gates.
+```
+
+One run token moves through the workflow's phases with a gate between every one — e.g. for
+`feature`: clarify → design → build → adversarial-review → test → review. Each phase is executed
+by a versioned skill on an assigned CLI worker; the gates decide, and every decision is audited.
+
+## The governed-run model
+
+- **You own the workflow; the agent owns the work.** The orchestrator sequences phases and holds
+  the gates; the agent does the coding inside a phase.
+- **Workflows are data.** `feature` / `bug` / `migration` ship built-in; new ones are drop-in JSON
+  files, not code.
+- **Gates are real, not self-graded.** Phase transitions resolve **deny-dominates** on a
+  deterministic structural floor, with an independent evaluator seat that reads cold evidence
+  only — a model may fail a gate, never solely approve one.
+- **Evidence, not assertion.** "Done" is re-derived from evidence at the gate, never claimed by
+  the agent that did the work.
+
+The engine underneath is [wicked-core](https://github.com/mikeparcewski/wicked-core) (Rust,
+single-writer), embedded via the `wicked-core-ts` napi bridge — the daemon is a thin REST+WS
+layer over it.
+
+## The acceptance gate
+
+`GET /api/v1/runs/:id/acceptance` answers "does the QE evidence ledger accept this run's work?" —
+crew's machine gate, absorbed from the retired wicked-testing product. <!-- historical --> It reads the repo's
+evidence ledger (a wicked-ledger store at `<repo>/.wicked-qe/`, written by wicked-garden's QE
+skills; legacy `.wicked-testing/` ledgers are still read) and resolves the workflow's acceptance
+requirement **deny-dominates**: only a `PASS` verdict satisfies it. `FAIL`, `CONDITIONAL`,
+`PARTIAL`, `INCONCLUSIVE`, a missing ledger, or a missing verdict each deny with their own named
+reason — no evidence is never a pass. The route always returns 200 for a known run ("no verdict"
+is a real answer about the gate, not an error); `?qeRun=<id>` pins the read to one QE run.
+
+## CLI
+
+```
+wicked-crew serve|start|resume|gate|status|mcp
+```
+
+| command | what it does |
+|---|---|
+| `serve` | run the daemon: REST `/api/v1` + WS `/ws` + the bundled studio console |
+| `start` | boot and launch a run headless (`--problem`, `--workflow`, `--repo`) |
+| `resume` | resume a persisted run (`--session <id>`) |
+| `gate` | answer a pending human gate from the terminal |
+| `status` | inspect run state |
+| `mcp` | stdio MCP server — crew-as-a-tool for coding agents |
+
+## Links
+
+- Repo: <https://github.com/mikeparcewski/wicked-crew>
+- Site & docs: <https://wc.wickedagile.com>
+- Wire contract (every `/api/v1` + `/ws` shape, types-only): [`wicked-crew-api-types`](https://www.npmjs.com/package/wicked-crew-api-types)
+- Engine: [wicked-core](https://github.com/mikeparcewski/wicked-core) · Console: [wicked-studio](https://github.com/mikeparcewski/wicked-studio)
+
+MIT

package/dist/api/delivery-index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The run→delivered-PR index (CREW-UX-8, crew#321).
+ *
+ * `LaunchRunBody.deliver?: 'pr'` is input-only; the deliver phase computes the PR URL
+ * (`core/deliver.ts` — re-derived from the remote, refused without one) and prints it as the
+ * unit's last output line, which is console text, not a wire. This index is the read-side
+ * latency layer that lets the run DTOs echo `session.delivery` on BOTH `GET /runs` and
+ * `GET /runs/:id` without a `workOutput` read per request — the persisted field that makes a
+ * list surface's "4 of 5 siblings delivered" rollup affordable without an N-fetch fan-out
+ * (wicked-studio#27).
+ *
+ * Mirrors `RetryIndex`/`GuidanceIndex`'s posture exactly: the DURABLE record is the audit
+ * trail (the engine run record has no such field) — action `run.delivered`, `detail.url` —
+ * hydrated once at server start (best-effort: a missing or unreadable trail leaves deliveries
+ * blank, the pre-#321 behavior, not an error) and updated at the same post-terminal point
+ * that writes the audit entry.
+ *
+ * KNOWN LIMIT (stated in the contract too): runs that delivered before this landed have no
+ * `run.delivered` entry and carry no field. Do NOT backfill by scanning `work_output` at
+ * hydrate — that is an unbounded boot cost. Historical runs still resolve their URL through
+ * the per-run output endpoint.
+ */
+import type { AuditLog } from './audit.js';
+import type { SessionView, WorkUnit } from '../core/types.js';
+/** The wire shape `AgentSession.delivery` carries (api-types 0.11.0). */
+export interface SessionDelivery {
+    kind: 'pull_request';
+    url: string;
+}
+/**
+ * The PR URL in a deliver transcript — crew's own extraction, mirrored
+ * (`core/deliver.ts`: `grep -Eo 'https://[^[:space:]]+/pull/[0-9]+' | tail -1`). Requiring
+ * the digits keeps `…/pull/new/<branch>` — the create-PR form git prints on every push —
+ * from ever matching; the LAST match wins, same as `tail -1`.
+ */
+export declare function prUrlFrom(text: string): string | null;
+/**
+ * This run's deliver unit, or `null`. The composed id suffix (`<base>:deliver`) is the
+ * primary key; the `tool_cmd` probe is the fallback for an operator OVERLAY that carried the
+ * deliver phase under its own name — do NOT key on `workflow_id`, which is plain for
+ * overlay-carried deliver phases (crew#321).
+ */
+export declare function deliverUnitOf(view: SessionView): WorkUnit | null;
+export declare class DeliveryIndex {
+    private readonly runToUrl;
+    /**
+     * Load deliveries from EVERY `run.delivered` entry in the trail — exhaustively, not capped
+     * (BRIEF-UX-002 C5, the same defect class as `RetryIndex.hydrate`: a durable record must
+     * not vanish because 1000+ newer writes landed on top of it). The trail answers newest
+     * first, so the FIRST entry seen per run wins; older entries for the same run are
+     * superseded and skipped. Still best-effort, like its siblings; cost is one full-file scan
+     * at boot. (Third exhaustive trail scan at boot, after RetryIndex and GuidanceIndex — a
+     * FOURTH should trigger consolidating them into one pass, per crew#321.)
+     */
+    hydrate(audit: AuditLog, log?: (msg: string) => void): Promise<void>;
+    /** Record the run's delivered PR URL (idempotent — the newest write wins). */
+    set(runId: string, url: string): void;
+    /** The delivery for this run, or `undefined` (the DTO spells that as an ABSENT field). */
+    deliveryFor(runId: string): SessionDelivery | undefined;
+}
+//# sourceMappingURL=delivery-index.d.ts.map

package/dist/api/delivery-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-index.d.ts","sourceRoot":"","sources":["../../src/api/delivery-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE9D,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGrD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAIhE;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IAEtD;;;;;;;;OAQG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB1E,8EAA8E;IAC9E,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAIrC,0FAA0F;IAC1F,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;CAIxD"}

package/dist/api/delivery-index.js

@@ -0,0 +1,87 @@
+/**
+ * The run→delivered-PR index (CREW-UX-8, crew#321).
+ *
+ * `LaunchRunBody.deliver?: 'pr'` is input-only; the deliver phase computes the PR URL
+ * (`core/deliver.ts` — re-derived from the remote, refused without one) and prints it as the
+ * unit's last output line, which is console text, not a wire. This index is the read-side
+ * latency layer that lets the run DTOs echo `session.delivery` on BOTH `GET /runs` and
+ * `GET /runs/:id` without a `workOutput` read per request — the persisted field that makes a
+ * list surface's "4 of 5 siblings delivered" rollup affordable without an N-fetch fan-out
+ * (wicked-studio#27).
+ *
+ * Mirrors `RetryIndex`/`GuidanceIndex`'s posture exactly: the DURABLE record is the audit
+ * trail (the engine run record has no such field) — action `run.delivered`, `detail.url` —
+ * hydrated once at server start (best-effort: a missing or unreadable trail leaves deliveries
+ * blank, the pre-#321 behavior, not an error) and updated at the same post-terminal point
+ * that writes the audit entry.
+ *
+ * KNOWN LIMIT (stated in the contract too): runs that delivered before this landed have no
+ * `run.delivered` entry and carry no field. Do NOT backfill by scanning `work_output` at
+ * hydrate — that is an unbounded boot cost. Historical runs still resolve their URL through
+ * the per-run output endpoint.
+ */
+/**
+ * The PR URL in a deliver transcript — crew's own extraction, mirrored
+ * (`core/deliver.ts`: `grep -Eo 'https://[^[:space:]]+/pull/[0-9]+' | tail -1`). Requiring
+ * the digits keeps `…/pull/new/<branch>` — the create-PR form git prints on every push —
+ * from ever matching; the LAST match wins, same as `tail -1`.
+ */
+export function prUrlFrom(text) {
+    const matches = text.match(/https:\/\/\S+\/pull\/\d+/g);
+    return matches === null ? null : (matches[matches.length - 1] ?? null);
+}
+/**
+ * This run's deliver unit, or `null`. The composed id suffix (`<base>:deliver`) is the
+ * primary key; the `tool_cmd` probe is the fallback for an operator OVERLAY that carried the
+ * deliver phase under its own name — do NOT key on `workflow_id`, which is plain for
+ * overlay-carried deliver phases (crew#321).
+ */
+export function deliverUnitOf(view) {
+    const byId = view.units.find((u) => u.id.endsWith(':deliver'));
+    if (byId !== undefined)
+        return byId;
+    return view.units.find((u) => (u.tool_cmd ?? []).join(' ').includes('gh pr create')) ?? null;
+}
+export class DeliveryIndex {
+    runToUrl = new Map();
+    /**
+     * Load deliveries from EVERY `run.delivered` entry in the trail — exhaustively, not capped
+     * (BRIEF-UX-002 C5, the same defect class as `RetryIndex.hydrate`: a durable record must
+     * not vanish because 1000+ newer writes landed on top of it). The trail answers newest
+     * first, so the FIRST entry seen per run wins; older entries for the same run are
+     * superseded and skipped. Still best-effort, like its siblings; cost is one full-file scan
+     * at boot. (Third exhaustive trail scan at boot, after RetryIndex and GuidanceIndex — a
+     * FOURTH should trigger consolidating them into one pass, per crew#321.)
+     */
+    async hydrate(audit, log) {
+        try {
+            const seen = new Set();
+            for (const entry of await audit.readAll({ action: 'run.delivered' })) {
+                if (typeof entry.runId !== 'string')
+                    continue;
+                if (seen.has(entry.runId))
+                    continue;
+                // Newest entry decides, even when malformed — marking the run seen BEFORE the url
+                // check keeps a corrupt newest write from resurrecting an older one (the #312 rule).
+                seen.add(entry.runId);
+                const url = entry.detail?.['url'];
+                if (typeof url !== 'string' || url === '')
+                    continue;
+                this.runToUrl.set(entry.runId, url);
+            }
+        }
+        catch (err) {
+            log?.(`[runs] delivery-index hydrate failed (prior runs read as undelivered until restart): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /** Record the run's delivered PR URL (idempotent — the newest write wins). */
+    set(runId, url) {
+        this.runToUrl.set(runId, url);
+    }
+    /** The delivery for this run, or `undefined` (the DTO spells that as an ABSENT field). */
+    deliveryFor(runId) {
+        const url = this.runToUrl.get(runId);
+        return url === undefined ? undefined : { kind: 'pull_request', url };
+    }
+}
+//# sourceMappingURL=delivery-index.js.map

package/dist/api/delivery-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-index.js","sourceRoot":"","sources":["../../src/api/delivery-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAWH;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC;IACxD,OAAO,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;AACzE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,IAAiB;IAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;IAC/D,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACpC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,IAAI,IAAI,CAAC;AAC/F,CAAC;AAED,MAAM,OAAO,aAAa;IACP,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEtD;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,CAAC,KAAe,EAAE,GAA2B;QACxD,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;YAC/B,KAAK,MAAM,KAAK,IAAI,MAAM,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,EAAE,CAAC;gBACrE,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;oBAAE,SAAS;gBAC9C,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC;oBAAE,SAAS;gBACpC,kFAAkF;gBAClF,qFAAqF;gBACrF,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACtB,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;gBAClC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,EAAE;oBAAE,SAAS;gBACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,GAAG,EAAE,CACH,wFACE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CACjD,EAAE,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,8EAA8E;IAC9E,GAAG,CAAC,KAAa,EAAE,GAAW;QAC5B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,0FAA0F;IAC1F,WAAW,CAAC,KAAa;QACvB,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrC,OAAO,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC;IACvE,CAAC;CACF"}

package/dist/api/endpoint-manifest-live.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Build the LIVE endpoint manifest by booting the real server assembly (TH-11).
+ *
+ * A separate module from endpoint-manifest.ts on purpose: this imports `createServer` while
+ * server.ts imports the hook installer — folding both into one file would make the cycle
+ * structural instead of avoiding it.
+ *
+ * # Why boot `createServer` rather than re-list routes by hand
+ *
+ * The manifest's whole value is that it cannot drift from the daemon: it is read from the same
+ * `onRoute` hook, over the same registration calls (`registerRoutes`, project routes, terminal
+ * WS, `/ws`, interactive event routes), that the served daemon runs. A hand-maintained list would
+ * be a second spelling of the route table — the exact thing the manifest exists to end.
+ *
+ * # What is faked, and why it is safe
+ *
+ * Route REGISTRATION never calls the engine — only handlers do, and no request is ever injected
+ * here. The adapter stub answers the three things `createServer` itself asks at boot:
+ * `getSettings()` (worker-config root export), `projectsSupported()` → false (skips membership
+ * hydration), and `stub: true` (any answering seam that were ever armed would refuse rather than
+ * subscribe). Every optional seam is disabled explicitly, the audit trail goes to a temp file
+ * (never `~/.wicked-crew/audit.log`), and `studioRoot` points at a nonexistent directory so the
+ * server boots HEADLESS — deliberately: the static wildcard route depends on whether a studio
+ * bundle is installed on the generating machine, and a committed manifest must not vary by
+ * install state. The manifest documents the API + WS surface.
+ */
+import { type EndpointManifest } from './endpoint-manifest.js';
+export declare function collectLiveEndpointManifest(): Promise<EndpointManifest>;
+//# sourceMappingURL=endpoint-manifest-live.d.ts.map

package/dist/api/endpoint-manifest-live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-manifest-live.d.ts","sourceRoot":"","sources":["../../src/api/endpoint-manifest-live.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAQH,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEtF,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAmC7E"}

package/dist/api/endpoint-manifest-live.js

@@ -0,0 +1,72 @@
+/**
+ * Build the LIVE endpoint manifest by booting the real server assembly (TH-11).
+ *
+ * A separate module from endpoint-manifest.ts on purpose: this imports `createServer` while
+ * server.ts imports the hook installer — folding both into one file would make the cycle
+ * structural instead of avoiding it.
+ *
+ * # Why boot `createServer` rather than re-list routes by hand
+ *
+ * The manifest's whole value is that it cannot drift from the daemon: it is read from the same
+ * `onRoute` hook, over the same registration calls (`registerRoutes`, project routes, terminal
+ * WS, `/ws`, interactive event routes), that the served daemon runs. A hand-maintained list would
+ * be a second spelling of the route table — the exact thing the manifest exists to end.
+ *
+ * # What is faked, and why it is safe
+ *
+ * Route REGISTRATION never calls the engine — only handlers do, and no request is ever injected
+ * here. The adapter stub answers the three things `createServer` itself asks at boot:
+ * `getSettings()` (worker-config root export), `projectsSupported()` → false (skips membership
+ * hydration), and `stub: true` (any answering seam that were ever armed would refuse rather than
+ * subscribe). Every optional seam is disabled explicitly, the audit trail goes to a temp file
+ * (never `~/.wicked-crew/audit.log`), and `studioRoot` points at a nonexistent directory so the
+ * server boots HEADLESS — deliberately: the static wildcard route depends on whether a studio
+ * bundle is installed on the generating machine, and a committed manifest must not vary by
+ * install state. The manifest documents the API + WS surface.
+ */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createServer } from './server.js';
+import { buildEndpointManifest } from './endpoint-manifest.js';
+export async function collectLiveEndpointManifest() {
+    // Deterministic boot: auth mode is pinned OFF via options (no env/file resolution), and the
+    // logger is silenced for the duration — this runs inside test output and CI logs.
+    const savedLogLevel = process.env['LOG_LEVEL'];
+    process.env['LOG_LEVEL'] = 'silent';
+    const scratch = mkdtempSync(join(tmpdir(), 'crew-endpoint-manifest-'));
+    const adapter = {
+        stub: true,
+        projectsSupported: () => false,
+        getSettings: async () => ({}),
+        // The daemon's single CoreEvent fan-out subscribes at boot; no event ever arrives here.
+        onEvent: () => () => { },
+    };
+    try {
+        const app = await createServer(adapter, {
+            auth: { mode: 'off' },
+            auditPath: join(scratch, 'audit.log'),
+            projectEvents: { disabled: true },
+            interactiveWsRelay: { disabled: true },
+            seatHealthProbe: { enabled: false },
+            stallWatchdog: { enabled: false },
+            // Nonexistent on purpose — headless boot; see the module header.
+            studioRoot: join(scratch, 'no-studio-bundle'),
+        });
+        try {
+            await app.ready();
+            return buildEndpointManifest(app.endpointManifest ?? []);
+        }
+        finally {
+            await app.close();
+        }
+    }
+    finally {
+        if (savedLogLevel === undefined)
+            delete process.env['LOG_LEVEL'];
+        else
+            process.env['LOG_LEVEL'] = savedLogLevel;
+        rmSync(scratch, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=endpoint-manifest-live.js.map

package/dist/api/endpoint-manifest-live.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-manifest-live.js","sourceRoot":"","sources":["../../src/api/endpoint-manifest-live.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAyB,MAAM,wBAAwB,CAAC;AAEtF,MAAM,CAAC,KAAK,UAAU,2BAA2B;IAC/C,4FAA4F;IAC5F,kFAAkF;IAClF,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC/C,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC;IACpC,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,yBAAyB,CAAC,CAAC,CAAC;IACvE,MAAM,OAAO,GAAG;QACd,IAAI,EAAE,IAAI;QACV,iBAAiB,EAAE,GAAG,EAAE,CAAC,KAAK;QAC9B,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;QAC7B,wFAAwF;QACxF,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAE,CAAC;KACE,CAAC;IAC5B,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,YAAY,CAAC,OAAO,EAAE;YACtC,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE;YACrB,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC;YACrC,aAAa,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;YACjC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;YACtC,eAAe,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;YACnC,aAAa,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;YACjC,iEAAiE;YACjE,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,kBAAkB,CAAC;SAC9C,CAAC,CAAC;QACH,IAAI,CAAC;YACH,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC;YAClB,OAAO,qBAAqB,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC;gBAAS,CAAC;YACT,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC;QACpB,CAAC;IACH,CAAC;YAAS,CAAC;QACT,IAAI,aAAa,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;;YAC5D,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC;QAC9C,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC;AACH,CAAC"}

package/dist/api/endpoint-manifest.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The endpoint manifest (TH-11) — crew's route table as a MACHINE-READABLE build artifact.
+ *
+ * # Why this exists
+ *
+ * routes.ts declares zero fastify schemas (verified: grep `schema:` = 0), no OpenAPI spec exists
+ * anywhere in crew, and `wicked-crew-api-types` is types-only with no endpoint-to-type binding —
+ * so nothing machine-readable said which methods+paths this daemon serves, what a request body is
+ * called, or which status codes a route can answer. Request validation is NOT a vacuum (13
+ * `.strict()` zod objects guard the bodies), but zod objects are route-internal: a test harness,
+ * a drift check, or an API-test generator had nothing to read. With no fastify schemas declared,
+ * `@fastify/swagger` has nothing to generate from either — the `onRoute` hook IS the cheap path.
+ *
+ * # How it works
+ *
+ * {@link installEndpointManifestHook} registers a fastify `onRoute` hook (added by `createServer`
+ * BEFORE any route registration, so every route the daemon serves is seen) that accumulates one
+ * {@link EndpointEntry} per method+path. Two declaration channels feed the type/status fields:
+ *
+ *   1. `config.manifest` on the route options ({@link ManifestRouteConfig}) — the explicit
+ *      channel. Names should reference `wicked-crew-api-types` exports where one exists
+ *      (`LaunchRunBody`, `GateDecision`, …) so the manifest binds endpoints to the published
+ *      wire contract; a structural spelling (`'{ runId: string }'`) is the honest fallback for
+ *      wire shapes the contract has no name for.
+ *   2. `schema.response` keys, when fastify schemas start existing (the longer-term
+ *      zod-to-json-schema path) — status codes are folded in automatically, so migrating a route
+ *      to real fastify schemas enriches the manifest without touching this module.
+ *
+ * Routes that declare neither still land in the manifest with `requestType`/`responseType` null
+ * and `statusCodes: []` — the manifest records "where declared", never invents.
+ *
+ * # What consumes it
+ *
+ * - `scripts/generate-endpoint-manifest.ts` (npm run manifest:endpoints) writes the committed
+ *   `endpoint-manifest.json` at the package root — the build artifact.
+ * - `tests/endpoint-manifest.test.ts` rebuilds the live route table and fails on ANY drift from
+ *   the committed file, so an added/removed/renamed endpoint fails CI until the manifest is
+ *   regenerated and the diff reviewed. The manifest diff IS the API regression trigger.
+ * - `scripts/generate-api-tests.ts` derives positive + 400/404/409 negative API tests from the
+ *   committed manifest (see `tests/generated/`).
+ *
+ * HEAD entries are dropped: fastify v5 auto-exposes a HEAD twin for every GET
+ * (`exposeHeadRoutes`), which would double the GET surface with rows nobody declared.
+ */
+import type { FastifyInstance } from 'fastify';
+/** The explicit per-route declaration channel — `{ config: { manifest: {...} } }` on a route. */
+export interface ManifestRouteConfig {
+    /** Request-body type name — a `wicked-crew-api-types` export where one exists. */
+    requestType?: string;
+    /** Success-response type name, or a structural spelling when the contract has no name for it. */
+    responseType?: string;
+    /** Every status code this route answers on purpose (success + named error codes). */
+    statusCodes?: number[];
+}
+declare module 'fastify' {
+    interface FastifyContextConfig {
+        /** TH-11 — this route's row in the committed endpoint manifest. */
+        manifest?: ManifestRouteConfig;
+    }
+    interface FastifyInstance {
+        /** Accumulated by `createServer`'s onRoute hook; read after `app.ready()`. */
+        endpointManifest?: EndpointEntry[];
+    }
+}
+/** One method+path the daemon serves. */
+export interface EndpointEntry {
+    method: string;
+    path: string;
+    /** Declared request-body type name, or null — "where declared", never invented. */
+    requestType: string | null;
+    /** Declared response type name, or null. */
+    responseType: string | null;
+    /** Declared status codes (config.manifest + fastify schema.response keys), sorted. */
+    statusCodes: number[];
+    /** Present (true) only on websocket routes (`/ws`, `/ws/terminals/:id`). */
+    websocket?: boolean;
+}
+/** The committed artifact's shape (endpoint-manifest.json). */
+export interface EndpointManifest {
+    version: 1;
+    /**
+     * The `wicked-crew-api-types` version this route table was generated against — the published
+     * wire contract the type names bind to. Evidence manifests that cite endpoints should carry
+     * this (recon R8/R11: api-types drift is live; studio pinned ^0.8.0 against 0.10.0).
+     */
+    apiTypesVersion: string;
+    /** Sorted by path, then method — a stable order so drift diffs are readable. */
+    endpoints: EndpointEntry[];
+}
+/**
+ * Register the accumulating `onRoute` hook. MUST run before any route is registered — fastify
+ * only replays `onRoute` for routes added after the hook exists. Returns the live array the hook
+ * appends to; `createServer` exposes it as `app.endpointManifest`.
+ */
+export declare function installEndpointManifestHook(app: FastifyInstance): EndpointEntry[];
+/**
+ * The published wire contract's version, read from the actually-installed dependency.
+ *
+ * NOT `require('wicked-crew-api-types/package.json')`: that package's exports map exposes only
+ * `.` (types-only, no runtime condition), so both the subpath and a bare resolve are refused.
+ * Walking the resolver's candidate directories and reading the file with fs sidesteps the
+ * exports map while still honoring the real resolution order (workspace link included).
+ */
+export declare function apiTypesVersion(): string;
+/** Entries → the committed artifact: stable order, contract version stamped. */
+export declare function buildEndpointManifest(entries: EndpointEntry[]): EndpointManifest;
+//# sourceMappingURL=endpoint-manifest.d.ts.map

package/dist/api/endpoint-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-manifest.d.ts","sourceRoot":"","sources":["../../src/api/endpoint-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,SAAS,CAAC;AAE7D,iGAAiG;AACjG,MAAM,WAAW,mBAAmB;IAClC,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,oBAAoB;QAC5B,mEAAmE;QACnE,QAAQ,CAAC,EAAE,mBAAmB,CAAC;KAChC;IACD,UAAU,eAAe;QACvB,8EAA8E;QAC9E,gBAAgB,CAAC,EAAE,aAAa,EAAE,CAAC;KACpC;CACF;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,4CAA4C;IAC5C,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,sFAAsF;IACtF,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,CAAC,CAAC;IACX;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,SAAS,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,EAAE,CAgCjF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAWxC;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,gBAAgB,CAKhF"}

package/dist/api/endpoint-manifest.js

@@ -0,0 +1,108 @@
+/**
+ * The endpoint manifest (TH-11) — crew's route table as a MACHINE-READABLE build artifact.
+ *
+ * # Why this exists
+ *
+ * routes.ts declares zero fastify schemas (verified: grep `schema:` = 0), no OpenAPI spec exists
+ * anywhere in crew, and `wicked-crew-api-types` is types-only with no endpoint-to-type binding —
+ * so nothing machine-readable said which methods+paths this daemon serves, what a request body is
+ * called, or which status codes a route can answer. Request validation is NOT a vacuum (13
+ * `.strict()` zod objects guard the bodies), but zod objects are route-internal: a test harness,
+ * a drift check, or an API-test generator had nothing to read. With no fastify schemas declared,
+ * `@fastify/swagger` has nothing to generate from either — the `onRoute` hook IS the cheap path.
+ *
+ * # How it works
+ *
+ * {@link installEndpointManifestHook} registers a fastify `onRoute` hook (added by `createServer`
+ * BEFORE any route registration, so every route the daemon serves is seen) that accumulates one
+ * {@link EndpointEntry} per method+path. Two declaration channels feed the type/status fields:
+ *
+ *   1. `config.manifest` on the route options ({@link ManifestRouteConfig}) — the explicit
+ *      channel. Names should reference `wicked-crew-api-types` exports where one exists
+ *      (`LaunchRunBody`, `GateDecision`, …) so the manifest binds endpoints to the published
+ *      wire contract; a structural spelling (`'{ runId: string }'`) is the honest fallback for
+ *      wire shapes the contract has no name for.
+ *   2. `schema.response` keys, when fastify schemas start existing (the longer-term
+ *      zod-to-json-schema path) — status codes are folded in automatically, so migrating a route
+ *      to real fastify schemas enriches the manifest without touching this module.
+ *
+ * Routes that declare neither still land in the manifest with `requestType`/`responseType` null
+ * and `statusCodes: []` — the manifest records "where declared", never invents.
+ *
+ * # What consumes it
+ *
+ * - `scripts/generate-endpoint-manifest.ts` (npm run manifest:endpoints) writes the committed
+ *   `endpoint-manifest.json` at the package root — the build artifact.
+ * - `tests/endpoint-manifest.test.ts` rebuilds the live route table and fails on ANY drift from
+ *   the committed file, so an added/removed/renamed endpoint fails CI until the manifest is
+ *   regenerated and the diff reviewed. The manifest diff IS the API regression trigger.
+ * - `scripts/generate-api-tests.ts` derives positive + 400/404/409 negative API tests from the
+ *   committed manifest (see `tests/generated/`).
+ *
+ * HEAD entries are dropped: fastify v5 auto-exposes a HEAD twin for every GET
+ * (`exposeHeadRoutes`), which would double the GET surface with rows nobody declared.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+/**
+ * Register the accumulating `onRoute` hook. MUST run before any route is registered — fastify
+ * only replays `onRoute` for routes added after the hook exists. Returns the live array the hook
+ * appends to; `createServer` exposes it as `app.endpointManifest`.
+ */
+export function installEndpointManifestHook(app) {
+    const entries = [];
+    app.addHook('onRoute', (route) => {
+        const methods = Array.isArray(route.method) ? route.method : [route.method];
+        const declared = route.config?.manifest;
+        // The future-proofing channel: fastify response schemas keyed by status code. None exist
+        // today (routes.ts declares zero), but the fold means the zod→fastify-schema migration
+        // enriches the manifest for free.
+        const schemaResponse = route.schema
+            ?.response;
+        const schemaCodes = Object.keys(schemaResponse ?? {})
+            .map(Number)
+            .filter((n) => Number.isInteger(n) && n >= 100 && n <= 599);
+        const statusCodes = [...new Set([...(declared?.statusCodes ?? []), ...schemaCodes])].sort((a, b) => a - b);
+        const websocket = route.websocket === true;
+        for (const method of methods) {
+            // Fastify v5 auto-exposes a HEAD twin per GET; recording it would double the GET surface
+            // with rows nobody declared and no client calls on purpose.
+            if (method === 'HEAD')
+                continue;
+            entries.push({
+                method,
+                path: route.url,
+                requestType: declared?.requestType ?? null,
+                responseType: declared?.responseType ?? null,
+                statusCodes,
+                ...(websocket ? { websocket: true } : {}),
+            });
+        }
+    });
+    return entries;
+}
+/**
+ * The published wire contract's version, read from the actually-installed dependency.
+ *
+ * NOT `require('wicked-crew-api-types/package.json')`: that package's exports map exposes only
+ * `.` (types-only, no runtime condition), so both the subpath and a bare resolve are refused.
+ * Walking the resolver's candidate directories and reading the file with fs sidesteps the
+ * exports map while still honoring the real resolution order (workspace link included).
+ */
+export function apiTypesVersion() {
+    const require = createRequire(import.meta.url);
+    for (const dir of require.resolve.paths('wicked-crew-api-types') ?? []) {
+        const pkgPath = join(dir, 'wicked-crew-api-types', 'package.json');
+        if (existsSync(pkgPath)) {
+            return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+        }
+    }
+    throw new Error('wicked-crew-api-types is not resolvable from packages/crew — the manifest cannot stamp the wire-contract version');
+}
+/** Entries → the committed artifact: stable order, contract version stamped. */
+export function buildEndpointManifest(entries) {
+    const endpoints = [...entries].sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+    return { version: 1, apiTypesVersion: apiTypesVersion(), endpoints };
+}
+//# sourceMappingURL=endpoint-manifest.js.map

package/dist/api/endpoint-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-manifest.js","sourceRoot":"","sources":["../../src/api/endpoint-manifest.ts"],"names":[],"mappings":"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"}

package/dist/api/governance-wiki.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The `/api/v1/governance/wiki/*` surface (wiki-mgmt) — the management wire for the graph-backed
+ * architecture wiki, so the wiki is VISIBLE (not just queryable): a scoreboard that tells a
+ * populated wiki from an ingested-once-and-decaying one, and a meta probe cheap enough for the
+ * UI to call on mount so an empty store shows an honest "nothing seeded — here's the runbook"
+ * instead of a blank table.
+ *
+ * Thin by design, like `campaigns/routes.ts`: the scoreboard is computed by wicked-core's
+ * governance layer (`wicked-governance::scoreboard`, read-only `open_store_ro` — safe beside the
+ * live single-writer daemon); the daemon keeps no shadow wiki state. Error posture mirrors the
+ * campaign surface: a build whose engine addon lacks the `governanceScoreboard` binding answers
+ * 501 (`GovernanceScoreboardUnsupportedError` — "upgrade the engine"), never 400 ("fix your
+ * request").
+ *
+ * Rule/ruleset BROWSE and RETIRE deliberately live elsewhere — this module adds no second door:
+ * `GET /governance/rules` (facet-filterable, retired rows flagged) is the browse surface and
+ * `DELETE /governance/rules/:id` (retire-not-delete, FINDING-038) is the kill switch, both in
+ * `api/routes.ts`.
+ */
+import type { FastifyInstance } from 'fastify';
+import { type CoreAdapter } from '../core/adapter.js';
+/**
+ * The authoring guide the honest empty state points at: the AW-13 seed runbook — frontmatter
+ * conventions, the `seed_wiki.py` driver, and the `wicked-core rules` ingest/fanout/relink CLIs.
+ */
+export declare const WIKI_AUTHORING_DOC = "https://github.com/mikeparcewski/wicked-core/blob/main/crates/wicked-governance/seed/README.md";
+export declare function registerGovernanceWikiRoutes(app: FastifyInstance, adapter: CoreAdapter): void;
+//# sourceMappingURL=governance-wiki.d.ts.map

package/dist/api/governance-wiki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governance-wiki.d.ts","sourceRoot":"","sources":["../../src/api/governance-wiki.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAwC,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAM5F;;;GAGG;AACH,eAAO,MAAM,kBAAkB,mGACmE,CAAC;AAMnG,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,CAwE7F"}