wicked-crew 0.7.39 → 0.7.45

package/dist/api/routes.js

@@ -1,3 +1,5 @@
+import { busSeamsOffWarning, busUnavailableWarning } from '../core/bus-notice.js';
+import { PlanSchema, toLaunchPlan } from './plan-schema.js';
 import { z } from 'zod';
 import { listRequirements, getRequirement, patchRequirement } from './requirements.js';
 import { randomUUID } from 'node:crypto';
@@ -5,12 +7,12 @@ import { readFileSync, existsSync } from 'node:fs';
 import { promises as fsp } from 'node:fs';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { CampaignsUnsupportedError, ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, SteeringUnsupportedError, humanGatePhaseIds, settingsFilePath } from '../core/adapter.js';
+import { CampaignsUnsupportedError, ChatUnsupportedError, CoreAdapter, ElicitationUnsupportedError, GovernanceReplayUnsupportedError, PlanLaunchUnsupportedError, SteeringUnsupportedError, humanGatePhaseIds, settingsFilePath } from '../core/adapter.js';
 import { codeGraphDb, codeGraphErrorStatus, requirementsGraph } from '../core/repoPaths.js';
 import { resolveCursorUnit } from '../core/cursor.js';
 import { detectRefusal } from './gate-cache.js';
-import { QeGateCache } from '../qe/gate-events.js';
-import { buildAcceptanceView, resolveRunWorkflow } from '../qe/acceptance.js';
+import { acceptanceRequirementOf, buildAcceptanceView } from '../qe/acceptance.js';
+import { runIdentityOf, wireIdentity } from '../core/run-identity.js';
 import { buildEvidenceBundle, coreUnitId, evidenceFilename } from './evidence.js';
 import { outputUnavailableReason, resolveUnit, unitKeysFor } from './unit-output.js';
 import { execCapped, ExecOutputTooLarge } from '../core/exec.js';
@@ -20,42 +22,54 @@ import { applyWorkerConfigRoot, signedInHeuristic } from './seat-signin.js';
 import { chatSeatAdmission } from './seat-standing.js';
 import { rosterWithStandingFactory } from './roster-standing.js';
 import { ChatTurnIndex } from './chat-turns.js';
