@lsctech/polaris 0.5.6 → 0.5.7

package/dist/config/validator.js

@@ -10,6 +10,9 @@ function isNumber(value) {
 function isPositiveInteger(value) {
     return Number.isInteger(value) && Number(value) > 0;
 }
+function isNonNegativeInteger(value) {
+    return Number.isInteger(value) && Number(value) >= 0;
+}
 function isString(value) {
     return typeof value === "string";
 }
@@ -91,6 +94,8 @@ const SUPPORTED_QC_PROVIDER_CAPABILITIES = [
     "auto-fix",
     "metrics-import",
 ];
+const SUPPORTED_QC_OUTPUT_FORMATS = ["json", "jsonl", "sarif", "generic"];
+const SUPPORTED_QC_FAILURE_ACTIONS = ["fail", "fallback", "ignore", "block"];
 const SEVERITY_ORDER = ["info", "low", "medium", "high", "critical"];
 function severityIndex(severity) {
     return SEVERITY_ORDER.indexOf(severity);
@@ -908,6 +913,158 @@ function validateConfig(config) {
                                 }
                             }
                         }
+                        if ("enabled" in providerConfig && providerConfig.enabled !== undefined && !isBoolean(providerConfig.enabled)) {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName}.enabled must be a boolean`);
+                        }
+                        if ("execution" in providerConfig && providerConfig.execution !== undefined) {
+                            if (!isPlainObject(providerConfig.execution)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.execution must be a plain object`);
+                            }
+                            else {
+                                const execution = providerConfig.execution;
+                                if ("command" in execution && execution.command !== undefined && !isString(execution.command)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.execution.command must be a string`);
+                                }
+                                if ("args" in execution && execution.args !== undefined && !isStringArray(execution.args)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.execution.args must be an array of strings`);
+                                }
+                                if ("output" in execution && execution.output !== undefined) {
+                                    if (!isPlainObject(execution.output)) {
+                                        result.valid = false;
+                                        result.errors.push(`qc.providers.${providerName}.execution.output must be a plain object`);
+                                    }
+                                    else {
+                                        if ("format" in execution.output &&
+                                            execution.output.format !== undefined &&
+                                            (!isString(execution.output.format) ||
+                                                !SUPPORTED_QC_OUTPUT_FORMATS.includes(execution.output.format))) {
+                                            result.valid = false;
+                                            result.errors.push(`qc.providers.${providerName}.execution.output.format must be one of json, jsonl, sarif, generic`);
+                                        }
+                                        if ("parser" in execution.output &&
+                                            execution.output.parser !== undefined &&
+                                            !isString(execution.output.parser)) {
+                                            result.valid = false;
+                                            result.errors.push(`qc.providers.${providerName}.execution.output.parser must be a string`);
+                                        }
+                                    }
+                                }
+                                if ("configPath" in execution &&
+                                    execution.configPath !== undefined &&
+                                    !isString(execution.configPath)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.execution.configPath must be a string`);
+                                }
+                            }
+                        }
+                        if ("timeoutMs" in providerConfig && providerConfig.timeoutMs !== undefined && !isPositiveInteger(providerConfig.timeoutMs)) {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName}.timeoutMs must be a positive integer`);
+                        }
+                        if ("primary" in providerConfig && providerConfig.primary !== undefined && !isBoolean(providerConfig.primary)) {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName}.primary must be a boolean`);
+                        }
+                        if ("fallback" in providerConfig && providerConfig.fallback !== undefined && !isStringArray(providerConfig.fallback)) {
+                            result.valid = false;
+                            result.errors.push(`qc.providers.${providerName}.fallback must be an array of strings`);
+                        }
+                        if ("failurePolicy" in providerConfig && providerConfig.failurePolicy !== undefined) {
+                            if (!isPlainObject(providerConfig.failurePolicy)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.failurePolicy must be a plain object`);
+                            }
+                            else {
+                                for (const key of ["timeout", "parseFailure", "allProvidersFailed"]) {
+                                    const value = providerConfig.failurePolicy[key];
+                                    if (value !== undefined && (!isString(value) || !SUPPORTED_QC_FAILURE_ACTIONS.includes(value))) {
+                                        result.valid = false;
+                                        result.errors.push(`qc.providers.${providerName}.failurePolicy.${key} must be one of fail, fallback, ignore, block`);
+                                    }
+                                }
+                            }
+                        }
+                        if ("rateLimit" in providerConfig && providerConfig.rateLimit !== undefined) {
+                            if (!isPlainObject(providerConfig.rateLimit)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.rateLimit must be a plain object`);
+                            }
+                            else {
+                                if ("requestsPerMinute" in providerConfig.rateLimit &&
+                                    providerConfig.rateLimit.requestsPerMinute !== undefined &&
+                                    !isPositiveInteger(providerConfig.rateLimit.requestsPerMinute)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.rateLimit.requestsPerMinute must be a positive integer`);
+                                }
+                                if ("maxConcurrent" in providerConfig.rateLimit &&
+                                    providerConfig.rateLimit.maxConcurrent !== undefined &&
+                                    !isPositiveInteger(providerConfig.rateLimit.maxConcurrent)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.rateLimit.maxConcurrent must be a positive integer`);
+                                }
+                            }
+                        }
+                        if ("retry" in providerConfig && providerConfig.retry !== undefined) {
+                            if (!isPlainObject(providerConfig.retry)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.retry must be a plain object`);
+                            }
+                            else {
+                                if ("maxRetries" in providerConfig.retry &&
+                                    providerConfig.retry.maxRetries !== undefined &&
+                                    !isNonNegativeInteger(providerConfig.retry.maxRetries)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.retry.maxRetries must be a non-negative integer`);
+                                }
+                                if ("backoffMs" in providerConfig.retry &&
+                                    providerConfig.retry.backoffMs !== undefined &&
+                                    !isNonNegativeInteger(providerConfig.retry.backoffMs)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.retry.backoffMs must be a non-negative integer`);
+                                }
+                            }
+                        }
+                        if ("artifactPolicy" in providerConfig && providerConfig.artifactPolicy !== undefined) {
+                            if (!isPlainObject(providerConfig.artifactPolicy)) {
+                                result.valid = false;
+                                result.errors.push(`qc.providers.${providerName}.artifactPolicy must be a plain object`);
+                            }
+                            else {
+                                if ("retainRawOutput" in providerConfig.artifactPolicy &&
+                                    providerConfig.artifactPolicy.retainRawOutput !== undefined &&
+                                    !isBoolean(providerConfig.artifactPolicy.retainRawOutput)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.artifactPolicy.retainRawOutput must be a boolean`);
+                                }
+                                if ("outputDir" in providerConfig.artifactPolicy &&
+                                    providerConfig.artifactPolicy.outputDir !== undefined &&
+                                    !isString(providerConfig.artifactPolicy.outputDir)) {
+                                    result.valid = false;
+                                    result.errors.push(`qc.providers.${providerName}.artifactPolicy.outputDir must be a string`);
+                                }
+                            }
+                        }
+                    }
+                    // Validate fallback references after all provider keys are known.
+                    if (providers) {
+                        const providerKeys = new Set(Object.keys(config.qc.providers));
+                        for (const [providerName, providerConfig] of Object.entries(config.qc.providers)) {
+                            if (!isPlainObject(providerConfig))
+                                continue;
+                            const fallback = providerConfig.fallback;
+                            if (Array.isArray(fallback)) {
+                                for (const fallbackName of fallback) {
+                                    if (isString(fallbackName) && !providerKeys.has(fallbackName)) {
+                                        result.valid = false;
+                                        result.errors.push(`qc.providers.${providerName}.fallback contains unknown provider: ${fallbackName}`);
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }

package/dist/finalize/index.js

@@ -185,7 +185,7 @@ function resolveQcTelemetryFile(state, repoRoot) {
 }
 async function runQcGate(options) {
     const { config, state, repoRoot, branch, trigger, prUrl, stepLabel } = options;
-    const registry = (0, index_js_2.createDefaultQcRegistry)();
+    const registry = (0, index_js_2.createQcRegistry)(config);
     const result = await (0, index_js_2.runQcAtTrigger)({
         config,
         registry,

package/dist/loop/parent.js

@@ -37,12 +37,15 @@ const node_child_process_1 = require("node:child_process");
 const artifact_policy_js_1 = require("../finalize/artifact-policy.js");
 const dispatch_boundary_js_1 = require("./dispatch-boundary.js");
 const triggers_js_1 = require("../qc/triggers.js");
+const index_js_1 = require("../qc/index.js");
+const repair_loop_js_1 = require("../qc/repair-loop.js");
+const worker_packet_js_2 = require("./worker-packet.js");
 const run_bootstrap_js_1 = require("./run-bootstrap.js");
 const ledger_js_1 = require("./ledger.js");
 const dispatch_js_1 = require("./dispatch.js");
-const index_js_1 = require("./router/index.js");
+const index_js_2 = require("./router/index.js");
 const child_selector_js_1 = require("../runtime/scheduling/child-selector.js");
-const index_js_2 = require("../tracker/index.js");
+const index_js_3 = require("../tracker/index.js");
 const lifecycle_transition_js_1 = require("../tracker/lifecycle-transition.js");
 const local_graph_js_1 = require("../tracker/local-graph.js");
 const CLAIM_TTL_MS = 30 * 60 * 1000;
@@ -813,7 +816,7 @@ async function runParentLoop(options) {
         if (openChildrenNeedingScope.length > 0) {
             process.stderr.write(`[polaris] ${openChildrenNeedingScope.length} children missing scope — attempting tracker sync-in...\n`);
             try {
-                await (0, index_js_2.loadTrackerGraph)(config, state.cluster_id);
+                await (0, index_js_3.loadTrackerGraph)(config, state.cluster_id);
                 process.stderr.write(`[polaris] sync-in complete.\n`);
             }
             catch (syncErr) {
@@ -844,7 +847,7 @@ async function runParentLoop(options) {
             max_concurrent: maxConcurrentWorkers,
             claim_ttl_ms: CLAIM_TTL_MS,
             get_dependencies: (childId) => localGraph?.getDependencies(childId) ?? [],
-            decide_route: ({ activeSlotsByProvider }) => (0, index_js_1.decideWorkerRoute)({
+            decide_route: ({ activeSlotsByProvider }) => (0, index_js_2.decideWorkerRoute)({
                 role: "worker",
                 taskType: "impl",
                 adapter: adapterName,
@@ -884,6 +887,154 @@ async function runParentLoop(options) {
                 };
             }
             const autoFinalizeRequested = orchestrationMode === "auto" && config.orchestration?.auto_finalize === true;
+            // ── QC repair loop (post-completion gate) ─────────────────────────────
+            // When QC is enabled, run the completed-cluster QC trigger and, if
+            // findings are produced, run the bounded repair loop before halting.
+            // The repair loop is Foreman-owned: it dispatches repair workers via the
+            // same adapter and NEVER implements repairs inline.
+            if (!dryRun && config.qc?.enabled) {
+                const qcRegistry = (0, index_js_1.createQcRegistry)(config.qc);
+                let initialQcResult;
+                try {
+                    initialQcResult = await (0, index_js_1.runQcAtTrigger)({
+                        config: config.qc,
+                        registry: qcRegistry,
+                        trigger: "completed-cluster",
+                        repoRoot,
+                        runId: state.run_id,
+                        clusterId: state.cluster_id,
+                        branch: state.branch ?? getCurrentBranch(repoRoot),
+                        telemetryFile,
+                        state,
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    appendTelemetry(telemetryFile, {
+                        event: "qc-repair-loop-qc-run-error",
+                        run_id: state.run_id,
+                        error: msg,
+                        timestamp: new Date().toISOString(),
+                    });
+                    // Non-fatal: proceed to cluster-complete without repair loop.
+                    initialQcResult = null;
+                }
+                const hasFindings = initialQcResult !== null &&
+                    initialQcResult.results.some((r) => r.findings.length > 0 && r.status !== "passed" && r.status !== "skipped");
+                if (initialQcResult !== null && hasFindings) {
+                    const maxRepairRounds = config.qc.maxRepairRounds ?? repair_loop_js_1.DEFAULT_MAX_REPAIR_ROUNDS;
+                    const priorLoopState = state.qc_repair_loop ?? null;
+                    // Build the repair worker dispatcher using the existing adapter + provider.
+                    const repairDispatcher = async (packet, round, manifest) => {
+                        const repairPacketId = packet.packetId;
+                        const dispatchId = (0, node_crypto_1.randomUUID)();
+                        const repairWorkerId = `${state.run_id}:repair-${repairPacketId}:${Date.now()}`;
+                        const repairResultPath = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", state.cluster_id, "results", `repair-${repairPacketId}-${dispatchId}.json`);
+                        const workerPacket = (0, worker_packet_js_2.compileRepairWorkerPacket)({
+                            runId: state.run_id,
+                            clusterId: state.cluster_id,
+                            packetId: repairPacketId,
+                            branch: state.branch ?? getCurrentBranch(repoRoot),
+                            stateFile,
+                            telemetryFile,
+                            round,
+                            allowedScope: packet.allowedScope,
+                            prohibitedScope: packet.prohibitedScope,
+                            validationCommands: packet.validationCommands,
+                            rootCauseHint: packet.rootCauseHint,
+                            resultFile: repairResultPath,
+                            maxConcurrentWorkers,
+                        });
+                        appendTelemetry(telemetryFile, {
+                            event: "repair-worker-dispatched",
+                            run_id: state.run_id,
+                            cluster_id: state.cluster_id,
+                            packet_id: repairPacketId,
+                            worker_id: repairWorkerId,
+                            round,
+                            timestamp: new Date().toISOString(),
+                        });
+                        try {
+                            const dispatchResult = await adapter.dispatch(workerPacket, { provider: providerName, dryRun });
+                            const workerSummary = parseWorkerSummary(dispatchResult.summary);
+                            const success = workerSummary?.status === "done";
+                            appendTelemetry(telemetryFile, {
+                                event: "repair-worker-completed",
+                                run_id: state.run_id,
+                                packet_id: repairPacketId,
+                                worker_id: repairWorkerId,
+                                round,
+                                status: success ? "success" : "failure",
+                                timestamp: new Date().toISOString(),
+                            });
+                            return {
+                                packetId: repairPacketId,
+                                status: success ? "success" : "failure",
+                                commitSha: workerSummary?.commit,
+                                errorMessage: success ? undefined : String(workerSummary?.error_message ?? "repair worker failed"),
+                            };
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            appendTelemetry(telemetryFile, {
+                                event: "repair-worker-error",
+                                run_id: state.run_id,
+                                packet_id: repairPacketId,
+                                worker_id: repairWorkerId,
+                                round,
+                                error: msg,
+                                timestamp: new Date().toISOString(),
+                            });
+                            return {
+                                packetId: repairPacketId,
+                                status: "failure",
+                                errorMessage: msg,
+                            };
+                        }
+                    };
+                    try {
+                        const repairLoopResult = await (0, repair_loop_js_1.runQcRepairLoop)({
+                            clusterId: state.cluster_id,
+                            runId: state.run_id,
+                            branch: state.branch ?? getCurrentBranch(repoRoot),
+                            repoRoot,
+                            telemetryFile,
+                            config: config.qc,
+                            registry: qcRegistry,
+                            initialQcResults: initialQcResult.results,
+                            dispatchRepairWorker: repairDispatcher,
+                            maxRounds: maxRepairRounds,
+                            priorLoopState,
+                            onStateUpdate: (loopState) => {
+                                // Persist loop state to the state file on each mutation.
+                                const stateWithLoop = { ...state, qc_repair_loop: loopState };
+                                (0, checkpoint_js_1.writeStateAtomic)(stateFile, stateWithLoop);
+                            },
+                        });
+                        state = { ...state, qc_repair_loop: repairLoopResult.loop_state };
+                        (0, checkpoint_js_1.writeStateAtomic)(stateFile, state);
+                        appendTelemetry(telemetryFile, {
+                            event: "qc-repair-loop-finished",
+                            run_id: state.run_id,
+                            outcome: repairLoopResult.outcome,
+                            rounds_completed: repairLoopResult.rounds_completed,
+                            summary: repairLoopResult.summary,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        appendTelemetry(telemetryFile, {
+                            event: "qc-repair-loop-error",
+                            run_id: state.run_id,
+                            error: msg,
+                            timestamp: new Date().toISOString(),
+                        });
+                        // Non-fatal: proceed to cluster-complete.
+                    }
+                }
+            }
+            // ── End QC repair loop ─────────────────────────────────────────────────
             // All children completed — write final state and halt
             if (!dryRun) {
                 logStatus(notificationFormat, "COMPLETE");
@@ -1427,7 +1578,7 @@ async function runParentLoop(options) {
                 // Errors are logged to telemetry but do not fail the halt.
                 let adapter;
                 try {
-                    adapter = (0, index_js_2.loadTrackerAdapter)(config);
+                    adapter = (0, index_js_3.loadTrackerAdapter)(config);
                 }
                 catch (err) {
                     const errorMsg = err instanceof Error ? err.message : String(err);

package/dist/loop/worker-packet.js

@@ -11,7 +11,7 @@
  * accept BootstrapPacket transparently accept WorkerPacket.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
+exports.REPAIR_RETURN_CONTRACT = exports.STARTUP_RETURN_CONTRACT = exports.PREFLIGHT_RETURN_CONTRACT = exports.WORKER_PROHIBITED_WRITE_PATHS = exports.FINALIZE_RETURN_CONTRACT = exports.IMPL_RETURN_CONTRACT = void 0;
 exports.roleContextForWorkerRole = roleContextForWorkerRole;
 exports.isWorkerPacket = isWorkerPacket;
 exports.getWorkerCommitPolicy = getWorkerCommitPolicy;
@@ -19,6 +19,7 @@ exports.compileStartupPacket = compileStartupPacket;
 exports.compileImplPacket = compileImplPacket;
 exports.compileFinalizePacket = compileFinalizePacket;
 exports.compilePreflightPacket = compilePreflightPacket;
+exports.compileRepairWorkerPacket = compileRepairWorkerPacket;
 const worker_prompt_js_1 = require("./worker-prompt.js");
 const body_parser_js_1 = require("./body-parser.js");
 const WORKER_ROLE_CONTEXT = {
@@ -421,3 +422,76 @@ function compilePreflightPacket(input) {
         },
     };
 }
+/** Return contract for repair workers (same shape as impl). */
+exports.REPAIR_RETURN_CONTRACT = [
+    'child_id',
+    'status',
+    'commit',
+    'validation',
+    'next_recommended_action',
+];
+/**
+ * Build a compiled repair worker packet.
+ *
+ * Repair workers use `worker_role: "repair"` and the same sealed packet/result
+ * contracts as impl workers, but with tightly scoped allowed/prohibited paths
+ * derived from the compiled repair packet manifest.
+ *
+ * The parent/orchestrator MUST use this function and MUST NOT implement
+ * repair work inline.
+ */
+function compileRepairWorkerPacket(input) {
+    const steps = [
+        `Confirm QC repair scope: allowed=${JSON.stringify(input.allowedScope)}, prohibited=${JSON.stringify(input.prohibitedScope)}.`,
+        `Review root-cause hint: ${input.rootCauseHint}`,
+        `Apply minimal repair to files within allowed scope only. Do NOT touch prohibited paths.`,
+        `Run validation commands and confirm all pass.`,
+        `Create exactly ONE git commit: [REPAIR] ${input.clusterId} round-${input.round} packet-${input.packetId}.`,
+        `Write compact return JSON to stdout (fields: ${exports.REPAIR_RETURN_CONTRACT.join(', ')}). next_recommended_action MUST be "continue" on success, "stop" on unresolvable blocker.`,
+        `TERMINATE SESSION IMMEDIATELY.`,
+    ];
+    return {
+        schema_version: '2.1',
+        worker_role: 'repair',
+        run_id: input.runId,
+        cluster_id: input.clusterId,
+        active_child: input.packetId,
+        state_file: input.stateFile,
+        telemetry_file: input.telemetryFile,
+        instructions: {
+            primary_goal: `QC repair worker for cluster ${input.clusterId}, round ${input.round}, packet ${input.packetId}. ` +
+                `Apply minimal targeted repairs to findings within the allowed scope. Root cause: ${input.rootCauseHint}`,
+            steps,
+            allowed_scope: input.allowedScope,
+            validation_commands: input.validationCommands,
+        },
+        lifecycle: defaultLifecycle(input.maxConcurrentWorkers ?? 1, 'commit-and-exit'),
+        return_contract: exports.REPAIR_RETURN_CONTRACT,
+        prompt_mode: 'full',
+        prompt_metrics: { mode: 'full', char_count: 0, estimated_tokens: 0 },
+        role_context: roleContextForWorkerRole('repair'),
+        routing_context: {
+            task_type: "repair",
+            required_capabilities: ["repair"],
+        },
+        prohibited_write_paths: [
+            ...exports.WORKER_PROHIBITED_WRITE_PATHS,
+            ...input.prohibitedScope,
+        ],
+        result_file_contract: {
+            result_file: input.resultFile,
+            result_required_fields: Object.fromEntries([
+                ['run_id', input.runId],
+                ['cluster_id', input.clusterId],
+                ['child_id', input.packetId],
+                ...exports.REPAIR_RETURN_CONTRACT.filter((key) => key !== 'child_id').map((key) => [key, `<${key}>`]),
+            ]),
+        },
+        context: {
+            branch: input.branch,
+            worker_role: 'repair',
+            repair_round: input.round,
+            repair_packet_id: input.packetId,
+        },
+    };
+}

package/dist/qc/fixtures/repair-packets.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TEST_CONFIG = void 0;
+exports.makeFinding = makeFinding;
+exports.makeResult = makeResult;
+exports.makeSameFileFindings = makeSameFileFindings;
+exports.makeCrossFileSubsystemFindings = makeCrossFileSubsystemFindings;
+exports.makeOverlappingScopeFindings = makeOverlappingScopeFindings;
+exports.makeHighRiskFindings = makeHighRiskFindings;
+exports.makeLowConfidenceBroadFindings = makeLowConfidenceBroadFindings;
+exports.DEFAULT_TEST_CONFIG = {
+    enabled: true,
+    severityThresholds: { block: "high", repair: "medium", followUp: "low" },
+};
+function makeFinding(overrides = {}) {
+    return {
+        findingId: `f-${Math.random().toString(36).slice(2, 8)}`,
+        severity: "medium",
+        category: "style",
+        title: "Test finding",
+        fixAvailable: true,
+        autofixEligible: false,
+        attribution: { confidence: "high", reason: "changed-file-owner", childId: "POL-472" },
+        status: "open",
+        ...overrides,
+    };
+}
+function makeResult(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: "1.0",
+        qcRunId: `qc-run-${Math.random().toString(36).slice(2, 8)}`,
+        runId: "run-1",
+        clusterId: "POL-TEST",
+        trigger: "completed-cluster",
+        provider: "coderabbit",
+        providerMode: "local",
+        startedAt: now,
+        completedAt: now,
+        status: "findings",
+        findings: [],
+        rawArtifactPaths: [],
+        parserVersion: "coderabbit-1.0",
+        policyDecision: {
+            blocksDelivery: false,
+            requiresOperatorReview: false,
+            routedToRepair: false,
+            summary: "ok",
+        },
+        ...overrides,
+    };
+}
+function makeSameFileFindings() {
+    return [
+        makeFinding({
+            findingId: "f-same-1",
+            filePath: "src/auth/login.ts",
+            category: "style",
+            severity: "medium",
+            range: { startLine: 10, endLine: 15 },
+        }),
+        makeFinding({
+            findingId: "f-same-2",
+            filePath: "src/auth/login.ts",
+            category: "type-safety",
+            severity: "medium",
+            range: { startLine: 30, endLine: 35 },
+        }),
+        makeFinding({
+            findingId: "f-same-3",
+            filePath: "src/auth/login.ts",
+            category: "style",
+            severity: "medium",
+            range: { startLine: 12, endLine: 16 },
+        }),
+    ];
+}
+function makeCrossFileSubsystemFindings() {
+    return [
+        makeFinding({
+            findingId: "f-sub-a",
+            filePath: "src/qc/compiler.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 5, endLine: 8 },
+        }),
+        makeFinding({
+            findingId: "f-sub-b",
+            filePath: "src/qc/runner.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 20, endLine: 24 },
+        }),
+        makeFinding({
+            findingId: "f-sub-c",
+            filePath: "src/loop/worker.ts",
+            category: "error-handling",
+            severity: "medium",
+            range: { startLine: 7, endLine: 11 },
+        }),
+    ];
+}
+function makeOverlappingScopeFindings() {
+    return [
+        makeFinding({
+            findingId: "f-overlap-1",
+            filePath: "src/core/state.ts",
+            category: "race-condition",
+            severity: "high",
+            range: { startLine: 40, endLine: 45 },
+        }),
+        makeFinding({
+            findingId: "f-overlap-2",
+            filePath: "src/core/state.ts",
+            category: "race-condition",
+            severity: "high",
+            range: { startLine: 42, endLine: 48 },
+        }),
+    ];
+}
+function makeHighRiskFindings() {
+    return [
+        makeFinding({
+            findingId: "f-security-1",
+            filePath: "src/auth/token.ts",
+            category: "security",
+            severity: "high",
+            range: { startLine: 1, endLine: 5 },
+        }),
+        makeFinding({
+            findingId: "f-security-2",
+            filePath: "src/auth/token.ts",
+            category: "auth",
+            severity: "medium",
+            range: { startLine: 10, endLine: 14 },
+        }),
+        makeFinding({
+            findingId: "f-migration-1",
+            filePath: "src/db/migrate.ts",
+            category: "migration",
+            severity: "medium",
+            range: { startLine: 3, endLine: 7 },
+        }),
+    ];
+}
+function makeLowConfidenceBroadFindings() {
+    return [
+        makeFinding({
+            findingId: "f-broad-1",
+            filePath: undefined,
+            category: "architecture",
+            severity: "medium",
+            attribution: { confidence: "low", reason: "provider-uncertain" },
+        }),
+        makeFinding({
+            findingId: "f-broad-2",
+            filePath: undefined,
+            category: "architecture",
+            severity: "low",
+            attribution: { confidence: "unattributed", reason: "unattributed" },
+        }),
+        makeFinding({
+            findingId: "f-preexisting-1",
+            filePath: "src/legacy/old.ts",
+            category: "tech-debt",
+            severity: "low",
+            attribution: { confidence: "medium", reason: "pre-existing" },
+        }),
+    ];
+}

package/dist/qc/index.js

@@ -28,3 +28,5 @@ __exportStar(require("./registry.js"), exports);
 __exportStar(require("./attribution.js"), exports);
 __exportStar(require("./autofix.js"), exports);
 __exportStar(require("./routing.js"), exports);
+__exportStar(require("./repair-packets.js"), exports);
+__exportStar(require("./repair-loop.js"), exports);

package/dist/qc/orchestration.js

@@ -108,6 +108,8 @@ async function runQcAtTrigger(options) {
                 branch,
                 telemetryFile,
                 timeoutMs,
+                config,
+                registry,
             });
             const result = applyAttributionAndRouting(rawResult, config, attributionContext, ownership, routeName);
             try {