wicked-crew 0.16.11 → 0.16.13

package/dist/api/routes.js

@@ -3,40 +3,58 @@ import { busSeamsOffWarning, busUnavailableWarning } from '../core/bus-notice.js
 import { vaultBinWarning, vaultDiagnostics } from '../core/vault-bin.js';
 import { PlanSchema, toLaunchPlan } from './plan-schema.js';
 import { z } from 'zod';
-import { listRequirements, getRequirement, patchRequirement } from './requirements.js';
+import { listRequirementsRead, getRequirement, patchRequirement, readRequirementsGraph, REQUIREMENTS_NOT_GENERATED, } from './requirements.js';
 import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, realpathSync } from 'node:fs';
 import { promises as fsp } from 'node:fs';
-import { isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { videoPalette } from '../appearance/video-palette.js';
 import { CampaignsUnsupportedError, ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, GovernanceReplayUnsupportedError, PlanLaunchUnsupportedError, SteeringUnsupportedError, addonSupportsQeOverride, addonSupportsReducedAssurance, humanGatePhaseIds, settingsFilePath } from '../core/adapter.js';
-import { codeGraphDb, codeGraphErrorStatus, requirementsGraph } from '../core/repoPaths.js';
+import { codeGraphDb, codeGraphErrorStatus, repoFolderMissing, repoFolderMissingBody } from '../core/repoPaths.js';
 import { resolveCursorUnit } from '../core/cursor.js';
 /** Create `dir` (private) when missing and answer it — a read root must exist when a run launches. */
 function ensureDir(dir) {
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     return dir;
 }
+/** DES-CHAT-ARTIFACTS-001 §5.1: the chat's `open/` and `context/` read roots, made and proven real beneath its scratch
+ *  root, as the seat sees them; none where the platform cannot open beneath a root, or when they cannot be made. */
+function turnReadRoots(scratchRoot) {
+    if (!beneathSupported())
+        return [];
+    try {
+        ensureRealDir(contextReadRoots(scratchRoot).open);
+        ensureRealDir(contextReadRoots(scratchRoot).context);
+    }
+    catch {
+        return [];
+    }
+    const real = seatPathOf(scratchRoot);
+    return [join(real, 'open'), join(real, 'context')];
+}
 import { detectRefusal, isOpenGate, offeredChoices, replayOpenGate } from './gate-cache.js';
 import { acceptanceRequirementOf, buildAcceptanceView } from '../qe/acceptance.js';
 import { runIdentityOf, wireIdentity } from '../core/run-identity.js';
+import { buildWorkflowCatalog } from '../workflow-catalog/build.js';
 import { buildEvidenceBundle, coreUnitId, evidenceFilename } from './evidence.js';
 import { attemptUnavailableReason, capturedAttempts, outputUnavailableReason, resolveUnit, storedAttempt, unitKeysFor } from './unit-output.js';
 import { execCapped, ExecOutputTooLarge } from '../core/exec.js';
-import { callEstateTool, EstateMcpError, memoryStoreInfo } from '../core/estate-mcp-client.js';
+import { callEstateTool, EstateMcpError, ESTATE_INSTALL_HINT, memoryStoreInfo } from '../core/estate-mcp-client.js';
+import { NO_LEARNINGS_WORKFLOWS } from '../learnings/service.js';
 import { SeatHealthTracker } from './seat-health.js';
 import { applyWorkerConfigRoot, signedInHeuristic } from './seat-signin.js';
 import { applyCouncilSettings, isCouncilSize, isCouncilStaggerMs } from '../core/council-settings.js';
+import { applyRequirementsGraphSettings, isRequirementsGraphSettings, REQUIREMENTS_GRAPH_SETTINGS_RULE, } from '../core/requirements-graph-setting.js';
 import { defaultLaunchRoster, markOptIn } from '../core/opt-in-seats.js';
-import { chatSeatAdmission } from './seat-standing.js';
+import { chatSeatAdmission, homeless } from './seat-standing.js';
 import { seatGovernanceDiagnostics, seatGovernanceWarnings, } from './seat-governance.js';
 import { seatWorkDefaultNow } from './seat-work-default.js';
 import { ROSTER_REFRESH_WAIT_MS, rosterWithStandingFactory } from './roster-standing.js';
 import { SeatContainerStatus, gatewayDirOf, isContainerLoginCli, isContainerSeatFloor, isHostSeatFloor, loginDetail, runSeatLogin, seatLoginDepsFor, } from './seat-container-login.js';
 import { ChatTurnIndex } from './chat-turns.js';
-import { ChatScopeIndex, chatScopeDeps, chatScopeStatement, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
+import { CHAT_ID, chatMakeDigest, ChatScopeIndex, chatScopeDeps, chatScopeStatement, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
 import { ASK_TURN_BUDGET_SECS, AskPathIndex, isAskTurn } from './ask-paths.js';
 import { chatTurnStep, resolveChatWorkflow, servedChatWorkflows, writeCapableStep } from './chat-workflow.js';
 import { reassignRefusedSeats } from '../core/reassign-refusal.js';
@@ -55,7 +73,7 @@ import { registerTeamRoutes } from '../team/routes.js';
 import { registerCampaignRoutes } from '../campaigns/routes.js';
 import { registerGovernanceWikiRoutes } from './governance-wiki.js';
 import { DEFAULT_STEERING_TYPE, STEERING_TYPE_VALUES, STEERING_TYPES, registerGovernanceSteeringRoutes, } from './governance-steering.js';
-import { isSteeringAuthorRun, landSteeringProposal } from './steering-landing.js';
+import { atProposeGate, draftedSteeringRules, isSteeringAuthorRun, landSteeringProposal } from './steering-landing.js';
 import { inventoryComplete, parseInventoryClaims } from '../core/inventory-claim.js';
 import { ApproveEditSchema, approveEdited, captureLaunchRoots, editInFlight, FileProposalSchema, registerCaptureRoutes } from './capture.js';
 import { registerTestingRoutes } from './testing.js';
@@ -86,21 +104,31 @@ import { composeDeliverText, configuredPublicOrigin, extractFollowUps, factsFrom
 import { deliverIdentityFor, deliverRepoFor, deliverTargetView, isGitHubLogin, pushIdentityOf, readDeliverOriginUrl, resolvePullRequest as resolvePullRequestViaGh, unverifiedTreesFrom, } from '../core/deliver.js';
 import { credentialsMissingIn, deliverCredentialsProbe, missingCredentials } from '../core/deliver-credentials.js';
 import { codebaseArchiveUrl } from './codebase-archive.js';
-import { registerInteractiveProxy } from '../interactive/proxy-routes.js';
+import { projectRepoCandidates } from '../interactive/doc-grounding.js';
+import { artifactStatus, beneathSupported, buildTurnContext, chatMount, ChatMessageContextSchema, contextReadRoots, ensureRealDir, sha256Hex, parseArtifactRef, readGroundingBeneath, seatPathOf, UNFILED_MOUNT, } from './chat-context.js';
+import { createDocInProcess, registerInteractiveProxy } from '../interactive/proxy-routes.js';
+import { CreateLauncher } from '../interactive/proposal-create.js';
+import { buildRunBrief } from './run-brief.js';
+import { readBeneath } from './beneath.js';
+/** A context brief copied into a document's packet, at most (the packet's per-file cap). */
+const BRIEF_COPY_MAX = 512 * 1024;
 import { registerInteractiveDocDelete } from '../interactive/doc-delete-routes.js';
 import { registerInteractiveDocChecks } from '../interactive/doc-checks-routes.js';
 import { crewStateHome, stateHomeOfDb } from '../projects/state-home.js';
+import { ChatProposals, LaunchOnceRegistry, RecordingStubDispatcher, runCostFromEvents } from './chat-proposals.js';
+import { CATALOG_SEEDS } from '../workflow-catalog/catalog-data.js';
 import { registerInteractiveDocList } from '../interactive/doc-list-routes.js';
 import { REVIEWS_DIRNAME } from '../interactive/review-ledger.js';
 import { MembershipIndex } from '../projects/membership-index.js';
 import { MEMBERSHIP_ATTACHED, membershipAttachedKey } from '../projects/events.js';
 import { resolveLinkedIssues } from '../core/linked-issues.js';
 import { AuditLog } from './audit.js';
-import { AcpFoldCache, EngineVersionCache, eventsDirOf, installedPackageVersion, hostSandboxLauncher, seatRosterFile, listStoreFiles, readStudioBundleVersion, } from './diagnostics.js';
+import { AcpFoldCache, EngineVersionCache, FloorCacheCache, eventsDirOf, installedPackageVersion, hostSandboxLauncher, seatRosterFile, listStoreFiles, readStudioBundleVersion, } from './diagnostics.js';
 import { GovernanceDiagnostics } from './governance-health.js';
 import { ATTACHMENT_LIMITS, ATTACHMENT_MAX_MESSAGE_BYTES, AttachmentError, ChatAttachmentStore, attachmentWire, attachmentsBlock, boundaryOf, parseMultipart, stageForSeat } from './chat-attachments.js';
 import { CHAT_HISTORY_MAX_LIMIT, ChatHistoryStore, decodeCursor } from './chat-history.js';
-import { PROBE_TIMEOUT_MS, SYSTEM_BUDGET_MS, SYSTEM_STATS_DAYS, SYSTEM_STATS_TTL_MS, WeekFoldCache, assembleSnapshot, buildNeeds, buildClis, buildGovernance, diskRow, estateReadonlyCall, infraRow, judgeGaps, livenessThresholds, loadRow, probeBroker, probeBus, probeEstate, probeGateway, probeInteractive, probeVault, readBridgeLockAsync, readWeek, resolveContainerRuntime, runLiveness, settleWithin, skillsRow, sortRuns, stateHomeRow, unfinished, } from './system-snapshot.js';
+import { PROBE_TIMEOUT_MS, SYSTEM_BUDGET_MS, SYSTEM_STATS_DAYS, SYSTEM_STATS_TTL_MS, WeekFoldCache, assembleSnapshot, buildNeeds, buildClis, buildGovernance, diskRow, estateReadonlyCall, infraRow, judgeGaps, livenessThresholds, loadRow, probeBroker, probeBus, probeEstate, probeGateway, probeInteractive, probeVault, readBridgeLockAsync, readWeek, resolveContainerRuntime, runLiveness, settleWithin, skillsRow, sortRuns, stateHomeRow, reposRow, unfinished, } from './system-snapshot.js';
+import { parseSeatImageStatus, probeSeatImages, SeatImageRebuilder } from './seat-images.js';
 import { RunCostCache } from './needs.js';
 import { governanceStoreFix, legacyHomeOutboxPath } from '../core/governance-store.js';
 import { UsageError, replayOutboxInto } from '../cli/governance.js';
@@ -109,6 +137,10 @@ import { RetryIndex } from './retry-index.js';
 import { SEAT_RECORD_DEFAULT_DAYS, SEAT_RECORD_MAX_DAYS, seatRecord } from './seat-record.js';
 import { jobTitle } from './job-title.js';
 import { DeliveryFreeze, frozenRefusal, isDeliverUnit, registerDeliveryFreezeRoutes } from './delivery-freeze.js';
+import { VoiceService, defaultVoiceDir } from '../voice/service.js';
+import { VoiceDashboardStore } from '../voice/dashboard.js';
+import { registerVoiceRoutes } from '../voice/routes.js';
+import { VoiceInjectInputs } from '../voice/inject-input.js';
 import { GroupIndex } from './group-index.js';
 import { RunTimingIndex, recordRunLaunched } from './run-timing-index.js';
 import { GuidanceIndex } from './guidance-index.js';
@@ -173,6 +205,18 @@ function codeGraphDbOr503(repo, reply) {
         return null;
     }
 }
+/**
+ * `true` after answering **409** when the repo's registered folder is gone, BEFORE anything spawns
+ * there: Node reports a missing spawn `cwd` as `spawn <binary> ENOENT`, which named an installed
+ * binary as the fault (rig, tiny-math). The words are the finding's, the same everywhere.
+ */
+function refusedMissingFolder(repo, reply) {
+    const missing = repoFolderMissing(repo);
+    if (missing === null)
+        return false;
+    void reply.code(409).send(repoFolderMissingBody(missing));
+    return true;
+}
 function message(err) {
     return err instanceof Error ? err.message : String(err);
 }
@@ -588,7 +632,15 @@ export const GateSchema = z.object({
     /** api-types 0.44.0 — the gate this decision answers (its unit `ord`). A mismatch with the run's
      *  open gate is a 409 `gate_changed`: the decision was made on a gate that is no longer open. */
     ord: z.number().int().nonnegative().optional(),
-}).strict().refine((b) => b.action === undefined
+    /** (api-types 0.156.0, DES-VOICE) The person answered by voice and confirmed it on screen: recorded on the
+     *  `gate.decided` audit line and the decided-gate history ("by voice, confirmed"). It grants nothing. */
+    input: z.literal('voice').optional(),
+    /** (program DES-LEARN §3.1, api-types 0.160.0) On a steering-author propose gate: the drafted rule ids
+     *  (`GET /governance/steering/author/:runId/draft`) the person keeps. Only those land; the rest are
+     *  declined. Absent = every drafted rule lands, as before. 409 `no_draft` unless the run waits at its
+     *  steering-author propose gate with a readable draft; 400 with anything but a plain approve. */
+    keepRules: z.array(z.string().min(1).max(256)).max(500).optional(),
+}).strict().refine((b) => b.keepRules === undefined || (b.approve && (b.action === undefined || b.action === 'approve') && b.plan === undefined), { message: 'keepRules goes with a plain approve (no action other than approve, no plan) of a steering-author propose gate', path: ['keepRules'] }).refine((b) => b.action === undefined
     || (b.action === 'approve' || b.action === 'edit_plan' || b.action === 'amend_intent' || b.action === OPERATOR_JUDGMENT_ACTION || b.action === SKIP_QE_ACTION || isEscalationAction(b.action)) === b.approve, { message: '`action` disagrees with `approve`: request_changes and reject require approve: false; approve, edit_plan, amend_intent, operator_judgment, skip_qe, extend, targeted, accept_partial, accept_suggestion, rejudge and consent:<id> require approve: true', path: ['action'] }).refine(
 // (operator ruling 2026-10-21) The override's rationale IS its record: a blank one is a 400 here,
 // before the engine is asked.
@@ -607,10 +659,19 @@ export const GuidanceSchema = z.object({
 }).strict();
 /** ~8KB — a guidance note is operator prose, not a document store. */
 const GUIDANCE_MAX_BYTES = 8192;
+/** `POST /runs/:id/cancel` (api-types `CancelRunRequest`): optional, so a bodiless cancel stays valid. */
+const CancelSchema = z.object({
+    reason: z.string().trim().max(2000).optional(),
+    input: z.literal('voice').optional(),
+}).strict();
 const InjectSchema = z.object({
     message: z.string().min(1),
     /** `"all"` broadcasts to every active worker; any other value is a CLI key. */
     target: z.string().min(1).default('all'),
+    /** (api-types 0.161.0, DES-VOICE) The person said this note and confirmed it on screen. A person's only (403 for
+     *  any other actor); kept on the `run.injected` audit line and stamped on the note's queued/injected frames so the
+     *  thread says "You (by voice)". It grants nothing a typed note does not. */
+    input: z.literal('voice').optional(),
 }).strict();
 // The manual reassign lever (crew#442): `cli` omitted lets the engine's council re-pick, the
 // same shape the automatic stall-watchdog escalation uses for an unknown failover target.
@@ -740,6 +801,9 @@ export const ChatOpenSchema = z.object({
     /** (api-types 0.141.0, crew#1157) The read-only workflow every turn runs (`analyze`); see
      *  `chat-workflow.ts`. Omitted ⇒ a plain chat. */
     workflow: z.string().min(1).max(64).optional(),
+    /** (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §6.3) "Ask about this" on a document no open chat holds: seed the
+     *  chat's repositories from the document's recorded binding, after an access check. */
+    seedFromArtifact: z.string().max(200).optional(),
 }).strict();
 /**
  * The `singleSeat` disclosure (crew#641, hole closed in crew#650) — built in ONE place so the 201
@@ -837,6 +901,17 @@ runtime = {}) {
     const seatHealth = runtime.seatHealth ?? new SeatHealthTracker();
     const deliveryFreeze = runtime.deliveryFreeze ?? new DeliveryFreeze();
     registerDeliveryFreezeRoutes(app, { freeze: deliveryFreeze, audit });
+    const voice = runtime.voice ?? {
+        service: new VoiceService({ dir: defaultVoiceDir() }),
+        dashboard: (() => { try {
+            return VoiceDashboardStore.under(crewStateHome());
+        }
+        catch {
+            return null;
+        } })(),
+    };
+    registerVoiceRoutes(app, { voice: voice.service, dashboard: voice.dashboard, audit });
+    const voiceInputs = runtime.voiceInputs ?? new VoiceInjectInputs();
     const openWithOs = runtime.openWithOs ?? openWithSystemDefault;
     const signedIn = runtime.signedIn ?? signedInHeuristic;
     const retryIndex = runtime.retryIndex ?? new RetryIndex();
@@ -845,10 +920,35 @@ runtime = {}) {
     const guidanceIndex = runtime.guidanceIndex ?? new GuidanceIndex();
     const chatScopes = runtime.chatScopes ?? new ChatScopeIndex();
     const chatTurns = runtime.chatTurns ?? new ChatTurnIndex();
+    // DES-LEARN §3.3: the voice a chat in this project is told (the project's override, else the person's).
+    const voiceFor = (projectId) => {
+        const v = runtime.personaVoice?.(projectId ?? null) ?? null;
+        return v === null ? {} : { voice: v };
+    };
     const askPaths = runtime.askPaths ?? new AskPathIndex();
     const chatTranscripts = runtime.chatTranscripts;
     const chatAttachments = runtime.chatAttachments ?? new ChatAttachmentStore();
     const chatHistory = runtime.chatHistory ?? (chatTranscripts !== undefined ? new ChatHistoryStore(chatTranscripts, chatAttachments) : null);
+    // DES-CHAT-ARTIFACTS-001 §14 (A2): what a chat can do with artifacts. Production: `proposals` on and every operation
+    // off — each later slice turns its own on and registers its launcher. The TEST configuration (§13 A2) turns every
+    // operation's resolution on and registers a recording stub that starts nothing.
+    const chatArtifactsStub = runtime.chatArtifactsStub === true;
+    // A3: a real `create` exists whenever the draft seam can launch a proposal-bound draft (the launcher is registered
+    // below, once the bridge pool exists). Production advertises it; the test configuration keeps the recording stub only
+    // for the operations whose slices have not landed.
+    const realCreate = runtime.docBindings !== undefined && runtime.launchBoundDraft !== undefined;
+    const stubOps = realCreate ? ['refine', 'theme', 'demo'] : ['create', 'refine', 'theme', 'demo'];
+    const chatArtifactFlags = chatArtifactsStub
+        ? { context: true, proposals: true, create: true, refine: true, theme: true, demo: true, stub: true, stubOps }
+        : { context: true, proposals: true, create: realCreate, refine: false, theme: false, demo: false };
+    const proposalLaunchers = new LaunchOnceRegistry();
+    if (chatArtifactsStub) {
+        // Under the registered `chats` entry (a new top-level state-home entry would make core refuse every launch), and
+        // not a `.jsonl` there (the boot sweep clears orphaned transcripts by that suffix).
+        const stub = new RecordingStubDispatcher(join(crewStateHome(), 'chats', 'proposal-stub', 'dispatches.ndjson'));
+        for (const kind of stubOps)
+            proposalLaunchers.register(kind, stub);
+    }
     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).
@@ -1157,6 +1257,15 @@ runtime = {}) {
         const chatId = runTimingIndex.chatIdFor(view.session.id);
         if (chatId !== undefined)
             view.session.chat_id = chatId;
+        // DES-CHAT-ARTIFACTS-001 (A3): the proposal a run answers, the artifact it makes, and a landing that failed.
+        const proposalOf = runTimingIndex.proposalOf(view.session.id);
+        if (proposalOf !== undefined) {
+            view.session.proposal_id = proposalOf.proposalId;
+            view.session.artifact_ref = proposalOf.artifactRef;
+        }
+        const landingFailed = runTimingIndex.landingFailedOf(view.session.id);
+        if (landingFailed !== undefined)
+            view.session.landing_failed = landingFailed;
         // crew#552: the onboarding run a chained capture was launched from — ABSENT otherwise.
         const chainedFrom = runTimingIndex.chainedFromOf(view.session.id);
         if (chainedFrom !== undefined)
@@ -1325,6 +1434,15 @@ runtime = {}) {
             workingDoc: app.hasRoute({ method: 'GET', url: `${V}/runs/:id/working-doc` }),
             // (api-types 0.149.0) Power mode: the routes are served AND the engine runs it.
             powerMode: powerSupported(),
+            // (api-types 0.156.0, DES-VOICE) Voice mode's routes are served: local speech to text, the model with
+            // consent, and the per-person dashboard. Whether transcription can run now is `GET /voice/status`.
+            voice: app.hasRoute({ method: 'POST', url: `${V}/voice/transcribe` }),
+            // (api-types 0.168.0, wf-catalog) The categorised workflow catalog with the operator's usage.
+            workflowCatalog: app.hasRoute({ method: 'GET', url: `${V}/workflows/catalog` }),
+            // (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §14) Per operation: A1 serves `context` (the chat sees the open
+            // artifact and the runs the person names; `seedFromArtifact`); A2 (0.170.0) `proposals`. The operations are later
+            // slices (all on, with `stub`, in the test configuration).
+            chatArtifacts: { ...chatArtifactFlags },
         };
         // 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
@@ -1359,6 +1477,7 @@ runtime = {}) {
     // can never turn this GET into an event-log re-reader or a `--version` spawner per request.
     const acpFoldCache = new AcpFoldCache();
     const engineVersionCache = new EngineVersionCache();
+    const floorCacheCache = new FloorCacheCache();
     // The governance block (crew#495): the store the engine's emit seam writes to (as the adapter
     // exported it — `null` on a boot that resolved none), its record count through the engine
     // binding when the addon has one, and the dead-letter outbox folded on change. Built at boot so
@@ -1370,13 +1489,14 @@ runtime = {}) {
         // `dbPath` is a readonly field of the real adapter; a stub-driven route set may lack it,
         // and diagnostics over an unknown store honestly reports no stores and no ACP record.
         const dbPath = typeof adapter.dbPath === 'string' && adapter.dbPath !== '' ? adapter.dbPath : null;
-        const [stores, byCli, engineBinaries, governance] = await Promise.all([
+        const [stores, byCli, engineBinaries, governance, floorCache] = await Promise.all([
             dbPath !== null ? listStoreFiles(dbPath) : Promise.resolve([]),
             dbPath !== null
                 ? acpFoldCache.get(eventsDirOf(dbPath))
                 : Promise.resolve({}),
             engineVersionCache.get(),
             governanceDiagnostics.health(),
+            floorCacheCache.get(),
         ]);
         const uptimeMs = Math.round(process.uptime() * 1000);
         const addr = app.server.address();
@@ -1423,6 +1543,8 @@ runtime = {}) {
             // crew#1068: the wicked-vault CLI handed to the engine, with a remedy when it has none.
             // `null` on a route set driven without the real adapter.
             vault: adapter.vaultBin != null ? vaultDiagnostics(adapter.vaultBin) : null,
+            // crew#1147: the repo-checks floor cache's disk usage (cached 60 s); `null` on an addon without it.
+            floorCache,
         };
     };
     app.get(`${V}/diagnostics`, { config: { manifest: { responseType: 'DiagnosticsResponse', statusCodes: [200] } } }, async () => diagnosticsNow());
@@ -1948,6 +2070,8 @@ runtime = {}) {
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
+        if (refusedMissingFolder(repo, reply))
+            return reply;
         const body = OnboardBodySchema.safeParse(req.body ?? {});
         if (!body.success)
             return reply.code(400).send(invalidBody(body.error, 'Invalid request body'));
@@ -2039,6 +2163,20 @@ runtime = {}) {
         const garden = gardenRefusalBody();
         if (garden !== null)
             return reply.code(422).send(garden);
+        // A run on a repo whose folder is gone could only fail at its first worktree or floor, with the
+        // spawn's ENOENT for a reason: refused here by name, before the engine sees it.
+        // A registry that cannot be read here refuses nothing: the engine judges the ref as before.
+        if (b.repoRef !== undefined) {
+            let target;
+            try {
+                target = (await adapter.listRepos()).find((r) => r.id === b.repoRef);
+            }
+            catch {
+                target = undefined;
+            }
+            if (target !== undefined && refusedMissingFolder(target, reply))
+                return reply;
+        }
         // 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)
@@ -2198,6 +2336,12 @@ runtime = {}) {
             else {
                 input.power = true;
                 input.humanConfirm = 'none';
+                // DES-LEARN §3.3 / wicked-core#1216: the orchestrator talks to the person in their personality
+                // for this project (the project's override, else theirs). The engine hands it to the
+                // orchestrator only; reviewers, judges and QE never hear it.
+                const { voice } = voiceFor(b.projectId);
+                if (voice !== undefined)
+                    input.voice = voice;
             }
         }
         // QE-IN-APP-WORKFLOWS: the operator's explicit skip (with its reason) or force — forwarded only
@@ -2289,6 +2433,20 @@ runtime = {}) {
             catch (err) {
                 req.log.warn(`linked-issue resolution failed; launching on the intent alone: ${message(err)}`);
             }
+            // Run learnings: the approved learnings that apply to this repo/project ride in the brief, in a
+            // marked block the deliver text takes back out (src/learnings/recall.ts). Workflow launches only,
+            // for the linked-issues reason above; best-effort: an unreadable store launches without it.
+            if (runtime.recallLearnings !== undefined && !NO_LEARNINGS_WORKFLOWS.has(b.workflow)) {
+                try {
+                    const recalled = await runtime.recallLearnings(input.problem, b.repoRef ?? null, b.projectId ?? null);
+                    input.problem = recalled.problem;
+                    if (recalled.recalled > 0)
+                        req.log.info(`[learnings] ${input.sessionId}: ${recalled.recalled} approved learning(s) in the brief`);
+                }
+                catch (err) {
+                    req.log.warn(`[learnings] the memory store could not be read; launching without approved learnings: ${message(err)}`);
+                }
+            }
         }
         // DES-RUNS-REVIEW-001 §3: a hand launch of the run review (`/workflow-review-recent-work`) is prepared like a
         // scheduled one: its snapshot written, repo-less, one seat, its review directory as the only write root.
@@ -2313,6 +2471,13 @@ runtime = {}) {
             }
             deliver = 'none';
         }
+        // DES-CHAT-ARTIFACTS-001 §4.3 (A3): one live job per chat, work and artifact runs together. A work launch filed under
+        // a chat whose proposal's document attempt has no outcome yet is refused, as Go is refused the other way round.
+        if (b.chatId !== undefined && chatArtifactFlags.proposals) {
+            const live = await chatProposals.liveJobOf(b.chatId).catch(() => null);
+            if (live !== null)
+                return reply.code(409).send({ code: 'chat_busy', error: `This chat already has a job running (${live}). Wait, or stop that run.` });
+        }
         try {
             const runId = await adapter.launchRun(input);
             // crew#641/#642 (item 5): when a run is promoted from a chat, record how many seats
@@ -2654,6 +2819,47 @@ runtime = {}) {
         await backfillEndedAt([run]);
         return { run: decorateRun(run) };
     });
+    // Run learnings: what a run proposed to the approve queue (its end card, "3 learnings proposed · Review").
+    // Proposals are attributed by provenance (`run_id`); a distil seat still reading the run says so.
+    app.get(`${V}/runs/:id/learnings`, { config: { manifest: { responseType: 'RunLearningsResponse', statusCodes: [200, 404, 501, 502] } } }, async (req, reply) => {
+        const { id } = req.params;
+        if (runtime.runLearnings === undefined)
+            return reply.code(501).send({ error: 'run learnings are not wired on this daemon' });
+        if (!(await adapter.sessions()).includes(id))
+            return reply.code(404).send({ error: 'Run not found' });
+        try {
+            const body = await runtime.runLearnings.view(id);
+            return body;
+        }
+        catch (err) {
+            return estateUpstreamError(reply, err);
+        }
+    });
+    // (program DES-LEARN §3.1) A steering-author run's DRAFTED rules, read before the person decides: the
+    // same sources and the same normalization the landing uses, so the ids a person keeps are the ids
+    // `POST /runs/:id/gate {keepRules}` names. `ready: false` until the propose step has run and its gate
+    // is the run's open gate. Read-only.
+    app.get(`${V}/governance/steering/author/:runId/draft`, { config: { manifest: { responseType: 'SteeringDraftResponse', statusCodes: [200, 404, 500] } } }, async (req, reply) => {
+        const { runId } = req.params;
+        const views = await adapter.sessionsDetail();
+        const run = views.find((v) => v.session.id === runId);
+        if (!run)
+            return reply.code(404).send({ error: 'Run not found' });
+        if (!isSteeringAuthorRun(run))
+            return reply.code(404).send({ error: `run ${runId} is not a steering-author run`, code: 'not_steering_author' });
+        const open = run.session.status === 'awaiting_human' ? await gateOfRecord(run, undefined) : null;
+        const prompt = open !== null && !('refusal' in open) ? open.prompt : undefined;
+        const draft = await draftedSteeringRules(adapter, run, prompt);
+        if (draft !== null && 'unreadable' in draft)
+            return reply.code(500).send({ error: draft.unreadable });
+        const waiting = open !== null && !('refusal' in open) && atProposeGate(run);
+        return {
+            runId,
+            ready: draft !== null && waiting,
+            rules: draft?.rules ?? [],
+            ...(draft !== null ? { source: draft.source } : {}),
+        };
+    });
     // ── Inventory claims (crew#721) — whether each enumerating step's list is complete ──
     // A step that lists things a later step acts on ends its reply with a `wicked-inventory` block
     // (wicked-garden core/refs/inventory-report.md). This reads them off every unit's captured
@@ -3062,7 +3268,7 @@ runtime = {}) {
             manifest: {
                 requestType: 'ChatOpenBody',
                 responseType: 'ChatOpenResponse',
-                statusCodes: [201, 400, 404, 409, 500, 501],
+                statusCodes: [201, 400, 403, 404, 409, 500, 501],
             },
         },
     }, async (req, reply) => {
@@ -3073,11 +3279,87 @@ runtime = {}) {
         const b = parsed.data;
         const chatId = b.chatId ?? randomUUID();
         const requestedRefs = [...(b.repoRef !== undefined ? [b.repoRef] : []), ...(b.repoRefs ?? [])];
+        // The scope kind as the open resolves it: the request's, unless an Ask-about-this seed names the repositories.
+        let scopeKind = b.scopeKind;
         // A named scope's SHAPE first (studio#323 R4, codex on #664): a body whose kind refuses its own
-        // projectId/repoRefs is a 400 — never masked by the project lookup's 404/409 below.
-        const shape = namedKindRefusal(b.scopeKind, b.projectId, [...new Set(requestedRefs)]);
+        // projectId/repoRefs is a 400 — never masked by the project lookup's 404/409 below, nor by a seed's reads.
+        // (A seed asked to fill an empty `repo`/`repos` list is checked once it has filled it, below.)
+        const seedFills = b.seedFromArtifact !== undefined && requestedRefs.length === 0 && (scopeKind === 'repo' || scopeKind === 'repos');
+        const shape = seedFills ? null : namedKindRefusal(scopeKind, b.projectId, [...new Set(requestedRefs)]);
         if (shape !== null)
             return reply.code(400).send({ error: shape.error });
+        // DES-CHAT-ARTIFACTS-001 §6.3 (A1): "Ask about this" on a document no open chat holds. Access first (a person,
+        // a document that exists), then the scope rule: a chat in no project, or a project chat whose project is the
+        // document's mount and holds every repository the document was made about. Only then are the chat's
+        // repositories seeded from that binding — and only when the request names none and no kind that refuses them.
+        if (b.seedFromArtifact !== undefined) {
+            const seed = parseArtifactRef(b.seedFromArtifact);
+            if (seed === null)
+                return reply.code(400).send({ code: 'seed_invalid', error: 'seedFromArtifact must be <mount>/<doc>' });
+            if (actorOf(req).kind !== 'human') {
+                return reply.code(403).send({ code: 'seed_refused', error: 'only a person can open a chat about a document' });
+            }
+            // Scope before any read: a project chat may be seeded only from a document in that project.
+            const chatMountOf = chatMount(b.projectId);
+            if (chatMountOf !== null && seed.mount !== chatMountOf) {
+                return reply.code(400).send({
+                    code: 'seed_out_of_scope',
+                    error: `${seed.ref} is ${seed.mount === UNFILED_MOUNT ? 'Unfiled' : `in project ${seed.mount}`}, not in project ${b.projectId}; open the chat in its project, or in no project`,
+                });
+            }
+            let root;
+            try {
+                root = await projectDocsRoot(adapter, projectSettings, seed.projectId);
+            }
+            catch (err) {
+                return reply.code(500).send({ error: `cannot read ${seed.ref}: ${message(err)}` });
+            }
+            const status = root === null ? 'missing' : artifactStatus(root, seed.doc);
+            if (status === 'unsupported') {
+                return reply.code(501).send({ code: 'seed_unsupported', error: 'this platform cannot read a document without following links in its folders' });
+            }
+            if (root === null || status === 'missing') {
+                return reply.code(404).send({ code: 'seed_not_found', error: `no document ${seed.ref} on this daemon` });
+            }
+            // The repositories the document was grounded on, as its draft launch resolved them (inferred from the brief or
+            // the project's one repository too); the create-time request's list only for a binding that predates that.
+            // Read beneath the docs root like every A1 read (crew#1274).
+            const grounding = readGroundingBeneath(root, seed.doc);
+            if (grounding !== null && 'unreadable' in grounding) {
+                return reply.code(409).send({ code: 'seed_binding_unreadable', error: `what ${seed.ref} was made about cannot be read; open the chat without it` });
+            }
+            const bound = grounding?.repoRefs ?? [];
+            if (b.projectId !== undefined && bound.length > 0) {
+                const members = new Set((await projectRepoCandidates(adapter, b.projectId)).map((r) => r.repoRef));
+                const outside = bound.filter((r) => !members.has(r));
+                if (outside.length > 0) {
+                    return reply.code(400).send({
+                        code: 'seed_out_of_scope',
+                        error: `${seed.ref} was made about ${outside.join(', ')}, which project ${b.projectId} does not hold; open the chat in no project`,
+                    });
+                }
+            }
+            // Seeded: the chat reads the repositories the document was made about, unless the request named its own or a
+            // kind that reads every repository (`everything`) or names its repositories by project (`project`). A chat in
+            // no project that asked for no repository (`system`, `none`) becomes the document's repository scope; a
+            // project chat keeps the kind it asked for.
+            const seedable = b.projectId === undefined
+                ? scopeKind === undefined || scopeKind === 'repo' || scopeKind === 'repos' || scopeKind === 'system' || scopeKind === 'none'
+                : scopeKind === undefined || scopeKind === 'repo' || scopeKind === 'repos';
+            if (requestedRefs.length === 0 && bound.length > 0 && seedable) {
+                // Only where the binding becomes the chat's repository list does a chat's limit apply (an `everything` or
+                // `project` chat, or one that names its own repositories, reads its own scope whatever the binding holds).
+                if (bound.length > 32) {
+                    return reply.code(400).send({ code: 'seed_too_many_repos', error: `${seed.ref} was made about ${bound.length} repositories; a chat reads at most 32 — open it in its project or across all repositories` });
+                }
+                requestedRefs.push(...bound);
+                if (scopeKind === 'system' || scopeKind === 'none')
+                    scopeKind = undefined;
+            }
+            const reshaped = namedKindRefusal(scopeKind, b.projectId, [...new Set(requestedRefs)]);
+            if (reshaped !== null)
+                return reply.code(400).send({ error: reshaped.error });
+        }
         // Validate the project BEFORE opening seats: a chat has no launch record for the engine to
         // attach against atomically (chats are an in-memory seat pool), so the route validates
         // up-front and attaches right after open — the one non-atomic attach, documented in the ADR
@@ -3114,7 +3396,7 @@ runtime = {}) {
                 return reply.code(resolved.status).send({ error: resolved.error });
             workflow = resolved.workflow;
         }
-        const statementOpts = { analysis: workflow !== undefined };
+        const statementOpts = { analysis: workflow !== undefined, make: chatProposals.digest() };
         // A chat id this daemon already holds a scope for is LIVE: re-preparing its scratch root and
         // re-opening it would overwrite the statement its seats are reading and (on a changed scope)
         // evict them mid-conversation (Copilot, #518). Close it first, or let the daemon mint the id.
@@ -3140,7 +3422,7 @@ runtime = {}) {
                 chatId,
                 ...(b.projectId !== undefined ? { projectId: b.projectId } : {}),
                 repoRefs: requestedRefs,
-                ...(b.scopeKind !== undefined ? { kind: b.scopeKind } : {}),
+                ...(scopeKind !== undefined ? { kind: scopeKind } : {}),
             };
             const resolution = await resolveScope(scopeRequest, req);
             if (!resolution.ok) {
@@ -3148,6 +3430,7 @@ runtime = {}) {
                 return reply.code(resolution.status).send({
                     error: resolution.error,
                     ...(resolution.missing !== undefined ? { missing: resolution.missing } : {}),
+                    ...(resolution.code !== undefined ? { code: resolution.code, path: resolution.path ?? null } : {}),
                 });
             }
             const { scope, engine } = resolution;
@@ -3162,7 +3445,7 @@ runtime = {}) {
                 if (!chatScopes.owns(chatId, token)) {
                     return reply.code(409).send({ error: `chat ${chatId} was closed while it was being opened; open it again` });
                 }
-                prepareChatScratch(chatId, scope, inForceAtOpen, statementOpts);
+                prepareChatScratch(chatId, scope, inForceAtOpen, { ...statementOpts, ...voiceFor(scope.projectId) });
             }
             catch (err) {
                 // The helper removes only what it created itself (a pre-existing root is preserved) —
@@ -3322,6 +3605,8 @@ runtime = {}) {
                         startedOn: b.startedOn,
                         cli: b.primary ?? clis[0] ?? null,
                         actorId: security.authMode === 'required' ? actorOf(req).id : null,
+                        // A2: an ended chat's proposal frames still name its project.
+                        projectId: scope.projectId ?? null,
                     });
                 }
                 catch (err) {
@@ -3387,7 +3672,78 @@ runtime = {}) {
         targets: z.array(z.string().min(1)).min(1).max(8).optional(),
         /** (api-types 0.137.0) Attachment ids from `POST /chats/:id/attachments`. */
         attachments: z.array(z.string().min(1).max(64)).optional(),
+        /** (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §5.1) What studio shows beside the message. */
+        context: ChatMessageContextSchema.optional(),
     }).strict();
+    // DES-CHAT-ARTIFACTS-001 §5.1 (A1): what a turn's block reads — the docs roots, the decorated runs (project,
+    // document and chat ids), unit outputs and the acceptance line. One set of deps, so the block and the run pages
+    // read the same records.
+    const chatContextDeps = {
+        docsRoot: (projectId) => projectDocsRoot(adapter, projectSettings, projectId),
+        runs: async () => (await adapter.sessionsDetail()).map((v) => decorateRun(v)),
+        workOutput: async (unitId) => (typeof adapter.workOutput === 'function' ? adapter.workOutput(unitId) : null),
+        acceptanceLine: async (view) => (await acceptanceViewOf(view, {})).summary.line,
+        docStyle: (root, doc) => {
+            const g = readGroundingBeneath(root, doc);
+            return g !== null && 'style' in g ? g.style : undefined;
+        },
+    };
+    // DES-CHAT-ARTIFACTS-001 §4 (A2): proposals. Resolved from crew's own records (the same reads the turn block uses);
+    // records go to the live transcript, or the kept history copy once the chat has ended.
+    // A dollar figure only from a run whose EVERY dispatched attempt of every agent step reported a price (DES §4.2).
+    const proposalCosts = async (view) => runCostFromEvents(view, (await adapter.runEvents(view.session.id)));
+    const chatProposals = new ChatProposals({
+        flags: () => chatArtifactFlags,
+        catalog: CATALOG_SEEDS,
+        records: (chatId) => chatHistory?.messages(chatId) ?? chatTranscripts?.read(chatId) ?? [],
+        append: (chatId, record) => {
+            if (chatHistory?.stateOf(chatId)?.status === 'closed')
+                return chatHistory.appendKept(chatId, record);
+            return chatTranscripts?.appendProposalRecord(chatId, record) ?? false;
+        },
+        instanceOf: (chatId) => chatHistory?.stateOf(chatId)?.instance ?? null,
+        projectOf: (chatId) => chatScopes.get(chatId)?.projectId ?? chatHistory?.stateOf(chatId)?.projectId ?? null,
+        chat: (chatId) => {
+            const scope = chatScopes.get(chatId);
+            if (scope === undefined)
+                return null;
+            const path = askPaths.get(chatId);
+            return {
+                projectId: scope.projectId ?? null,
+                repos: scope.repos.map((r) => ({ id: r.id, name: r.name })),
+                lead: path?.pa ?? path?.primary ?? null,
+                seats: path?.eligible ?? [],
+                analysis: path?.workflow !== undefined,
+            };
+        },
+        rosterEligible: () => rosterWithStanding()
+            .filter((s) => s.enabled_for_council && s.seat_eligible_for_work !== false && s.auth !== 'signed_out' && s.optIn !== true)
+            .map((s) => ({ key: String(s.key), name: s.display_name || String(s.key) })),
+        runs: async () => (await adapter.sessionsDetail()).map((v) => decorateRun(v)),
+        chatOfRun: (runId) => runTimingIndex.chatIdFor(runId),
+        isAskPath: (runId) => runTimingIndex.isAskPath(runId),
+        docsRoot: (projectId) => projectDocsRoot(adapter, projectSettings, projectId),
+        projectName: async (projectId) => (await adapter.projectGet(projectId).catch(() => null))?.name ?? null,
+        projectRepos: async (projectId) => (await projectRepoCandidates(adapter, projectId, (m) => app.log.warn(m))).map((r) => ({ id: r.repoRef, name: r.name })),
+        attachments: (chatId) => chatAttachments.list(chatId).map((a) => ({ id: a.id, name: a.name, bytes: a.bytes, mediaType: a.mediaType })),
+        repoIds: async () => new Set((await adapter.listRepos()).map((r) => r.id)),
+        workflowSteps: async (name, projectId) => {
+            // The preset a launch in this project resolves first (a project row wins over a global one), then the def.
+            const presets = await adapter.listPresets(projectId ?? undefined).catch(() => []);
+            const preset = presets.find((p) => p.name === name && p.scope !== 'global') ?? presets.find((p) => p.name === name);
+            if (preset !== undefined && preset.steps.length > 0)
+                return preset.steps.length;
+            const phases = adapter.getWorkflow(name)?.phases;
+            return phases !== undefined && phases.length > 0 ? phases.length : null;
+        },
+        runCostUsd: proposalCosts,
+        registry: proposalLaunchers,
+        broadcast: (frame) => runtime.broadcast?.(frame),
+        audit: (event, actor, detail) => {
+            audit.record(event, actor, { detail });
+        },
+        log: (m) => app.log.warn(m),
+    });
     // F-RECON-017: a message sent while a targeted seat is still answering the previous one is
     // REFUSED, not queued. The engine queues silently (the worker gets the text the instant the
     // previous turn's final block lands) and its reply frames carry no message correlation, so the
@@ -3416,6 +3772,22 @@ runtime = {}) {
             return reply.code(409).send({ error: `chat '${id}' has no eligible seat — sign a seat in and re-seat it (POST /chats/:id/seats)` });
         }
         const text = parsed.data.text;
