@lsctech/polaris 0.4.9 → 0.5.2

package/dist/cluster-state/store.js

@@ -33,17 +33,54 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeClusterState = exports.writeClusterStateSync = exports.writeClusterState = exports.readClusterStateSync = exports.readClusterState = void 0;
+exports.recordQcRun = exports.initializeClusterState = exports.writeClusterStateSync = exports.writeClusterState = exports.readClusterStateSync = exports.readClusterState = void 0;
+exports.pruneExpiredClaims = pruneExpiredClaims;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const local_graph_1 = require("../tracker/local-graph");
+const artifacts_js_1 = require("../qc/artifacts.js");
 const getClusterStatePath = (clusterId, repoRoot) => {
     return path.join(repoRoot || process.cwd(), '.polaris', 'clusters', clusterId, 'cluster-state.json');
 };
 const normalizeClusterState = (state) => ({
     ...state,
     tracker_mutations: state.tracker_mutations ?? {},
+    qc_runs: state.qc_runs ?? {},
 });
+function pruneExpiredClaims(state, now = new Date()) {
+    const nowMs = now.getTime();
+    const expiredChildIds = [];
+    const nextClaimMetadata = {};
+    for (const [childId, claim] of Object.entries(state.claim_metadata ?? {})) {
+        const expiresAtMs = new Date(claim.expires_at).getTime();
+        const active = Number.isFinite(expiresAtMs) && expiresAtMs > nowMs;
+        if (active) {
+            nextClaimMetadata[childId] = claim;
+            continue;
+        }
+        expiredChildIds.push(childId);
+    }
+    if (expiredChildIds.length === 0) {
+        return { state, expiredChildIds };
+    }
+    const expiredSet = new Set(expiredChildIds);
+    const recoverableStatuses = new Set(["claimed", "dispatched", "running"]);
+    const child_states = state.child_states.map((child) => {
+        if (!expiredSet.has(child.id) || !recoverableStatuses.has(child.status)) {
+            return child;
+        }
+        return { ...child, status: "ready" };
+    });
+    return {
+        state: {
+            ...state,
+            state_generation: state.state_generation + 1,
+            claim_metadata: nextClaimMetadata,
+            child_states,
+        },
+        expiredChildIds,
+    };
+}
 const readClusterState = async (clusterId, repoRoot) => {
     const filePath = getClusterStatePath(clusterId, repoRoot);
     try {
@@ -295,8 +332,40 @@ const initializeClusterState = async (clusterId, repoRoot) => {
         commits: {},
         tracker_mutations: {},
         blockers: [],
+        qc_runs: {},
     };
     await (0, exports.writeClusterState)(clusterId, initialState, repoRoot);
     return initialState;
 };
 exports.initializeClusterState = initializeClusterState;
+/**
+ * Persist a QC result artifact under the active cluster's evidence surface and
+ * record a pointer in the cluster state. This is the only supported way to
+ * durably store QC runs; callers must not write QC artifacts directly outside
+ * `.polaris/clusters/<cluster-id>/qc/`.
+ */
+const recordQcRun = async (clusterId, result, repoRoot) => {
+    const artifactPath = (0, artifacts_js_1.writeQcArtifact)(clusterId, result, repoRoot);
+    const currentState = await (0, exports.readClusterState)(clusterId, repoRoot);
+    if (!currentState) {
+        throw new Error(`Cluster ${clusterId} state not found; cannot record QC run ${result.qcRunId}.`);
+    }
+    const pointer = {
+        artifact_path: artifactPath,
+        status: result.status,
+        provider: result.provider,
+        started_at: result.startedAt,
+        completed_at: result.completedAt,
+    };
+    const nextState = {
+        ...currentState,
+        state_generation: currentState.state_generation + 1,
+        qc_runs: {
+            ...currentState.qc_runs,
+            [result.qcRunId]: pointer,
+        },
+    };
+    await (0, exports.writeClusterState)(clusterId, nextState, repoRoot);
+    return { artifactPath, state: nextState };
+};
+exports.recordQcRun = recordQcRun;

package/dist/config/defaults.js

@@ -39,6 +39,14 @@ exports.DEFAULT_CONFIG = {
         rotation: [],
         allowCrossAgentFallback: false,
         roles: {},
+        routerPolicy: {
+            defaultWorkerPool: {
+                maxActiveWorkers: 1,
+                maxActiveSlots: 1,
+            },
+            providerRegistry: {},
+            allowCrossProviderFallback: false,
+        },
     },
     finalize: {
         targetBranch: "main",
@@ -95,4 +103,21 @@ exports.DEFAULT_CONFIG = {
         auto_deep_analysis: false,
         allow_cross_provider_delegation: false,
     },
+    qc: {
+        enabled: false,
+        defaultTrigger: "completed-cluster",
+        providers: {},
+        severityThresholds: {
+            block: "high",
+            repair: "medium",
+            followUp: "low",
+        },
+        autoFix: "disabled",
+        repairRouting: "route",
+        artifactRetention: {
+            retainRawOutput: false,
+            maxRuns: 10,
+        },
+        routes: {},
+    },
 };

package/dist/config/validator.js

@@ -7,6 +7,9 @@ function isPlainObject(value) {
 function isNumber(value) {
     return typeof value === "number" && !Number.isNaN(value);
 }
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && Number(value) > 0;
+}
 function isString(value) {
     return typeof value === "string";
 }
@@ -44,6 +47,29 @@ const SUPPORTED_EXECUTION_ADAPTERS = [
     "remote-worker",
     "cross-agent",
 ];
+const SUPPORTED_ROUTER_CAPABILITIES = [
+    "orchestration",
+    "analysis",
+    "implementation",
+    "repair",
+    "docs",
+    "finalization",
+];
+const SUPPORTED_ROUTER_TASK_TYPES = [
+    "startup",
+    "analyze",
+    "impl",
+    "repair",
+    "docs",
+    "finalize",
+];
+const SUPPORTED_ROUTER_TRUST_TIERS = ["sandbox", "standard", "trusted"];
+const SUPPORTED_ROUTER_COST_TIERS = ["low", "medium", "high"];
+const SUPPORTED_ROUTER_QUOTA_POLICIES = [
+    "best-effort",
+    "rate-limited",
+    "reserved",
+];
 const SUPPORTED_LIFECYCLE_STATES = [
     "backlog",
     "in_progress",
@@ -53,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)) {
@@ -325,6 +378,126 @@ function validateConfig(config) {
                     }
                 }
             }
