@lsctech/polaris 0.5.0 → 0.5.3

package/dist/config/validator.js

@@ -79,6 +79,33 @@ const SUPPORTED_LIFECYCLE_STATES = [
     "cancelled",
     "no_status_change",
 ];
+const SUPPORTED_QC_TRIGGERS = ["pr", "completed-cluster", "child"];
+const SUPPORTED_QC_SEVERITIES = ["critical", "high", "medium", "low", "info"];
+const SUPPORTED_QC_PROVIDER_MODES = ["local", "pr", "metrics-import"];
+const SUPPORTED_QC_AUTO_FIX_POLICIES = ["disabled", "dry-run", "apply"];
+const SUPPORTED_QC_REPAIR_ROUTING_POLICIES = ["block", "route", "follow-up", "log"];
+const SUPPORTED_QC_PROVIDER_CAPABILITIES = [
+    "diff-review",
+    "pr-review",
+    "result-parsing",
+    "auto-fix",
+    "metrics-import",
+];
+const SEVERITY_ORDER = ["info", "low", "medium", "high", "critical"];
+function severityIndex(severity) {
+    return SEVERITY_ORDER.indexOf(severity);
+}
+function hasEligibleQcAutoFixProvider(providers) {
+    if (!isPlainObject(providers))
+        return false;
+    return Object.values(providers).some((providerConfig) => {
+        if (!isPlainObject(providerConfig))
+            return false;
+        const capabilities = providerConfig.capabilities;
+        const eligible = providerConfig.autoFixEligible;
+        return eligible === true && Array.isArray(capabilities) && capabilities.includes("auto-fix");
+    });
+}
 function validateConfig(config) {
     const result = { valid: true, errors: [], warnings: [] };
     if (!isPlainObject(config)) {
@@ -797,6 +824,222 @@ function validateConfig(config) {
             }
         }
     }
