@lsctech/polaris 0.5.11 → 0.5.13

package/dist/qc/repair-packets.js

@@ -78,6 +78,16 @@ function subsystemFromFilePath(filePath) {
     const lastSlash = filePath.lastIndexOf("/");
     return lastSlash === -1 ? "root" : filePath.slice(0, lastSlash);
 }
+function deriveSourceQcRunId(finding, fallbackRunId) {
+    // Some findingId formats encode the source QC run as `<provider>-<index>-<runId>`
+    // (e.g. coderabbit-1-1783818427443). Prefer that provenance over the result
+    // run ID so packet sourceQcRunIds match the runs that emitted the findings.
+    const match = finding.findingId.match(/^(.+?)-(\d+)-(\d+)$/);
+    if (match) {
+        return `${match[1]}-${match[3]}`;
+    }
+    return fallbackRunId;
+}
 function enrichFinding(finding, config, sourceQcRunId) {
     return {
         ...finding,
@@ -85,7 +95,7 @@ function enrichFinding(finding, config, sourceQcRunId) {
         risk: riskLevel(finding),
         confidenceBand: confidenceBand(finding),
         subsystem: subsystemFromFilePath(finding.filePath),
-        sourceQcRunId,
+        sourceQcRunId: deriveSourceQcRunId(finding, sourceQcRunId),
     };
 }
 /**
@@ -213,6 +223,8 @@ function buildPacket(group, index, clusterId, round, allRunIds, validationComman
     const packetId = `pkt-${clusterId}-r${round}-${String(index).padStart(3, "0")}`;
     const findingIds = group.map((f) => f.findingId).sort();
     const sourceRunIds = [...new Set(group.map((f) => f.sourceQcRunId))].sort();
+    // Preserve the artifact run ID while also capturing the finding-level source run.
+    const combinedSourceRunIds = [...new Set([...allRunIds, ...sourceRunIds])].sort();
     const severityFloor = group.reduce((acc, f) => (0, severity_js_1.maxSeverity)(acc, f.severity), "info");
     const categories = [...new Set(group.map((f) => f.category).filter(Boolean))].sort();
     const filePaths = group.map((f) => f.filePath).filter((f) => Boolean(f));
@@ -230,7 +242,7 @@ function buildPacket(group, index, clusterId, round, allRunIds, validationComman
         packetId,
         round,
         clusterId,
-        sourceQcRunIds: sourceRunIds.length > 0 ? sourceRunIds : allRunIds,
+        sourceQcRunIds: combinedSourceRunIds,
         findingIds,
         severityFloor,
         rootCauseHint,
@@ -346,12 +358,13 @@ function compileRepairPackets(input) {
         packets.push(buildPacket(group, packets.length, clusterId, round, allRunIds, validationCommands, compiledAt));
     }
     const finalPackets = assignParallelGroups(packets);
+    const manifestSourceRunIds = [...new Set(finalPackets.flatMap((p) => p.sourceQcRunIds))].sort();
     const manifest = {
         schemaVersion: "1.0",
         clusterId,
         round,
         compiledAt,
-        sourceQcRunIds: allRunIds,
+        sourceQcRunIds: manifestSourceRunIds.length > 0 ? manifestSourceRunIds : allRunIds,
         packets: finalPackets,
     };
     const manifestPath = getRepairPacketManifestPath(clusterId, round, repoRoot);

package/dist/qc/routing.js

@@ -12,6 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decideRepairRouting = decideRepairRouting;
 const security_category_js_1 = require("./security-category.js");
 const severity_js_1 = require("./severity.js");
+function isStateRepairCategory(category) {
+    return category === "state-repair";
+}
 function getBlockThreshold(config, context) {
     const route = context.routeName ? config.routes?.[context.routeName] : undefined;
     return route?.blockThreshold ?? config.severityThresholds?.block ?? "high";
@@ -34,6 +37,9 @@ function decideRepairRouting(finding, config, autofixEligible, context = {}) {
     if ((0, security_category_js_1.isSecurityCategory)(finding.category)) {
         return "operator-review";
     }
+    if (isStateRepairCategory(finding.category)) {
+        return "operator-review";
+    }
     const attribution = finding.attribution;
     const clearAttribution = attribution.confidence === "high" || attribution.confidence === "medium";
     if (autofixEligible && clearAttribution && attribution.childId) {

package/dist/qc/types.js

@@ -7,3 +7,6 @@
  * shapes so that Polaris can support multiple QC backends without vendor lock-in.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QC_RESOLUTION_OUTCOMES = void 0;
+/** Allowed outcomes for an operator resolution artifact. */
+exports.QC_RESOLUTION_OUTCOMES = ["pass", "no-repairable"];

package/dist/run-health/index.js

@@ -150,6 +150,18 @@ function appendSymptom(runId, symptom, repoRoot) {
         symptoms: [...existing.symptoms, symptom],
         updated_at: new Date().toISOString(),
     };
+    // A later high/critical symptom means a previously resolved Medic consult is
+    // no longer satisfied; reopen it so closeout/medic gates do not pass on a
+    // stale resolved decision.
+    if (existing.medic_consult?.status === "resolved" &&
+        (symptom.severity === "critical" || symptom.severity === "high")) {
+        updated.medic_consult = {
+            ...existing.medic_consult,
+            status: "in-progress",
+            resolved_at: undefined,
+            resolution_notes: undefined,
+        };
+    }
     const validation = (0, schema_js_1.validateRunHealthReport)(updated);
     if (!validation.valid) {
         throw new Error(`Appended symptom produces invalid report:\n${validation.errors.join("\n")}`);

package/dist/skill-packet/generator.js

@@ -1,9 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUPPORTED_SKILLS = exports.SKILL_ROLE_MAP = void 0;
 exports.generateSetupBootstrapPacket = generateSetupBootstrapPacket;
 exports.generateSkillPacket = generateSkillPacket;
 const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 exports.SKILL_ROLE_MAP = {
     analyze: "Analyst",
     run: "Foreman",
@@ -362,7 +368,37 @@ function buildCatalogPacket() {
         ],
     };
 }
-function buildReconcilePacket() {
+function buildReconcilePacket(_config, options) {
+    const repoRoot = node_path_1.default.resolve(options?.repoRoot ?? process.cwd());
+    const issueId = resolveIssueId(repoRoot, options?.issueId);
+    const runId = buildReconcileRunId(issueId);
+    const changedFiles = getReconcileChangedFiles(repoRoot);
+    const affectedFolders = resolveAffectedFolders(repoRoot, changedFiles);
+    if (affectedFolders.length === 0) {
+        return buildBlockedReconcilePacket(runId, issueId, repoRoot);
+    }
+    const allowedWritePaths = affectedFolders.flatMap((folder) => {
+        const paths = [node_path_1.default.join(repoRoot, folder, "POLARIS.md")];
+        const summaryPath = node_path_1.default.join(repoRoot, folder, "SUMMARY.md");
+        if (node_fs_1.default.existsSync(summaryPath)) {
+            paths.push(summaryPath);
+        }
+        return paths;
+    });
+    const workInventory = {
+        affected_folders: affectedFolders,
+        all_changed_files: changedFiles,
+        child_summaries: [],
+        pending_cognition_notes: [],
+        polaris_md_files: Object.fromEntries(affectedFolders.map((folder) => [
+            folder,
+            readFileOrNull(node_path_1.default.join(repoRoot, folder, "POLARIS.md")),
+        ])),
+        summary_md_files: Object.fromEntries(affectedFolders.map((folder) => [
+            folder,
+            readFileOrNull(node_path_1.default.join(repoRoot, folder, "SUMMARY.md")),
+        ])),
+    };
     return {
         authority_boundaries: [
             "Read packet-scoped folders and their POLARIS.md and SUMMARY.md files",
@@ -389,9 +425,204 @@ function buildReconcilePacket() {
             "A requested write falls outside packet-allowed paths",
             "Work evidence is missing or contradictory",
         ],
+        packet_kind: "reconcile",
+        run_id: runId,
+        issue_id: issueId,
+        affected_folders: affectedFolders,
+        work_inventory: workInventory,
+        allowed_write_paths: allowedWritePaths,
+        prohibited_write_paths: [repoRoot],
+        constraints: {
+            max_summary_addition_lines: 50,
+        },
     };
 }
-function generateSkillPacket(skillName, config) {
+function buildBlockedReconcilePacket(runId, issueId, repoRoot) {
+    return {
+        authority_boundaries: [
+            "Read packet-scoped folders and their POLARIS.md and SUMMARY.md files",
+            "Update cognition files only within packet-allowed write paths",
+            "Create one sealed local cognition commit",
+        ],
+        prohibited_actions: [
+            "Modify implementation source code, tests, or configuration",
+            "Move, ingest, classify, or promote documents",
+            "Write outside packet-allowed paths",
+            "Call polaris loop continue or polaris finalize",
+            "Git push or create a pull request",
+            "Fabricate affected folders or work inventory when no git diff is available",
+        ],
+        allowed_outputs: [
+            "Updated POLARIS.md and SUMMARY.md files in packet-allowed paths",
+            "A sealed local cognition commit",
+        ],
+        deliverables: [
+            "Packet-scoped cognition reconciled with completed work",
+            "All cognition changes recorded in one sealed local commit",
+        ],
+        stop_conditions: [
+            "All packet-scoped cognition reconciled",
+            "A requested write falls outside packet-allowed paths",
+            "Work evidence is missing or contradictory",
+            "No git diff is available to scope reconciliation",
+        ],
+        packet_kind: "reconcile",
+        run_id: runId,
+        issue_id: issueId,
+        affected_folders: [],
+        work_inventory: {
+            affected_folders: [],
+            all_changed_files: [],
+            child_summaries: [],
+            pending_cognition_notes: [],
+            polaris_md_files: {},
+            summary_md_files: {},
+        },
+        allowed_write_paths: [],
+        prohibited_write_paths: [repoRoot],
+        constraints: {
+            max_summary_addition_lines: 50,
+        },
+    };
+}
+// ── Reconcile helpers ─────────────────────────────────────────────────────────
+function resolveIssueId(repoRoot, explicitIssueId) {
+    if (explicitIssueId)
+        return explicitIssueId;
+    const stateCandidates = [
+        node_path_1.default.join(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json"),
+        node_path_1.default.join(repoRoot, ".polaris", "runs", "current-state.json"),
+    ];
+    for (const candidate of stateCandidates) {
+        try {
+            const raw = JSON.parse(node_fs_1.default.readFileSync(candidate, "utf-8"));
+            const activeChild = raw["active_child"];
+            if (typeof activeChild === "string" && activeChild)
+                return activeChild;
+            const clusterId = raw["cluster_id"];
+            if (typeof clusterId === "string" && clusterId)
+                return clusterId;
+        }
+        catch {
+            // ignore missing or malformed state
+        }
+    }
+    try {
+        const branch = execGit(repoRoot, ["branch", "--show-current"]).join("").trim();
+        const match = /^pol-?(\d+)(?:-.*)?$/i.exec(branch);
+        if (match && match[1]) {
+            return `POL-${match[1]}`;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return "unknown";
+}
+function buildReconcileRunId(issueId) {
+    const slug = issueId.replace(/\s+/g, "-");
+    const date = new Date().toISOString().slice(0, 10);
+    // Minimal sequence: 001 for now; each call is a distinct run by packet_id.
+    const seq = "001";
+    return `polaris-reconcile-${slug}-${date}-${seq}`;
+}
+function getReconcileChangedFiles(repoRoot) {
+    const files = new Set();
+    try {
+        for (const file of execGit(repoRoot, ["diff", "--name-only", "HEAD"])) {
+            if (file)
+                files.add(file);
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        const base = resolveReconcileBase(repoRoot);
+        if (base) {
+            for (const file of execGit(repoRoot, ["diff", "--name-only", `${base}..HEAD`])) {
+                if (file)
+                    files.add(file);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [...files].sort();
+}
+function resolveReconcileBase(repoRoot) {
+    const candidates = [
+        resolveRemoteDefaultBranch(repoRoot),
+        "origin/main",
+        "origin/master",
+        "main",
+        "master",
+    ];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            const base = execGit(repoRoot, ["merge-base", "HEAD", candidate]).join("").trim();
+            if (base)
+                return base;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+function resolveRemoteDefaultBranch(repoRoot) {
+    try {
+        const ref = execGit(repoRoot, ["rev-parse", "--abbrev-ref", "refs/remotes/origin/HEAD"]).join("").trim();
+        return ref || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveAffectedFolders(repoRoot, changedFiles) {
+    const routeMap = loadFileRouteMap(repoRoot);
+    const folders = new Set();
+    for (const file of changedFiles) {
+        const entry = routeMap[file];
+        if (entry && typeof entry.route === "string") {
+            folders.add(entry.route.replace(/\/+$/, "") + "/");
+        }
+    }
+    return [...folders].sort();
+}
+function loadFileRouteMap(repoRoot) {
+    const mapPath = node_path_1.default.join(repoRoot, ".polaris", "map", "file-routes.json");
+    try {
+        const raw = JSON.parse(node_fs_1.default.readFileSync(mapPath, "utf-8"));
+        const normalized = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (value && typeof value === "object") {
+                const entry = value;
+                normalized[key] = { route: typeof entry.route === "string" ? entry.route : undefined };
+            }
+        }
+        return normalized;
+    }
+    catch {
+        return {};
+    }
+}
+function readFileOrNull(filePath) {
+    try {
+        return node_fs_1.default.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function execGit(repoRoot, args) {
+    const output = (0, node_child_process_1.execFileSync)("git", args, { cwd: repoRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return output.split("\n").filter(Boolean);
+}
+function generateSkillPacket(skillName, config, options) {
     const active_role = exports.SKILL_ROLE_MAP[skillName];
     const role_summary = ROLE_SUMMARIES[active_role];
     const generated_at = new Date().toISOString();
@@ -425,7 +656,7 @@ function generateSkillPacket(skillName, config) {
             body = buildCatalogPacket();
             break;
         case "reconcile":
-            body = buildReconcilePacket();
+            body = buildReconcilePacket(config, options);
             break;
     }
     return {

package/dist/smartdocs-engine/canon-check.js

@@ -43,7 +43,7 @@ function locateCanonFiles(changedFiles, repoRoot) {
             canon.add(polarisMd);
     }
     // Active doctrine
-    const doctrineDir = (0, node_path_1.join)(repoRoot, "docs", "doctrine", "active");
+    const doctrineDir = (0, node_path_1.join)(repoRoot, "smartdocs", "doctrine", "active");
     if ((0, node_fs_1.existsSync)(doctrineDir)) {
         for (const f of (0, node_fs_1.readdirSync)(doctrineDir)) {
             if (f.endsWith(".md") && (0, node_path_1.basename)(f).toLowerCase() !== "summary.md")
@@ -61,7 +61,7 @@ function locateCanonFiles(changedFiles, repoRoot) {
         }
     }
     for (const specSubdir of ["active", "implemented"]) {
-        const specDir = (0, node_path_1.join)(repoRoot, "docs", "specs", specSubdir);
+        const specDir = (0, node_path_1.join)(repoRoot, "smartdocs", "specs", specSubdir);
         if (!(0, node_fs_1.existsSync)(specDir))
             continue;
         for (const f of (0, node_fs_1.readdirSync)(specDir)) {
@@ -124,7 +124,7 @@ function checkPolarisMd(canonFile, changedFiles, repoRoot) {
                 // Determine conflict type based on rule text and changed file
                 let conflictType = "stale-implementation";
                 const ext = changedFile.split(".").pop()?.toLowerCase() ?? "";
-                const isDocFile = ext === "md" || changedFile.startsWith("docs/");
+                const isDocFile = ext === "md" || changedFile.startsWith("smartdocs/");
                 const hasDocKeywords = /\b(doc|documentation|readme|guide|spec)\b/i.test(lower);
                 const hasCandidateKeywords = /\b(candidate|divergence|proposal)\b/i.test(lower);
                 if (isDocFile || hasDocKeywords) {
@@ -282,7 +282,7 @@ function runCanonCheck(options) {
     return result;
 }
 function writeStaleDraftDocs(conflicts, repoRoot, childId) {
-    const rawDir = (0, node_path_1.join)(repoRoot, "docs", "raw");
+    const rawDir = (0, node_path_1.join)(repoRoot, "smartdocs", "raw");
     try {
         (0, node_fs_1.mkdirSync)(rawDir, { recursive: true });
         for (const conflict of conflicts) {
@@ -309,7 +309,7 @@ function writeStaleDraftDocs(conflicts, repoRoot, childId) {
     }
 }
 function writeCandidateDraftDocs(conflicts, repoRoot, childId) {
-    const candidateDir = (0, node_path_1.join)(repoRoot, "docs", "doctrine", "candidate");
+    const candidateDir = (0, node_path_1.join)(repoRoot, "smartdocs", "doctrine", "candidate");
     try {
         (0, node_fs_1.mkdirSync)(candidateDir, { recursive: true });
         for (const conflict of conflicts) {

package/dist/smartdocs-engine/index.js

@@ -38,6 +38,32 @@ function printSeedAllResult(filename, dryRun, { written, skippedExists, skippedD
     }
     console.log(`${leadingBlankLine ? "\n" : ""}Done. ${written.length} written, ${skippedExists.length} skipped (exists), ${skippedDraft.length} skipped (draft)${extraSummary}.`);
 }
+function printReconcileReport(report, dryRun) {
+    for (const path of report.created) {
+        console.log(`${dryRun ? "[dry-run] would create" : "created"}: ${path}`);
+    }
+    for (const path of report.regenerated) {
+        console.log(`${dryRun ? "[dry-run] would regenerate" : "regenerated"}: ${path}`);
+    }
+    for (const path of report.regeneratedRegion) {
+        console.log(`${dryRun ? "[dry-run] would regenerate (region)" : "regenerated (region)"}: ${path}`);
+    }
+    for (const path of report.skipped) {
+        console.log(`skipped (up-to-date): ${path}`);
+    }
+    for (const path of report.blocked) {
+        console.log(`blocked (manual migration): ${path}`);
+    }
+    if (report.skippedRoot) {
+        console.log(`skipped (root): ${report.skippedRoot.path}/ (${report.skippedRoot.reason})`);
+    }
+    if (report.skippedIneligible.length > 0) {
+        for (const entry of report.skippedIneligible) {
+            console.log(`skipped (ineligible): ${entry.path}/ (${entry.reason})`);
+        }
+    }
+    console.log(`\nDone. ${report.created.length} created, ${report.regenerated.length} regenerated, ${report.regeneratedRegion.length} regenerated (region), ${report.skipped.length} skipped, ${report.blocked.length} blocked.`);
+}
 /**
  * Build and return the top-level "docs" Commander command group for Polaris docs lifecycle workflows.
  *
@@ -434,6 +460,34 @@ function createDocsCommand(options = {}) {
             console.log(`skipped (draft exists): ${targetPath}/index.md`);
         }
     });
+    docs
+        .command("reconcile")
+        .description("Reconcile POLARIS.md and SUMMARY.md files across all eligible route folders")
+        .option("--all", "Reconcile all eligible directories")
+        .option("--dry-run", "Print what would be changed without writing files")
+        .option("--include-agent-folders", "Include .codex, .claude, .agents folders (default: skip)")
+        .option("--include-hidden", "Include all hidden directories starting with . (default: skip)")
+        .option("--include-root", "Include root directory (default: skip)")
+        .option("-r, --repo-root <path>", "Repository root", defaultRepoRoot)
+        .action((options) => {
+        if (!options.all) {
+            console.error("Error: provide --all to reconcile all eligible directories");
+            process.exit(1);
+        }
+        try {
+            const report = (0, seed_instructions_js_1.reconcileAll)(options.repoRoot, {
+                dryRun: options.dryRun,
+                includeAgentFolders: options.includeAgentFolders,
+                includeHidden: options.includeHidden,
+                includeRoot: options.includeRoot,
+            });
+            printReconcileReport(report, options.dryRun);
+        }
+        catch (err) {
+            console.error(`polaris docs reconcile: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
     docs
         .command("backfill-type")
         .description("Add OKF-conformant `type` frontmatter to existing smartdocs/ files that are missing it, " +