+        // DES-CHAT-ARTIFACTS-001 §5.1 (A1): the per-turn block reads crew's records (documents, runs) for the chat's own
+        // person. A message that carries `context` from anyone else (another actor under `auth: required`, or an agent,
+        // system or plugin actor) is refused before anything is reserved or read; one without `context` from them still
+        // goes through, with no block.
+        const msgContext = parsed.data.context;
+        const sender = actorOf(req);
+        const ownsChat = chatHistory === null || chatHistory.visibleTo(id, security.authMode === 'required' ? sender.id : null);
+        const contextAllowed = sender.kind === 'human' && ownsChat;
+        if (msgContext !== undefined && !contextAllowed) {
+            return reply.code(403).send({
+                code: 'chat_context_refused',
+                error: sender.kind !== 'human'
+                    ? `only a person can send what they are looking at with a chat message (you are a ${sender.kind} actor). Nothing was sent.`
+                    : `chat '${id}' was opened by someone else; only its owner can send what they are looking at into it. Nothing was sent.`,
+            });
+        }
         // DES-SYSTEM-CHAT: the attachments this message carries — every id this chat's, within the caps,
         // refused before anything is reserved or sent.
         let attached = [];
@@ -3463,6 +3835,8 @@ runtime = {}) {
         // crew#826: the turn lives as long as its answer step may (`budget_secs`), not 3× the pool knob.
         let turn = null;
         let turnId = randomUUID();
+        // A1: what this turn's seats were given beside the words (recorded with the turn).
+        let turnBinding = null;
         // What an ACCEPTED message records — the engine has it, so a persistence failure here is
         // logged, never a retraction of a turn that is already being answered (codex on #808 r2, 9).
         const persistAccepted = (preface, after) => {
@@ -3470,7 +3844,9 @@ runtime = {}) {
                 after();
                 if (preface !== null)
                     chatTranscripts?.appendSystem(id, turnId, preface);
-                chatTranscripts?.appendUser(id, turnId, text, voice, attached.map(attachmentWire));
+                chatTranscripts?.appendUser(id, turnId, text, voice, attached.map(attachmentWire), contextAllowed);
+                if (turnBinding !== null)
+                    chatTranscripts?.appendContext(id, turnId, turnBinding);
                 // The recorder's audience is the turn's AS THE TURN INDEX HOLDS IT NOW: the eligible roster
                 // for a random pick, or the PA the relay narrowed it to during the engine awaits above
                 // (`path.started` / `path.repicked` may land before this record exists — ASK-C2, codex on
@@ -3567,6 +3943,31 @@ runtime = {}) {
                 });
             }
             const pending = await considerations.pendingPreface(id, { inForce: rules });
