wicked-crew 0.7.40 → 0.7.45

package/dist/api/server.js

@@ -2,7 +2,7 @@ import Fastify from 'fastify';
 import fastifyWebsocket from '@fastify/websocket';
 import fastifyStatic from '@fastify/static';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve as resolvePath } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { registerRoutes } from './routes.js';
 import { ErrorRing, teeStreamWithErrorRing } from './diagnostics.js';
@@ -16,17 +16,17 @@ import { GroupIndex } from './group-index.js';
 import { RunTimingIndex, recordRunLaunched } from './run-timing-index.js';
 import { GuidanceIndex } from './guidance-index.js';
 import { ChatScopeIndex, reapStaleChatNamespaces } from './chat-scope.js';
-import { DeliveryIndex, deliverUnitOf, gitRunBranchIsEmpty, gitWorktreeIsClean, prUrlFrom, canDeliverResolver, } from './delivery-index.js';
+import { chatCitationDeps, citationsFrame, verifyCitations, } from './chat-citations.js';
+import { DeliveryIndex, deliverUnitOf, gitRunBranchIsEmpty, gitWorktreeIsClean, deliveryRecordFrom, canDeliverResolver, } from './delivery-index.js';
+import { DeliveryFreeze } from './delivery-freeze.js';
 import { DeliveryDerivationCache } from './delivery-cache.js';
 import { coreUnitId } from './evidence.js';
 import { registerClient, broadcast } from '../events/bus.js';
 import { TerminalHub, registerTerminalWs } from '../events/terminals.js';
-import { QeGateCache, startQeGateSubscriber } from '../qe/gate-events.js';
 import { INTERACTIVE_DRAFT_WORKFLOW_DEF, startInteractiveDraftSubscriber } from '../interactive/draft-events.js';
 import { INTERACTIVE_EDIT_WORKFLOW_DEF, startInteractiveEditSubscriber } from '../interactive/edit-events.js';
 import { INTERACTIVE_CHAT_WORKFLOW_DEF, startInteractiveChatSubscriber } from '../interactive/chat-events.js';
 import { PhaseSkillArming, RunSkillGapIndex } from '../skills/phase-skill-gaps.js';
-import { startInteractiveDemoSubscriber } from '../interactive/demo-events.js';
 import { resolveProjectInteractiveRoot } from '../interactive/bridge-root.js';
 import { sweepDocLedgers } from '../interactive/doc-ledger-sweep.js';
 import { DocRunIndex } from '../interactive/doc-run-index.js';
@@ -34,8 +34,18 @@ import { TestSetIndex, registerTestSetForRun } from '../qe/test-sets.js';
 import { DocGroundingStore } from '../interactive/doc-grounding.js';
 import { ProjectSettingsStore } from '../projects/settings.js';
 import { crewStateHome } from '../projects/state-home.js';
+import { homedir } from 'node:os';
+import { discoverMcpServers } from '../mcp/discovery.js';
+import { probeMcpServer } from '../mcp/probe.js';
+import { budgetFromEnv, MCP_CALL_COMPLETED, McpBroker } from '../mcp/broker.js';
+import { McpCallRecordFile } from '../mcp/call-records.js';
+import { emitOnBus } from '../core/bus.js';
+import { McpRegistry } from '../mcp/registry.js';
+import { McpRegistryStore } from '../mcp/registry-store.js';
+import { platformSecretStore } from '../mcp/secrets.js';
 import { startProjectBus, MEMBERSHIP_ATTACHED, membershipAttachedKey } from '../projects/events.js';
 import { startInteractiveWsRelay, registerInteractiveEventRoutes } from '../interactive/ws-relay.js';
+import { startTeamWsRelay } from '../team/ws-relay.js';
 import { MembershipIndex } from '../projects/membership-index.js';
 import { writeRunEvidencePointer } from '../projects/charter.js';
 import { engineBenchesUnclassifiedSeats, CoreAdapter } from '../core/adapter.js';
@@ -48,6 +58,15 @@ import { ChatTranscriptStore } from './chat-transcripts.js';
 import { sweepDeliveredWorktree } from './worktree-sweep.js';
 import { installEndpointManifestHook } from './endpoint-manifest.js';
 import { WorkerStallWatchdog } from './stall-watchdog.js';
+import { RunLivenessSampler } from './run-liveness.js';
+import { resumeRunningCampaigns } from '../campaign/boot-resume.js';
+import { StandingOrderStore } from '../standing-orders/store.js';
+import { StandingOrderEvaluator } from '../standing-orders/evaluator.js';
+import { registerStandingOrderRoutes } from '../standing-orders/routes.js';
+import { seatParser } from '../standing-orders/parse.js';
+import { registerGateHistoryRoute, runBand, runPreset, runProject } from '../standing-orders/history.js';
+import { busRows, openPlanGateRisk } from '../team/routes.js';
+import { isSteeringAuthorRun } from './steering-landing.js';
 import { applyWorkerConfigRoot } from './seat-signin.js';
 import { registeredSkillRefs } from '../skills/core-closure.js';
 import { assertSkillsRootFenced } from '../skills/root-fence.js';
