wicked-crew 0.7.29 → 0.7.31

package/dist/api/routes.d.ts.map

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

package/dist/api/routes.js

@@ -17,9 +17,13 @@ import { execCapped, ExecOutputTooLarge } from '../core/exec.js';
 import { callEstateTool, EstateMcpError } from '../core/estate-mcp-client.js';
 import { SeatHealthTracker } from './seat-health.js';
 import { applyWorkerConfigRoot, signedInHeuristic } from './seat-signin.js';
+import { chatSeatAdmission, seatStanding } from './seat-standing.js';
 import { ChatScopeIndex, chatScopeDeps, prepareChatScratch, removeChatScratch, resolveChatScope, } from './chat-scope.js';
 import { allowedRootsFor, isInsideRoot, openWithSystemDefault } from './open-path.js';
-import { InvalidDiffBaseError, NotARegularFileError, UnresolvableDiffBaseError, readFileCapped, worktreeDiff, } from './run-files.js';
+import { InvalidDiffBaseError, MERGE_BASE_LITERAL, NotARegularFileError, UnresolvableDiffBaseError, branchDiff, isPlainRef, readFileCapped, worktreeDiff, } from './run-files.js';
+import { DocRunIndex } from '../interactive/doc-run-index.js';
+import { listInteractiveDocs } from '../interactive/docs-index.js';
+import { TestSetIndex } from '../qe/test-sets.js';
 import { resolveProjectGraphBinding } from '../projects/graph.js';
 import { registerProjectRoutes } from '../projects/routes.js';
 import { registerCampaignRoutes } from '../campaigns/routes.js';
