wicked-crew 0.16.3 → 0.16.5

package/dist/api/routes.js

@@ -1,3 +1,4 @@
+import { REVIEW_WORKFLOW } from '../insights/workflow.js';
 import { busSeamsOffWarning, busUnavailableWarning } from '../core/bus-notice.js';
 import { vaultBinWarning, vaultDiagnostics } from '../core/vault-bin.js';
 import { PlanSchema, toLaunchPlan } from './plan-schema.js';
@@ -36,7 +37,8 @@ import { ROSTER_REFRESH_WAIT_MS, rosterWithStandingFactory } from './roster-stan
 import { SeatContainerStatus, gatewayDirOf, isContainerLoginCli, isContainerSeatFloor, isHostSeatFloor, loginDetail, runSeatLogin, seatLoginDepsFor, } from './seat-container-login.js';
 import { ChatTurnIndex } from './chat-turns.js';
 import { ChatScopeIndex, chatScopeDeps, chatScopeStatement, prepareChatScratch, removeChatScratch, namedKindRefusal, resolveChatScope, } from './chat-scope.js';
-import { ASK_TURN_BUDGET_SECS, AskPathIndex, answerStep, isAskTurn } from './ask-paths.js';
+import { ASK_TURN_BUDGET_SECS, AskPathIndex, isAskTurn } from './ask-paths.js';
+import { chatTurnStep, resolveChatWorkflow, servedChatWorkflows, writeCapableStep } from './chat-workflow.js';
 import { reassignRefusedSeats } from '../core/reassign-refusal.js';
 import { allowedRootsFor, isInsideRoot, openWithSystemDefault } from './open-path.js';
 import { InvalidDiffBaseError, MERGE_BASE_LITERAL, NotARegularFileError, UnresolvableDiffBaseError, branchDiff, isGitStopped, isPlainRef, readFileCapped, worktreeDiff, } from './run-files.js';
@@ -57,10 +59,15 @@ import { isSteeringAuthorRun, landSteeringProposal } from './steering-landing.js
 import { inventoryComplete, parseInventoryClaims } from '../core/inventory-claim.js';
 import { ApproveEditSchema, approveEdited, captureLaunchRoots, editInFlight, FileProposalSchema, registerCaptureRoutes } from './capture.js';
 import { registerTestingRoutes } from './testing.js';
+import { registerDefaultEvalRoutes, runAndRecord } from '../evals/routes.js';
+import { prepareRunEvalsLaunch, RUN_EVALS_WORKFLOW } from '../evals/workflow.js';
+import { defaultReplaySet } from '../evals/replay.js';
+import { gardenRootFor } from '../learn/scheduler.js';
 import { DEMO_PRESET, demoLaunchRoots, registerDemoDocumentRoute, registerDemoRoutes, registerWalkthroughRoutes, walkthroughAcceptance } from './recording.js';
 import { projectDocsRoot } from '../interactive/project-root.js';
 import { registerSkillsRoutes } from './skills.js';
 import { registerMcpRoutes } from './mcp.js';
+import { chatMcpToolsFor } from './chat-mcp.js';
 import { McpPolicies } from '../mcp/policies.js';
 import { disabledSkillsHealth } from '../skills/runtime.js';
 import { withPhaseSkillGaps } from '../skills/phase-skill-gaps.js';
@@ -70,7 +77,7 @@ import { REQUIRED_GARDEN_VERSION } from '../skills/plugin-source.js';
 import { engineRosterJson, noEligibleSeatBody, parseNoEligibleSeat, toEngineSeat } from '../core/engine-roster.js';
 import { launchAssuranceNotice } from '../core/assurance.js';
 import { launchRequiresQe, mayRequireQe, qeAcceptanceMode, qeSettingSkipReason } from '../core/qe-acceptance-setting.js';
-import { aggregateReceipt, postHocDeliveryAssurance, qeAcceptanceFromView, qeAcceptanceRefusal, QE_ACCEPTANCE_REQUIRED_CODE, receiptOf, qeAcceptanceNotRequired, qeDecisionBypasses, qeDecisionOf, unreadableQeAcceptance, } from './delivery-assurance.js';
+import { aggregateReceipt, postHocDeliveryAssurance, qeAcceptanceFromView, qeAcceptanceRefusal, QE_ACCEPTANCE_REQUIRED_CODE, receiptOf, qeAcceptanceNotRequired, qeDecisionBypasses, qeDecisionOf, qeAcceptanceSkippedAtGate, unreadableQeAcceptance, } from './delivery-assurance.js';
 import { ProjectSettingsStore } from '../projects/settings.js';
 import { isHumanOperator } from './watch-routes.js';
 import { boundOrigin, InteractiveBridgePool } from '../interactive/bridge-pool.js';