+            // DES-CHAT-ARTIFACTS-001 §5.1 (A1): the turn's block — scope checked before anything is read or copied; the
+            // copies and briefs land in the scratch root's `open/` and `context/`, read roots of the chat's run.
+            // Built in memory here (it awaits); its files are written only after the last check below, with no await between.
+            let contextBlock = '';
+            let publishContext = () => undefined;
+            if (scope !== undefined && contextAllowed) {
+                try {
+                    const built = await buildTurnContext({
+                        chatId: id,
+                        scratchRoot: scope.cwd,
+                        projectId: scope.projectId ?? null,
+                        text,
+                        context: msgContext,
+                        records: chatTranscripts?.read(id) ?? [],
+                        attachmentIds: chatAttachments.list(id).map((a) => a.id),
+                    }, chatContextDeps);
+                    contextBlock = built.block;
+                    turnBinding = built.binding;
+                    publishContext = built.publish;
+                }
+                catch (err) {
+                    askPaths.release(id, lease);
+                    return reply.code(500).send({ error: `could not prepare what this message is about: ${message(err)}. Nothing was sent.` });
+                }
+            }
             // The last await before delivery may also have closed/reopened the chat. From this check
             // through publication and the send there is no await, so no executing turn's files change.
             if (askPaths.get(id)?.generation !== lease || chatScopes.get(id) !== storedScope) {
@@ -3574,7 +3975,7 @@ runtime = {}) {
             }
             if (storedScope !== undefined && scope !== undefined && engine !== undefined &&
                 (JSON.stringify(scope) !== JSON.stringify(storedScope) || JSON.stringify(engine) !== JSON.stringify(chatScopes.engineOf(id)))) {
-                prepareChatScratch(id, scope, rules, { analysis: path.workflow !== undefined });
+                prepareChatScratch(id, scope, rules, { analysis: path.workflow !== undefined, make: chatProposals.digest(), ...voiceFor(scope.projectId) });
                 if (chatScopes.refresh(id, storedScope, scope, engine)) {
                     chatTranscripts?.registerRoots(id, scope.repos.map((r) => ({ absRoot: resolve(r.rootPath), name: r.name })));
                 }
@@ -3595,6 +3996,22 @@ runtime = {}) {
                     return reply.code(500).send({ error: `could not stage the attachments for the seat: ${message(err)}` });
                 }
             }