@@ -73,13 +77,6 @@ const STATUS_ORDER = {
 function sortActionableFirst(views) {
     return [...views].sort((a, b) => (STATUS_ORDER[a.session.status] ?? 9) - (STATUS_ORDER[b.session.status] ?? 9));
 }
-/**
- * `codeGraphDb(repo)` for a repo surface, or `null` after answering **503** — a CURRENT engine that
- * resolved no repo-graph root (`code_graph_root_unresolvable`, wicked-core#406) is a daemon-
- * environment fault, not a bad request and not Fastify's generic 500. The mapping is the shared
- * `codeGraphErrorStatus`; anything it does not classify rethrows unchanged (the stale-addon error
- * keeps its pre-existing shape here).
- */
 function codeGraphDbOr503(repo, reply) {
     try {
         return codeGraphDb(repo);
@@ -475,6 +472,10 @@ runtime = {}) {
     const guidanceIndex = runtime.guidanceIndex ?? new GuidanceIndex();
     const chatScopes = runtime.chatScopes ?? new ChatScopeIndex();
     const deliveryIndex = runtime.deliveryIndex ?? new DeliveryIndex();
+    // Wave 6: the doc↔run binding and the registered test sets — `createServer` injects the real
+    // ones; a directly-driven route set gets an empty index (every run `document_id: null`, no sets).
+    const docRuns = runtime.docRuns ?? new DocRunIndex(() => []);
+    const testSets = runtime.testSets ?? new TestSetIndex();
     const worktreeExists = runtime.worktreeExists ?? ((p) => existsSync(p));
     const vacuityProbes = {
         worktreeExists,
@@ -563,6 +564,9 @@ runtime = {}) {
     const decorateRun = (view) => {
         const conflictStrand = normalizeStranded(view);
         view.session.project_id = projects.index.projectOf(view.session.id) ?? null;
+        // Wave 6 (F-4R2-006): the interactive document this run answered, from the seams' handoff
+        // ledgers — `null` = genuinely not a document run, so the field is ALWAYS present on served runs.
+        view.session.document_id = docRuns.documentOf(view.session.id) ?? null;
         const retryOf = retryIndex.retryOfFor(view.session.id);
         if (retryOf !== undefined)
             view.session.retry_of = retryOf;
@@ -707,16 +711,33 @@ runtime = {}) {
     // 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 () => {
+    //
+    // Each seat ALSO carries its STANDING (F-2R2-009): `auth` re-reads `signed_in` for what it means
+    // (a `signed_out` codex is benched on its first ballot; a `not_required` opencode answers on its
+    // free tier), and `council_eligible` says what a council would do with the seat as far as the
+    // daemon can tell. `POST /chats` seats its defaults through the SAME standing, so the roster and
+    // the chat never disagree about a seat.
+    const rosterWithStanding = () => {
         const workerRoot = process.env['WICKED_WORKER_HOME'];
-        return {
-            roster: CoreAdapter.roster().map((seat) => ({
+        return CoreAdapter.roster().map((seat) => {
+            const key = String(seat.key);
+            const health = seatHealth.healthFor(key);
+            const signed = signedIn(key, workerRoot === '' ? undefined : workerRoot);
+            return {
                 ...seat,
-                health: seatHealth.healthFor(String(seat.key)),
-                signed_in: signedIn(String(seat.key), workerRoot === '' ? undefined : workerRoot),
-            })),
-        };
-    });
+                health,
+                signed_in: signed,
+                // The bench is THIS daemon's council evidence (councilSeatFailed, bounded window) — the
+                // prediction learns from what the engine actually did with the seat (#533 review, F-1).
+                ...seatStanding(seat, signed, health, seatHealth.councilBenchFor(key), 
+                // F-A45-006: the seat's OWN "no credential" report (a ballot's "No API key found", a
+                // worker's 401, an auth ACP fallback) overrides the file probe — `auth` flips, not only
+                // `council_eligible`, and the evidence rides on the wire.
+                seatHealth.authFailureFor(key)),
+            };
+        });
+    };
+    app.get(`${V}/roster`, async () => ({ roster: rosterWithStanding() }));
     // 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
@@ -861,26 +882,8 @@ runtime = {}) {
         if (resolved === null)
             return reply;
         const workdir = resolved.session.workdir;
-        if (typeof workdir !== 'string' || workdir.length === 0) {
-            return reply.code(409).send({ error: `run ${id} has no workdir — nothing to diff` });
-        }
-        if (!existsSync(workdir)) {
-            return reply.code(409).send({ error: `run ${id}'s workdir no longer exists: ${workdir}` });
-        }
-        // Narrowing is WORKTREE-scoped: a contained-but-outside-the-worktree path (extra write
-        // root / repo root) is a valid FILE read but has no meaning as a diff pathspec — rejected
-        // explicitly here rather than handing git a `../`-prefixed pathspec and surfacing its
-        // "outside repository" error as a 500 (Copilot, #305).
-        if (resolved.target !== undefined && !isInsideRoot(workdir, resolved.target)) {
-            return reply.code(400).send({
-                error: `\`path\` must be inside the run's worktree to diff: ${workdir}`,
-            });
-        }
-        const rel = resolved.target === undefined ? undefined : relative(workdir, resolved.target);
-        try {
-            return await worktreeDiff(workdir, rel, rawBase);
-        }
-        catch (err) {
+        /** The route's one error mapping, shared by the worktree and the branch reads. */
+        const diffError = (err) => {
             // Named 400s (§8.1): malformed base (not a plain ref) and well-formed-but-unresolvable
             // base are both client errors, each with its error name in the body — never a git 500.
             if (err instanceof InvalidDiffBaseError || err instanceof UnresolvableDiffBaseError) {
@@ -898,6 +901,75 @@ runtime = {}) {
                 });
             }
             return reply.code(500).send({ error: message(err) });
+        };
+        const worktreeLive = typeof workdir === 'string' && workdir.length > 0 && existsSync(workdir);
+        if (!worktreeLive) {
+            // Wave 6 (F-7R2-013): the engine reaps a completed run's worktree, and the run page went dark
+            // (`409 workdir no longer exists`). The run's WORK is not gone — it lives on the `wicked/<id>`
+            // branch of the registered repo, and the wave-6 engine records `run_branch` + `base_commit`
+            // on the session. Serve the diff from the BRANCH (`source: 'branch'`): the recorded branch
+            // (else `wicked/<id>`) against the recorded base (else its merge-base with the default
+            // branch), `?base=<ref>` overriding the base with a plain in-repo ref. Only when there is
+            // neither a worktree nor a branch does the 409 stand — and then it says so.
+            const repoRef = resolved.session.repo_ref;
+            const root = repoRef !== null ? await repoRootOf(repoRef) : undefined;
+            if (root !== undefined) {
+                const session = resolved.session;
+                const branch = typeof session.run_branch === 'string' && session.run_branch !== '' ? session.run_branch : `wicked/${id}`;
+                let base = typeof session.base_commit === 'string' && session.base_commit !== '' ? session.base_commit : null;
+                if (rawBase !== undefined && rawBase !== '' && rawBase !== MERGE_BASE_LITERAL) {
+                    if (!isPlainRef(rawBase)) {
+                        return reply.code(400).send({
+                            error: `InvalidDiffBaseError: \`base\` must be the literal '${MERGE_BASE_LITERAL}' or a plain git ref`,
+                        });
+                    }
+                    base = rawBase;
+                }
+                // Narrowing: a path under the (gone) worktree or under the repo root, made repo-relative.
+                let rel;
+                if (resolved.target !== undefined) {
+                    if (isInsideRoot(root, resolved.target))
+                        rel = relative(root, resolved.target);
+                    else if (typeof workdir === 'string' && workdir.length > 0 && isInsideRoot(workdir, resolved.target)) {
+                        rel = relative(workdir, resolved.target);
+                    }
+                    else {
+                        return reply.code(400).send({
+                            error: `\`path\` must be inside the run's worktree or its repository to diff: ${root}`,
+                        });
+                    }
+                }
+                try {
+                    const fromBranch = await branchDiff(root, branch, base, rel);
+                    if (fromBranch !== null)
+                        return fromBranch;
+                }
+                catch (err) {
+                    return diffError(err);
+                }
+            }
+            if (typeof workdir !== 'string' || workdir.length === 0) {
+                return reply.code(409).send({ error: `run ${id} has no workdir and no run branch — nothing to diff` });
+            }
+            return reply.code(409).send({
+                error: `run ${id}'s workdir no longer exists (${workdir}) and its run branch holds no commits — nothing to diff`,
+            });
+        }
+        // Narrowing is WORKTREE-scoped: a contained-but-outside-the-worktree path (extra write
+        // root / repo root) is a valid FILE read but has no meaning as a diff pathspec — rejected
+        // explicitly here rather than handing git a `../`-prefixed pathspec and surfacing its
+        // "outside repository" error as a 500 (Copilot, #305).
+        if (resolved.target !== undefined && !isInsideRoot(workdir, resolved.target)) {
+            return reply.code(400).send({
+                error: `\`path\` must be inside the run's worktree to diff: ${workdir}`,
+            });
+        }
+        const rel = resolved.target === undefined ? undefined : relative(workdir, resolved.target);
+        try {
+            return { ...(await worktreeDiff(workdir, rel, rawBase)), source: 'worktree' };
+        }
+        catch (err) {
+            return diffError(err);
         }
     });
     // Registered repos → target-repo picker.
