@claudexor/control-api 3.1.1 → 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";
@@ -8,31 +8,43 @@ import { safeArtifactPath, safeArtifactRoot } from "./artifact-paths.js";
 import { TERMINAL_STATES } from "./sse-shared.js";
 import { streamRunEvents } from "./run-events-stream.js";
 import { boundedArtifactText, outputReadyState, primaryOutput } from "./primary-output.js";
+import { budgetValuationFromEvents, cashEstimatedFromLedgerEvent, normalizeLegacyBudgetComponents, } from "./budget-valuation.js";
 import { controlWebEvidence, eventPayload, evidenceLevel, latestPlanProgress, readRunEvents, readRunEventsWithIntegrity, timelineEvents, } from "./run-timeline.js";
-import { projectSession, projectThread, projectTurn, turnRunCard } from "./thread-projection.js";
-import { chainThreadMutation, handleThreadTurnCreate, handleThreadTurnRetry, } from "./thread-turn-routes.js";
-import { assertThreadIdle, threadIdOfRun } from "./thread-mutation.js";
+import { projectTurnRunCards } from "./thread-projection.js";
+import { projectSession, projectThread, projectTurn } from "./thread-projection.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";
+import { directDelegatedChildrenFromRecords, delegatedDescendantsFromRecords, paramsRecord, } from "./run-record.js";
 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, 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();
@@ -59,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)
@@ -96,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)
             : {},
     });
 }