@@ -93,7 +100,8 @@ import { AcpFoldCache, EngineVersionCache, eventsDirOf, installedPackageVersion,
 import { GovernanceDiagnostics } from './governance-health.js';
 import { ATTACHMENT_LIMITS, ATTACHMENT_MAX_MESSAGE_BYTES, AttachmentError, ChatAttachmentStore, attachmentWire, attachmentsBlock, boundaryOf, parseMultipart, stageForSeat } from './chat-attachments.js';
 import { CHAT_HISTORY_MAX_LIMIT, ChatHistoryStore, decodeCursor } from './chat-history.js';
-import { PROBE_TIMEOUT_MS, SYSTEM_BUDGET_MS, SYSTEM_STATS_DAYS, WeekFoldCache, assembleSnapshot, buildAttention, buildClis, buildGovernance, diskRow, estateReadonlyCall, infraRow, judgeGaps, livenessThresholds, loadRow, probeBroker, probeBus, probeEstate, probeGateway, probeInteractive, probeVault, readBridgeLockAsync, readWeek, resolveContainerRuntime, runLiveness, settleWithin, skillsRow, sortRuns, stateHomeRow, unfinished, } from './system-snapshot.js';
+import { PROBE_TIMEOUT_MS, SYSTEM_BUDGET_MS, SYSTEM_STATS_DAYS, SYSTEM_STATS_TTL_MS, WeekFoldCache, assembleSnapshot, buildNeeds, buildClis, buildGovernance, diskRow, estateReadonlyCall, infraRow, judgeGaps, livenessThresholds, loadRow, probeBroker, probeBus, probeEstate, probeGateway, probeInteractive, probeVault, readBridgeLockAsync, readWeek, resolveContainerRuntime, runLiveness, settleWithin, skillsRow, sortRuns, stateHomeRow, unfinished, } from './system-snapshot.js';
+import { RunCostCache } from './needs.js';
 import { governanceStoreFix, legacyHomeOutboxPath } from '../core/governance-store.js';
 import { UsageError, replayOutboxInto } from '../cli/governance.js';
 import { foldDeadletters } from './governance-health.js';
@@ -119,6 +127,7 @@ import { registerDecisionRoutes } from '../decisions/routes.js';
 import { ChatDecisionRecorder } from '../decisions/chat-recorder.js';
 import { ConsiderationService } from '../decisions/consider.js';
 import { gardenConformance, gardenPackCheck } from '../editors/pack-install.js';
+import { conformanceProvisioner, conformanceRuntimeRoot } from '../editors/conformance-runtime.js';
 import { EditorRegistry } from '../editors/registry.js';
 import { registerEditorRoutes } from '../editors/routes.js';
 import { registerMcpInspectRoutes } from '../mcp-inspect/routes.js';
@@ -549,12 +558,21 @@ const isEscalationAction = (a) => a !== undefined && (ESCALATION_ACTIONS.include
  *  run and the delivery too) and refuses it (409, gate left open) at any other gate and while any
  *  other layer of the gate also denied. QE acceptance is never waived by it. */
 export const OPERATOR_JUDGMENT_ACTION = 'operator_judgment';
+/** (j4-gates, api-types 0.139.0) SKIP QE ACCEPTANCE at a gate — the launch's `skipQeAcceptance`,
+ *  given later: `approve: true`, the written reason in `amend` (required, non-empty), no
+ *  `amendScope` or `plan`. The engine (wicked-core `HumanDecision::SkipQe`) records the run's QE
+ *  decision as `skipped` by the operator ("QE acceptance skipped by operator: <reason>"), labelled on
+ *  the run, every later gate and the delivery, and answers: the gate before the deliver step (this
+ *  route lets the delivery go without a QE PASS, saying so), the escalation gate of a unit only QE
+ *  denied (it counts), or a failed floor's gate with QE behind it (it re-opens on the floor alone).
+ *  Refused (409, gate left open) everywhere else and on a run that does not require QE. */
+export const SKIP_QE_ACTION = 'skip_qe';
 export const GateSchema = z.object({
     approve: z.boolean(),
     amend: z.string().optional(),
     action: z
         .union([
-        z.enum(['approve', 'request_changes', 'reject', 'edit_plan', 'amend_intent', OPERATOR_JUDGMENT_ACTION, ...ESCALATION_ACTIONS]),
+        z.enum(['approve', 'request_changes', 'reject', 'edit_plan', 'amend_intent', OPERATOR_JUDGMENT_ACTION, SKIP_QE_ACTION, ...ESCALATION_ACTIONS]),
         z.string().regex(CONSENT_CHOICE_ACTION, 'a consent choice is `consent:<choice id>`'),
     ])
         .optional(),
@@ -565,10 +583,12 @@ export const GateSchema = z.object({
      *  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' || b.action === OPERATOR_JUDGMENT_ACTION || isEscalationAction(b.action)) === b.approve, { message: '`action` disagrees with `approve`: request_changes and reject require approve: false; approve, edit_plan, amend_intent, operator_judgment, extend, targeted, accept_partial, accept_suggestion, rejudge and consent:<id> require approve: true', path: ['action'] }).refine(
+    || (b.action === 'approve' || b.action === 'edit_plan' || b.action === 'amend_intent' || b.action === OPERATOR_JUDGMENT_ACTION || b.action === SKIP_QE_ACTION || isEscalationAction(b.action)) === b.approve, { message: '`action` disagrees with `approve`: request_changes and reject require approve: false; approve, edit_plan, amend_intent, operator_judgment, skip_qe, extend, targeted, accept_partial, accept_suggestion, rejudge and consent:<id> require approve: true', path: ['action'] }).refine(
 // (operator ruling 2026-10-21) The override's rationale IS its record: a blank one is a 400 here,
 // before the engine is asked.
 (b) => b.action !== OPERATOR_JUDGMENT_ACTION || (b.amend !== undefined && b.amend.trim() !== ''), { message: 'operator_judgment needs `amend`: your written rationale — why the failed floor is not the work\'s (an empty one is refused)', path: ['amend'] }).refine((b) => b.action !== OPERATOR_JUDGMENT_ACTION || (b.amendScope === undefined && b.plan === undefined), { message: 'operator_judgment takes no amendScope or plan — it answers the failed floor of the gated unit', path: ['amendScope'] }).refine(
+// (j4-gates) A QE skip's reason IS its record, as at launch: a blank one is a 400 here.
+(b) => b.action !== SKIP_QE_ACTION || (b.amend !== undefined && b.amend.trim() !== ''), { message: 'skip_qe needs `amend`: your written reason for skipping QE acceptance (an empty one is refused)', path: ['amend'] }).refine((b) => b.action !== SKIP_QE_ACTION || (b.amendScope === undefined && b.plan === undefined), { message: 'skip_qe takes no amendScope or plan — it answers the run\'s QE acceptance', path: ['amendScope'] }).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.
@@ -708,6 +728,9 @@ export const ChatOpenSchema = z.object({
     primary: z.string().min(1).optional(),
     /** (api-types 0.137.0, DES-SYSTEM-CHAT) The page the chat was started on, for the history list. */
     startedOn: z.object({ route: z.string().min(1).max(512), label: z.string().min(1).max(200) }).strict().optional(),
+    /** (api-types 0.141.0, crew#1157) The read-only workflow every turn runs (`analyze`); see
+     *  `chat-workflow.ts`. Omitted ⇒ a plain chat. */
+    workflow: z.string().min(1).max(64).optional(),
 }).strict();
 /**
  * The `singleSeat` disclosure (crew#641, hole closed in crew#650) — built in ONE place so the 201
@@ -787,6 +810,8 @@ function pushedOnlyRefusal(runId, pushed) {
         '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');
 }
+/** B8: the editor-conformance browser runtime crew provisions when a host has none (one per process). */
+const editorConformanceRuntime = conformanceProvisioner(() => conformanceRuntimeRoot());
 export function registerRoutes(app, adapter, gateCache, elicitationCache, 
 // Defaulted for the same reason: tests that drive this function directly get
 // the projects surface with no bus (events skipped) and a fresh index.
@@ -919,7 +944,7 @@ runtime = {}) {
         registry: editorRegistry,
         adapter,
         packCheck: runtime.packCheck ?? gardenPackCheck(discoverLivePlugin()?.path ?? null),
-        conformance: runtime.editorConformance ?? gardenConformance(discoverLivePlugin()?.path ?? null, () => process.env['WICKED_CREW_URL'] ?? null),
+        conformance: runtime.editorConformance ?? gardenConformance(discoverLivePlugin()?.path ?? null, () => process.env['WICKED_CREW_URL'] ?? null, { provision: editorConformanceRuntime }),
         log: (m) => app.log.warn(m),
     });
     const chatRecorder = decisions !== null && chatTranscripts !== undefined && runtime.broadcast !== undefined
@@ -1220,6 +1245,22 @@ runtime = {}) {
         // crew#1068: the engine has no wicked-vault CLI to record held boundary findings with.
         ...[adapter.vaultBin != null ? vaultBinWarning(adapter.vaultBin) : null].filter((w) => w !== null),
     ];
+    // crew#1157: the engine's built-in presets are compiled in, so the chat workflows it carries are
+    // read once (on the first probe that can read them) and held until restart.
+    let chatWorkflowsHeld = null;
+    const chatWorkflowsNow = async () => {
+        if (chatWorkflowsHeld !== null)
+            return chatWorkflowsHeld;
+        if (typeof adapter.listPresets !== 'function')
+            return [];
+        try {
+            chatWorkflowsHeld = servedChatWorkflows(await adapter.listPresets());
+            return chatWorkflowsHeld;
+        }
+        catch {
+            return [];
+        }
+    };
     app.get(`${V}/health`, { config: { manifest: { statusCodes: [200] } } }, async () => {
         const ping = await enginePing();
         // F-E2E-030: what this deployment can keep. A composer reads `capabilities.deliverGate`
@@ -1253,9 +1294,14 @@ runtime = {}) {
             launchPrimary: true,
             // api-types 0.136.0 (DES-SYSTEM-VIEW): `GET /system`, the Nerve Center snapshot, is served.
             system: true,
+            // api-types 0.140.0: attention[] is the one needs-you list; unresolved[] + toReview; POST /runs/:id/resolve.
+            attentionRanked: true,
             // api-types 0.137.0 (DES-SYSTEM-CHAT): the chat history (list, reopen, close) and attachments.
             chatList: chatHistory !== null,
             chatAttachments: true,
+            // api-types 0.141.0 (crew#1157): the read-only workflows `POST /chats {workflow}` runs on THIS
+            // engine (`analyze` on a core-ts that carries it); `[]` = plain chats only.
+            chatWorkflows: await chatWorkflowsNow(),
         };
         // wicked-core#411 / crew#497: the state-home blocker rides the health probe as a WARNING. The
         // daemon still SERVES (status stays ok — studio must load and show the blocker) but refuses to
@@ -2190,6 +2236,29 @@ runtime = {}) {
                 req.log.warn(`linked-issue resolution failed; launching on the intent alone: ${message(err)}`);
             }
         }
+        // DES-RUNS-REVIEW-001 §3: a hand launch of the run review (`/workflow-review-recent-work`) is prepared like a
+        // scheduled one: its snapshot written, repo-less, one seat, its review directory as the only write root.
+        // DES-DEFAULT-EVALS-001 §7: a launch of `run-evals` (`/workflow-run-evals`) is prepared by the daemon, which runs
+        // the evals in-process and writes the report copy its Tool step reads; it delivers nothing.
+        if (b.workflow === RUN_EVALS_WORKFLOW) {
+            try {
+                await runEvalsPrepare(input);
+            }
+            catch (err) {
+                return reply.code(409).send({ error: `the default evals could not be prepared: ${message(err)}` });
+            }
+            deliver = 'none';
+        }
+        const isReview = b.workflow === REVIEW_WORKFLOW && runtime.reviewLaunch !== undefined;
+        if (isReview) {
+            try {
+                await runtime.reviewLaunch(input);
+            }
+            catch (err) {
+                return reply.code(409).send({ error: `the review could not be prepared: ${message(err)}` });
+            }
+            deliver = 'none';
+        }
         try {
             const runId = await adapter.launchRun(input);
             // crew#641/#642 (item 5): when a run is promoted from a chat, record how many seats
@@ -2299,6 +2368,8 @@ runtime = {}) {
         }
         catch (err) {
             const msg = message(err);
+            if (isReview)
+                runtime.reviewLaunchRefused?.(input.sessionId, msg);
             // 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) {
@@ -2436,6 +2507,60 @@ runtime = {}) {
             return reply.code(500).send({ error: msg });
         }
     });