+            // A1: the copies and briefs land now — after the last await and the generation check, before the send — and the
+            // block rides after the person's words (and their files), labelled as data.
+            if (contextBlock !== '') {
+                try {
+                    publishContext();
+                }
+                catch (err) {
+                    askPaths.release(id, lease);
+                    return reply.code(500).send({ error: `could not hand the seat what this message is about: ${message(err)}. Nothing was sent.` });
+                }
+                seatText = `${seatText}\n\n${contextBlock}`;
+            }
+            // A2: the per-message digest of what the chat can make now (advertised operations only; never in an analysis).
+            const makeDigest = path.workflow === undefined ? chatMakeDigest(chatProposals.digest()) : '';
+            if (makeDigest !== '')
+                seatText = `${seatText}\n\n${makeDigest}`;
             voice = path.pa !== null ? [path.pa] : [];
             // A random pick reserves every eligible seat until the relay names the PA.
             audience = voice.length > 0 ? voice : path.eligible;
@@ -3604,7 +4021,8 @@ runtime = {}) {
             // chat (crew#1157) never delivers: it is bound to its repository read-only, with no deliver.
             const repoRef = scope?.kind === 'repos' && scope.repos.length === 1 ? scope.repos[0].id : undefined;
             const delivers = repoRef !== undefined && path.workflow === undefined;
-            const statementOpts = { analysis: path.workflow !== undefined };
+            // A2: the per-message digest of what the chat can make now (advertised operations only).
+            const statementOpts = { analysis: path.workflow !== undefined, make: chatProposals.digest(), ...voiceFor(scope?.projectId) };
             const projectId = scope?.projectId;
             if (path.runId === undefined) {
                 const stepId = 'answer-1';
@@ -3631,8 +4049,20 @@ runtime = {}) {
                     // statement tells the seats to read them at their paths, so the boundary must let them.
                     // DES-SYSTEM-CHAT: plus the chat's attachments directory, from launch (a run cannot gain a
                     // read root later), so a file attached on any later turn is readable too.
-                    ...(readRoots.length > 0 || attachRoot !== null
-                        ? { extraReadRoots: [...readRoots, ...(attachRoot !== null ? [ensureDir(attachRoot)] : [])] }
+                    // DES-CHAT-ARTIFACTS-001 §5.1 (A1): and the directories the turn blocks copy artifacts (`open/`) and write run
+                    // briefs (`context/`) into, from launch, so a later turn's copies and briefs are readable too.
+                    ...(readRoots.length > 0 || attachRoot !== null || scope !== undefined
+                        ? {
+                            extraReadRoots: [
+                                ...readRoots,
+                                ...(attachRoot !== null ? [ensureDir(attachRoot)] : []),
+                                // At their real paths: a seat in a container sees a read root only there (see `seatPathOf`). Named from the
+                                // trusted scratch root's real path, never a child's (a child is the seat's to change; and no seat of this
+                                // chat exists yet: this is its first launch). Left out where the platform cannot write them safely, and
+                                // when they cannot be made: a plain chat still launches.
+                                ...(scope !== undefined ? turnReadRoots(scope.cwd) : []),
+                            ],
+                        }
                         : {}),
                 };
                 const runId = await adapter.launchRun(input);
@@ -3715,6 +4145,56 @@ runtime = {}) {
             return reply.code(400).send({ error: message(err) });
         }
     });