-import { ChatScopeIndex, chatScopeDeps, prepareChatScratch, removeChatScratch, resolveChatScope, } from './chat-scope.js';
+import { ChatScopeIndex, chatScopeDeps, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
 import { allowedRootsFor, isInsideRoot, openWithSystemDefault } from './open-path.js';
 import { InvalidDiffBaseError, MERGE_BASE_LITERAL, NotARegularFileError, UnresolvableDiffBaseError, branchDiff, isPlainRef, readFileCapped, worktreeDiff, } from './run-files.js';
 import { DocRunIndex } from '../interactive/doc-run-index.js';
 import { listInteractiveDocs } from '../interactive/docs-index.js';
 import { TestSetIndex } from '../qe/test-sets.js';
-import { estateExe, resolveProjectGraphBinding } from '../projects/graph.js';
+import { estateExe, parseEstateTotals, resolveProjectGraphBinding } from '../projects/graph.js';
 import { registerProjectRoutes } from '../projects/routes.js';
+import { registerPresetRoutes } from '../presets/routes.js';
+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 { ApproveEditSchema, approveEdited, captureLaunchRoots, editInFlight, FileProposalSchema, registerCaptureRoutes } from './capture.js';
 import { registerTestingRoutes } from './testing.js';
+import { DEMO_PRESET, demoLaunchRoots, registerDemoRoutes } from './demo.js';
 import { registerSkillsRoutes } from './skills.js';
+import { registerMcpRoutes } from './mcp.js';
+import { McpPolicies } from '../mcp/policies.js';
 import { disabledSkillsHealth } from '../skills/runtime.js';
+import { phaseSkillFindings, withPhaseSkillGaps } from '../skills/phase-skill-gaps.js';
 import { STATE_HOME_BLOCKER_CODE, STATE_HOME_REMEDY, isEngineStateHomeRefusal, stateHomeBlockerBody, } from '../projects/state-home-preflight.js';
 import { BASE_SKILL_POLICIES, BASE_SKILL_REF_SHAPE, baseSkillRemedy } from '../skills/base-skill.js';
 import { noEligibleSeatBody, parseNoEligibleSeat } from '../core/engine-roster.js';
 import { ProjectSettingsStore } from '../projects/settings.js';
 import { boundOrigin, InteractiveBridgePool } from '../interactive/bridge-pool.js';
-import { composeDeliverText, factsFromRun, framedDeliverText, runUrlFor } from '../core/deliver-text.js';
-import { resolvePullRequest as resolvePullRequestViaGh } from '../core/deliver.js';
+import { composeDeliverText, configuredPublicOrigin, extractFollowUps, factsFromRun, FOLLOW_UPS_MAX, framedDeliverText, runUrlFor, } from '../core/deliver-text.js';
+import { deliverRepoFor, deliverTargetView, isGitHubLogin, readDeliverOriginUrl, resolvePullRequest as resolvePullRequestViaGh, } from '../core/deliver.js';
 import { registerInteractiveProxy } from '../interactive/proxy-routes.js';
 import { registerInteractiveDocDelete } from '../interactive/doc-delete-routes.js';
 import { registerInteractiveDocList } from '../interactive/doc-list-routes.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, listStoreFiles, readStudioBundleVersion, } from './diagnostics.js';
 import { GovernanceDiagnostics } from './governance-health.js';
 import { legacyHomeOutboxPath } from '../core/governance-store.js';
+import { UsageError, replayOutboxInto } from '../cli/governance.js';
+import { foldDeadletters } from './governance-health.js';
 import { RetryIndex } from './retry-index.js';
+import { SEAT_RECORD_DEFAULT_DAYS, SEAT_RECORD_MAX_DAYS, seatRecord } from './seat-record.js';
+import { DeliveryFreeze, frozenRefusal, isDeliverUnit, registerDeliveryFreezeRoutes } from './delivery-freeze.js';
 import { GroupIndex } from './group-index.js';
 import { RunTimingIndex, recordRunLaunched } from './run-timing-index.js';
 import { GuidanceIndex } from './guidance-index.js';
-import { DeliveryIndex, gitRunBranchIsEmpty, gitWorktreeIsClean, isDeliverConflictStranded, prUrlFrom, canDeliverResolver, } from './delivery-index.js';
+import { DeliveryIndex, gitRunBranchIsEmpty, gitWorktreeIsClean, isDeliverConflictStranded, deliveryRecordFrom, pushedState, canDeliverResolver, } from './delivery-index.js';
 import { DeliveryDerivationCache } from './delivery-cache.js';
 import { gitReprovisionWorktree, runDeliverScript, } from './post-hoc-deliver.js';
 import { LOCAL_ACTOR } from './auth.js';
@@ -64,6 +78,10 @@ import { LOCAL_ACTOR } from './auth.js';
 export { API_PREFIX } from './api-prefix.js';
 import { API_PREFIX } from './api-prefix.js';
 const V = API_PREFIX;
+/** How long `GET /health` waits on the engine's actor before answering `ping: "busy"` (crew#471). */
+export const HEALTH_PING_WAIT_MS = 1_000;
+/** `HealthResponse.ping` while the engine's actor is occupied: the daemon serves, the engine is busy. */
+export const ENGINE_BUSY_PING = 'busy';
 // Daemon version reported by /health — read from package.json so it never drifts
 // from the shipped version across releases. Resolves the package root from the
 // compiled module location (dist/api/routes.js → ../../package.json) and works the
@@ -83,17 +101,10 @@ const STATUS_ORDER = {
 function sortActionableFirst(views) {
     return [...views].sort((a, b) => (STATUS_ORDER[a.session.status] ?? 9) - (STATUS_ORDER[b.session.status] ?? 9));
 }
-/**
- * The whole-graph counts from `wicked-estate stats --db` stdout (`nodes=N edges=M files=F …`, the
- * first line estate prints — `main.rs`'s `stats` summary). `undefined` when the line does not parse
- * (an older/newer estate, an error message): the caller leaves `CodeGraphData.totals` ABSENT.
- */
-export function parseEstateTotals(stdout) {
-    const m = /^nodes=(\d+) edges=(\d+) files=(\d+)/m.exec(stdout);
-    if (m === null)
-        return undefined;
-    return { nodes: Number(m[1]), edges: Number(m[2]), files: Number(m[3]) };
-}
+// parseEstateTotals lives in projects/graph.ts — shared with chat-scope.ts (crew#642) to avoid
+// a circular import (routes.ts → chat-scope.ts). Re-exported here for backward compat
+// (tests import it from routes.js; see top-of-file import for local use).
+export { parseEstateTotals };
 function codeGraphDbOr503(repo, reply) {
     try {
         return codeGraphDb(repo);
@@ -312,6 +323,12 @@ const RegisterRepoSchema = z
     // defaults to ~/.wicked/repos/<name>.
     rootPath: z.string().optional(),
     gitUrl: z.string().optional(),
+    /** crew#496: the project the register form had selected — the onboarding run is filed there
+     *  (membership `crew.run`), not left unfiled while the repo joins the project. */
+    projectId: z.string().min(1).max(128).optional(),
+    /** crew#496 / crew#632: the launch surface and caller, recorded on the run's launch entry. */
+    channel: z.enum(['studio', 'cli', 'api']).optional(),
+    actor: z.string().min(1).max(256).optional(),
 })
     .strict()
     .refine((d) => {
@@ -321,6 +338,14 @@ const RegisterRepoSchema = z
     // or rootPath alone (register existing local repo) — all valid.
     return hasRemote || hasLocal;
 }, { message: 'Provide gitUrl (remote clone) or rootPath (local registration), or both.' });
+/** `POST /repos/:id/onboard`'s optional body (crew#496): where to file the run, and who asked. */
+const OnboardBodySchema = z
+    .object({
+    projectId: z.string().min(1).max(128).optional(),
+    channel: z.enum(['studio', 'cli', 'api']).optional(),
+    actor: z.string().min(1).max(256).optional(),
+})
+    .strict();
 /**
  * The launch body. Every field but `problem` is optional, which is what made stripping dangerous:
  * omitting one is a legitimate request that gets an engine default, so a MISSPELLED one was
@@ -337,6 +362,7 @@ const RegisterRepoSchema = z
 // The request-body schemas below are exported so `tests/wire-contract.test.ts` can prove, at
 // compile time, that every body the published contract (`wicked-crew-api-types`) lets a client
 // send is a body these schemas accept — the request-direction half of the drift guard (task #84).
+export { PlanSchema };
 export const LaunchSchema = z.object({
     problem: z.string().min(1),
     sessionId: z.string().min(1).optional(),
@@ -345,6 +371,10 @@ export const LaunchSchema = z.object({
     humanConfirm: z.string().min(1).optional(),
     repoRef: z.string().min(1).optional(),
     workflow: z.string().min(1).optional(),
+    /** DES-TEAMING-002 T3 — a user-composed plan (`LaunchRunBody.plan`), forwarded to the engine,
+     *  which publishes `plan.proposed{by:"human"}` and holds it at a `plan_approval` gate when the
+     *  approval matrix says so. Mutually exclusive with `workflow` (refine below). */
+    plan: PlanSchema.optional(),
     /** DES-PROJECT-001 §2.2 — file the run into a project; membership attaches atomically with
      *  the launch record. Unknown/archived ⇒ the launch fails (never a silent unfiled run). */
     projectId: z.string().min(1).optional(),
@@ -395,7 +425,10 @@ export const LaunchSchema = z.object({
      *  launch (e.g. a CI job name or a studio tab id). Persisted on the `run.launched` audit entry
      *  (`detail.actor`) and served on the run DTO; absent = caller omitted it. */
     actor: z.string().min(1).max(256).optional(),
-}).strict().refine((b) => b.deliver !== 'pr' || b.workflow !== undefined, {
+}).strict().refine((b) => b.plan === undefined || b.workflow === undefined, {
+    message: 'plan and workflow are mutually exclusive — a launch carries a plan or names a preset, not both',
+    path: ['plan'],
+}).refine((b) => b.plan !== undefined || b.deliver !== 'pr' || b.workflow !== undefined, {
     message: 'deliver: "pr" requires a workflow — a free-text run has no def to append the deliver phase to',
     path: ['deliver'],
 }).refine((b) => b.deliverGate === undefined || b.deliver !== 'none', {
@@ -414,19 +447,43 @@ export const LaunchSchema = z.object({
     message: 'revisesPr needs deliver: "pr" — a launch that declines delivery has no phase to push the revision with',
     path: ['revisesPr'],
 });
+/** The escalation arms (wicked-core#469 / #467): approve-shaped, no `amend` / `amendScope`.
+ *  `extend` | `targeted` | `accept_partial` answer the gate of a repo-checks floor that did not
+ *  finish (`repo_checks_timeout`) — the engine re-runs the floor on the tree as it stands with 2×
+ *  bounds, the targeted test set, or the unfinished checks waived; `accept_suggestion` adopts the
+ *  evaluator's discarded, pinned edit as the creator's amendment. The ENGINE refuses each at any
+ *  other gate (a 409 naming the gate it answers). */
+export const ESCALATION_ACTIONS = ['extend', 'targeted', 'accept_partial', 'accept_suggestion'];
+const isEscalationAction = (a) => a !== undefined && ESCALATION_ACTIONS.includes(a);
 /** `POST /runs/:id/gate` (api-types 0.38.0 `GateDecision`; DES-L1 PR-2). Additive arms: `action`
  *  names the arm (`approve` | `request_changes` | `reject`; absent = today's two-arm mapping of
  *  `approve`), `amendScope` says where an approve's `amend` lands (`cursor` = the gated unit, today's
  *  behaviour | `creator` = the first creator phase at/after the cursor — an intake steer reaches the
  *  phase that implements). `request_changes` sends a NOT-PASS review back to the creator with the
  *  findings in context (`amend` = the operator's note). A disagreement between `action` and
- *  `approve` is a 400 that names both. */
+ *  `approve` is a 400 that names both. The escalation arms ({@link ESCALATION_ACTIONS}) require
+ *  `approve: true` and take no `amend` / `amendScope` / `plan`.
+ *
+ *  `amend_intent` (wicked-core#555) approves the gate AND AMENDS THE RUN'S INTENT: `amend` is
+ *  what the acceptance list now says (required, non-empty), `approve: true`, and no `amendScope`
+ *  — an intent amendment reaches every unit at or after the cursor, which is what makes it reach
+ *  the LATER EVALUATOR. It is the only arm that can descope a run mid-flight. */
 export const GateSchema = z.object({
     approve: z.boolean(),
     amend: z.string().optional(),
-    action: z.enum(['approve', 'request_changes', 'reject']).optional(),
+    action: z.enum(['approve', 'request_changes', 'reject', 'edit_plan', 'amend_intent', ...ESCALATION_ACTIONS]).optional(),
     amendScope: z.enum(['cursor', 'creator']).optional(),
-}).strict().refine((b) => b.action === undefined || (b.action === 'approve') === b.approve, { message: '`action` disagrees with `approve`: request_changes and reject require approve: false; approve requires approve: true', path: ['action'] }).refine((b) => b.amendScope === undefined || b.approve, { message: '`amendScope` applies to an approve only (approve: true)', path: ['amendScope'] });
+    /** DES-TEAMING-002 T3 — approve a `plan_approval` gate WITH AN EDIT (`GateDecision.plan`). */
+    plan: PlanSchema.optional(),
+    /** 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
+    || (b.action === 'approve' || b.action === 'edit_plan' || b.action === 'amend_intent' || isEscalationAction(b.action)) === b.approve, { message: '`action` disagrees with `approve`: request_changes and reject require approve: false; approve, edit_plan, amend_intent, extend, targeted, accept_partial and accept_suggestion require approve: true', path: ['action'] }).refine(
+// (wicked-core#555) An intent amendment IS its text: an empty one amends nothing, and the arm's
+// scope is every unit at or after the cursor — which is what makes it reach the evaluator — so
+// `amendScope` cannot narrow it. Both are 400s here rather than a 409 from the engine.
+(b) => b.action !== 'amend_intent' || (b.amend !== undefined && b.amend.trim() !== ''), { message: 'amend_intent needs `amend`: what the run\'s acceptance list now says (approve without an action to proceed unamended)', path: ['amend'] }).refine((b) => b.action !== 'amend_intent' || (b.amendScope === undefined && b.plan === undefined), { message: 'amend_intent takes no amendScope or plan — an intent amendment reaches every unit at or after the cursor, which is what makes it reach the evaluator', path: ['amendScope'] }).refine((b) => !isEscalationAction(b.action) || (b.amend === undefined && b.amendScope === undefined && b.plan === undefined), { message: 'extend, targeted, accept_partial and accept_suggestion take no amend, amendScope or plan — the engine re-runs the floor or adopts the pinned edit as it stands', path: ['action'] }).refine((b) => (b.action === 'edit_plan') === (b.plan !== undefined) || (b.action === undefined && b.plan !== undefined), { message: 'an edited plan answers a plan_approval gate: `plan` needs approve: true with `action` omitted or edit_plan, and edit_plan needs `plan`', path: ['plan'] }).refine((b) => b.plan === undefined || (b.approve && b.amend === undefined && b.amendScope === undefined), { message: '`plan` is an approve WITH an edited plan: approve: true, and no amend / amendScope (the plan is the edit)', path: ['plan'] }).refine((b) => b.amendScope === undefined || b.approve, { message: '`amendScope` applies to an approve only (approve: true)', path: ['amendScope'] });
 /** `PUT /runs/:id/guidance` (DES-UX-002 §7.2, CREW-UX-7) — the durable pre-gate note body.
  *  The empty string is a legal body: it CLEARS the note. The byte cap is checked in the route
  *  (not zod's char-counting `max`) so the 400 names the actual limit. */
@@ -470,6 +527,14 @@ export const OpenPathSchema = z.object({
 export const RetireMemorySchema = z.object({
     scope_prefix: z.string(),
 }).strict();
+/** `POST /memory/retire-item` body (studio#206): ONE memory, by its `memory_id` from `GET /memory`.
+ *  `.strict()`: a stray `scope_prefix` is a 400, never read as a wider erase than one row. */
+export const RetireMemoryItemSchema = z.object({
+    memory_id: z.string().min(1).max(512),
+}).strict();
+/** The error an estate from before wicked-estate#188 answers to `memory.erase {id}`: it knows only the
+ *  subtree erase, so it refuses the call (deleting nothing) for want of a `scope_prefix`. */
+const ESTATE_NO_ERASE_BY_ID = /scope_prefix \(non-empty\) required/i;
 /**
  * A SKIN-OWNED settings key (crew#323): one lowercase segment under the `studio.` namespace,
  * e.g. `studio.appearance`, `studio.notifications`. The daemon never interprets these values —
@@ -526,12 +591,89 @@ export const ChatOpenSchema = z.object({
     /** File the chat into a project (`crew.chat` membership) — and, with no `repoRefs`, scope it to
      *  every registered `crew.repo` member of that project (crew#502). */
     projectId: z.string().min(1).optional(),
+    /** The scope the caller NAMES (studio#323 R4) — omitted ⇒ the legacy inference. Shape rules
+     *  (which kinds need / refuse `projectId` / `repoRefs`) are the resolver's (`chat-scope.ts`). */
+    scopeKind: z.enum(['system', 'everything', 'project', 'repo', 'repos', 'none']).optional(),
 }).strict();
+/**
+ * The `singleSeat` disclosure (crew#641, hole closed in crew#650) — built in ONE place so the 201
+ * and the 202 cannot drift.
+ *
+ * The property this field states is **"this chat has one seat; it cannot disagree with itself"**,
+ * and that is true of every one-warm-seat chat. The first cut also required `refused.length > 0`,
+ * so the case an operator is most likely to create — a chat deliberately opened with a single seat
+ * — returned `ok: true` with no signal at all, which is the exact failure mode #641 was filed
+ * about. It also made the 202 go quiet after a restart, when `refusedOf` no longer knows the
+ * refusals, even though the chat is just as single-seated as it was a minute earlier.
+ *
+ * `refused` therefore rides along as EVIDENCE when there is any — it never decides whether the
+ * caller is told.
+ *
+ * THREE states, not two (review of #658). The refusal list has a third possibility that `[]` cannot
+ * express: this daemon does not KNOW. `chatScopes.refusedOf` answers `undefined` for a chat this
+ * daemon did not open — the engine keeps the warm session across a restart, the in-memory index does
+ * not — and the first cut collapsed that to `[]` with `?? []`, which made the 202 tell an operator
+ * *"It was opened with a single seat — no other seat was refused"* about a chat that was opened with
+ * two seats, one of which was refused. Both halves false, stated confidently. It is the same
+ * distinction #651 got right for chat-promotion provenance (`.catch(() => null)`, never `[]`):
+ * unreadable and empty are different answers, and only one of them may be asserted.
+ *
+ * TWO MOMENTS, and only one route witnessed each (third review of #658). `refused` describes the
+ * daemon's record — what the OPEN (or the last re-seat) observed; `warmRoster` describes NOW. Any
+ * sentence built from both fabricates the instant they diverge, and they diverge routinely: a seat
+ * that blows its turn budget is RELEASED by the engine (`chat-turns.ts`), a re-seat clears an entry
+ * from the record, a restart drops the record entirely. A chat opened with `['claude','opencode']`
+ * — both warm, nothing refused, nothing unknown — whose `opencode` is later released would have been
+ * told *"It was opened with a single seat — no other seat was refused"*: false in both halves, with
+ * no `undefined` anywhere near it. So `at` names the moment the caller is asking about:
+ *
+ *   • `'open'` — the 201. This route just performed the open, so it is the ONLY one with standing to
+ *     describe it: refusals known and empty ⇒ it may say the chat was opened with a single seat.
+ *   • `'turn'` — the 202. It knows the roster NOW and the refusal record; it knows nothing about how
+ *     the chat came to look like this. Refusals known and empty ⇒ it says NOTHING about opening.
+ *     It still names refusals that are on record, and still says so when the record is unavailable —
+ *     both are statements about the record it holds, not about a moment it did not see.
+ *
+ * `refusalsKnown` carries the known/unknown distinction for a machine reader, because `refused: []`
+ * is exactly as ambiguous on the wire as the sentence was in prose.
+ */
+function singleSeatDisclosure(warmed, 
+/** `undefined` = this daemon has no refusal record for the chat (it did not open it). */
+refused, 
+/** Which moment the caller is asking about — see the note above; only `'open'` may describe one. */
+at) {
+    const known = refused !== undefined;
+    const list = refused ?? [];
+    const refusalClause = list.length > 0
+        ? `Refused: ${list.map((r) => `${r.cliKey} (${r.reason})`).join('; ')}. `
+        : known
+            ? at === 'open'
+                ? 'It was opened with a single seat — no other seat was refused. '
+                : // A turn has no standing to say how the chat was opened: this seat may be the survivor of
+                    // a two-seat chat whose other seat was released mid-session. Say nothing.
+                    ''
+            : 'This daemon holds no refusal record for this chat — it was opened before a restart — so ' +
+                'whether another seat was refused is UNKNOWN: the empty refused[] means the record is gone, ' +
+                'not that nothing was refused. ';
+    return {
+        degraded: true,
+        warmed,
+        refused: list,
+        refusalsKnown: known,
+        message: 
+        // "warm" on a turn: the claim is about the roster as it stands, not about how it got there.
+        `This chat has one ${at === 'open' ? 'seat' : 'warm seat'} (${warmed}); it cannot disagree with itself. ` +
+            refusalClause +
+            'The single-seat root cause is tracked as wicked-core#563; this chat makes it visible.',
+    };
+}
+/** N1: why a post-hoc deliver answers 409 for a branch already on a non-GitHub origin. */
+function pushedOnlyRefusal(runId, pushed) {
+    return (`run ${runId} is delivered as a pushed branch: ${pushed.branch} is on ${pushed.remote}, and no ` +
+        'pull request can be opened there because that origin is not a GitHub host gh can resolve — ' +
+        'open the pull/merge request on your forge; merge stays human');
+}
 export function registerRoutes(app, adapter, gateCache, elicitationCache, 
-// Defaulted so a caller that never arms the bus seam (tests drive this
-// function directly) gets the same behavior as an unarmed daemon: an empty
-// cache, `busEvent: null`, and the lazy ledger read doing all the work.
-qeGateEvents = new QeGateCache(), 
 // Defaulted for the same reason: tests that drive this function directly get
 // the projects surface with no bus (events skipped) and a fresh index.
 projects = { bus: null, index: new MembershipIndex(), log: () => undefined }, 
@@ -545,6 +687,8 @@ security = { audit: AuditLog.noop(), authMode: 'off' },
 runtime = {}) {
     const { audit } = security;
     const seatHealth = runtime.seatHealth ?? new SeatHealthTracker();
+    const deliveryFreeze = runtime.deliveryFreeze ?? new DeliveryFreeze();
+    registerDeliveryFreezeRoutes(app, { freeze: deliveryFreeze, audit });
     const openWithOs = runtime.openWithOs ?? openWithSystemDefault;
     const signedIn = runtime.signedIn ?? signedInHeuristic;
     const retryIndex = runtime.retryIndex ?? new RetryIndex();
@@ -582,7 +726,7 @@ runtime = {}) {
         new DeliveryDerivationCache({
             listViews: () => adapter.sessionsDetail(),
             probes: vacuityProbes,
-            isDelivered: (runId) => deliveryIndex.urlFor(runId) !== undefined,
+            isDelivered: (runId) => deliveryIndex.isDelivered(runId),
             canDeliver,
         });
     const deliverExec = runtime.deliverExec ?? runDeliverScript;
@@ -601,6 +745,32 @@ runtime = {}) {
     const repoRootOf = async (repoRef) => (await adapter.listRepos()).find((r) => r.id === repoRef)?.root_path;
     /** DES-L9: PR number → head branch, through `gh pr view` unless the runtime injected an answerer. */
     const resolvePullRequest = runtime.resolvePullRequest ?? resolvePullRequestViaGh;
+    /** crew#627: the intent's linked issues, read under the daemon's identity at launch. */
+    const readLinkedIssues = runtime.resolveLinkedIssues ?? ((p, root, ref) => resolveLinkedIssues(p, root, ref));
+    /** crew#550 P-7: the follow-ups the run's evaluator units flagged, read from their captured output.
+     *  A unit whose output cannot be read contributes nothing (the section then says what WAS read);
+     *  an adapter without transcripts (a directly-driven route set) reads as "not read" — absent. */
+    const evaluatorFollowUps = async (view) => {
+        if (typeof adapter.workOutput !== 'function')
+            return undefined;
+        const evaluators = view.units.filter((u) => u.role === 'evaluator').sort((a, b) => a.ord - b.ord);
+        const out = [];
+        for (const u of evaluators) {
+            let text = null;
+            try {
+                text = await adapter.workOutput(coreUnitId(view.session.id, u));
+            }
+            catch {
+                text = null;
+            }
+            if (text === null)
+                continue;
+            for (const x of extractFollowUps(text))
+                if (!out.includes(x))
+                    out.push(x);
+        }
+        return out.slice(0, FOLLOW_UPS_MAX);
+    };
     // The run-DTO joins (DES-UX-001 §8.2/§8.3, DES-UX-002 §7.2): `project_id` from the membership
     // record — `null` = genuinely unfiled, so the field is ALWAYS present on served runs —
     // `retry_of` from the lineage index and `guidance` from the guidance index, each set only
@@ -648,12 +818,19 @@ runtime = {}) {
         const url = deliveryIndex.urlFor(view.session.id);
         if (url !== undefined)
             return { delivery: 'delivered', deliverUrl: url };
+        // N1: a branch pushed to a non-GitHub origin IS the delivery — never 'stranded'.
+        const pushed = deliveryIndex.pushedFor(view.session.id);
+        if (pushed !== undefined)
+            return pushedState(pushed);
         if (conflictStrand)
             return { delivery: 'stranded' };
         return deliveryCache.read(view);
     };
     const decorateRun = (view) => {
         const conflictStrand = normalizeStranded(view);
+        // Seam X2: what the run IS — the adapter attaches it from the engine's record; a view from a
+        // directly-driven adapter gets it resolved from its record here, so it is always served.
+        view.session.run_identity = wireIdentity(runIdentityOf(view));
         view.session.project_id = projects.index.projectOf(view.session.id) ?? null;
         // Wave 6 (F-4R2-006): the interactive document this run answered, from the seams' handoff
         // ledgers — `null` = genuinely not a document run, so the field is ALWAYS present on served runs.
@@ -673,6 +850,10 @@ runtime = {}) {
         const guidance = guidanceIndex.guidanceFor(view.session.id);
         if (guidance !== undefined)
             view.session.guidance = guidance;
+        // crew#661: the declared skills this run's phases ran WITHOUT (degrade-and-disclose) — ABSENT when none.
+        const skillGaps = runtime.runSkillGaps?.gapsFor(view.session.id);
+        if (skillGaps !== undefined)
+            view.session.skill_gaps = skillGaps;
         // Run launch time (home command-center run metrics): unix SECONDS from the `run.launched`
         // audit entry, ABSENT when the daemon has no launch record for this run (onboarding/campaign
         // runs launched off POST /runs, pre-field runs) — never fabricated, so a bucketed KPI can
@@ -696,6 +877,17 @@ runtime = {}) {
         view.session.delivery = state.delivery;
         if (state.deliverUrl !== undefined)
             view.session.deliverUrl = state.deliverUrl;
+        if (state.deliverBranch !== undefined)
+            view.session.deliverBranch = state.deliverBranch;
+        if (state.deliverRemote !== undefined)
+            view.session.deliverRemote = state.deliverRemote;
+        // crew#641/#642 (item 5): chat promotion provenance — ABSENT when not a chat-promoted run.
+        const chatSeatCount = runTimingIndex.chatSeatCountFor(view.session.id);
+        if (chatSeatCount !== undefined)
+            view.session.chat_seat_count = chatSeatCount;
+        const chatGrounded = runTimingIndex.chatGroundedFor(view.session.id);
+        if (chatGrounded !== undefined)
+            view.session.chat_grounded = chatGrounded;
         return view;
     };
     // Resolved ONCE and shared by the project routes (which read/write `interactiveRoot`) and the
@@ -707,13 +899,31 @@ runtime = {}) {
     // still gets the ONE actor shape via this accessor.
     const actorOf = (req) => req.actor ?? LOCAL_ACTOR;
     // Liveness — also proves the actor + event pump are up.
+    //
+    // crew#471: the engine's ping is a round trip through its single-writer actor, and a launch that
+    // plans many units holds that actor for minutes. Awaiting it made `/health` go dark exactly when
+    // an operator needed to know the daemon was up, and each waiting probe pinned a libuv worker
+    // thread the rest of the read path needs. So at most ONE ping is in flight (later probes join it)
+    // and `/health` waits for it at most HEALTH_PING_WAIT_MS: past that it answers `ping: "busy"` —
+    // the daemon serves, the engine is occupied.
+    let pingInFlight = null;
+    const enginePing = () => {
+        pingInFlight ??= adapter.ping().finally(() => {
+            pingInFlight = null;
+        });
+        let timer;
+        const busy = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(ENGINE_BUSY_PING), HEALTH_PING_WAIT_MS);
+        });
+        return Promise.race([pingInFlight, busy]).finally(() => clearTimeout(timer));
+    };
     // `config.manifest` on the routes below (TH-11): the declaration channel the endpoint manifest
     // reads — type names bind to `wicked-crew-api-types` exports where one exists, structural
     // spellings where the contract has no name, statusCodes list every code the route answers on
     // purpose. Declared on the highest-traffic run-lifecycle routes first; the manifest records
     // null / [] for the rest ("where declared", never invented). See src/api/endpoint-manifest.ts.
     app.get(`${V}/health`, { config: { manifest: { statusCodes: [200] } } }, async () => {
-        const ping = await adapter.ping();
+        const ping = await enginePing();
         // F-E2E-030: what this deployment can keep. A composer reads `capabilities.deliverGate`
         // before it promises "pauses at the deliver gate"; a stub-driven route set without the
         // probe honestly reports no gate.
@@ -735,9 +945,18 @@ runtime = {}) {
         // `baseSkill.finding` and `/diagnostics.skills.findings[]` (one surface, no new field;
         // `HealthWarning.kind` is open); status stays ok because the daemon serves and studio must load
         // and show it — exactly the state-home blocker's precedent above.
+        // crew#661: a drafting seam that armed WITHOUT its declared skill rides `warnings` as well — its
+        // runs proceed degraded, so "status ok, no warnings" would be the silent answer the issue names.
         const warnings = [
             ...(stateHome === null ? [] : stateHome.findings.map((f) => ({ kind: f.kind, severity: f.severity, message: f.message }))),
             ...(baseSkill?.finding ? [{ kind: baseSkill.finding.kind, severity: baseSkill.finding.severity, message: baseSkill.finding.message }] : []),
+            ...phaseSkillFindings(runtime.phaseSkills?.gaps() ?? []),
+            // DES-TEAMING-002 T0: the daemon's bus did not open at boot, so the engine was handed none
+            // and runs un-teamed. A daemon-level notice (status stays ok: it serves); the per-run
+            // `transport:"none"` record lands with P1.
+            ...(adapter.busUnavailable != null ? [busUnavailableWarning(adapter.busUnavailable)] : []),
+            // wicked-core#631: the engine has the bus but not the calls crew reaches it through.
+            ...(adapter.busSeamsOff != null ? [busSeamsOffWarning(adapter.busSeamsOff)] : []),
         ];
         return {
             status: 'ok',
@@ -790,7 +1009,9 @@ runtime = {}) {
             // The skills seam's last outcome (skills keystone): published / fallback / blocked /
             // config-error, with the `skills.*` findings the ladder produced — the operator's one
             // read-only answer to "why do launches refuse the snapshot".
-            skills: runtime.skills?.health() ?? disabledSkillsHealth(),
+            // crew#661: plus every subsystem whose phases ARMED without a declared skill (`phaseSkillGaps`,
+            // one `skills.phase-skill` finding each) — the degraded runs' operator-facing record.
+            skills: withPhaseSkillGaps(runtime.skills?.health() ?? disabledSkillsHealth(), runtime.phaseSkills),
             // Is the governance evidence LANDING (crew#495): the store, the records on it, the dead
             // letters — with a `governance.deadletter` finding the moment the outbox holds one.
             governance,
@@ -809,8 +1030,10 @@ runtime = {}) {
         authMode: security.authMode,
     }));
     // The actor audit trail (task #88): who launched/steered/governed what.
-    // Read-only (observer trust); newest first; `?runId=` / `?action=` / `?limit=`.
-    app.get(`${V}/audit`, async (req, reply) => {
+    // Read-only (observer trust); newest first; `?runId=` / `?action=` / `?limit=` / `?since=`.
+    // `since` (unix millis, inclusive) is the lower time bound a skin's "while you were away"
+    // handover reads — the trail since the operator's last visit (studio wave 2b).
+    app.get(`${V}/audit`, { config: { manifest: { responseType: 'AuditPage', statusCodes: [200, 400, 500] } } }, async (req, reply) => {
         const q = req.query;
         const first = (v) => (Array.isArray(v) ? v[0] : v)?.trim() || undefined;
         const runId = first(q.runId);
@@ -822,11 +1045,18 @@ runtime = {}) {
         if (limitRaw !== undefined && (!Number.isFinite(limit) || limit < 1 || !Number.isInteger(limit))) {
             return reply.code(400).send({ error: '`limit` must be a positive integer' });
         }
+        // Same strict parse as `limit`, but zero is a valid clock (the epoch).
+        const sinceRaw = first(q.since);
+        const since = sinceRaw !== undefined ? Number(sinceRaw) : undefined;
+        if (sinceRaw !== undefined && (!Number.isInteger(since) || since < 0)) {
+            return reply.code(400).send({ error: '`since` must be a non-negative integer (unix millis)' });
+        }
         try {
             const entries = await audit.read({
                 ...(runId !== undefined ? { runId } : {}),
                 ...(action !== undefined ? { action } : {}),
                 ...(limit !== undefined ? { limit } : {}),
+                ...(since !== undefined ? { since } : {}),
             });
             return { entries };
         }
@@ -851,6 +1081,33 @@ runtime = {}) {
     // disagree about a seat.
     const rosterWithStanding = runtime.rosterWithStanding ?? rosterWithStandingFactory({ seatHealth, signedIn });
     app.get(`${V}/roster`, async () => ({ roster: rosterWithStanding() }));
+    // Each seat's week (studio's weekly 1:1 per agent; api-types 0.52.0): units, first pass, rework,
+    // stalls, bench and cost, folded from the runs' durable event logs by `seatRecord` — nothing new
+    // is stored. The daemon's remembered stall frames join the engine's, as on `/runs/:id/events`.
+    app.get(`${V}/roster/record`, { config: { manifest: { responseType: 'SeatRecordResponse', statusCodes: [200, 400, 503] } } }, async (req, reply) => {
+        const raw = req.query.days;
+        let days = SEAT_RECORD_DEFAULT_DAYS;
+        if (raw !== undefined) {
+            const one = Array.isArray(raw) ? undefined : raw;
+            const n = one !== undefined && /^[1-9][0-9]?$/.test(one) ? Number(one) : NaN;
+            if (!(n >= 1 && n <= SEAT_RECORD_MAX_DAYS)) {
+                return reply.code(400).send({ error: `Invalid ?days — expected one whole number from 1 to ${SEAT_RECORD_MAX_DAYS}, got ${JSON.stringify(raw)}` });
+            }
+            days = n;
+        }
+        const views = (await adapter.sessionsDetail()).map(decorateRun);
+        const out = await seatRecord(views, async (id) => {
+            const engine = await adapter.runEvents(id);
+            if (engine === null)
+                return null;
+            const daemon = runtime.stallFrames?.(id) ?? [];
+            return daemon.length === 0 ? engine : [...engine, ...daemon];
+        }, { days, now: Date.now() });
+        if (out === null) {
+            return reply.code(503).send({ error: 'Seat records are unavailable: this wicked-core build has no event-log read binding' });
+        }
+        return out;
+    });
     // Open a file/folder with the OS default application (crew#273) — the studio Files tab's
     // click-to-open. The open MUST happen daemon-side (the SPA cannot spawn a process), which is
     // why the path is validated first: absolute, and inside one of the caller-visible roots — the
@@ -1087,33 +1344,61 @@ runtime = {}) {
     });
     // Registered repos → target-repo picker.
     app.get(`${V}/repos`, async () => ({ repos: await adapter.listRepos() }));
+    /** Filing for an onboarding run: what `POST /runs` does for a launch, for the runs `POST /repos`
+     *  and `POST /repos/:id/onboard` start (crew#496). The launch entry (`run.launched`, which dates
+     *  the run and names who started it) is always written; with a `projectId` the run joins that
+     *  project. The run is LIVE by then, so a filing failure is named in the answer, never a 4xx. */
+    const recordOnboardingLaunch = async (req, runId, repoId, opts) => {
+        recordRunLaunched(audit, runTimingIndex, actorOf(req), runId, {
+            workflow: 'onboarding',
+            repoRef: repoId,
+            ...(opts.projectId !== undefined ? { projectId: opts.projectId } : {}),
+            ...(opts.channel !== undefined ? { channel: opts.channel } : {}),
+            ...(opts.actor !== undefined ? { actor: opts.actor } : {}),
+        });
+        if (opts.projectId === undefined)
+            return undefined;
+        try {
+            const { member } = await adapter.projectMemberAttach(opts.projectId, 'crew.run', runId, { onboarding: true }, actorOf(req).id);
+            projects.index.set(runId, opts.projectId);
+            projects.bus?.emit(MEMBERSHIP_ATTACHED, { project_id: opts.projectId, member: { kind: 'crew.run', ref: runId }, actor: actorOf(req).id }, membershipAttachedKey(opts.projectId, 'crew.run', runId, member.attached_at));
+            return undefined;
+        }
+        catch (err) {
+            req.log.warn({ runId, projectId: opts.projectId }, `onboarding run filing failed: ${message(err)}`);
+            return message(err);
+        }
+    };
     app.post(`${V}/repos`, async (req, reply) => {
         const parsed = RegisterRepoSchema.safeParse(req.body);
         if (!parsed.success) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
-        const { name, rootPath, gitUrl } = parsed.data;
+        const { name, rootPath, gitUrl, projectId, channel, actor } = parsed.data;
+        let repo;
+        let runId;
         try {
             if (gitUrl) {
                 // Remote: clone to rootPath (if provided) or default ~/.wicked/repos/<name>,
                 // register, and launch onboarding run.
-                const { repoId, runId } = await adapter.cloneAndRegisterRepo(name, gitUrl, rootPath);
+                const cloned = await adapter.cloneAndRegisterRepo(name, gitUrl, rootPath);
+                runId = cloned.runId;
                 const repos = await adapter.listRepos();
-                const repo = repos.find((r) => r.id === repoId);
+                repo = repos.find((r) => r.id === cloned.repoId);
                 if (!repo)
                     return reply.code(500).send({ error: 'Repo registered but could not be retrieved' });
-                return reply.code(201).send({ repo, onboardRunId: runId });
             }
             else {
                 // Local: register then launch onboarding run.
-                const repo = await adapter.registerRepo(name, rootPath);
-                const runId = await adapter.launchOnboardingRun(repo.id, name);
-                return reply.code(201).send({ repo, onboardRunId: runId });
+                repo = await adapter.registerRepo(name, rootPath);
+                runId = await adapter.launchOnboardingRun(repo.id, name);
             }
         }
         catch (err) {
             return reply.code(400).send({ error: message(err) });
         }
+        const projectAttachError = await recordOnboardingLaunch(req, runId, repo.id, { projectId, channel, actor });
+        return reply.code(201).send({ repo, onboardRunId: runId, ...(projectAttachError !== undefined ? { projectAttachError } : {}) });
     });
     // Return the onboarding run id for a repo (so the UI can navigate to it).
     app.get(`${V}/repos/:id/onboard`, async (req, reply) => {
@@ -1128,13 +1413,18 @@ runtime = {}) {
         const repo = repos.find((r) => r.id === id);
         if (!repo)
             return reply.code(404).send({ error: `Repo ${id} not found` });
+        const body = OnboardBodySchema.safeParse(req.body ?? {});
+        if (!body.success)
+            return reply.code(400).send(invalidBody(body.error, 'Invalid request body'));
+        let runId;
         try {
-            const runId = await adapter.launchOnboardingRun(repo.id, repo.name);
-            return reply.code(201).send({ runId });
+            runId = await adapter.launchOnboardingRun(repo.id, repo.name);
         }
         catch (err) {
             return reply.code(400).send({ error: message(err) });
         }
+        const projectAttachError = await recordOnboardingLaunch(req, runId, repo.id, body.data);
+        return reply.code(201).send({ runId, ...(projectAttachError !== undefined ? { projectAttachError } : {}) });
     });
     // Launch a run (replaces POST /sessions). `clisJson` defaults to the roster;
     // `sessionId` is minted if the client omits it.
@@ -1142,7 +1432,7 @@ runtime = {}) {
         config: {
             manifest: {
                 requestType: 'LaunchRunBody',
-                responseType: '{ runId: string }',
+                responseType: 'LaunchRunResponse',
                 // 404/409: unknown project / unknown campaignId (wicked-studio#27) /
                 // archived-or-synthesized project + busy engine + the state-home blocker
                 // (`state_home_unregistered`) + a roster with no eligible seat (`no_eligible_seat`,
@@ -1159,6 +1449,13 @@ runtime = {}) {
             return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
         }
         const b = parsed.data;
+        // The demo preset launches only from POST /projects/:id/demo (api/demo.ts), which mints the run's
+        // demo root and brief first: launched here directly it would have neither.
+        if (b.workflow === DEMO_PRESET && (b.sessionId === undefined || !demoLaunchRoots.has(b.sessionId))) {
+            return reply.code(400).send({
+                error: 'the demo preset launches from POST /projects/:id/demo, which makes its demo root and brief; POST /runs does not take it directly',
+            });
+        }
         // wicked-core#411 / crew#497: the state-home blocker, judged BEFORE anything is resolved or
         // committed. While the handed skills snapshot derives a state home with an entry the worker
         // Read fence cannot classify, the engine refuses this launch at intake (and an engine before
@@ -1171,6 +1468,10 @@ runtime = {}) {
                 return reply.code(409).send(stateHomeBlockerBody(stateHome));
             }
         }
+        // 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)
+            await rosterWithStanding.ready?.();
         const input = {
             problem: b.problem,
             sessionId: b.sessionId ?? randomUUID(),
@@ -1179,6 +1480,15 @@ runtime = {}) {
             // (`core/engine-roster.ts`), so a signed-out seat is never convened, never a judge.
             clisJson: b.clisJson ?? JSON.stringify(rosterWithStanding()),
         };
+        // A capture launch (api/capture.ts) reads its materials from a per-run inbox outside every
+        // sandbox: the capture route registered it under the run id it minted.
+        const captureRoot = captureLaunchRoots.get(input.sessionId);
+        if (captureRoot !== undefined)
+            input.extraWriteRoots = [captureRoot];
+        // A demo launch (api/demo.ts) writes every file into the demo root the demo route minted for it.
+        const demoRoot = demoLaunchRoots.get(input.sessionId);
+        if (demoRoot !== undefined)
+            input.extraWriteRoots = [demoRoot];
         if (b.entityMode !== undefined)
             input.entityMode = b.entityMode;
         if (b.humanConfirm !== undefined)
@@ -1192,6 +1502,10 @@ runtime = {}) {
             input.repoRef = b.repoRef;
         if (b.workflow !== undefined)
             input.workflow = b.workflow;
+        // DES-TEAMING-002 T3: the plan is the ENGINE's to propose, score, floor and gate — crew
+        // forwards the command and publishes nothing (§4.0).
+        if (b.plan !== undefined)
+            input.plan = toLaunchPlan(b.plan);
         if (b.projectId !== undefined) {
             input.projectId = b.projectId;
             // A project is a CONTEXT (crew#326): a run filed into one should see the project's whole
@@ -1310,8 +1624,45 @@ runtime = {}) {
                 throw err;
             }
         }
+        // crew#627: a workflow run's intent may name its work only by issue ("fix #541"), and the
+        // worker cannot read GitHub. The daemon reads each linked issue now and appends its text to the
+        // problem, inside a marked block the deliver text takes back out. Workflow launches only: the
+        // free-text planner turns sentences into units, so issue text there would become work units.
+        let linkedIssues;
+        if (b.workflow !== undefined) {
+            // Best-effort by contract: reading issues never fails the launch it decorates. A resolver
+            // fault (the repo list unreadable, say) launches the run on its intent alone and is logged.
+            try {
+                const root = b.repoRef !== undefined ? await repoRootOf(b.repoRef) : undefined;
+                const linked = await readLinkedIssues(b.problem, root, b.repoRef);
+                if (linked.block !== null) {
+                    input.problem = `${b.problem.trimEnd()}\n\n${linked.block}`;
+                    linkedIssues = linked.issues;
+                }
+            }
+            catch (err) {
+                req.log.warn(`linked-issue resolution failed; launching on the intent alone: ${message(err)}`);
+            }
+        }
         try {
             const runId = await adapter.launchRun(input);
+            // crew#641/#642 (item 5): when a run is promoted from a chat, record how many seats
+            // participated and whether the chat was grounded — so an intent authored by a single
+            // ungrounded model is distinguishable from one that survived a disagreement.
+            let chatSeatCount;
+            let chatGrounded;
+            // Both stay ABSENT unless the chat actually resolves: a closed or unknown chatId must read as
+            // "provenance unavailable", not as "promoted from an ungrounded zero-seat chat". A valid chat
+            // always has at least one warm seat (`crew-api-types` ChatOpenResponse), so 0 is not a value
+            // `chat_seat_count` can honestly hold.
+            if (b.chatId !== undefined) {
+                const promotedFrom = await adapter.chatSeats(b.chatId).catch(() => null);
+                const scope = chatScopes.engineOf(b.chatId);
+                if (promotedFrom !== null && promotedFrom.length > 0 && scope !== undefined) {
+                    chatSeatCount = promotedFrom.length;
+                    chatGrounded = scope.codeGraphDb != null;
+                }
+            }
             // Who launched it — the engine's LaunchOptions carries no actor field
             // (checked, wicked-core-ts 0.6.0), so the crew-side trail is the system
             // of record for run provenance (task #88).
@@ -1344,10 +1695,19 @@ runtime = {}) {
                 // crew#619: the chat↔run link is durable so the retention maps can be rehydrated after a
                 // daemon restart (rehydration reads `run.launched` entries and keeps non-terminal entries).
                 ...(b.chatId !== undefined ? { chatId: b.chatId } : {}),
+                // crew#641/#642 (item 5): chat promotion provenance — seat count and grounding at launch.
+                ...(chatSeatCount !== undefined ? { chatSeatCount } : {}),
+                ...(chatGrounded !== undefined ? { chatGrounded } : {}),
                 // crew#632: launch surface and caller identity — human-readable provenance on the audit trail.
                 ...(b.channel !== undefined ? { channel: b.channel } : {}),
                 ...(b.actor !== undefined ? { actor: b.actor } : {}),
+                // crew#627: which linked issues the daemon read into the problem, and which it could not.
+                ...(linkedIssues !== undefined ? { linkedIssues } : {}),
             });
+            // Stamp the index live so the field is served without waiting for a daemon restart.
+            if (chatSeatCount !== undefined && chatGrounded !== undefined) {
+                runTimingIndex.setChatPromotion(runId, chatSeatCount, chatGrounded);
+            }
             if (b.retryOf !== undefined)
                 retryIndex.set(runId, b.retryOf);
             if (revisesPr !== undefined)
@@ -1370,10 +1730,15 @@ runtime = {}) {
             // is always reproducible even if the chat is idle-reclaimed before the run finishes.
             if (b.chatId !== undefined)
                 runtime.linkChatRun?.(b.chatId, runId);
-            return reply.code(201).send({ runId });
+            return reply.code(201).send({ runId, ...(linkedIssues !== undefined ? { linkedIssues } : {}) });
         }
         catch (err) {
             const msg = message(err);
+            // DES-TEAMING-002 T3: a plan on an engine without the plan approval gate is an "upgrade the
+            // engine" 501 — never a free-text run launched in its place.
+            if (err instanceof PlanLaunchUnsupportedError) {
+                return reply.code(501).send({ error: msg });
+            }
             // The engine's own intake refusal (wicked-core#411 `StateHomeConfigError`) is a configuration
             // error, not a malformed request: the same typed 409 the pre-check above answers, over a fresh
             // survey — the pre-check saw a clean state home (or an addon that could not classify), the
@@ -1536,8 +1901,6 @@ runtime = {}) {
             return reply.code(404).send({ error: 'Run not found' });
         return { run: decorateRun(run) };
     });