@@ -252,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") {
@@ -375,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") {
@@ -411,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);
@@ -423,7 +436,9 @@ export class DaemonControlApiServer {
             // Fence order: cursor FIRST, every projection (pending interactions
             // included) after it — see the detailFor doc comment.
             const lastSeq = rec.runDir ? lastSeqInFile(join(rec.runDir, "events.jsonl")) : 0;
-            return this.json(res, 200, detailFor(rec, this.pendingInteractionsFor(rec), lastSeq, this.validOperatorDecisionFor(rec)));
+            const parentRunId = rec.runId ?? rec.id;
+            const children = directDelegatedChildrenFromRecords(parentRunId, await this.opts.daemon.list()).map((candidate) => this.summarizeRunOrDiagnostic(candidate));
+            return this.json(res, 200, detailFor(rec, this.pendingInteractionsFor(rec), lastSeq, this.validOperatorDecisionFor(rec), children));
         }
         const interactionAnswerMatch = /^\/runs\/([^/]+)\/interactions\/([^/]+)\/answer$/.exec(path);
         if (method === "POST" && interactionAnswerMatch) {
@@ -481,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,
@@ -533,15 +542,7 @@ export class DaemonControlApiServer {
                 const runs = await this.opts.daemon.list();
                 const byRun = new Map(runs.map((r) => [r.runId ?? r.id, r]));
                 const thread = detail.thread;
-                const cards = new Map();
-                for (const turn of detail.turns) {
-                    const runId = turn.run_id ?? null;
-                    if (runId && !cards.has(runId)) {
-                        const rec = byRun.get(runId);
-                        if (rec)
-                            cards.set(runId, turnRunCard(this.summarizeRunOrDiagnostic(rec)));
-                    }
-                }
+                const cards = projectTurnRunCards(detail.turns, runs, (record) => this.summarizeRunOrDiagnostic(record));
                 const headRec = byRun.get(thread.head_run_id ?? "");
                 const headNeedsHuman = headRec ? this.runNeedsAttention(headRec) : false;
                 return this.json(res, 200, ControlThreadDetail.parse({
@@ -633,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);
@@ -814,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);
@@ -843,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 {
@@ -976,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 {
@@ -1040,13 +998,30 @@ export class DaemonControlApiServer {
                     error: `run is ${rec.state}; ${body.control.kind} has nothing to stop`,
                 });
             }
-            await this.opts.daemon.cancel(rec.id);
+            let activeDescendants;
+            try {
+                const cancelled = await cancelDelegationFamily({
+                    daemon: this.opts.daemon,
+                    parent: rec,
+                    descendantsAfterFence: () => this.delegatedDescendants(rec.runId ?? rec.id),
+                    pollMs: this.opts.pollMs,
+                });
+                activeDescendants = cancelled.descendants;
+            }
+            catch (error) {
+                appendRunAuditEvent(rec, "control.rejected", {
+                    control: body.control,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+                return this.requestError(res, error);
+            }
             appendRunAuditEvent(rec, "control.applied", { control: body.control });
             return this.json(res, 200, ControlRunControlResponse.parse({
                 accepted: true,
                 status: "applied",
                 runId: rec.runId ?? rec.id,
-                message: `${body.control.kind} requested`,
+                cascadeRunIds: activeDescendants.map((child) => child.runId ?? child.id),
+                message: `${body.control.kind} requested${activeDescendants.length ? ` for parent and ${activeDescendants.length} delegated descendant(s)` : ""}`,
             }));
         }
         const eventsMatch = /^\/runs\/([^/]+)\/events$/.exec(path);
@@ -1298,6 +1273,11 @@ export class DaemonControlApiServer {
         const runs = await this.opts.daemon.list();
         return runs.find((r) => r.id === id || r.runId === id) ?? null;
     }
+    /** Persisted Delegate-only descendant graph. `parentRunId` alone is broader
+     * thread/retry lineage and deliberately does not participate. */
+    async delegatedDescendants(parentRunId) {
+        return delegatedDescendantsFromRecords(parentRunId, await this.opts.daemon.list());
+    }
     /**
      * GET /v2/runs (QA-052): a bounded, newest-first, keyset-paginated page of run
      * summaries. Ordering, filtering, and slicing all happen on the raw daemon
@@ -1390,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 ?? {};
@@ -1417,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,
         };
@@ -1521,11 +1488,22 @@ export class DaemonControlApiServer {
             return this.summarizeRunLive(rec);
         }
         catch (err) {
+            const delegatedFromRunId = Id.safeParse(paramsRecord(rec)["delegatedFromRunId"]);
+            let waitingOnUser = false;
+            try {
+                waitingOnUser = this.pendingInteractionsFor(rec).length > 0;
+            }
+            catch {
+                // The diagnostic row remains fail-soft even when interaction state is
+                // also corrupt; false is the only safe fallback without evidence.
+            }
             return ControlRunSummary.parse({
                 jobId: rec.id,
                 runId: rec.runId ?? rec.id,
+                ...(delegatedFromRunId.success ? { delegatedFromRunId: delegatedFromRunId.data } : {}),
+                waitingOnUser,
                 state: "failed",
-                error: `unprojectable job record: ${err instanceof Error ? err.message : String(err)}`,
+                error: redactSecrets(`unprojectable job record: ${err instanceof Error ? err.message : String(err)}`),
             });
         }
     }
@@ -1572,11 +1550,6 @@ export class DaemonControlApiServer {
     }
 }
 /* ---- Thread projections (engine snake_case -> control camelCase) ---- */
-function paramsRecord(rec) {
-    return rec.params && typeof rec.params === "object" && !Array.isArray(rec.params)
-        ? rec.params
-        : {};
-}
 function projectMetadata(rec) {
     const p = paramsRecord(rec);
     const scope = p["scope"];
@@ -1628,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)
@@ -1826,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).
@@ -1875,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"])
@@ -1894,11 +1806,18 @@ function summarizeRun(rec, eventsSnapshot) {
     return ControlRunSummary.parse({
         jobId: rec.id,
         runId: rec.runId ?? rec.id,
+        parentRunId: (typeof p["parentRunId"] === "string" ? p["parentRunId"] : null) ??
+            task?.run_lineage.parent_run_id ??
+            null,
+        delegatedFromRunId: (typeof p["delegatedFromRunId"] === "string" ? p["delegatedFromRunId"] : null) ??
+            task?.run_lineage.delegated_from_run_id ??
+            null,
+        delegation: telemetry?.delegation ?? null,
         taskId: rec.taskId,
         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),
@@ -1925,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,
@@ -1934,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,
@@ -1946,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.
@@ -1989,7 +1905,7 @@ function controlRoute(telemetry, p) {
         verified: observed !== null,
     };
 }
-function detailFor(rec, pendingInteractions = [], cursor, operator = null) {
+function detailFor(rec, pendingInteractions = [], cursor, operator = null, children = []) {
     // Snapshot fence: capture the event cursor BEFORE building any projection.
     // The fence promise is "every event with seq <= lastSeq is reflected" — a
     // cursor read AFTER the projections could skip an event that landed in
@@ -2010,22 +1926,29 @@ function detailFor(rec, pendingInteractions = [], cursor, operator = null) {
         ? 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"),
@@ -2049,8 +1972,9 @@ function detailFor(rec, pendingInteractions = [], cursor, operator = null) {
         // 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) {
@@ -2074,42 +1998,6 @@ function parseAccessMaybe(value) {
     const parsed = AccessProfile.safeParse(value);
     return parsed.success ? parsed.data : undefined;
 }
-/**
- * Pure subscription-VALUATION fold over a run's events (QA-023c/QA-017b),
- * independent of the cash truth. The owner-locked ledger settles native-
- * subscription work to cash $0 while accumulating its token valuation on
- * `budget.cash.valuation_usd` (last-wins, cumulative). An UNKNOWN valuation (no
- * usage ever reported — e.g. a Cursor draft) stays NULL and is never coerced to
- * a fake $0. The legacy fallback for runs predating budget.cash is the summed
- * `budget.observation` spend. Vendor token valuation is at best an estimate.
- */
-export function budgetValuationFromEvents(events) {
-    let valuationUsd = null;
-    let observation = 0;
-    let sawObservation = false;
-    for (const ev of events) {
-        const payload = eventPayload(ev);
-        if (ev["type"] === "budget.cash") {
-            const val = payload["valuation_usd"];
-            if (typeof val === "number" && Number.isFinite(val))
-                valuationUsd = val;
-            continue;
-        }
-        if (ev["type"] === "budget.observation" && payload["kind"] === "spend") {
-            const usd = payload["usd"];
-            if (typeof usd === "number" && Number.isFinite(usd)) {
-                observation += usd;
-                sawObservation = true;
-            }
-        }
-    }
-    if (valuationUsd === null && sawObservation)
-        valuationUsd = observation;
-    return {
-        valuationUsd,
-        valuationKnowledge: valuationUsd === null ? "unknown" : "estimated",
-    };
-}
 /** Typed severity per event type — no string matching over event names. */
 function budgetSnapshot(rec, decision, eventsSnapshot, integrity) {
     const p = paramsRecord(rec);
@@ -2126,7 +2014,9 @@ function budgetSnapshot(rec, decision, eventsSnapshot, integrity) {
     let source = spendUsd === null ? "unknown" : "decision";
     // Subscription VALUATION (QA-023c/QA-017b) beside cash — computed by the pure
     // event fold so an UNKNOWN valuation stays null, never a fabricated $0.
-    const { valuationUsd, valuationKnowledge } = budgetValuationFromEvents(evs);
+    const normalized = normalizeLegacyBudgetComponents(decision?.budget_summary ?? null, evs, budgetValuationFromEvents(evs));
+    let { valuationUsd, valuationKnowledge } = normalized;
+    estimated = normalized.cashEstimated;
     if (spendUsd === null) {
         // The CASH truth for a decision-less run (plan/ask/explore — they never
         // write a decision record) is the ledger's own `budget.cash` disclosure:
@@ -2147,8 +2037,10 @@ function budgetSnapshot(rec, decision, eventsSnapshot, integrity) {
             const payload = eventPayload(ev);
             if (ev["type"] === "budget.cash") {
                 const cash = payload["cash_spend_usd"];
-                if (typeof cash === "number" && Number.isFinite(cash))
+                if (typeof cash === "number" && Number.isFinite(cash)) {
                     lastCash = cash;
+                    estimated = cashEstimatedFromLedgerEvent(payload);
+                }
                 continue;
             }
             if (ev["type"] === "budget.observation" && payload["kind"] === "spend") {
@@ -2270,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),
@@ -2285,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,
     };
 }
 /**