wicked-crew 0.16.4 → 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,6 +59,10 @@ 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';
@@ -94,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';
@@ -721,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
@@ -1235,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`
@@ -1268,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
@@ -2205,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
@@ -2314,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) {
@@ -2451,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),
@@ -2926,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.
@@ -2973,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) —
@@ -3044,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
@@ -3111,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) {
@@ -3154,6 +3287,7 @@ runtime = {}) {
                     seats,
                     scope,
                     refused,
+                    ...(workflow !== undefined ? { workflow: workflow.name } : {}),
                     ...(projectAttachError !== undefined ? { projectAttachError } : {}),
                     ...(singleSeat !== undefined ? { singleSeat } : {}),
                 });
@@ -3378,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 })));
                 }
@@ -3404,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';
@@ -3414,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
@@ -3456,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({
@@ -3467,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.
@@ -3485,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;
             });
@@ -3557,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({
@@ -4191,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' } } });
@@ -4275,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` /
@@ -4298,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.
@@ -7061,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
@@ -7124,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
@@ -7182,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;
@@ -7217,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 });
@@ -7275,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();
@@ -7296,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 };
@@ -7393,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,
             infra,
             clis,
+            gaps,
+            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,
-            gaps,
-            blockedByInfra: (key) => key === 'gateway' || key === 'broker' ? (containerFloor ? working : 0) : key === 'skills' || key === 'state_home' || key === 'disk' || key === 'load' ? working : 0,
+            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,
@@ -7501,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