-    /** The full workflow registry, or `[]` on a directly-driven route set whose fake adapter has none. */
-    const listWorkflowsSafe = () => typeof adapter.listWorkflows === 'function' ? adapter.listWorkflows() : [];
     // ── Deliver text (crew#524 / F-3R2-014) — the PR title + body a run's delivery carries ──
     // `gh pr create --fill` gave wicked-studio#249 a mid-word title and an EMPTY body. The deliver
     // script now asks this route for the text composed from the PERSISTED RUN RECORD: the intent,
@@ -1552,12 +1915,12 @@ runtime = {}) {
         const run = views.find((v) => v.session.id === id);
         if (!run)
             return reply.code(404).send({ error: 'Run not found' });
-        const origin = boundOrigin(app.server.address());
-        // The workflow DEFINITION (a user-registered workflow's view carries the engine instance id).
-        const def = resolveRunWorkflow(run, listWorkflowsSafe());
-        const text = composeDeliverText(factsFromRun(decorateRun(run), runUrlFor(origin, id), {
-            workflowId: def?.id ?? null,
+        const followUps = await evaluatorFollowUps(run);
+        // The run's preset or workflow NAME, as the engine recorded it (seam X2).
+        const text = composeDeliverText(factsFromRun(decorateRun(run), runUrlFor(configuredPublicOrigin(), id), {
+            workflowId: runIdentityOf(run).name,
             revisesPr: retryIndex.revisesPrFor(id) ?? null,
+            ...(followUps !== undefined ? { followUps } : {}),
         }));
         return reply.type('text/plain; charset=utf-8').send(framedDeliverText(text));
     });
@@ -1618,10 +1981,19 @@ runtime = {}) {
         const existing = deliveryIndex.urlFor(id);
         if (existing !== undefined)
             return { prUrl: existing };
+        // N1: a run whose branch is already on a non-GitHub origin has nothing left to lift, and no
+        // pull request can be opened from here — say so instead of pushing the branch again.
+        const pushedAlready = deliveryIndex.pushedFor(id);
+        if (pushedAlready !== undefined) {
+            return reply.code(409).send({ error: pushedOnlyRefusal(id, pushedAlready) });
+        }
         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' });
+        // Freeze deliveries (idea 15): nothing pushes while the switch is on.
+        if (deliveryFreeze.state().frozen)
+            return reply.code(409).send(frozenRefusal(deliveryFreeze.state()));
         // crew#418/#432: a run stranded by a recoverable deliver lift failure reads `failed` from the
         // engine but IS liftable post-hoc — normalize its status to `completed` so this route
         // accepts it, exactly as the run wire and the resume route see it.
@@ -1685,7 +2057,7 @@ runtime = {}) {
                     // crew#524: the post-hoc lift composes its PR text from the run record it already
                     // holds (the fallback), and names this daemon so the script can re-ask at delivery.
                     const origin = boundOrigin(app.server.address());
-                    const def = resolveRunWorkflow(run, listWorkflowsSafe());
+                    const workflowName = runIdentityOf(run).name;
                     const revising = retryIndex.revisesPrFor(id);
                     let revisesPr = null;
                     if (revising !== undefined) {
@@ -1699,14 +2071,20 @@ runtime = {}) {
                         }
                         revisesPr = { number: revising.number, headRef: again.pr.headRef, url: again.pr.url };
                     }
+                    const followUps = await evaluatorFollowUps(run);
                     result = await deliverExec(workdir, s.problem ?? undefined, {
                         runId: id,
                         apiOrigin: origin,
-                        facts: factsFromRun(run, runUrlFor(origin, id), {
-                            workflowId: def?.id ?? null,
+                        facts: factsFromRun(run, runUrlFor(configuredPublicOrigin(), id), {
+                            workflowId: workflowName,
                             revisesPr: revisesPr === null ? null : { number: revisesPr.number, url: revisesPr.url },
+                            ...(followUps !== undefined ? { followUps } : {}),
                         }),
                         revisesPr,
+                        // R1 (Copilot on crew#736): the post-hoc delivery binds `gh pr create --repo` to the
+                        // origin's GitHub repository too, read now from the worktree (it shares its repo's
+                        // remotes), so the PR opens where origin points rather than where gh's default does.
+                        originUrl: await readDeliverOriginUrl(workdir),
                     });
                 }
                 finally {
@@ -1748,7 +2126,19 @@ runtime = {}) {
                 error: `deliver failed (exit ${result.status}): ${deliverErrorTail(result.output)}`,
             });
         }