+    // ── Resolve an unresolved run (api-types 0.140.0) ─────────────────────────────
+    // Unresolved work (`GET /system.unresolved[]`) is resolved, never hidden: archived WITH a reason,
+    // or closed as superseded naming the run that replaced it (retry is `POST /runs {retryOf}`). A run
+    // parked at a gate is stopped first (no worker is running), then archived; a run that is
+    // executing is refused, so a resolve never ends live work. The note keeps the reason.
+    const ResolveSchema = z.discriminatedUnion('action', [
+        z.object({ action: z.literal('archive'), reason: z.string().trim().min(1, 'a reason is required to archive').max(480) }).strict(),
+        z.object({ action: z.literal('superseded'), by: z.string().min(1), reason: z.string().trim().max(400).optional() }).strict(),
+    ]);
+    app.post(`${V}/runs/:id/resolve`, { config: { manifest: { requestType: 'ResolveRunRequest', responseType: 'ResolveRunResponse', statusCodes: [200, 400, 404, 409, 500] } } }, async (req, reply) => {
+        const { id } = req.params;
+        const parsed = ResolveSchema.safeParse(req.body ?? {});
+        if (!parsed.success)
+            return reply.code(400).send(invalidBody(parsed.error, 'Invalid request body'));
+        const b = parsed.data;
+        const note = b.action === 'archive' ? `resolved: ${b.reason}` : `superseded by ${b.by}${b.reason !== undefined && b.reason !== '' ? `: ${b.reason}` : ''}`;
+        // Inside the run's decision lock (the gate path's): the status read, the stop and the archive
+        // are one step, so a gate answered at the same moment can never be stopped by a resolve. The
+        // status is read again inside the lock, right before the stop.
+        const outcome = await decideExclusively(id, async () => {
+            const views = await adapter.sessionsDetail();
+            const run = views.find((v) => v.session.id === id);
+            if (run === undefined)
+                return { code: 404, body: { error: 'Run not found' } };
+            if (b.action === 'superseded') {
+                if (b.by === id)
+                    return { code: 400, body: { error: '`by` must name another run' } };
+                if (!views.some((v) => v.session.id === b.by))
+                    return { code: 400, body: { error: `\`by\` names an unknown run: ${b.by}` } };
+            }
+            const status = run.session.status;
+            if (status !== 'awaiting_human' && status !== 'failed' && status !== 'completed' && status !== 'cancelled') {
+                return { code: 409, body: { error: `run ${id} is ${status}: a running job cannot be resolved; stop it first` } };
+            }
+            let cancelled = false;
+            try {
+                if (status === 'awaiting_human') {
+                    await adapter.cancelRun(id);
+                    cancelled = true;
+                }
+                const found = await adapter.archiveRun(id, true, note);
+                if (!found)
+                    return { code: 404, body: { error: 'Run not found' } };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { code: /only a terminal run/i.test(msg) ? 409 : 500, body: { error: msg } };
+            }
+            audit.record('run.resolved', actorOf(req), { runId: id, detail: { action: b.action, note, cancelled, ...(b.action === 'superseded' ? { by: b.by } : {}) } });
+            const out = { runId: id, action: b.action, archived: true, cancelled, note };
+            return { code: 200, body: out };
+        });
+        return reply.code(outcome.code).send(outcome.body);
+    });
     // Bulk write-off for campaign backlogs — explicit ids only, never implicit age selection.
     const BulkArchiveSchema = z.object({
         ids: z.array(z.string().min(1)).min(1).max(200),
@@ -2911,6 +3036,23 @@ runtime = {}) {
                 return reply.code(501).send({ error: message(err) });
             }
         }
