@lsctech/polaris 0.5.11 → 0.5.13

package/dist/loop/worker-packet.js

@@ -10,6 +10,39 @@
  * WorkerPacket extends BootstrapPacket so all existing adapters that
  * accept BootstrapPacket transparently accept WorkerPacket.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REPAIR_RETURN_CONTRACT = exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_SYMPTOM_CATEGORIES = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
 exports.roleContextForWorkerRole = roleContextForWorkerRole;
@@ -20,6 +53,7 @@ exports.compileImplPacket = compileImplPacket;
 exports.compileFinalizePacket = compileFinalizePacket;
 exports.compilePreflightPacket = compilePreflightPacket;
 exports.compileRepairWorkerPacket = compileRepairWorkerPacket;
+const path = __importStar(require("node:path"));
 const worker_prompt_js_1 = require("./worker-prompt.js");
 const body_parser_js_1 = require("./body-parser.js");
 const WORKER_ROLE_CONTEXT = {
@@ -172,6 +206,49 @@ function defaultLifecycle(maxConcurrent, cleanupOnExit) {
         cleanup_on_exit: cleanupOnExit,
     };
 }
+/** Derives the adjacent test file path(s) for a single source TypeScript file. */
+function deriveTestPaths(sourcePath) {
+    if (!sourcePath.endsWith('.ts') || sourcePath.endsWith('.test.ts') || sourcePath.endsWith('.d.ts')) {
+        return [];
+    }
+    if (sourcePath.includes('*') || sourcePath.includes('?')) {
+        return [];
+    }
+    const candidates = [sourcePath.replace(/\.ts$/, '.test.ts')];
+    if (sourcePath.endsWith('/index.ts')) {
+        const dir = sourcePath.slice(0, -'/index.ts'.length);
+        const dirName = path.basename(dir);
+        if (dirName) {
+            candidates.push(`${dir}/${dirName}.test.ts`);
+        }
+    }
+    return candidates;
+}
+/**
+ * Expands an allowed scope list with adjacent test paths when the validation
+ * commands include a vitest run. This lets workers touch test files for source
+ * files they are modifying, matching the `*.test.ts` validation commands.
+ */
+function expandScopeWithTestPaths(scope, validationCommands) {
+    const hasVitest = validationCommands.some((cmd) => cmd.includes('vitest'));
+    if (!hasVitest || scope.length === 0)
+        return scope;
+    const testPaths = new Set();
+    for (const item of scope) {
+        for (const testPath of deriveTestPaths(item)) {
+            testPaths.add(testPath);
+        }
+    }
+    if (testPaths.size === 0)
+        return scope;
+    const expanded = [...scope];
+    for (const testPath of testPaths) {
+        if (!expanded.includes(testPath)) {
+            expanded.push(testPath);
+        }
+    }
+    return expanded;
+}
 /**
  * Build a compiled startup worker packet.
  * Startup workers prepare tracker/graph/config/run-state evidence; the parent
@@ -257,6 +334,8 @@ function compileImplPacket(input) {
     const resolvedRequirements = input.issueContext?.key_requirements.length
         ? input.issueContext.key_requirements
         : bodyParsed?.requirements ?? [];
+    // Include adjacent test files when the validation commands indicate a vitest run.
+    const expandedScope = expandScopeWithTestPaths(resolvedScope, resolvedValidation);
     const requirementLines = resolvedRequirements.map((r, i) => `   ${i + 1}. ${r}`);
     const bodyLines = input.issueContext?.body
         ? [`Issue description:\n${input.issueContext.body}`]
@@ -285,7 +364,7 @@ function compileImplPacket(input) {
         stateFile: input.stateFile,
         telemetryFile: input.telemetryFile,
         issueContext: input.issueContext,
-        allowedScope: resolvedScope,
+        allowedScope: expandedScope,
         validationCommands: resolvedValidation,
         mode: promptMode,
         simplicityMode: input.simplicityMode,
@@ -301,7 +380,7 @@ function compileImplPacket(input) {
         instructions: {
             primary_goal: promptResult.prompt,
             steps,
-            allowed_scope: resolvedScope,
+            allowed_scope: expandedScope,
             validation_commands: resolvedValidation,
             issue_context: input.issueContext,
         },

package/dist/map/inference.js

@@ -17,7 +17,10 @@ function inferRoute(filePath, repoRoot, config, knownRoutes, branchName) {
             const subdir = rest.split("/")[0];
             if (subdir && rest.includes("/")) {
                 domain = subdir;
-                route = `${sourceRoot}/${subdir}`;
+                // Route identity follows the file's own containing directory, not just the
+                // top-level domain subdir — otherwise nested folders (e.g. src/runtime/continuation)
+                // incorrectly report the parent domain's route (e.g. src/runtime).
+                route = (0, node_path_1.dirname)(filePath).replace(/\\/g, "/");
                 taskchain = `polaris-${subdir}`;
                 confidence += 0.85;
                 tags.push(subdir);

package/dist/medic/routing-signals.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Polaris routing anomaly → Medic/state-repair signal classification.
+ *
+ * These signals are emitted by the loop/dispatch/runtime boundary and are
+ * reviewed by Medic, not used to mutate routing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyRoutingTelemetryEvent = classifyRoutingTelemetryEvent;
+/**
+ * Map a raw telemetry event to a state-repair review signal.
+ *
+ * Only loop/dispatch boundary events that indicate runtime state-repair work
+ * are classified. The returned signal has occurrences=1 and a single child_id;
+ * consumers (such as SOL scoring) should aggregate by signal name.
+ */
+function classifyRoutingTelemetryEvent(event) {
+    const eventName = event["event"];
+    if (typeof eventName !== "string")
+        return undefined;
+    const childId = typeof event["child_id"] === "string" ? event["child_id"] : undefined;
+    const childIds = childId ? [childId] : [];
+    switch (eventName) {
+        case "sealed-result-read-error":
+            return {
+                signal: "missing-sealed-result",
+                reason: "missing-sealed-result",
+                occurrences: 1,
+                child_ids: childIds,
+            };
+        case "stale-dispatch-aborted":
+            return {
+                signal: "stale-dispatch-abort",
+                reason: "stale-dispatch-abort",
+                occurrences: 1,
+                child_ids: childIds,
+            };
+        case "invalid-inline-attempt":
+            return {
+                signal: "invalid-inline-attempt",
+                reason: "invalid-inline-attempt",
+                occurrences: 1,
+                child_ids: childIds,
+            };
+        case "child-recovery-initiated": {
+            const recoveryReason = event["recovery_reason"];
+            if (recoveryReason === "stale-dispatch") {
+                return {
+                    signal: "stale-dispatch-abort",
+                    reason: "stale-dispatch",
+                    occurrences: 1,
+                    child_ids: childIds,
+                };
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}

package/dist/medic/run-health-consult.js

@@ -114,11 +114,12 @@ function markInProgress(report, chartRef, repoRoot) {
     (0, index_js_1.markMedicDecision)(report.run_id, { status: "in-progress", chartRefs: [chartRef] }, repoRoot);
 }
 function markResolved(report, chartRef, treatmentRefs, outcome, repoRoot) {
+    const success = outcome === "treatment-success" || outcome === "no-treatment-needed";
     (0, index_js_1.markMedicDecision)(report.run_id, {
-        status: "resolved",
+        status: success ? "resolved" : "in-progress",
         chartRefs: [chartRef],
         treatmentPacketRefs: treatmentRefs,
-        resolvedAt: new Date().toISOString(),
+        resolvedAt: success ? new Date().toISOString() : undefined,
         resolutionNotes: `Terminal outcome: ${outcome}`,
     }, repoRoot);
 }
@@ -355,7 +356,7 @@ async function runMedicRunHealthConsult(input) {
                 run_id: packet.run_id,
                 cluster_id: packet.cluster_id,
                 dispatch_id: packet.dispatch_id,
-                status: "resolved",
+                status: "blocked",
                 chart_id: chart.chart_id,
                 decision: "terminal",
                 treatment_packet_refs: allTreatmentRefs,
@@ -371,7 +372,7 @@ async function runMedicRunHealthConsult(input) {
         run_id: packet.run_id,
         cluster_id: packet.cluster_id,
         dispatch_id: packet.dispatch_id,
-        status: "resolved",
+        status: remainingSymptoms.length === 0 ? "resolved" : "blocked",
         chart_id: chart.chart_id,
         decision: "terminal",
         treatment_packet_refs: allTreatmentRefs,

package/dist/medic/treatment-packets.js

@@ -59,7 +59,7 @@ function buildTreatmentPackets(input) {
     return treated.map((symptom) => {
         const packetId = buildTreatmentPacketId(report.run_id, round, symptom.id);
         const dispatchId = (0, node_crypto_1.randomUUID)();
-        const resultFile = (0, node_path_1.join)(getMedicDir(report.cluster_id, repoRoot), `${packetId}-result.json`);
+        const resultFile = (0, node_path_1.relative)(repoRoot, (0, node_path_1.join)(getMedicDir(report.cluster_id, repoRoot), `${packetId}-result.json`));
         return {
             packet_id: packetId,
             run_id: report.run_id,
@@ -154,12 +154,16 @@ async function dispatchTreatmentWorker(input) {
     const result = await dispatch(workerPacket);
     const summary = parseTreatmentWorkerSummary(result.summary);
     if (result.exit_code === 0 && summary?.status === "done") {
+        const completedTreatment = { ...treatment, status: "completed" };
+        writeTreatmentPacket({ treatment: completedTreatment, repoRoot });
         return {
             packet_id: treatment.packet_id,
             status: "success",
             commit_sha: summary.commit,
         };
     }
+    const failedTreatment = { ...treatment, status: "failed" };
+    writeTreatmentPacket({ treatment: failedTreatment, repoRoot });
     return {
         packet_id: treatment.packet_id,
         status: "failure",

package/dist/qc/policy.js

@@ -59,6 +59,8 @@ function decideProviderFailureAction(reason, policy) {
             return policy?.timeout ?? "fail";
         case "parse-failed":
             return policy?.parseFailure ?? "fail";
+        case "rate-limited":
+            return policy?.rateLimited ?? "fail";
         default:
             return "fail";
     }

package/dist/qc/providers/coderabbit.js

@@ -37,6 +37,8 @@ const FINDING_BOOKKEEPING_KEYS = [
     "findingId",
 ];
 const PROGRESS_SHAPE_KEYS = new Set(["event", "progress", "heartbeat", "complete", "review_context"]);
+const ERROR_TYPE_RATE_LIMIT = new Set(["rate_limit", "rate-limit", "ratelimit", "rate limit"]);
+const ERROR_TYPE_AUTH = new Set(["auth", "authentication", "unauthorized", "unauthorised", "forbidden"]);
 const PROGRESS_TYPE_VALUES = new Set([
     "progress",
     "status",
@@ -56,6 +58,14 @@ const PROGRESS_STATUS_VALUES = new Set([
     "ok",
     "success",
 ]);
+const TERMINAL_COMPLETE_STATUSES = new Set([
+    "review_completed",
+    "review_skipped",
+    "completed",
+    "complete",
+    "done",
+    "success",
+]);
 function hasFindingLocation(record) {
     return FINDING_LOCATION_KEYS.some((key) => record[key] !== undefined);
 }
@@ -112,6 +122,8 @@ function isProgressRecord(record) {
     return false;
 }
 function isActionableFinding(record) {
+    if (isErrorRecord(record))
+        return false;
     if (isProgressRecord(record))
         return false;
     return hasFindingLocation(record) || hasFindingContent(record);
@@ -124,6 +136,87 @@ function makeUnusableOutputError(message) {
     err.qcFailureReason = "unusable-output";
     return err;
 }
+function makeQcFailureError(reason, message) {
+    const err = new Error(message);
+    err.qcFailureReason = reason;
+    return err;
+}
+function isErrorRecord(record) {
+    if (record.type === "error")
+        return true;
+    if (typeof record.errorType === "string")
+        return true;
+    if (record.error === true || record.error === "true")
+        return true;
+    if (typeof record.status === "string" && record.status.toLowerCase() === "error")
+        return true;
+    return false;
+}
+function errorTypeFromRecord(record) {
+    const fromType = typeof record.errorType === "string" ? record.errorType : undefined;
+    const fromMessage = typeof record.message === "string" ? record.message : undefined;
+    return fromType ?? fromMessage;
+}
+function classifyErrorType(record) {
+    const raw = errorTypeFromRecord(record);
+    const errorType = (raw ?? "").toString().toLowerCase().trim();
+    if (errorType === "")
+        return "unavailable-provider";
+    if (ERROR_TYPE_RATE_LIMIT.has(errorType))
+        return "rate-limited";
+    if (ERROR_TYPE_AUTH.has(errorType))
+        return "auth-failure";
+    if (errorType.includes("rate limit"))
+        return "rate-limited";
+    if (errorType.includes("auth"))
+        return "auth-failure";
+    if (errorType.includes("unauthorized"))
+        return "auth-failure";
+    if (errorType.includes("forbidden"))
+        return "auth-failure";
+    if (["timeout", "timed out"].includes(errorType))
+        return "timeout";
+    if (errorType.includes("not found") || errorType.includes("not_found"))
+        return "command-not-found";
+    if (errorType.includes("unavailable") || errorType.includes("api_error") || errorType.includes("apierror") || errorType.includes("server") || errorType.includes("network") || errorType.includes("connection") || errorType.includes("internal")) {
+        return "unavailable-provider";
+    }
+    return "unavailable-provider";
+}
+function getTerminalCompleteFindingsCount(record) {
+    if (record.findings !== undefined) {
+        if (Array.isArray(record.findings)) {
+            return record.findings.length;
+        }
+        const count = typeof record.findings === "number" ? record.findings : Number(record.findings);
+        if (Number.isFinite(count))
+            return count;
+    }
+    const summary = record.summary;
+    if (summary && typeof summary === "object") {
+        const summaryRecord = summary;
+        if (summaryRecord.total !== undefined) {
+            const count = Number(summaryRecord.total);
+            if (Number.isFinite(count))
+                return count;
+        }
+        if (summaryRecord.issues !== undefined) {
+            const count = Number(summaryRecord.issues);
+            if (Number.isFinite(count))
+                return count;
+        }
+    }
+    return undefined;
+}
+function isTerminalCompleteNoFindings(record) {
+    if (record.type !== "complete")
+        return false;
+    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+    if (!TERMINAL_COMPLETE_STATUSES.has(status))
+        return false;
+    const count = getTerminalCompleteFindingsCount(record);
+    return count === undefined || count === 0;
+}
 function buildRange(raw) {
     const startLine = coerceNumber(raw.startLine ?? raw.line) ?? 1;
     const endLine = coerceNumber(raw.endLine);
@@ -144,14 +237,27 @@ function parseFindingsFromPayload(payload) {
         return [];
     }
     const record = payload;
-    if (Array.isArray(record.findings)) {
-        return record.findings.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
-    }
-    if (Array.isArray(record.issues)) {
-        return record.issues.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
+    if (isErrorRecord(record)) {
+        throw makeQcFailureError(classifyErrorType(record), `CodeRabbit provider returned an error: ${record.message ?? record.errorType ?? "unknown"}`);
     }
-    if (Array.isArray(record.results)) {
-        return record.results.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
+    const arrays = [record.findings, record.issues, record.results];
+    for (const arr of arrays) {
+        if (Array.isArray(arr)) {
+            const findings = [];
+            for (const item of arr) {
+                if (typeof item !== "object" || item === null) {
+                    continue;
+                }
+                const itemRecord = item;
+                if (isErrorRecord(itemRecord)) {
+                    throw makeQcFailureError(classifyErrorType(itemRecord), `CodeRabbit provider returned an error in findings array: ${itemRecord.message ?? itemRecord.errorType ?? "unknown"}`);
+                }
+                if (isActionableFinding(itemRecord)) {
+                    findings.push(item);
+                }
+            }
+            return findings;
+        }
     }
     // Single finding wrapped in an object
     if (isActionableFinding(record)) {
@@ -172,6 +278,9 @@ function parseReport(output, format, parser) {
         const findings = parseFindingsFromPayload(data);
         const record = data;
         if (findings.length === 0) {
+            if (isTerminalCompleteNoFindings(record)) {
+                return { findings: [] };
+            }
             if (isProgressRecord(record)) {
                 throw makeUnusableOutputError("CodeRabbit output was a progress/status/heartbeat record");
             }
@@ -198,7 +307,19 @@ function parseReport(output, format, parser) {
         try {
             const parsed = JSON.parse(text);
             if (Array.isArray(parsed)) {
-                const findings = parsed.filter((item) => typeof item === "object" && item !== null && isActionableFinding(item));
+                const findings = [];
+                for (const item of parsed) {
+                    if (typeof item !== "object" || item === null) {
+                        continue;
+                    }
+                    const itemRecord = item;
+                    if (isErrorRecord(itemRecord)) {
+                        throw makeQcFailureError(classifyErrorType(itemRecord), `CodeRabbit provider returned an error in JSON array: ${itemRecord.message ?? itemRecord.errorType ?? "unknown"}`);
+                    }
+                    if (isActionableFinding(itemRecord)) {
+                        findings.push(item);
+                    }
+                }
                 if (findings.length === 0 && parsed.length > 0) {
                     const unusableCount = parsed.filter((item) => typeof item === "object" && item !== null && isUnusableFindingRecord(item)).length;
                     if (unusableCount > 0) {
@@ -210,6 +331,9 @@ function parseReport(output, format, parser) {
             const findings = parseFindingsFromPayload(parsed);
             if (findings.length === 0) {
                 const parsedRecord = parsed;
+                if (isTerminalCompleteNoFindings(parsedRecord)) {
+                    return { findings: [] };
+                }
                 if (isProgressRecord(parsedRecord)) {
                     throw makeUnusableOutputError("CodeRabbit output was a progress/status/heartbeat record");
                 }
@@ -260,9 +384,12 @@ function parseReport(output, format, parser) {
                 continue;
             }
             const record = parsed;
-            if (record.type === "complete" && record.status === "review_skipped") {
+            if (isTerminalCompleteNoFindings(record)) {
                 sawExplicitSkip = true;
             }
+            if (isErrorRecord(record)) {
+                throw makeQcFailureError(classifyErrorType(record), `CodeRabbit provider returned an error in JSONL: ${record.message ?? record.errorType ?? "unknown"}`);
+            }
             if (isProgressRecord(record)) {
                 progressLineCount++;
                 continue;
@@ -274,7 +401,10 @@ function parseReport(output, format, parser) {
                 unusableLineCount++;
             }
         }
-        catch {
+        catch (err) {
+            if (typeof err === "object" && err !== null && "qcFailureReason" in err) {
+                throw err;
+            }
             // Ignore unparseable lines.
         }
     }

package/dist/qc/repair-loop.js

@@ -19,10 +19,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_REPAIR_DISPATCH_TIMEOUT_MS = exports.DEFAULT_MAX_REPAIR_ROUNDS = void 0;
 exports.partitionRepairPackets = partitionRepairPackets;
 exports.initRepairLoopState = initRepairLoopState;
+exports.getQcResolutionArtifactPath = getQcResolutionArtifactPath;
+exports.resolveQcResolutionFindings = resolveQcResolutionFindings;
+exports.getResolverIdentity = getResolverIdentity;
+exports.isValidQcResolutionArtifact = isValidQcResolutionArtifact;
+exports.readQcResolutionArtifact = readQcResolutionArtifact;
+exports.writeQcResolutionArtifact = writeQcResolutionArtifact;
 exports.runQcRepairLoop = runQcRepairLoop;
 const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
 const node_path_1 = require("node:path");
 const repair_packets_js_1 = require("./repair-packets.js");
+const types_js_1 = require("./types.js");
 const orchestration_js_1 = require("./orchestration.js");
 const store_js_1 = require("../cluster-state/store.js");
 // ── Constants ─────────────────────────────────────────────────────────────────
@@ -189,6 +197,127 @@ function initRepairLoopState(opts) {
         updated_at: now,
     };
 }
+// ── Operator resolution artifact helpers ──────────────────────────────────────
+/** Path for the operator-written resolution artifact for a repair round. */
+function getQcResolutionArtifactPath(clusterId, round, repoRoot) {
+    return (0, node_path_1.join)((0, repair_packets_js_1.getRepairRoundDir)(clusterId, round, repoRoot), "resolution.json");
+}
+/** Resolve the finding IDs covered by a resolution artifact. */
+function resolveQcResolutionFindings(manifest, explicitFindings) {
+    const manifestFindings = [
+        ...new Set(manifest.packets.flatMap((p) => p.findingIds)),
+    ].sort();
+    if (!explicitFindings || explicitFindings.length === 0) {
+        return manifestFindings;
+    }
+    const allowed = new Set(manifestFindings);
+    const unknown = explicitFindings.filter((id) => !allowed.has(id));
+    if (unknown.length > 0) {
+        throw new Error(`Unknown finding IDs: ${unknown.join(", ")}. Expected one of: ${manifestFindings.join(", ") || "none"}`);
+    }
+    return [...new Set(explicitFindings)].sort();
+}
+/** Determine the resolver identity from git config or the default operator. */
+function getResolverIdentity(repoRoot) {
+    try {
+        const name = (0, node_child_process_1.execFileSync)("git", ["config", "user.name"], {
+            cwd: repoRoot || process.cwd(),
+            encoding: "utf-8",
+        }).trim();
+        return name || "lsctech";
+    }
+    catch {
+        return "lsctech";
+    }
+}
+const QC_RESOLUTION_OUTCOME_SET = new Set(types_js_1.QC_RESOLUTION_OUTCOMES);
+/** Validate a resolution artifact object. */
+function isValidQcResolutionArtifact(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    if (typeof v.schemaVersion !== "string")
+        return false;
+    if (typeof v.clusterId !== "string")
+        return false;
+    if (typeof v.round !== "number")
+        return false;
+    if (typeof v.resolvedAt !== "string")
+        return false;
+    if (typeof v.resolver !== "string" || v.resolver === "")
+        return false;
+    if (typeof v.resolvedOutcome !== "string" ||
+        !QC_RESOLUTION_OUTCOME_SET.has(v.resolvedOutcome)) {
+        return false;
+    }
+    if (typeof v.reason !== "string" || v.reason.trim() === "")
+        return false;
+    if (!Array.isArray(v.findings) ||
+        v.findings.length === 0 ||
+        !v.findings.every((f) => typeof f === "string")) {
+        return false;
+    }
+    return true;
+}
+/** Read and validate a resolution artifact, if it exists. */
+function readQcResolutionArtifact(clusterId, round, repoRoot) {
+    const artifactPath = getQcResolutionArtifactPath(clusterId, round, repoRoot);
+    try {
+        const data = (0, node_fs_1.readFileSync)(artifactPath, "utf-8");
+        const parsed = JSON.parse(data);
+        if (isValidQcResolutionArtifact(parsed)) {
+            // Verify identity matches expected clusterId and round
+            if (parsed.clusterId !== clusterId || parsed.round !== round) {
+                return null;
+            }
+            return parsed;
+        }
+        return null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        if (error instanceof SyntaxError) {
+            return null;
+        }
+        throw error;
+    }
+}
+/** Write a resolution artifact atomically and return its absolute path. */
+function writeQcResolutionArtifact(options) {
+    const { clusterId, round, resolver, resolvedOutcome, reason, findings, repoRoot, } = options;
+    const artifactPath = getQcResolutionArtifactPath(clusterId, round, repoRoot);
+    const dir = (0, node_path_1.dirname)(artifactPath);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const artifact = {
+        schemaVersion: "1.0",
+        clusterId,
+        round,
+        resolvedAt: new Date().toISOString(),
+        resolver,
+        resolvedOutcome,
+        reason,
+        findings,
+    };
+    const tempPath = `${artifactPath}.tmp.${process.pid}.${Date.now()}.${Math.random()
+        .toString(36)
+        .slice(2, 8)}`;
+    try {
+        (0, node_fs_1.writeFileSync)(tempPath, JSON.stringify(artifact, null, 2), "utf-8");
+        (0, node_fs_1.renameSync)(tempPath, artifactPath);
+    }
+    catch (error) {
+        try {
+            (0, node_fs_1.unlinkSync)(tempPath);
+        }
+        catch {
+            // Ignore cleanup failure.
+        }
+        throw error;
+    }
+    return artifactPath;
+}
 // ── Main repair loop ───────────────────────────────────────────────────────────
 /**
  * Run the bounded QC repair loop.
@@ -293,10 +422,21 @@ async function runQcRepairLoop(options) {
         else {
             const existingManifestPath = loopState.manifest_path ??
                 (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId, "qc", "repair-rounds", String(round), "repair-packets.json");
+            // Synchronize manifest packet statuses with the persisted loop state.
+            const completedSet = new Set(loopState.completed_packet_ids);
+            for (const packet of manifest.packets) {
+                if (completedSet.has(packet.packetId)) {
+                    packet.status = "completed";
+                }
+            }
+            (0, repair_packets_js_1.writeRepairPacketManifest)(manifest, repoRoot);
             loopState = {
                 ...loopState,
                 current_round: round,
                 manifest_path: existingManifestPath,
+                pending_packet_ids: manifest.packets
+                    .filter((p) => p.status === "pending" && !completedSet.has(p.packetId))
+                    .map((p) => p.packetId),
                 updated_at: new Date().toISOString(),
             };
             onStateUpdate?.(loopState);
@@ -367,10 +507,16 @@ async function runQcRepairLoop(options) {
             const result = await dispatchRepairWorkerWithTimeout(dispatchRepairWorker, pkt, round, manifest, repairDispatchTimeoutMs, telemetryFile, runId, clusterId);
             allWorkerResults.push(result);
         }
-        // Record completed packet IDs.
+        // Record completed packet IDs and update manifest statuses.
         const completedIds = allWorkerResults
             .filter((r) => r.status !== "skipped")
             .map((r) => r.packetId);
+        for (const packet of manifest.packets) {
+            if (completedIds.includes(packet.packetId)) {
+                packet.status = "completed";
+            }
+        }
+        (0, repair_packets_js_1.writeRepairPacketManifest)(manifest, repoRoot);
         loopState = {
             ...loopState,
             completed_packet_ids: [...loopState.completed_packet_ids, ...completedIds],