+    // DES-CHAT-ARTIFACTS-001 §4.3 (A2): the ONLY way a proposal starts work. Capability, person and owner are checked
+    // first on every call (a worker or system actor is refused even on an `accepting` proposal); the service then takes
+    // the proposal's lock and looks for what already happened before any state check.
+    const ProposalPatchValue = z.union([z.string().max(200), z.number(), z.boolean()]);
+    const ProposalDecisionSchema = z.object({
+        decision: z.enum(['go', 'not_now']),
+        edits: z.object({
+            title: z.string().max(400).optional(),
+            brief: z.string().max(16000).optional(),
+            sources: z.array(z.string().min(1).max(300)).max(32).optional(),
+            repos: z.array(z.string().min(1).max(200)).max(16).optional(),
+            project: z.string().max(200).nullable().optional(),
+            ask: z.string().max(8000).optional(),
+            allow: z.array(z.string().min(1).max(128)).max(64).optional(),
+            name: z.string().max(200).optional(),
+            patch: z.record(z.string().max(40), ProposalPatchValue).optional(),
+            url: z.string().max(2048).optional(),
+            audience: z.string().max(800).optional(),
+            show: z.string().max(4000).optional(),
+            helpers: z.array(z.string().min(1).max(64)).max(8).optional(),
+        }).strict().optional(),
+    }).strict();
+    app.post(`${V}/chats/:id/proposals/:pid`, { config: { manifest: { requestType: 'ChatProposalDecisionBody', responseType: 'ChatProposalDecisionResponse', statusCodes: [200, 400, 403, 404, 409, 502] } } }, async (req, reply) => {
+        const { id, pid } = req.params;
+        if (!chatArtifactFlags.proposals)
+            return reply.code(404).send({ error: 'this daemon does not answer chat proposals' });
+        const actor = actorOf(req);
+        if (!isHumanOperator(actor)) {
+            audit.record('chat.proposal.refused', actor, { detail: { chatId: id, pid, reason: 'not_a_person' } });
+            return reply.code(403).send({
+                code: 'proposal_refused',
+                error: `only a person answers a proposal (you are ${actor.kind}/${actor.trust}). Nothing was started.`,
+            });
+        }
+        const viewer = security.authMode === 'required' ? actor.id : null;
+        if (!CHAT_ID.test(id) || chatHistory === null || !chatHistory.visibleTo(id, viewer)) {
+            return reply.code(404).send({ error: `no chat ${id} on this daemon` });
+        }
+        // The instance these checks passed against: nothing is recorded on a chat that reuses the id meanwhile.
+        const instance = chatHistory.stateOf(id)?.instance ?? null;
+        const parsed = ProposalDecisionSchema.safeParse(req.body);
+        if (!parsed.success)
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+        // Optional fields arrive as absent, never as `undefined` (the contract's exact optional shape).
+        const edits = parsed.data.edits === undefined
+            ? undefined
+            : Object.fromEntries(Object.entries(parsed.data.edits).filter(([, v]) => v !== undefined));
+        const out = await chatProposals.decide(id, pid, { decision: parsed.data.decision, ...(edits !== undefined ? { edits } : {}) }, actor, instance);
+        return reply.code(out.code).send(out.body);
+    });
     const ChatSeatsSchema = z.object({
         clis: z.array(z.string().min(1)).min(1).max(8),
     }).strict();
@@ -4617,6 +5097,21 @@ runtime = {}) {
             // holds nothing after a restart and another gate's words after a late frame.
             const steeringPropose = parsed.data.approve && isSteeringAuthorRun(run);
             const gatePrompt = steeringPropose ? decided.prompt : undefined;
+            // DES-LEARN §3.1: `keepRules` names drafted rules: on a steering-author propose gate only, and only
+            // ids of THIS draft. A draft that changed since the person read it is a 409, the gate left open.
+            let keptSnapshot;
+            if (parsed.data.keepRules !== undefined) {
+                const draft = steeringPropose && atProposeGate(run) ? await draftedSteeringRules(adapter, run, gatePrompt) : null;
+                if (draft === null || 'unreadable' in draft) {
+                    return { code: 409, body: { error: 'keepRules answers a steering-author propose gate with a readable draft; this gate has none', code: 'no_draft' } };
+                }
+                const ids = new Set(draft.rules.map((r) => r.id));
+                const unknown = parsed.data.keepRules.filter((k) => !ids.has(k));
+                if (unknown.length > 0) {
+                    return { code: 409, body: { error: `the draft changed since it was read (no drafted rule ${unknown.join(', ')}): read it again`, code: 'draft_changed' } };
+                }
+                keptSnapshot = draft.snapshot;
+            }
             try {
                 // All five positionals, explicit `undefined` for the absent ones (DES-L1 PR-2; the
                 // gate-arms tripwire pins the arity). An engine refusal (no creator to send back to,
@@ -4646,6 +5141,7 @@ runtime = {}) {
                         ...(parsed.data.amendScope !== undefined ? { amendScope: parsed.data.amendScope } : {}),
                         ...(parsed.data.plan !== undefined ? { planSteps: parsed.data.plan.steps.length } : {}),
                         ...(parsed.data.ord !== undefined ? { ord: parsed.data.ord } : {}),
+                        ...(parsed.data.input !== undefined ? { input: parsed.data.input } : {}),
                         ...extraDetail,
                         status,
                     },
@@ -4672,7 +5168,10 @@ runtime = {}) {
                 // text (an operator who wants different rules rejects and re-authors). A reject lands
                 // nothing — the run cancels and the proposal stays an artifact.
                 const landing = steeringPropose
-                    ? await landSteeringProposal({ adapter, audit, actor }, run, gatePrompt)
+                    ? await landSteeringProposal({ adapter, audit, actor }, run, gatePrompt, {
+                        ...(parsed.data.keepRules !== undefined ? { keep: parsed.data.keepRules } : {}),
+                        ...(keptSnapshot !== undefined ? { snapshot: keptSnapshot } : {}),
+                    })
                     : undefined;
                 return {
                     code: 200,
@@ -4709,15 +5208,25 @@ runtime = {}) {
         return reply.code(out.code).send(out.body);
     });
     // Cancel a running or paused run (distinct third action, §11.1).