@@ -974,7 +1046,10 @@ runtime = {}) {
         const input = {
             problem: b.problem,
             sessionId: b.sessionId ?? randomUUID(),
-            clisJson: b.clisJson ?? JSON.stringify(CoreAdapter.roster()),
+            // The default roster carries crew's STANDING (wave 6, the crew half of F-7R2-006): the adapter
+            // translates `council_eligible: false` into the engine's per-seat bench verdict at launch
+            // (`core/engine-roster.ts`), so a signed-out seat is never convened, never a judge.
+            clisJson: b.clisJson ?? JSON.stringify(rosterWithStanding()),
         };
         if (b.entityMode !== undefined)
             input.entityMode = b.entityMode;
@@ -1145,8 +1220,17 @@ runtime = {}) {
         // 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, limit } = req.query;
+        const { include, limit, doc } = req.query;
         const includeArchived = (Array.isArray(include) ? include : [include]).includes('archived');
+        // `?doc=<document id>` (wave 6, F-4R2-006): only the runs the interactive seams launched for
+        // that document — the doc↔run binding as a direct read (the run DTO carries `document_id`).
+        // A repeated `?doc` is an ambiguity, not a repetition — refused like a repeated `?limit`.
+        if (Array.isArray(doc)) {
+            return reply.code(400).send({ error: '`doc` may be given at most once' });
+        }
+        if (doc !== undefined && doc.trim() === '') {
+            return reply.code(400).send({ error: '`doc` must name a document id' });
+        }
         // `?limit=N` — the top N AFTER the actionable-first sort below, so a capped poll still sees
         // the runs that need a human before the terminal sediment. The default stays UNBOUNDED: the
         // param used to be read by nobody (silently ignored — the full payload regardless), so an
@@ -1169,9 +1253,10 @@ runtime = {}) {
             }
             cap = Number(limit);
         }
