wicked-crew 0.7.46 → 0.7.48

package/dist/api/routes.js

@@ -38,7 +38,7 @@ import { DEFAULT_STEERING_TYPE, STEERING_TYPE_VALUES, STEERING_TYPES, registerGo
 import { isSteeringAuthorRun, landSteeringProposal } from './steering-landing.js';
 import { ApproveEditSchema, approveEdited, captureLaunchRoots, editInFlight, FileProposalSchema, registerCaptureRoutes } from './capture.js';
 import { registerTestingRoutes } from './testing.js';
-import { DEMO_PRESET, demoLaunchRoots, registerDemoRoutes } from './demo.js';
+import { DEMO_PRESET, demoLaunchRoots, registerDemoRoutes, registerWalkthroughRoutes, walkthroughAcceptance } from './recording.js';
 import { registerSkillsRoutes } from './skills.js';
 import { registerMcpRoutes } from './mcp.js';
 import { McpPolicies } from '../mcp/policies.js';
@@ -46,8 +46,10 @@ import { disabledSkillsHealth } from '../skills/runtime.js';
 import { phaseSkillFindings, withPhaseSkillGaps } from '../skills/phase-skill-gaps.js';
 import { STATE_HOME_BLOCKER_CODE, STATE_HOME_REMEDY, isEngineStateHomeRefusal, stateHomeBlockerBody, } from '../projects/state-home-preflight.js';
 import { BASE_SKILL_POLICIES, BASE_SKILL_REF_SHAPE, baseSkillRemedy } from '../skills/base-skill.js';
+import { REQUIRED_GARDEN_VERSION } from '../skills/plugin-source.js';
 import { noEligibleSeatBody, parseNoEligibleSeat } from '../core/engine-roster.js';
 import { ProjectSettingsStore } from '../projects/settings.js';
+import { isHumanOperator } from './watch-routes.js';
 import { boundOrigin, InteractiveBridgePool } from '../interactive/bridge-pool.js';
 import { composeDeliverText, configuredPublicOrigin, extractFollowUps, factsFromRun, FOLLOW_UPS_MAX, framedDeliverText, runUrlFor, } from '../core/deliver-text.js';
 import { deliverRepoFor, deliverTargetView, isGitHubLogin, readDeliverOriginUrl, resolvePullRequest as resolvePullRequestViaGh, } from '../core/deliver.js';
@@ -69,14 +71,25 @@ import { DeliveryFreeze, frozenRefusal, isDeliverUnit, registerDeliveryFreezeRou
 import { GroupIndex } from './group-index.js';
 import { RunTimingIndex, recordRunLaunched } from './run-timing-index.js';
 import { GuidanceIndex } from './guidance-index.js';
-import { DeliveryIndex, gitRunBranchIsEmpty, gitWorktreeIsClean, isDeliverConflictStranded, deliveryRecordFrom, pushedState, canDeliverResolver, } from './delivery-index.js';
+import { DELIVER_REQUESTED_ACTION, DeliveryIndex, gitRunBranchIsEmpty, gitWorktreeIsClean, isDeliverConflictStranded, deliveryRecordFrom, pushedState, canDeliverResolver, FREE_TEXT_NOTICE, freeTextOutcome, } from './delivery-index.js';
 import { DeliveryDerivationCache } from './delivery-cache.js';
 import { gitReprovisionWorktree, runDeliverScript, } from './post-hoc-deliver.js';
-import { LOCAL_ACTOR } from './auth.js';
+import { LOCAL_ACTOR, trustAtLeast } 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';
+import { landPolicyRule, policyProposalToRule } from './policy-landing.js';
+import { DecisionError, DecisionService } from '../decisions/land.js';
+import { ingestDecision } from '../decisions/ingest.js';
+import { registerDecisionRoutes } from '../decisions/routes.js';
+import { ChatDecisionRecorder } from '../decisions/chat-recorder.js';
+import { ConsiderationService } from '../decisions/consider.js';
+import { gardenPackCheck } from '../editors/pack-install.js';
+import { EditorRegistry } from '../editors/registry.js';
+import { registerEditorRoutes } from '../editors/routes.js';
+import { discoverLivePlugin } from '../skills/plugin-source.js';
+import { resolveDecisionsMode } from '../decisions/types.js';
 const V = API_PREFIX;
 /** How long `GET /health` waits on the engine's actor before answering `ping: "busy"` (crew#471). */
 export const HEALTH_PING_WAIT_MS = 1_000;
@@ -185,80 +198,8 @@ function isStringRecord(v) {
         !Array.isArray(v) &&
         Object.values(v).every((x) => typeof x === 'string'));
 }
-/**
- * Map an APPROVED policy proposal (estate `proposal.approve` → `handed_off`) into a steering
- * ConformanceRule (DES-MEM-FACETED-001 §5.2). A policy proposal's `kind_type` is
- * `policy:<steering_type>` and its `payload` is `{ rule, severity }`; estate writes NOTHING for it
- * (the AW-11 "no rules.write on estate" invariant) and hands the payload back for crew — the ONE
- * governed rules-write path — to land. Returns the rule to upsert plus the resolved steering type,
- * or a loud `error` string when the proposal cannot be shaped into a valid rule (a malformed
- * `kind_type` / missing `rule` / out-of-enum `severity`) — the caller reports it as a failed
- * landing, never a silent drop (the crew#388 anti-silent-loss doctrine).
- *
- * The rule id is DETERMINISTIC (`proposal:<id>`) so a re-driven landing UPSERTS the same rule
- * (idempotent) instead of minting a duplicate; it sits OUTSIDE the reserved `PAT-/POL-` namespace,
- * which UI/chat/proposal-authored rules are free to do (INV-C1). The rule carries NO `effect`
- * (recall-only — exactly what `{rule, severity}` supports: an enforcement rule would need a
- * non-blank `applies_to`, which the payload does not carry, and INV-S3 fails such a rule closed).
- * `steering_type` is validated against the vocabulary here so the engine's INV-S1 never rejects it
- * as an unknown page.
- */
-export function policyProposalToRule(proposalId, kindType, payload, facets) {
-    const steeringType = kindType.startsWith('policy:') ? kindType.slice('policy:'.length) : '';
-    if (!STEERING_TYPES.has(steeringType)) {
-        return {
-            error: `the approved proposal's kind_type ${JSON.stringify(kindType)} does not name a steering ` +
-                `type — expected \`policy:<${STEERING_TYPE_VALUES.join('|')}>\``,
-        };
-    }
-    const body = typeof payload === 'object' && payload !== null && !Array.isArray(payload)
-        ? payload
-        : {};
-    const statement = typeof body['rule'] === 'string' ? body['rule'].trim() : '';
-    if (statement === '') {
-        return {
-            error: 'the approved policy proposal payload has no `rule` string to make a rule statement from',
-        };
-    }
-    const rawSeverity = body['severity'];
-    // Normalize common LLM drift before the enum check: a model naturally writes the English word
-    // "warning", but the engine's enum is the short "warn" (info/error/critical are already the
-    // natural words). Tolerate case/whitespace too. A capture worker that says "warning" must still
-    // land its policy — otherwise every derived policy at the middle band silently fails to land.
-    const normSeverity = typeof rawSeverity === 'string'
-        ? (() => {
-            const s = rawSeverity.trim().toLowerCase();
-            return s === 'warning' ? 'warn' : s;
-        })()
-        : rawSeverity;
-    const severity = normSeverity === 'info' || normSeverity === 'warn' || normSeverity === 'error' || normSeverity === 'critical'
-        ? normSeverity
-        : undefined;
-    if (rawSeverity !== undefined && severity === undefined) {
-        return {
-            error: `the approved policy proposal payload has an invalid severity ${JSON.stringify(rawSeverity)} — ` +
-                'expected info|warn|error|critical (or the natural "warning" for warn)',
-        };
-    }
-    const language = facets?.['language'];
-    const rule = {
-        id: `proposal:${proposalId}`,
-        rule_type: 'policy',
-        statement,
-        // A policy proposal SHOULD carry severity; a missing one defaults to `warn` (the middle band)
-        // rather than failing the landing, but a present-but-garbage one fails loud above.
-        severity: severity ?? 'warn',
-        // REQUIRED engine-side (f32, no serde default, INV-C2 `[0,1]`); the payload carries none, so a
-        // fixed authority — the same 0.8 the steering-author landing defaults to.
-        confidence: 0.8,
-        // Only the `language` facet maps onto the engine's Targets facet object; `repo`/`project`
-        // facets have no ConformanceRule slot and are dropped (see the route's open question).
-        targets: typeof language === 'string' && language !== '' ? { language } : {},
-        provenance: { source: 'proposal', source_kinds: [] },
-        steering_type: steeringType,
-    };
-    return { rule, steeringType: steeringType };
-}
+// `policyProposalToRule` lives beside THE landing (policy-landing.ts); re-exported for its callers.
+export { policyProposalToRule } from './policy-landing.js';
 /** A JSON object whose every value is a number (a coverage breakdown map). */
 function isNumberRecord(v) {
     return (typeof v === 'object' &&
@@ -741,6 +682,62 @@ runtime = {}) {
     // default is the real spawn-per-call `wicked-estate-mcp` client; route tests inject a stub so no
     // process is ever spawned.
     const estateTool = runtime.callEstateTool ?? callEstateTool;
+    // DC-S4a: decision capture over the structured hosts (gate note, elicitation, inject). Words are
+    // recorded post-commit, off the request path, and only from a human actor (decisions/ingest.ts).
+    const decisions = runtime.decisionLedger !== undefined
+        ? new DecisionService({
+            ledger: runtime.decisionLedger,
+            mode: runtime.decisionsMode ?? resolveDecisionsMode(),
+            authMode: security.authMode,
+            estateTool,
+            adapter,
+            audit,
+            emit: runtime.decisionsEmit ?? null,
+            ...(runtime.broadcast !== undefined
+                ? { broadcast: (frame) => runtime.broadcast?.(frame) }
+                : {}),
+            log: (m) => app.log.warn(m),
+        })
+        : null;
+    if (decisions !== null)
+        registerDecisionRoutes(app, decisions);
+    // DC-S4b: the studio chat host. The recorder writes the transcript's `decisions` record and the
+    // `chatDecisions` frame, so without the store or the /ws fan-out there is no chat host at all.
+    // DC-S7: considered · set aside · cited (unchecked) for chat turns and run units, and how the
+    // seats learn the rules (the statement at open, a disclosed preface on the next send after a rule
+    // lands). Fail-soft on an engine or a stub without the rule reads.
+    const considerations = new ConsiderationService({
+        adapter,
+        ...(runtime.decisionLedger !== undefined ? { ledger: runtime.decisionLedger } : {}),
+        ...(chatTranscripts !== undefined ? { transcripts: chatTranscripts } : {}),
+        projectOf: (id) => projects.index.projectOf(id),
+        emit: runtime.decisionsEmit ?? null,
+        log: (m) => app.log.warn(m),
+    });
+    // EP-C1 (DES-artifact-editor-plugins §9.1): the editor registry — first-party editors discovered
+    // in studio's bundle, flags in `daemon-editors.json` — and its routes. Pack installs are refused
+    // until EP-C8, after garden's gate has run and the approval list has been read.
+    const editorRegistry = new EditorRegistry({
+        ...(runtime.editorsStateHome !== undefined ? { stateHome: runtime.editorsStateHome } : {}),
+        ...(runtime.studioRoot !== undefined ? { studioRoot: runtime.studioRoot } : {}),
+        log: (m) => app.log.warn(m),
+    });
+    registerEditorRoutes(app, {
+        registry: editorRegistry,
+        adapter,
+        packCheck: runtime.packCheck ?? gardenPackCheck(discoverLivePlugin()?.path ?? null),
+        log: (m) => app.log.warn(m),
+    });
+    const chatRecorder = decisions !== null && chatTranscripts !== undefined && runtime.broadcast !== undefined
+        ? new ChatDecisionRecorder({
+            service: decisions,
+            transcripts: chatTranscripts,
+            broadcast: runtime.broadcast,
+            projectOf: (chat) => projects.index.projectOf(chat),
+            onTurnRecorded: (chat, turnId) => considerations.onChatTurn(chat, turnId),
+            log: (m) => app.log.warn(m),
+        })
+        : null;
     /** Repo root for a repo ref, from the registry — shared by the reprovision path below. */
     const repoRootOf = async (repoRef) => (await adapter.listRepos()).find((r) => r.id === repoRef)?.root_path;
     /** DES-L9: PR number → head branch, through `gh pr view` unless the runtime injected an answerer. */
@@ -875,6 +872,20 @@ runtime = {}) {
             view.session.launch_actor = launchActor;
         const state = resolveDelivery(view, conflictStrand);
         view.session.delivery = state.delivery;
+        // crew#762: was delivery asked for? The launch's decision (`deliver: 'pr'`), a post-hoc attempt
+        // or a delivery on record says yes; a launch that said `deliver: 'none'` with neither says no.
+        // ABSENT when the daemon holds no launch record and no attempt (never fabricated).
+        const launchDeliver = runTimingIndex.launchDeliverFor(view.session.id);
+        if (launchDeliver === 'pr' || deliveryIndex.wasRequested(view.session.id) || deliveryIndex.isDelivered(view.session.id)) {
+            view.session.deliver_requested = true;
+        }
+        else if (launchDeliver === 'none') {
+            view.session.deliver_requested = false;
+        }
+        // crew#755: a completed repo-less free-text run answered in text and changed nothing — say so.
+        const outcome = freeTextOutcome(view);
+        if (outcome !== undefined)
+            view.session.outcome = outcome;
         if (state.deliverUrl !== undefined)
             view.session.deliverUrl = state.deliverUrl;
         if (state.deliverBranch !== undefined)
@@ -888,6 +899,10 @@ runtime = {}) {
         const chatGrounded = runTimingIndex.chatGroundedFor(view.session.id);
         if (chatGrounded !== undefined)
             view.session.chat_grounded = chatGrounded;
+        // C1: the chat the run was launched from, on every run (terminal ones too) — ABSENT otherwise.
+        const chatId = runTimingIndex.chatIdFor(view.session.id);
+        if (chatId !== undefined)
+            view.session.chat_id = chatId;
         return view;
     };
     // Resolved ONCE and shared by the project routes (which read/write `interactiveRoot`) and the
@@ -898,6 +913,17 @@ runtime = {}) {
     // 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;
+    // crew#753: the blocking `skills.garden` finding (an installed garden older than the minimum), or
+    // `null`. Read from the skills runtime's cached health; no seam ⇒ nothing to judge.
+    const gardenBlocker = () => {
+        const f = runtime.skills?.health().findings.find((x) => x.kind === 'skills.garden' && x.severity === 'error');
+        return f === undefined ? null : { kind: f.kind, severity: f.severity, message: f.message };
+    };
+    /** The typed 422 a launch or onboard answers while {@link gardenBlocker} holds. */
+    const gardenRefusalBody = () => {
+        const f = gardenBlocker();
+        return f === null ? null : { code: 'garden_required', error: f.message, required: REQUIRED_GARDEN_VERSION };
+    };
     // Liveness — also proves the actor + event pump are up.
     //
     // crew#471: the engine's ping is a round trip through its single-writer actor, and a launch that
@@ -927,9 +953,15 @@ runtime = {}) {
         // F-E2E-030: what this deployment can keep. A composer reads `capabilities.deliverGate`
         // before it promises "pauses at the deliver gate"; a stub-driven route set without the
         // probe honestly reports no gate.
-        const capabilities = typeof adapter.engineCapabilities === 'function'
-            ? adapter.engineCapabilities()
-            : { deliverGate: false, revisesPr: false, chatIdOnLaunch: false, seatChipOnCreate: false };
+        const capabilities = {
+            ...(typeof adapter.engineCapabilities === 'function'
+                ? adapter.engineCapabilities()
+                : { deliverGate: false, revisesPr: false, chatIdOnLaunch: false, seatChipOnCreate: false }),
+            // C1: `AgentSession.chat_id` is served from the daemon's own launch index, whatever the engine.
+            runChatId: true,
+            // WT-W1: repo-bound launches mint an evidence root only on an addon that takes the field.
+            walkthroughRoots: typeof adapter.evidenceRootsSupported === 'function' ? adapter.evidenceRootsSupported() : false,
+        };
         // wicked-core#411 / crew#497: the state-home blocker rides the health probe as a WARNING. The
         // daemon still SERVES (status stays ok — studio must load and show the blocker) but refuses to
         // launch while the state home holds an entry the worker Read fence cannot classify. Re-surveyed
@@ -950,6 +982,8 @@ runtime = {}) {
         const warnings = [
             ...(stateHome === null ? [] : stateHome.findings.map((f) => ({ kind: f.kind, severity: f.severity, message: f.message }))),
             ...(baseSkill?.finding ? [{ kind: baseSkill.finding.kind, severity: baseSkill.finding.severity, message: baseSkill.finding.message }] : []),
+            // crew#753: a garden older than the minimum is a blocking finding on the first screen too.
+            ...[gardenBlocker()].filter((f) => f !== null),
             ...phaseSkillFindings(runtime.phaseSkills?.gaps() ?? []),
             // DES-TEAMING-002 T0: the daemon's bus did not open at boot, so the engine was handed none
             // and runs un-teamed. A daemon-level notice (status stays ok: it serves); the per-run
@@ -1015,6 +1049,8 @@ runtime = {}) {
             // Is the governance evidence LANDING (crew#495): the store, the records on it, the dead
             // letters — with a `governance.deadletter` finding the moment the outbox holds one.
             governance,
+            // DC-S4b: the chat recorder's per-CLI `wicked-decisions` compliance (null without the chat host).
+            decisions: chatRecorder?.diagnostics() ?? null,
             // The state-home classification (wicked-core#411 / crew#497): which state home the worker
             // Read fence classifies, every entry it cannot classify there (top level and skills root),
             // who classified (the engine, or crew's registry copy on an older addon) and whether that
@@ -1369,11 +1405,39 @@ runtime = {}) {
             return message(err);
         }
     };
+    /**
+     * crew#753: what refuses an onboarding launch, judged BEFORE anything is registered — so a
+     * refused onboard leaves no repo row (core has no unregister). The same three intake refusals a
+     * launch meets: a garden older than the minimum (422 `garden_required`), the state-home blocker
+     * (409) and a base skill the handed generation lacks, e.g. no garden at all (422
+     * `base_skill_refused`). `null` when the launch would be admitted.
+     */
+    const onboardRefusal = async () => {
+        const garden = gardenRefusalBody();
+        if (garden !== null)
+            return { status: 422, body: garden };
+        if (runtime.stateHome !== undefined) {
+            const stateHome = await runtime.stateHome.refresh();
+            if (stateHome.refusesLaunches)
+                return { status: 409, body: stateHomeBlockerBody(stateHome) };
+        }
+        const posture = runtime.skills?.baseSkill() ?? null;
+        if (posture !== null && !posture.present && posture.finding !== null) {
+            return {
+                status: 422,
+                body: { code: 'base_skill_refused', error: posture.finding.message, baseSkill: posture, remedy: baseSkillRemedy(posture.inCatalog) },
+            };
+        }
+        return null;
+    };
     app.post(`${V}/repos`, async (req, reply) => {
         const parsed = RegisterRepoSchema.safeParse(req.body);
         if (!parsed.success) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
+        const refused = await onboardRefusal();
+        if (refused !== null)
+            return reply.code(refused.status).send(refused.body);
         const { name, rootPath, gitUrl, projectId, channel, actor } = parsed.data;
         let repo;
         let runId;
@@ -1416,6 +1480,9 @@ runtime = {}) {
         const body = OnboardBodySchema.safeParse(req.body ?? {});
         if (!body.success)
             return reply.code(400).send(invalidBody(body.error, 'Invalid request body'));
+        const refused = await onboardRefusal();
+        if (refused !== null)
+            return reply.code(refused.status).send(refused.body);
         let runId;
         try {
             runId = await adapter.launchOnboardingRun(repo.id, repo.name);
@@ -1449,7 +1516,7 @@ runtime = {}) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
         const b = parsed.data;
-        // The demo preset launches only from POST /projects/:id/demo (api/demo.ts), which mints the run's
+        // The demo preset launches only from POST /projects/:id/demo (api/recording.ts), which mints the run's
         // demo root and brief first: launched here directly it would have neither.
         if (b.workflow === DEMO_PRESET && (b.sessionId === undefined || !demoLaunchRoots.has(b.sessionId))) {
             return reply.code(400).send({
@@ -1468,6 +1535,10 @@ runtime = {}) {
                 return reply.code(409).send(stateHomeBlockerBody(stateHome));
             }
         }
+        // crew#753: a garden older than the minimum refuses the launch by name (found vs required).
+        const garden = gardenRefusalBody();
+        if (garden !== null)
+            return reply.code(422).send(garden);
         // crew#645: an expired login reads signed out BEFORE routing — wait (bounded) for every seat's
         // missing or stale login check, so the standing below is the seats' own answer.
         if (b.clisJson === undefined)
@@ -1485,7 +1556,7 @@ runtime = {}) {
         const captureRoot = captureLaunchRoots.get(input.sessionId);
         if (captureRoot !== undefined)
             input.extraWriteRoots = [captureRoot];
-        // A demo launch (api/demo.ts) writes every file into the demo root the demo route minted for it.
+        // A demo launch (api/recording.ts) writes every file into the demo root the demo route minted for it.
         const demoRoot = demoLaunchRoots.get(input.sessionId);
         if (demoRoot !== undefined)
             input.extraWriteRoots = [demoRoot];
@@ -1730,7 +1801,11 @@ runtime = {}) {
             // is always reproducible even if the chat is idle-reclaimed before the run finishes.
             if (b.chatId !== undefined)
                 runtime.linkChatRun?.(b.chatId, runId);
-            return reply.code(201).send({ runId, ...(linkedIssues !== undefined ? { linkedIssues } : {}) });
+            // crew#755: a launch that named neither a workflow nor a plan runs the engine's free-text
+            // planner (one unit, the brief verbatim). Say so in the answer, with how to get work done,
+            // instead of letting it pass for a launch of real work.
+            const freeText = input.workflow === undefined && input.plan === undefined ? { freeText: { notice: FREE_TEXT_NOTICE } } : {};
+            return reply.code(201).send({ runId, ...(linkedIssues !== undefined ? { linkedIssues } : {}), ...freeText });
         }
         catch (err) {
             const msg = message(err);
@@ -2024,6 +2099,10 @@ runtime = {}) {
             });
         }
         deliverInFlight.add(id);
+        // crew#762: the attempt is the durable fact "delivery was requested" — recorded BEFORE the
+        // script runs, so a lift that then fails still reads requested after a reload or restart.
+        audit.record(DELIVER_REQUESTED_ACTION, actorOf(req), { runId: id, detail: { via: 'post-hoc' } });
+        deliveryIndex.markRequested(id);
         // The worktree the script runs in. Usually the run's own; but the engine REAPS a
         // failed-deliver run's worktree once its work is committed (crew#418/#432) — the work then lives
         // on the `wicked/<id>` branch. For such a strand, stand a throwaway worktree back up from
@@ -2254,6 +2333,8 @@ runtime = {}) {
                     : `chat ${chatId} is already open on this daemon; DELETE /chats/${chatId} first, or omit chatId to mint a fresh one`,
             });
         }