+    // (api-types 0.161.0, DES-VOICE) An optional body: the person's `reason` (said or typed) and `input: "voice"`, both
+    // kept on the `run.cancelled` audit line. A bodiless cancel is unchanged; voice is a person's only (403).
     app.post(`${V}/runs/:id/cancel`, async (req, reply) => {
         const { id } = req.params;
+        // A bodiless cancel arrives as undefined, null or '' (an empty text/plain body): all three are no body.
+        const parsed = CancelSchema.safeParse(req.body === undefined || req.body === null || req.body === '' ? {} : req.body);
+        if (!parsed.success)
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+        const reason = parsed.data.reason !== undefined && parsed.data.reason !== '' ? parsed.data.reason : null;
+        const spoken = parsed.data.input === 'voice';
+        if (spoken && !isHumanOperator(actorOf(req)))
+            return reply.code(403).send({ error: 'Only a person speaks: input "voice" is a person\'s stop' });
         const views = await adapter.sessionsDetail();
         const run = views.find((v) => v.session.id === id);
         if (!run)
             return reply.code(404).send({ error: 'Run not found' });
         try {
             const status = await adapter.cancelRun(id);
-            audit.record('run.cancelled', actorOf(req), { runId: id, detail: { status } });
+            audit.record('run.cancelled', actorOf(req), { runId: id, detail: { status, ...(reason !== null ? { reason } : {}), ...(spoken ? { input: 'voice' } : {}) } });
             return reply.send({ status });
         }
         catch (err) {
@@ -4738,6 +5247,15 @@ runtime = {}) {
             // but its work is complete and liftable — normalize to `completed` so the terminal branch
             // below refuses resume with the DELIVER recovery (POST /runs/:id/deliver), not a re-entry.
             const conflictStrand = normalizeStranded(run);
+            // DES-CHAT-ARTIFACTS-001 §6.2 (A3): a chat proposal's FAILED attempt is never resumed from its cursor: its seam flight
+            // is gone (a resume would finish without landing anything) and its retry may already run. Try again is the path.
+            // A still-live bound run's own gate is approved as any run's.
+            if (run.session.status === 'failed' && runtime.docBindings?.isBound(id) === true) {
+                return reply.code(409).send({
+                    error: `run ${id} answered a chat proposal: it cannot be resumed. Use Try again on its card in the chat (a new attempt at the same document).`,
+                    recovery: 'retry',
+                });
+            }
             // A TERMINAL run is refused LOUDLY, with the actual recovery named (crew#311 defect 2).
             // The engine's `resume_run` no-ops on completed/cancelled and answers the status token, so
             // this route used to reply 200 {"status":"cancelled"} — on the exact runs an operator was
@@ -4818,12 +5336,27 @@ runtime = {}) {
         if (!parsed.success) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
+        const spoken = parsed.data.input === 'voice';
+        if (spoken && !isHumanOperator(actorOf(req)))
+            return reply.code(403).send({ error: 'Only a person speaks: input "voice" is a person\'s note' });
         const ids = await adapter.sessions();
         if (!ids.includes(id))
             return reply.code(404).send({ error: 'Run not found' });
         try {
-            await adapter.injectWorkerMessage(id, parsed.data.message, parsed.data.target);
-            audit.record('run.injected', actorOf(req), { runId: id, detail: { target: parsed.data.target } });
+            // Remembered BEFORE the engine call (its queued frame can reach /ws before the call returns), and forgotten if
+            // the engine refuses it: a send that never happened labels nothing and evicts nothing.
+            const token = spoken ? voiceInputs.remember(id, parsed.data.message, parsed.data.target) : null;
+            try {
+                await adapter.injectWorkerMessage(id, parsed.data.message, parsed.data.target);
+            }
+            catch (err) {
+                if (token !== null)
+                    voiceInputs.forget(id, token);
+                throw err;
+            }
+            if (token !== null)
+                voiceInputs.settle(id);
+            audit.record('run.injected', actorOf(req), { runId: id, detail: { target: parsed.data.target, ...(spoken ? { input: 'voice' } : {}) } });
             // DC-S4a host: the operator's mid-run steering text (review S9).
             if (decisions !== null) {
                 decisions.track(ingestDecision(decisions, {
@@ -5399,8 +5932,12 @@ runtime = {}) {
         /** Guards against stale-tab submissions: must match the current elicitation's id. */
         elicitationId: z.string().min(1),
         action: z.enum(['accept', 'decline', 'cancel']),
-        /** Required when action is "accept" (response must be non-empty); must be absent for decline/cancel. */
-        content: z.object({ response: z.string().min(1) }).optional(),
+        /** Required when action is "accept"; must be absent for decline/cancel. `response` answers a free-text or
+         *  single-choice question; `values` (api-types 0.158.0) a multi-select one. */
+        content: z.union([
+            z.object({ response: z.string().min(1) }).strict(),
+            z.object({ values: z.array(z.string().min(1)).min(1).max(100) }).strict(),
+        ]).optional(),
     })
         .strict()
         .superRefine((val, ctx) => {
@@ -5420,9 +5957,9 @@ runtime = {}) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
         const body = parsed.data;
-        // 1b. Accept requires content.response — validated here, before any state query, so
-        //     the 400 is deterministic regardless of run-existence / cache state (P2).
-        if (body.action === 'accept' && !body.content?.response) {
+        // 1b. Accept requires content (a response, or a multi-select's values) — validated here, before any state
+        //     query, so the 400 is deterministic regardless of run-existence / cache state (P2).
+        if (body.action === 'accept' && body.content === undefined) {
             return reply.code(400).send({ error: 'action:accept requires content.response' });
         }
         // 2. Existence check (IDs only — cheaper than sessionsDetail).
@@ -5441,20 +5978,40 @@ runtime = {}) {
                 .send({ error: 'Elicitation superseded; fetch the current prompt and resubmit' });
         }
         // 5. Accept-specific validation.
+        let response = null;
+        let picked = null;
         if (body.action === 'accept') {
-            // 5a. content.response must be present.
-            if (typeof body.content?.response !== 'string') {
+            const refuse = (error) => {
                 elicitationCache.restoreIfUnchanged(id, taken.entry, taken.gen);
-                return reply.code(400).send({ error: 'action:accept requires content.response' });
+                return reply.code(400).send({ error });
+            };
+            const multi = taken.entry.multi;
+            if (multi !== undefined) {
+                // 5a. A multi-select is answered with `values`: distinct options, min..=max of them, sent in option order.
+                if (body.content === undefined || !('values' in body.content))
+                    return refuse('this question takes content.values (pick several)');
+                const values = body.content.values;
+                const options = taken.entry.options ?? [];
+                if (values.some((v) => !options.includes(v)))
+                    return refuse('values must be among the allowed options');
+                if (new Set(values).size !== values.length)
+                    return refuse('values must name each option once');
+                if (values.length < multi.min || values.length > multi.max)
+                    return refuse(`pick ${multi.min} to ${multi.max} of the options`);
+                picked = options.filter((o) => values.includes(o));
+                response = JSON.stringify(picked);
             }
-            // 5b. Enum check: if the schema constrained the response, honour it.
-            if (taken.entry.options !== null &&
-                !taken.entry.options.includes(body.content.response)) {
-                elicitationCache.restoreIfUnchanged(id, taken.entry, taken.gen);
-                return reply.code(400).send({ error: 'response must be one of the allowed options' });
+            else {
+                // 5b. content.response must be present; `values` answers only a multi-select.
+                if (body.content === undefined || !('response' in body.content))
+                    return refuse('action:accept requires content.response');
+                // 5c. Enum check: if the schema constrained the response, honour it.
+                if (taken.entry.options !== null && !taken.entry.options.includes(body.content.response)) {
+                    return refuse('response must be one of the allowed options');
+                }
+                response = body.content.response;
             }
         }
-        const response = body.action === 'accept' ? body.content.response : null;
         // 6. Forward to the actor.
         try {
             await adapter.resolveElicitation(id, taken.entry.elicitationId, body.action, response);
@@ -5471,12 +6028,12 @@ runtime = {}) {
         });
         // 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;
+            const hasOptions = 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 } : {}),
+                words: response !== null && !hasOptions ? response : '',
+                ...(picked !== null ? { choice: picked.join(', ') } : response !== null && hasOptions ? { choice: response } : body.action !== 'accept' ? { choice: body.action } : {}),
                 projectId: projects.index.projectOf(id) ?? null,
                 runId: id,
                 elicitationId: taken.entry.elicitationId,
@@ -5536,7 +6093,9 @@ runtime = {}) {
             .map((t) => t.trim())
             .filter(Boolean);
         const wanted = names.length > 0 ? new Set(names) : null;
-        const filtered = wanted ? events.filter((e) => wanted.has(e.type)) : events;
+        // DES-VOICE: a note said by voice reads "You (by voice)" on a reloaded thread too (this daemon's memory).
+        const stamped = voiceInputs.stampHistory(id, events);
+        const filtered = wanted ? stamped.filter((e) => wanted.has(e.type)) : stamped;
         return { runId: id, total: events.length, returned: filtered.length, events: filtered };
     });
     // ── Governance reads (crew#40) ──────────────────────────────────────────────
@@ -5929,6 +6488,46 @@ runtime = {}) {
         const { workflows, unavailable } = await adapter.workflowCatalog();
         return { workflows, unavailable };
     });
+    // wf-catalog (api-types 0.168.0): the workflows as a categorised catalog with the requesting
+    // operator's usage. Metadata is the ONE data module (`workflow-catalog/catalog-data.ts`); what a
+    // workflow is and does stays on its def; usage is derived from the runs and the launch trail.
+    app.get(`${V}/workflows/catalog`, { config: { manifest: { responseType: 'WorkflowCatalogResponse', statusCodes: [200, 400] } } }, async (req, reply) => {
+        const raw = req.query?.projectId;
+        if (raw !== undefined && (typeof raw !== 'string' || raw.length > 200)) {
+            return reply.code(400).send({ error: '`projectId` must be a string' });
+        }
+        const projectId = typeof raw === 'string' && raw !== '' ? raw : null;
+        const { workflows } = await adapter.workflowCatalog();
+        let presets = [];
+        try {
+            presets = await adapter.listPresets(projectId ?? undefined);
+        }
+        catch (err) {
+            // An unknown project: the global presets (built-in attribution and saved ones still hold, agy r1).
+            // An engine without presets lists the served defs only. Either way, said once in the log.
+            app.log.warn(`workflows/catalog: the presets could not be read${projectId !== null ? ` for project ${projectId}` : ''} (${message(err)}); listing ${projectId !== null ? 'the global ones' : 'the served workflows only'}`);
+            if (projectId !== null)
+                presets = await adapter.listPresets().catch(() => []);
+        }
+        const views = await adapter.sessionsDetail();
+        // codex r1: date terminal runs that have no `run.ended` entry from their event log, as GET /runs
+        // does, so the median does not depend on which read came first. Only THIS principal's completed
+        // runs can reach a median, so only they are read (Copilot).
+        const me = actorOf(req).id;
+        await backfillEndedAt(views.filter((v) => v.session.status === 'completed' && runTimingIndex.principalFor(v.session.id) === me));
+        const runs = views.map((view) => ({
+            id: view.session.id,
+            workflow: runIdentityOf(view).name,
+            projectId: projects.index.projectOf(view.session.id) ?? null,
+            status: view.session.status,
+            createdAt: runTimingIndex.createdAtFor(view.session.id),
+            endedAt: runTimingIndex.endedAtFor(view.session.id),
+            retryOf: retryIndex.retryOfFor(view.session.id),
+            principal: runTimingIndex.principalFor(view.session.id),
+        }));
+        const body = buildWorkflowCatalog({ defs: workflows, presets, runs, actorId: me, projectId });
+        return body;
+    });
     app.get(`${V}/workflows/:id`, async (req, reply) => {
         const { id } = req.params;
         const workflow = adapter.getWorkflow(id);
@@ -5970,31 +6569,27 @@ runtime = {}) {
             return reply.code(500).send({ error: message(err) });
         }
     });
-    // ── Domain-model browser (crew#44) ────────────────────────────────────────
-    // Reads the `requirements_graph.json` artifact produced by `wicked-core domain-graph`.
-    // Path: `.wicked-estate/requirements/requirements_graph.json` relative to cwd.
-    app.get(`${V}/domain-graph`, async (_req, reply) => {
-        const path = join(process.cwd(), '.wicked-estate', 'requirements', 'requirements_graph.json');
-        try {
-            const content = await fsp.readFile(path, 'utf8');
-            return { graph: JSON.parse(content) };
-        }
-        catch (err) {
-            if (err.code === 'ENOENT')
-                return { graph: null };
-            return reply.code(500).send({ error: message(err) });
-        }
-    });
+    // ── Domain-model browser (crew#44) — RETIRED ──────────────────────────────
+    // This read `<daemon cwd>/.wicked-estate/requirements/requirements_graph.json`. A requirements
+    // graph lives in its repository's estate store now (operator ruling 2026-10-31) and has a
+    // repository: `GET /repos/:id/domain-graph` and `GET /repos/:id/requirements` read it. Answering
+    // from a file here would serve a stale graph forever, so the route says where to go instead.
+    app.get(`${V}/domain-graph`, async (_req, reply) => reply.code(410).send({
+        error: 'The daemon-wide domain graph is retired: a requirements graph belongs to a repository and lives in its estate store. Read GET /api/v1/repos/:id/domain-graph or GET /api/v1/repos/:id/requirements.',
+        code: 'movedToRepository',
+    }));
     // ── Per-repo domain graph ─────────────────────────────────────────────────
-    // Reads requirements_graph.json from the repo root. Coverage stats come from
-    // the live estate store via `wicked-core coverage --json` (not a cached file).
+    // The graph is read from the repo's estate store through the engine (operator ruling 2026-10-31:
+    // never a JSON file in the repo). Coverage stats come from the live estate store via
+    // `wicked-core coverage --json` (not a cached file).
     app.get(`${V}/repos/:id/domain-graph`, async (req, reply) => {
         const { id } = req.params;
         const repos = await adapter.listRepos();
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
-        const graphPath = requirementsGraph(repo);
+        if (refusedMissingFolder(repo, reply))
+            return reply;
         const dbPath = codeGraphDbOr503(repo, reply);
         if (dbPath === null)
             return reply;
@@ -6023,13 +6618,12 @@ runtime = {}) {
             }
         }
         try {
-            const content = await fsp.readFile(graphPath, 'utf8');
-            return { graph: JSON.parse(content), coverage };
+            const read = await readRequirementsGraph(repo, adapter);
+            return { graph: read.graph, coverage };
         }
         catch (err) {
-            if (err.code === 'ENOENT')
-                return { graph: null, coverage };
-            return reply.code(500).send({ error: message(err) });
+            const status = codeGraphErrorStatus(err);
+            return reply.code(status ?? 500).send({ error: message(err) });
         }
     });
     // ── Repo code graph (via wicked-estate graph-view) ──────────────────────────