-        const url = prUrlFrom(result.output);
+        // The SAME parser the in-run record uses: the script's push-only verdict outranks a URL a
+        // remote hook echoed earlier in the transcript (Copilot on crew#734).
+        const record = deliveryRecordFrom(result.output);
+        const url = record !== null && 'url' in record ? record.url : null;
+        const pushedOnly = record !== null && 'pushed' in record ? record.pushed : null;
+        if (pushedOnly !== null) {
+            // N1: the script pushed the branch and gh could resolve no GitHub repository for the
+            // origin. That IS a delivery — record it, so the run reads `delivery: 'pushed'` — but there
+            // is no PR URL to answer with, so the reply says what happened instead of a 200 `prUrl`.
+            audit.record('run.delivered', actorOf(req), { runId: id, detail: { pushed: pushedOnly, via: 'post-hoc' } });
+            deliveryIndex.setPushed(id, pushedOnly);
+            return reply.code(409).send({ error: pushedOnlyRefusal(id, pushedOnly) });
+        }
         if (url === null) {
             // Exit 0 with no URL should be unreachable (the script re-derives its own success),
             // but a delivery nothing can be pointed at is never recorded (crew#317).
@@ -1826,6 +2216,12 @@ runtime = {}) {
         }
         const b = parsed.data;
         const chatId = b.chatId ?? randomUUID();