+        // DC-S7: the in-force rules the statement lists; recorded as "told" only once the open succeeds.
+        let inForceAtOpen = [];
         // Everything below either ends in `chatScopes.set(chatId, …, token)` or releases the reservation.
         try {
             // The scope (crew#502): explicit repos (`repoRefs`, the legacy `repoRef` merged in) or the
@@ -2280,7 +2361,10 @@ runtime = {}) {
             const { scope, engine } = resolution;
             try {
                 // Cleans up only what it created itself on failure (Copilot, #518).
-                prepareChatScratch(chatId, scope);
+                // DC-S7: the seats learn the project's in-force rules from the statement (cap 20, severity
+                // order); the service remembers what they were told so a later landing can be prefaced.
+                inForceAtOpen = (await considerations.inForceFor(scope.projectId ?? null)).rules;
+                prepareChatScratch(chatId, scope, inForceAtOpen);
             }
             catch (err) {
                 chatScopes.release(chatId, token);
@@ -2459,6 +2543,9 @@ runtime = {}) {
                     const roots = scope.repos.map((r) => ({ absRoot: resolve(r.rootPath), name: r.name }));
                     chatTranscripts.registerRoots(chatId, roots);
                 }
+                // DC-S7: only a chat that actually OPENED is preface-eligible — recorded here, after the scope
+                // is published, so a refused open leaves no per-chat state behind (codex r1).
+                considerations.noteChatOpen(chatId, inForceAtOpen);
                 // 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.
@@ -2549,12 +2636,20 @@ runtime = {}) {
         // Sync, same tick as `inFlight`: the window is closed before anything yields.
         const turn = chatTurns.begin(id, audience, parsed.data.text);
         try {
-            const seats = await adapter.chatSend(id, parsed.data.text, parsed.data.targets);
+            // DC-S7: a rule remembered since the seats last heard from crew rides this send as a
+            // crew-authored preface — disclosed below as a `system` transcript record; the `user` record
+            // keeps the operator's own words.
+            const preface = await considerations.prefaceForSend(id);
+            const seats = await adapter.chatSend(id, preface !== null ? `${preface}\n\n${parsed.data.text}` : parsed.data.text, parsed.data.targets);
             if (turn !== null) {
                 // The engine's answer is the truth: the reserved audience is squared with the seats it
                 // reached, and the operator's message joins the transcript with exactly those seats.
                 chatTurns.reconcile(id, turn.turnId, seats);
                 chatTranscripts?.appendUser(id, turn.turnId, parsed.data.text, seats);
+                // DC-S4b: who said it, to whom — the recorder matches the seats' quotes against THIS message.
+                chatRecorder?.noteSend(id, turn.turnId, actorOf(req), parsed.data.text, seats);
+                if (preface !== null)
+                    chatTranscripts?.appendSystem(id, turn.turnId, preface);
             }
             // crew#641: re-state single-seat degradation on every turn so it is visible in the transcript.
             // Decided from `warmRoster` — the seats that are WARM — never from `seats`, which is only the
@@ -2744,6 +2839,40 @@ runtime = {}) {
             return reply.send({ output });
         return reply.send({ output: null, outputUnavailable: outputUnavailableReason(unit) });
     });