@@ -6056,8 +6650,9 @@ runtime = {}) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid query'));
         }
         let page;
+        let coverage = null;
         try {
-            page = await listRequirements(repo, parsed.data);
+            ({ page, coverage } = await listRequirementsRead(repo, parsed.data, adapter));
         }
         catch (err) {
             // wicked-core#406: a CURRENT engine with no repo-graph root is a 503, not a 500.
@@ -6067,7 +6662,12 @@ runtime = {}) {
             return reply.code(status).send({ error: message(err) });
         }
         if (page === null) {
-            return reply.code(404).send({ error: 'requirements_graph.json not generated for this repo yet' });
+            // Not generated yet is a state, typed by `code`, not a refusal (lane repo-page). It says how
+            // far the repository is ("23% real requirements · 4397 placeholders · target 80%";
+            // wicked-core#1233), from the very engine read the page used, when it has a store to count.
+            return reply
+                .code(404)
+                .send(coverage === null ? REQUIREMENTS_NOT_GENERATED : { ...REQUIREMENTS_NOT_GENERATED, coverage });
         }
         // Overrides keyed by ids the corpus no longer mints (an estate id-scheme migration re-keys
         // method/field SymbolIds) would otherwise vanish without a trace — the count is on the page
@@ -6092,7 +6692,7 @@ runtime = {}) {
         }
         let detail;
         try {
-            detail = await getRequirement(repo, decoded);
+            detail = await getRequirement(repo, decoded, adapter);
         }
         catch (err) {
             // wicked-core#406: a CURRENT engine with no repo-graph root is a 503, not a 500.
@@ -6137,7 +6737,7 @@ runtime = {}) {
         }
         let detail;
         try {
-            detail = await patchRequirement(repo, decodedKey, parsed.data);
+            detail = await patchRequirement(repo, decodedKey, parsed.data, adapter);
         }
         catch (err) {
             // wicked-core#406: a CURRENT engine with no repo-graph root is a 503, not a 500.
@@ -6150,12 +6750,14 @@ runtime = {}) {
             return reply.code(404).send({ error: 'Requirement not found' });
         return { requirement: detail };
     });
-    app.get(`${V}/repos/:id/graph`, { config: { manifest: { responseType: 'RepoGraphResponse', statusCodes: [200, 404, 500, 503] } } }, async (req, reply) => {
+    app.get(`${V}/repos/:id/graph`, { config: { manifest: { responseType: 'RepoGraphResponse', statusCodes: [200, 404, 409, 500, 503] } } }, async (req, reply) => {
         const { id } = req.params;
         const repos = await adapter.listRepos();
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
+        if (refusedMissingFolder(repo, reply))
+            return reply;
         const dbPath = codeGraphDbOr503(repo, reply);
         if (dbPath === null)
             return reply;
@@ -6231,6 +6833,8 @@ runtime = {}) {
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
+        if (refusedMissingFolder(repo, reply))
+            return reply;
         const dbPath = codeGraphDbOr503(repo, reply);
         if (dbPath === null)
             return reply;
@@ -6269,14 +6873,24 @@ runtime = {}) {
         const credentials = await deliverCredentialsProbe(originUrl, process.env, undefined, identity);
         return reply.send({ repo: repo.id, ...deliverTargetView(originUrl), credentials });
     });
+    // `?limit=` (1..500, default 20): the repo page shows the latest 20; its "Show all" asks for more.
+    const GitHistoryQuerySchema = z.object({
+        limit: z.coerce.number().int().min(1).max(500).default(20),
+    }).strict();
     app.get(`${V}/repos/:id/git-history`, async (req, reply) => {
         const { id } = req.params;
         const repos = await adapter.listRepos();
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
+        if (refusedMissingFolder(repo, reply))
+            return reply;
+        const query = GitHistoryQuerySchema.safeParse(req.query);
+        if (!query.success) {
+            return reply.code(400).send(invalidBody(query.error, 'Invalid query'));
+        }
         try {
-            const { stdout } = await execCapped('git', ['log', '--pretty=format:%H\x1f%h\x1f%s\x1f%an\x1f%ar', '-n', '20'], { timeout: 10_000, cwd: repo.root_path });
+            const { stdout } = await execCapped('git', ['log', '--pretty=format:%H\x1f%h\x1f%s\x1f%an\x1f%ar', '-n', String(query.data.limit)], { timeout: 10_000, cwd: repo.root_path });
             const commits = stdout.trim().split('\n').filter(Boolean).map((line) => {
                 const parts = line.split('\x1f');
                 return {
@@ -6307,6 +6921,8 @@ runtime = {}) {
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
+        if (refusedMissingFolder(repo, reply))
+            return reply;
         try {
             const { stdout } = await execCapped('git', ['shortlog', '-sne', '-n', '--no-merges', 'HEAD'], { timeout: 10_000, cwd: repo.root_path });
             // Output: "  42\tFull Name <email@example.com>"
@@ -6620,6 +7236,12 @@ runtime = {}) {
                 .code(400)
                 .send({ error: 'councilSpawnStaggerMs must be an integer between 0 and 30000' });
         }
+        // Requirements-graph minimum coverage (operator ruling 2026-10-31): `{ minCoveragePct: 1..100 }`.
+        if (Object.hasOwn(patch, 'requirementsGraph') && !isRequirementsGraphSettings(patch.requirementsGraph)) {
+            return reply
+                .code(400)
+                .send({ error: REQUIREMENTS_GRAPH_SETTINGS_RULE });
+        }
         if (Object.hasOwn(patch, 'worker_config_root')) {
             const root = patch.worker_config_root;
             if (typeof root !== 'string' || (root !== '' && !isAbsolute(root))) {
@@ -6841,6 +7463,7 @@ runtime = {}) {
             'baseSkillPolicy',
             'councilSize',
             'councilSpawnStaggerMs',
+            'requirementsGraph',
         ];
         const safe = {};
         for (const key of allowed) {
@@ -6872,6 +7495,8 @@ runtime = {}) {
         applyWorkerConfigRoot(settings.worker_config_root);
         // …and the council size + stagger, read by the engine per council (wicked-core#888).
         applyCouncilSettings(settings);
+        // …and the requirements-graph minimum, read by the engine's coverage check and domain-graph step.
+        applyRequirementsGraphSettings(settings);
         // Re-judge and re-export the BASE skill (crew#554) — the engine reads WICKED_BASE_SKILL_REF at
         // intake, per launch, so this alone makes a changed name or policy live at the next launch.
         // Only when the patch named either key: an unrelated settings write must not re-log the seam.
@@ -6904,6 +7529,11 @@ runtime = {}) {
         if (err instanceof EstateMcpError && err.code === -32602) {
             return reply.code(400).send({ error: err.message });
         }
+        // A spawn that failed with ENOENT (the OS code, not text in the message) means estate is not
+        // installed; every other error — EACCES on a path that names ENOENT included — keeps its own message.
+        if (err instanceof EstateMcpError && err.spawnCode === 'ENOENT') {
+            return reply.code(502).send({ error: `wicked-estate is not installed: ${ESTATE_INSTALL_HINT}` });
+        }
         return reply.code(502).send({ error: message(err) });
     };
     // GET /proposals?kind_type=&state= → proposal.list → { proposals: Proposal[] }.
@@ -7730,6 +8360,71 @@ runtime = {}) {
             // F-043: the bridge emits where this daemon's interactive seams read — one bus per daemon.
             busDataDir: runtime.interactiveBridgeBusDataDir ?? null,
         });
+    // The seat images row (`seat_images`) and its fix: the engine's `seat-image status --json`, read
+    // per request, and one background `seat-image build` at a time.
+    const coreExe = () => process.env['WICKED_CORE_EXE'] || null;
+    const seatImageRebuilder = runtime.seatImageRebuilder ?? new SeatImageRebuilder(coreExe);
+    const seatImageStatus = runtime.seatImageStatus ??
+        (async () => {
+            const exe = coreExe();
+            if (exe === null)
+                throw new Error('WICKED_CORE_EXE is not set');
+            try {
+                const out = await execCapped(exe, ['seat-image', 'status', '--json'], { timeout: PROBE_TIMEOUT_MS });
+                return parseSeatImageStatus(out.stdout);
+            }
+            catch (err) {
+                const e = err;
+                throw new Error(loginDetail(typeof e.stderr === 'string' && e.stderr !== '' ? e.stderr : (e.message ?? 'failed')));
+            }
+        });
+    // The roster's seats (on the container floor every seat runs in an image); `null` when unreadable.
+    const rosterSeatClis = () => {
+        try {
+            return rosterWithStanding().map((r) => String(r.key));
+        }
+        catch {
+            return null;
+        }
+    };
+    // ── POST /system/seat-images/rebuild — the seat images row's fix (api-types 0.162.0) ──
+    // A person's only: it builds images in the container runtime for minutes. One at a time; the
+    // progress reads on the `seat_images` row.
+    app.post(`${V}/system/seat-images/rebuild`, { config: { manifest: { responseType: 'RebuildSeatImagesResponse', statusCodes: [202, 403, 409, 503] } } }, async (req, reply) => {
+        if (!isHumanOperator(actorOf(req)))
+            return reply.code(403).send({ error: 'Only a person can rebuild the seat images' });
+        if (!isContainerSeatFloor()) {
+            const out = { started: false, reason: 'seats run on the host floor: there are no seat images to rebuild', rebuild: null };
+            return reply.code(503).send(out);
+        }
+        // A rebuild already running is 409 before anything else is asked of a busy runtime.
+        const active = seatImageRebuilder.current();
+        if (active?.running === true) {
+            const out = { started: false, reason: 'a rebuild is already running', rebuild: active };
+            return reply.code(409).send(out);
+        }
+        // The roster's seats the engine has a seat image for (it refuses a name it does not know).
+        const roster = rosterSeatClis();
+        if (roster === null) {
+            const out = { started: false, reason: 'the roster could not be read', rebuild: active };
+            return reply.code(503).send(out);
+        }
+        const st = await settleWithin(seatImageStatus, PROBE_TIMEOUT_MS);
+        if (st.kind !== 'ok' || st.value === null) {
+            const why = st.kind === 'timeout' ? 'the engine did not answer its seat image status in time' : st.kind === 'error' ? homeless(st.error) : 'the engine gave no seat image status';
+            const out = { started: false, reason: why, rebuild: seatImageRebuilder.current() };
+            return reply.code(503).send(out);
+        }
+        const known = new Set(st.value.seats.map((x) => x.cli));
+        const r = await seatImageRebuilder.start(roster.filter((c) => known.has(c)));
+        if (r.started) {
+            audit.record('system.seat_images.rebuild', actorOf(req), { detail: { clis: r.state.clis } });
+            const out = { started: true, rebuild: r.state };
+            return reply.code(202).send(out);
+        }
+        const out = { started: false, reason: r.reason, rebuild: r.state };
+        return reply.code(r.state?.running === true ? 409 : 503).send(out);
+    });
     // ── GET /system — the Nerve Center snapshot (DES-SYSTEM-VIEW, api-types 0.136.0) ──
     // One derived, READ-ONLY answer: the CLIs with their 7-day record, every unfinished run with a
     // COMPUTED liveness, the infrastructure as real bounded probes, the governance instruments and
@@ -7785,6 +8480,8 @@ runtime = {}) {
                 toReviewCache = { at: Date.now(), value }; // a failed read is never kept
             return value;
         }, PROBE_TIMEOUT_MS);
+        // The registered repositories' folders (repo_folder_missing): a missing one is a fixable item.
+        const reposP = settleWithin(() => adapter.listRepos(), PROBE_TIMEOUT_MS);
         const gatesByYouP = settleWithin(async () => {
             const since = Date.now() - SYSTEM_STATS_DAYS * 86_400_000;
             const entries = await audit.readAll({ action: 'gate.decided', since });
@@ -7822,9 +8519,10 @@ runtime = {}) {
             }),
             probeVault({ vault: adapter.vaultBin != null ? vaultDiagnostics(adapter.vaultBin) : null, exec: systemExec }),
             diskRow(stateHome),
+            probeSeatImages({ containerFloor, clis: rosterSeatClis(), status: seatImageStatus, rebuild: () => seatImageRebuilder.current() }),
         ]);
-        const [views, settings, openGates, diag, ping, rules, gatesByYou, infraProbed] = await Promise.all([
-            viewsP, settingsP, gatesP, diagP, pingP, rulesP, gatesByYouP, infraP,
+        const [views, settings, openGates, diag, ping, rules, gatesByYou, infraProbed, reposRead] = await Promise.all([
+            viewsP, settingsP, gatesP, diagP, pingP, rulesP, gatesByYouP, infraP, reposP,
         ]);
         // The broker probe refreshed each container seat's sign-in reading: the CLI cards read the
         // roster AFTER it, so one snapshot never says "broker: signed in" beside "claude: signed out".
@@ -7952,6 +8650,8 @@ runtime = {}) {
             stateHomeRow(d === null ? null : (d.stateHome ?? null)),
             storesRow,
             seatFloorRow,
+            infraProbed[7],
+            reposRow(reposRead),
             infraProbed[6],
             loadRow(),
         ];
@@ -8013,14 +8713,80 @@ runtime = {}) {
             toReview: toReview.kind === 'ok' ? toReview.value : null,
         });
     });