+        const requestedRefs = [...(b.repoRef !== undefined ? [b.repoRef] : []), ...(b.repoRefs ?? [])];
+        // 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)]);
+        if (shape !== null)
+            return reply.code(400).send({ error: shape.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
@@ -1866,8 +2262,14 @@ runtime = {}) {
             const resolution = await resolveChatScope({
                 chatId,
                 ...(b.projectId !== undefined ? { projectId: b.projectId } : {}),
-                repoRefs: [...(b.repoRef !== undefined ? [b.repoRef] : []), ...(b.repoRefs ?? [])],
-            }, { ...chatScopeDeps(adapter), scratchBase: chatScopes.base, log: (m) => req.log.warn(m) });
+                repoRefs: requestedRefs,
+                ...(b.scopeKind !== undefined ? { kind: b.scopeKind } : {}),
+            }, {
+                ...chatScopeDeps(adapter),
+                scratchBase: chatScopes.base,
+                log: (m) => req.log.warn(m),
+                ...(runtime.entityCount !== undefined ? { entityCount: runtime.entityCount } : {}),
+            });
             if (!resolution.ok) {
                 chatScopes.release(chatId, token);
                 return reply.code(resolution.status).send({
@@ -1895,7 +2297,10 @@ runtime = {}) {
             // here is NAMED on the response (`refused`) and in the thread (`chatSeatRefused`), so a
             // person can see why pi is missing. Explicit `clis` are passed through as asked; the engine
             // refuses per seat with its reason, which is copied into `refused` too.
-            const scoped = scope.kind !== 'none';
+            // A chat is SCOPED — held to read-only roots — when it reads repositories by its kind. `none`
+            // and `system` (studio#323 R4: the platform itself, no repository) read none, so they take the
+            // unscoped admission and open on an engine that predates chat scope.
+            const scoped = scope.kind !== 'none' && scope.kind !== 'system';
             const refused = [];
             // The standing roster, read ONCE: the default admission below and the engine-drop
             // attribution after `chatOpen` both consult it (F-A45-011).
@@ -2067,12 +2472,17 @@ runtime = {}) {
                         ...(b.projectId !== undefined ? { project_id: b.projectId } : {}),
                     });
                 }
+                // crew#641: a chat with exactly ONE warm seat cannot disagree with itself — disclosed
+                // prominently so the caller does not have to reason about the refused[] array.
+                const warm = seats.filter((s) => s.ok);
+                const singleSeat = warm.length === 1 ? singleSeatDisclosure(warm[0].cliKey, refused, 'open') : undefined;
                 return reply.code(201).send({
                     chatId,
                     seats,
                     scope,
                     refused,
                     ...(projectAttachError !== undefined ? { projectAttachError } : {}),
+                    ...(singleSeat !== undefined ? { singleSeat } : {}),
                 });
             }
             catch (err) {
@@ -2123,7 +2533,12 @@ runtime = {}) {
         // warm seats — so the turn can be opened BEFORE the engine call, in the same tick as the
         // predicate below: two racing sends can no longer both pass `inFlight` during the await, and a
         // `chatDelta` that lands before `chatSend` resolves is already stamped with its `turn_id`.
-        const audience = parsed.data.targets ?? (await adapter.chatSeats(id));
+        // crew#641 (review): the ROSTER and the AUDIENCE are different things and only one of them can
+        // answer "can this chat disagree with itself". Resolved ONCE here: `audience` is who this turn
+        // goes to (the named targets, else everyone warm), `warmRoster` is who is warm at all. A
+        // targeted send to one seat of a two-seat chat is not a degraded chat.
+        const warmRoster = await adapter.chatSeats(id);
+        const audience = parsed.data.targets ?? warmRoster;
         if (audience.length === 0) {
             return reply.code(409).send({ error: `chat '${id}' has no warm seats — open it first` });
         }
@@ -2141,7 +2556,22 @@ runtime = {}) {
                 chatTurns.reconcile(id, turn.turnId, seats);
                 chatTranscripts?.appendUser(id, turn.turnId, parsed.data.text, seats);
             }
-            return reply.code(202).send({ seats, ...(turn !== null ? { turnId: turn.turnId } : {}) });
+            // crew#641: re-state single-seat degradation on every turn so it is visible in the transcript.
+            // Decided from `warmRoster` — the seats that are WARM — never from `seats`, which is only the
+            // seats this turn reached: a targeted send to one seat of a two-seat chat would otherwise
+            // announce a degradation that does not exist, and a false "you are degraded" sends an operator
+            // after a problem they do not have.
+            // crew#650: `refusedOf` is `undefined` for a chat THIS daemon did not open (a restart drops
+            // the index) — that is "the refusals are unknown", not "the chat gained a seat". The
+            // disclosure is decided by the warm roster alone, and the `undefined` is handed STRAIGHT to
+            // the builder (never `?? []`, review of #658): only it may decide what an unknown record is
+            // allowed to claim.
+            const singleSeat202 = warmRoster.length === 1 ? singleSeatDisclosure(warmRoster[0], chatScopes.refusedOf(id), 'turn') : undefined;
+            return reply.code(202).send({
+                seats,
+                ...(turn !== null ? { turnId: turn.turnId } : {}),
+                ...(singleSeat202 !== undefined ? { singleSeat: singleSeat202 } : {}),
+            });
         }
         catch (err) {
             // Nothing went out: the reservation is retracted so the next send is not refused for it.
@@ -2348,11 +2778,11 @@ runtime = {}) {
         const run = views.find((v) => v.session.id === id);
         if (!run)
             return reply.code(404).send({ error: 'Run not found' });
-        // `sessionsDetail()` patches workflow_id back to the definition name for
-        // BUILT-INS; runs of user-registered workflows still carry the instance id,
-        // so resolve by phase sequence over the full registry. A free-text run
-        // resolves to no workflow, which reads as "declares no requirement".
-        const workflow = resolveRunWorkflow(run, adapter.listWorkflows());
+        // What the run must prove, from what it CONTAINS (seam X2): a plan or preset run's steps whose
+        // catalog entry re-verifies evidence, a registered workflow's def, nothing for free text — and
+        // an unknown run (or one the daemon cannot read) is declared and denied with the reason.
+        const verifiedCatalog = typeof adapter.verifiedEvidenceCatalog === 'function' ? await adapter.verifiedEvidenceCatalog() : null;
+        const requirement = acceptanceRequirementOf(run, adapter.listWorkflows(), verifiedCatalog);
         let repo = null;
         if (run.session.repo_ref !== null) {
             const repos = await adapter.listRepos();
@@ -2361,8 +2791,7 @@ runtime = {}) {
         return buildAcceptanceView({
             runId: id,
             repo,
-            workflow,
-            gateEvents: qeGateEvents,
+            requirement,
             ...(qeRunId !== undefined && qeRunId !== '' ? { qeRunId } : {}),
             // AW-14 (arch-R13a + R16): the conformance section reads the same wires the standalone
             // `/governance/claims` and `/runs/:id/events` routes serve, but run-scoped and resolved
@@ -2372,55 +2801,122 @@ runtime = {}) {
             events: (rid) => adapter.runEvents(rid),
         });
     });