+    // DC-S7 (§4.6): what the seats considered, set aside and cited for one chat turn or one unit
+    // attempt. Operator+ (the rules are the project's doctrine). A cited rule is "unchecked", never
+    // "followed" (B4). 404 when the transcript holds no such turn, or the run has no such unit.
+    const operatorOnlyRead = (req, reply) => {
+        const actor = actorOf(req);
+        if (trustAtLeast(actor, 'operator'))
+            return true;
+        void reply.code(403).send({ error: `Insufficient trust: considered needs 'operator' (you are '${actor.trust}')` });
+        return false;
+    };
+    app.get(`${V}/chats/:id/turns/:turnId/considered`, { config: { manifest: { responseType: 'Consideration', statusCodes: [200, 403, 404] } } }, async (req, reply) => {
+        if (!operatorOnlyRead(req, reply))
+            return reply;
+        const { id, turnId } = req.params;
+        const c = await considerations.forChatTurn(id, turnId);
+        if (c === null)
+            return reply.code(404).send({ error: `chat ${id} holds no turn ${turnId}` });
+        return c;
+    });
+    app.get(`${V}/runs/:id/units/:unitKey/considered`, { config: { manifest: { responseType: 'Consideration', statusCodes: [200, 400, 403, 404] } } }, async (req, reply) => {
+        if (!operatorOnlyRead(req, reply))
+            return reply;
+        const { id, unitKey } = req.params;
+        const raw = req.query.attempt;
+        const attemptRaw = Array.isArray(raw) ? raw[0] : raw;
+        const attempt = attemptRaw === undefined || attemptRaw === '' ? 0 : Number(attemptRaw);
+        if (!Number.isInteger(attempt) || attempt < 0) {
+            return reply.code(400).send({ error: '`attempt` must be a non-negative integer' });
+        }
+        const c = await considerations.forUnit(id, unitKey, attempt);
+        if (c === null)
+            return reply.code(404).send({ error: `run ${id} has no unit '${unitKey}'` });
+        return c;
+    });
     // 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
     // per-run event log — what actually happened, not a re-derivation of it.
