@lsctech/polaris 0.4.4 → 0.4.6

package/dist/cli/adopt-command.js

@@ -140,8 +140,9 @@ async function runAdoptPhase(phase, repoRoot, options = {}) {
             if (!options.inventory || !options.plan) {
                 throw new Error("consolidate requires inventory and plan");
             }
+            const dryRun = options.plan.dry_run ?? options.dryRun ?? false;
             await (0, adopt_smartdocs_js_1.migrateSmartDocs)(options.plan, repoRoot);
-            await (0, adopt_genesis_js_1.reconcileAgentFiles)(repoRoot);
+            await (0, adopt_genesis_js_1.reconcileAgentFiles)(repoRoot, { dryRun });
             break;
         }
         case "map": {

package/dist/cli/adopt-genesis.js

@@ -25,7 +25,9 @@ function isAlreadyPointer(content) {
     });
     return meaningfulLines.length <= 3 && meaningfulLines.some((line) => line.includes("POLARIS_RULES.md"));
 }
-function appendGenesisProvenance(repoRoot, records) {
+function appendGenesisProvenance(repoRoot, records, dryRun = false) {
+    if (dryRun)
+        return;
     if (records.length === 0)
         return;
     const provenancePath = (0, node_path_1.join)(repoRoot, ".polaris", "adoption-provenance.json");
@@ -57,6 +59,7 @@ async function reconcileAgentFiles(repoRoot, options) {
     const provenanceRecords = [];
     const now = options?.now ?? new Date();
     const timestamp = now.toISOString();
+    const dryRun = options?.dryRun ?? false;
     for (const file of AGENT_FILES) {
         const filePath = (0, node_path_1.join)(repoRoot, file);
         if (!(0, node_fs_1.existsSync)(filePath)) {
@@ -74,6 +77,11 @@ async function reconcileAgentFiles(repoRoot, options) {
             });
             continue;
         }
+        if (dryRun) {
+            process.stdout.write(`[dry-run] would prompt to compress and archive ${file} as genesis doctrine\n`);
+            results.push({ file, outcome: "skipped" });
+            continue;
+        }
         const rl = (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout });
         let answer;
         try {
@@ -146,11 +154,13 @@ async function reconcileAgentFiles(repoRoot, options) {
         const dateStr = formatDate(now);
         const genesisPath = `smartdocs/doctrine/active/${dateStr}-genesis-agent-doctrine.md`;
         const genesisFullPath = (0, node_path_1.join)(repoRoot, genesisPath);
-        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, "smartdocs/doctrine/active"), { recursive: true });
-        (0, node_fs_1.writeFileSync)(genesisFullPath, distilled, "utf8");
-        const thinPointer = `# Agent Instructions\n\nRead [POLARIS_RULES.md](POLARIS_RULES.md) before beginning any work.\n\n` +
-            `<!-- genesis doctrine archived: ${genesisPath} -->\n`;
-        (0, node_fs_1.writeFileSync)(filePath, thinPointer, "utf8");
+        if (!dryRun) {
+            (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, "smartdocs/doctrine/active"), { recursive: true });
+            (0, node_fs_1.writeFileSync)(genesisFullPath, distilled, "utf8");
+            const thinPointer = `# Agent Instructions\n\nRead [POLARIS_RULES.md](POLARIS_RULES.md) before beginning any work.\n\n` +
+                `<!-- genesis doctrine archived: ${genesisPath} -->\n`;
+            (0, node_fs_1.writeFileSync)(filePath, thinPointer, "utf8");
+        }
         results.push({ file, outcome: "compressed", genesisPath });
         provenanceRecords.push({
             source_path: file,
@@ -160,6 +170,6 @@ async function reconcileAgentFiles(repoRoot, options) {
             migration_outcome: "compressed",
         });
     }
-    appendGenesisProvenance(repoRoot, provenanceRecords);
+    appendGenesisProvenance(repoRoot, provenanceRecords, dryRun);
     return results;
 }

package/dist/cli/adopt-smartdocs.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldBundleRoot = scaffoldBundleRoot;
 exports.migrateSmartDocs = migrateSmartDocs;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