-        const visible = includeArchived
+        const unarchived = includeArchived
             ? views
             : views.filter((v) => v.session.archived_at == null);
+        const visible = doc === undefined ? unarchived : unarchived.filter((v) => docRuns.documentOf(v.session.id) === doc.trim());
         const ordered = sortActionableFirst(visible);
         return { runs: (cap !== undefined ? ordered.slice(0, cap) : ordered).map(decorateRun) };
     });
@@ -1559,26 +1644,47 @@ runtime = {}) {
                     .code(500)
                     .send({ error: `cannot prepare the chat's scratch root ${scope.cwd}: ${message(err)}` });
             }
-            // The default seats of a SCOPED chat are pre-filtered by admissibility (independent review,
-            // W5): the engine admits a seat to a scoped chat only when its ACP adapter asks permissions
-            // (`acp_input_governance`) or its record arms the kernel write floor (`os_sandbox`) — with the
-            // default roster that is claude and opencode — so a default project-scoped open does not show
-            // four refused seats. Explicit `clis` are passed through as asked; the engine refuses per seat
-            // with the reason.
+            // The DEFAULT seats are the roster seats the daemon's own admission admits (F-2R2-007,
+            // F-2R2-009): the seat's auth standing (a signed-out seat is refused up front, with the
+            // reason, instead of failing its first turn — the same predicate `GET /roster` reports as
+            // `council_eligible`) and, for a SCOPED chat, the engine's rule restated (only a seat whose
+            // ACP adapter asks permissions or whose record arms the kernel write floor can be held to
+            // read-only roots — with the default roster that is claude and opencode). Every seat dropped
+            // here is NAMED on the response (`refused`) and in the thread (`chatSeatRefused`), so a
+            // person can see why pi is missing. Explicit `clis` are passed through as asked; the engine
+            // refuses per seat with its reason, which is copied into `refused` too.
             const scoped = scope.kind !== 'none';