@@ -2782,7 +2911,10 @@ runtime = {}) {
         // catalog entry re-verifies evidence, a registered workflow's def, nothing for free text — and
         // an unknown run (or one the daemon cannot read) is declared and denied with the reason.
         const verifiedCatalog = typeof adapter.verifiedEvidenceCatalog === 'function' ? await adapter.verifiedEvidenceCatalog() : null;
-        const requirement = acceptanceRequirementOf(run, adapter.listWorkflows(), verifiedCatalog);
+        const knownCatalog = typeof adapter.catalogIds === 'function' ? await adapter.catalogIds() : null;
+        const requirement = acceptanceRequirementOf(run, adapter.listWorkflows(), verifiedCatalog, knownCatalog);
+        // WT-W2: every walkthrough step the requirement names is resolved from its proof root and seal.
+        const walkthroughs = await walkthroughAcceptance(adapter, run, requirement.phases);
         let repo = null;
         if (run.session.repo_ref !== null) {
             const repos = await adapter.listRepos();
@@ -2799,6 +2931,7 @@ runtime = {}) {
             // unit both appear on the page humans actually look at.
             claims: () => adapter.listConformanceClaims(),
             events: (rid) => adapter.runEvents(rid),
+            ...(walkthroughs.gates.length > 0 ? { walkthroughs } : {}),
         });
     });
     /**
@@ -2920,6 +3053,19 @@ runtime = {}) {
                     status,
                 },
             });
+            // DC-S4a host: the gate note (amend / request_changes text) — a bare approve or reject is a
+            // `choice`. Post-commit, off the request path; a non-human actor (a standing order) records nothing.
+            if (decisions !== null) {
+                decisions.track(ingestDecision(decisions, {
+                    host: 'gate',
+                    actor,
+                    words: parsed.data.amend ?? '',
+                    choice: parsed.data.action ?? (parsed.data.approve ? 'approve' : 'reject'),
+                    projectId: projects.index.projectOf(id) ?? null,
+                    runId: id,
+                    ...(parsed.data.ord !== undefined ? { ord: parsed.data.ord } : {}),
+                }));
+            }
             // APPROVE of the steering-author propose gate = the doctrine's landing moment: the
             // approved proposal is written to the governance store with `provenance.source: "chat"`,
             // audited per rule, idempotent on replay, and LOUD on failure — the response carries the
@@ -3046,6 +3192,16 @@ runtime = {}) {
         try {
             await adapter.injectWorkerMessage(id, parsed.data.message, parsed.data.target);
             audit.record('run.injected', actorOf(req), { runId: id, detail: { target: parsed.data.target } });
+            // DC-S4a host: the operator's mid-run steering text (review S9).
+            if (decisions !== null) {
+                decisions.track(ingestDecision(decisions, {
+                    host: 'inject',
+                    actor: actorOf(req),
+                    words: parsed.data.message,
+                    projectId: projects.index.projectOf(id) ?? null,
+                    runId: id,
+                }));
+            }
             return reply.send({ status: 'ok' });
         }
         catch (err) {
@@ -3298,6 +3454,19 @@ runtime = {}) {
             runId: id,
             detail: { elicitationId: taken.entry.elicitationId, action: body.action },
         });
+        // DC-S4a host: a free-text answer is words; a picked option (or a decline) is a `choice`.
+        if (decisions !== null) {
+            const picked = taken.entry.options !== null;
+            decisions.track(ingestDecision(decisions, {
+                host: 'elicitation',
+                actor: actorOf(req),
+                words: response !== null && !picked ? response : '',
+                ...(response !== null && picked ? { choice: response } : body.action !== 'accept' ? { choice: body.action } : {}),
+                projectId: projects.index.projectOf(id) ?? null,
+                runId: id,
+                elicitationId: taken.entry.elicitationId,
+            }));
+        }
         return { status: 'resolved' };
     });
     // The durable history of one run (FINDING-057).
@@ -3656,6 +3825,21 @@ runtime = {}) {
                     });
                 }
             }
+            // DC-S3: `targets.project` and `supersedes` shipped with `considerRules` (wicked-core-ts
+            // 0.7.35). An older engine would accept and drop them, so a project rule would land
+            // everywhere: refuse, naming the fields (codex on DC-S3).
+            if (!adapter.projectRulesSupported() && rule !== null && typeof rule === 'object') {
+                const carried = [
+                    ...(rule.targets?.project !== undefined ? ['targets.project'] : []),
+                    ...(rule.supersedes !== undefined ? ['supersedes'] : []),
+                ];
+                if (carried.length > 0) {
+                    return reply.code(501).send({
+                        error: `the installed engine would silently drop ${carried.map((f) => `\`${f}\``).join(', ')} ` +
+                            'and land the rule everywhere; upgrade wicked-core-ts (>= 0.7.35)',
+                    });
+                }
+            }
             await adapter.upsertConformanceRule(rule);
             audit.record('governance.rule.upserted', actorOf(req), { detail: { id: rule?.id } });
             return { status: 'ok' };
@@ -4332,6 +4516,26 @@ runtime = {}) {
                 });
             }
         }
+        // The watch registry's switches (DES-TRIGGER-REGISTRY-001 §4.2, TR-W5a): only `enabled` and
+        // `threshold` of a shipped entry, and `llm`. Turning a watcher off is the one way to make the
+        // platform stop telling the operator something, so only a PERSON may do it — the "human"
+        // predicate decision capture uses; a worker's bearer gets 403. A bad patch is a 400 naming the
+        // key (never a silent drop), and the daemon stamps who changed what and when.
+        let watchNext;
+        if (Object.hasOwn(patch, 'watch')) {
+            const actor = actorOf(req);
+            if (!isHumanOperator(actor)) {
+                return reply.code(403).send({ error: 'Only a person can change what is watched (watch.* settings); a worker or system actor cannot' });
+            }
+            const registry = runtime.watchRegistry?.() ?? null;
+            if (registry === null) {
+                return reply.code(400).send({ error: 'watch: watching is not configured on this daemon' });
+            }
+            const problem = registry.validateSettingsPatch(patch.watch);
+            if (problem !== null)
+                return reply.code(400).send({ error: problem });
+            watchNext = registry.mergeSettings((await adapter.getSettings()).watch, patch.watch, actor.id, Date.now());
+        }
         // Only known engine keys and validated `studio.*` keys are persisted. A key that is
         // NEITHER is dropped, not refused: request bodies are forward-additive too (DES-STUDIO-001
         // §5.1), so an older daemon meeting a newer client's engine key must not fail the whole
@@ -4364,11 +4568,15 @@ runtime = {}) {
         for (const key of studioKeys) {
             safe[key] = patch[key];
         }
+        if (watchNext !== undefined)
+            safe.watch = watchNext;
         // `Object.hasOwn`, NOT `k in safe`: `in` walks the prototype chain, so a dropped key named
         // `toString` / `valueOf` / `constructor` would test as "kept" and vanish from `ignored` —
         // the exact silent drop this route exists to end.
         const ignored = Object.keys(patch).filter((k) => !Object.hasOwn(safe, k));
         const settings = await adapter.updateSettings(safe);
+        if (watchNext !== undefined)
+            runtime.watchRegistry?.()?.applySettings(settings.watch);
         // 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.
@@ -4383,7 +4591,12 @@ runtime = {}) {
         // `changed` names every persisted key, engine and `studio.*` alike; `ignored` (present only
         // when there is one) is where a dropped unknown key stops being invisible.
         audit.record('settings.updated', actorOf(req), {
-            detail: { changed: Object.keys(safe), ...(ignored.length > 0 ? { ignored } : {}) },
+            detail: {
+                changed: Object.keys(safe),
+                ...(ignored.length > 0 ? { ignored } : {}),
+                // Which watchers were switched or re-thresholded (health reads the stamps; this is the trail).
+                ...(watchNext !== undefined ? { watch: patch.watch } : {}),
+            },
         });
         return { settings };
     });
@@ -4514,6 +4727,46 @@ runtime = {}) {
         if (editInFlight(id)) {
             return reply.code(409).send({ error: `proposal ${id} is already being accepted` });
         }
+        // DC-S4a: a proposal THIS ledger filed for a decision lands through `remember()` — the one
+        // landing path, with the human check inside it (§4.5). A payload naming an id the ledger does
+        // not know is an ordinary policy proposal (no ORIGIN claim) and takes the path below.
+        let decisionId = decisions?.deps.ledger.decisionForProposal(id) ?? null;
+        if (decisions !== null && decisionId === null) {
+            // The ledger links a proposal to its decision only once the `offered` outcome is written; a
+            // proposal crew filed but has not linked yet (the publish window, or a crash in it) names a
+            // decision this ledger HOLDS — it must still land through `remember()` (codex on DC-S4a).
+            try {
+                const pending = (await estateTool('proposal.list', { state: 'pending' }));
+                const named = pending.proposals.find((p) => p.id === id)?.payload?.decision?.id;
+                if (typeof named === 'string' && decisions.deps.ledger.record(named) !== null)
+                    decisionId = named;
+            }
+            catch (err) {
+                return estateUpstreamError(reply, err);
+            }
+        }
+        if (decisions !== null && decisionId !== null) {
+            try {
+                const landed = await decisions.remember(decisionId, actorOf(req), { how: 'needs-you' });
+                const view = decisions.deps.ledger.view(decisionId);
+                const landing = {
+                    outcome: 'landed',
+                    ruleId: landed.rule_id,
+                    ...(view !== null ? { steering_type: view.edits?.steering_type ?? view.derived.steering_type } : {}),
+                    ...(landed.project !== undefined ? { project: landed.project } : {}),
+                };
+                return {
+                    outcome: 'handed_off',
+                    payload: { rule: view?.edits?.statement ?? view?.derived.statement ?? '', severity: 'warn', capture: 'decision', decision: { id: decisionId } },
+                    landing,
+                };
+            }
+            catch (err) {
+                if (err instanceof DecisionError)
+                    return reply.code(err.status).send({ error: err.message });
+                throw err;
+            }
+        }
         let approved;
         try {
             approved = (await estateTool('proposal.approve', { id }));
@@ -4561,26 +4814,13 @@ runtime = {}) {
         if ('error' in built) {
             return landFailed(built.error);
         }
-        try {
-            await adapter.upsertConformanceRule(built.rule);
-        }
-        catch (err) {
-            return landFailed(`the store refused the steering rule derived from the approved policy proposal: ${message(err)}`);
-        }
-        audit.record('governance.rule.upserted', actorOf(req), {
-            detail: {
-                id: built.rule.id,
-                source: 'proposal',
-                via: 'proposal-approve',
-                steeringType: built.steeringType,
-                proposalId: id,
-            },
+        // THE landing (probe, upsert, read-back, audit) — shared with the decision landing (DC-S4a).
+        const landing = await landPolicyRule({ adapter, audit }, built, actorOf(req), {
+            via: 'proposal-approve',
+            proposalId: id,
         });
-        const landing = {
-            outcome: 'landed',
-            ruleId: built.rule.id,
-            steering_type: built.steeringType,
-        };
+        if (landing.outcome === 'failed')
+            return landFailed(landing.error ?? 'the landing failed');
         return { outcome: 'handed_off', payload: approved.payload, landing };
     });
     // POST /proposals/:id/reject → proposal.reject → { ok: true }.
@@ -4594,6 +4834,19 @@ runtime = {}) {
         if (editInFlight(id.trim())) {
             return reply.code(409).send({ error: `proposal ${id.trim()} is being accepted` });
         }
+        // DC-S4a B12: rejecting a decision's proposal dismisses the decision too (one object, two places).
+        const rejectedDecision = decisions?.deps.ledger.decisionForProposal(id.trim()) ?? null;
+        if (decisions !== null && rejectedDecision !== null) {
+            try {
+                await decisions.dismiss(rejectedDecision, actorOf(req), 'not-a-rule');
+                return { ok: true };
+            }
+            catch (err) {
+                if (err instanceof DecisionError)
+                    return reply.code(err.status).send({ error: err.message });
+                throw err;
+            }
+        }
         try {
             return (await estateTool('proposal.reject', { id }));
         }
@@ -4814,6 +5067,8 @@ runtime = {}) {
     registerCaptureRoutes(app);
     // The Demo experience (studio#373): the demo preset's launch, view, files and script edit.
     registerDemoRoutes(app, adapter);
+    // WT-W3: the storyline PUT checks the open gate through the same resolution the gate routes use.
+    registerWalkthroughRoutes(app, adapter, { resolveOpenGate, audit });
     // ── Presets (DES-TEAMING-002 §8.4, seam C2) — saved phase selections in the engine's store;
     // a launch names one via `workflow`, and the ENGINE resolves it.
     registerPresetRoutes(app, adapter, security);
@@ -4959,6 +5214,6 @@ runtime = {}) {
         pool: interactiveBridges,
         log: (m) => app.log.warn(m),
     });
-    return { decideGate };
+    return { decideGate, decisions, chatRecorder, considerations };
 }
 //# sourceMappingURL=routes.js.map