@claudexor/control-api 3.1.2 → 3.2.0

package/dist/daemon-server.js

@@ -1,5 +1,5 @@
 import { timingSafeEqual } from "node:crypto";
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync, } from "node:fs";
 import { createServer } from "node:http";
 import { basename, extname, join } from "node:path";
 import { deriveApplyEligibility, revertInPlaceFromAnchor, validateApplyGate, verifyAndDeliver, } from "@claudexor/delivery";
@@ -12,8 +12,8 @@ import { budgetValuationFromEvents, cashEstimatedFromLedgerEvent, normalizeLegac
 import { controlWebEvidence, eventPayload, evidenceLevel, latestPlanProgress, readRunEvents, readRunEventsWithIntegrity, timelineEvents, } from "./run-timeline.js";
 import { projectTurnRunCards } from "./thread-projection.js";
 import { projectSession, projectThread, projectTurn } from "./thread-projection.js";
-import { chainThreadMutation, handleThreadTurnCreate, handleThreadTurnRetry, } from "./thread-turn-routes.js";
-import { assertThreadIdle, threadIdOfRun } from "./thread-mutation.js";
+import { handleThreadTurnCreate, handleThreadTurnRetry, } from "./thread-turn-routes.js";
+import { chainIdleRunMutation, chainThreadMutation } from "./thread-mutation.js";
 import { handleThreadLifecycleRoutes, } from "./thread-lifecycle-routes.js";
 import * as runStart from "./run-start.js";
 import { cancelDelegationFamily } from "./delegation-control.js";
@@ -21,22 +21,30 @@ import { directDelegatedChildrenFromRecords, delegatedDescendantsFromRecords, pa
 import { handleRunRetryRoute } from "./run-retry-routes.js";
 import { handleRunApplyRoutes, runIdempotentDelivery, } from "./run-apply-routes.js";
 import { rerunWithFeedback } from "./decision-rerun.js";
+import { acceptRiskDecision } from "./decision-accept-risk.js";
 export { normalizeRunStartRequest } from "./run-start.js";
 import { candidatesFor } from "./candidates.js";
 import { handleProjectRoute } from "./project-routes.js";
+import { writeBinaryResponse } from "./binary-response.js";
+export { inlineContentDisposition } from "./binary-response.js";
 import { handleRecoveryRoute } from "./recovery-routes.js";
 import { handleJournalEventRoute } from "./journal-event-routes.js";
 import { handleMaintenanceRoute } from "./maintenance-routes.js";
 import { handleResourceRoute } from "./resource-routes.js";
 import { handleArtifactServeRoute, listArtifacts, resolveProjectRoot, } from "./artifact-serve-routes.js";
 import { requiredGateSpecsFromTaskArtifact } from "./task-contract-gates.js";
-import { assertOnlyQueryParams, optionalBooleanQuery, singleQuery } from "./query.js";
+import { bearerCredential } from "./authorization.js";
+import { assertOnlyQueryParams, singleQuery } from "./query.js";
+import { parseCredentialProfilesSnapshotQuery, parseHarnessListQuery, parseRunApplicabilityQuery, } from "./catalog-query.js";
 import { lruGet, lruSet, parseRunListQuery, selectRunListPage, } from "./run-list.js";
+import { summaryFingerprint } from "./run-list-fingerprint.js";
+export { resetRunListFingerprintProbeCountForTests, runListFingerprintProbeCountForTests, } from "./run-list-fingerprint.js";
 import { controlProblemError, normalizeRequestValidationError, revertRefusedProblem, thrownProblemCode, } from "./problem-response.js";
 import { handleSecurityRoute } from "./security-routes.js";
-import { PlanQuestionsArtifact, CouncilProjection, derivePlanReadiness, ControlAuthReadinessRefreshRequest, ControlAuthReadinessRefreshResponse, ControlProblem, AccessProfile, AgentCapabilityCatalog, ControlHarnessListResponse, ControlHarnessModelsResponse, ControlSetupJob, ControlSetupJobCreateRequest, ControlSetupJobEvent, ControlSetupJobSnapshot, isTerminalControlSetupJobState, ControlSetupJobListFilter, ControlSetupJobListResponse, ControlRunStartInfo, ControlRunControlRequest, ControlRunControlResponse, ControlReviewerPanelEntry, ControlRunDetail, ControlRunListResponse, ControlRunSummary, ControlRunResult, ControlBudgetSnapshot, PaidBudget, ControlSettingsSnapshot, ControlSettingsUpdateRequest, ControlQuotaResponse, ControlCredentialProfilesResponse, ControlCredentialProfileCreateRequest, ControlCredentialProfileCreateResponse, ControlCredentialProfileUpdateRequest, ControlCredentialProfileUpdateResponse, ControlCredentialProfileDeleteResponse, ControlInteractionAnswerRequest, ControlInteractionAnswerResponse, ControlRunDecisionRequest, ControlRunDecisionResponse, ControlThreadCreateRequest, ControlThreadTurnRequest, ControlThreadUpdateRequest, ControlThreadDetail, ControlThreadListResponse, DecisionRecord, Id, ModeKind, RoutingGoal, ReviewFinding, RunDeliveryState, RunFailure, RunTelemetry, StructuredOutputConformance, TaskContract, ProtectedPathApproval, isTerminalLifecycle, needsDecision, needsOperatorAttention, requiredActionsFor, outcomeBanner, outcomeFactsFromFailure, TestCommandInvocation, WorkProduct, } from "@claudexor/schema";
+import { effectiveTerminalFacts, expectedRunFacts, projectRunFactsForDetail, } from "./run-facts-projection.js";
+import { PlanQuestionsArtifact, CouncilProjection, derivePlanReadiness, ControlAuthReadinessRefreshRequest, ControlAuthReadinessRefreshResponse, ControlProblem, AccessProfile, AgentCapabilityCatalog, ControlHarnessListResponse, ControlHarnessModelsResponse, ControlSetupJob, ControlSetupJobCreateRequest, ControlSetupJobEvent, ControlSetupJobSnapshot, isTerminalControlSetupJobState, ControlSetupJobListFilter, ControlSetupJobListResponse, ControlRunStartInfo, ControlRunControlRequest, ControlRunControlResponse, ControlReviewerPanelEntry, ControlRunDetail, ControlRunListResponse, ControlRunSummary, ControlRunResult, ControlBudgetSnapshot, PaidBudget, ControlSettingsSnapshot, ControlSettingsUpdateRequest, ControlQuotaResponse, ControlCredentialProfileCreateRequest, ControlCredentialProfileCreateResponse, ControlCredentialProfileUpdateRequest, ControlCredentialProfileUpdateResponse, ControlCredentialProfileDeleteResponse, ControlInteractionAnswerRequest, ControlInteractionAnswerResponse, ControlRunDecisionRequest, ControlRunDecisionResponse, ControlRunApplicabilityResponse, ControlThreadCreateRequest, ControlThreadTurnRequest, ControlThreadUpdateRequest, ControlThreadDetail, ControlThreadListResponse, DecisionRecord, Id, ModeKind, RoutingGoal, ReviewFinding, RunDeliveryState, RunFailure, RunTelemetry, StructuredOutputConformance, TaskContract, ProtectedPathApproval, isTerminalLifecycle, needsDecision, needsOperatorAttention, outcomeBanner, outcomeFactsFromFailure, TestCommandInvocation, WorkProduct, } from "@claudexor/schema";
 import { resolveControlProtocol } from "./operation-catalog.js";
-import { assertNoInlineSecretValues, containsSecretLikeToken, errorCode, noProjectRepoRoot, nowIso, redactSecrets, sha256, } from "@claudexor/util";
+import { assertNoInlineSecretValues, containsSecretLikeToken, errorCode, noProjectRepoRoot, nowIso, redactSecrets, safeProblemContext, safeProblemRequiredActions, sha256, } from "@claudexor/util";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
 const NO_PROJECT_ROOT = noProjectRepoRoot();
@@ -63,6 +71,8 @@ function stringArrayProperty(error, key) {
     if (!error || typeof error !== "object" || !(key in error))
         return [];
     const value = error[key];
+    if (key === "requiredActions")
+        return safeProblemRequiredActions(value);
     return Array.isArray(value)
         ? value
             .filter((item) => typeof item === "string" && item.length > 0)
@@ -100,7 +110,7 @@ function problemBody(error, fallbackCode, fallbackRetryable, fallbackMessage) {
         requiredActions: stringArrayProperty(error, "requiredActions"),
         evidenceRefs: stringArrayProperty(error, "evidenceRefs"),
         context: error && typeof error === "object" && "context" in error
-            ? (error.context ?? {})
+            ? safeProblemContext(error.context)
             : {},
     });
 }
@@ -256,15 +266,12 @@ export class DaemonControlApiServer {
         if (!hostIsLoopback(req.headers.host) ||
             !originIsLoopback(req.headers.origin))
             return false;
-        const m = /^Bearer\s+(.+)$/i.exec(req.headers.authorization ?? "");
-        return this.tokenMatches(m?.[1]?.trim());
+        return this.tokenMatches(bearerCredential(req.headers.authorization));
     }
-    requestError(res, err) {
-        // QA-053: at the request boundary, project a raw ZodError into structured
-        // fieldErrors + a single-line human message (see normalizeRequestValidationError).
-        // Typed errors and non-Zod errors pass through unchanged.
-        const normalized = normalizeRequestValidationError(err);
-        this.problem(res, finiteHttpStatus(normalized, 400), normalized, "invalid_request", false, "bad request");
+    requestError(res, err, fallbackStatus = 400) {
+        // QA-053: normalize raw Zod issues only at the client-request boundary.
+        const normalized = fallbackStatus === 400 ? normalizeRequestValidationError(err) : err;
+        this.problem(res, finiteHttpStatus(normalized, fallbackStatus), normalized, fallbackStatus === 400 ? "invalid_request" : "internal_error", false, fallbackStatus === 400 ? "bad request" : "service failed");
     }
     json(res, status, body, contentType = "application/json") {
         if (status >= 400 && contentType === "application/json") {
@@ -379,21 +386,22 @@ export class DaemonControlApiServer {
             services: this.opts.services,
             readBody: (request) => this.readBody(request),
             json: (response, status, body) => this.json(response, status, body),
-            requestError: (response, error) => this.requestError(response, error),
+            requestError: (response, error, fallback) => this.requestError(response, error, fallback),
         }, method, path, req, res))
             return;
         if (await handleMaintenanceRoute({
             services: this.opts.services,
             readBody: (request) => this.readBody(request),
             json: (response, status, body) => this.json(response, status, body),
-            requestError: (response, error) => this.requestError(response, error),
+            requestError: (response, error, fallback) => this.requestError(response, error, fallback),
         }, method, path, req, res))
             return;
         if (await handleProjectRoute({
             services: this.opts.services,
             readBody: (request) => this.readBody(request),
             json: (response, status, body) => this.json(response, status, body),
-            requestError: (response, error) => this.requestError(response, error),
+            requestError: (response, error, fallback) => this.requestError(response, error, fallback),
+            binary: writeBinaryResponse,
         }, method, path, req, res))
             return;
         if (method === "POST" && path === "/runs") {
@@ -415,8 +423,9 @@ export class DaemonControlApiServer {
             services: this.opts.services,
             findRun: (id) => this.findRun(id),
             waitForRunStart: (id) => this.waitForRunStart(id),
+            serializeThreadMutation: (threadId, work) => chainThreadMutation(this.threadTurnChains, threadId, work),
             json: (response, status, body) => this.json(response, status, body),
-            requestError: (response, error) => this.requestError(response, error),
+            requestError: (response, error, fallbackStatus) => this.requestError(response, error, fallbackStatus),
         }, method, path, req, res))
             return;
         const runDetailMatch = /^\/runs\/([^/]+)$/.exec(path);
@@ -487,13 +496,7 @@ export class DaemonControlApiServer {
                 const idempotencyKey = runStart.requiredIdempotencyKey(req);
                 let repoRoot = null;
                 if (parsed.scope.kind === "project") {
-                    repoRoot = parsed.scope.root.trim();
-                    const absoluteRepoError = runStart.validateAbsoluteRepoRoot(repoRoot);
-                    if (absoluteRepoError)
-                        throw Object.assign(new Error(absoluteRepoError), { status: 400 });
-                    if (!existsSync(repoRoot) || !lstatSync(repoRoot).isDirectory()) {
-                        throw Object.assign(new Error(`project root does not exist or is not a directory: ${repoRoot}`), { status: 400 });
-                    }
+                    repoRoot = runStart.normalizeExistingProjectRoot(parsed.scope.root);
                 }
                 const thread = await svc({
                     title: parsed.title,
@@ -631,70 +634,17 @@ export class DaemonControlApiServer {
                 return this.requestError(res, err);
             }
             if (body.action === "accept_risk" || body.action === "override_needs_human") {
-                const decisionBody = body;
-                const decisionAction = body.action;
                 try {
-                    return await this.chainRunMutation(rec, async () => {
-                        // D-16: a work_state veto (the model attested needs_input / incomplete)
-                        // is NON-OVERRIDABLE — a risk acceptance cannot supply missing input,
-                        // and the delivery gate refuses the override on that axis. Reject
-                        // accept_risk with a TYPED problem here instead of recording a false
-                        // "Apply is now available" ACK that the gate would then refuse.
-                        const workVeto = this.runWorkStateVeto(rec);
-                        if (workVeto) {
-                            return this.json(res, 409, {
-                                error: workVeto === "needs_input"
-                                    ? "run reported it needs more input; a risk override cannot supply the missing input — re-run with the input (rerun_with_feedback)"
-                                    : "run reported the work is incomplete; a risk override cannot finish it — re-run until it completes (rerun_with_feedback)",
-                                code: "work_state_needs_input",
-                            });
-                        }
-                        // The override unblocks a NEEDS-DECISION run (review blocked /
-                        // checks failed, D8); recording one elsewhere would claim an apply
-                        // permission that does not exist.
-                        if (!this.runNeedsDecision(rec)) {
-                            return this.json(res, 409, {
-                                error: rec.state === "succeeded"
-                                    ? "run does not need a decision; apply it directly if its review is clean (no risk override needed)"
-                                    : `run is ${rec.state}; risk overrides only unblock needs-decision runs (use rerun_with_feedback instead)`,
-                            });
-                        }
-                        const patch = readPatch(rec);
-                        if (patch === null)
-                            return this.json(res, 409, {
-                                error: "no patch artifact; there is nothing to unblock for apply",
-                            });
-                        const decision = this.recordOperatorDecision(rec, {
-                            action: decisionAction,
-                            findingIds: decisionBody.findingIds,
-                            acceptedRisks: decisionBody.acceptedRisks,
-                            patchSha256: sha256(patch),
-                            decidedAt: nowIso(),
-                        }, {
-                            key: decisionKey,
-                            client: "control-api",
-                            request: { runId: rec.runId ?? rec.id, body: decisionBody },
-                        });
-                        try {
-                            writeOperatorDecisionProjection(rec, decision);
-                            appendRunAuditEvent(rec, "control.applied", {
-                                decision: decisionAction,
-                                finding_ids: decisionBody.findingIds,
-                                accepted_risks: decisionBody.acceptedRisks,
-                            });
-                        }
-                        catch {
-                            // Journal authority remains queryable and replayable by Idempotency-Key.
-                        }
-                        return this.json(res, 200, ControlRunDecisionResponse.parse({
-                            accepted: true,
-                            status: "applied",
-                            // Honest ACK (QA-032B): nothing is mutated at decision time. The
-                            // risk is accepted for this exact patch; Apply is now available
-                            // and a fresh final check runs just-in-time before any mutation.
-                            message: `${decisionAction} recorded for this exact patch; Apply is now available and will run a fresh final check before changing the project`,
-                        }));
-                    });
+                    return await acceptRiskDecision({
+                        services: this.opts.services,
+                        chainMutation: (record, work) => this.chainRunMutation(record, work),
+                        workStateVeto: (record) => this.runWorkStateVeto(record),
+                        needsDecision: (record) => this.runNeedsDecision(record),
+                        readPatch,
+                        writeProjection: writeOperatorDecisionProjection,
+                        appendAudit: (record, payload) => appendRunAuditEvent(record, "control.applied", payload),
+                        json: (response, status, responseBody) => this.json(response, status, responseBody),
+                    }, rec, body, decisionKey, res);
                 }
                 catch (error) {
                     return this.requestError(res, error);
@@ -812,28 +762,23 @@ export class DaemonControlApiServer {
                     return this.requestError(res, error);
                 }
             }
-            return rerunWithFeedback({
-                daemon: this.opts.daemon,
-                services: this.opts.services,
-                waitForRunStart: (id) => this.waitForRunStart(id),
-                appendAudit: (record, payload) => appendRunAuditEvent(record, "control.applied", payload),
-                json: (response, status, responseBody) => this.json(response, status, responseBody),
-            }, rec, body, decisionKey, res);
+            try {
+                return await rerunWithFeedback({
+                    daemon: this.opts.daemon,
+                    services: this.opts.services,
+                    serializeThreadMutation: (threadId, work) => chainThreadMutation(this.threadTurnChains, threadId, work),
+                    waitForRunStart: (id) => this.waitForRunStart(id),
+                    appendAudit: (record, payload) => appendRunAuditEvent(record, "control.applied", payload),
+                    json: (response, status, responseBody) => this.json(response, status, responseBody),
+                }, rec, body, decisionKey, res);
+            }
+            catch (error) {
+                return this.requestError(res, error, 500);
+            }
         }
         if (method === "GET" && path === "/harnesses") {
             try {
-                assertOnlyQueryParams(url, ["fresh", "all", "harness"]);
-                const fresh = optionalBooleanQuery(url, "fresh");
-                const includeFakes = optionalBooleanQuery(url, "all");
-                const harnessIds = url.searchParams
-                    .getAll("harness")
-                    .map((id) => id.trim())
-                    .filter(Boolean);
-                return this.service(res, "harnesses", {
-                    ...(fresh === undefined ? {} : { fresh }),
-                    ...(includeFakes === undefined ? {} : { includeFakes }),
-                    ...(harnessIds.length === 0 ? {} : { harnessIds }),
-                }, ControlHarnessListResponse);
+                return this.service(res, "harnesses", parseHarnessListQuery(url), ControlHarnessListResponse);
             }
             catch (err) {
                 return this.requestError(res, err);
@@ -841,6 +786,14 @@ export class DaemonControlApiServer {
         }
         if (method === "GET" && path === "/agent-capabilities")
             return this.service(res, "agentCapabilities", undefined, AgentCapabilityCatalog);
+        if (method === "GET" && path === "/run-applicability") {
+            try {
+                return this.service(res, "runApplicability", parseRunApplicabilityQuery(url), ControlRunApplicabilityResponse);
+            }
+            catch (error) {
+                return this.requestError(res, error);
+            }
+        }
         const harnessModelsMatch = /^\/harnesses\/([^/]+)\/models$/.exec(path);
         if (method === "GET" && harnessModelsMatch) {
             try {
@@ -974,8 +927,15 @@ export class DaemonControlApiServer {
             return this.service(res, "quota", undefined, ControlQuotaResponse);
         if (method === "POST" && path === "/quota")
             return this.service(res, "refreshQuota", undefined, ControlQuotaResponse);
-        if (method === "GET" && path === "/credential-profiles")
-            return this.service(res, "credentialProfiles", undefined, ControlCredentialProfilesResponse);
+        if (method === "GET" && path === "/credential-profiles") {
+            try {
+                const query = parseCredentialProfilesSnapshotQuery(url);
+                return this.service(res, "credentialProfiles", query.input, query.schema);
+            }
+            catch (error) {
+                return this.requestError(res, error);
+            }
+        }
         if (method === "POST" && path === "/credential-profiles") {
             let body;
             try {
@@ -1410,23 +1370,8 @@ export class DaemonControlApiServer {
         const state = facts.work_state?.state;
         return state === "needs_input" || state === "incomplete" ? state : null;
     }
-    recordOperatorDecision(rec, decision, idempotency) {
-        const record = this.opts.services?.recordOperatorDecision;
-        if (!record) {
-            throw Object.assign(new Error("operator decisions are not supported by this engine build"), {
-                status: 501,
-            });
-        }
-        return record(rec.runId ?? rec.id, rec.params, decision, idempotency);
-    }
     chainRunMutation(rec, work) {
-        const threadId = threadIdOfRun(rec);
-        if (!threadId)
-            return work();
-        return chainThreadMutation(this.threadTurnRouteCtx(), threadId, async () => {
-            await assertThreadIdle(rec, () => this.opts.daemon.list());
-            return work();
-        });
+        return chainIdleRunMutation(this.threadTurnChains, this.opts.daemon, rec, work);
     }
     threadTurnRouteCtx() {
         const services = this.opts.services ?? {};
@@ -1437,10 +1382,12 @@ export class DaemonControlApiServer {
             resolveRunArtifactPath: async (runId, rel) => this.resolveRunArtifactPath(runId, rel),
             normalizeStart: runStart.normalizeRunStart,
             preflightRunRequirements: services.preflightRunRequirements,
+            preflightThreadRunRequirements: services.preflightThreadRunRequirements,
             isTerminalState: (state) => TERMINAL_STATES.has(state),
             daemon: this.opts.daemon,
             threadDetail: services.threadDetail,
             createThreadTurn: services.createThreadTurn,
+            findThreadTurnByIdempotency: services.findThreadTurnByIdempotency,
             setTurnEnqueueError: services.setTurnEnqueueError,
             threadTurnChains: this.threadTurnChains,
         };
@@ -1654,83 +1601,6 @@ function appendRunAuditEvent(rec, type, payload) {
         /* audit append must not change control behavior */
     }
 }
-/**
- * QA-052 observability: how many artifact-path probes the run-list fingerprinter
- * has performed (each probe is a synchronous filesystem stat-family lookup). The
- * single-parse test pattern (eventsParseCount) proves warm-list work is BOUNDED
- * — by page size (only sliced records are fingerprinted) and, for terminal runs,
- * by the one-probe short-circuit below (1 path instead of 12).
- */
-let fingerprintProbeCount = 0;
-export function runListFingerprintProbeCountForTests() {
-    return fingerprintProbeCount;
-}
-export function resetRunListFingerprintProbeCountForTests() {
-    fingerprintProbeCount = 0;
-}
-function summaryFingerprint(rec) {
-    const mtime = (rel) => {
-        fingerprintProbeCount++;
-        if (!rec.runDir)
-            return 0;
-        const path = safeArtifactPath(rec.runDir, rel);
-        if (!path)
-            return 0;
-        try {
-            return statSync(path).mtimeMs;
-        }
-        catch {
-            return 0;
-        }
-    };
-    const identity = [rec.state, paramsFingerprint(rec), rec.finishedAt ?? "", rec.error ?? ""];
-    // QA-052 terminal short-circuit: a TERMINAL run's every projected artifact
-    // (events.jsonl, arbitration, telemetry, failure, the final/* outputs,
-    // work_product) is written before the daemon marks the run terminal and never
-    // changes afterward. The SOLE post-terminal mutation is the delivery/apply
-    // overlay (final/delivery_state.yaml), which the apply/revert route is the one
-    // writer of [B7]. So a warm re-list of a terminal run fingerprints ONE path
-    // instead of twelve — the cheap probe still detects an apply/revert, and every
-    // other axis is frozen. Active (queued/running) runs keep the full
-    // artifact-mtime fingerprint because their events.jsonl and final/* land while
-    // the run is still live.
-    if (TERMINAL_STATES.has(rec.state)) {
-        return [...identity, mtime("final/delivery_state.yaml")].join("|");
-    }
-    return [
-        ...identity,
-        mtime("events.jsonl"),
-        mtime("arbitration/decision.yaml"),
-        mtime("final/telemetry.yaml"),
-        mtime("final/failure.yaml"),
-        mtime("final/summary.md"),
-        // Primary outputs feed outputReadyState; a summary cached before the
-        // answer/plan/report/patch landed must invalidate when it does.
-        mtime("final/answer.md"),
-        mtime("final/plan.md"),
-        mtime("final/explore.md"),
-        mtime("final/report.md"),
-        mtime("final/patch.diff"),
-        // The honest outcome (result kind / diffstat / adopted) is projected from
-        // work_product.yaml; a summary cached before it landed must invalidate.
-        mtime("final/work_product.yaml"),
-        // The MUTABLE delivery state (applied / reverted / not_applied) is written
-        // to delivery_state.yaml by markRunApplyState, and controlRunResult prefers
-        // that overlay over work_product.yaml's immutable apply_state. It must be in
-        // the fingerprint set or a summary cached before an apply/revert keeps
-        // reporting the stale applyState (the dedicated apply route writes only this
-        // file, so no other fingerprinted mtime would move). [B7]
-        mtime("final/delivery_state.yaml"),
-    ].join("|");
-}
-function paramsFingerprint(rec) {
-    try {
-        return sha256(JSON.stringify(rec.params ?? null));
-    }
-    catch {
-        return "unserializable-params";
-    }
-}
 /** v0.9 strategy flags projected back so surfaces can tell a race from a repair loop. */
 function strategyFromParams(p) {
     if (p["untilClean"] === true)
@@ -1852,6 +1722,13 @@ function runOutcomeFacts(rec, decision, failure,
  * folded into a DECISION-LESS terminal so a needs_input/incomplete ask
  * carries its veto axis just like an arbitrated agent run. */
 workState = null) {
+    const legacy = legacyRunOutcomeFacts(rec, decision, failure, workState);
+    if (!legacy)
+        return null;
+    return effectiveTerminalFacts(rec.runDir, legacy, decision, expectedRunFacts(rec)).outcomeFacts;
+}
+/** Legacy-only terminal projection retained for active/pre-RunFacts records. */
+function legacyRunOutcomeFacts(rec, decision, failure, workState = null) {
     if (!isTerminalLifecycle(rec.state))
         return null;
     // Arbitrated runs already carry work_state on decision.facts (INV-116).
@@ -1901,6 +1778,15 @@ function summarizeRun(rec, eventsSnapshot) {
     const externalContextPolicy = telemetry?.external_context_policy ?? task?.external_context.policy;
     const webEvidence = controlWebEvidence(telemetry, task);
     const decision = safeReadStructuredArtifact(rec, "arbitration/decision.yaml", DecisionRecord);
+    const failure = readFailure(rec);
+    const workState = telemetry?.final_attempt_id
+        ? (telemetry.attempts.find((a) => a.attempt_id === telemetry.final_attempt_id)?.outcome
+            .work_state ?? null)
+        : null;
+    const legacyOutcome = legacyRunOutcomeFacts(rec, decision, failure, workState);
+    const terminalFacts = legacyOutcome
+        ? effectiveTerminalFacts(rec.runDir, legacyOutcome, decision, expectedRunFacts(rec))
+        : { runFacts: null, outcomeFacts: null, decision };
     const budget = budgetSnapshot(rec, decision, eventsSnapshot);
     const parsedReviewerPanel = Array.isArray(p["reviewerPanel"])
         ? ControlReviewerPanelEntry.array().safeParse(p["reviewerPanel"])
@@ -1931,7 +1817,7 @@ function summarizeRun(rec, eventsSnapshot) {
         state: rec.state,
         runDir: rec.runDir,
         error: rec.error,
-        failure: readFailure(rec),
+        failure,
         project: projectMetadata(rec),
         mode: parsedMode.success ? parsedMode.data : undefined,
         strategy: strategyFromParams(p),
@@ -1958,7 +1844,6 @@ function summarizeRun(rec, eventsSnapshot) {
         // The single engine validator's receipt, projected verbatim — surfaces
         // never re-validate the answer (null = no structured-output contract).
         outputConformance: outputConformance?.status ?? null,
-        // Route receipt projected verbatim (INV-061 disclosure); never re-derived.
         authRoute: telemetry?.auth_route
             ? {
                 requested: telemetry.auth_route.requested,
@@ -1967,6 +1852,7 @@ function summarizeRun(rec, eventsSnapshot) {
                 reason: telemetry.auth_route.reason,
                 harnessId: telemetry.auth_route.harness_id,
                 attemptId: telemetry.auth_route.attempt_id,
+                profileId: telemetry.auth_route.profile_id,
                 modelMismatch: telemetry.auth_route.model_mismatch,
             }
             : null,
@@ -1979,13 +1865,10 @@ function summarizeRun(rec, eventsSnapshot) {
         webEvidence,
         requestRequirements: telemetry?.request_requirements ?? [],
         toolPermissionPolicy: task?.tool_permission_policy,
-        outputReadyState: outputReadyState(rec, parsedMode.success ? parsedMode.data : null, readFailure(rec)),
+        outputReadyState: outputReadyState(rec, parsedMode.success ? parsedMode.data : null, failure, terminalFacts.runFacts),
         toolWarningsTotal: telemetry?.tool_warnings_total ?? 0,
         result: controlRunResult(rec),
-        outcomeFacts: runOutcomeFacts(rec, decision, readFailure(rec), telemetry?.final_attempt_id
-            ? (telemetry.attempts.find((a) => a.attempt_id === telemetry.final_attempt_id)?.outcome
-                .work_state ?? null)
-            : null),
+        outcomeFacts: terminalFacts.outcomeFacts,
         route: controlRoute(telemetry, p),
         // QA-034: routing rationale projected verbatim from the engine telemetry —
         // surfaces never reconstruct the order from prose.
@@ -2043,23 +1926,29 @@ function detailFor(rec, pendingInteractions = [], cursor, operator = null, child
         ? readRunEventsWithIntegrity(rec)
         : { events: [], integrity: undefined };
     const summary = summarizeRun(rec, events);
-    // Non-null exactly when the run has an applyable patch — the authoritative
-    // "something to apply" banner signal (a convergence patch may carry kind:patch
-    // with no meta.result_kind, so result.kind alone would miss it).
-    const applyEligibility = applyEligibilityFor(rec, operator);
+    // applyEligibility is non-null exactly when the run has an applyable patch —
+    // the authoritative "something to apply" banner signal (a convergence patch
+    // may carry kind:patch with no meta.result_kind, so result.kind alone would
+    // miss it).
+    const { runFacts, outcomeFacts, applyEligibility, requiredActions } = projectRunFactsForDetail(rec.runDir, summary.outcomeFacts ?? null, operator !== null, () => applyEligibilityFor(rec, operator), expectedRunFacts(rec));
     const planProjection = planProjectionFor(rec, summary.mode);
     return ControlRunDetail.parse({
-        summary: { ...summary, waitingOnUser: pendingInteractions.length > 0 },
+        summary: {
+            ...summary,
+            outcomeFacts,
+            waitingOnUser: pendingInteractions.length > 0,
+        },
         children,
+        runFacts,
         // Server-owned outcome headline (D18), from the single projection owner —
         // surfaces render it verbatim above model prose, never re-derive it.
-        outcomeBanner: outcomeBanner(summary.outcomeFacts ?? null, {
+        outcomeBanner: outcomeBanner(outcomeFacts, {
             applyState: summary.result.applyState,
             hasApplyableChange: applyEligibility !== null,
         }),
         lastSeq,
         artifacts: rec.runDir ? listArtifacts(rec.runDir) : [],
-        primaryOutput: primaryOutput(rec, summary.mode, failure),
+        primaryOutput: primaryOutput(rec, summary.mode, failure, runFacts),
         timeline: timelineEvents(rec, events, integrity),
         budget: budgetSnapshot(rec, decision, events, integrity),
         finalSummary: boundedArtifactText(rec, "final/summary.md"),
@@ -2083,8 +1972,9 @@ function detailFor(rec, pendingInteractions = [], cursor, operator = null, child
         // Minimal typed required-actions (GH #29) for a succeeded-but-blocked run,
         // from the single status-projection owner: review-blocked / checks-failed /
         // needs-decision / work_state needs_input, keyed to the same validated
-        // operator decision the needs-decision + apply gates consult.
-        requiredActions: requiredActionsFor(summary.outcomeFacts ?? null, operator !== null),
+        // operator decision the needs-decision + apply gates consult — the
+        // canonical terminal actions plus legitimate post-terminal overlays.
+        requiredActions,
     });
 }
 function readTextArtifact(rec, relPath, redact = true) {
@@ -2272,9 +2162,10 @@ function applyGateError(rec, patch, targetRepoRoot, operatorDecision, finalVerif
 }
 function applyGateInputFor(rec, patch, targetRepoRoot, operatorDecision) {
     const decision = safeReadStructuredArtifact(rec, "arbitration/decision.yaml", DecisionRecord);
+    const terminal = effectiveTerminalFacts(rec.runDir, decision?.facts ?? null, decision, expectedRunFacts(rec));
     return {
         state: rec.state,
-        decision,
+        decision: terminal.decision,
         workProduct: safeReadStructuredArtifact(rec, "final/work_product.yaml", WorkProduct),
         patch,
         originalRepoRoot: runRepoRoot(rec),
@@ -2287,9 +2178,10 @@ function applyGateInputFor(rec, patch, targetRepoRoot, operatorDecision) {
         // an already-applied / reverted run gets a terminal eligibility disposition
         // instead of a stale "rerun a fresh check" (QA-021).
         applyState: controlRunResult(rec).applyState,
-        // D-16 work_state veto (INV-116): thread the model-attested work outcome so
-        // the gate refuses a needs_input/incomplete winner even with a clean review.
-        workState: decision?.facts?.work_state ?? null,
+        // D-16 work_state veto (INV-116): thread the model-attested work outcome
+        // (the canonical terminal facts) so the gate refuses a needs_input/
+        // incomplete winner even with a clean legacy review.
+        workState: terminal.outcomeFacts?.work_state ?? null,
     };
 }
 /**