+    // qc
+    if ("qc" in config && config.qc !== undefined) {
+        if (!isPlainObject(config.qc)) {
+            result.valid = false;
+            result.errors.push("qc must be an object");
+        }
+        else {
+            if ("enabled" in config.qc && config.qc.enabled !== undefined) {
+                if (!isBoolean(config.qc.enabled)) {
+                    result.valid = false;
+                    result.errors.push("qc.enabled must be a boolean");
+                }
+            }
+            if ("defaultTrigger" in config.qc && config.qc.defaultTrigger !== undefined) {
+                if (!isString(config.qc.defaultTrigger) ||
+                    !SUPPORTED_QC_TRIGGERS.includes(config.qc.defaultTrigger)) {
+                    result.valid = false;
+                    result.errors.push('qc.defaultTrigger must be one of "pr", "completed-cluster", "child"');
+                }
+            }
+            const providers = isPlainObject(config.qc.providers) ? config.qc.providers : null;
+            if ("providers" in config.qc && config.qc.providers !== undefined) {
+                if (!isPlainObject(config.qc.providers)) {
+                    result.valid = false;
+                    result.errors.push("qc.providers must be a plain object");
+                }
+                else {
+                    for (const [providerName, providerConfig] of Object.entries(config.qc.providers)) {
+                        if (!isPlainObject(providerConfig)) {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName} must be a plain object`);
+                            continue;
+                        }
+                        if ("name" in providerConfig && providerConfig.name !== undefined && !isString(providerConfig.name)) {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName}.name must be a string`);
+                        }
+                        if ("mode" in providerConfig && providerConfig.mode !== undefined) {
+                            if (!isString(providerConfig.mode) ||
+                                !SUPPORTED_QC_PROVIDER_MODES.includes(providerConfig.mode)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.mode must be one of local, pr, metrics-import`);
+                            }
+                        }
+                        else {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName}.mode is required`);
+                        }
+                        if ("capabilities" in providerConfig && providerConfig.capabilities !== undefined) {
+                            if (!Array.isArray(providerConfig.capabilities) ||
+                                !providerConfig.capabilities.every((capability) => isString(capability) &&
+                                    SUPPORTED_QC_PROVIDER_CAPABILITIES.includes(capability))) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.capabilities must contain only: diff-review, pr-review, result-parsing, auto-fix, metrics-import`);
+                            }
+                        }
+                        if ("trigger" in providerConfig && providerConfig.trigger !== undefined) {
+                            if (!isString(providerConfig.trigger) ||
+                                !SUPPORTED_QC_TRIGGERS.includes(providerConfig.trigger)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.trigger must be one of pr, completed-cluster, child`);
+                            }
+                        }
+                        if ("autoFixEligible" in providerConfig && providerConfig.autoFixEligible !== undefined) {
+                            if (!isBoolean(providerConfig.autoFixEligible)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.autoFixEligible must be a boolean`);
+                            }
+                        }
+                        if ("severityMapping" in providerConfig && providerConfig.severityMapping !== undefined) {
+                            if (!isPlainObject(providerConfig.severityMapping)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.severityMapping must be a plain object`);
+                            }
+                            else {
+                                for (const [label, severity] of Object.entries(providerConfig.severityMapping)) {
+                                    if (!isString(severity) ||
+                                        !SUPPORTED_QC_SEVERITIES.includes(severity)) {
+                                        result.valid = false;
+                                        result.errors.push(`qc.providers.${providerName}.severityMapping.${label} must be one of critical, high, medium, low, info`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if ("severityThresholds" in config.qc && config.qc.severityThresholds !== undefined) {
+                if (!isPlainObject(config.qc.severityThresholds)) {
+                    result.valid = false;
+                    result.errors.push("qc.severityThresholds must be a plain object");
+                }
+                else {
+                    const thresholds = config.qc.severityThresholds;
+                    for (const key of ["block", "repair", "followUp"]) {
+                        if (key in thresholds && thresholds[key] !== undefined) {
+                            if (!isString(thresholds[key]) ||
+                                !SUPPORTED_QC_SEVERITIES.includes(thresholds[key])) {
+                                result.valid = false;
+                                result.errors.push(`qc.severityThresholds.${key} must be one of critical, high, medium, low, info`);
+                            }
+                        }
+                    }
+                    if (isString(thresholds.block) &&
+                        SUPPORTED_QC_SEVERITIES.includes(thresholds.block) &&
+                        isString(thresholds.repair) &&
+                        SUPPORTED_QC_SEVERITIES.includes(thresholds.repair) &&
+                        severityIndex(thresholds.block) < severityIndex(thresholds.repair)) {
+                        result.valid = false;
+                        result.errors.push("qc.severityThresholds.repair must be at or below qc.severityThresholds.block severity");
+                    }
+                    if (isString(thresholds.repair) &&
+                        SUPPORTED_QC_SEVERITIES.includes(thresholds.repair) &&
+                        isString(thresholds.followUp) &&
+                        SUPPORTED_QC_SEVERITIES.includes(thresholds.followUp) &&
+                        severityIndex(thresholds.repair) < severityIndex(thresholds.followUp)) {
+                        result.valid = false;
+                        result.errors.push("qc.severityThresholds.followUp must be at or below qc.severityThresholds.repair severity");
+                    }
+                }
+            }
+            if ("autoFix" in config.qc && config.qc.autoFix !== undefined) {
+                if (!isString(config.qc.autoFix) ||
+                    !SUPPORTED_QC_AUTO_FIX_POLICIES.includes(config.qc.autoFix)) {
+                    result.valid = false;
+                    result.errors.push('qc.autoFix must be one of "disabled", "dry-run", "apply"');
+                }
+            }
+            if ("repairRouting" in config.qc && config.qc.repairRouting !== undefined) {
+                if (!isString(config.qc.repairRouting) ||
+                    !SUPPORTED_QC_REPAIR_ROUTING_POLICIES.includes(config.qc.repairRouting)) {
+                    result.valid = false;
+                    result.errors.push('qc.repairRouting must be one of "block", "route", "follow-up", "log"');
+                }
+            }
+            if ("artifactRetention" in config.qc && config.qc.artifactRetention !== undefined) {
+                if (!isPlainObject(config.qc.artifactRetention)) {
+                    result.valid = false;
+                    result.errors.push("qc.artifactRetention must be a plain object");
+                }
+                else {
+                    const retention = config.qc.artifactRetention;
+                    if ("retainRawOutput" in retention && retention.retainRawOutput !== undefined) {
+                        if (!isBoolean(retention.retainRawOutput)) {
+                            result.valid = false;
+                            result.errors.push("qc.artifactRetention.retainRawOutput must be a boolean");
+                        }
+                    }
+                    if ("maxRuns" in retention && retention.maxRuns !== undefined) {
+                        if (!isPositiveInteger(retention.maxRuns)) {
+                            result.valid = false;
+                            result.errors.push("qc.artifactRetention.maxRuns must be a positive integer");
+                        }
+                    }
+                }
+            }
+            if ("routes" in config.qc && config.qc.routes !== undefined) {
+                if (!isPlainObject(config.qc.routes)) {
+                    result.valid = false;
+                    result.errors.push("qc.routes must be a plain object");
+                }
+                else {
+                    for (const [routeName, routePolicy] of Object.entries(config.qc.routes)) {
+                        if (!isPlainObject(routePolicy)) {
+                            result.valid = false;
+                            result.errors.push(`qc.routes.${routeName} must be a plain object`);
+                            continue;
+                        }
+                        if ("childLevel" in routePolicy && routePolicy.childLevel !== undefined) {
+                            if (!isBoolean(routePolicy.childLevel)) {
+                                result.valid = false;
+                                result.errors.push(`qc.routes.${routeName}.childLevel must be a boolean`);
+                            }
+                        }
+                        if ("blockThreshold" in routePolicy && routePolicy.blockThreshold !== undefined) {
+                            if (!isString(routePolicy.blockThreshold) ||
+                                !SUPPORTED_QC_SEVERITIES.includes(routePolicy.blockThreshold)) {
+                                result.valid = false;
+                                result.errors.push(`qc.routes.${routeName}.blockThreshold must be one of critical, high, medium, low, info`);
+                            }
+                        }
+                        if ("autoFix" in routePolicy && routePolicy.autoFix !== undefined) {
+                            if (!isString(routePolicy.autoFix) ||
+                                !SUPPORTED_QC_AUTO_FIX_POLICIES.includes(routePolicy.autoFix)) {
+                                result.valid = false;
+                                result.errors.push(`qc.routes.${routeName}.autoFix must be one of disabled, dry-run, apply`);
+                            }
+                            if (routePolicy.autoFix === "apply" && !hasEligibleQcAutoFixProvider(providers)) {
+                                result.valid = false;
+                                result.errors.push(`qc.routes.${routeName}.autoFix "apply" requires at least one provider with capability "auto-fix" and autoFixEligible true`);
+                            }
+                        }
+                    }
+                }
+            }
+            // Unsafe auto-fix policy combinations
+            const autoFix = isString(config.qc.autoFix)
+                ? config.qc.autoFix
+                : "disabled";
+            const blockSeverity = isPlainObject(config.qc.severityThresholds)
+                ? config.qc.severityThresholds.block
+                : undefined;
+            if (autoFix === "apply") {
+                if (!hasEligibleQcAutoFixProvider(providers)) {
+                    result.valid = false;
+                    result.errors.push('qc.autoFix "apply" requires at least one provider with capability "auto-fix" and autoFixEligible true');
+                }
+                if (isString(blockSeverity) &&
+                    SUPPORTED_QC_SEVERITIES.includes(blockSeverity) &&
+                    severityIndex(blockSeverity) <= severityIndex("medium")) {
+                    result.valid = false;
+                    result.errors.push('qc.autoFix "apply" is unsafe when qc.severityThresholds.block is medium or lower');
+                }
+            }
+        }
+    }
     // unknown top-level fields -> warnings
     const knownKeys = new Set([
         "version",
@@ -812,6 +1055,7 @@ function validateConfig(config) {
         "providers",
         "budget",
         "compact",
+        "qc",
     ]);
     for (const key of Object.keys(config)) {
         if (!knownKeys.has(key)) {

package/dist/finalize/artifact-policy.js

@@ -38,7 +38,8 @@ function isPromotedClusterArtifact(relativePath, activeClusterId) {
     return (suffix === "clusters.json"
         || suffix === "cluster-state.json"
         || suffix.startsWith("packets/")
-        || suffix.startsWith("results/"));
+        || suffix.startsWith("results/")
+        || suffix.startsWith("qc/"));
 }
 function classifyArtifactPath(filePath, activeClusterId) {
     const relativePath = normalizeArtifactPath(filePath);
@@ -132,6 +133,7 @@ function getArtifactPromotionPolicy(activeClusterId) {
             `${activeClusterPrefix}cluster-state.json`,
             `${activeClusterPrefix}packets/**`,
             `${activeClusterPrefix}results/**`,
+            `${activeClusterPrefix}qc/**`,
             PROMOTED_RUN_LEDGER,
             `${PROMOTED_COGNITION_ARCHIVE_PREFIX}**`,
             `${PROMOTED_MAP_PREFIX}**`,

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/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

@@ -501,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"
@@ -519,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");

package/dist/loop/dispatch-boundary.js

@@ -40,8 +40,10 @@ exports.validateTransition = validateTransition;
 exports.initialDispatchBoundary = initialDispatchBoundary;
 exports.advanceDispatchEpoch = advanceDispatchEpoch;
 exports.advanceContinueEpoch = advanceContinueEpoch;
+exports.assertChildQcSelectionAllowed = assertChildQcSelectionAllowed;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const triggers_js_1 = require("../qc/triggers.js");
 // ──────────────────────────────────────────────────────────────────────────────
 // Error constants
 // ──────────────────────────────────────────────────────────────────────────────
@@ -333,3 +335,30 @@ function advanceContinueEpoch(current) {
         last_dispatched_child: current.last_dispatched_child,
     };
 }
+/**
+ * Validate that a child-level QC trigger is only selected when permitted.
+ *
+ * Child-level QC is opt-in: high-risk scope, route policy, or explicit operator
+ * request. If a packet carries child-level QC without meeting one of those
+ * conditions, the dispatch boundary is violated.
+ */
+function assertChildQcSelectionAllowed(state, childId, config, allowedScope, labels, telemetryFile) {
+    const meta = state.open_children_meta?.[childId];
+    if (meta?.qc_trigger !== "child")
+        return;
+    const routeName = childId; // route-specific overrides are keyed by child/route identifier
+    if ((0, triggers_js_1.isChildQcSelected)(config, childId, allowedScope, labels, routeName)) {
+        return;
+    }
+    const reason = `Child-level QC selected for ${childId} but no opt-in condition is met (high-risk scope, route policy, or "qc-child" label)`;
+    appendDispatchViolationEvent(telemetryFile, {
+        event: "illegal-state-transition",
+        run_id: state.run_id,
+        child_id: childId,
+        from_state: getMachineState(state),
+        to_state: "dispatched",
+        reason,
+        timestamp: new Date().toISOString(),
+    });
+    throw new Error(reason);
+}