+    // DES-CHAT-ARTIFACTS-001 §5.2 (A3): a create's `chat_id` + `proposal_id` counts only through the caller's accepted record.
+    const proposalGrant = (chatId, pid, actorId) => (CHAT_ID.test(chatId) ? chatProposals.grantFor(chatId, pid, actorId) : null);
     registerInteractiveProxy(app, adapter, {
         settings: projectSettings,
         pool: interactiveBridges,
         ...(runtime.docGrounding !== undefined ? { grounding: runtime.docGrounding } : {}),
         // crew#631: supply the standing roster so doc/demo creates can refuse an unavailable seat.
         roster: () => rosterWithStanding(),
+        proposalGrant,
+        actorOf: (req) => actorOf(req).id,
         log: (m) => app.log.warn(m),
     });
+    // A3: the real `create` launcher (§4.3 steps 2-3): one document and one run per proposal identity.
+    if (realCreate) {
+        const bindings = runtime.docBindings;
+        proposalLaunchers.register('create', new CreateLauncher({
+            bindings,
+            runExists: async (runId) => (await adapter.sessions()).includes(runId),
+            docsRoot: (projectId) => projectDocsRoot(adapter, projectSettings, projectId),
+            createDoc: (projectId, body, actorId) => createDocInProcess(adapter, {
+                settings: projectSettings,
+                pool: interactiveBridges,
+                ...(runtime.docGrounding !== undefined ? { grounding: runtime.docGrounding } : {}),
+                roster: () => rosterWithStanding(),
+                proposalGrant,
+                log: (m) => app.log.warn(m),
+            }, projectId, body, actorId),
+            launchBound: runtime.launchBoundDraft,
+            ...(runtime.fenceBoundDraft !== undefined ? { fence: runtime.fenceBoundDraft } : {}),
+            records: (chatId) => chatHistory?.messages(chatId) ?? chatTranscripts?.read(chatId) ?? [],
+            instanceOf: (chatId) => chatHistory?.stateOf(chatId)?.instance ?? null,
+            chatIdOf: (chatId, instance) => (chatHistory === null ? chatId : chatHistory.idOfInstance(chatId, instance)),
+            repos: async () => (await adapter.listRepos()).map((r) => ({ id: r.id, name: typeof r.name === 'string' && r.name.trim() !== '' ? r.name.trim() : basename(r.root_path), rootPath: r.root_path })),
+            graphFor: async (projectId, chatId) => {
+                if (projectId === null)
+                    return chatScopes.engineOf(chatId)?.codeGraphDb ?? null;
+                const decision = await resolveProjectGraphBinding(adapter, projectId, undefined).catch(() => ({ binding: null }));
+                return decision.binding?.dbPath ?? null;
+            },
+            clisJsonFor: (seats) => {
+                const roster = rosterWithStanding();
+                const picked = seats.map((k) => roster.find((s) => s.key === k));
+                return picked.some((s) => s === undefined) ? null : JSON.stringify(picked);
+            },
+            styleOf: (entry) => {
+                const seed = CATALOG_SEEDS.find((c) => c.id === entry);
+                return seed !== undefined && seed.launch.kind === 'document' ? seed.launch.style : 'web';
+            },
+            packetDeps: {
+                runs: chatContextDeps.runs,
+                brief: (view) => buildRunBrief(view, { workOutput: chatContextDeps.workOutput, ...(chatContextDeps.acceptanceLine !== undefined ? { acceptanceLine: chatContextDeps.acceptanceLine } : {}) }),
+                docsRoot: chatContextDeps.docsRoot,
+                attachment: (chatId, id) => {
+                    const hit = chatAttachments.resolve(chatId, [id])[0];
+                    return hit === undefined ? null : { name: hit.name, path: hit.path };
+                },
+                // The exact brief a turn was given, from the live chat's scratch root, beneath it (no link followed), only when
+                // its bytes still hash to what the turn recorded (A1's binding). Gone after the chat ends or the daemon restarts.
+                contextBrief: (chatId, relPath, sha) => {
+                    const cwd = chatScopes.get(chatId)?.cwd;
+                    if (cwd === undefined)
+                        return null;
+                    try {
+                        const data = readBeneath(realpathSync(cwd), relPath, BRIEF_COPY_MAX).data;
+                        return sha256Hex(data) === sha ? data : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+            },
+            log: (m) => app.log.warn(m),
+        }));
+    }
     // ── Governed doc delete (crew#338) — the one door that changes BOTH stores ──
     // `DELETE /projects/:id/interactive/docs/:doc` retires the doc on the bridge AND drops crew's
     // handoff-ledger rows for it (the draft leg keys by document id, so a stale row claims the
@@ -8035,6 +8801,13 @@ runtime = {}) {
         // the operator's real ~/.wicked-crew ledgers. The real sweep always arrives from
         // `createServer`.
         dropDocLedgerRows: runtime.dropDocLedgerRows ?? (() => ({ ok: true, removed_keys: [] })),
+        // A3: a document a chat proposal is still drafting (or landing) is not retired under it.
+        busyReason: (projectId, doc) => {
+            const pending = runtime.docBindings?.busy(`${projectId === 'default' ? UNFILED_MOUNT : projectId}/${doc}`) ?? null;
+            return pending !== null && (pending.launchingAt !== undefined || pending.launchedAt !== undefined || pending.emittedAt !== undefined)
+                ? `a chat proposal is still drafting this document (run ${pending.runId.slice(0, 8)}); wait for it to land, or stop that run first`
+                : null;
+        },
         log: (m) => app.log.warn(m),
     });
     // ── A demo run's video as an editable document (the video editor re-cuts it through E1's per-doc API) ──
@@ -8113,6 +8886,6 @@ runtime = {}) {
     const runEvalsPrepare = async (input) => {
         await prepareRunEvalsLaunch(input, () => runAndRecord(defaultEvalDeps, { project: null, baseline: false, id: randomUUID(), now: new Date() }), runtime.evalRunsDir);
     };
-    return { decideGate, decisions, chatRecorder, considerations, search, decorateRun, runEvalsPrepare };
+    return { decideGate, decisions, chatRecorder, considerations, search, decorateRun, runEvalsPrepare, chatProposals, proposalLaunchers };
 }
 //# sourceMappingURL=routes.js.map