@lsctech/polaris 0.1.0

package/dist/smartdocs-engine/ingest.js

@@ -0,0 +1,495 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMART_DOCS_SCAFFOLD_DIRS = exports.CANONICAL_TARGET = void 0;
+exports.classifyDoc = classifyDoc;
+exports.ensureDocsScaffold = ensureDocsScaffold;
+exports.ingestDocs = ingestDocs;
+exports.printIngestResults = printIngestResults;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const loader_js_1 = require("../config/loader.js");
+const atlas_js_1 = require("../map/atlas.js");
+const monotonic_timestamp_js_1 = require("../utils/monotonic-timestamp.js");
+const smartdoc_ignore_js_1 = require("./smartdoc-ignore.js");
+const doctrine_js_1 = require("./doctrine.js");
+const summary_delta_js_1 = require("../cognition/summary-delta.js");
+exports.CANONICAL_TARGET = "smartdocs";
+const DOCS_INGEST_STATE_FILE = ".taskchain_artifacts/polaris-docs-ingest/current-state.json";
+const DOCS_INGEST_RUNS_DIR = ".taskchain_artifacts/polaris-docs-ingest/runs";
+const DEFAULT_BATCH_LIMIT = 4;
+const TARGET_DIRS = {
+    "runtime-summary": `${exports.CANONICAL_TARGET}/runtime/summaries`,
+    "run-report": `${exports.CANONICAL_TARGET}/runtime/run-reports`,
+    "spec-raw": `${exports.CANONICAL_TARGET}/raw`,
+    "spec-active": `${exports.CANONICAL_TARGET}/specs/active`,
+    "audit-finding": `${exports.CANONICAL_TARGET}/audits/findings`,
+    "doctrine-candidate": `${exports.CANONICAL_TARGET}/doctrine/active`,
+    architecture: `${exports.CANONICAL_TARGET}/architecture`,
+    decision: `${exports.CANONICAL_TARGET}/decisions`,
+    "deprecated-noise": `${exports.CANONICAL_TARGET}/runtime/generated`,
+};
+exports.SMART_DOCS_SCAFFOLD_DIRS = [
+    exports.CANONICAL_TARGET,
+    ...Object.values(TARGET_DIRS),
+    `${exports.CANONICAL_TARGET}/raw`,
+    `${exports.CANONICAL_TARGET}/specs/implemented`,
+    `${exports.CANONICAL_TARGET}/specs/superseded`,
+    `${exports.CANONICAL_TARGET}/audits/resolved`,
+    `${exports.CANONICAL_TARGET}/doctrine/active`,
+    `${exports.CANONICAL_TARGET}/doctrine/deprecated`,
+];
+const APPROVAL_REQUIRED = new Set(["spec-active", "architecture", "decision"]);
+/**
+ * Conflict detection uses subject-verb-keyword triples rather than bare
+ * verb-keyword pairs. A conflict only fires when both the subject AND the
+ * keyword match between the ingested doc and an active doctrine file.
+ * This prevents false positives such as:
+ *   doctrine:  "SUMMARY.md must contain (standard schema)"
+ *   ingested:  "Workers must not contain stale assumptions"
+ * — same keyword (`contain`), completely different subjects.
+ */
+const MODAL_REQUIRES_RE = /([A-Za-z][\w/.\-]{0,40})\s+(?:must|always)\s+(\w+)/gi;
+const MODAL_PROHIBITS_RE = /([A-Za-z][\w/.\-]{0,40})\s+(?:never|must\s+not)\s+(\w+)/gi;
+const CONFLICT_STOPWORDS = new Set([
+    "this", "that", "with", "from", "have", "been", "will", "when", "then",
+    "else", "each", "every", "also", "note", "not", "used", "only", "be",
+    "are", "the", "and", "for", "its", "any", "all",
+]);
+function readJson(filePath, fallback) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf-8"));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return fallback;
+        }
+        throw error;
+    }
+}
+function frontMatterValue(content, key) {
+    if (!content.startsWith("---\n"))
+        return undefined;
+    const end = content.indexOf("\n---", 4);
+    if (end === -1)
+        return undefined;
+    const lines = content.slice(4, end).split(/\r?\n/);
+    const found = lines.find((line) => line.toLowerCase().startsWith(`${key.toLowerCase()}:`));
+    return found?.slice(found.indexOf(":") + 1).trim().replace(/^["']|["']$/g, "");
+}
+function classifyDoc(content, filePath = "") {
+    const lower = `${filePath}\n${content}`.toLowerCase();
+    const status = frontMatterValue(content, "status")?.toLowerCase();
+    const authority = frontMatterValue(content, "authority")?.toLowerCase();
+    if ((0, node_path_1.basename)(filePath).toLowerCase() === "summary.md") {
+        return "deprecated-noise";
+    }
+    if (status === "deprecated" || lower.includes("deprecated noise") || lower.includes("obsolete")) {
+        return "deprecated-noise";
+    }
+    if (lower.includes("run report") || lower.includes("run-report"))
+        return "run-report";
+    if (lower.includes("runtime summary") || lower.includes("session summary"))
+        return "runtime-summary";
+    if (lower.includes("audit finding") || lower.includes("vulnerability") || lower.includes("security audit")) {
+        return "audit-finding";
+    }
+    if (authority === "doctrine" || lower.includes("doctrine") || lower.includes("must always") || lower.includes("never silently")) {
+        return "doctrine-candidate";
+    }
+    if (lower.includes("architecture decision record") || /^#\s*adr[:\s-]/im.test(content))
+        return "decision";
+    if (authority === "architecture" || lower.includes("architecture") || lower.includes("structural design"))
+        return "architecture";
+    if (status === "active" || lower.includes("active spec"))
+        return "spec-active";
+    if (lower.includes("spec") || lower.includes("acceptance criteria") || lower.includes("implementation plan")) {
+        return "spec-raw";
+    }
+    return "spec-raw";
+}
+function readCurrentState(repoRoot) {
+    return readJson((0, node_path_1.resolve)(repoRoot, DOCS_INGEST_STATE_FILE), {});
+}
+function generateRunId(repoRoot) {
+    const date = new Date().toISOString().slice(0, 10);
+    const runsDir = (0, node_path_1.resolve)(repoRoot, DOCS_INGEST_RUNS_DIR);
+    let seq = 1;
+    if ((0, node_fs_1.existsSync)(runsDir)) {
+        try {
+            const existing = (0, node_fs_1.readdirSync)(runsDir).filter((d) => d.includes(date));
+            const suffixes = existing
+                .map((d) => {
+                const match = d.match(/-(\d{3})$/);
+                return match ? parseInt(match[1], 10) : 0;
+            })
+                .filter((n) => !isNaN(n) && n > 0);
+            const maxSuffix = suffixes.length > 0 ? Math.max(...suffixes) : 0;
+            seq = maxSuffix + 1;
+        }
+        catch {
+            // use seq = 1
+        }
+    }
+    return `polaris-docs-ingest-docs-ingest-${date}-${String(seq).padStart(3, "0")}`;
+}
+function docsIngestTelemetryPath(repoRoot, runId) {
+    return (0, node_path_1.resolve)(repoRoot, DOCS_INGEST_RUNS_DIR, runId, "telemetry.jsonl");
+}
+function emitRunStartTelemetry(repoRoot, runId, priorRunId) {
+    const telPath = docsIngestTelemetryPath(repoRoot, runId);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(telPath), { recursive: true });
+    (0, node_fs_1.appendFileSync)(telPath, JSON.stringify({
+        event: "run-start",
+        run_id: runId,
+        prior_run_id: priorRunId,
+        timestamp: (0, monotonic_timestamp_js_1.getMonotonicTimestamp)(),
+    }) + "\n", "utf-8");
+}
+function emitTelemetry(telPath, runId, event) {
+    try {
+        (0, node_fs_1.appendFileSync)(telPath, JSON.stringify({ ...event, run_id: runId, timestamp: (0, monotonic_timestamp_js_1.getMonotonicTimestamp)() }) + "\n", "utf-8");
+    }
+    catch {
+        // non-fatal for post-run-start events
+    }
+}
+function writeDocsIngestState(repoRoot, state) {
+    const statePath = (0, node_path_1.resolve)(repoRoot, DOCS_INGEST_STATE_FILE);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(statePath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+function ensureDocsScaffold(repoRoot, options = {}) {
+    const created = exports.SMART_DOCS_SCAFFOLD_DIRS.filter((dir) => !(0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, dir)));
+    const existing = exports.SMART_DOCS_SCAFFOLD_DIRS.filter((dir) => (0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, dir)));
+    if (!options.dryRun) {
+        for (const dir of created) {
+            (0, node_fs_1.mkdirSync)((0, node_path_1.resolve)(repoRoot, dir), { recursive: true });
+        }
+    }
+    return {
+        created,
+        existing,
+        dryRun: Boolean(options.dryRun),
+    };
+}
+function uniqueDestination(filePath) {
+    if (!(0, node_fs_1.existsSync)(filePath))
+        return filePath;
+    const dir = (0, node_path_1.dirname)(filePath);
+    const ext = (0, node_path_1.extname)(filePath);
+    const stem = (0, node_path_1.basename)(filePath, ext);
+    let index = 2;
+    let candidate = (0, node_path_1.join)(dir, `${stem}-${index}${ext}`);
+    while ((0, node_fs_1.existsSync)(candidate)) {
+        index += 1;
+        candidate = (0, node_path_1.join)(dir, `${stem}-${index}${ext}`);
+    }
+    return candidate;
+}
+function deriveLinkedArea(content, routes) {
+    const entries = Object.entries(routes);
+    const explicit = entries.find(([filePath]) => content.includes(filePath));
+    if (explicit) {
+        return { label: explicit[1].route || explicit[0], entry: explicit[1] };
+    }
+    const area = content.match(/\b(src\/[A-Za-z0-9_/-]+)/)?.[1];
+    if (area) {
+        const matched = entries.find(([filePath]) => filePath.startsWith(area));
+        if (matched)
+            return { label: matched[1].route || area, entry: matched[1] };
+        return { label: area, entry: null };
+    }
+    return { label: null, entry: null };
+}
+function updateMapEntry(repoRoot, destinationPath, linkedEntry) {
+    const config = (0, loader_js_1.loadConfig)(repoRoot);
+    const atlasPath = (0, node_path_1.resolve)(repoRoot, config.repo.sidecarOutputPath ?? ".polaris/map");
+    const routes = (0, atlas_js_1.readFileRoutes)(atlasPath);
+    const relDestination = (0, node_path_1.relative)(repoRoot, destinationPath).replace(/\\/g, "/");
+    const now = new Date().toISOString();
+    routes[relDestination] = {
+        domain: linkedEntry?.domain ?? "docs",
+        route: linkedEntry?.route ?? (0, node_path_1.dirname)(relDestination),
+        taskchain: linkedEntry?.taskchain ?? "polaris-docs",
+        confidence: linkedEntry ? 0.85 : 0.7,
+        classification: "indexed",
+        last_updated: now,
+        updated_by: "polaris-docs-ingest",
+        tags: ["docs", "ingested"],
+        instructionFile: linkedEntry?.instructionFile,
+    };
+    (0, atlas_js_1.writeFileRoutes)(atlasPath, routes);
+    const needsReview = (0, atlas_js_1.readNeedsReview)(atlasPath);
+    const entries = { ...routes, ...needsReview };
+    const instructionCoverage = (0, atlas_js_1.computeInstructionCoverage)(entries);
+    (0, atlas_js_1.writeAtlasIndex)(atlasPath, {
+        scan_date: now,
+        file_count: Object.keys(entries).length,
+        coverage_pct: Math.round((Object.values(entries).filter((e) => e.classification === "indexed").length / Object.keys(entries).length) * 100),
+        instructionCoverage,
+        entries,
+    });
+}
+function extractVerbTriples(content, pattern) {
+    const result = [];
+    const re = new RegExp(pattern.source, pattern.flags);
+    for (const match of content.matchAll(re)) {
+        const subject = match[1]?.toLowerCase().replace(/[^a-z0-9./\-]/g, "");
+        const keyword = match[2]?.toLowerCase();
+        if (subject && keyword &&
+            keyword.length >= 3 &&
+            !CONFLICT_STOPWORDS.has(keyword) &&
+            !CONFLICT_STOPWORDS.has(subject)) {
+            result.push({ subject, keyword });
+        }
+    }
+    return result;
+}
+/** Returns true if two triple sets share a (subject, keyword) pair. */
+function triplesConflict(a, b) {
+    for (const ta of a) {
+        for (const tb of b) {
+            if (ta.subject === tb.subject && ta.keyword === tb.keyword) {
+                return { subject: ta.subject, keyword: ta.keyword };
+            }
+        }
+    }
+    return null;
+}
+function detectDoctrineConflict(content, repoRoot) {
+    const activeDoctrineDir = (0, node_path_1.resolve)(repoRoot, exports.CANONICAL_TARGET, "doctrine", "active");
+    if (!(0, node_fs_1.existsSync)(activeDoctrineDir))
+        return null;
+    let files;
+    try {
+        files = (0, node_fs_1.readdirSync)(activeDoctrineDir).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return null;
+    }
+    if (files.length === 0)
+        return null;
+    const ingestedRequires = extractVerbTriples(content, MODAL_REQUIRES_RE);
+    const ingestedProhibits = extractVerbTriples(content, MODAL_PROHIBITS_RE);
+    for (const file of files) {
+        let docContent;
+        try {
+            docContent = (0, node_fs_1.readFileSync)((0, node_path_1.join)(activeDoctrineDir, file), "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const docRequires = extractVerbTriples(docContent, MODAL_REQUIRES_RE);
+        const docProhibits = extractVerbTriples(docContent, MODAL_PROHIBITS_RE);
+        // ingested prohibits X; doctrine requires X — same subject
+        const prohibitConflict = triplesConflict(ingestedProhibits, docRequires);
+        if (prohibitConflict) {
+            return {
+                conflictingFile: file,
+                detail: `ingested doc prohibits "${prohibitConflict.keyword}" for "${prohibitConflict.subject}" but ${file} requires it`,
+            };
+        }
+        // ingested requires X; doctrine prohibits X — same subject
+        const requireConflict = triplesConflict(ingestedRequires, docProhibits);
+        if (requireConflict) {
+            return {
+                conflictingFile: file,
+                detail: `ingested doc requires "${requireConflict.keyword}" for "${requireConflict.subject}" but ${file} prohibits it`,
+            };
+        }
+    }
+    return null;
+}
+function ingestDocs(files, options) {
+    const repoRoot = (0, node_path_1.resolve)(options.repoRoot);
+    // Canonical target check (STOP CONDITION)
+    const canonicalDir = (0, node_path_1.resolve)(repoRoot, exports.CANONICAL_TARGET);
+    if (!(0, node_fs_1.existsSync)(canonicalDir)) {
+        throw new Error(`polaris docs ingest: canonical target ${exports.CANONICAL_TARGET}/ not found — halting`);
+    }
+    const limit = options.maxFiles ?? DEFAULT_BATCH_LIMIT;
+    if (files.length === 0)
+        throw new Error("polaris docs ingest: provide at least one file");
+    if (files.length > limit)
+        throw new Error(`polaris docs ingest: batch limit is ${limit} files`);
+    const priorState = readCurrentState(repoRoot);
+    const clusterId = options.clusterId ?? null;
+    const runId = generateRunId(repoRoot);
+    // Emit run-start telemetry (STOP CONDITION if this write fails)
+    emitRunStartTelemetry(repoRoot, runId, priorState.run_id ?? null);
+    const telPath = docsIngestTelemetryPath(repoRoot, runId);
+    ensureDocsScaffold(repoRoot);
+    const config = (0, loader_js_1.loadConfig)(repoRoot);
+    const atlasPath = (0, node_path_1.resolve)(repoRoot, config.repo.sidecarOutputPath ?? ".polaris/map");
+    const routes = {
+        ...(0, atlas_js_1.readFileRoutes)(atlasPath),
+        ...(0, atlas_js_1.readNeedsReview)(atlasPath),
+    };
+    const results = [];
+    for (const source of files) {
+        const absSource = (0, node_path_1.resolve)(repoRoot, source);
+        const relCheck = (0, node_path_1.relative)(repoRoot, absSource);
+        if (relCheck.startsWith("..") || relCheck.startsWith("/")) {
+            throw new Error(`polaris docs ingest: path traversal detected, file outside repo: ${source}`);
+        }
+        const relSource = (0, node_path_1.relative)(repoRoot, absSource).replace(/\\/g, "/");
+        if ((0, node_path_1.basename)(relSource).toLowerCase() === "summary.md") {
+            throw new Error(`polaris docs ingest: SUMMARY.md is an endpoint artifact and cannot be ingested`);
+        }
+        const eligibility = (0, smartdoc_ignore_js_1.isIngestIneligible)(relSource, repoRoot);
+        if (eligibility.ineligible) {
+            emitTelemetry(telPath, runId, {
+                event: "docs-ingest-skipped-endpoint-artifact",
+                file: relSource,
+                reason: eligibility.reason,
+                cluster_id: clusterId,
+            });
+            throw new Error(`polaris docs ingest: ${relSource} is ineligible for docs ingest - ${eligibility.reason}`);
+        }
+        if (!(0, node_fs_1.existsSync)(absSource))
+            throw new Error(`polaris docs ingest: file not found: ${source}`);
+        const content = (0, node_fs_1.readFileSync)(absSource, "utf-8");
+        const classification = classifyDoc(content, relSource);
+        if (APPROVAL_REQUIRED.has(classification) && !options.approveAuthority) {
+            throw new Error(`polaris docs ingest: ${classification} requires explicit approval; rerun with --approve-authority`);
+        }
+        // Conflict detection against active doctrine (STOP CONDITION)
+        const conflict = detectDoctrineConflict(content, repoRoot);
+        if (conflict) {
+            emitTelemetry(telPath, runId, {
+                event: "docs-ingest-conflict-detected",
+                file: relSource,
+                conflicting_doctrine_file: conflict.conflictingFile,
+                detail: conflict.detail,
+                cluster_id: clusterId,
+            });
+            throw new Error(`polaris docs ingest: conflict detected — ${conflict.detail}`);
+        }
+        const { label: linkedMapArea, entry: linkedEntry } = deriveLinkedArea(content, routes);
+        const targetDir = (0, node_path_1.resolve)(repoRoot, TARGET_DIRS[classification]);
+        (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
+        const rawDestination = (0, node_path_1.join)(targetDir, (0, node_path_1.basename)(absSource));
+        const destination = (0, node_path_1.resolve)(rawDestination) === (0, node_path_1.resolve)(absSource)
+            ? absSource
+            : uniqueDestination(rawDestination);
+        const relDestination = (0, node_path_1.relative)(repoRoot, destination).replace(/\\/g, "/");
+        const provenancePath = /\.md$/i.test(destination)
+            ? destination.replace(/\.md$/i, ".provenance.json")
+            : `${destination}.provenance.json`;
+        emitTelemetry(telPath, runId, {
+            event: "docs-ingest-classified",
+            file: relSource,
+            classification,
+            destination: relDestination,
+            linked_map_area: linkedMapArea,
+            cluster_id: clusterId,
+        });
+        if (!options.dryRun) {
+            if ((0, node_path_1.resolve)(absSource) !== (0, node_path_1.resolve)(destination)) {
+                (0, node_fs_1.renameSync)(absSource, destination);
+            }
+            const stampedContent = (0, doctrine_js_1.stampIngestFrontMatter)((0, node_fs_1.readFileSync)(destination, "utf-8"), {
+                originalPath: relSource,
+                classifiedAs: classification,
+                ingestRunId: runId,
+                ingestClusterId: clusterId,
+                linkedMapArea,
+                ingestedAt: new Date().toISOString(),
+            });
+            (0, node_fs_1.writeFileSync)(destination, stampedContent, "utf-8");
+            updateMapEntry(repoRoot, destination, linkedEntry);
+        }
+        if (classification === "doctrine-candidate" && !options.dryRun) {
+            emitTelemetry(telPath, runId, {
+                event: "doc-auto-promoted",
+                file: relDestination,
+                classification,
+                linked_map_area: linkedMapArea,
+                cluster_id: clusterId,
+            });
+        }
+        emitTelemetry(telPath, runId, {
+            event: "docs-ingest",
+            file: relSource,
+            classification,
+            destination: relDestination,
+            linked_map_area: linkedMapArea,
+            cluster_id: clusterId,
+        });
+        // ── SUMMARY.md delta check ────────────────────────────────────────────
+        // Associate the ingested doc with its nearest route SUMMARY.md and
+        // determine whether a SUMMARY.md update is warranted. Informational only —
+        // never promotes SUMMARY.md into canon or doctrine.
+        const summaryDelta = (0, summary_delta_js_1.applySummaryDelta)({
+            repoRoot,
+            touchedFiles: [relDestination],
+            skipRoot: true,
+        });
+        const nearestSummary = (0, summary_delta_js_1.findNearestSummarymd)(relDestination, repoRoot, true);
+        if (summaryDelta.updateWarranted) {
+            emitTelemetry(telPath, runId, {
+                event: "summary-delta-warranted",
+                file: relDestination,
+                reasons: summaryDelta.reasons,
+                precedence_source: summaryDelta.precedenceSource,
+                summary_target: nearestSummary,
+                cluster_id: clusterId,
+            });
+        }
+        // ── Promoted-doc route detection ──────────────────────────────────────
+        // When a doc lands in an active doctrine or spec path, it becomes the
+        // preferred cognition source for nearby routes. Emit a lightweight
+        // cognition-maintenance-needed event so operators/workers can act.
+        // Does NOT write any file; informational only.
+        const precedence = (0, summary_delta_js_1.detectPrecedenceLevel)([relDestination]);
+        if (precedence === "promoted-doctrine" || precedence === "spec-or-arch") {
+            if (nearestSummary) {
+                emitTelemetry(telPath, runId, {
+                    event: "cognition-maintenance-needed",
+                    trigger: "doc-promotion",
+                    promoted_file: relDestination,
+                    precedence_source: precedence,
+                    affected_summary: nearestSummary,
+                    cluster_id: clusterId,
+                });
+            }
+        }
+        results.push({
+            sourcePath: relSource,
+            destinationPath: relDestination,
+            classification,
+            linkedMapArea,
+            runId,
+            dryRun: Boolean(options.dryRun),
+            nearestSummary,
+            summaryDeltaWarranted: summaryDelta.updateWarranted,
+        });
+    }
+    emitTelemetry(telPath, runId, {
+        event: "docs-ingest-complete",
+        count: results.length,
+        cluster_id: clusterId,
+    });
+    if (!options.dryRun) {
+        writeDocsIngestState(repoRoot, {
+            run_id: runId,
+            prior_run_id: priorState.run_id ?? null,
+            cluster_id: clusterId ?? undefined,
+            status: "complete",
+            files_ingested: results.length,
+            last_run_at: new Date().toISOString(),
+        });
+    }
+    return results;
+}
+function printIngestResults(results) {
+    for (const result of results) {
+        const prefix = result.dryRun ? "[dry-run] " : "";
+        console.log(`${prefix}${result.sourcePath} -> ${result.destinationPath}`);
+        console.log(`classification: ${result.classification}`);
+        console.log(`linked_map_area: ${result.linkedMapArea ?? "none"}`);
+        console.log(`run_id: ${result.runId}`);
+        if (result.nearestSummary)
+            console.log(`nearest_summary: ${result.nearestSummary}${result.summaryDeltaWarranted ? " (delta warranted)" : ""}`);
+    }
+}

package/dist/smartdocs-engine/ingest.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_fs_2 = require("node:fs");
+const node_os_1 = require("node:os");
+const vitest_1 = require("vitest");
+const ingest_js_1 = require("./ingest.js");
+function makeRepo() {
+    const repoRoot = (0, node_fs_2.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "polaris-docs-ingest-"));
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw"), { recursive: true });
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ingest_js_1.CANONICAL_TARGET, "doctrine", "active"), { recursive: true });
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".polaris", "map"), { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "polaris.config.json"), JSON.stringify({ repo: { sidecarOutputPath: ".polaris/map" } }), "utf-8");
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "map", "file-routes.json"), JSON.stringify({
+        "src/smartdocs-engine/index.ts": {
+            domain: "docs",
+            route: "src/smartdocs-engine",
+            taskchain: "polaris-docs",
+            confidence: 0.95,
+            classification: "indexed",
+            last_updated: "",
+            updated_by: "",
+            tags: ["docs"],
+            instructionFile: "src/smartdocs-engine/POLARIS.md",
+        },
+    }), "utf-8");
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "map", "needs-review.json"), "{}\n", "utf-8");
+    return repoRoot;
+}
+function makeRepoWithoutCanonical() {
+    const repoRoot = (0, node_fs_2.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "polaris-docs-ingest-"));
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".polaris", "map"), { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "polaris.config.json"), JSON.stringify({ repo: { sidecarOutputPath: ".polaris/map" } }), "utf-8");
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "map", "file-routes.json"), "{}\n", "utf-8");
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "map", "needs-review.json"), "{}\n", "utf-8");
+    return repoRoot;
+}
+(0, vitest_1.describe)("classifyDoc", () => {
+    (0, vitest_1.it)("classifies docs from explicit content signals", () => {
+        (0, vitest_1.expect)((0, ingest_js_1.classifyDoc)("# Runtime Summary\n\nSession summary")).toBe("runtime-summary");
+        (0, vitest_1.expect)((0, ingest_js_1.classifyDoc)("# Audit Finding\n\nSecurity audit result")).toBe("audit-finding");
+        (0, vitest_1.expect)((0, ingest_js_1.classifyDoc)("# Doctrine\n\nAgents must always preserve state")).toBe("doctrine-candidate");
+        (0, vitest_1.expect)((0, ingest_js_1.classifyDoc)("# Feature Spec\n\nAcceptance Criteria")).toBe("spec-raw");
+    });
+    (0, vitest_1.it)("classifies SUMMARY.md as deprecated-noise regardless of content", () => {
+        (0, vitest_1.expect)((0, ingest_js_1.classifyDoc)("# Authoritative Doctrine\nAgents must always X.", "SUMMARY.md")).toBe("deprecated-noise");
+    });
+});
+(0, vitest_1.describe)("ingestDocs", () => {
+    (0, vitest_1.it)("rejects SUMMARY.md ingest with a hard guard", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "SUMMARY.md"), "# Summary\n", "utf-8");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)(["SUMMARY.md"], { repoRoot })).toThrow("polaris docs ingest: SUMMARY.md is an endpoint artifact and cannot be ingested");
+    });
+    (0, vitest_1.it)("moves a raw spec, writes provenance, links map area, and emits telemetry", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", "ingest-plan.md"), "# Ingest Spec\n\nAcceptance Criteria\n\nTouches src/smartdocs-engine/index.ts.", "utf-8");
+        const [result] = (0, ingest_js_1.ingestDocs)(["smartdocs/docs/raw/ingest-plan.md"], { repoRoot });
+        (0, vitest_1.expect)(result.classification).toBe("spec-raw");
+        (0, vitest_1.expect)(result.destinationPath).toBe(`${ingest_js_1.CANONICAL_TARGET}/raw/ingest-plan.md`);
+        (0, vitest_1.expect)(result.linkedMapArea).toBe("src/smartdocs-engine");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, ingest_js_1.CANONICAL_TARGET, "raw", "ingest-plan.md"))).toBe(true);
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, ingest_js_1.CANONICAL_TARGET, "raw", "ingest-plan.provenance.json"))).toBe(true);
+        // Telemetry written to polaris-docs-ingest path using the generated run_id
+        const runsDir = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-docs-ingest", "runs");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(runsDir)).toBe(true);
+        const runDirs = (0, node_fs_1.readdirSync)(runsDir);
+        (0, vitest_1.expect)(runDirs).toHaveLength(1);
+        const telemetry = (0, node_fs_1.readFileSync)((0, node_path_1.join)(runsDir, runDirs[0], "telemetry.jsonl"), "utf-8");
+        (0, vitest_1.expect)(telemetry).toContain('"event":"run-start"');
+        (0, vitest_1.expect)(telemetry).toContain('"event":"docs-ingest"');
+        // run_id in result matches the telemetry dir
+        (0, vitest_1.expect)(result.runId).toBe(runDirs[0]);
+    });
+    (0, vitest_1.it)("rejects batches above the bounded file limit", () => {
+        const repoRoot = makeRepo();
+        for (const name of ["a.md", "b.md", "c.md", "d.md", "e.md"]) {
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", name), "# Spec\n\nAcceptance Criteria", "utf-8");
+        }
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)([
+            "smartdocs/docs/raw/a.md",
+            "smartdocs/docs/raw/b.md",
+            "smartdocs/docs/raw/c.md",
+            "smartdocs/docs/raw/d.md",
+            "smartdocs/docs/raw/e.md",
+        ], { repoRoot })).toThrow("batch limit is 4 files");
+    });
+    (0, vitest_1.it)("does not promote high-authority architecture docs without approval", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", "architecture.md"), "# Architecture\n\nStructural design", "utf-8");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)(["smartdocs/docs/raw/architecture.md"], { repoRoot })).toThrow("requires explicit approval");
+    });
+    (0, vitest_1.it)("halts when smartdocs/docs/ canonical target is missing", () => {
+        const repoRoot = makeRepoWithoutCanonical();
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "test.md"), "# Spec\n\nAcceptance Criteria", "utf-8");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)(["test.md"], { repoRoot })).toThrow("canonical target");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)(["test.md"], { repoRoot })).toThrow("smartdocs/docs");
+    });
+    (0, vitest_1.it)("dry-run classifies and reports placement without moving files", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", "spec-dry.md"), "# Feature Spec\n\nAcceptance Criteria", "utf-8");
+        const [result] = (0, ingest_js_1.ingestDocs)(["smartdocs/docs/raw/spec-dry.md"], { repoRoot, dryRun: true });
+        (0, vitest_1.expect)(result.dryRun).toBe(true);
+        (0, vitest_1.expect)(result.classification).toBe("spec-raw");
+        (0, vitest_1.expect)(result.destinationPath).toBe(`${ingest_js_1.CANONICAL_TARGET}/raw/spec-dry.md`);
+        (0, vitest_1.expect)(result.provenancePath).toBeNull();
+        // Source file still exists (not moved)
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", "spec-dry.md"))).toBe(true);
+        // Target file does not exist
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)((0, node_path_1.join)(repoRoot, ingest_js_1.CANONICAL_TARGET, "specs", "raw", "spec-dry.md"))).toBe(false);
+        // run-start telemetry still emitted even for dry-run
+        const runsDir = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-docs-ingest", "runs");
+        const runDirs = (0, node_fs_1.readdirSync)(runsDir);
+        (0, vitest_1.expect)(runDirs).toHaveLength(1);
+        const telemetry = (0, node_fs_1.readFileSync)((0, node_path_1.join)(runsDir, runDirs[0], "telemetry.jsonl"), "utf-8");
+        (0, vitest_1.expect)(telemetry).toContain('"event":"run-start"');
+    });
+    (0, vitest_1.it)("halts and emits conflict telemetry when ingested doc contradicts active doctrine", () => {
+        const repoRoot = makeRepo();
+        // "must preserve" → docRequires captures "preserve"
+        // "never preserve" → ingestedProhibits captures "preserve" → conflict
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ingest_js_1.CANONICAL_TARGET, "doctrine", "active", "state-integrity.md"), "# State Integrity Doctrine\n\nAgents must preserve telemetry files.\n", "utf-8");
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", "conflicting-doc.md"), "# Conflicting Policy\n\nAgents never preserve telemetry files.", "utf-8");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)(["smartdocs/docs/raw/conflicting-doc.md"], { repoRoot })).toThrow("conflict detected");
+        // Conflict telemetry should be present
+        const runsDir = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-docs-ingest", "runs");
+        const runDirs = (0, node_fs_1.readdirSync)(runsDir);
+        (0, vitest_1.expect)(runDirs).toHaveLength(1);
+        const telemetry = (0, node_fs_1.readFileSync)((0, node_path_1.join)(runsDir, runDirs[0], "telemetry.jsonl"), "utf-8");
+        (0, vitest_1.expect)(telemetry).toContain('"event":"docs-ingest-conflict-detected"');
+    });
+    (0, vitest_1.it)("writes durable state to polaris-docs-ingest after a successful ingest", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "smartdocs", "docs", "raw", "state-test.md"), "# Feature Spec\n\nAcceptance Criteria", "utf-8");
+        const [result] = (0, ingest_js_1.ingestDocs)(["smartdocs/docs/raw/state-test.md"], { repoRoot });
+        const stateFile = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-docs-ingest", "current-state.json");
+        (0, vitest_1.expect)((0, node_fs_1.existsSync)(stateFile)).toBe(true);
+        const state = JSON.parse((0, node_fs_1.readFileSync)(stateFile, "utf-8"));
+        (0, vitest_1.expect)(state.run_id).toBe(result.runId);
+        (0, vitest_1.expect)(state.status).toBe("complete");
+        (0, vitest_1.expect)(state.files_ingested).toBe(1);
+    });
+    (0, vitest_1.it)("rejects ignored endpoint artifacts before ingesting and emits telemetry", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run"), { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run", "current-state.json"), JSON.stringify({ run_id: "test-run" }), "utf-8");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)([".taskchain_artifacts/polaris-run/current-state.json"], { repoRoot })).toThrow("ineligible for docs ingest");
+        const runsDir = (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-docs-ingest", "runs");
+        const runDirs = (0, node_fs_1.readdirSync)(runsDir);
+        (0, vitest_1.expect)(runDirs).toHaveLength(1);
+        const telemetry = (0, node_fs_1.readFileSync)((0, node_path_1.join)(runsDir, runDirs[0], "telemetry.jsonl"), "utf-8");
+        (0, vitest_1.expect)(telemetry).toContain('"event":"docs-ingest-skipped-endpoint-artifact"');
+        (0, vitest_1.expect)(telemetry).toContain('"file":".taskchain_artifacts/polaris-run/current-state.json"');
+    });
+    (0, vitest_1.it)("rejects paths ignored by a custom .smartdocignore pattern", () => {
+        const repoRoot = makeRepo();
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, "scratch"), { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".smartdocignore"), "scratch/*.md\n", "utf-8");
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, "scratch", "draft.md"), "# Spec\n\nAcceptance Criteria", "utf-8");
+        (0, vitest_1.expect)(() => (0, ingest_js_1.ingestDocs)(["scratch/draft.md"], { repoRoot })).toThrow("ignored by .smartdocignore/defaults: scratch/draft.md");
+    });
+});