-            const roster = CoreAdapter.roster();
-            const clis = b.clis ??
-                roster
-                    .filter((s) => !scoped || s.acp?.acp_input_governance === true || s.acp?.os_sandbox === true)
-                    .map((s) => s.key)
-                    .filter((k) => typeof k === 'string');
+            const refused = [];
+            // The standing roster, read ONCE: the default admission below and the engine-drop
+            // attribution after `chatOpen` both consult it (F-A45-011).
+            const standing = rosterWithStanding();
+            const standingOf = (key) => standing.find((s) => String(s.key) === key);
+            let clis;
+            if (b.clis !== undefined) {
+                clis = b.clis;
+            }
+            else {
+                clis = [];
+                for (const seat of standing) {
+                    const key = String(seat.key);
+                    const admission = chatSeatAdmission(seat, seat.auth ?? 'unknown', scoped);
+                    if (admission.ok)
+                        clis.push(key);
+                    else
+                        refused.push({ cliKey: key, reason: admission.reason, source: admission.source });
+                }
+            }
             if (clis.length === 0) {
                 chatScopes.release(chatId, token);
                 removeChatScratch(scope.cwd, chatScopes.base);
                 return reply.code(409).send({
-                    error: 'no seat in the roster can be held to a scoped chat (an ACP adapter admitted to input ' +
-                        'governance, or `os_sandbox = true` on its [cli.acp] record); open the chat unscoped, or ' +
-                        'name seats with `clis`',
+                    error: (scoped
+                        ? 'no seat in the roster can be held to a scoped chat (an ACP adapter admitted to input ' +
+                            'governance, or `os_sandbox = true` on its [cli.acp] record) and take a turn; open the ' +
+                            'chat unscoped, sign a seat in, or name seats with `clis`'
+                        : 'no seat in the roster can take a turn (every seat is signed out); sign a seat in from ' +
+                            'the System page, or name seats with `clis`') + ' — see refused',
+                    refused,
                 });
             }
             try {
@@ -1586,6 +1692,48 @@ runtime = {}) {
                     codeGraphDb: engine.codeGraphDb,
                     readRoots: engine.readRoots,
                 });
+                // A REQUESTED seat the engine refused joins the same list, with the engine's reason.
+                for (const s of seats) {
+                    if (!s.ok)
+                        refused.push({ cliKey: s.cliKey, reason: s.error ?? 'the engine refused the seat', source: 'engine' });
+                }
+                // F-A45-011 (F-2R2-007 still open): a seat the engine DROPPED — absent from `seats`
+                // altogether, neither ok nor refused — used to vanish without a trace (the fresh rig's pi:
+                // default chips claude·pi·opencode, 201 `seats:[claude, opencode]`, `refused: []`). It was
+                // taken out by the council-bench / dispatch-timeout path, not by admission, so admission's
+                // list never named it. Every requested-or-defaulted seat that is not in `seats` is named
+                // here with the most specific cause the daemon knows: its own "no credential" report
+                // (`auth`), this daemon's council bench (`bench`), else the dispatch budget (`budget`).
+                for (const key of clis) {
+                    if (seats.some((s) => s.cliKey === key) || refused.some((r) => r.cliKey === key))
+                        continue;
+                    const st = standingOf(key);
+                    const authFailure = seatHealth.authFailureFor(key);
+                    if (authFailure !== null || st?.auth === 'signed_out') {
+                        refused.push({
+                            cliKey: key,
+                            reason: authFailure !== null
+                                ? `not seated — the seat itself reported no credential (${authFailure.source}: ${authFailure.detail}); sign it in from the System page`
+                                : 'not seated — signed out; sign it in from the System page',
+                            source: 'auth',
+                        });
+                    }
+                    else if (st?.council_bench !== undefined) {
+                        refused.push({
+                            cliKey: key,
+                            reason: `not seated — ${st.council_ineligible_reason ?? 'benched by this daemon’s recent councils'}`,
+                            source: 'bench',
+                        });
+                    }
+                    else {
+                        refused.push({
+                            cliKey: key,
+                            reason: 'not seated — the engine did not warm it within its dispatch budget (the seat timed out or ' +
+                                'was dropped at dispatch); check GET /roster and try again, or name seats with `clis`',
+                            source: 'budget',
+                        });
+                    }
+                }
                 // Nothing warmed (independent review, W1): the engine holds no pool row and has dropped the
                 // scope itself (no `chatClosed` will come) — report the PER-SEAT reasons, never an
                 // engine-version guess; the root goes, the id is free again.
@@ -1595,6 +1743,7 @@ runtime = {}) {
                     return reply.code(409).send({
                         error: `chat ${chatId}: no seat warmed (${seats.length} failed) — see seats`,
                         seats,
+                        refused,
                     });
                 }
                 // Honest scope (Copilot, #518): a SCOPED chat is a promise — the roots are read-only, the