-    // The steering gate (§11.1). approve+amend = approve-with-steer; approve:false = reject (cancels).
-    app.post(`${V}/runs/:id/gate`, {
-        config: {
-            manifest: {
-                requestType: 'GateDecision',
-                responseType: '{ status: SessionStatus; landing?: SteeringLandingResult }',
-                // 409 twice over: a run not awaiting a human gate, and an engine refusal at confirm.
-                statusCodes: [200, 400, 404, 409],
-            },
-        },
-    }, async (req, reply) => {
-        const { id } = req.params;
-        const parsed = GateSchema.safeParse(req.body);
+    /**
+     * The run's OPEN gate, resolved the way `GET /runs/:id/gate` serves it: the cache, then the
+     * engine's durable `interaction_requests` row (adopted into the cache), then the event-log replay.
+     * The caller has already checked `awaiting_human`. `null` = the log records no open gate;
+     * `'no-log'` = this build cannot read the log, so nothing can be said.
+     */
+    async function resolveOpenGate(id) {
+        const cached = gateCache.get(id);
+        if (cached)
+            return cached;
+        const durableRows = typeof adapter.interactionRequests === 'function'
+            ? await adapter.interactionRequests(id, 'open')
+            : null;
+        const durableGate = durableRows?.find((r) => r.kind === 'gate');
+        if (durableGate !== undefined) {
+            // This path builds the entry inline (not through `fold`), so it must run the SAME refusal
+            // detection (issue #419) — otherwise a gate served from the durable row after a restart would
+            // silently drop the warning that the live/replay paths carry.
+            const refusal = detectRefusal(durableGate.prompt);
+            const entry = {
+                ord: durableGate.ord ?? 0,
+                prompt: durableGate.prompt,
+                lifecycle: 'open',
+                receivedAt: new Date(durableGate.created_at).toISOString(),
+                ...(refusal !== undefined ? { refusal } : {}),
+            };
+            gateCache.adopt(id, entry);
+            return entry;
+        }
+        const events = await adapter.runEvents(id);
+        if (events === null)
+            return 'no-log';
+        return gateCache.rebuild(id, events) ?? null;
+    }
+    /**
+     * THE gate decision path. `POST /runs/:id/gate` answers with it, and so does a standing order
+     * (behaviour 10) — the same awaiting check, the same ord check and 409 `gate_changed` /
+     * `gate_unknown`, the same `confirmGate`, the same `gate.decided` audit. There is no side path:
+     * an order is just another actor, named on the audit line (`extraDetail.standingOrder`).
+     */
+    async function decideGate(id, decision, actor, extraDetail = {}) {
+        const parsed = GateSchema.safeParse(decision);
         if (!parsed.success) {
-            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+            return { code: 400, body: invalidBody(parsed.error, 'Invalid request body') };
         }
         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' });
+            return { code: 404, body: { error: 'Run not found' } };
         if (run.session.status !== 'awaiting_human') {
-            return reply
-                .code(409)
-                .send({ error: `Run is not awaiting a human gate (status: ${run.session.status})` });
+            return { code: 409, body: { error: `Run is not awaiting a human gate (status: ${run.session.status})` } };
+        }
+        // api-types 0.44.0: a decision that names its gate answers THAT gate or nothing. When the
+        // daemon cannot tell which gate is open (no cache, no durable row, no log binding, or a log
+        // recording no open gate) it cannot confirm the named one either, so it refuses — the skin
+        // re-reads the gate and the person decides again. A request without `ord` is unchanged.
+        if (parsed.data.ord !== undefined) {
+            const open = await resolveOpenGate(id);
+            if (open === null || open === 'no-log') {
+                return { code: 409, body: {
+                        error: `Gate unknown: this decision names the gate before unit ${parsed.data.ord}, but the daemon cannot `
+                            + 'tell which gate is open on this run — refresh and decide again.',
+                        code: 'gate_unknown',
+                    } };
+            }
+            if (open.ord !== parsed.data.ord) {
+                return { code: 409, body: {
+                        error: `Gate changed: this decision was made on the gate before unit ${parsed.data.ord}, but the open gate `
+                            + `is before unit ${open.ord} — it was answered or replaced. Read the open gate before deciding.`,
+                        code: 'gate_changed',
+                        openOrd: open.ord,
+                    } };
+            }
+        }
+        // Freeze deliveries (idea 15): an APPROVE that would run the run's deliver unit is held while
+        // the switch is on — the gate stays open, so unfreezing lets the same approve through. The gate
+        // is the named one, else the open one, else the unit the run's cursor points at.
+        if (parsed.data.approve && deliveryFreeze.state().frozen) {
+            let gateOrd = parsed.data.ord;
+            if (gateOrd === undefined) {
+                const open = await resolveOpenGate(id);
+                gateOrd = open !== null && open !== 'no-log' ? open.ord : undefined;
+            }
+            const units = run.units ?? [];
+            const gated = gateOrd !== undefined
+                ? units.find((u) => u.ord === gateOrd)
+                : [...units].sort((a, b) => a.ord - b.ord)[run.session.unit_ix];
+            if (gated !== undefined && isDeliverUnit(gated)) {
+                return { code: 409, body: frozenRefusal(deliveryFreeze.state()) };
+            }
         }
         // The steering-author landing (crew#388): decided — and the gate prompt captured — BEFORE
         // the confirm, because a terminal-phase approve prunes the gate cache and moves the run out
-        // of `awaiting_human`. The landing itself runs AFTER a successful approve only.
-        // (`listWorkflows` is presence-guarded for partial-stub adapters — a registry-less adapter
-        // cannot be hosting a steering-author run, and the legacy gate path must not 500 over it.)
-        const steeringPropose = parsed.data.approve &&
-            typeof adapter.listWorkflows === 'function' &&
-            isSteeringAuthorRun(run, adapter.listWorkflows());
+        // of `awaiting_human`. The landing itself runs AFTER a successful approve only. The run is
+        // classified by its recorded name (seam X2), so a partial-stub adapter with no registry cannot
+        // 500 the legacy gate path here.
+        const steeringPropose = parsed.data.approve && isSteeringAuthorRun(run);
         const gatePrompt = steeringPropose ? gateCache.get(id)?.prompt : undefined;
         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,
             // an engine older than the arm) surfaces as the existing 409 below.
-            const status = await adapter.confirmGate(id, parsed.data.approve, parsed.data.amend, parsed.data.action, parsed.data.amendScope);
+            const status = await adapter.confirmGate(id, parsed.data.approve, parsed.data.amend, parsed.data.action, parsed.data.amendScope, parsed.data.plan !== undefined ? toLaunchPlan(parsed.data.plan) : undefined);
             // WHO approved/rejected — the gate-decision audit (task #88). The engine
             // records THAT the gate resolved (interaction_requests / gateDecided);
             // only this HTTP layer knows the authenticated principal behind it.
-            audit.record('gate.decided', actorOf(req), {
+            audit.record('gate.decided', actor, {
                 runId: id,
                 detail: {
                     approve: parsed.data.approve,
                     ...(parsed.data.amend !== undefined ? { amend: parsed.data.amend } : {}),
                     ...(parsed.data.action !== undefined ? { action: parsed.data.action } : {}),
                     ...(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 } : {}),
+                    ...extraDetail,
                     status,
                 },
             });
@@ -2433,13 +2929,32 @@ 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: actorOf(req) }, run, gatePrompt)
+                ? await landSteeringProposal({ adapter, audit, actor }, run, gatePrompt)
                 : undefined;
-            return reply.send({ status, ...(landing !== undefined ? { landing } : {}) });
+            return { code: 200, body: { status, ...(landing !== undefined ? { landing } : {}) } };
         }
         catch (err) {
-            return reply.code(409).send({ error: message(err) });
+            if (err instanceof PlanLaunchUnsupportedError) {
+                return { code: 501, body: { error: message(err) } };
+            }
+            return { code: 409, body: { error: message(err) } };
         }
+    }
+    // The steering gate (§11.1). approve+amend = approve-with-steer; approve:false = reject (cancels).
+    app.post(`${V}/runs/:id/gate`, {
+        config: {
+            manifest: {
+                requestType: 'GateDecision',
+                responseType: '{ status: SessionStatus; landing?: SteeringLandingResult }',
+                // 409 twice over: a run not awaiting a human gate, and an engine refusal at confirm.
+                // 501: an edited plan on an addon without the plan approval gate (DES-TEAMING-002 T3).
+                statusCodes: [200, 400, 404, 409, 501],
+            },
+        },
+    }, async (req, reply) => {
+        const { id } = req.params;
+        const out = await decideGate(id, req.body, actorOf(req));
+        return reply.code(out.code).send(out.body);
     });
     // Cancel a running or paused run (distinct third action, §11.1).
     app.post(`${V}/runs/:id/cancel`, async (req, reply) => {
@@ -2486,9 +3001,11 @@ runtime = {}) {
                 ? `run ${id} is cancelled — a terminal run cannot be resumed; relaunch the work as a new run with POST /runs {"retryOf":"${id}"}`
                 : state.delivery === 'stranded'
                     ? `run ${id} is already completed — nothing to resume; its unlifted work is on the wicked/${id} branch: deliver it with POST /runs/${id}/deliver`
-                    : state.delivery === 'vacuous'
-                        ? `run ${id} is already completed, but VACUOUSLY — its units produced no work to resume or deliver; relaunch with POST /runs {"retryOf":"${id}"}`
-                        : `run ${id} is already completed — nothing to resume; relaunch the work as a new run with POST /runs {"retryOf":"${id}"}`;
+                    : state.delivery === 'pushed'
+                        ? `run ${id} is already completed and delivered — its branch ${state.deliverBranch ?? `wicked/${id}`} is on ${state.deliverRemote ?? 'origin'} (no pull request: that origin is not a GitHub host gh can resolve); nothing to resume`
+                        : state.delivery === 'vacuous'
+                            ? `run ${id} is already completed, but VACUOUSLY — its units produced no work to resume or deliver; relaunch with POST /runs {"retryOf":"${id}"}`
+                            : `run ${id} is already completed — nothing to resume; relaunch the work as a new run with POST /runs {"retryOf":"${id}"}`;
             return reply.code(409).send({ error: why, recovery });
         }
         try {
@@ -2496,9 +3013,7 @@ runtime = {}) {
             // A gated resume IS a gate approval, so it lands a steering-author proposal exactly like
             // POST /runs/:id/gate would — the "no side door" rule (task #88) holds for the landing
             // write too (crew#388). Prompt captured pre-confirm; see the gate route.
-            const steeringPropose = gated &&
-                typeof adapter.listWorkflows === 'function' &&
-                isSteeringAuthorRun(run, adapter.listWorkflows());
+            const steeringPropose = gated && isSteeringAuthorRun(run);
             const gatePrompt = steeringPropose ? gateCache.get(id)?.prompt : undefined;
             const status = gated ? await adapter.confirmGate(id, true) : await adapter.resumeRun(id);
             // A resume of a gated run IS a gate approval — audit it as one, so the
@@ -2580,7 +3095,7 @@ runtime = {}) {
                     `this build cannot approve the gate on your behalf (no confirmGate); approve via POST /runs/${id}/gate, then reassign`,
             });
         }
