wicked-crew 0.4.0 → 0.6.0

package/dist/api/routes.js

@@ -3,13 +3,31 @@ import { listRequirements, getRequirement, patchRequirement } from './requiremen
 import { randomUUID } from 'node:crypto';
 import { readFileSync, existsSync } from 'node:fs';
 import { promises as fsp } from 'node:fs';
-import { join } from 'node:path';
+import { isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError } from '../core/adapter.js';
+import { ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, humanGatePhaseIds } from '../core/adapter.js';
 import { codeGraphDb, requirementsGraph } from '../core/repoPaths.js';
-import { buildEvidenceBundle, evidenceFilename } from './evidence.js';
+import { QeGateCache } from '../qe/gate-events.js';
+import { buildAcceptanceView, resolveRunWorkflow } from '../qe/acceptance.js';
+import { buildEvidenceBundle, coreUnitId, evidenceFilename } from './evidence.js';
+import { outputUnavailableReason, resolveUnit, unitKeysFor } from './unit-output.js';
 import { execCapped, ExecOutputTooLarge } from '../core/exec.js';
-const V = '/api/v1';
+import { SeatHealthTracker } from './seat-health.js';
+import { applyWorkerConfigRoot, signedInHeuristic } from './seat-signin.js';
+import { isInsideRoot, openWithSystemDefault } from './open-path.js';
+import { registerProjectRoutes } from '../projects/routes.js';
+import { ProjectSettingsStore } from '../projects/settings.js';
+import { InteractiveBridgePool } from '../interactive/bridge-pool.js';
+import { registerInteractiveProxy } from '../interactive/proxy-routes.js';
+import { MembershipIndex } from '../projects/membership-index.js';
+import { MEMBERSHIP_ATTACHED, membershipAttachedKey } from '../projects/events.js';
+import { AuditLog } from './audit.js';
+import { LOCAL_ACTOR } from './auth.js';
+// Re-exported so existing `import { API_PREFIX } from './routes.js'` callers keep working; the
+// value lives in the leaf module api-prefix.ts to keep unit-output.ts out of this file's cycle.
+export { API_PREFIX } from './api-prefix.js';
+import { API_PREFIX } from './api-prefix.js';
+const V = API_PREFIX;
 // Daemon version reported by /health — read from package.json so it never drifts
 // from the shipped version across releases. Resolves the package root from the
 // compiled module location (dist/api/routes.js → ../../package.json) and works the
@@ -88,7 +106,10 @@ const RegisterRepoSchema = z
  * schema does not accept — so `.strict()` is what turns that trip into a 400 instead of an
  * unworkflowed run reported as `201`.
  */