@@ -110,64 +111,100 @@ function normalizeStatus(step, status, completedAt) {
         error: status === "completed" || status === "skipped" ? undefined : step.error,
     };
 }
+const SMARTDOCS_BUNDLE_INDEX_CONTENT = `---\nokf_version: "0.1"\n---\n\n# SmartDocs — Polaris Cognition Bundle\n\n# Governance\n\n- [Docs authority model](specs/active/docs-authority-model.md)\n- [Doctrine](doctrine/active/)\n\n# Routes\n\n<!-- Routes placeholder: dynamic file-routes.json generation deferred. -->\n`;
+const SMARTDOCS_BUNDLE_LOG_CONTENT = "# SmartDocs — Change Log\n";
+function scaffoldBundleRoot(repoRoot, dryRun = false) {
+    const smartdocsDir = (0, node_path_1.join)(repoRoot, "smartdocs");
+    if (dryRun) {
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(smartdocsDir, "index.md"))) {
+            process.stdout.write(`[dry-run] would create smartdocs/index.md\n`);
+        }
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(smartdocsDir, "log.md"))) {
+            process.stdout.write(`[dry-run] would create smartdocs/log.md\n`);
+        }
+        return;
+    }
+    (0, node_fs_1.mkdirSync)(smartdocsDir, { recursive: true });
+    const indexPath = (0, node_path_1.join)(smartdocsDir, "index.md");
+    if (!(0, node_fs_1.existsSync)(indexPath)) {
+        (0, node_fs_1.writeFileSync)(indexPath, SMARTDOCS_BUNDLE_INDEX_CONTENT, "utf-8");
+    }
+    const logPath = (0, node_path_1.join)(smartdocsDir, "log.md");
+    if (!(0, node_fs_1.existsSync)(logPath)) {
+        (0, node_fs_1.writeFileSync)(logPath, SMARTDOCS_BUNDLE_LOG_CONTENT, "utf-8");
+    }
+}
 function migrateSmartDocs(plan, repoRoot = (0, node_path_1.resolve)(process.cwd())) {
     const effectivePlan = loadPlan(repoRoot, plan);
     const provenanceRecords = [];
     const seenRecords = existingRecordKeys(repoRoot);
     const now = new Date().toISOString();
+    const dryRun = effectivePlan.dry_run ?? false;
     for (let index = 0; index < effectivePlan.steps.length; index += 1) {
         const step = effectivePlan.steps[index];
         if (step.category !== "smartdocs-migrate" || COMPLETE_STATUSES.has(step.status)) {
             continue;
         }
         if (step.routing !== undefined && step.routing !== "candidate") {
-            effectivePlan.steps[index] = {
-                ...step,
-                status: "skipped",
-                completed_at: now,
-                error: `routing not candidate: ${step.routing}`,
-            };
+            if (!dryRun) {
+                effectivePlan.steps[index] = {
+                    ...step,
+                    status: "skipped",
+                    completed_at: now,
+                    error: `routing not candidate: ${step.routing}`,
+                };
+            }
             continue;
         }
         const sourcePath = step.source_path ?? "";
         const destPath = step.dest_path ?? `smartdocs/raw/${(0, node_path_1.basename)(sourcePath || `step-${step.order}.md`)}`;
         if (!sourcePath) {
-            effectivePlan.steps[index] = normalizeStatus(step, "skipped", now);
+            if (!dryRun)
+                effectivePlan.steps[index] = normalizeStatus(step, "skipped", now);
             continue;
         }
         if (isExcludedSourcePath(sourcePath)) {
-            effectivePlan.steps[index] = normalizeStatus(step, "skipped", now);
+            if (!dryRun)
+                effectivePlan.steps[index] = normalizeStatus(step, "skipped", now);
             continue;
         }
         const sourceAbs = (0, node_path_1.join)(repoRoot, sourcePath);
         const destAbs = (0, node_path_1.join)(repoRoot, destPath);
-        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destAbs), { recursive: true });
         if (!(0, node_fs_1.existsSync)(sourceAbs)) {
             if ((0, node_fs_1.existsSync)(destAbs)) {
-                effectivePlan.steps[index] = normalizeStatus(step, "completed", step.completed_at ?? now);
-                const record = {
-                    step_id: step.step_id,
-                    source_path: sourcePath,
-                    dest_path: destPath,
-                    migrated_at: step.completed_at ?? now,
-                    migration_run_id: effectivePlan.plan_id,
-                    transport: "reconciled",
-                };
-                if (!seenRecords.has(recordKey(record))) {
-                    provenanceRecords.push(record);
-                    seenRecords.add(recordKey(record));
+                if (!dryRun) {
+                    effectivePlan.steps[index] = normalizeStatus(step, "completed", step.completed_at ?? now);
+                    const record = {
+                        step_id: step.step_id,
+                        source_path: sourcePath,
+                        dest_path: destPath,
+                        migrated_at: step.completed_at ?? now,
+                        migration_run_id: effectivePlan.plan_id,
+                        transport: "reconciled",
+                    };
+                    if (!seenRecords.has(recordKey(record))) {
+                        provenanceRecords.push(record);
+                        seenRecords.add(recordKey(record));
+                    }
                 }
             }
             else {
-                effectivePlan.steps[index] = {
-                    ...step,
-                    status: "skipped",
-                    completed_at: now,
-                    error: `source missing: ${sourcePath}`,
-                };
+                if (!dryRun) {
+                    effectivePlan.steps[index] = {
+                        ...step,
+                        status: "skipped",
+                        completed_at: now,
+                        error: `source missing: ${sourcePath}`,
+                    };
+                }
             }
             continue;
         }
+        if (dryRun) {
+            process.stdout.write(`[dry-run] would move ${sourcePath} → ${destPath}\n`);
+            continue;
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destAbs), { recursive: true });
         let transport = "git mv";
         try {
             (0, node_child_process_1.execFileSync)("git", ["mv", "--", sourcePath, destPath], {
@@ -194,8 +231,11 @@ function migrateSmartDocs(plan, repoRoot = (0, node_path_1.resolve)(process.cwd(
             seenRecords.add(recordKey(record));
         }
     }
-    savePlan(repoRoot, effectivePlan);
-    saveProvenance(repoRoot, provenanceRecords);
-    Object.assign(plan, effectivePlan);
+    scaffoldBundleRoot(repoRoot, dryRun);
+    if (!dryRun) {
+        savePlan(repoRoot, effectivePlan);
+        saveProvenance(repoRoot, provenanceRecords);
+        Object.assign(plan, effectivePlan);
+    }
     return Promise.resolve();
 }

package/dist/cognition/librarian-packet.js

@@ -90,6 +90,7 @@ function generateLibrarianPacket(options) {
     // Prohibited: anything that is not documentation or cognition
     const prohibitedWritePaths = [
         stateFile,
+        node_path_1.default.join(repoRoot, ".polaris", "clusters", clusterId, "cluster-state.json"),
         node_path_1.default.join(repoRoot, ".polaris", "clusters", clusterId, "state.json"),
         node_path_1.default.join(repoRoot, ".taskchain_artifacts"),
         node_path_1.default.join(repoRoot, ".polaris", "runs"),
@@ -143,16 +144,24 @@ function generateLibrarianPacket(options) {
 }
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function resolveStateFile(repoRoot, clusterId) {
-    const canonical = node_path_1.default.join(repoRoot, ".polaris", "clusters", clusterId, "state.json");
-    if (node_fs_1.default.existsSync(canonical))
-        return canonical;
+    // Note: .polaris/clusters/<id>/cluster-state.json is intentionally not a candidate here.
+    // It holds the ClusterState schema (child_states, packet_pointers, ...), not the LoopState
+    // schema (completed_children, run_id, open_children_meta, ...) that readState()/this
+    // function require.
+    // Check per-cluster run-state convention: state.json
+    const legacyState = node_path_1.default.join(repoRoot, ".polaris", "clusters", clusterId, "state.json");
+    if (node_fs_1.default.existsSync(legacyState))
+        return legacyState;
+    // Check taskchain artifacts fallback
     const taskchain = node_path_1.default.join(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json");
     if (node_fs_1.default.existsSync(taskchain))
         return taskchain;
-    const legacy = node_path_1.default.join(repoRoot, ".polaris", "runs", "current-state.json");
-    if (node_fs_1.default.existsSync(legacy))
-        return legacy;
-    return canonical;
+    // Check legacy runs fallback
+    const legacyRuns = node_path_1.default.join(repoRoot, ".polaris", "runs", "current-state.json");
+    if (node_fs_1.default.existsSync(legacyRuns))
+        return legacyRuns;
+    // Return per-cluster state path as default
+    return legacyState;
 }
 function findResultFile(resultsDir, childId) {
     try {

package/dist/loop/adapters/cli-subtask-bridge.js

@@ -65,6 +65,7 @@ function writeSealedResultFromSummary(packet, parsedSummary) {
     const validation = parsedSummary["validation"] ?? parsedSummary["validation_summary"];
     const sealedResult = {
         run_id: packet.run_id,
+        cluster_id: packet.cluster_id,
         child_id: packet.active_child,
         status: normalizeSealedStatus(parsedSummary["status"]),
     };

package/dist/loop/adapters/terminal-cli.js

@@ -320,6 +320,7 @@ class TerminalCliAdapter {
             const sealedResult = {
                 ...normalized,
                 run_id: packet.run_id,
+                cluster_id: packet.cluster_id,
                 child_id: String(normalized["child_id"] ?? packet.active_child),
                 status: effectiveStatus,
                 commit: typeof normalized["commit"] === "string"

package/dist/loop/body-parser.js

@@ -123,6 +123,10 @@ function parseSections(body) {
 /**
  * Extracts bullet list items from the given text and returns them as trimmed strings.
  *
+ * This is a generic list parser used by all section types (Validation, Acceptance
+ * Criteria, Ordering, Non-goals, etc.). It does NOT strip parenthetical annotations
+ * — that logic is scope-specific and handled separately.
+ *
  * @param text - Section content to scan for bullet list lines (lines starting with `- ` or `* `)
  * @returns The extracted list item strings, trimmed of whitespace; empty items are omitted.
  */
@@ -133,9 +137,25 @@ function parseListItems(text) {
         .map((line) => line.replace(/^\s*[-*]\s+/, '').trim())
         .filter((s) => s.length > 0);
 }
+/**
+ * Removes trailing parenthetical annotations from a string.
+ *
+ * Used exclusively for Scope section items to strip annotations like "(new)" or
+ * "(thread flag through...)" so that allowed_scope entries in worker packets
+ * contain only bare file paths or valid glob patterns.
+ *
+ * @param s - The string to process
+ * @returns The input string with trailing `(...)` removed, re-trimmed
+ */
+function stripTrailingParenthetical(s) {
+    return s.replace(/\s*\([^)]*\)\s*$/, '').trim();
+}
 /**
  * Extracts list items from the first section whose header matches a provided set.
  *
+ * This is a generic section parser that does NOT apply any parenthetical stripping.
+ * For Scope sections, use `findScopeSection` instead.
+ *
  * @param sections - Map of normalized header names to their section content; iteration follows the map's order
  * @param headers - Set of normalized header names to match against section headers
  * @returns An array of parsed list-item strings from the first matching section, or an empty array if no match is found
@@ -148,6 +168,25 @@ function findSection(sections, headers) {
     }
     return [];
 }
+/**
+ * Extracts list items from the Scope section, stripping trailing parenthetical annotations.
+ *
+ * Scope section items often include human-readable annotations like "(new)" or
+ * "(thread flag through...)". These are stripped so that allowed_scope entries in
+ * worker packets contain only bare file paths or valid glob patterns.
+ *
+ * @param sections - Map of normalized header names to their section content
+ * @param headers - Set of normalized Scope header variants (e.g., SCOPE_HEADERS)
+ * @returns An array of scope paths with parentheticals removed, or an empty array if no Scope section is found
+ */
+function findScopeSection(sections, headers) {
+    for (const [header, content] of sections) {
+        if (headers.has(header)) {
+            return parseListItems(content).map(stripTrailingParenthetical).filter((s) => s.length > 0);
+        }
+    }
+    return [];
+}
 /**
  * Returns trimmed prose text from the first section matching a header set.
  * Used for single-paragraph sections (Objective, Context, Goal).
@@ -189,7 +228,7 @@ function parseIssueBody(body) {
         };
     }
     const sections = parseSections(body);
-    const rawScope = findSection(sections, SCOPE_HEADERS);
+    const rawScope = findScopeSection(sections, SCOPE_HEADERS);
     const scopeBlocked = rawScope.length > 0 && rawScope.every((item) => TBD_BLOCKED_RE.test(item));
     const filteredScope = rawScope.filter((item) => !TBD_BLOCKED_RE.test(item));
     return {

package/dist/loop/continue.js

@@ -14,6 +14,8 @@ const canon_check_js_1 = require("../smartdocs-engine/canon-check.js");
 const dispatch_boundary_js_1 = require("./dispatch-boundary.js");
 const ledger_js_1 = require("./ledger.js");
 const librarian_dispatch_js_1 = require("../cognition/librarian-dispatch.js");
+const index_js_1 = require("../tracker/index.js");
+const lifecycle_transition_js_1 = require("../tracker/lifecycle-transition.js");
 /** Resolves the expected sealed result file path for a child from its dispatch metadata. */
 function resolveResultFileForChild(state, childId) {
     const meta = state.open_children_meta?.[childId];
@@ -206,6 +208,10 @@ function countLoopAbortedEvents(telemetryFile, runId) {
         .filter((event) => event.event === "loop-aborted" && event.run_id === runId)
         .length;
 }
+function appendTelemetryEvent(telemetryFile, event) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(telemetryFile), { recursive: true });
+    (0, node_fs_1.appendFileSync)(telemetryFile, JSON.stringify(event) + "\n", "utf-8");
+}
 function resolveTelemetryFilePath(state, repoRoot) {
     const artifactDir = state.artifact_dir ?? (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run");
     return (0, node_path_1.join)(artifactDir, "runs", state.run_id, "telemetry.jsonl");
@@ -430,6 +436,71 @@ function runLoopContinue(options) {
                 process.exit(1);
             }
         }
+        // ── Apply lifecycle transition for child-validation-passed event ───────
+        // Fire-and-forget: tracker mutations must not block state checkpointing.
+        // Policy default targets "in_review" (not "done") — "done" is reserved for
+        // the child-merged event, applied once the delivering PR actually merges.
+        let transitionAdapter;
+        let transitionConfig;
+        const transitionTelemetryFile = resolveTelemetryFilePath(state, repoRoot);
+        try {
+            transitionConfig = (0, loader_js_1.loadConfig)(repoRoot);
+            transitionAdapter = (0, index_js_1.loadTrackerAdapter)(transitionConfig);
+        }
+        catch (err) {
+            appendTelemetryEvent(transitionTelemetryFile, {
+                event: "lifecycle-transition-error",
+                run_id: state.run_id,
+                child_id: completedChild,
+                transition_event: "child-validation-passed",
+                error: `Failed to load config or tracker adapter: ${err instanceof Error ? err.message : String(err)}`,
+                timestamp: new Date().toISOString(),
+            });
+            transitionAdapter = null;
+            transitionConfig = null;
+        }
+        // Note: transitionAdapter may legitimately be null (no tracker adapter configured) —
+        // that's not an error, and applyTransitionSafe/applyTransition handle a null adapter
+        // by returning a skip result. Only skip the attempt entirely when config loading itself
+        // failed (transitionConfig is null).
+        if (transitionConfig) {
+            new lifecycle_transition_js_1.LifecycleTransitionService()
+                .applyTransitionSafe({
+                adapter: transitionAdapter,
+                policy: transitionConfig.tracker?.lifecyclePolicy,
+                taskId: completedChild,
+                event: "child-validation-passed",
+                evidence: {
+                    commit: completionCommit,
+                    validationResults: completionValidation,
+                },
+                timestamp: new Date().toISOString(),
+            })
+                .then((result) => {
+                appendTelemetryEvent(transitionTelemetryFile, {
+                    event: "lifecycle-transition-attempt",
+                    run_id: state.run_id,
+                    child_id: completedChild,
+                    transition_event: result.event,
+                    target_state: result.targetState,
+                    applied: result.applied,
+                    skipped: result.skipped,
+                    skip_reason: result.skipReason,
+                    error: result.error,
+                    timestamp: result.timestamp,
+                });
+            })
+                .catch((err) => {
+                appendTelemetryEvent(transitionTelemetryFile, {
+                    event: "lifecycle-transition-error",
+                    run_id: state.run_id,
+                    child_id: completedChild,
+                    transition_event: "child-validation-passed",
+                    error: err instanceof Error ? err.message : String(err),
+                    timestamp: new Date().toISOString(),
+                });
+            });
+        }
     }
     if (completedChild && completionResultFile) {
         const telemetryFile = resolveTelemetryFilePath(state, repoRoot);

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCanonCheck = runCanonCheck;
+exports.runSmartDocsLinkCheck = runSmartDocsLinkCheck;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const doctrine_js_1 = require("./doctrine.js");
 // Modal verbs that indicate behavioral assertions in doctrine/spec files
 const MODAL_VERBS = /\b(must|never|always|should|required|requires|shall)\b/i;
 // Domains matched by filename keywords
@@ -338,3 +340,81 @@ function writeCandidateDraftDocs(conflicts, repoRoot, childId) {
         // Non-fatal
     }
 }
+/** Subdirectories of smartdocs/ that are subject to strict link checking */
+const STRICT_SMARTDOCS_DIRS = [
+    (0, node_path_1.join)("smartdocs", "doctrine", "candidate"),
+    (0, node_path_1.join)("smartdocs", "doctrine", "active"),
+    (0, node_path_1.join)("smartdocs", "specs", "candidate"),
+    (0, node_path_1.join)("smartdocs", "specs", "active"),
+];
+/**
+ * Recursively walk a directory and return all .md file paths.
+ *
+ * @param dir - Directory to walk
+ * @returns Array of absolute paths to all .md files found recursively
+ */
+function walkMarkdownFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkMarkdownFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+/**
+ * Walk the strict-tier smartdocs directories (candidate/ and active/ under doctrine/ and specs/)
+ * and check every .md file for broken cross-links into smartdocs/.
+ *
+ * Recursively traverses subdirectories to find nested documents.
+ * Files in raw/ are never checked (OKF §5.3 permissive default).
+ * Broken links are reported as SpecConflict entries with type "stale-assumption".
+ *
+ * @param options - Options including repoRoot, runId, and telemetryFile
+ * @returns Object with all detected conflicts and the count of files checked
+ */
+function runSmartDocsLinkCheck(options) {
+    const { repoRoot, runId, telemetryFile, childId } = options;
+    const root = (0, node_path_1.resolve)(repoRoot);
+    const allConflicts = [];
+    let filesChecked = 0;
+    for (const subdir of STRICT_SMARTDOCS_DIRS) {
+        const dir = (0, node_path_1.join)(root, subdir);
+        if (!(0, node_fs_1.existsSync)(dir))
+            continue;
+        const markdownFiles = walkMarkdownFiles(dir);
+        for (const filePath of markdownFiles) {
+            let content;
+            try {
+                content = (0, node_fs_1.readFileSync)(filePath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            filesChecked++;
+            const conflicts = (0, doctrine_js_1.checkSmartDocsLinks)(filePath, content, root);
+            allConflicts.push(...conflicts);
+        }
+    }
+    appendTelemetry(telemetryFile, {
+        event: "smartdocs-link-check-result",
+        run_id: runId,
+        child_id: childId ?? null,
+        files_checked: filesChecked,
+        broken_links: allConflicts.length,
+        conflicts: allConflicts,
+        timestamp: new Date().toISOString(),
+    });
+    return { conflicts: allConflicts, filesChecked };
+}