-        if (gated && typeof adapter.listWorkflows === 'function' && isSteeringAuthorRun(run, adapter.listWorkflows())) {
+        if (gated && isSteeringAuthorRun(run)) {
             return reply.code(409).send({
                 error: `run ${id} is awaiting a steering-author propose gate — approve or reject it via POST /runs/${id}/gate (the approve lands the proposal); reassign is not a review of the rules`,
             });
@@ -2648,34 +3163,12 @@ runtime = {}) {
             return reply.code(404).send({ error: 'No open gate for this run' });
         }
         // DURABLE TRUTH FIRST (DES-PROJECT-001 §5.3): the engine persists the open prompt in
-        // `interaction_requests`, written in the same transaction as the `awaiting_human` pause —
-        // so a daemon restart reads it back directly instead of replaying the event log. The cache
-        // adopts the row (latency layer over durable truth — its comments finally true). The replay
-        // below stays as the FALLBACK, not just for engines predating the binding: a run parked
-        // BEFORE the engine grew the table is awaiting_human with no row, and answering 404 there
-        // would re-open FINDING-051 for exactly the runs mid-upgrade. Row → serve it; no row →
-        // fall through and let the log speak.
-        const durableRows = typeof adapter.interactionRequests === 'function'
-            ? await adapter.interactionRequests(id, 'open')
-            : null;
-        const durableGate = durableRows?.find((r) => r.kind === 'gate');
-        if (durableGate !== undefined) {
-            // This path builds the entry inline (not through `fold`), so it must run the SAME refusal
-            // detection (issue #419) — otherwise a gate served from the durable row after a restart would
-            // silently drop the warning that the live/replay paths carry.
-            const refusal = detectRefusal(durableGate.prompt);
-            const entry = {
-                ord: durableGate.ord ?? 0,
-                prompt: durableGate.prompt,
-                lifecycle: 'open',
-                receivedAt: new Date(durableGate.created_at).toISOString(),
-                ...(refusal !== undefined ? { refusal } : {}),
-            };
-            gateCache.adopt(id, entry);
-            return { runId: id, ...entry };
-        }
-        const events = await adapter.runEvents(id);
-        if (events === null) {
+        // `interaction_requests`, written in the same transaction as the `awaiting_human` pause — so a
+        // daemon restart reads it back instead of replaying the log; the replay stays the FALLBACK for
+        // runs parked before the engine grew the table. `resolveOpenGate` is that one resolution, shared
+        // with the POST route's `ord` check.
+        const open = await resolveOpenGate(id);
+        if (open === 'no-log') {
             // Now — and only now — 503 is the honest answer: this run really is holding for a human, and
             // this build cannot say what it is asking. Distinct cause, distinct message; answering "no
             // gate" here would report a capability gap as a fact about the run (the FINDING-050 shape).
@@ -2683,13 +3176,12 @@ runtime = {}) {
                 error: 'Gate history is unavailable: this wicked-core build has no event-log read binding',
             });
         }
-        const replayed = gateCache.rebuild(id, events);
-        if (!replayed) {
+        if (open === null) {
             // Parked, with a history that records no open gate. Pre-log runs land here (their prompt is
             // genuinely lost), as does a gate whose `awaitingHuman` predates the log's retention.
             return reply.code(404).send({ error: 'No open gate for this run' });
         }
-        return { runId: id, ...replayed };
+        return { runId: id, ...open };
     });
     // ── Elicitation (DES-002) ────────────────────────────────────────────────────
     //
@@ -2979,6 +3471,74 @@ runtime = {}) {
         const claims = await adapter.listConformanceClaims();
         return { claims };
     });
+    // Replay THIS daemon's governance dead-letter outbox into its own store — the
+    // `wicked-crew governance replay` CLI (crew#495) as a route, so a skin can offer the repair
+    // beside the count it shows (`/diagnostics.governance.deadletters`). `dryRun: true` folds the
+    // outbox and moves nothing, and says up front whether a real replay could run at all
+    // (`blocker`); a real replay drains exactly as the CLI does (archive first, entries that fail
+    // go back onto the live outbox and stay dead letters). One replay at a time per daemon.
+    let deadletterReplayInFlight = false;
+    app.post(`${V}/governance/deadletters/replay`, {
+        config: {
+            manifest: {
+                requestType: 'GovernanceReplayBody',
+                responseType: 'GovernanceReplayOutcome',
+                statusCodes: [200, 400, 409, 500, 501],
+            },
+        },
+    }, async (req, reply) => {
+        const parsed = z.object({ dryRun: z.boolean().optional() }).strict().safeParse(req.body ?? {});
+        if (!parsed.success)
+            return reply.code(400).send({ error: parsed.error.message });
+        const dryRun = parsed.data.dryRun === true;
+        const store = adapter.governanceStore ?? null;
+        if (store === null) {
+            return reply.code(409).send({ error: 'this daemon resolved no governance store — there is nothing to replay into' });
+        }
+        const blocker = store.dbPath === ':memory:'
+            ? 'the governance store is in-memory — name a durable store before replaying'
+            : !CoreAdapter.replayEmitOutboxSupported()
+                ? 'the installed engine cannot replay a dead-letter outbox — upgrade wicked-core-ts'
+                : null;
+        // Checked FIRST, for both modes: a running replay has renamed the live outbox to its archive,
+        // so any read now would report a false zero while those dead letters are still in flight.
+        if (deadletterReplayInFlight)
+            return reply.code(409).send({ error: 'a dead-letter replay is already running' });
+        const outbox = store.outboxPath;
+        if (!existsSync(outbox)) {
+            // No outbox = no dead letters: a zero outcome, never an error.
+            const fold = await foldDeadletters(outbox);
+            return {
+                outbox, store: { path: store.displayPath, source: store.source }, archive: null,
+                read: 0, replayed: 0, alreadyPresent: null, failed: 0, dryRun, note: null,
+                ...(dryRun ? { fold } : {}), blocker,
+            };
+        }
+        if (!dryRun && blocker !== null)
+            return reply.code(blocker.startsWith('the installed engine') ? 501 : 409).send({ error: blocker });
+        if (!dryRun)
+            deadletterReplayInFlight = true;
+        try {
+            const { outcome } = await replayOutboxInto(outbox, store, { dryRun });
+            if (!dryRun) {
+                audit.record('governance.deadletters.replayed', actorOf(req), {
+                    detail: { read: outcome.read, replayed: outcome.replayed, failed: outcome.failed },
+                });
+            }
+            return { ...outcome, blocker: dryRun ? blocker : null };
+        }
+        catch (err) {
+            if (err instanceof GovernanceReplayUnsupportedError)
+                return reply.code(501).send({ error: message(err) });
+            if (err instanceof UsageError)
+                return reply.code(409).send({ error: message(err) });
+            return reply.code(500).send({ error: message(err) });
+        }
+        finally {
+            if (!dryRun)
+                deadletterReplayInFlight = false;
+        }
+    });
     // Normalize a `?repo=` query: Fastify parses a repeated `?repo=a&repo=b` into a `string[]` (take
     // the first), and the value is TRIMMED so it's both validated and PASSED trimmed — a `?repo=%20x%20`
     // must not pass the guard then miss the registry lookup on whitespace (Copilot #227).
@@ -3148,15 +3708,41 @@ runtime = {}) {
         }
     });
     // ── Workflow viewer + builder (crew#44) ───────────────────────────────────
+    // (crew#718) Start the engine's verdict pass at registration, so every SYNC reader of
+    // `listWorkflows()` / `getWorkflow()` (the deliver resolver, the acceptance fold, the launch
+    // lookup) sees the judged catalog from the first request rather than after the first catalog GET.
+    // The pass is memoized: the handlers below await the same promise.
+    // Guarded like `listWorkflows` at :1110 — the endpoint-manifest collector registers these routes
+    // against a partial adapter that carries neither.
+    if (typeof adapter.workflowCatalog === 'function') {
+        void adapter.workflowCatalog().catch((err) => {
+            app.log.warn(`wicked-crew: the workflow overlay could not be judged (${message(err)}); the catalog lists what parsed`);
+        });
+    }
+    // (crew#718) The catalog is what the ENGINE will honour, not what parses as `{id, phases[]}`.
+    // A drop-in core refused at boot ("gate evaluates nothing: …") used to be listed here and
+    // offered in studio's selector, and the launch then 400'd `unknown workflow` — the operator
+    // learnt about it only from the failed launch. `workflowCatalog()` asks core's own validator:
+    // the refused def leaves `workflows` (so it cannot be launched) and appears in `unavailable`
+    // with core's verbatim reason (so its author is told why, and what to fix).
     app.get(`${V}/workflows`, async () => {
-        const workflows = adapter.listWorkflows();
-        return { workflows };
+        const { workflows, unavailable } = await adapter.workflowCatalog();
+        return { workflows, unavailable };
     });
     app.get(`${V}/workflows/:id`, async (req, reply) => {
         const { id } = req.params;
+        // (crew#718) JUDGE FIRST (review of PR #724, MEDIUM). `getWorkflow` only hydrates the overlay
+        // dir; `workflowRefusal` is what runs the engine's verdict pass and drops the defs it refused.
+        // Read the other way round, the FIRST request for a refused drop-in answered 200 with the def
+        // the engine had thrown away — and this route is where the launch looks it up.
+        const refusal = await adapter.workflowRefusal(id);
+        if (refusal !== null) {
+            return reply.code(404).send({ error: `workflow '${id}' was refused by the engine: ${refusal}`, reason: refusal });
+        }
         const workflow = adapter.getWorkflow(id);
-        if (!workflow)
+        if (!workflow) {
             return reply.code(404).send({ error: `workflow '${id}' not found` });
+        }
         // humanGates: the phases that will PAUSE for a person even under humanConfirm:none (core#208).
         // Surfaced so an operator can see a workflow's gates BEFORE launching it (FINDING-023).
         return { workflow, humanGates: humanGatePhaseIds(workflow) };
@@ -3478,6 +4064,18 @@ runtime = {}) {
             return reply.code(500).send({ error: message(err) });
         }
     });
+    // R3 (ship-prove-3): what a delivering launch on this repo would push and where — read by the
+    // SAME origin preflight the deliver gate card uses (crew#730), so the launch composer cannot
+    // promise "opens a PR" on an origin that can never carry one. Read-only: one
+    // `git remote get-url --push origin` in the registered checkout; nothing is pushed or probed.
+    app.get(`${V}/repos/:id/deliver-target`, { config: { manifest: { responseType: 'DeliverTargetResponse', statusCodes: [200, 404] } } }, async (req, reply) => {
+        const { id } = req.params;
+        const repo = deliverRepoFor(await adapter.listRepos(), id);
+        if (repo === undefined)
+            return reply.code(404).send({ error: `Repo ${id} not found` });
+        const originUrl = repo.root_path === '' ? null : await readDeliverOriginUrl(repo.root_path);
+        return reply.send({ repo: repo.id, ...deliverTargetView(originUrl) });
+    });
     app.get(`${V}/repos/:id/git-history`, async (req, reply) => {
         const { id } = req.params;
         const repos = await adapter.listRepos();
@@ -3660,6 +4258,22 @@ runtime = {}) {
                     .send({ error: 'workerStallMaxEscalations must be an integer between 1 and 10' });
             }
         }
+        // deliverIdentityLogin (crew#549): the login the deliver phase must push as. A typo here
+        // would be an identity the script can never match — every delivery would refuse — so an
+        // invalid value is a 400, never a silently-dropped key. `''` clears it (back to GH_ACCOUNT).
+        // A LOGIN, never a token: the same validator the deliver script's splice uses.
+        if (Object.hasOwn(patch, 'deliverIdentityLogin')) {
+            const login = patch.deliverIdentityLogin;
+            if (typeof login !== 'string' || (login !== '' && !isGitHubLogin(login.trim()))) {
+                return reply.code(400).send({
+                    error: 'deliverIdentityLogin must be a GitHub login (letters, digits and single hyphens, '
+                        + 'up to 39 characters), or "" to fall back to the GH_ACCOUNT environment variable. '
+                        + 'It is a login, never a token — the credential stays in gh\'s keyring or GH_TOKEN.',
+                });
+            }
+            if (typeof login === 'string')
+                patch.deliverIdentityLogin = login.trim();
+        }
         // deliverDefault (crew#393): the repo-scoped launch delivery default. Two values only —
         // this knob decides whether completed code runs open PRs, so a typo must be a 400, never
         // a silently-dropped key that leaves the operator believing they flipped it.
@@ -3731,6 +4345,7 @@ runtime = {}) {
             'workerStallEscalateAction',
             'workerStallMaxEscalations',
             'deliverDefault',
+            'deliverIdentityLogin',
             'baseSkillRef',
             'baseSkillPolicy',
         ];
@@ -3815,6 +4430,41 @@ runtime = {}) {
             return estateUpstreamError(reply, err);
         }
     });