@@ -1649,7 +1798,7 @@ runtime = {}) {
                         projectAttachError = message(err);
                     }
                 }
-                if (!chatScopes.set(chatId, scope, token)) {
+                if (!chatScopes.set(chatId, scope, token, refused)) {
                     // The reservation was cancelled while the open was in flight — an engine `chatClosed` or a
                     // `DELETE` for this id (Copilot, #518). Nothing was recorded; tear the chat down (engine
                     // session, scratch root, and the filing just made) instead of returning a stale 201.
@@ -1663,10 +1812,24 @@ runtime = {}) {
                         error: `chat ${chatId} was closed while it was being opened; open it again`,
                     });
                 }
+                // The thread learns of every refused seat the way it learns of everything else — a frame
+                // on /ws — AFTER the scope is published, so a reader never sees a refusal for a chat it
+                // cannot yet look up.
+                for (const r of refused) {
+                    runtime.broadcast?.({
+                        type: 'chatSeatRefused',
+                        chat: chatId,
+                        cliKey: r.cliKey,
+                        reason: r.reason,
+                        source: r.source,
+                        ...(b.projectId !== undefined ? { project_id: b.projectId } : {}),
+                    });
+                }
                 return reply.code(201).send({
                     chatId,
                     seats,
                     scope,
+                    refused,
                     ...(projectAttachError !== undefined ? { projectAttachError } : {}),
                 });
             }
@@ -1723,11 +1886,33 @@ runtime = {}) {
                 .send({ error: message(err) });
         }
     });