+        // crew#1157: a chat that runs a workflow runs a BUILT-IN read-only one, resolved before anything
+        // is reserved or warmed (a 400 for a name chats do not run, a 409 for an engine without it).
+        let workflow;
+        if (b.workflow !== undefined) {
+            let presets = [];
+            try {
+                presets = typeof adapter.listPresets === 'function' ? await adapter.listPresets() : [];
+            }
+            catch {
+                presets = [];
+            }
+            const resolved = resolveChatWorkflow(b.workflow, presets);
+            if (!resolved.ok)
+                return reply.code(resolved.status).send({ error: resolved.error });
+            workflow = resolved.workflow;
+        }
+        const statementOpts = { analysis: workflow !== undefined };
         // A chat id this daemon already holds a scope for is LIVE: re-preparing its scratch root and
         // re-opening it would overwrite the statement its seats are reading and (on a changed scope)
         // evict them mid-conversation (Copilot, #518). Close it first, or let the daemon mint the id.
@@ -2958,7 +3100,7 @@ runtime = {}) {
                 if (!chatScopes.owns(chatId, token)) {
                     return reply.code(409).send({ error: `chat ${chatId} was closed while it was being opened; open it again` });
                 }
-                prepareChatScratch(chatId, scope, inForceAtOpen);
+                prepareChatScratch(chatId, scope, inForceAtOpen, statementOpts);
             }
             catch (err) {
                 // The helper removes only what it created itself (a pre-existing root is preserved) —
@@ -3029,6 +3171,12 @@ runtime = {}) {
                     refused,
                 });
             }