@@ -95,9 +114,11 @@ export async function createServer(adapter, options) {
     // test); costs one array push per route at boot, nothing per request.
     app.decorate('endpointManifest', installEndpointManifestHook(app));
     const gateCache = new GateCache();
+    // Standing orders (behaviour 10): armed once the routes (and so THE gate decision path) exist;
+    // the event relays above it read it late-bound.
+    let standingOrderEvaluator = null;
     const elicitationCache = new ElicitationCache();
     const terminals = new TerminalHub();
-    const qeGateCache = new QeGateCache();
     // Per-seat runtime health (crew#274): folded from the single CoreEvent subscription below,
     // surfaced on GET /roster, recovered by the low-frequency probe armed further down.
     const seatHealth = new SeatHealthTracker({
@@ -311,6 +332,10 @@ export async function createServer(adapter, options) {
     // trail's `run.delivered` entries so `session.delivery` survives a daemon restart.
     const deliveryIndex = new DeliveryIndex();
     await deliveryIndex.hydrate(audit, (m) => app.log.warn(m));
+    // Freeze deliveries (idea 15): same durable pattern — the trail's `deliveries.frozen` /
+    // `deliveries.unfrozen` entries, so a restart keeps the freeze on.
+    const deliveryFreeze = new DeliveryFreeze();
+    await deliveryFreeze.hydrate(audit, (m) => app.log.warn(m));
     // Wave 6 (F-7R2-014): the test sets `qe-author-tests` runs registered — same durable pattern,
     // hydrated from the trail's `testing.testset.registered` entries, fed at each terminal frame.
     const testSets = new TestSetIndex();
@@ -337,7 +362,7 @@ export async function createServer(adapter, options) {
     const deliveryCache = new DeliveryDerivationCache({
         listViews: () => adapter.sessionsDetail(),
         probes: vacuityProbes,
-        isDelivered: (runId) => deliveryIndex.urlFor(runId) !== undefined,
+        isDelivered: (runId) => deliveryIndex.isDelivered(runId),
         canDeliver,
         log: (m) => app.log.warn(m),
         // Non-probe derivation throws are defects — error level, so the diagnostics ring sees them.
@@ -365,7 +390,7 @@ export async function createServer(adapter, options) {
         try {
             // Resume/retry re-terminals: already resolved once, and a terminal run's PR URL never
             // changes — never re-read, never double-write the trail.
-            if (deliveryIndex.urlFor(runId) !== undefined)
+            if (deliveryIndex.isDelivered(runId))
                 return;
             const views = await adapter.sessionsDetail();
             const view = views.find((v) => v.session.id === runId);
@@ -380,28 +405,35 @@ export async function createServer(adapter, options) {
             const output = await adapter.workOutput(coreUnitId(runId, unit));
             if (output === null)
                 return;
-            const url = prUrlFrom(output);
-            if (url === null)
+            // A PR URL, or (N1) a push-only delivery to an origin gh cannot resolve to GitHub — a
+            // delivery too, so the run reads `delivery: 'pushed'` and never `'stranded'`.
+            const record = deliveryRecordFrom(output);
+            if (record === null)
                 return;
             // The durable record first, then the read-side index — the same write order as
             // `guidance.set`, so the index can only LAG a crash (rehydrated at next boot), never
             // hold a record the trail does not.
-            audit.record('run.delivered', DAEMON_ACTOR, {
-                runId,
-                detail: { url },
-            });
-            deliveryIndex.set(runId, url);
+            audit.record('run.delivered', DAEMON_ACTOR, { runId, detail: record });
+            if ('url' in record)
+                deliveryIndex.set(runId, record.url);
+            else
+                deliveryIndex.setPushed(runId, record.pushed);
         }
         catch (err) {
             app.log.warn(`[runs] delivery resolution for ${runId} failed (field absent until restart replays the trail): ${err instanceof Error ? err.message : String(err)}`);
         }
     };
+    // Crew reaches a bus only through the engine that holds it (wicked-core#631, core/bus.ts): a seam
+    // with no bus db of its own reads and writes the one this adapter handed its engine.
+    const engineBusDb = typeof adapter.busDbPath === 'string' ? adapter.busDbPath : undefined;
+    const busOf = (dbPath) => {
+        const bus = dbPath ?? engineBusDb;
+        return bus !== undefined ? { dbPath: bus } : {};
+    };
     const projectBus = options?.projectEvents?.disabled === true
         ? null
         : await startProjectBus({
-            ...(options?.projectEvents?.dbPath !== undefined
-                ? { dbPath: options.projectEvents.dbPath }
-                : {}),
+            ...busOf(options?.projectEvents?.dbPath),
             ...(options?.projectEvents?.pollIntervalMs !== undefined
                 ? { pollIntervalMs: options.projectEvents.pollIntervalMs }
                 : {}),
@@ -422,7 +454,6 @@ export async function createServer(adapter, options) {
     // is still preferred over its file once armed; the seams themselves arm further down.
     let draftSub = null;
     let editSub = null;
-    let demoSub = null;
     let chatSub = null;
     /** The crew-side half of deleting an interactive doc (crew#338): drop the doc's replay-dedup
      *  rows from all four handoff ledgers — the draft leg keys by DOCUMENT ID ("one first draft
@@ -433,11 +464,11 @@ export async function createServer(adapter, options) {
      *  override, crew#353/#398). Never throws — the report says what happened. */
     const crewStateDir = crewStateHome();
     // F-046: the create-time doc → subject-repo bindings, shared by the proxy (records) and the
-    // draft/demo seams (read). The store keeps NO file of its own — each binding is a
+    // draft seam (read). The store keeps NO file of its own — each binding is a
     // `crew-grounding.json` sidecar beside the doc's `versions.json` under the project's docs root
     // (doc-grounding.ts says why not the state home: core's fence refuses unregistered entries).
     const docGrounding = new DocGroundingStore();
-    /** The four seams' ledgers, read AT USE TIME (a seam that armed after this closure was built is
+    /** The three seams' ledgers, read AT USE TIME (a seam that armed after this closure was built is
      *  still preferred over its file) — shared by the doc-delete sweep and the doc↔run index. */
     const docLedgerSources = () => [
         {
@@ -458,12 +489,6 @@ export async function createServer(adapter, options) {
             path: options?.interactiveChatEvents?.ledgerPath ??
                 join(crewStateDir, 'interactive-chat-ledger.json'),
         },
-        {
-            name: 'demo',
-            ledger: demoSub?.ledger,
-            path: options?.interactiveDemoEvents?.ledgerPath ??
-                join(crewStateDir, 'interactive-demo-ledger.json'),
-        },
     ];
     const dropDocLedgerRows = (documentId) => sweepDocLedgers(documentId, docLedgerSources());
     // Wave 6 (F-4R2-006 root fix): the document ↔ run binding as a direct read off the SAME four
@@ -477,9 +502,7 @@ export async function createServer(adapter, options) {
     const interactiveRelay = options?.interactiveWsRelay?.disabled === true
         ? null
         : await startInteractiveWsRelay({
-            ...(options?.interactiveWsRelay?.dbPath !== undefined
-                ? { dbPath: options.interactiveWsRelay.dbPath }
-                : {}),
+            ...busOf(options?.interactiveWsRelay?.dbPath),
             ...(options?.interactiveWsRelay?.pollIntervalMs !== undefined
                 ? { pollIntervalMs: options.interactiveWsRelay.pollIntervalMs }
                 : {}),
@@ -506,6 +529,31 @@ export async function createServer(adapter, options) {
             await interactiveRelay.stop();
         });
     }
+    // The team relay (DES-TEAMING-002 §4.5): every team row the engine publishes becomes a
+    // `teamEvent` frame on the same /ws socket, tagged with the run's project. Only where the engine
+    // has a bus: no bus, no team rows.
+    const teamBusDb = engineBusDb;
+    const teamRelay = options?.teamWsRelay?.disabled === true || teamBusDb === undefined
+        ? null
+        : await startTeamWsRelay({
+            dbPath: teamBusDb,
+            projectOf: (runId) => membershipIndex.projectOf(runId),
+            // Standing orders (behaviour 10) read the same team rows: a finding can wake the operator.
+            broadcast: (frame) => {
+                broadcast(frame);
+                void standingOrderEvaluator?.onTeamFrame(frame);
+            },
+            ...(options?.teamWsRelay?.pollIntervalMs !== undefined
+                ? { pollIntervalMs: options.teamWsRelay.pollIntervalMs }
+                : {}),
+            log: (m) => app.log.warn(m),
+        });
+    if (teamRelay !== null) {
+        app.log.info('team /ws relay armed (team rows → teamEvent)');
+        app.addHook('onClose', async () => {
+            await teamRelay.stop();
+        });
+    }
     /** The post-commit half of a project-FILED launch, shared with the launch route (§2.2/§4):
      *  the engine already attached the crew.run membership atomically with the launch — here we
      *  tag future /ws frames and announce the attach on the project bus. */
@@ -520,34 +568,16 @@ export async function createServer(adapter, options) {
     /** The docs root a project's interactive docs live under — the SAME per-project resolution
      *  the project routes and the interactive proxy use (DES-MERGE-001 §7.1/§7.2; partitioned
      *  per project since crew#472, with an event that carries no `project_id` belonging to
-     *  Unfiled). Shared by the edit seam (demo-kind gate, CREW-UX-9), the demo seam (spec
-     *  install + manifest reads), and the chat seam. The partition is containment-checked on
+     *  Unfiled). Shared by the edit seam (demo-kind gate) and the chat seam. The partition is containment-checked on
      *  REAL paths here exactly as the routes check it (crew#474 — one walk, `bridge-root.ts`):
      *  a symlinked `projects/<id>` throws `InteractivePartitionRefusedError` into the seam's
      *  handler (logged by its `onError`, the event unanswered — fail closed) instead of being
      *  followed into another project's docs; the seams only READ under a root the routes
      *  materialized, so a missing partition is returned as spelled and nothing is created. */
     const interactiveDocsRoot = (projectId) => resolveProjectInteractiveRoot(projectId, projectId !== undefined ? projectSettings.get(projectId) : null);
-    // Arm the opt-in QE gate-event subscription (crew's bus seam). Failure to
-    // arm is LOUD but non-fatal: the acceptance route never depends on the bus.
-    if (options?.qeGateEvents?.enabled === true) {
-        const { dbPath, pollIntervalMs } = options.qeGateEvents;
-        const sub = await startQeGateSubscriber(qeGateCache, {
-            ...(dbPath !== undefined ? { dbPath } : {}),
-            ...(pollIntervalMs !== undefined ? { pollIntervalMs } : {}),
-            log: (m) => app.log.warn(m),
-            logError: (m) => app.log.error(m),
-        });
-        if (sub !== null) {
-            app.log.info(`qe gate-event subscription armed (filter wicked.qe.**)`);
-            app.addHook('onClose', async () => {
-                await sub.stop();
-            });
-        }
-    }
     // ── A STUB ENGINE NEVER ANSWERS ANOTHER PRODUCT'S TRAFFIC (crew#309) ────────────────────────
     //
-    // The four seams below are ANSWERERS: each opens a durable wicked-bus subscription and replies
+    // The four seams below are ANSWERERS: each taps the bus (core/bus.ts) and replies
     // to wicked-interactive's events by LAUNCHING A GOVERNED RUN. Under `serve --stub` the engine is
     // `Core.spawnStub` — a `StubDispatcher` (every seat votes for the first roster option, no
     // subprocess) plus a `StubStepRunner` (fixed text, no CLI) — so such a run resolves every phase
@@ -556,7 +586,8 @@ export async function createServer(adapter, options) {
     // approved outline — moving on…", "Gate approved the draft…". Nothing ran. Nothing was written.
     // Two gate approvals were announced anyway.
     //
-    // Worse than fabricating locally: the durable cursor is keyed by PLUGIN NAME
+    // Worse than fabricating locally (until crew#679 moved the seams to in-memory taps): the durable
+    // cursor was keyed by PLUGIN NAME
     // (`wicked-crew-interactive-draft`), so on the shared bus a stub daemon and the production
     // daemon are ONE consumer group — a frame claimed by the stub is a frame the real daemon never
     // sees. That is what wicked-crew#309 recorded: bus rows 242632–242643 carry a complete draft
@@ -567,8 +598,8 @@ export async function createServer(adapter, options) {
     // convening, which is the StubDispatcher's signature; the real runs 5 minutes later took ~95s to
     // vote and split their seats (`pi` for outline, `claude` for draft).
     //
-    // So: refuse to arm, loudly. The deny is scoped to the ANSWERERS on purpose — the QE seam above
-    // only fills a freshness cache and the project seam only relays, neither launches work nor
+    // So: refuse to arm, loudly. The deny is scoped to the ANSWERERS on purpose — the project seam
+    // only relays, neither launches work nor
     // narrates governance, so neither can fabricate a verdict. Offline/deterministic runs are NOT
     // lost by this: every harness in `e2e/` already does the correct thing, keeping the REAL engine
     // (`stub: false`) and registering a scripted stub SEAT in the roster — which exercises planning,
@@ -593,7 +624,7 @@ export async function createServer(adapter, options) {
     if (options?.interactiveDraftEvents?.enabled === true && !refuseStubSeam('interactive-draft')) {
         const o = options.interactiveDraftEvents;
         draftSub = await startInteractiveDraftSubscriber(adapter, {
-            ...(o.dbPath !== undefined ? { dbPath: o.dbPath } : {}),
+            ...busOf(o.dbPath),
             ...(o.pollIntervalMs !== undefined ? { pollIntervalMs: o.pollIntervalMs } : {}),
             ...(o.heartbeatMs !== undefined ? { heartbeatMs: o.heartbeatMs } : {}),
             ...(o.ledgerPath !== undefined ? { ledgerPath: o.ledgerPath } : {}),
@@ -627,14 +658,10 @@ export async function createServer(adapter, options) {
     // Arm the opt-in interactive STRUCTURAL-edit answering seam (task #86 final leg). Same
     // posture as the draft seam: failure to arm is LOUD but non-fatal — interactive's assist
     // loop is the fallback answerer, and this daemon must boot on a machine whose bus is broken.
-    // `demoSub` (declared above) is deliberately still null here: the demo seam arms after (it
-    // must, so the per-doc serialization contract can see the edit seam's in-flight set), but the
-    // edit seam's demo-kind gate needs to know at EVENT time whether the demo seam actually came
-    // up — a closure over the binding reads the settled value; a boolean captured here would not.
     if (options?.interactiveEditEvents?.enabled === true && !refuseStubSeam('interactive-edit')) {
         const o = options.interactiveEditEvents;
         editSub = await startInteractiveEditSubscriber(adapter, {
-            ...(o.dbPath !== undefined ? { dbPath: o.dbPath } : {}),
+            ...busOf(o.dbPath),
             ...(o.pollIntervalMs !== undefined ? { pollIntervalMs: o.pollIntervalMs } : {}),
             ...(o.heartbeatMs !== undefined ? { heartbeatMs: o.heartbeatMs } : {}),
             ...(o.ledgerPath !== undefined ? { ledgerPath: o.ledgerPath } : {}),
@@ -645,11 +672,9 @@ export async function createServer(adapter, options) {
             // The quality-floor skill gate (draft-skill.ts): stamped only when the published snapshot holds it;
             // the arm-time answer is recorded for /diagnostics (crew#661).
             skillHeld: phaseSkills.probe('interactive-edit', INTERACTIVE_EDIT_WORKFLOW_DEF, skillHeld),
-            // The demo-kind gate (CREW-UX-9): a demo doc's step feedback is the demo seam's — but
-            // only when that seam is actually up. Probed per event (the demo seam arms below), so an
-            // un-armed demo seam gets an honest error status instead of a silent, unanswerable drop.
+            // The demo-kind gate: a demo doc's step feedback is declined with an honest error status
+            // (demos are made by the Demo experience's `demo` preset now, studio#373).
             resolveDocsRoot: o.resolveDocsRoot ?? interactiveDocsRoot,
-            demoSeamArmed: () => demoSub !== null,
             onRunFiled: fileRun,
             log: (m) => app.log.warn(m),
             logError: (m) => app.log.error(m),
@@ -665,37 +690,6 @@ export async function createServer(adapter, options) {
             });
         }
     }
-    // Arm the opt-in interactive DEMO answering seam (CREW-UX-9 — the retired assist agent's
-    // Step 8). Same posture as the sibling seams: failure to arm is LOUD but non-fatal — a demo
-    // doc then keeps its placeholder, and this daemon must boot on a machine whose bus is
-    // broken. Armed beside the edit seam because the two split `feedback.processed` by the doc
-    // manifest's kind (demo → re-author the spec here; everything else → structural edit there).
-    if (options?.interactiveDemoEvents?.enabled === true && !refuseStubSeam('interactive-demo')) {
-        const o = options.interactiveDemoEvents;
-        demoSub = await startInteractiveDemoSubscriber(adapter, {
-            ...(o.dbPath !== undefined ? { dbPath: o.dbPath } : {}),
-            ...(o.pollIntervalMs !== undefined ? { pollIntervalMs: o.pollIntervalMs } : {}),
-            ...(o.heartbeatMs !== undefined ? { heartbeatMs: o.heartbeatMs } : {}),
-            ...(o.ledgerPath !== undefined ? { ledgerPath: o.ledgerPath } : {}),
-            ...(o.demoDir !== undefined ? { demoDir: o.demoDir } : {}),
-            ...(o.clisJson !== undefined ? { clisJson: o.clisJson } : {}),
-            // The roster WITH standing when no override is set (F-RECON-002/003).
-            roster: rosterWithStanding,
-            resolveDocsRoot: o.resolveDocsRoot ?? interactiveDocsRoot,
-            onRunFiled: fileRun,
-            onRunLaunched: (runId, detail) => { recordRunLaunched(audit, runTimingIndex, DAEMON_ACTOR, runId, detail); },
-            groundingStore: docGrounding,
-            log: (m) => app.log.warn(m),
-            logError: (m) => app.log.error(m),
-        });
-        if (demoSub !== null) {
-            const sub = demoSub;
-            app.log.info('interactive-demo subscription armed (filters wicked.interactive.doc.created + feedback.processed, kind:demo)');
-            app.addHook('onClose', async () => {
-                await sub.stop();
-            });
-        }
-    }
     // Arm the opt-in interactive CHAT answering seam (CREW-UX-5 — the iteration ask). Same
     // posture again: failure to arm is LOUD but non-fatal. Armed AFTER the sibling seams so the
     // per-doc serialization contract (no draft/edit/chat run races another on one doc) can
@@ -704,7 +698,7 @@ export async function createServer(adapter, options) {
     if (options?.interactiveChatEvents?.enabled === true && !refuseStubSeam('interactive-chat')) {
         const o = options.interactiveChatEvents;
         chatSub = await startInteractiveChatSubscriber(adapter, {
-            ...(o.dbPath !== undefined ? { dbPath: o.dbPath } : {}),
+            ...busOf(o.dbPath),
             ...(o.pollIntervalMs !== undefined ? { pollIntervalMs: o.pollIntervalMs } : {}),
             ...(o.heartbeatMs !== undefined ? { heartbeatMs: o.heartbeatMs } : {}),
             ...(o.ledgerPath !== undefined ? { ledgerPath: o.ledgerPath } : {}),
@@ -753,14 +747,23 @@ export async function createServer(adapter, options) {
             // candidates. Views with no units (older engines, stub adapters) keep the historical
             // `unit_ix` fallback.
             const cursor = resolveCursorUnit(v);
-            // DES-L3 PR-3E (F-RC1-012): an EVALUATOR cursor must never fail over onto a seat
-            // that built the work it reviews — the creators' seats ride as `avoid`. A free-text
-            // unit carries no role → no constraint (today's pick).
-            const avoid = cursor?.role === 'evaluator'
-                ? v.units
-                    .filter((u) => u.role === 'creator' && u.assigned_cli != null)
-                    .map((u) => u.assigned_cli)
-                : [];
+            // Evaluator ≠ creator across a failover: an EVALUATOR cursor avoids the seats that
+            // built the work it reviews (DES-L3 PR-3E), a CREATOR cursor avoids the run's
+            // evaluator seats (crew#638), and a unit the engine routed `evaluator_distinct`
+            // avoids the seat it was routed away from (crew#583). A free-text unit carries no role
+            // and no such routing → no constraint.
+            const seatsOfRole = (role) => v.units
+                .filter((u) => u.role === role && u.assigned_cli != null)
+                .map((u) => u.assigned_cli);
+            const cursorUnit = cursor === undefined ? undefined : v.units.find((u) => u.ord === cursor.ord);
+            const routing = cursorUnit?.routing;
+            const avoid = [
+                ...new Set([
+                    ...(cursor?.role === 'evaluator' ? seatsOfRole('creator') : []),
+                    ...(cursor?.role === 'creator' ? seatsOfRole('evaluator') : []),
+                    ...(routing?.method === 'evaluator_distinct' ? [routing.was] : []),
+                ]),
+            ].filter((s) => s !== cursor?.cli);
             return {
                 id: v.session.id,
                 ord: cursor?.ord ?? v.session.unit_ix,
@@ -820,6 +823,13 @@ export async function createServer(adapter, options) {
         onTurnTimeout: ({ session, ...detail }) => {
             audit.record('run.turn.timedout', { id: 'stall-watchdog', kind: 'system', trust: 'admin' }, { runId: session, detail });
         },
+        // crew#629: a unit whose own processes are working (a test runner, a build) is not silent.
+        ...(options?.stallWatchdog?.busy === null
+            ? {}
+            : {
+                busy: options?.stallWatchdog?.busy ??
+                    ((sampler) => (runIds) => sampler.busy(runIds))(new RunLivenessSampler()),
+            }),
         log: (m) => app.log.warn(m),
     });
     // The daemon's single CoreEvent subscription fans out here: cache gate prompts
@@ -846,6 +856,51 @@ export async function createServer(adapter, options) {
     // written from the stamped frames below, dropped with the chat on `chatClosed`, served on
     // `GET /chats/:id.messages`.
     const chatTranscripts = new ChatTranscriptStore();
+    // Chat citations (crew#561, F-RC1-117): what the seat CITED, checked against the very read roots
+    // the daemon handed it. Runs off the reply's own path — after the broadcast below — and publishes
+    // one `chatCitations` frame per reply; the seat's text is never edited.
+    const citationsDisabled = options?.chatCitations?.disabled === true;
+    const citationDeps = options?.chatCitations?.deps ?? chatCitationDeps();
+    const citationLimits = options?.chatCitations?.limits;
+    async function verifyReplyCitations(frame, projectId) {
+        const f = frame;
+        const chatId = typeof f['chat'] === 'string' ? f['chat'] : undefined;
+        const cliKey = typeof f['cliKey'] === 'string' ? f['cliKey'] : undefined;
+        const text = typeof f['text'] === 'string' ? f['text'] : '';
+        // A NOT-ok reply is the daemon's/engine's own reason line (an eviction, a refusal): it cites
+        // nothing the reader would paste, so it is not verified — and never marked.
+        if (chatId === undefined || cliKey === undefined || text === '' || f['ok'] === false)
+            return;
+        const scope = chatScopes.get(chatId);
+        // No scope (a chat this daemon did not open, or `kind: 'none'`/`system`) ⇒ nothing to verify
+        // AGAINST. Saying "unverified" then would blame the seat for the daemon's missing roots.
+        if (scope === undefined || scope.repos.length === 0)
+            return;
+        const roots = scope.repos.map((r) => ({ absRoot: resolvePath(r.rootPath), name: r.name }));
+        const turnId = typeof f['turn_id'] === 'string' ? f['turn_id'] : undefined;
+        // A chat is filed by its CHAT id (`crew.chat` membership), so the project of a chat frame is
+        // looked up by that — the run-keyed lookup on the relay above answers `undefined` for chats.
+        const project = projectId ?? membershipIndex.projectOf(chatId);
+        try {
+            const result = await verifyCitations(text, roots, citationDeps, citationLimits);
+            const out = citationsFrame({
+                chat: chatId,
+                cliKey,
+                ...(turnId !== undefined ? { turn_id: turnId } : {}),
+                ...(project !== undefined ? { project_id: project } : {}),
+            }, result);
+            if (out !== null) {
+                broadcast(out);
+                // ...and into the transcript, so a reload still shows the marks (api-types 0.68.0): the
+                // verdicts are their own append-only record, folded onto their reply by the reader.
+                chatTranscripts.recordCitations(out);
+            }
+        }
+        catch (err) {
+            // Loud-non-fatal: a reply is never held hostage to its own verification.
+            app.log.warn(`[chat] citation verification failed for ${chatId}/${cliKey}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     // crew#619: see declaration of chatRetained/runToChat above (before the hydration block).
     // linkChatRun populates both maps and is called from the hydration block (function-hoisted)
     // and from the launch route (via RoutesRuntime.linkChatRun).
@@ -908,6 +963,13 @@ export async function createServer(adapter, options) {
         const session = typeof event.session === 'string' ? event.session : undefined;
         const projectId = session !== undefined ? membershipIndex.projectOf(session) : undefined;
         broadcast(projectId !== undefined ? { ...rewritten, project_id: projectId } : rewritten);
+        // crew#561: the citations in that reply, checked against the chat's read roots — AFTER the
+        // broadcast (the answer is never delayed by verification) and never awaited on this path.
+        if (!citationsDisabled && rewritten.type === 'chatReply')
+            void verifyReplyCitations(rewritten, projectId);
+        // Standing orders (behaviour 10): a gate that opened may be one an order answers, holds or
+        // reports — after the gate cache folded it, so the order's decision carries the right ord.
+        void standingOrderEvaluator?.onEvent(event);
         // The delivered-PR record (CREW-UX-8, crew#321): resolved once per run at its terminal
         // frame, best-effort, off the hot path — see `resolveRunDelivery` above for why BOTH
         // terminal frames trigger it and why a failed deliver is a no-op. THEN the delivery-
@@ -977,7 +1039,6 @@ export async function createServer(adapter, options) {
                 adapter,
                 audit,
                 index: testSets,
-                workflows: () => adapter.listWorkflows(),
                 deliveryUrlFor: (runId) => deliveryIndex.urlFor(runId),
                 labelFor: (runId) => {
                     const attach = groupIndex.attachOf(runId);
@@ -1080,14 +1141,17 @@ export async function createServer(adapter, options) {
         try {
             done(null, JSON.parse(body));
         }
-        catch (err) {
+        catch {
             // A syntactically invalid body is the CLIENT's error: without an explicit statusCode
             // Fastify reports a parser error as a 500, which misfiles "you sent `{not json`" as a
             // server fault — on the elicitation answer path that told an operator the daemon broke
             // when their request did. 400 matches Fastify's own default JSON parser
             // (FST_ERR_CTP_INVALID_JSON) and every schema-level 400 these routes already return.
-            err.statusCode = 400;
-            done(err);
+            // The message is a fixed one, never JSON.parse's: V8 quotes the body around the bad token
+            // (`Unexpected token 's', ..."{"value": sk-…"... is not valid JSON`), and Fastify both
+            // answers and logs it, so an unquoted `PUT /mcp/servers/:name/secret` value would leave the
+            // broker in the response and the log (DES-MCP-TOOLS-001 D-2).
+            done(Object.assign(new Error('the request body is not valid JSON'), { statusCode: 400, code: 'FST_ERR_CTP_INVALID_JSON' }));
         }
     });
     await app.register(fastifyWebsocket);
@@ -1109,13 +1173,47 @@ export async function createServer(adapter, options) {
     // diagnostics reads the bundle's shipped version manifest from the same root the static
     // handler serves. One resolution, two consumers.
     const studioRoot = options?.studioRoot ?? defaultStudioRoot();
-    registerRoutes(app, adapter, gateCache, elicitationCache, qeGateCache, {
+    // DES-MCP-TOOLS-001 S2: the registry over `<state home>/mcp` (created on the first save).
+    const mcpRegistry = new McpRegistry({
+        store: new McpRegistryStore(),
+        secrets: platformSecretStore(),
+        probe: probeMcpServer,
+        // Read the worker home at request time: `PUT /settings` can move it (applyWorkerConfigRoot).
+        discover: (managed) => discoverMcpServers({ home: homedir(), workerHome: process.env['WICKED_WORKER_HOME'] ?? null }, managed),
+    });
+    // S3: every brokered call is judged by the in-process engine (the token registry is the
+    // engine's, process-global), recorded to `<state home>/mcp/calls.ndjson`, and published on /ws
+    // and the engine's bus. A bus that is not attached only loses the event; the record is the record.
+    // S7: the same file (one serialized chain) is what `GET /mcp/usage` reads back and folds.
+    const mcpCallRecords = new McpCallRecordFile();
+    const mcpBroker = new McpBroker({
+        registry: mcpRegistry,
+        engine: () => CoreAdapter.mcpEngineGate(),
+        records: mcpCallRecords,
+        budgetPerUnit: budgetFromEnv(),
+        log: (m) => app.log.warn(m),
+        publish: async (record) => {
+            broadcast({ type: 'mcpCallCompleted', record });
+            if (engineBusDb === undefined)
+                return;
+            await emitOnBus(engineBusDb, {
+                event_type: MCP_CALL_COMPLETED,
+                domain: 'wicked-crew',
+                subdomain: 'mcp',
+                payload: record,
+                producer_id: 'wicked-crew',
+                idempotency_key: `${MCP_CALL_COMPLETED}:${record.spanId}`,
+            });
+        },
+    });
+    const registered = registerRoutes(app, adapter, gateCache, elicitationCache, {
         bus: projectBus,
         index: membershipIndex,
         log: (m) => app.log.warn(m),
         settings: projectSettings,
     }, { audit, authMode: auth.mode }, {
         seatHealth,
+        deliveryFreeze,
         // wicked-studio#284: the watchdog's remembered frames ride `GET /runs/:id/events`.
         stallFrames: (runId) => stallFrameIndex.framesFor(runId),
         // The SAME standing accessor the seams and the adapter launch with (F-RECON-002/003).
@@ -1149,6 +1247,13 @@ export async function createServer(adapter, options) {
         interactiveBridgeBusDataDir: options?.interactiveBridge?.busDataDir ?? null,
         docGrounding,
         ...(skillsRuntime !== undefined ? { skills: skillsRuntime } : {}),
+        // DES-MCP-TOOLS-001 S2: the registry over `<state home>/mcp` (created on the first save).
+        // Route tests drive `registerMcpRoutes` over their own registry (tests/mcp-registry.test.ts).
+        mcp: mcpRegistry,
+        // DES-MCP-TOOLS-001 S3: the broker's call path over that registry.
+        mcpBroker,
+        // DES-MCP-TOOLS-001 S7: the call records the usage fold reads.
+        mcpCalls: mcpCallRecords,
         // wicked-core#411 / crew#497: the live state-home classification the routes report and gate on.
         stateHome: stateHomeWatch,
         // Routes that say something to the thread (a refused chat seat, F-2R2-007) emit through the
@@ -1157,6 +1262,68 @@ export async function createServer(adapter, options) {
         // crew#619: retain a chat's transcript for the lifetime of its promoted run.
         linkChatRun,
     });
+    // Standing orders (Studio OS behaviour 10): the store, the evaluator over THE gate decision path
+    // (`registered.decideGate`), and the routes. See src/standing-orders/.
+    // The durable record is the audit trail (store.ts): fold it once, here.
+    const standingOrders = new StandingOrderStore(audit);
+    await standingOrders.hydrate(audit, (m) => app.log.warn(m));
+    standingOrderEvaluator = new StandingOrderEvaluator({
+        store: standingOrders,
+        decideGate: registered.decideGate,
+        audit,
+        runFacts: async (runId) => {
+            const v = (await adapter.sessionsDetail()).find((x) => x.session.id === runId);
+            if (v === undefined)
+                return undefined;
+            return {
+                projectId: runProject(v, runId, (id) => membershipIndex.projectOf(id)),
+                band: runBand(v),
+                preset: runPreset(v),
+                problem: v.session.problem,
+                phaseOf: (ord) => v.units.find((u) => u.ord === ord)?.phase_ref ?? undefined,
+                firstOrd: v.units.length === 0 ? undefined : Math.min(...v.units.map((u) => u.ord)),
+                landsDoctrine: isSteeringAuthorRun(v),
+            };
+        },
+        openGates: async () => {
+            if (typeof adapter.interactionRequests !== 'function')
+                return [];
+            const rows = (await adapter.interactionRequests(undefined, 'open')) ?? [];
+            return rows
+                .filter((r) => r.kind === 'gate' && typeof r.ord === 'number')
+                .map((r) => ({
+                runId: r.session_id,
+                ord: r.ord,
+                reviewingOrd: r.reviewing_ord,
+                gateKind: typeof r['gate_kind'] === 'string' ? r['gate_kind'] : '',
+                prompt: r.prompt,
+            }));
+        },
+        // Brainstorm idea 13: a plan-approval trust order re-reads the open plan gate's own band.
+        planGate: async (runId) => openPlanGateRisk(await busRows(adapter.busDbPath, runId)),
+        log: (m) => app.log.warn(m),
+    });
+    // The decided-gate history (brainstorm ideas 7 and 8): a seat's track record, and the preview
+    // of what a proposed order would have done — read with the evaluator's own phase and invariant.
+    registerGateHistoryRoute(app, {
+        audit,
+        views: () => adapter.sessionsDetail(),
+        gateRows: async () => typeof adapter.interactionRequests === 'function' ? ((await adapter.interactionRequests(undefined, undefined)) ?? []) : [],
+        projectOf: (id) => membershipIndex.projectOf(id),
+        landsDoctrine: isSteeringAuthorRun,
+    });
+    registerStandingOrderRoutes(app, {
+        store: standingOrders,
+        evaluator: standingOrderEvaluator,
+        parse: seatParser({ adapter, roster: rosterWithStanding }),
+    });
+    // Orders hydrated from the trail act on gates ALREADY open: one sweep of the engine's open gate
+    // rows at boot. It also covers any gate that opened before the evaluator existed (the live
+    // subscription above reads it late-bound); every later gate arrives as a live frame.
+    void standingOrderEvaluator.sweep().catch((err) => app.log.warn(`[standing-orders] boot sweep failed: ${String(err)}`));
+    // crew#471: a campaign the previous daemon left `running` is crash-resumed by the engine (its
+    // node runs froze with that process) — asked once, at boot, never for a paused one.
+    void resumeRunningCampaigns(adapter, (m) => app.log.warn(m));
     // The UI-emittable direction of the interactive seam. Registered unconditionally (a null relay
     // answers 503, not 404) and BEFORE the static/SPA fallback below, like every other API route.
     registerInteractiveEventRoutes(app, interactiveRelay);
@@ -1213,6 +1380,11 @@ export async function createServer(adapter, options) {
     }
     return app;
 }
+/** The URL a worker on this host reaches the daemon at: a wildcard bind is reached on loopback. */
+export function brokerUrlFor(host, port) {
+    const h = host === '0.0.0.0' || host === '' ? '127.0.0.1' : host === '::' ? '::1' : host;
+    return `http://${h.includes(':') ? `[${h}]` : h}:${port}`;
+}
 export async function startServer(adapter, port = 7701, host = '127.0.0.1', options) {
     const app = await createServer(adapter, options);
     await app.listen({ port, host });
@@ -1220,6 +1392,10 @@ export async function startServer(adapter, port = 7701, host = '127.0.0.1', opti
     const boundPort = typeof addr === 'object' && addr ? addr.port : port;
     const boundHost = typeof addr === 'object' && addr ? addr.address : host;
     app.log.info(`wicked-crew daemon listening on ${boundHost}:${boundPort}`);
+    // DES-MCP-TOOLS-001 S1/S3: the in-process engine hands each governed worker this URL (with its
+    // `WICKED_MCP_TOKEN`) as `WICKED_CREW_URL`, so the garden shim reaches THIS daemon's broker. The
+    // engine reads the daemon's own env at every spawn; a daemon that never listened hands none.
+    process.env['WICKED_CREW_URL'] = brokerUrlFor(boundHost, boundPort);
     return { app, port: boundPort, host: boundHost };
 }
 //# sourceMappingURL=server.js.map