@lsctech/polaris 0.4.9 → 0.5.2

package/dist/finalize/index.js

@@ -29,6 +29,7 @@ const local_graph_js_1 = require("../tracker/local-graph.js");
 const index_js_1 = require("../tracker/sync/index.js");
 const finalize_evidence_js_1 = require("../loop/finalize-evidence.js");
 const delivery_integrity_js_1 = require("./delivery-integrity.js");
+const index_js_2 = require("../qc/index.js");
 function getBranch(repoRoot) {
     try {
         return (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
@@ -178,6 +179,36 @@ function checkLibrarianGate(repoRoot, clusterId) {
         return `Librarian result gate error: ${err instanceof Error ? err.message : String(err)}`;
     }
 }
+function resolveQcTelemetryFile(state, repoRoot) {
+    const artifactDir = state.artifact_dir ?? (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run");
+    return (0, node_path_1.join)(artifactDir, "runs", state.run_id, "telemetry.jsonl");
+}
+async function runQcGate(options) {
+    const { config, state, repoRoot, branch, trigger, prUrl, stepLabel } = options;
+    const registry = (0, index_js_2.createDefaultQcRegistry)();
+    const result = await (0, index_js_2.runQcAtTrigger)({
+        config,
+        registry,
+        trigger,
+        prUrl,
+        repoRoot,
+        runId: state.run_id,
+        clusterId: state.cluster_id,
+        branch,
+        telemetryFile: resolveQcTelemetryFile(state, repoRoot),
+        state,
+    });
+    if (result.action === "pass") {
+        console.log(`${stepLabel} QC ${trigger} passed: ${result.summary}`);
+        return;
+    }
+    if (result.action === "follow-up") {
+        console.warn(`${stepLabel} QC ${trigger} produced follow-up work: ${result.summary}`);
+        return;
+    }
+    process.stderr.write(`${stepLabel} QC ${trigger} blocked finalize: ${result.summary}\n`);
+    process.exit(1);
+}
 async function runFinalize(options) {
     const { repoRoot, stateFile, dryRun, skipDelivery, skipLibrarian } = options;
     const config = (0, loader_js_1.loadConfig)(repoRoot);
@@ -356,6 +387,16 @@ async function runFinalize(options) {
             }
         }
     }
+    // Step 5.8: Completed-cluster QC trigger (when configured)
+    // Runs after all authoritative gates and before final commit/delivery.
+    await runQcGate({
+        config: config.qc,
+        state,
+        repoRoot,
+        branch,
+        trigger: "completed-cluster",
+        stepLabel: "[5.8/14]",
+    });
     // Step 6: Tracker Reconciliation
     // LinearAdapter is sync-in only; only McpBridgeAdapter supports full reconciliation.
     const trackerType = config.tracker?.adapter;
@@ -392,28 +433,32 @@ async function runFinalize(options) {
     else {
         console.warn(`[6/14] Unknown tracker adapter '${trackerType}' — skipping reconciliation.`);
     }
-    // Step 7: Single final commit: source changes + durable Polaris artifacts
-    console.log("[7/14] Committing durable Polaris state + map..."); // Step count updated
+    // Step 7: Closeout Librarian gate (pre-commit preflight)
+    // Must run before the finalize commit so that a missing or invalid librarian
+    // result aborts before any mutating git I/O.
+    if (!skipDelivery) {
+        if (!skipLibrarian) {
+            console.log("[7/14] Checking Closeout Librarian gate...");
+            const librarianBlocker = checkLibrarianGate(repoRoot, state.cluster_id);
+            if (librarianBlocker) {
+                process.stderr.write(`finalize aborted: Closeout Librarian gate failed.\n${librarianBlocker}\n`);
+                process.exit(1);
+            }
+            console.log("[7/14] Closeout Librarian gate passed.");
+        }
+        else {
+            console.log("[7/14] Closeout Librarian gate skipped (--skip-librarian).");
+        }
+    }
+    // Step 8: Single final commit: source changes + durable Polaris artifacts
+    console.log("[8/14] Committing durable Polaris state + map..."); // Step count updated
     const resolvedStateFile = (0, node_path_1.resolve)(stateFile);
     (0, _06_commit_js_1.stepCommit)(repoRoot, state, resolvedStateFile, reportPath);
     if (skipDelivery) {
-        console.log("[8–14/14] Delivery skipped (--skip-delivery).");
-        console.log("polaris finalize steps 1–7 complete.");
+        console.log("[9–14/14] Delivery skipped (--skip-delivery).");
+        console.log("polaris finalize steps 1–8 complete.");
         return;
     }
-    // Step 8: Closeout Librarian gate
-    if (!skipLibrarian) {
-        console.log("[8/14] Checking Closeout Librarian gate...");
-        const librarianBlocker = checkLibrarianGate(repoRoot, state.cluster_id);
-        if (librarianBlocker) {
-            process.stderr.write(`finalize aborted: Closeout Librarian gate failed.\n${librarianBlocker}\n`);
-            process.exit(1);
-        }
-        console.log("[8/14] Closeout Librarian gate passed.");
-    }
-    else {
-        console.log("[8/14] Closeout Librarian gate skipped (--skip-librarian).");
-    }
     // Step 9: git push
     console.log("[9/14] Pushing branch...");
     (0, _07_push_js_1.stepPush)(repoRoot, branch);
@@ -421,6 +466,17 @@ async function runFinalize(options) {
     const prDraft = config.finalize?.prDraft ?? true;
     console.log("[10/14] Creating draft PR...");
     const prUrl = (0, _08_create_pr_js_1.stepCreatePr)(repoRoot, branch, state, prDraft);
+    // Step 10.5: PR-required QC trigger (when configured)
+    // Providers that require a PR URL run here after the PR is created.
+    await runQcGate({
+        config: config.qc,
+        state,
+        repoRoot,
+        branch,
+        trigger: "pr",
+        prUrl,
+        stepLabel: "[10.5/14]",
+    });
     // Step 11: Write PR URL to current-state.json
     console.log("[11/14] Writing PR URL to state...");
     state = (0, _09_update_state_js_1.stepUpdateState)(resolvedStateFile, state, prUrl);

package/dist/finalize/linear.js

@@ -4,6 +4,8 @@ exports.assertNotDoneState = assertNotDoneState;
 exports.findReviewState = findReviewState;
 exports.postLinearComment = postLinearComment;
 exports.updateLinearIssueAfterFinalize = updateLinearIssueAfterFinalize;
+exports.buildFollowUpIssuePayload = buildFollowUpIssuePayload;
+exports.createLinearFollowUpIssue = createLinearFollowUpIssue;
 const node_https_1 = require("node:https");
 const lifecycle_policy_js_1 = require("../tracker/lifecycle-policy.js");
 // ──────────────────────────────────────────────────────────────────────────────
@@ -211,3 +213,46 @@ async function updateLinearIssueAfterFinalize(options) {
         throw new Error(`Linear commentCreate failed: ${JSON.stringify(commentData.commentCreate)}`);
     }
 }
+async function findIssueTeamId(issueId, apiKey) {
+    const issueData = await linearGraphQL(`query GetIssueTeam($id: String!) { issue(id: $id) { team { id } } }`, { id: issueId }, apiKey);
+    return issueData.issue?.team?.id ?? null;
+}
+/**
+ * Build the GraphQL variables for a Linear follow-up issue.
+ * Exported separately so tests can inspect the payload shape.
+ */
+function buildFollowUpIssuePayload(options) {
+    const input = {
+        title: options.title,
+        description: options.description,
+        parentId: options.parentIssueId,
+        teamId: options.teamId,
+    };
+    if (options.stateId)
+        input.stateId = options.stateId;
+    if (options.labelIds && options.labelIds.length > 0)
+        input.labelIds = options.labelIds;
+    return {
+        query: `mutation CreateFollowUpIssue($input: IssueCreateInput!) {
+      issueCreate(input: $input) { success issue { id identifier url } }
+    }`,
+        variables: { input },
+    };
+}
+/**
+ * Create a Linear follow-up issue linked to a parent issue.
+ *
+ * This is the repair path for QC findings that are routed to follow-up work.
+ */
+async function createLinearFollowUpIssue(options) {
+    const teamId = options.teamId ?? await findIssueTeamId(options.parentIssueId, options.apiKey);
+    if (!teamId) {
+        throw new Error(`Unable to resolve Linear team for parent issue ${options.parentIssueId}`);
+    }
+    const payload = buildFollowUpIssuePayload({ ...options, teamId });
+    const data = await linearGraphQL(payload.query, payload.variables, options.apiKey);
+    if (data.issueCreate?.success !== true || !data.issueCreate?.issue) {
+        throw new Error(`Linear issueCreate failed: ${JSON.stringify(data.issueCreate)}`);
+    }
+    return data.issueCreate.issue;
+}

package/dist/finalize/run-report.js

@@ -1,8 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRunReport = generateRunReport;
+function renderQcSection(qcSummary) {
+    if (!qcSummary)
+        return "";
+    const { total_findings, blocking_findings, autofixed_findings, repaired_findings, waived_findings, unvalidated_findings, open_by_severity, blocks_delivery, qc_run_count, weighted_open_score, qc_penalty, provider_breakdown, routing_breakdown } = qcSummary;
+    const openTotal = open_by_severity.critical + open_by_severity.high +
+        open_by_severity.medium + open_by_severity.low + open_by_severity.info;
+    const deliveryStatus = blocks_delivery
+        ? "**BLOCKED** — unresolved critical/high findings must be addressed before delivery"
+        : "Not blocking delivery";
+    const providers = Object.entries(provider_breakdown)
+        .map(([provider, summary]) => `| ${provider} | ${summary.total} | ${summary.blocking} | ${summary.unvalidated} |`)
+        .join("\n");
+    const routing = `| original-worker | ${routing_breakdown.original_worker} |
+| repair-worker | ${routing_breakdown.repair_worker} |
+| follow-up | ${routing_breakdown.follow_up} |
+| operator-review | ${routing_breakdown.operator_review} |
+| unset | ${routing_breakdown.unset} |`;
+    const solImpactValue = qc_penalty > 0
+        ? `-${(qc_penalty * 100).toFixed(1)}% (weighted open score ${weighted_open_score.toFixed(2)})`
+        : `none (weighted open score ${weighted_open_score.toFixed(2)})`;
+    return `
+## QC summary
+
+| Metric | Value |
+|---|---|
+| **QC runs** | ${qc_run_count} |
+| **Delivery status** | ${deliveryStatus} |
+| **Total findings** | ${total_findings} (${unvalidated_findings} unvalidated/provider-noise excluded from scoring) |
+| **SOL score impact** | ${solImpactValue} |
+
+| Status | Count |
+|---|---|
+| Blocking (critical/high, open) | ${blocking_findings} |
+| Open (all severities) | ${openTotal} |
+| Autofixed | ${autofixed_findings} |
+| Repaired | ${repaired_findings} |
+| Waived | ${waived_findings} |
+
+| **Open by severity** | critical=${open_by_severity.critical} high=${open_by_severity.high} medium=${open_by_severity.medium} low=${open_by_severity.low} info=${open_by_severity.info} |
+
+### Providers
+
+| Provider | Total | Blocking | Unvalidated |
+|---|---|---|---|
+${providers || "| _none_ | — | — | — |"}
+
+### Repair routing
+
+| Decision | Count |
+|---|---|
+${routing}
+`;
+}
 function generateRunReport(data) {
-    const { state, branch, validationPassed, prUrl, artifacts, notes } = data;
+    const { state, branch, validationPassed, prUrl, artifacts, notes, qcSummary } = data;
     const total = state.completed_children.length + state.open_children.length;
     const completedCount = state.completed_children.length;
     const childRows = state.completed_children
@@ -18,19 +71,22 @@ function generateRunReport(data) {
     const blockerNote = state.blocker
         ? `\n**Blocker:** ${state.blocker.reason} (child: ${state.blocker.child_id})\n`
         : "";
+    const qcSection = renderQcSection(qcSummary);
     return `# Run Report: ${state.run_id}
 
-**Status:** ${state.status}
-**Branch:** ${branch}
-**PR:** ${prUrl ?? "TBD — set at delivery step 9"}
-**Children completed:** ${completedCount} of ${total}
-**Validation:** ${validationPassed ? "passed" : "failed"}
-${blockerNote}
-## Children
+  | Field | Value |
+  |---|---|
+  | **Status** | ${state.status} |
+  | **Branch** | ${branch} |
+  | **PR** | ${prUrl ?? "TBD — set at delivery step 9"} |
+  | **Children completed** | ${completedCount} of ${total} |
+  | **Validation** | ${validationPassed ? "passed" : "failed"} |
+  ${blockerNote}
+  ## Children
 
-| ID | Title | Commit | Status |
-|---|---|---|---|
-${childRows || "_No children recorded_"}
+  | ID | Title | Commit | Status |
+  |---|---|---|---|
+  ${childRows || "_No children recorded_"}
 
 ## Artifacts produced
 
@@ -39,7 +95,7 @@ ${artifactList}
 ## Validation summary
 
 ${validationPassed ? "Map validate passed. Schema validate passed." : "One or more validations failed — see step output above."}
-
+${qcSection}
 ## Notes
 
 ${notesList}

package/dist/loop/adapters/agent-subtask.js

@@ -50,6 +50,7 @@ class AgentSubtaskAdapter {
         const label = packet.active_child || ((0, worker_packet_js_1.isWorkerPacket)(packet) ? packet.worker_role : 'worker');
         const commandRun = `agent-subtask:${label}`;
         const provider = options.provider || "agent-subtask";
+        const routerEvidence = options.routerDecision;
         if (!this.dispatcher) {
             const error = "Native ephemeral agent subtask dispatch is unavailable in this host environment. " +
                 "Use manual handoff or a configured terminal-cli adapter.";
@@ -60,6 +61,10 @@ class AgentSubtaskAdapter {
                 command_run: commandRun,
                 summary: error,
                 stderr: error,
+                failure_origin: "provider-launch",
+                failure_category: "provider-unavailable",
+                fallback_eligible: true,
+                router_evidence: routerEvidence,
             };
         }
         if ((0, worker_packet_js_1.isWorkerPacket)(packet) && packet.worker_role === 'impl') {
@@ -78,6 +83,10 @@ class AgentSubtaskAdapter {
                         warnings: ["empty-allowed-scope"],
                     }),
                     stderr: blockedMsg,
+                    failure_origin: "provider-launch",
+                    failure_category: "launch-error",
+                    fallback_eligible: false,
+                    router_evidence: routerEvidence,
                 };
             }
         }
@@ -94,6 +103,7 @@ class AgentSubtaskAdapter {
                     next_action: "resume-parent",
                     warnings: ["dry-run"],
                 }),
+                router_evidence: routerEvidence,
             };
         }
         const instructions = (0, worker_instructions_js_1.buildWorkerInstructions)(packet);
@@ -113,6 +123,10 @@ class AgentSubtaskAdapter {
                     command_run: commandRun,
                     summary: validationError,
                     stderr: validationError,
+                    failure_origin: "worker-execution",
+                    failure_category: "worker-failure",
+                    fallback_eligible: false,
+                    router_evidence: routerEvidence,
                 };
             }
             return {
@@ -120,6 +134,7 @@ class AgentSubtaskAdapter {
                 provider_used: provider,
                 command_run: commandRun,
                 summary,
+                router_evidence: routerEvidence,
             };
         }
         catch (err) {
@@ -130,6 +145,10 @@ class AgentSubtaskAdapter {
                 command_run: commandRun,
                 summary: `Native ephemeral agent subtask dispatch failed: ${msg}`,
                 stderr: msg,
+                failure_origin: "worker-execution",
+                failure_category: "worker-failure",
+                fallback_eligible: false,
+                router_evidence: routerEvidence,
             };
         }
     }

package/dist/loop/adapters/cli-subtask-bridge.js

@@ -65,7 +65,6 @@ function writeSealedResultFromSummary(packet, parsedSummary) {
     const validation = parsedSummary["validation"] ?? parsedSummary["validation_summary"];
     const sealedResult = {
         run_id: packet.run_id,
-        cluster_id: packet.cluster_id,
         child_id: packet.active_child,
         status: normalizeSealedStatus(parsedSummary["status"]),
     };

package/dist/loop/adapters/terminal-cli.js

@@ -46,6 +46,71 @@ function resolveCommand(cmd) {
         return false;
     }
 }
+function isQuotaExhaustedSignal(...parts) {
+    const text = parts.filter((value) => typeof value === "string" && value.length > 0).join("\n").toLowerCase();
+    if (!text)
+        return false;
+    return (text.includes("quota") ||
+        text.includes("rate limit") ||
+        text.includes("429") ||
+        text.includes("resource exhausted") ||
+        text.includes("insufficient_quota"));
+}
+function hasWorkerExecutionEvidence(packet, resultFilePath) {
+    if (resultFilePath && node_fs_1.default.existsSync(resultFilePath))
+        return true;
+    if (!packet.telemetry_file || !packet.active_child || !node_fs_1.default.existsSync(packet.telemetry_file))
+        return false;
+    try {
+        const telemetry = node_fs_1.default.readFileSync(packet.telemetry_file, "utf-8").trim();
+        if (!telemetry)
+            return false;
+        const lines = telemetry.split("\n");
+        const packetDispatchId = packet.dispatch_id;
+        // Scan backwards: when both the packet and the parsed event carry a dispatch_id,
+        // use that as the primary scope gate so stale events from a previous attempt are
+        // never attributed to the current dispatch.  Fall back to the child-dispatched
+        // boundary for older telemetry that lacks dispatch_id on individual events.
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i]?.trim();
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.child_id !== packet.active_child)
+                    continue;
+                if (parsed.event === "worker-acknowledged" ||
+                    parsed.event === "worker-heartbeat" ||
+                    parsed.event === "worker-result") {
+                    const eventDispatchId = parsed.dispatch_id;
+                    if (packetDispatchId && eventDispatchId) {
+                        // Primary gate: dispatch_id available on both sides — match determines
+                        // whether this event belongs to the current dispatch.
+                        if (eventDispatchId === packetDispatchId)
+                            return true;
+                        // Mismatch — event belongs to a different dispatch; keep scanning.
+                        continue;
+                    }
+                    // Fallback: dispatch_id not available on one or both sides — accept the
+                    // event as evidence for the current dispatch (scoped by the
+                    // child-dispatched boundary below).
+                    return true;
+                }
+                // Boundary fallback: stop at the child-dispatched event so events from a
+                // prior attempt are not counted when dispatch_id matching is unavailable.
+                if (parsed.event === "child-dispatched")
+                    break;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 class TerminalCliAdapter {
     config;
     name = 'terminal-cli';
@@ -102,6 +167,8 @@ class TerminalCliAdapter {
     }
     async dispatch(packet, options) {
         const primaryProvider = options.provider || "terminal-cli";
+        const routerEvidence = options.routerDecision;
+        const providerAttempts = [];
         if ((0, worker_packet_js_1.isWorkerPacket)(packet) && packet.worker_role === "impl") {
             const allowed = Array.isArray(packet.instructions?.allowed_scope) ? packet.instructions.allowed_scope : [];
             if (allowed.length === 0) {
@@ -119,6 +186,20 @@ class TerminalCliAdapter {
                     }),
                     stderr: blockedMsg,
                     pre_dispatch_failure: true,
+                    failure_origin: "provider-launch",
+                    failure_category: "launch-error",
+                    fallback_eligible: false,
+                    router_evidence: routerEvidence,
+                    provider_attempts: [
+                        {
+                            provider: primaryProvider,
+                            failure_origin: "provider-launch",
+                            failure_category: "launch-error",
+                            pre_dispatch_failure: true,
+                            fallback_eligible: false,
+                            message: blockedMsg,
+                        },
+                    ],
                 };
             }
         }
@@ -132,11 +213,15 @@ class TerminalCliAdapter {
         const policyProviders = (canFallback && Array.isArray(workerPolicy?.providers))
             ? workerPolicy.providers
             : [];
+        const routerProviders = canFallback && Array.isArray(routerEvidence?.providersTried)
+            ? routerEvidence.providersTried
+            : [];
+        const fallbackOrder = routerProviders.length > 0 ? routerProviders : policyProviders;
         const providersToTry = [
             { name: primaryProvider, cfg: primaryCfg, isPrimary: true },
         ];
         if (canFallback) {
-            for (const p of policyProviders) {
+            for (const p of fallbackOrder) {
                 if (p !== primaryProvider && p in (this.config.providers ?? {})) {
                     try {
                         providersToTry.push({ name: p, cfg: this.getProvider(p), isPrimary: false });
@@ -167,12 +252,30 @@ class TerminalCliAdapter {
                         provider_used: provider,
                         command_run: provider,
                         stderr: err instanceof Error ? err.message : String(err),
+                        pre_dispatch_failure: true,
+                        failure_origin: "provider-launch",
+                        failure_category: "launch-error",
+                        fallback_eligible: true,
+                        router_evidence: routerEvidence,
                     };
+                    providerAttempts.push({
+                        provider,
+                        failure_origin: "provider-launch",
+                        failure_category: "launch-error",
+                        pre_dispatch_failure: true,
+                        fallback_eligible: true,
+                        message: lastResult.stderr,
+                    });
                     continue;
                 }
                 const commandLine = formatCommandLine(command, args);
                 if (options.dryRun) {
-                    return this.dryRun(provider, command, args, commandLine, packet, packetFile, workerPrompt);
+                    const dryRun = this.dryRun(provider, command, args, commandLine, packet, packetFile, workerPrompt);
+                    return {
+                        ...dryRun,
+                        router_evidence: routerEvidence,
+                        provider_attempts: providerAttempts,
+                    };
                 }
                 if (!resolveCommand(command)) {
                     lastResult = {
@@ -181,28 +284,108 @@ class TerminalCliAdapter {
                         command_run: commandLine,
                         stderr: `Provider command "${command}" not found on PATH. ` +
                             `Install it or update the "command" field for provider "${provider}" in polaris.config.json.`,
+                        pre_dispatch_failure: true,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        fallback_eligible: true,
+                        router_evidence: routerEvidence,
+                    };
+                    providerAttempts.push({
+                        provider,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        pre_dispatch_failure: true,
+                        fallback_eligible: true,
+                        message: lastResult.stderr,
+                    });
+                    continue;
+                }
+                let result;
+                try {
+                    result = await this.runProcess(command, args, commandLine, packet, packetFile, provider, workerPrompt);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    lastResult = {
+                        exit_code: 1,
+                        provider_used: provider,
+                        command_run: commandLine,
+                        stderr: message,
+                        pre_dispatch_failure: true,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        fallback_eligible: true,
+                        router_evidence: routerEvidence,
                     };
+                    providerAttempts.push({
+                        provider,
+                        failure_origin: "provider-launch",
+                        failure_category: "provider-unavailable",
+                        pre_dispatch_failure: true,
+                        fallback_eligible: true,
+                        message,
+                    });
                     continue;
                 }
-                const result = await this.runProcess(command, args, commandLine, packet, packetFile, provider, workerPrompt);
                 // Worker succeeded — return immediately.
                 if (result.exit_code === 0) {
-                    return result;
+                    return {
+                        ...result,
+                        router_evidence: routerEvidence,
+                        provider_attempts: providerAttempts,
+                    };
                 }
-                // If the worker wrote a result file it actually ran (and failed) — don't
-                // retry with another provider; that would double-dispatch the same child.
                 const resultFilePath = (0, worker_packet_js_1.isWorkerPacket)(packet) ? packet.result_file_contract?.result_file : undefined;
-                if (resultFilePath && node_fs_1.default.existsSync(resultFilePath)) {
-                    return result;
+                const workerStarted = hasWorkerExecutionEvidence(packet, resultFilePath);
+                if (workerStarted) {
+                    return {
+                        ...result,
+                        failure_origin: "worker-execution",
+                        failure_category: "worker-failure",
+                        fallback_eligible: false,
+                        router_evidence: routerEvidence,
+                        provider_attempts: providerAttempts,
+                    };
                 }
-                // Worker did not start (wrong args, command not found, etc.) — try next.
-                lastResult = result;
+                const category = isQuotaExhaustedSignal(result.stderr, result.stdout, result.summary)
+                    ? "quota-exhausted"
+                    : "provider-unavailable";
+                const classified = {
+                    ...result,
+                    pre_dispatch_failure: true,
+                    failure_origin: "provider-launch",
+                    failure_category: category,
+                    fallback_eligible: true,
+                    router_evidence: routerEvidence,
+                };
+                providerAttempts.push({
+                    provider,
+                    failure_origin: "provider-launch",
+                    failure_category: category,
+                    pre_dispatch_failure: true,
+                    fallback_eligible: true,
+                    message: result.stderr ?? result.summary,
+                });
+                lastResult = classified;
             }
-            return lastResult ?? {
+            const exhausted = lastResult ?? {
                 exit_code: 1,
                 provider_used: primaryProvider,
                 command_run: '',
                 stderr: 'All configured providers exhausted without starting a worker',
+                pre_dispatch_failure: true,
+                failure_origin: "provider-launch",
+                failure_category: "provider-unavailable",
+                fallback_eligible: false,
+                router_evidence: routerEvidence,
+                provider_attempts: providerAttempts,
+            };
+            return {
+                ...exhausted,
+                // All providers have been exhausted — no further fallback is possible.
+                fallback_eligible: false,
+                router_evidence: exhausted.router_evidence ?? routerEvidence,
+                provider_attempts: exhausted.provider_attempts ?? providerAttempts,
             };
         }
         finally {
@@ -318,9 +501,7 @@ class TerminalCliAdapter {
             // that return minimal status objects instead of proper CompactReturn structs.
             const effectiveStatus = (exitCode === 0 && isValidCompactReturn) ? "success" : "failure";
             const sealedResult = {
-                ...normalized,
                 run_id: packet.run_id,
-                cluster_id: packet.cluster_id,
                 child_id: String(normalized["child_id"] ?? packet.active_child),
                 status: effectiveStatus,
                 commit: typeof normalized["commit"] === "string"
@@ -336,7 +517,6 @@ class TerminalCliAdapter {
                             ? normalized["error_message"]
                             : stdout || summary)
                     : undefined,
-                ...(compactReturnErrors.length > 0 ? { compact_return_errors: compactReturnErrors } : {}),
             };
             node_fs_1.default.mkdirSync(node_path_1.default.dirname(resultFile), { recursive: true });
             node_fs_1.default.writeFileSync(resultFile, JSON.stringify(sealedResult, null, 2), "utf-8");