@lsctech/polaris 0.5.7 → 0.5.9

package/dist/finalize/index.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStateFileAuthority = validateStateFileAuthority;
+exports.validateQcRepairLoopGate = validateQcRepairLoopGate;
+exports.warnOnMissingQcArtifacts = warnOnMissingQcArtifacts;
+exports.validateAuthoritativeChildState = validateAuthoritativeChildState;
 exports.runFinalize = runFinalize;
 exports.createFinalizeCommand = createFinalizeCommand;
 const commander_1 = require("commander");
@@ -12,6 +16,7 @@ const checkpoint_js_1 = require("../loop/checkpoint.js");
 const artifact_policy_js_1 = require("./artifact-policy.js");
 const git_custody_js_1 = require("../loop/git-custody.js");
 const store_js_1 = require("../cluster-state/store.js");
+const artifacts_js_1 = require("../qc/artifacts.js");
 const canon_check_js_1 = require("../smartdocs-engine/canon-check.js");
 const _01_map_update_js_1 = require("./steps/01-map-update.js");
 const _02_map_validate_js_1 = require("./steps/02-map-validate.js");
@@ -29,6 +34,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 medic_gate_js_1 = require("./medic-gate.js");
 const index_js_2 = require("../qc/index.js");
 function getBranch(repoRoot) {
     try {
@@ -85,6 +91,60 @@ function validateStateBranchMatchesGitBranch(stateBranch, branch) {
         process.exit(1);
     }
 }
+const CLUSTER_STATE_FILE_PATTERN = /[\\/]\.polaris[\\/]clusters[\\/][^\\/]+[\\/]state\.json$/;
+function isClusterStateSnapshotFile(filePath) {
+    return CLUSTER_STATE_FILE_PATTERN.test(filePath.replace(/\\/g, "/"));
+}
+function computeRunStateFreshness(state) {
+    const s = state;
+    let score = 0;
+    score += (s.completed_children?.length ?? 0) * 10;
+    if (s.status === "complete")
+        score += 50;
+    if (s.pr_url)
+        score += 30;
+    if (s.qc_repair_loop?.terminal_outcome)
+        score += 40;
+    score += (s.dispatch_boundary?.dispatch_epoch ?? 0) * 5;
+    score += (s.context_budget?.children_completed ?? 0) * 2;
+    return score;
+}
+/**
+ * Refuse to use a promoted cluster state snapshot when the authoritative
+ * taskchain current-state.json is newer. Cluster snapshots under
+ * `.polaris/clusters/<id>/state.json` are secondary; the taskchain state
+ * owned by the parent loop is authoritative.
+ */
+function validateStateFileAuthority(stateFile, state, repoRoot) {
+    if (!isClusterStateSnapshotFile(stateFile)) {
+        return;
+    }
+    const taskchainStateFile = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json");
+    if (!(0, node_fs_1.existsSync)(taskchainStateFile)) {
+        return;
+    }
+    let taskchainState;
+    try {
+        taskchainState = (0, checkpoint_js_1.readState)(taskchainStateFile);
+    }
+    catch {
+        return;
+    }
+    if (taskchainState.run_id !== state.run_id ||
+        taskchainState.cluster_id !== state.cluster_id) {
+        return;
+    }
+    const taskchainFreshness = computeRunStateFreshness(taskchainState);
+    const snapshotFreshness = computeRunStateFreshness(state);
+    if (taskchainFreshness > snapshotFreshness) {
+        process.stderr.write(`finalize aborted: cluster state snapshot is stale.\n` +
+            `  Snapshot: ${stateFile}\n` +
+            `  Authoritative taskchain state: ${taskchainStateFile}\n` +
+            `The taskchain current-state.json is newer; use it instead, or ` +
+            `update the cluster snapshot before finalizing.\n`);
+        process.exit(1);
+    }
+}
 /**
  * Check that the Closeout Librarian has run and its result passes the gate.
  * Returns null if finalize may proceed; returns a human-readable blocker string if not.
@@ -183,8 +243,106 @@ 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");
 }
+// ── QC repair-loop terminal state gate ────────────────────────────────────────
+/**
+ * Trusted QC repair-loop terminal outcomes that allow finalize to proceed.
+ * "pass" = QC rerun passed; "qc-disabled" = QC was off; "no-repairable" = no
+ * findings routable to repair workers (follow-up-only or already resolved).
+ */
+const TRUSTED_QC_REPAIR_OUTCOMES = new Set(["pass", "qc-disabled", "no-repairable"]);
+/**
+ * Validate QC repair-loop terminal state when QC is enabled and repair routing
+ * is active. Returns null when finalize may proceed; returns a human-readable
+ * blocker string otherwise.
+ */
+function validateQcRepairLoopGate(state, config) {
+    // Gate only applies when QC is enabled
+    if (!config.enabled)
+        return null;
+    // Gate only applies when repair routing is active (not "log" or "block")
+    const repairRouting = config.repairRouting ?? "route";
+    if (repairRouting !== "route" && repairRouting !== "follow-up")
+        return null;
+    const repairLoop = state.qc_repair_loop;
+    // No repair-loop state at all — the completed-cluster QC trigger ran but
+    // never entered the repair loop. This is a gap: finalize should not proceed.
+    if (!repairLoop) {
+        return ("QC is enabled with repair routing active, but no qc_repair_loop state " +
+            "was found in the run state. The parent loop must run the QC repair loop " +
+            "before finalize can proceed.");
+    }
+    const outcome = repairLoop.terminal_outcome;
+    if (outcome === null || outcome === undefined) {
+        return ("QC repair loop is still in-flight (terminal_outcome is null). " +
+            "Finalize cannot proceed until the repair loop reaches a terminal state.");
+    }
+    if (TRUSTED_QC_REPAIR_OUTCOMES.has(outcome))
+        return null;
+    return (`QC repair loop terminated with untrusted outcome: "${outcome}". ` +
+        `Only ${Array.from(TRUSTED_QC_REPAIR_OUTCOMES).join(", ")} outcomes allow finalize to proceed. ` +
+        `Resolve the repair loop before re-running finalize.`);
+}
+// ── Authoritative completed-child state cross-check ───────────────────────────
+function warnOnMissingQcArtifacts(clusterState, repoRoot) {
+    if (!clusterState)
+        return;
+    const validation = (0, artifacts_js_1.validateQcArtifactPointers)(clusterState.qc_runs);
+    if (validation.ok)
+        return;
+    for (const missing of validation.missing) {
+        console.warn(`finalize warning: cluster-state QC pointer references missing artifact: ${missing}`);
+    }
+    for (const unavailable of validation.unavailable) {
+        console.warn(`finalize warning: QC audit artifact unavailable: ${unavailable}`);
+    }
+}
+/**
+ * Cross-check completed children in the loop state against the cluster-state
+ * child_states. Returns a diagnostic result — when `ok` is false, finalize
+ * should refuse PR creation.
+ */
+function validateAuthoritativeChildState(state, repoRoot) {
+    const clusterState = (0, store_js_1.readClusterStateSync)(state.cluster_id, repoRoot);
+    const stateCount = state.completed_children.length;
+    // No cluster state available — backward-compat: trust the loop state.
+    if (!clusterState) {
+        return { ok: true, authoritativeCount: stateCount, stateCount };
+    }
+    const childStates = clusterState.child_states;
+    // No child_states array in cluster state — backward-compat: trust the loop state.
+    // This covers legacy cluster-state files that don't track individual child lifecycle.
+    if (!childStates || childStates.length === 0) {
+        return { ok: true, authoritativeCount: stateCount, stateCount };
+    }
+    const doneChildren = childStates.filter((c) => c.status === "done" || c.status === "reviewed" || c.status === "finalized");
+    const authoritativeCount = doneChildren.length;
+    // When cluster-state has tracked children but zero are done while loop state
+    // claims completions, the cluster state file is stale or was never updated.
+    if (authoritativeCount === 0 && stateCount > 0) {
+        return {
+            ok: false,
+            authoritativeCount,
+            stateCount,
+            reason: `Stale cluster state: cluster-state.json has 0 done children but ` +
+                `loop state claims ${stateCount} completed. ` +
+                `The cluster state file was never updated by worker completions.`,
+        };
+    }
+    // Significant mismatch: cluster-state has fewer done children than loop state
+    if (authoritativeCount < stateCount) {
+        return {
+            ok: false,
+            authoritativeCount,
+            stateCount,
+            reason: `Completed-child count mismatch: cluster-state has ${authoritativeCount} done ` +
+                `children but loop state has ${stateCount}. ` +
+                `The cluster state may be stale or child completions were not recorded properly.`,
+        };
+    }
+    return { ok: true, authoritativeCount, stateCount };
+}
 async function runQcGate(options) {
-    const { config, state, repoRoot, branch, trigger, prUrl, stepLabel } = options;
+    const { config, state, repoRoot, branch, baseRef, trigger, prUrl, stepLabel } = options;
     const registry = (0, index_js_2.createQcRegistry)(config);
     const result = await (0, index_js_2.runQcAtTrigger)({
         config,
@@ -195,6 +353,7 @@ async function runQcGate(options) {
         runId: state.run_id,
         clusterId: state.cluster_id,
         branch,
+        baseRef,
         telemetryFile: resolveQcTelemetryFile(state, repoRoot),
         state,
     });
@@ -210,7 +369,7 @@ async function runQcGate(options) {
     process.exit(1);
 }
 async function runFinalize(options) {
-    const { repoRoot, stateFile, dryRun, skipDelivery, skipLibrarian } = options;
+    const { repoRoot, stateFile, dryRun, skipDelivery, skipLibrarian, bypassMedicReason } = options;
     const config = (0, loader_js_1.loadConfig)(repoRoot);
     // Step 1: polaris map update --changed
     console.log("[1/14] Updating map..."); // Step count updated
@@ -236,6 +395,7 @@ async function runFinalize(options) {
     validateStateFilePath(stateFile);
     validateClusterIdMatchesBranch(state.cluster_id, branch);
     validateStateBranchMatchesGitBranch(state.branch, branch);
+    validateStateFileAuthority(stateFile, state, repoRoot);
     // Step 4: Run configured checks
     const checks = config.finalize?.runChecks ?? [];
     if (checks.length > 0) {
@@ -322,6 +482,7 @@ async function runFinalize(options) {
     // loop.allowBranchDivergence is true (direct-main mode).
     {
         const clusterState = (0, store_js_1.readClusterStateSync)(state.cluster_id, repoRoot);
+        warnOnMissingQcArtifacts(clusterState, repoRoot);
         const baseBranch = clusterState?.base_branch;
         const deliveryBranch = clusterState?.delivery_branch;
         const directMainMode = config.loop?.allowBranchDivergence === true;
@@ -389,14 +550,60 @@ async function runFinalize(options) {
     }
     // Step 5.8: Completed-cluster QC trigger (when configured)
     // Runs after all authoritative gates and before final commit/delivery.
+    const clusterStateForQc = (0, store_js_1.readClusterStateSync)(state.cluster_id, repoRoot);
+    const qcBaseRef = clusterStateForQc?.base_branch ??
+        config.finalize?.targetBranch ??
+        "main";
     await runQcGate({
         config: config.qc,
         state,
         repoRoot,
         branch,
+        baseRef: qcBaseRef,
         trigger: "completed-cluster",
         stepLabel: "[5.8/14]",
     });
+    // Step 5.9: QC repair-loop terminal state gate
+    // When QC is enabled and repair routing is active, require a trusted
+    // terminal outcome from the QC repair loop before allowing PR creation.
+    {
+        const repairLoopBlocker = validateQcRepairLoopGate(state, config.qc);
+        if (repairLoopBlocker) {
+            process.stderr.write(`finalize aborted: QC repair-loop gate failed.\n${repairLoopBlocker}\n`);
+            process.exit(1);
+        }
+    }
+    // Step 5.10: Authoritative completed-child state cross-check
+    // Verify that the completed children claimed by the loop state match
+    // the cluster-state child_states. Blocks on stale or inconsistent state.
+    const authChildResult = validateAuthoritativeChildState(state, repoRoot);
+    if (!authChildResult.ok) {
+        process.stderr.write(`finalize aborted: authoritative child state mismatch.\n${authChildResult.reason}\n`);
+        process.exit(1);
+    }
+    // Step 5.11: Run-health Medic gate
+    // After all worker/QC evidence is available and before any final commit, push,
+    // PR creation, or tracker update, require a Medic consultation decision for any
+    // run that recorded health symptoms.
+    {
+        console.log("[5.11/14] Checking run-health Medic gate...");
+        const bypassPolicy = config.finalize?.medic?.bypassPolicy ?? "none";
+        if (dryRun && bypassMedicReason && bypassPolicy === "cli") {
+            console.warn(`Dry run: would write Medic bypass to run-health report for run "${state.run_id}" (reason: ${bypassMedicReason}).`);
+        }
+        const medicBlocker = (0, medic_gate_js_1.validateMedicGate)({
+            runId: state.run_id,
+            repoRoot,
+            bypassReason: bypassMedicReason,
+            bypassPolicy,
+            dryRun,
+        });
+        if (medicBlocker) {
+            process.stderr.write(`finalize aborted: run-health Medic gate failed.\n${medicBlocker}\n`);
+            process.exit(1);
+        }
+        console.log("[5.11/14] Run-health Medic gate passed.");
+    }
     // Step 6: Tracker Reconciliation
     // LinearAdapter is sync-in only; only McpBridgeAdapter supports full reconciliation.
     const trackerType = config.tracker?.adapter;
@@ -465,7 +672,7 @@ async function runFinalize(options) {
     // Step 10: Create draft PR
     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);
+    const prUrl = (0, _08_create_pr_js_1.stepCreatePr)(repoRoot, branch, state, prDraft, authChildResult.authoritativeCount);
     // Step 10.5: PR-required QC trigger (when configured)
     // Providers that require a PR URL run here after the PR is created.
     await runQcGate({
@@ -480,6 +687,17 @@ async function runFinalize(options) {
     // 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);
+    // Promote the authoritative run state into the cluster snapshot so that
+    // `.polaris/clusters/<id>/state.json` preserves completed children, the
+    // dispatch boundary, QC repair-loop terminal state, and the PR URL.
+    try {
+        const clusterStateSnapshotPath = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", state.cluster_id, "state.json");
+        (0, checkpoint_js_1.writeStateAtomic)(clusterStateSnapshotPath, state);
+    }
+    catch (snapshotError) {
+        process.stderr.write(`[11/14] WARNING: Failed to write cluster state snapshot: ${snapshotError instanceof Error ? snapshotError.message : String(snapshotError)}\n`);
+        process.stderr.write(`Delivery will proceed, but cluster state snapshot at .polaris/clusters/${state.cluster_id}/state.json may be incomplete.\n`);
+    }
     // Step 12: Append JSONL events
     console.log("[12/14] Appending JSONL events...");
     const artifactDir = state.artifact_dir ?? (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run");
@@ -489,7 +707,7 @@ async function runFinalize(options) {
     console.log("[13/14] Updating Linear...");
     const linearEnabled = config.tracker?.linear?.enabled ?? false;
     const lifecyclePolicy = config.tracker?.lifecyclePolicy;
-    await (0, _11_update_linear_js_1.stepUpdateLinear)(state, branch, prUrl, true, linearEnabled, state.cluster_id, lifecyclePolicy);
+    await (0, _11_update_linear_js_1.stepUpdateLinear)(state, branch, prUrl, true, linearEnabled, state.cluster_id, lifecyclePolicy, authChildResult.authoritativeCount);
     // Step 14: Archive run snapshot
     console.log("[14/14] Archiving run snapshot...");
     (0, _12_archive_js_1.stepArchive)(repoRoot, state, resolvedStateFile, reportPath);
@@ -521,11 +739,19 @@ function createFinalizeCommand(handlers = {}) {
         .option("--dry-run", "non-mutating preview: validate and generate report without committing or pushing")
         .option("--skip-delivery", "perform local finalize steps only; skip push/PR/Linear/archive")
         .option("--skip-librarian", "skip the Closeout Librarian gate (backward compatibility only)")
+        .option("--bypass-medic <reason>", "bypass the run-health Medic gate (requires finalize.medic.bypassPolicy=cli)")
         .action((options) => {
         const repoRoot = options.repoRoot;
         const stateFile = options.stateFile ??
             (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json");
-        finalizeHandler({ repoRoot, stateFile, dryRun: options.dryRun, skipDelivery: options.skipDelivery, skipLibrarian: options.skipLibrarian })
+        finalizeHandler({
+            repoRoot,
+            stateFile,
+            dryRun: options.dryRun,
+            skipDelivery: options.skipDelivery,
+            skipLibrarian: options.skipLibrarian,
+            bypassMedicReason: options.bypassMedic,
+        })
             .catch((err) => {
             process.stderr.write(`finalize error: ${err instanceof Error ? err.message : String(err)}\n`);
             process.exit(1);

package/dist/finalize/linear.js

@@ -97,6 +97,7 @@ async function findReviewState(issueId, apiKey) {
 // Comment body builder
 // ──────────────────────────────────────────────────────────────────────────────
 function buildCommentBody(opts) {
+    const childCount = opts.authoritativeChildCount ?? opts.state.completed_children.length;
     const lines = [
         `**polaris finalize complete** — run \`${opts.state.run_id}\``,
         ``,
@@ -104,7 +105,7 @@ function buildCommentBody(opts) {
         `|---|---|`,
         `| Branch | \`${opts.branch}\` |`,
         `| PR | ${opts.prUrl} |`,
-        `| Children completed | ${opts.state.completed_children.length} |`,
+        `| Children completed | ${childCount} |`,
         `| Map validation | ${opts.validationPassed ? "✓ passed" : "✗ failed"} |`,
     ];
     if (opts.reviewStateMissing) {
@@ -117,8 +118,8 @@ function buildCommentBody(opts) {
 // ──────────────────────────────────────────────────────────────────────────────
 /** Posts a finalize-complete comment without attempting a state transition. */
 async function postLinearComment(options) {
-    const { issueId, state, branch, prUrl, validationPassed, apiKey } = options;
-    const body = buildCommentBody({ state, branch, prUrl, validationPassed, reviewStateMissing: false });
+    const { issueId, state, branch, prUrl, validationPassed, apiKey, authoritativeChildCount } = options;
+    const body = buildCommentBody({ state, branch, prUrl, validationPassed, reviewStateMissing: false, authoritativeChildCount });
     const data = await linearGraphQL(`mutation CreateComment($issueId: String!, $body: String!) {
       commentCreate(input: { issueId: $issueId, body: $body }) { success }
     }`, { issueId, body }, apiKey);
@@ -140,7 +141,7 @@ async function postLinearComment(options) {
  * state ID. The assertNotDoneState guard enforces this at runtime.
  */
 async function updateLinearIssueAfterFinalize(options) {
-    const { issueId, state, branch, prUrl, validationPassed, apiKey, lifecyclePolicy } = options;
+    const { issueId, state, branch, prUrl, validationPassed, apiKey, lifecyclePolicy, authoritativeChildCount } = options;
     // Resolve lifecycle transition from policy
     const lifecycleTransition = (0, lifecycle_policy_js_1.resolveLifecycleTransition)("parent-all-children-complete", lifecyclePolicy);
     // If policy says skip, skip the state transition entirely
@@ -152,6 +153,7 @@ async function updateLinearIssueAfterFinalize(options) {
             prUrl,
             validationPassed,
             reviewStateMissing: false,
+            authoritativeChildCount,
         });
         const commentData = await linearGraphQL(`mutation CreateComment($issueId: String!, $body: String!) {
         commentCreate(input: { issueId: $issueId, body: $body }) { success }
@@ -172,6 +174,7 @@ async function updateLinearIssueAfterFinalize(options) {
             prUrl,
             validationPassed,
             reviewStateMissing: false,
+            authoritativeChildCount,
         });
         const commentData = await linearGraphQL(`mutation CreateComment($issueId: String!, $body: String!) {
         commentCreate(input: { issueId: $issueId, body: $body }) { success }
@@ -205,6 +208,7 @@ async function updateLinearIssueAfterFinalize(options) {
         prUrl,
         validationPassed,
         reviewStateMissing: reviewState === null,
+        authoritativeChildCount,
     });
     const commentData = await linearGraphQL(`mutation CreateComment($issueId: String!, $body: String!) {
       commentCreate(input: { issueId: $issueId, body: $body }) { success }

package/dist/finalize/medic-gate.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMedicGate = validateMedicGate;
+const index_js_1 = require("../run-health/index.js");
+/**
+ * Validates that a run with a run-health report either has a Medic decision or
+ * an explicit, allowed policy bypass. Returns `null` when finalize may proceed;
+ * returns a human-readable blocker string otherwise.
+ *
+ * Fails closed: a report that exists but lacks a Medic decision/bypass blocks
+ * final commit, push, PR creation, and tracker update.
+ */
+function validateMedicGate(options) {
+    const { runId, repoRoot, bypassReason, bypassPolicy = "none", dryRun = false } = options;
+    const reportPath = (0, index_js_1.getRunHealthReportPath)(runId, repoRoot);
+    const report = (0, index_js_1.readRunHealthReport)(runId, repoRoot);
+    // No report means no symptoms were recorded — gate does not apply.
+    if (!report)
+        return null;
+    if ((0, index_js_1.isMedicGateSatisfied)(report))
+        return null;
+    if (bypassReason) {
+        if (bypassPolicy !== "cli") {
+            return (`Run-health report at ${reportPath} requires Medic consultation, but a CLI bypass is not allowed ` +
+                `by finalize.medic.bypassPolicy (current: "${bypassPolicy}").`);
+        }
+        if (!dryRun) {
+            (0, index_js_1.markBypassed)(runId, {
+                reason: bypassReason,
+                bypassed_by: process.env.USER ?? process.env.LOGNAME ?? "operator",
+                bypassed_at: new Date().toISOString(),
+            }, repoRoot);
+        }
+        return null;
+    }
+    const bypassHint = bypassPolicy === "cli"
+        ? `To bypass this gate, use --bypass-medic "<reason>".`
+        : `Bypass is not enabled by finalize.medic.bypassPolicy (current: "${bypassPolicy}").`;
+    return (`Run-health report at ${reportPath} has recorded symptoms and requires a Medic consultation decision ` +
+        `(medic_consult.status "resolved" or "bypassed", or an explicit policy_bypass) before finalize can commit, push, ` +
+        `create a PR, or update the tracker.\n${bypassHint}`);
+}

package/dist/finalize/steps/08-create-pr.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepCreatePr = stepCreatePr;
 const github_js_1 = require("../github.js");
-function stepCreatePr(repoRoot, branch, state, draft) {
-    const prUrl = (0, github_js_1.createDraftPr)({ repoRoot, branch, state, draft });
+function stepCreatePr(repoRoot, branch, state, draft, authoritativeChildCount) {
+    const prUrl = (0, github_js_1.createDraftPr)({ repoRoot, branch, state, draft, authoritativeChildCount });
     console.log(`PR created: ${prUrl}`);
     return prUrl;
 }

package/dist/finalize/steps/11-update-linear.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepUpdateLinear = stepUpdateLinear;
 const linear_js_1 = require("../linear.js");
-async function stepUpdateLinear(state, branch, prUrl, validationPassed, linearEnabled, parentIssueId, lifecyclePolicy) {
+async function stepUpdateLinear(state, branch, prUrl, validationPassed, linearEnabled, parentIssueId, lifecyclePolicy, authoritativeChildCount) {
     if (!linearEnabled) {
         console.log("[11/12] Linear integration disabled — skipping.");
         return;
@@ -17,6 +17,6 @@ async function stepUpdateLinear(state, branch, prUrl, validationPassed, linearEn
         process.stderr.write("Warning: no Linear parent issue ID — skipping Linear update.\n");
         return;
     }
-    await (0, linear_js_1.updateLinearIssueAfterFinalize)({ issueId, state, branch, prUrl, validationPassed, apiKey, lifecyclePolicy });
+    await (0, linear_js_1.updateLinearIssueAfterFinalize)({ issueId, state, branch, prUrl, validationPassed, apiKey, lifecyclePolicy, authoritativeChildCount });
     console.log(`Linear parent ${issueId} updated.`);
 }