+    // ── Interactive documents, daemon-wide, WITHOUT spawning a bridge (wave 6, studio #263) ──────
+    // The per-project listing (`GET /projects/:id/interactive/api/docs`) asks the project's bridge —
+    // one `wicked-interactive serve` per project root, ≈60 s cold start — so a skin must never fan
+    // it out on mount. This reads what the bridge reads (every project's docs root, each slug child
+    // carrying a `versions.json`) plus what only the daemon knows (the seams that answered each doc
+    // and the runs they launched, from the handoff ledgers). `?includeRetired=1` lists tombstones.
+    app.get(`${V}/interactive/docs`, { config: { manifest: { responseType: 'InteractiveDocsListing', statusCodes: [200] } } }, async (req) => {
+        const q = req.query;
+        const flag = Array.isArray(q.includeRetired) ? q.includeRetired[0] : q.includeRetired;
+        return listInteractiveDocs({
+            adapter,
+            settings: projectSettings,
+            docRuns,
+            includeRetired: flag === '1' || flag === 'true',
+        });
+    });
     app.get(`${V}/chats/:id`, { config: { manifest: { responseType: 'ChatDetailResponse', statusCodes: [200, 400] } } }, async (req, reply) => {
         const { id } = req.params;
         try {
-            // The scope recorded at open (crew#502) — `null` for a chat this daemon did not open.
-            return { chatId: id, seats: await adapter.chatSeats(id), scope: chatScopes.get(id) ?? null };
+            // The scope recorded at open (crew#502) — `null` for a chat this daemon did not open — and
+            // the seats refused at open (F-A45-011), so the studio's admission copy survives a reload.
+            return {
+                chatId: id,
+                seats: await adapter.chatSeats(id),
+                scope: chatScopes.get(id) ?? null,
+                refused: chatScopes.refusedOf(id) ?? null,
+            };
         }
         catch (err) {
             return reply.code(400).send({ error: message(err) });
@@ -2008,11 +2193,39 @@ runtime = {}) {
         const run = views.find((v) => v.session.id === id);
         if (!run)
             return reply.code(404).send({ error: 'Run not found' });
-        if (run.session.status !== 'executing') {
+        // Wave 6 (F-7R2-007 root fix): a run PARKED at a gate on a dead seat — the stall watchdog's
+        // escalation gate, or a verdict escalation — used to answer 409 here, so the studio's control
+        // needed two calls (approve, then race the engine's re-dispatch of the same dead seat with a
+        // reassign). The ENGINE's `reassign_unit` accepts ONLY an Executing run (wicked-core actor.rs:
+        // "run X is not Executing (status: AwaitingHuman)") — there is no reassign-in-place for a gated
+        // run — so this route performs APPROVE-THEN-REASSIGN in one call: the approve resumes the run
+        // (the engine re-dispatches the cursor unit to its current seat), and the reassign IMMEDIATELY
+        // supersedes that turn (cancels its epoch, closes the seat's session, bumps the attempt) and
+        // re-dispatches to the requested seat or the council's pick. The dead seat is dispatched for
+        // the gap between the two engine calls — a bounded window the engine contract leaves open (a
+        // reassign-as-approval engine op would close it; documented in the PR). Audited as BOTH a gate
+        // decision (`via: 'reassign'`) and a reassign, so the "who approved" trail has no side door.
+        // A steering-author propose gate is NOT approvable this way: its approve LANDS the proposal
+        // through `POST /runs/:id/gate` (crew#388), and a reassign is not a review of the rules.
+        const gated = run.session.status === 'awaiting_human';
+        if (run.session.status !== 'executing' && !gated) {
             return reply.code(409).send({
                 error: `run ${id} is ${run.session.status}, not executing — only an executing run has a cursor unit to reassign`,
             });
         }
+        if (gated && typeof adapter.confirmGate !== 'function') {
+            // A partial adapter (a directly-driven route set) cannot approve the gate on the caller's
+            // behalf — say so by name, never a TypeError dressed as a refusal.
+            return reply.code(409).send({
+                error: `run ${id} is awaiting_human, not executing — the engine reassigns only an executing run, and ` +
+                    `this build cannot approve the gate on your behalf (no confirmGate); approve via POST /runs/${id}/gate, then reassign`,
+            });
+        }
+        if (gated && typeof adapter.listWorkflows === 'function' && isSteeringAuthorRun(run, adapter.listWorkflows())) {
+            return reply.code(409).send({
+                error: `run ${id} is awaiting a steering-author propose gate — approve or reject it via POST /runs/${id}/gate (the approve lands the proposal); reassign is not a review of the rules`,
+            });
+        }
         const requestedCli = parsed.data.cli;
         if (requestedCli !== undefined) {
             const pool = Array.isArray(run.session.clis) ? run.session.clis : [];
@@ -2025,12 +2238,24 @@ runtime = {}) {
         const cursor = resolveCursorUnit(run);
         const ord = cursor?.ord ?? run.session.unit_ix;
         try {
+            if (gated) {
+                const status = await adapter.confirmGate(id, true);
+                audit.record('gate.decided', actorOf(req), {
+                    runId: id,
+                    detail: { approve: true, via: 'reassign', status },
+                });
+            }
             await adapter.reassignUnit(id, ord, requestedCli ?? null);
             audit.record('run.reassigned', actorOf(req), {
                 runId: id,
-                detail: { ord, ...(requestedCli !== undefined ? { cli: requestedCli } : {}) },
+                detail: { ord, ...(requestedCli !== undefined ? { cli: requestedCli } : {}), ...(gated ? { approved: true } : {}) },
+            });
+            return reply.send({
+                status: 'ok',
+                ord,
+                ...(requestedCli !== undefined ? { cli: requestedCli } : {}),
+                ...(gated ? { approved: true } : {}),
             });
-            return reply.send({ status: 'ok', ord, ...(requestedCli !== undefined ? { cli: requestedCli } : {}) });
         }
         catch (err) {
             return reply.code(409).send({ error: message(err) });
@@ -2791,7 +3016,7 @@ runtime = {}) {
             return reply.code(404).send({ error: 'Requirement not found' });
         return { requirement: detail };
     });
-    app.get(`${V}/repos/:id/graph`, async (req, reply) => {
+    app.get(`${V}/repos/:id/graph`, { config: { manifest: { responseType: 'RepoGraphResponse', statusCodes: [200, 404, 500, 503] } } }, async (req, reply) => {
         const { id } = req.params;
         const repos = await adapter.listRepos();
         const repo = repos.find((r) => r.id === id);
@@ -2801,7 +3026,17 @@ runtime = {}) {
         if (dbPath === null)
             return reply;
         if (!existsSync(dbPath)) {
-            return reply.send({ graph: null });
+            // `graph: null` alone cannot tell "not indexed" from "empty" (F-2R2-005): say WHY, with the
+            // same finding text the repos wire carries when the engine has one.
+            const finding = (repo.findings ?? []).find((f) => f.code === 'in_tree_code_graph_ignored' || f.code === 'code_graph_root_unresolvable');
+            const unbuilt = {
+                graph: null,
+                reason: finding?.message ??
+                    `no code graph has been built for '${repo.name}' yet (nothing at ${dbPath}) — run onboarding ` +
+                        `(POST /api/v1/repos/${repo.id}/onboard) to index it`,
+                ...(finding !== undefined ? { finding } : {}),
+            };
+            return reply.send(unbuilt);
         }
         try {
             const settings = await adapter.getSettings();
@@ -2822,13 +3057,14 @@ runtime = {}) {
             });
             const raw = JSON.parse(stdout);
             const fileCount = new Set(raw.nodes.map((n) => n.file)).size;
-            return reply.send({
+            const built = {
                 graph: {
                     nodes: raw.nodes,
                     edges: raw.edges,
                     stats: { nodeCount: raw.nodes.length, edgeCount: raw.edges.length, fileCount },
                 },
-            });
+            };
+            return reply.send(built);
         }
         catch (err) {
             return reply.code(500).send({ error: message(err) });
@@ -3442,8 +3678,14 @@ runtime = {}) {
     registerCampaignRoutes(app, adapter, {
         audit,
         actorOf,
-        roster: () => CoreAdapter.roster(),
+        // The roster WITH crew's standing (F-086 — parity with POST /runs and POST /testing/*): the
+        // adapter turns `council_eligible` into the engine's per-seat bench at launch, per campaign
+        // node (`core/engine-roster.ts` `engineCampaignDef`), so a signed-out seat is never convened
+        // by a campaign node either.
+        roster: () => rosterWithStanding(),
         groupIndex,
+        // Wave 6 (F-7R2-014): the registered test sets ride beside the campaigns + groups.
+        testSets,
         deliveryUrlFor: (runId) => deliveryIndex.urlFor(runId),
         vacuity: vacuityProbes,
         // A non-probe derivation throw in the rollup is a defect — error level, loud in diagnostics.
@@ -3460,7 +3702,9 @@ runtime = {}) {
     registerGovernanceSteeringRoutes(app, adapter, {
         audit,
         actorOf,
-        roster: () => CoreAdapter.roster(),
+        // Standing too (F-086 parity): the steering-author run launches through `launchRun`, whose
+        // roster translation (`engineRosterJson`) already benches `council_eligible: false` seats.
+        roster: () => rosterWithStanding(),
         // So the steering-author run's `run.launched` entry stamps `created_at` live too (Copilot #466).
         runTimingIndex,
     });
@@ -3472,8 +3716,12 @@ runtime = {}) {
     registerTestingRoutes(app, adapter, {
         audit,
         actorOf,
-        roster: () => CoreAdapter.roster(),
+        // The roster WITH crew's standing (wave 6): the adapter turns `council_eligible` into the
+        // engine's per-seat bench at launch, and the author response's `plan.seats` reads it.
+        roster: () => rosterWithStanding(),
         projects: { bus: projects.bus, index: projects.index },
+        // The author launch files each run under its repo's `qe-tests-<repo>` label (F-7R2-014).
+        groupIndex,
         // So the recon fan's `run.launched` entries stamp `created_at` live too (Copilot #466), not
         // just after a restart re-hydrates the trail.
         runTimingIndex,