+            // crew#1157: a workflow chat is ONE seat — the operator's pick (`primary`), else the first
+            // admitted seat in roster order. The others are not refused; they simply do not sit this chat.
+            if (workflow !== undefined) {
+                const one = b.primary !== undefined && clis.includes(b.primary) ? b.primary : clis[0];
+                clis.splice(0, clis.length, one);
+            }
             try {
                 // DES-ASK-TEAM-CHAT-001 §5.1 (ASK-C1): an open resolves the scope and ELIGIBILITY and warms
                 // nothing — the chat is a path its first message launches, and the engine picks the PA
@@ -3096,7 +3244,7 @@ runtime = {}) {
                 askPaths.open(chatId, clis, b.primary, {
                     seats: standing.filter((s) => clis.includes(String(s.key))),
                     scopeKind: !scoped ? 'unscoped' : admissionKind === 'path-bound' ? 'scoped_bound' : 'scoped',
-                });
+                }, workflow);
                 // Register roots for path rewriting (crew#618): absolute host paths in seat replies are
                 // rewritten to repo-relative form before being stored in the transcript.
                 if (chatTranscripts !== undefined && scope.repos.length > 0) {
@@ -3139,6 +3287,7 @@ runtime = {}) {
                     seats,
                     scope,
                     refused,
+                    ...(workflow !== undefined ? { workflow: workflow.name } : {}),
                     ...(projectAttachError !== undefined ? { projectAttachError } : {}),
                     ...(singleSeat !== undefined ? { singleSeat } : {}),
                 });
@@ -3277,9 +3426,16 @@ runtime = {}) {
         };
         // DC-S7: the rules the chat's seats were told about ride the step's instructions, as the
         // preface rode a pool send; told only once the send is accepted (`commit`).
-        const withPreface = (preface) => (preface !== null ? `${preface}\n\n${seatText}` : seatText);
+        // crew#1155: the installed MCP tools and the one command that reaches them (the broker), read
+        // per turn so a server installed or disabled since the last turn is reflected.
+        let mcpTools = null;
+        const withPreface = (preface) => {
+            const body = mcpTools !== null ? `${mcpTools}\n\n${seatText}` : seatText;
+            return preface !== null ? `${preface}\n\n${body}` : body;
+        };
         try {
             const rules = (await considerations.inForceFor(scope?.projectId ?? null)).rules;
+            mcpTools = await chatMcpToolsFor(runtime.mcp);
             // crew#1020: a project/everything chat must see repos attached since open. Admission was
             // under this scope KIND and the kind stays the same, so do not re-run seat admission.
             const scopeRequest = chatScopes.requestOf(id);
@@ -3356,7 +3512,7 @@ runtime = {}) {
             }
             if (storedScope !== undefined && scope !== undefined && engine !== undefined &&
                 (JSON.stringify(scope) !== JSON.stringify(storedScope) || JSON.stringify(engine) !== JSON.stringify(chatScopes.engineOf(id)))) {
-                prepareChatScratch(id, scope, rules);
+                prepareChatScratch(id, scope, rules, { analysis: path.workflow !== undefined });
                 if (chatScopes.refresh(id, storedScope, scope, engine)) {
                     chatTranscripts?.registerRoots(id, scope.repos.map((r) => ({ absRoot: resolve(r.rootPath), name: r.name })));
                 }
@@ -3382,8 +3538,11 @@ runtime = {}) {
             audience = voice.length > 0 ? voice : path.eligible;
             turn = chatTurns.begin(id, audience, text, ASK_TURN_BUDGET_SECS);
             turnId = turn?.turnId ?? turnId;
-            // A repo-bound path can deliver; project and multi-repo scopes remain read-only asks.
+            // A repo-bound path can deliver; project and multi-repo scopes remain read-only asks. A workflow
+            // chat (crew#1157) never delivers: it is bound to its repository read-only, with no deliver.
             const repoRef = scope?.kind === 'repos' && scope.repos.length === 1 ? scope.repos[0].id : undefined;
+            const delivers = repoRef !== undefined && path.workflow === undefined;
+            const statementOpts = { analysis: path.workflow !== undefined };
             const projectId = scope?.projectId;
             if (path.runId === undefined) {
                 const stepId = 'answer-1';
@@ -3392,14 +3551,18 @@ runtime = {}) {
                 // crew#823: the run is titled by the operator's question (every reader titles a run from
                 // `problem`); the scope statement grounds the seats from the first answer step's
                 // instructions instead of standing in as the run's title.
-                const instructions = scope !== undefined ? `${chatScopeStatement(id, scope, rules)}\n\n${withPreface(pending.preface)}` : withPreface(pending.preface);
+                const instructions = scope !== undefined ? `${chatScopeStatement(id, scope, rules, statementOpts)}\n\n${withPreface(pending.preface)}` : withPreface(pending.preface);
                 const input = {
                     problem: text,
                     sessionId: randomUUID(),
                     clisJson: JSON.stringify(roster),
-                    plan: { steps: [answerStep(stepId, instructions)], monitors: { asked: 1 } },
+                    // A workflow chat is one seat and asks for no reviewer (crew#1157).
+                    plan: {
+                        steps: [chatTurnStep(stepId, instructions, path.workflow)],
+                        ...(path.workflow === undefined ? { monitors: { asked: 1 } } : {}),
+                    },
                     ...(path.primary !== undefined ? { primary: path.primary } : {}),
-                    ...(repoRef !== undefined ? { repoRef, deliver: 'pr' } : {}),
+                    ...(repoRef !== undefined ? (delivers ? { repoRef, deliver: 'pr' } : { repoRef }) : {}),
                     ...(projectId !== undefined ? { projectId } : {}),
                     ...(scope?.kind === 'project' && codeGraphDb !== null ? { projectGraph: { dbPath: codeGraphDb } } : {}),
                     // crew#1034: the scope's repositories are the run's read roots, graph or no graph — the
@@ -3434,7 +3597,8 @@ runtime = {}) {
                         askPath: true,
                         ...(repoRef !== undefined ? { repoRef } : {}),
                         ...(projectId !== undefined ? { projectId } : {}),
-                        deliver: repoRef !== undefined ? 'pr' : 'none',
+                        ...(path.workflow !== undefined ? { chatWorkflow: path.workflow.name } : {}),
+                        deliver: delivers ? 'pr' : 'none',
                     });
                 });
                 return reply.code(202).send({
@@ -3445,7 +3609,7 @@ runtime = {}) {
             // crew#1033: EVERY answer step carries the scope statement, as the first one does. A seat on a
             // single-shot carrier (codex on the wrapped carrier) remembers nothing of the first turn, so a
             // follow-up told only the question answered "the supplied repository contains only tmp".
-            const instructions = scope !== undefined ? `${chatScopeStatement(id, scope, rules)}\n\n${withPreface(pending.preface)}` : withPreface(pending.preface);
+            const instructions = scope !== undefined ? `${chatScopeStatement(id, scope, rules, statementOpts)}\n\n${withPreface(pending.preface)}` : withPreface(pending.preface);
             // The continuation answers the path run's gate: under the per-run decision lock it re-reads the
             // run and is judged by the record before it proposes or confirms anything (crew#1083 round 7).
             // The status read above is a pre-check that changes nothing; this read is the one that counts.
@@ -3463,7 +3627,7 @@ runtime = {}) {
                 const decided = await gateForDecision(view, undefined);
                 if ('refusal' in decided)
                     return decided.refusal;
-                await adapter.proposePlan(pathRunId, { steps: [answerStep(stepId, instructions)] }, turnId);
+                await adapter.proposePlan(pathRunId, { steps: [chatTurnStep(stepId, instructions, path.workflow)] }, turnId);
                 await adapter.confirmGate(pathRunId, true);
                 return null;
             });