+            if ("routerPolicy" in config.execution && config.execution.routerPolicy !== undefined) {
+                if (!isPlainObject(config.execution.routerPolicy)) {
+                    result.valid = false;
+                    result.errors.push("execution.routerPolicy must be a plain object");
+                }
+                else {
+                    const routerPolicy = config.execution.routerPolicy;
+                    const providerKeys = isPlainObject(config.execution.providers)
+                        ? new Set(Object.keys(config.execution.providers))
+                        : null;
+                    if ("allowCrossProviderFallback" in routerPolicy &&
+                        routerPolicy.allowCrossProviderFallback !== undefined &&
+                        !isBoolean(routerPolicy.allowCrossProviderFallback)) {
+                        result.valid = false;
+                        result.errors.push("execution.routerPolicy.allowCrossProviderFallback must be a boolean");
+                    }
+                    if (isBoolean(config.execution.allowCrossAgentFallback) &&
+                        isBoolean(routerPolicy.allowCrossProviderFallback) &&
+                        config.execution.allowCrossAgentFallback !== routerPolicy.allowCrossProviderFallback) {
+                        result.valid = false;
+                        result.errors.push("execution fallback policy is ambiguous: allowCrossAgentFallback conflicts with execution.routerPolicy.allowCrossProviderFallback");
+                    }
+                    if ("defaultWorkerPool" in routerPolicy && routerPolicy.defaultWorkerPool !== undefined) {
+                        if (!isPlainObject(routerPolicy.defaultWorkerPool)) {
+                            result.valid = false;
+                            result.errors.push("execution.routerPolicy.defaultWorkerPool must be a plain object");
+                        }
+                        else {
+                            if ("maxActiveWorkers" in routerPolicy.defaultWorkerPool &&
+                                routerPolicy.defaultWorkerPool.maxActiveWorkers !== undefined &&
+                                !isPositiveInteger(routerPolicy.defaultWorkerPool.maxActiveWorkers)) {
+                                result.valid = false;
+                                result.errors.push("execution.routerPolicy.defaultWorkerPool.maxActiveWorkers must be a positive integer");
+                            }
+                            if ("maxActiveSlots" in routerPolicy.defaultWorkerPool &&
+                                routerPolicy.defaultWorkerPool.maxActiveSlots !== undefined &&
+                                !isPositiveInteger(routerPolicy.defaultWorkerPool.maxActiveSlots)) {
+                                result.valid = false;
+                                result.errors.push("execution.routerPolicy.defaultWorkerPool.maxActiveSlots must be a positive integer");
+                            }
+                        }
+                    }
+                    if ("providerRegistry" in routerPolicy && routerPolicy.providerRegistry !== undefined) {
+                        if (!isPlainObject(routerPolicy.providerRegistry)) {
+                            result.valid = false;
+                            result.errors.push("execution.routerPolicy.providerRegistry must be a plain object");
+                        }
+                        else {
+                            for (const [providerName, providerPolicy] of Object.entries(routerPolicy.providerRegistry)) {
+                                if (providerKeys && !providerKeys.has(providerName)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry contains unknown provider: ${providerName}`);
+                                }
+                                if (!isPlainObject(providerPolicy)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry.${providerName} must be a plain object`);
+                                    continue;
+                                }
+                                if ("eligibleRoles" in providerPolicy && providerPolicy.eligibleRoles !== undefined) {
+                                    if (!Array.isArray(providerPolicy.eligibleRoles) ||
+                                        !providerPolicy.eligibleRoles.every((role) => isString(role) &&
+                                            SUPPORTED_EXECUTION_ROLES.includes(role))) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.eligibleRoles must contain only supported execution roles`);
+                                    }
+                                }
+                                if ("capabilities" in providerPolicy && providerPolicy.capabilities !== undefined) {
+                                    if (!Array.isArray(providerPolicy.capabilities) ||
+                                        !providerPolicy.capabilities.every((capability) => isString(capability) &&
+                                            SUPPORTED_ROUTER_CAPABILITIES.includes(capability))) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.capabilities must contain only: orchestration, analysis, implementation, repair, docs, finalization`);
+                                    }
+                                }
+                                if ("taskTypes" in providerPolicy && providerPolicy.taskTypes !== undefined) {
+                                    if (!Array.isArray(providerPolicy.taskTypes) ||
+                                        !providerPolicy.taskTypes.every((taskType) => isString(taskType) &&
+                                            SUPPORTED_ROUTER_TASK_TYPES.includes(taskType))) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.taskTypes must contain only: startup, analyze, impl, repair, docs, finalize`);
+                                    }
+                                }
+                                if ("trustTier" in providerPolicy && providerPolicy.trustTier !== undefined) {
+                                    if (!isString(providerPolicy.trustTier) ||
+                                        !SUPPORTED_ROUTER_TRUST_TIERS.includes(providerPolicy.trustTier)) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.trustTier must be one of: sandbox, standard, trusted`);
+                                    }
+                                }
+                                if ("costTier" in providerPolicy && providerPolicy.costTier !== undefined) {
+                                    if (!isString(providerPolicy.costTier) ||
+                                        !SUPPORTED_ROUTER_COST_TIERS.includes(providerPolicy.costTier)) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.costTier must be one of: low, medium, high`);
+                                    }
+                                }
+                                if ("quotaPolicy" in providerPolicy && providerPolicy.quotaPolicy !== undefined) {
+                                    if (!isString(providerPolicy.quotaPolicy) ||
+                                        !SUPPORTED_ROUTER_QUOTA_POLICIES.includes(providerPolicy.quotaPolicy)) {
+                                        result.valid = false;
+                                        result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.quotaPolicy must be one of: best-effort, rate-limited, reserved`);
+                                    }
+                                }
+                                if ("fallbackEligible" in providerPolicy &&
+                                    providerPolicy.fallbackEligible !== undefined &&
+                                    !isBoolean(providerPolicy.fallbackEligible)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.fallbackEligible must be a boolean`);
+                                }
+                                if ("maxActiveSlots" in providerPolicy &&
+                                    providerPolicy.maxActiveSlots !== undefined &&
+                                    !isPositiveInteger(providerPolicy.maxActiveSlots)) {
+                                    result.valid = false;
+                                    result.errors.push(`execution.routerPolicy.providerRegistry.${providerName}.maxActiveSlots must be a positive integer`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
     // finalize
@@ -651,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",
@@ -666,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}**`,