+    // POST /proposals {content, project?, source?} → proposal.submit → 201 { id } (api-types 0.54.0).
+    // A skin files ONE preference into the same review queue — studio's "takes": the person picks one
+    // of two candidate outputs, and the pick becomes "prefers takes like X", learned only once they
+    // accept it here. The kind (`memory`), tier and `capture: "preference"` marker are the daemon's; a
+    // caller cannot file a policy through this door (the schema is strict). `project` becomes the
+    // `project` facet, so the preference is recalled on that project only.
+    app.post(`${V}/proposals`, {
+        config: {
+            manifest: { requestType: 'FileProposalBody', responseType: 'FileProposalResponse', statusCodes: [201, 400, 502] },
+        },
+    }, async (req, reply) => {
+        const parsed = FileProposalSchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid proposal body'));
+        }
+        const { content, project, source } = parsed.data;
+        const payload = { content, tier: 'semantic', capture: 'preference' };
+        if (source !== undefined)
+            payload.source = source;
+        let submitted;
+        try {
+            submitted = (await estateTool('proposal.submit', {
+                kind_type: 'memory',
+                payload,
+                facets: project !== undefined ? { project } : {},
+            }));
+        }
+        catch (err) {
+            return estateUpstreamError(reply, err);
+        }
+        if (typeof submitted?.id !== 'string' || submitted.id === '') {
+            return reply.code(502).send({ error: 'proposal.submit returned no id' });
+        }
+        return reply.code(201).send({ id: submitted.id });
+    });
     // POST /proposals/:id/approve → proposal.approve →
     //   { outcome:'promoted', active_id }              — a MEMORY proposal, now an active memory (complete);
     //   { outcome:'handed_off', payload, landing }     — a POLICY proposal, LANDED here as a steering rule.
@@ -3829,7 +4479,16 @@ runtime = {}) {
     // 500, never the silent no-op that crew#388 exists to end — and `payload` is still returned for
     // backward compatibility. The MEMORY path is UNTOUCHED: a `promoted` outcome returns immediately
     // with no extra estate call and no landing.
-    app.post(`${V}/proposals/:id/approve`, { config: { manifest: { responseType: 'ApproveProposalResponse', statusCodes: [200, 400, 502] } } }, async (req, reply) => {
+    app.post(`${V}/proposals/:id/approve`, {
+        config: {
+            manifest: {
+                requestType: 'ApproveProposalBody',
+                responseType: 'ApproveProposalResponse',
+                // 404: an accept-with-edit naming no pending proposal; 409: one already in flight for it.
+                statusCodes: [200, 400, 404, 409, 502],
+            },
+        },
+    }, async (req, reply) => {
         // Normalize ONCE and use the trimmed value throughout — an id like `%20pol1%20`
         // decodes to a padded, non-empty string that would otherwise ride upstream as-is
         // and into `proposal:<id>` derivations.
@@ -3837,6 +4496,24 @@ runtime = {}) {
         if (id === '') {
             return reply.code(400).send({ error: '`id` is required' });
         }
+        // An accept WITH an edit (capture review, api-types 0.49.0): the edited copy replaces the
+        // original in the same queue — see `approveEdited`. No body / `{}` is the plain approve below.
+        const edit = ApproveEditSchema.safeParse(req.body ?? {});
+        if (!edit.success) {
+            return reply.code(400).send(invalidBody(edit.error, 'Invalid approve body'));
+        }
+        if (edit.data.content !== undefined || edit.data.reach !== undefined) {
+            try {
+                const done = await approveEdited(estateTool, id, edit.data, (runId) => projects.index.projectOf(runId));
+                return reply.code(done.status).send(done.body);
+            }
+            catch (err) {
+                return estateUpstreamError(reply, err);
+            }
+        }
+        if (editInFlight(id)) {
+            return reply.code(409).send({ error: `proposal ${id} is already being accepted` });
+        }
         let approved;
         try {
             approved = (await estateTool('proposal.approve', { id }));
@@ -3907,11 +4584,16 @@ runtime = {}) {
         return { outcome: 'handed_off', payload: approved.payload, landing };
     });
     // POST /proposals/:id/reject → proposal.reject → { ok: true }.
-    app.post(`${V}/proposals/:id/reject`, { config: { manifest: { responseType: 'RejectProposalResponse', statusCodes: [200, 400, 502] } } }, async (req, reply) => {
+    app.post(`${V}/proposals/:id/reject`, 
+    // 409: an accept-with-edit of this proposal is in flight (api/capture.ts).
+    { config: { manifest: { responseType: 'RejectProposalResponse', statusCodes: [200, 400, 409, 502] } } }, async (req, reply) => {
         const { id } = req.params;
         if (id.trim() === '') {
             return reply.code(400).send({ error: '`id` is required' });
         }
+        if (editInFlight(id.trim())) {
+            return reply.code(409).send({ error: `proposal ${id.trim()} is being accepted` });
+        }
         try {
             return (await estateTool('proposal.reject', { id }));
         }
@@ -3937,10 +4619,12 @@ runtime = {}) {
     //     applied HERE as post-filters over that complete set (see below) — filtering, not retrieval.
     //   • list returns { memory_id, scope, content, tier, facets, created_at }; facets ride through to
     //     MemoryItem.facets, powering the surface's facet filter.
-    //   • RETIRE is SUBTREE-scoped, never per-id. estate exposes NO per-memory delete: `memory.erase`
-    //     hard-deletes EVERY memory whose scope equals or descends from `scope_prefix`, and refuses an
-    //     empty prefix (a total-wipe guard). So retire takes a `scope_prefix` and reports how many
-    //     memories the subtree wipe removed — the UI must show the operator the subtree, not one row.
+    //   • RETIRE comes in two widths. `POST /memory/retire { scope_prefix }` is SUBTREE-scoped:
+    //     `memory.erase {scope_prefix}` hard-deletes EVERY memory whose scope equals or descends from
+    //     the prefix, and refuses an empty prefix (a total-wipe guard) — the UI must show the operator
+    //     the subtree. `POST /memory/retire-item { memory_id }` (studio#206) removes exactly ONE memory
+    //     through `memory.erase {id}` (wicked-estate#188); an older estate refuses that call without
+    //     deleting anything, and the route answers 501 naming the upgrade — never a subtree fallback.
     // GET /memory?query=&scope_prefix=&facets=<json>&limit= → memory.list + post-filter → { memories }.
     app.get(`${V}/memory`, { config: { manifest: { responseType: 'ListMemoriesResponse', statusCodes: [200, 400, 502] } } }, async (req, reply) => {
         const q = req.query;
@@ -4043,9 +4727,9 @@ runtime = {}) {
             return estateUpstreamError(reply, err);
         }
     });
-    // POST /memory/retire { scope_prefix } → memory.erase → { erased }. SUBTREE-scoped (no per-id
-    // delete in estate); an empty scope_prefix is refused at the route (a 400 BEFORE any spawn) — the
-    // same total-wipe guard estate enforces with -32602.
+    // POST /memory/retire { scope_prefix } → memory.erase → { erased }. SUBTREE-scoped (the per-item
+    // delete is /memory/retire-item below); an empty scope_prefix is refused at the route (a 400
+    // BEFORE any spawn) — the same total-wipe guard estate enforces with -32602.
     app.post(`${V}/memory/retire`, {
         config: {
             manifest: {
@@ -4062,7 +4746,7 @@ runtime = {}) {
         const scopePrefix = parsed.data.scope_prefix.trim();
         if (scopePrefix === '') {
             return reply.code(400).send({
-                error: '`scope_prefix` must not be empty — memory.erase is subtree-scoped (no per-id delete) and refuses a total wipe',
+                error: '`scope_prefix` must not be empty — this retire is subtree-scoped and refuses a total wipe (one memory: POST /memory/retire-item)',
             });
         }
         try {
@@ -4078,8 +4762,64 @@ runtime = {}) {
             return estateUpstreamError(reply, err);
         }
     });
+    // POST /memory/retire-item { memory_id } → memory.erase { id } → { erased: 1 } (studio#206). Removes
+    // exactly ONE memory: the id is the only target sent, so no reading of it can widen to a subtree.
+    // 404 when estate holds no memory with that id (it erased 0). 501 when the estate predates
+    // wicked-estate#188: it refuses an id-only erase for want of `scope_prefix`, deleting nothing.
+    app.post(`${V}/memory/retire-item`, {
+        config: {
+            manifest: {
+                requestType: 'RetireMemoryItemBody',
+                responseType: 'RetireMemoryResponse',
+                statusCodes: [200, 400, 404, 501, 502],
+            },
+        },
+    }, async (req, reply) => {
+        const parsed = RetireMemoryItemSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid retire request'));
+        }
+        const memoryId = parsed.data.memory_id.trim();
+        if (memoryId === '')
+            return reply.code(400).send({ error: '`memory_id` must not be empty' });
+        try {
+            const raw = await estateTool('memory.erase', { id: memoryId });
+            const deleted = typeof raw === 'object' && raw !== null ? raw['deleted_count'] : undefined;
+            if (typeof deleted !== 'number') {
+                throw new EstateMcpError('memory.erase returned an unexpected shape');
+            }
+            if (deleted === 0)
+                return reply.code(404).send({ error: `no memory ${memoryId}` });
+            if (deleted !== 1) {
+                // An id names one memory; any other count is estate misbehaving, and it is reported as such.
+                return reply.code(502).send({ error: `memory.erase {id} removed ${deleted} memories, expected 1` });
+            }
+            const body = { erased: 1 };
+            return body;
+        }
+        catch (err) {
+            if (err instanceof EstateMcpError && err.code === -32602 && ESTATE_NO_ERASE_BY_ID.test(err.message)) {
+                return reply.code(501).send({
+                    error: 'this wicked-estate cannot erase one memory by id (it needs wicked-estate#188); upgrade wicked-estate-mcp — nothing was deleted',
+                    code: 'estate_upgrade_required',
+                });
+            }
+            return estateUpstreamError(reply, err);
+        }
+    });
     // ── Projects (DES-PROJECT-001) — the 9-route experience-plane surface ────────
     registerProjectRoutes(app, adapter, { ...projects, settings: projectSettings }, security);
+    // ── Capture (Studio OS behaviour 8) — notes and photos → a project-filed run whose output is
+    // proposals in the queue above; the launch is POST /runs itself (api/capture.ts).
+    registerCaptureRoutes(app);
+    // The Demo experience (studio#373): the demo preset's launch, view, files and script edit.
+    registerDemoRoutes(app, adapter);
+    // ── Presets (DES-TEAMING-002 §8.4, seam C2) — saved phase selections in the engine's store;
+    // a launch names one via `workflow`, and the ENGINE resolves it.
+    registerPresetRoutes(app, adapter, security);
+    // ── Team (DES-TEAMING-002 T8) — reads and commands over the engine; the live stream is the
+    // teamEvent relay (team/ws-relay.ts). Crew publishes no team fact (§4.0).
+    registerTeamRoutes(app, adapter, security);
     // ── Campaigns (crew#342 + TH-9) — the engine's durable Run-DAG scheduler over REST ──────────
     // Progress streams as campaign* CoreEvents on the existing allowlist-free /ws relay; these
     // routes are launch/resume/cancel + the reads a scoreboard builds from. The GET routes join
@@ -4097,6 +4837,7 @@ runtime = {}) {
         // Wave 6 (F-7R2-014): the registered test sets ride beside the campaigns + groups.
         testSets,
         deliveryUrlFor: (runId) => deliveryIndex.urlFor(runId),
+        deliveryPushedFor: (runId) => deliveryIndex.pushedFor(runId),
         vacuity: vacuityProbes,
         // A non-probe derivation throw in the rollup is a defect — error level, loud in diagnostics.
         logDefect: (m) => app.log.error(m),
@@ -4150,6 +4891,24 @@ runtime = {}) {
         audit,
         actorOf,
     });
+    // ── MCP tools registry (DES-MCP-TOOLS-001 S2) — upstream servers, their tools, their secrets ─
+    // Preview-bound saves, the tool diff on test, and a secret route that never answers the value.
+    // S6: the policy preview and the approvals, over the same registry and the engine's rule store.
+    const mcpPolicies = runtime.mcp !== undefined
+        ? new McpPolicies(runtime.mcp, {
+            listRules: () => adapter.listConformanceRules(),
+            upsertRule: (rule) => adapter.upsertConformanceRule(rule),
+            previewCalls: (json) => adapter.previewMcpCalls(json),
+        })
+        : undefined;
+    registerMcpRoutes(app, {
+        ...(runtime.mcp !== undefined ? { registry: runtime.mcp, toolLister: () => CoreAdapter.mcpToolLister() } : {}),
+        ...(runtime.mcpBroker !== undefined ? { broker: runtime.mcpBroker } : {}),
+        ...(mcpPolicies !== undefined ? { policies: mcpPolicies } : {}),
+        ...(runtime.mcpCalls !== undefined ? { usage: runtime.mcpCalls } : {}),
+        audit,
+        actorOf,
+    });
     // ── The wicked-interactive bridge, reverse-proxied (DES-MERGE-001 §5.3/§7.2) ──
     // Mounted BESIDE the routes above and under the same `${V}` prefix, so it inherits one
     // origin, one auth hook, and one CORS posture — the whole point of slice 1.
@@ -4200,5 +4959,6 @@ runtime = {}) {
         pool: interactiveBridges,
         log: (m) => app.log.warn(m),
     });
+    return { decideGate };
 }
 //# sourceMappingURL=routes.js.map