@@ -3535,6 +3699,15 @@ runtime = {}) {
                 runId: launched.runId,
             });
         }
+        // crew#1157 (xreview on #1160): an analysis chat seats ONE helper; a re-seat may re-warm that
+        // seat, never add another.
+        if (launched?.workflow !== undefined && !(clis.length === 1 && launched.eligible.includes(clis[0]))) {
+            return reply.code(409).send({
+                code: 'analysis_one_seat',
+                error: `chat '${id}' is an analysis (${launched.workflow}) and seats one helper (${launched.eligible.join(', ')}); open a new chat to ask another`,
+                chatId: id,
+            });
+        }
         if (launched?.busy === true) {
             // The first message is launching with the roster as it stands (codex on #808 r3, 4).
             return reply.code(409).send({
@@ -4169,7 +4342,19 @@ runtime = {}) {
      *   A decision without one keeps the pre-table resolution (the cache, then the log, then the
      *   cursor unit) — an engine, or a run, older than the table.
      */
-    async function gateForDecision(run, namedOrd) {
+    async function gateForDecision(run, namedOrd, opts = {}) {
+        const decided = await gateOfRecord(run, namedOrd);
+        // crew#1157: every APPROVING path (the gate route, standing orders, a gated resume or reassign, a
+        // plan edit at the gate, the next message of a chat) is judged here, so no path approves a held
+        // plan change on an analysis run. Declining stays open.
+        if (!('refusal' in decided) && opts.declining !== true) {
+            const analysis = analysisPlanRefusal(run.session.id, { gateKind: decided.gateKind });
+            if (analysis !== null)
+                return { refusal: analysis };
+        }
+        return decided;
+    }
+    async function gateOfRecord(run, namedOrd) {
         const id = run.session.id;
         const unitAt = (ord) => (run.units ?? []).find((u) => u.ord === ord);
         const unknown = (why) => ({ refusal: { code: 409, body: { error: `Gate unknown: ${why} — refresh and decide again.`, code: 'gate_unknown' } } });
@@ -4204,9 +4389,18 @@ runtime = {}) {
      * freeze (idea 15), and wicked-core#850 EX-03 — a run whose contract requires QE acceptance
      * delivers only on an attributed PASS. A refusal leaves the gate open.
      */
-    async function deliverApprovalRefusal(run, deliverUnit) {
+    async function deliverApprovalRefusal(run, deliverUnit, 
+    /** (j4-gates) The operator's QE skip this approve carries (`action: 'skip_qe'`, its reason). */
+    skipQeReason) {
         if (deliveryFreeze.state().frozen)
             return { refusal: { code: 409, body: frozenRefusal(deliveryFreeze.state()) } };
+        // (j4-gates) An explicit operator skip at THIS gate, on a run whose QE acceptance is still
+        // required: the delivery goes without a ledger PASS, and its check says so in the skip's own
+        // words — the engine records the same decision with the confirm (or refuses it, 409, gate open).
+        const decision = qeDecisionOf(run);
+        if (skipQeReason !== undefined && decision !== null && !qeDecisionBypasses(decision)) {
+            return { qeAcceptance: qeAcceptanceSkippedAtGate(skipQeReason) };
+        }
         const qeAcceptance = await qeAcceptanceCheckFor(run);
         if (qeAcceptance !== null && !qeAcceptance.satisfied) {
             return { refusal: { code: 409, body: qeAcceptanceRefusal(run.session.id, qeAcceptance, receiptOf(deliverUnit), 'gate') } };
@@ -4244,6 +4438,30 @@ runtime = {}) {
         });
         return result;
     }
+    /**
+     * crew#1157 (xreview on #1160): an ANALYSIS chat's run never takes on work. Its seat is told not to
+     * propose any, but a `PLAN+` line in an answer would still hold a creator addition at a
+     * `plan_approval` gate; approving it (or approving with an edited plan) would let the run write.
+     * Refused here, for every decision path, by the durable launch record: declining stays allowed.
+     */
+    function analysisPlanRefusal(runId, held) {
+        const workflow = runTimingIndex.chatWorkflowOf(runId);
+        if (workflow === undefined)
+            return null;
+        // A held plan change (the gate the engine opens on a `PLAN+` line), or a plan edit with any step
+        // that could write (the same read-only predicate the chat open applies to the workflow).
+        const writes = held.plan?.steps.some((s) => writeCapableStep(s) !== null) === true;
+        if (held.gateKind !== 'plan_approval' && !writes)
+            return null;
+        return {
+            code: 409,
+            body: {
+                code: 'analysis_read_only',
+                error: `run ${runId} is an analysis (${workflow}): it answers questions and changes nothing, so it cannot take on ` +
+                    'the work its answer proposed. Decline it here, and start a job for the change.',
+            },
+        };
+    }
     /**
      * 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` /
@@ -4267,9 +4485,12 @@ runtime = {}) {
             // Decision integrity (api-types 0.44.0; crew#1083 rounds 3–5): the gate this decision answers
             // is the RECORD's — read first thing inside the lock, so the gated unit and its delivery
             // checks below are the ones the record confirms ({@link gateForDecision}).
-            const decided = await gateForDecision(run, parsed.data.ord);
+            const decided = await gateForDecision(run, parsed.data.ord, { declining: !parsed.data.approve });
             if ('refusal' in decided)
                 return decided.refusal;
+            const analysis = parsed.data.approve ? analysisPlanRefusal(id, { plan: parsed.data.plan }) : null;
+            if (analysis !== null)
+                return analysis;
             // The gated unit and its receipt as it stands when the person decides (wicked-core#850: every
             // gate answer carries it). An APPROVE that would run the deliver unit passes the delivery
             // checks first.
@@ -4277,7 +4498,7 @@ runtime = {}) {
             const assurance = receiptOf(gated);
             let deliveryCheck;
             if (parsed.data.approve && gated !== undefined && isDeliverUnit(gated)) {
-                const refused = await deliverApprovalRefusal(run, gated);
+                const refused = await deliverApprovalRefusal(run, gated, parsed.data.action === SKIP_QE_ACTION ? parsed.data.amend : undefined);
                 if ('refusal' in refused)
                     return refused.refusal;
                 deliveryCheck = { qeAcceptance: refused.qeAcceptance };
@@ -4520,7 +4741,7 @@ runtime = {}) {
     async function approveAcceptsWork(run, ord, gateKind) {
         const unit = run.units.find((u) => u.ord === ord);
         const denial = unit?.denial;
-        if (unit?.status === 'rejected' && (denial?.source === 'judge_unavailable' || denial?.source === 'qe_reviewer_unavailable')) {
+        if (unit?.status === 'rejected' && (denial?.source === 'judge_unavailable' || denial?.source === 'qe_reviewer_unavailable' || denial?.source === 'qe_inconclusive')) {
             return 'is the operator\'s judgment of the work as it stands (no judge could rule)';
         }
         if (gateKind === 'review_adjudication') {
@@ -7030,7 +7251,12 @@ runtime = {}) {
     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, { exclusive: decideExclusively, judge: gateForDecision });
+    registerTeamRoutes(app, adapter, security, {
+        exclusive: decideExclusively,
+        judge: gateForDecision,
+        // crew#1157: a plan edit on an analysis run may not add a step that could write.
+        readOnlyRefusal: (runId, plan) => analysisPlanRefusal(runId, { plan }),
+    });
     // ── 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
@@ -7093,6 +7319,19 @@ runtime = {}) {
         // directly-driven route set records nothing unless it injects one (no `~/.wicked-crew` writes).
         ...(runtime.evalStore !== undefined ? { evalStore: runtime.evalStore } : {}),
     });
+    // ── Default evals (DES-DEFAULT-EVALS-001) — the system's own judgments, scored against what happened ─────
+    // Read-only over the run store (sessions, events, the operator's decisions, QE ledgers, the latest steering
+    // eval); the only write is the report, under the eval store's root.
+    const defaultEvalDeps = {
+        ...(runtime.defaultEvalStore !== undefined ? { store: runtime.defaultEvalStore } : {}),
+        // Served runs, as GET /runs serves them: the derived title and the project membership join (codex r1).
+        runs: async () => (await adapter.sessionsDetail()).map(decorateRun),
+        events: async (id) => (typeof adapter.runEvents === 'function' ? (await adapter.runEvents(id)) : null),
+        decisions: () => (runtime.decisionLedger?.list({}) ?? []),
+        ...(runtime.evalStore !== undefined ? { steeringEvals: runtime.evalStore } : {}),
+        replay: defaultReplaySet({ gardenRoot: gardenRootFor(process.env) }),
+    };
+    registerDefaultEvalRoutes(app, defaultEvalDeps);
     // ── Skills (skills keystone) — the file manager over the daemon-owned garden plugin root ─────
     // Manifest + typed reads, guarded CAS writes, refresh/publish/analyze. `createServer` injects the
     // runtime it booted (store seeded from the installed plugin, snapshot published); a
@@ -7151,6 +7390,8 @@ runtime = {}) {
     // store is kept for SYSTEM_STATS_TTL_MS, with its `asOf`. The whole answer is held to
     // SYSTEM_BUDGET_MS: a part that does not settle in time reads `unknown` (or `null`) with why.
     const weekFoldCache = new WeekFoldCache();
+    const runCosts = new RunCostCache();
+    let toReviewCache = null;
     /** One stat of a run's durable event log: read before the 7-day fold, so the fold can never eat
      *  the time a liveness verdict needs. */
     const EVIDENCE_TIMEOUT_MS = 1_000;
@@ -7186,6 +7427,17 @@ runtime = {}) {
             const rules = await adapter.listConformanceRules();
             return rules.filter((r) => r.retired !== true).length;
         }, PROBE_TIMEOUT_MS);
+        // Pending proposals: "N to review", never in the needs-you number (no run waits on them).
+        // Kept for SYSTEM_STATS_TTL_MS: a skin polls /system, and each read would spawn the estate client.
+        const toReviewP = settleWithin(async () => {
+            if (toReviewCache !== null && Date.now() - toReviewCache.at < SYSTEM_STATS_TTL_MS)
+                return toReviewCache.value;
+            const got = (await estateTool('proposal.list', { state: 'pending' }));
+            const value = Array.isArray(got?.proposals) ? got.proposals.length : null;
+            if (value !== null)
+                toReviewCache = { at: Date.now(), value }; // a failed read is never kept
+            return value;
+        }, PROBE_TIMEOUT_MS);
         const gatesByYouP = settleWithin(async () => {
             const since = Date.now() - SYSTEM_STATS_DAYS * 86_400_000;
             const entries = await audit.readAll({ action: 'gate.decided', since });
@@ -7244,7 +7496,14 @@ runtime = {}) {
         if (openGates.kind === 'ok' && openGates.value !== null) {
             const at = (r) => new Date(r.created_at).getTime() || 0;
             for (const r of [...openGates.value].sort((a, b) => at(a) - at(b))) {
-                openByRun.set(r.session_id, { interactionId: r.id, ord: r.ord, kind: r.gate_kind ?? (r.kind === 'elicitation' ? 'question' : null), prompt: r.prompt.slice(0, 280) });
+                const arrived = at(r);
+                openByRun.set(r.session_id, {
+                    interactionId: r.id,
+                    ord: r.ord,
+                    kind: r.gate_kind ?? (r.kind === 'elicitation' ? 'question' : null),
+                    prompt: r.prompt.slice(0, 280),
+                    receivedAt: arrived > 0 ? new Date(arrived).toISOString() : (gateCache.get(r.session_id)?.receivedAt ?? null),
+                });
             }
         }
         const now = Date.now();
@@ -7265,7 +7524,7 @@ runtime = {}) {
             const cached = gateCache.get(view.session.id);
             const gate = openByRun.get(view.session.id) ??
                 (view.session.status === 'awaiting_human' && cached !== undefined
-                    ? { interactionId: null, ord: cached.ord, kind: cached.gateKind ?? null, prompt: cached.prompt.slice(0, 280) }
+                    ? { interactionId: null, ord: cached.ord, kind: cached.gateKind ?? null, prompt: cached.prompt.slice(0, 280), receivedAt: cached.receivedAt }
                     : null);
             const run = runLiveness({ view, now, evidence: await evidenceOf(view.session.id), gate: view.session.status === 'awaiting_human' ? gate : null, quietAfterMs, stallAfterMs });
             return { view, run };
@@ -7362,16 +7621,50 @@ runtime = {}) {
             steeringRules: rules.kind === 'ok' ? rules.value : null,
             ...(rules.kind === 'ok' && rules.value === null ? { steeringNote: 'this engine cannot list steering rules' } : rules.kind === 'timeout' ? { steeringNote: `the rule store did not answer within ${PROBE_TIMEOUT_MS / 1000} s` } : rules.kind === 'error' ? { steeringNote: `the rule store could not be read: ${rules.error}` } : {}),
         });
-        const working = runs.filter((r) => r.liveness !== 'waiting_on_you' && r.liveness !== 'held').length;
-        const attention = buildAttention({
+        // The one "needs you" rule (needs.ts): root causes ranked by impact, plus the unresolved work
+        // and what it cost. Per-run cost is read from the run's own log, cached, never waited on past
+        // the budget (an unread run's cost reads unknown and the next read has it).
+        const first = buildNeeds({
+            now,
+            views: allViews,
+            runs,
             infra,
             clis,
+            gaps,
+            infraHoldsLive: (key) => (key === 'gateway' || key === 'broker' ? containerFloor : key === 'skills' || key === 'state_home' || key === 'disk' || key === 'daemon'),
+            costOf: (id) => runCosts.get(id),
+        });
+        if (typeof adapter.runEvents === 'function' && first.unresolved.length > 0) {
+            const byId = new Map(allViews.map((v) => [v.session.id, v]));
+            await settleWithin(() => runCosts.fill(first.unresolved.map((u) => {
+                const s = byId.get(u.runId)?.session;
+                return { id: u.runId, final: ['failed', 'completed', 'cancelled'].includes(s?.status ?? ''), stamp: `${s?.status ?? ''}:${s?.ended_at ?? ''}` };
+            }), (id) => adapter.runEvents(id)), Math.min(left(), 2_000));
+        }
+        const needs = buildNeeds({
+            now,
+            views: allViews,
             runs,
-            governance,
+            infra,
+            clis,
             gaps,
-            blockedByInfra: (key) => key === 'gateway' || key === 'broker' ? (containerFloor ? working : 0) : key === 'skills' || key === 'state_home' || key === 'disk' || key === 'load' ? working : 0,
+            infraHoldsLive: (key) => (key === 'gateway' || key === 'broker' ? containerFloor : key === 'skills' || key === 'state_home' || key === 'disk' || key === 'daemon'),
+            costOf: (id) => runCosts.get(id),
+        });
+        const toReview = await toReviewP;
+        // A run list that could not be read never reads green: the daemon row (degraded, "did not list
+        // its runs") is in attention as a slowdown, and the level stays at least yellow.
+        return assembleSnapshot({
+            startedAt,
+            clis,
+            runs,
+            infra,
+            governance,
+            attention: needs.attention,
+            unresolved: needs.unresolved,
+            unresolvedSpend: needs.unresolvedSpend,
+            toReview: toReview.kind === 'ok' ? toReview.value : null,
         });
-        return assembleSnapshot({ startedAt, clis, runs, infra, governance, attention });
     });
     registerInteractiveProxy(app, adapter, {
         settings: projectSettings,
@@ -7470,6 +7763,9 @@ runtime = {}) {
         log: (m) => app.log.warn(m),
     });
     registerSearchRoutes(app, search);
-    return { decideGate, decisions, chatRecorder, considerations, search };
+    const runEvalsPrepare = async (input) => {
+        await prepareRunEvalsLaunch(input, () => runAndRecord(defaultEvalDeps, { project: null, baseline: false, id: randomUUID(), now: new Date() }), runtime.evalRunsDir);
+    };
+    return { decideGate, decisions, chatRecorder, considerations, search, decorateRun, runEvalsPrepare };
 }
 //# sourceMappingURL=routes.js.map