-const LaunchSchema = z.object({
+// The request-body schemas below are exported so `tests/wire-contract.test.ts` can prove, at
+// compile time, that every body the published contract (`wicked-crew-api-types`) lets a client
+// send is a body these schemas accept — the request-direction half of the drift guard (task #84).
+export const LaunchSchema = z.object({
     problem: z.string().min(1),
     sessionId: z.string().min(1).optional(),
     clisJson: z.string().min(1).optional(),
@@ -96,8 +117,11 @@ const LaunchSchema = z.object({
     humanConfirm: z.string().min(1).optional(),
     repoRef: z.string().min(1).optional(),
     workflow: z.string().min(1).optional(),
+    /** DES-PROJECT-001 §2.2 — file the run into a project; membership attaches atomically with
+     *  the launch record. Unknown/archived ⇒ the launch fails (never a silent unfiled run). */
+    projectId: z.string().min(1).optional(),
 }).strict();
-const GateSchema = z.object({
+export const GateSchema = z.object({
     approve: z.boolean(),
     amend: z.string().optional(),
 }).strict();
@@ -106,7 +130,7 @@ const InjectSchema = z.object({
     /** `"all"` broadcasts to every active worker; any other value is a CLI key. */
     target: z.string().min(1).default('all'),
 }).strict();
-const OpenTerminalSchema = z.object({
+export const OpenTerminalSchema = z.object({
     cwd: z.string().min(1),
     cmd: z.array(z.string().min(1)).min(1).optional(),
     cols: z.number().int().positive(),
@@ -119,16 +143,81 @@ const ResizeTerminalSchema = z.object({
     cols: z.number().int().positive(),
     rows: z.number().int().positive(),
 }).strict();
+/** `POST /open` (crew#273) — the studio Files tab's "open with the OS default app" body. */
+export const OpenPathSchema = z.object({
+    path: z.string().min(1),
+    runId: z.string().min(1).optional(),
+}).strict();
 /**
  * The daemon REST surface. Every endpoint is a thin wrapper over one adapter /
  * core-ts call (DES-STUDIO-001 §2). `session`/`phase` nouns are now `run`/`unit`.
  */
-export function registerRoutes(app, adapter, gateCache, elicitationCache) {
+export function registerRoutes(app, adapter, gateCache, elicitationCache, 
+// Defaulted so a caller that never arms the bus seam (tests drive this
+// function directly) gets the same behavior as an unarmed daemon: an empty
+// cache, `busEvent: null`, and the lazy ledger read doing all the work.
+qeGateEvents = new QeGateCache(), 
+// Defaulted for the same reason: tests that drive this function directly get
+// the projects surface with no bus (events skipped) and a fresh index.
+projects = { bus: null, index: new MembershipIndex(), log: () => undefined }, 
+// Defaulted likewise — to a NOOP trail, deliberately: a directly-driven
+// route set (unit tests) must never write the operator's real
+// ~/.wicked-crew/audit.log or leave appends pending after close. The real
+// trail always arrives from `createServer`.
+security = { audit: AuditLog.noop(), authMode: 'off' }, 
+// Defaulted likewise: a directly-driven route set gets a fresh (all-active) health map and the
+// real OS opener — tests inject both through this seam.
+runtime = {}) {
+    const { audit } = security;
+    const seatHealth = runtime.seatHealth ?? new SeatHealthTracker();
+    const openWithOs = runtime.openWithOs ?? openWithSystemDefault;
+    const signedIn = runtime.signedIn ?? signedInHeuristic;
+    // Resolved ONCE and shared by the project routes (which read/write `interactiveRoot`) and the
+    // interactive proxy (which resolves a root from it) — two stores would let a PATCH land in one
+    // and the proxy keep reading the other.
+    const projectSettings = projects.settings ?? new ProjectSettingsStore();
+    // `req.actor` is pinned by the auth hooks `createServer` installs; a caller
+    // driving this function directly (tests) has no hooks, so downstream code
+    // still gets the ONE actor shape via this accessor.
+    const actorOf = (req) => req.actor ?? LOCAL_ACTOR;
     // Liveness — also proves the actor + event pump are up.
     app.get(`${V}/health`, async () => {
         const ping = await adapter.ping();
         return { status: 'ok', version: PKG_VERSION, ping };
     });
+    // Who am I talking to the daemon as? (task #88). In local mode this is
+    // always the implicit full-trust local actor; in required mode it names the
+    // token's actor — the cheap probe a skin uses to decide what to render.
+    app.get(`${V}/whoami`, async (req) => ({
+        actor: actorOf(req),
+        authMode: security.authMode,
+    }));
+    // The actor audit trail (task #88): who launched/steered/governed what.
+    // Read-only (observer trust); newest first; `?runId=` / `?action=` / `?limit=`.
+    app.get(`${V}/audit`, async (req, reply) => {
+        const q = req.query;
+        const first = (v) => (Array.isArray(v) ? v[0] : v)?.trim() || undefined;
+        const runId = first(q.runId);
+        const action = first(q.action);
+        const limitRaw = first(q.limit);
+        // Reject partial-numeric strings like "10abc" — parseInt accepts those,
+        // Number() is strict and returns NaN for them (Copilot, #250).
+        const limit = limitRaw !== undefined ? Number(limitRaw) : undefined;
+        if (limitRaw !== undefined && (!Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))) {
+            return reply.code(400).send({ error: '`limit` must be a positive integer' });
+        }
+        try {
+            const entries = await audit.read({
+                ...(runId !== undefined ? { runId } : {}),
+                ...(action !== undefined ? { action } : {}),
+                ...(limit !== undefined ? { limit } : {}),
+            });
+            return { entries };
+        }
+        catch (err) {
+            return reply.code(500).send({ error: message(err) });
+        }
+    });
     // Report the actually-bound port/host (honours --port / CREW_PORT / port 0).
     app.get(`${V}/config`, async () => {
         const addr = app.server.address();
@@ -136,8 +225,77 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         const host = typeof addr === 'object' && addr ? addr.address : '127.0.0.1';
         return { port, host };
     });
-    // The council seats for the launch form (static production roster).
-    app.get(`${V}/roster`, async () => ({ roster: CoreAdapter.roster() }));
+    // The council seats for the launch form (static production roster), each carrying its RUNTIME
+    // health (crew#274). The roster is declarative — every configured seat is listed — and `health`
+    // is what the platform has observed: default active with no message; inactive + the error
+    // excerpt after a seat-level failure, until an ok output or the recovery probe flips it back.
+    // Existing fields ride through verbatim (the seat still round-trips into `clisJson` on launch)
+    // — the spread is deliberately NOT a field whitelist, which is what lets the engine's
+    // `login_invocation` (seat sign-in, wicked-core PR#278) pass through untouched. Each seat also
+    // gains `signed_in`: the cheap file/env presence heuristic, computed against the LIVE
+    // `WICKED_WORKER_HOME` env — the same value the engine reads at the next worker spawn, kept
+    // current by `applyWorkerConfigRoot` at boot and on every settings change.
+    app.get(`${V}/roster`, async () => {
+        const workerRoot = process.env['WICKED_WORKER_HOME'];
+        return {
+            roster: CoreAdapter.roster().map((seat) => ({
+                ...seat,
+                health: seatHealth.healthFor(String(seat.key)),
+                signed_in: signedIn(String(seat.key), workerRoot === '' ? undefined : workerRoot),
+            })),
+        };
+    });
+    // Open a file/folder with the OS default application (crew#273) — the studio Files tab's
+    // click-to-open. The open MUST happen daemon-side (the SPA cannot spawn a process), which is
+    // why the path is validated first: absolute, and inside one of the caller-visible roots — the
+    // run's workdir + extra write roots (when `runId` is given) or a registered repo root. The
+    // run's QE evidence/decisions dirs (`.wicked-qe`/`.wicked-testing`) live under the repo root,
+    // so the repo-root rule covers them. Never an arbitrary path.
+    app.post(`${V}/open`, async (req, reply) => {
+        const parsed = OpenPathSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid open request'));
+        }
+        const { path: rawPath, runId } = parsed.data;
+        if (!isAbsolute(rawPath)) {
+            return reply.code(400).send({ error: '`path` must be an absolute path' });
+        }
+        const target = resolve(rawPath);
+        const roots = [];
+        try {
+            if (runId !== undefined) {
+                const views = await adapter.sessionsDetail();
+                const view = views.find((v) => v.session.id === runId);
+                if (view === undefined) {
+                    return reply.code(404).send({ error: `unknown run: ${runId}` });
+                }
+                const workdir = view.session.workdir;
+                if (typeof workdir === 'string' && workdir.length > 0)
+                    roots.push(workdir);
+                for (const r of view.session.extra_write_roots ?? []) {
+                    if (typeof r === 'string' && r.length > 0)
+                        roots.push(r);
+                }
+            }
+            for (const repo of await adapter.listRepos())
+                roots.push(repo.root_path);
+        }
+        catch (err) {
+            return reply.code(500).send({ error: message(err) });
+        }
+        if (!roots.some((root) => isInsideRoot(root, target))) {
+            return reply.code(403).send({
+                error: "path is outside every allowed root (the run's workdir/write roots and the registered repos)",
+            });
+        }
+        try {
+            await openWithOs(target);
+        }
+        catch (err) {
+            return reply.code(502).send({ error: `could not open ${target}: ${message(err)}` });
+        }
+        return { status: 'opened' };
+    });
     // Registered repos → target-repo picker.
     app.get(`${V}/repos`, async () => ({ repos: await adapter.listRepos() }));
     app.post(`${V}/repos`, async (req, reply) => {
@@ -210,23 +368,116 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             input.repoRef = b.repoRef;
         if (b.workflow !== undefined)
             input.workflow = b.workflow;
+        if (b.projectId !== undefined)
+            input.projectId = b.projectId;
         try {
             const runId = await adapter.launchRun(input);
+            // Who launched it — the engine's LaunchOptions carries no actor field
+            // (checked, wicked-core-ts 0.6.0), so the crew-side trail is the system
+            // of record for run provenance (task #88).
+            audit.record('run.launched', actorOf(req), {
+                runId,
+                detail: {
+                    ...(b.workflow !== undefined ? { workflow: b.workflow } : {}),
+                    ...(b.repoRef !== undefined ? { repoRef: b.repoRef } : {}),
+                    ...(b.projectId !== undefined ? { projectId: b.projectId } : {}),
+                },
+            });
+            if (b.projectId !== undefined) {
+                // The engine attached the crew.run membership ATOMICALLY with the launch record
+                // (DES-PROJECT-001 §2.2) — this is the post-commit half: tag future /ws frames and
+                // emit the membership event (auto-attach at launch is an attach, §4).
+                projects.index.set(runId, b.projectId);
+                projects.bus?.emit(MEMBERSHIP_ATTACHED, 
+                // The AUTHENTICATED actor id, not a caller-supplied string — locked
+                // decision #6 replaces spoofable actor strings on the event surface.
+                { project_id: b.projectId, member: { kind: 'crew.run', ref: runId }, actor: actorOf(req).id }, membershipAttachedKey(b.projectId, 'crew.run', runId, Date.now()));
+            }
             return reply.code(201).send({ runId });
         }
         catch (err) {
             const msg = message(err);
+            // An unknown/archived project is a state conflict on a real resource, not a malformed
+            // request: 404/409 per the projects error mapping; anything else keeps the launch 400/409.
+            if (b.projectId !== undefined && /project.*not registered/i.test(msg)) {
+                return reply.code(404).send({ error: msg });
+            }
+            if (b.projectId !== undefined && /archived|'default'|synthesized/i.test(msg)) {
+                return reply.code(409).send({ error: msg });
+            }
             const busy = /busy|in flight|already/i.test(msg);
             return reply.code(busy ? 409 : 400).send({ error: msg });
         }
     });
     // Run list (replaces GET /sessions). Actionable-first; reconciles the gate and elicitation caches
     // so that terminal-run entries are pruned even when their terminal CoreEvent was missed.
-    app.get(`${V}/runs`, async () => {
+    app.get(`${V}/runs`, async (req) => {
         const views = await adapter.sessionsDetail();
         gateCache.reconcile(views);
         elicitationCache.reconcile(views);
-        return { runs: sortActionableFirst(views) };
+        // Archived runs are WRITTEN OFF (crew#265): excluded from the default view so finished
+        // history doesn't drown live signal, returned in full with `?include=archived`. The caches
+        // above reconcile over the COMPLETE set either way — a gate on an archived run must still
+        // resolve, not leak.
+        // Fastify parses a REPEATED query param as string[] — normalize so `?include=archived`
+        // and `?include=archived&include=archived` behave identically (Copilot).
+        const { include } = req.query;
+        const includeArchived = (Array.isArray(include) ? include : [include]).includes('archived');
+        const visible = includeArchived
+            ? views
+            : views.filter((v) => v.session.archived_at == null);
+        return { runs: sortActionableFirst(visible) };
+    });
+    // ── Run archival (crew#265) — write-off, not delete ────────────────────────
+    const ArchiveSchema = z.object({
+        archived: z.boolean(),
+        note: z.string().max(500).optional(),
+    }).strict();
+    app.post(`${V}/runs/:id/archive`, async (req, reply) => {
+        const { id } = req.params;
+        const parsed = ArchiveSchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+        }
+        try {
+            const found = await adapter.archiveRun(id, parsed.data.archived, parsed.data.note);
+            if (!found)
+                return reply.code(404).send({ error: 'Run not found' });
+            return { runId: id, archived: parsed.data.archived };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            // The engine names a NON-terminal status ("run X is Executing — only a terminal run…"):
+            // a state conflict on a real resource, not a bad request (write-off must never hide
+            // live work). Anything else — including the old-addon guard — is a real 500.
+            if (/only a terminal run/i.test(msg))
+                return reply.code(409).send({ error: msg });
+            return reply.code(500).send({ error: msg });
+        }
+    });
+    // Bulk write-off for campaign backlogs — explicit ids only, never implicit age selection.
+    const BulkArchiveSchema = z.object({
+        ids: z.array(z.string().min(1)).min(1).max(200),
+        note: z.string().max(500).optional(),
+    }).strict();
+    app.post(`${V}/runs/archive`, async (req, reply) => {
+        const parsed = BulkArchiveSchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+        }
+        // Per-id outcomes rather than all-or-nothing: a batch of 45 with one live run in it
+        // should archive 44 and NAME the refusal, not roll back the write-off.
+        const results = [];
+        for (const id of parsed.data.ids) {
+            try {
+                const found = await adapter.archiveRun(id, true, parsed.data.note);
+                results.push(found ? { id, ok: true } : { id, ok: false, error: 'not found' });
+            }
+            catch (e) {
+                results.push({ id, ok: false, error: e instanceof Error ? e.message : String(e) });
+            }
+        }
+        return { results, archived: results.filter((r) => r.ok).length };
     });
     // One run's detail.
     app.get(`${V}/runs/:id`, async (req, reply) => {
@@ -237,9 +488,6 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             return reply.code(404).send({ error: 'Run not found' });
         return { run };
     });
-    // A unit's captured transcript. unitKey is the suffix after `<run>:` — `u<ord>` for free-text
-    // runs, `<phase_id>` for workflow runs (e.g. "survey", "coverage"). Strip any accidental
-    // `<id>:` prefix so both `survey` and `run-1:survey` resolve to the same key.
     // ── Chat sessions (crew#165): warm ACP seat pool + group fan-out (core#134) ──
     // A chat is NOT a run: no council, no gates, no units. Seats warm on open;
     // messages fan out to warm seats; replies stream on /ws as chatDelta/chatReply.
@@ -247,6 +495,8 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         chatId: z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/).optional(),
         clis: z.array(z.string().min(1)).min(1).max(8).optional(),
         repoRef: z.string().optional(),
+        /** DES-PROJECT-001 §2.2 — file the chat into a project (`crew.chat` membership). */
+        projectId: z.string().min(1).optional(),
     }).strict();
     app.post(`${V}/chats`, async (req, reply) => {
         const parsed = ChatOpenSchema.safeParse(req.body ?? {});
@@ -263,12 +513,48 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
                 return reply.code(404).send({ error: `Repo ${b.repoRef} not found` });
             cwd = repo.root_path;
         }
+        // Validate the project BEFORE opening seats: a chat has no launch record for the engine to
+        // attach against atomically (chats are an in-memory seat pool), so the route validates
+        // up-front and attaches right after open — the one non-atomic attach, documented in the ADR
+        // changelog. Fail here and no seats were warmed for a filing that could never happen.
+        if (b.projectId !== undefined) {
+            try {
+                const project = await adapter.projectGet(b.projectId);
+                if (project === null) {
+                    return reply.code(404).send({ error: `Project ${b.projectId} not found` });
+                }
+                if (project.status === 'archived') {
+                    return reply
+                        .code(409)
+                        .send({ error: `project ${b.projectId} is archived and blocks new attachments` });
+                }
+            }
+            catch (err) {
+                return reply.code(501).send({ error: message(err) });
+            }
+        }
         const clis = b.clis ??
             CoreAdapter.roster()
                 .map((s) => s.key)
                 .filter((k) => typeof k === 'string');
         try {
             const seats = await adapter.chatOpen(chatId, clis, cwd);
+            if (b.projectId !== undefined) {
+                try {
+                    const { member, created } = await adapter.projectMemberAttach(b.projectId, 'crew.chat', chatId);
+                    if (created) {
+                        projects.index.set(chatId, b.projectId);
+                        projects.bus?.emit(MEMBERSHIP_ATTACHED, { project_id: b.projectId, member: { kind: 'crew.chat', ref: chatId }, actor: actorOf(req).id }, membershipAttachedKey(b.projectId, 'crew.chat', chatId, member.attached_at));
+                    }
+                }
+                catch (err) {
+                    // The chat is open and usable; the filing failed. Say so instead of failing the open —
+                    // the caller can re-attach via POST /projects/:id/members.
+                    return reply
+                        .code(201)
+                        .send({ chatId, seats, projectAttachError: message(err) });
+                }
+            }
             return reply.code(201).send({ chatId, seats });
         }
         catch (err) {
@@ -333,11 +619,33 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             return reply.code(400).send({ error: message(err) });
         }
     });
+    // A unit's captured transcript. `unitKey` accepts the fully-qualified id (`run-1:survey`),
+    // the id suffix (`survey`, `u3`), or the ordinal (`u3`, `3`) — see `resolveUnit`.
+    //
+    // A `null` body is never bare here. An unknown run or an unknown key is a 404 that names the
+    // keys this run does have; a unit that exists but has no stored transcript answers 200 with
+    // `outputUnavailable` saying WHICH cause applies — denied, not finished, or a store that
+    // disagrees with itself. It previously answered `200 {"output": null}` to all four, so the
+    // failed unit an operator opens during triage was the one that told them nothing (FINDING-006).
     app.get(`${V}/runs/:id/units/:unitKey/output`, async (req, reply) => {
         const { id, unitKey } = req.params;
-        const suffix = unitKey.startsWith(`${id}:`) ? unitKey.slice(id.length + 1) : unitKey;
-        const output = await adapter.workOutput(`${id}:${suffix}`);
-        return reply.send({ output });
+        const views = await adapter.sessionsDetail();
+        const run = views.find((v) => v.session.id === id);
+        if (!run)
+            return reply.code(404).send({ error: 'Run not found' });
+        const unit = resolveUnit(run, unitKey);
+        if (!unit) {
+            return reply.code(404).send({
+                error: `Unit '${unitKey}' not found in run ${id}`,
+                units: unitKeysFor(run),
+            });
+        }
+        // Keyed off the unit RECORD (the same derivation the evidence bundle uses), not off the
+        // caller's path segment — the two disagreeing is what made a resolvable unit unreadable.
+        const output = await adapter.workOutput(coreUnitId(id, unit));
+        if (output !== null)
+            return reply.send({ output });
+        return reply.send({ output: null, outputUnavailable: outputUnavailableReason(unit) });
     });
     // The whole run as one auditable JSON attachment: the run, its units (each with
     // the captured transcript), and the decision trail read back from core's durable
@@ -353,6 +661,44 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             .header('Content-Disposition', `attachment; filename="${evidenceFilename(id)}"`)
             .send(bundle);
     });
+    // ── Acceptance gate read (Phase 6a) ─────────────────────────────────────────
+    // The QE evidence ledger's verdict + manifest for THIS run's repo, plus the
+    // gate's deny-dominates resolution of the workflow's acceptance requirement.
+    // Sits beside `/runs/:id/evidence` deliberately: evidence is what the RUN
+    // recorded about itself; acceptance is what the QE pipeline recorded about
+    // the repo the run worked on — two different systems of record, two routes.
+    //
+    // Always a 200 for a known run: "no ledger", "no verdict" and "FAIL" are
+    // real answers about the gate (each a deny with its own reason), not errors
+    // in the request. Only an unknown run 404s. `?qeRun=<id>` pins the read to
+    // one QE run's newest verdict instead of the repo's newest overall.
+    app.get(`${V}/runs/:id/acceptance`, async (req, reply) => {
+        const { id } = req.params;
+        const q = req.query;
+        const qeRunRaw = Array.isArray(q.qeRun) ? q.qeRun[0] : q.qeRun;
+        const qeRunId = qeRunRaw?.trim();
+        const views = await adapter.sessionsDetail();
+        const run = views.find((v) => v.session.id === id);
+        if (!run)
+            return reply.code(404).send({ error: 'Run not found' });
+        // `sessionsDetail()` patches workflow_id back to the definition name for
+        // BUILT-INS; runs of user-registered workflows still carry the instance id,
+        // so resolve by phase sequence over the full registry. A free-text run
+        // resolves to no workflow, which reads as "declares no requirement".
+        const workflow = resolveRunWorkflow(run, adapter.listWorkflows());
+        let repo = null;
+        if (run.session.repo_ref !== null) {
+            const repos = await adapter.listRepos();
+            repo = repos.find((r) => r.id === run.session.repo_ref) ?? null;
+        }
+        return buildAcceptanceView({
+            runId: id,
+            repo,
+            workflow,
+            gateEvents: qeGateEvents,
+            ...(qeRunId !== undefined && qeRunId !== '' ? { qeRunId } : {}),
+        });
+    });
     // The steering gate (§11.1). approve+amend = approve-with-steer; approve:false = reject (cancels).
     app.post(`${V}/runs/:id/gate`, async (req, reply) => {
         const { id } = req.params;
@@ -371,6 +717,17 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         }
         try {
             const status = await adapter.confirmGate(id, parsed.data.approve, parsed.data.amend);
+            // WHO approved/rejected — the gate-decision audit (task #88). The engine
+            // records THAT the gate resolved (interaction_requests / gateDecided);
+            // only this HTTP layer knows the authenticated principal behind it.
+            audit.record('gate.decided', actorOf(req), {
+                runId: id,
+                detail: {
+                    approve: parsed.data.approve,
+                    ...(parsed.data.amend !== undefined ? { amend: parsed.data.amend } : {}),
+                    status,
+                },
+            });
             return reply.send({ status });
         }
         catch (err) {
@@ -386,6 +743,7 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             return reply.code(404).send({ error: 'Run not found' });
         try {
             const status = await adapter.cancelRun(id);
+            audit.record('run.cancelled', actorOf(req), { runId: id, detail: { status } });
             return reply.send({ status });
         }
         catch (err) {
@@ -401,9 +759,14 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         if (!run)
             return reply.code(404).send({ error: 'Run not found' });
         try {
-            const status = run.session.status === 'awaiting_human'
-                ? await adapter.confirmGate(id, true)
-                : await adapter.resumeRun(id);
+            const gated = run.session.status === 'awaiting_human';
+            const status = gated ? await adapter.confirmGate(id, true) : await adapter.resumeRun(id);
+            // A resume of a gated run IS a gate approval — audit it as one, so the
+            // "who approved" trail has no side door (task #88).
+            audit.record(gated ? 'gate.decided' : 'run.resumed', actorOf(req), {
+                runId: id,
+                detail: gated ? { approve: true, via: 'resume', status } : { status },
+            });
             return reply.send({ status });
         }
         catch (err) {
@@ -424,6 +787,7 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             return reply.code(404).send({ error: 'Run not found' });
         try {
             await adapter.injectWorkerMessage(id, parsed.data.message, parsed.data.target);
+            audit.record('run.injected', actorOf(req), { runId: id, detail: { target: parsed.data.target } });
             return reply.send({ status: 'ok' });
         }
         catch (err) {
@@ -457,6 +821,28 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         if (run.session.status !== 'awaiting_human') {
             return reply.code(404).send({ error: 'No open gate for this run' });
         }
+        // DURABLE TRUTH FIRST (DES-PROJECT-001 §5.3): the engine persists the open prompt in
+        // `interaction_requests`, written in the same transaction as the `awaiting_human` pause —
+        // so a daemon restart reads it back directly instead of replaying the event log. The cache
+        // adopts the row (latency layer over durable truth — its comments finally true). The replay
+        // below stays as the FALLBACK, not just for engines predating the binding: a run parked
+        // BEFORE the engine grew the table is awaiting_human with no row, and answering 404 there
+        // would re-open FINDING-051 for exactly the runs mid-upgrade. Row → serve it; no row →
+        // fall through and let the log speak.
+        const durableRows = typeof adapter.interactionRequests === 'function'
+            ? await adapter.interactionRequests(id, 'open')
+            : null;
+        const durableGate = durableRows?.find((r) => r.kind === 'gate');
+        if (durableGate !== undefined) {
+            const entry = {
+                ord: durableGate.ord ?? 0,
+                prompt: durableGate.prompt,
+                lifecycle: 'open',
+                receivedAt: new Date(durableGate.created_at).toISOString(),
+            };
+            gateCache.adopt(id, entry);
+            return { runId: id, ...entry };
+        }
         const events = await adapter.runEvents(id);
         if (events === null) {
             // Now — and only now — 503 is the honest answer: this run really is holding for a human, and
@@ -491,6 +877,25 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         const ids = await adapter.sessions();
         if (!ids.includes(id))
             return reply.code(404).send({ error: 'Run not found' });
+        // Durable probe (DES-PROJECT-001 §5.3): `interaction_requests` reserves kind `elicitation`.
+        // The engine writes no elicitation rows yet (its elicitation surface is future work — the
+        // resolve path still answers 501), so this read is empty today; it exists so the cache is
+        // STRUCTURALLY a latency layer, and the day the engine writes the rows, restart survival
+        // holds here exactly as it does for gates, with no route change. Guarded like `runEvents`:
+        // a partial-stub adapter (tests) or a pre-0.6.0 addon simply has no durable half.
+        const durable = typeof adapter.interactionRequests === 'function'
+            ? await adapter.interactionRequests(id, 'open')
+            : null;
+        const pending = durable?.find((r) => r.kind === 'elicitation');
+        if (pending !== undefined) {
+            return {
+                runId: id,
+                elicitationId: pending.id,
+                message: pending.prompt,
+                options: null,
+                receivedAt: new Date(pending.created_at).toISOString(),
+            };
+        }
         return reply.code(404).send({ error: 'No pending elicitation for this run' });
     });
     const ElicitationRespondSchema = z
@@ -564,6 +969,10 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             return reply.code(code).send({ error: message(err) });
         }
         // 7. Done.
+        audit.record('elicitation.resolved', actorOf(req), {
+            runId: id,
+            detail: { elicitationId: taken.entry.elicitationId, action: body.action },
+        });
         return { status: 'resolved' };
     });
     // The durable history of one run (FINDING-057).
@@ -626,14 +1035,60 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         const claims = await adapter.listConformanceClaims();
         return { claims };
     });
-    app.get(`${V}/governance/coverage`, async () => {
+    // Normalize a `?repo=` query: Fastify parses a repeated `?repo=a&repo=b` into a `string[]` (take
+    // the first), and the value is TRIMMED so it's both validated and PASSED trimmed — a `?repo=%20x%20`
+    // must not pass the guard then miss the registry lookup on whitespace (Copilot #227).
+    const repoParam = (req) => {
+        const raw = req.query?.repo;
+        const first = Array.isArray(raw) ? raw[0] : raw;
+        const trimmed = first?.trim();
+        return trimmed ? trimmed : undefined;
+    };
+    // An unknown repo is the CALLER's error (404); a binding/parse failure is OURS (500). Don't collapse
+    // them (Copilot #227). Core spells the not-found case `no registered repo '<ref>'`.
+    const repoReadStatus = (msg) => (/no registered repo/i.test(msg) ? 404 : 500);
+    app.get(`${V}/governance/coverage`, async (req, reply) => {
+        // FINDING-009: with `?repo=<ref>`, report coverage over THAT repo's own code graph. The bare
+        // endpoint reads the daemon store and reports a vacuous `coverage: 1.0` that names no repo — the
+        // real gate lives per-repo. An unknown repo is an ERROR in core (never a silent vacuous report).
+        const repo = repoParam(req);
+        if (repo) {
+            try {
+                const report = await adapter.getCoverageReportForRepo(repo);
+                return { report };
+            }
+            catch (err) {
+                const msg = message(err);
+                return reply.code(repoReadStatus(msg)).send({ error: msg });
+            }
+        }
         const report = await adapter.getCoverageReport();
         return { report };
     });
+    app.get(`${V}/governance/graph`, async (req, reply) => {
+        // #122: node-count-by-kind summary of a repo's OWN code graph. Repo-scoped ONLY — there is no
+        // meaningful daemon-wide graph view (the daemon store holds run/governance nodes, not a repo's
+        // code graph), so a missing `?repo=` is a 400, an unknown repo a 404, and an engine/binding
+        // failure a 500 (not masked as 404).
+        const repo = repoParam(req);
+        if (!repo) {
+            return reply.code(400).send({ error: 'governance/graph requires a ?repo=<ref>' });
+        }
+        try {
+            const kinds = await adapter.getGraphKindsForRepo(repo);
+            return { kinds };
+        }
+        catch (err) {
+            const msg = message(err);
+            return reply.code(repoReadStatus(msg)).send({ error: msg });
+        }
+    });
     // ── Governance writes (crew#42) ────────────────────────────────────────────
     app.post(`${V}/governance/policies`, async (req, reply) => {
         try {
-            await adapter.upsertPolicy(req.body);
+            const policy = req.body;
+            await adapter.upsertPolicy(policy);
+            audit.record('governance.policy.upserted', actorOf(req), { detail: { id: policy?.id } });
             return { status: 'ok' };
         }
         catch (err) {
@@ -642,7 +1097,9 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
     });
     app.post(`${V}/governance/rules`, async (req, reply) => {
         try {
-            await adapter.upsertConformanceRule(req.body);
+            const rule = req.body;
+            await adapter.upsertConformanceRule(rule);
+            audit.record('governance.rule.upserted', actorOf(req), { detail: { id: rule?.id } });
             return { status: 'ok' };
         }
         catch (err) {
@@ -657,6 +1114,7 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             const existed = await adapter.retirePolicy(id);
             if (!existed)
                 return reply.code(404).send({ error: `policy '${id}' not found` });
+            audit.record('governance.policy.retired', actorOf(req), { detail: { id } });
             return { status: 'retired', id };
         }
         catch (err) {
@@ -669,6 +1127,7 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
             const existed = await adapter.retireConformanceRule(id);
             if (!existed)
                 return reply.code(404).send({ error: `conformance rule '${id}' not found` });
+            audit.record('governance.rule.retired', actorOf(req), { detail: { id } });
             return { status: 'retired', id };
         }
         catch (err) {
@@ -695,7 +1154,9 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         const workflow = adapter.getWorkflow(id);
         if (!workflow)
             return reply.code(404).send({ error: `workflow '${id}' not found` });
-        return { workflow };
+        // humanGates: the phases that will PAUSE for a person even under humanConfirm:none (core#208).
+        // Surfaced so an operator can see a workflow's gates BEFORE launching it (FINDING-023).
+        return { workflow, humanGates: humanGatePhaseIds(workflow) };
     });
     // Register (or replace) a user-authored workflow definition.
     // Validates, persists to ~/.wicked/workflows/<id>.json, hot-registers in the
@@ -710,6 +1171,7 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
         }
         try {
             const id = await adapter.registerWorkflow(body);
+            audit.record('workflow.registered', actorOf(req), { detail: { id } });
             return reply.code(201).send({ id, status: 'registered' });
         }
         catch (err) {
@@ -1071,14 +1533,41 @@ export function registerRoutes(app, adapter, gateCache, elicitationCache) {
                 return reply.code(400).send({ error: 'graphNodeLimit must be an integer between 20 and 500' });
             }
         }
+        if ('worker_config_root' in patch) {
+            const root = patch.worker_config_root;
+            if (typeof root !== 'string' || (root !== '' && !isAbsolute(root))) {
+                return reply.code(400).send({
+                    error: 'worker_config_root must be an absolute path, or "" for the default (~/.wicked-worker)',
+                });
+            }
+        }
         // Only allow known keys through.
-        const allowed = ['graphNodeLimit'];
+        const allowed = [
+            'graphNodeLimit',
+            'worker_config_root',
+        ];
         const safe = {};
         for (const key of allowed) {
             if (key in patch)
                 safe[key] = patch[key];
         }
-        return { settings: await adapter.updateSettings(safe) };
+        const settings = await adapter.updateSettings(safe);
+        // Re-apply the worker-config root to this process's env (seat sign-in). The engine reads
+        // WICKED_WORKER_HOME per worker spawn — never cached — so this alone makes the change live
+        // at the next spawn: no daemon restart, no engine restart.
+        applyWorkerConfigRoot(settings.worker_config_root);
+        audit.record('settings.updated', actorOf(req), { detail: { changed: Object.keys(safe) } });
+        return { settings };
+    });
+    // ── Projects (DES-PROJECT-001) — the 9-route experience-plane surface ────────
+    registerProjectRoutes(app, adapter, { ...projects, settings: projectSettings }, security);
+    // ── The wicked-interactive bridge, reverse-proxied (DES-MERGE-001 §5.3/§7.2) ──
+    // Mounted BESIDE the routes above and under the same `${V}` prefix, so it inherits one
+    // origin, one auth hook, and one CORS posture — the whole point of slice 1.
+    registerInteractiveProxy(app, adapter, {
+        settings: projectSettings,
+        pool: runtime.interactiveBridges ?? new InteractiveBridgePool({ log: (m) => app.log.warn(m) }),
+        log: (m) => app.log.warn(m),
     });
 }
 //# sourceMappingURL=routes.js.map