@interf/compiler 0.6.1 → 0.6.3

package/dist/lib/runtime-acceptance.js

@@ -1,269 +1 @@
-import { existsSync, } from "node:fs";
-import { join } from "node:path";
-import { listFilesRecursive } from "./filesystem.js";
-import { readJsonFileWithSchema } from "./parse.js";
-import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { RuntimeStageContractSchema, } from "./schema.js";
-import { stageContractPath } from "./runtime-paths.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { loadState } from "./state-io.js";
-import { countBrokenWikilinks, isOutputMarkdownFile, safeReadText, validateSynthFiles } from "./validate.js";
-function toFiniteNumber(value) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return null;
-    return value;
-}
-function hasAcceptanceRules(acceptance) {
-    if (!acceptance)
-        return false;
-    return (acceptance.artifacts_exist?.length ?? 0) > 0 ||
-        (acceptance.stage_truthy?.length ?? 0) > 0 ||
-        Object.keys(acceptance.stage_equals_counts ?? {}).length > 0 ||
-        Object.keys(acceptance.stage_at_least ?? {}).length > 0 ||
-        Object.keys(acceptance.stage_at_least_counts ?? {}).length > 0 ||
-        Object.keys(acceptance.zone_counts_at_least ?? {}).length > 0 ||
-        Object.keys(acceptance.zone_counts_at_least_counts ?? {}).length > 0 ||
-        (acceptance.markdown_frontmatter_valid_zones?.length ?? 0) > 0 ||
-        Object.keys(acceptance.frontmatter_required_keys_in_zones ?? {}).length > 0 ||
-        (acceptance.markdown_abstract_valid_zones?.length ?? 0) > 0 ||
-        (acceptance.wikilinks_valid_in_zones?.length ?? 0) > 0 ||
-        Object.keys(acceptance.artifacts_must_not_contain ?? {}).length > 0;
-}
-function readPathValue(record, keyPath) {
-    if (!record)
-        return undefined;
-    return keyPath
-        .split(".")
-        .filter((segment) => segment.length > 0)
-        .reduce((current, segment) => {
-        if (!current || typeof current !== "object" || Array.isArray(current))
-            return undefined;
-        return current[segment];
-    }, record);
-}
-function countZoneArtifacts(compiledPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
-}
-function markdownFilesForZone(compiledPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return [];
-    if (kind === "file") {
-        return isOutputMarkdownFile(absolutePath) ? [absolutePath] : [];
-    }
-    return listFilesRecursive(absolutePath, isOutputMarkdownFile);
-}
-function zoneRoots(compiledPath, acceptanceZones) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    if (!schema)
-        return [];
-    return acceptanceZones
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null)
-        .map((zone) => compiledZoneAbsolutePath(compiledPath, zone));
-}
-function readArtifactText(compiledPath, relativePath) {
-    const artifactPath = join(compiledPath, relativePath);
-    if (!existsSync(artifactPath))
-        return null;
-    return safeReadText(artifactPath);
-}
-function resolveStageCounts(contract, stageRecord) {
-    const merged = { ...contract.counts };
-    const fromStage = stageRecord?.counts;
-    if (fromStage && typeof fromStage === "object" && !Array.isArray(fromStage)) {
-        for (const [key, value] of Object.entries(fromStage)) {
-            const numeric = toFiniteNumber(value);
-            if (numeric !== null)
-                merged[key] = numeric;
-        }
-    }
-    return merged;
-}
-export function stageRecordFromState(state, stageId) {
-    const stages = state?.stages;
-    if (!stages || typeof stages !== "object")
-        return null;
-    const stage = stages[stageId];
-    if (!stage || typeof stage !== "object" || Array.isArray(stage))
-        return null;
-    return stage;
-}
-export function validateResolvedStageAcceptance(dirPath, options) {
-    const acceptance = options.acceptance;
-    if (!hasAcceptanceRules(acceptance)) {
-        return {
-            ok: true,
-            summary: "No additional stage acceptance criteria were declared.",
-            failures: [],
-        };
-    }
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
-    if (!schema) {
-        return {
-            ok: false,
-            summary: `Stage acceptance failed for ${options.stageId}: missing workflow schema.`,
-            failures: [`Missing workflow/${WORKFLOW_SCHEMA_FILE}.`],
-        };
-    }
-    const failures = [];
-    const state = loadState(dirPath);
-    const stageRecord = stageRecordFromState(state, options.stageId);
-    const counts = options.counts ?? {};
-    for (const relativePath of acceptance?.artifacts_exist ?? []) {
-        if (!existsSync(join(dirPath, relativePath))) {
-            failures.push(`Missing required artifact: ${relativePath}.`);
-        }
-    }
-    for (const keyPath of acceptance?.stage_truthy ?? []) {
-        if (!readPathValue(stageRecord, keyPath)) {
-            failures.push(`Expected truthy stage value at "${keyPath}".`);
-        }
-    }
-    for (const [keyPath, countKey] of Object.entries(acceptance?.stage_equals_counts ?? {})) {
-        const actual = readPathValue(stageRecord, keyPath);
-        const expected = counts[countKey];
-        if (typeof expected !== "number") {
-            failures.push(`Acceptance references missing count "${countKey}" for "${keyPath}".`);
-            continue;
-        }
-        if (actual !== expected) {
-            failures.push(`Expected stage "${keyPath}" to equal count "${countKey}" (${expected}), got ${JSON.stringify(actual)}.`);
-        }
-    }
-    for (const [keyPath, minimum] of Object.entries(acceptance?.stage_at_least ?? {})) {
-        const actual = toFiniteNumber(readPathValue(stageRecord, keyPath));
-        if (actual === null || actual < minimum) {
-            failures.push(`Expected stage "${keyPath}" to be at least ${minimum}, got ${actual === null ? "non-numeric" : actual}.`);
-        }
-    }
-    for (const [keyPath, countKey] of Object.entries(acceptance?.stage_at_least_counts ?? {})) {
-        const actual = toFiniteNumber(readPathValue(stageRecord, keyPath));
-        const expected = counts[countKey];
-        if (typeof expected !== "number") {
-            failures.push(`Acceptance references missing count "${countKey}" for "${keyPath}".`);
-            continue;
-        }
-        if (actual === null || actual < expected) {
-            failures.push(`Expected stage "${keyPath}" to be at least count "${countKey}" (${expected}), got ${actual === null ? "non-numeric" : actual}.`);
-        }
-    }
-    for (const [zoneId, minimum] of Object.entries(acceptance?.zone_counts_at_least ?? {})) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const actual = countZoneArtifacts(dirPath, zone.path, zone.kind);
-        if (actual < minimum) {
-            failures.push(`Expected zone "${zoneId}" to contain at least ${minimum} artifact(s), got ${actual}.`);
-        }
-    }
-    for (const [zoneId, countKey] of Object.entries(acceptance?.zone_counts_at_least_counts ?? {})) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const expected = counts[countKey];
-        if (typeof expected !== "number") {
-            failures.push(`Acceptance references missing count "${countKey}" for zone "${zoneId}".`);
-            continue;
-        }
-        const actual = countZoneArtifacts(dirPath, zone.path, zone.kind);
-        if (actual < expected) {
-            failures.push(`Expected zone "${zoneId}" to contain at least count "${countKey}" (${expected}) artifact(s), got ${actual}.`);
-        }
-    }
-    for (const zoneId of acceptance?.markdown_frontmatter_valid_zones ?? []) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const validation = validateSynthFiles(markdownFilesForZone(dirPath, zone.path, zone.kind));
-        if (validation.invalid_frontmatter > 0) {
-            failures.push(`Zone "${zoneId}" has ${validation.invalid_frontmatter} markdown file(s) with invalid or incomplete frontmatter.`);
-        }
-    }
-    for (const [zoneId, requiredKeys] of Object.entries(acceptance?.frontmatter_required_keys_in_zones ?? {})) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const validation = validateSynthFiles(markdownFilesForZone(dirPath, zone.path, zone.kind), { requiredFrontmatterKeys: requiredKeys });
-        if (validation.invalid_frontmatter > 0) {
-            failures.push(`Zone "${zoneId}" has ${validation.invalid_frontmatter} markdown file(s) missing required frontmatter keys (${requiredKeys.join(", ")}).`);
-        }
-    }
-    for (const zoneId of acceptance?.markdown_abstract_valid_zones ?? []) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const validation = validateSynthFiles(markdownFilesForZone(dirPath, zone.path, zone.kind));
-        if (validation.short_abstracts > 0) {
-            failures.push(`Zone "${zoneId}" has ${validation.short_abstracts} markdown file(s) with missing or weak abstracts.`);
-        }
-    }
-    if ((acceptance?.wikilinks_valid_in_zones?.length ?? 0) > 0) {
-        const roots = zoneRoots(dirPath, acceptance?.wikilinks_valid_in_zones ?? []);
-        const brokenLinks = countBrokenWikilinks(dirPath, roots, roots);
-        if (brokenLinks > 0) {
-            failures.push(`Detected ${brokenLinks} broken wikilink(s) across the declared acceptance zones.`);
-        }
-    }
-    for (const [relativePath, disallowedTexts] of Object.entries(acceptance?.artifacts_must_not_contain ?? {})) {
-        const content = readArtifactText(dirPath, relativePath);
-        if (content === null) {
-            failures.push(`Missing artifact required for content check: ${relativePath}.`);
-            continue;
-        }
-        for (const disallowed of disallowedTexts) {
-            if (content.includes(disallowed)) {
-                failures.push(`Artifact "${relativePath}" still contains forbidden text: ${JSON.stringify(disallowed)}.`);
-            }
-        }
-    }
-    if (failures.length === 0) {
-        return {
-            ok: true,
-            summary: `Stage acceptance satisfied for ${options.stageId}.`,
-            failures: [],
-        };
-    }
-    return {
-        ok: false,
-        summary: `Stage acceptance failed for ${options.stageId}: ${failures.join(" ")}`,
-        failures,
-    };
-}
-export function validateStageContractAcceptance(dirPath, contract = null) {
-    const resolvedContract = contract ?? (() => {
-        const path = stageContractPath(dirPath);
-        if (!existsSync(path))
-            return null;
-        return readJsonFileWithSchema(path, "stage contract", RuntimeStageContractSchema);
-    })();
-    if (!resolvedContract) {
-        return {
-            ok: true,
-            summary: "No active stage contract found for acceptance validation.",
-            failures: [],
-        };
-    }
-    const state = loadState(dirPath);
-    const stageRecord = stageRecordFromState(state, resolvedContract.stage);
-    return validateResolvedStageAcceptance(dirPath, {
-        stageId: resolvedContract.stage,
-        acceptance: resolvedContract.acceptance,
-        counts: resolveStageCounts(resolvedContract, stageRecord),
-    });
-}
+export * from "../packages/compiler/runtime-acceptance.js";

package/dist/lib/runtime-contracts.d.ts

@@ -1,2 +1 @@
-import { type RuntimeStageContractDraft, type RuntimeStageContractOptions } from "./runtime-types.js";
-export declare function buildRuntimeStageContract(options: RuntimeStageContractOptions): RuntimeStageContractDraft;
+export * from "../packages/compiler/runtime-contracts.js";

package/dist/lib/runtime-contracts.js

@@ -1,48 +1 @@
-import { WORKFLOW_SCHEMA_FILE } from "./compiled-schema.js";
-export function buildRuntimeStageContract(options) {
-    const localSkillDocs = options.localSkillDocs ?? [];
-    const workflowNotes = options.workflowNotes ?? [];
-    return {
-        instructions: options.instructions,
-        counts: {
-            ...(options.counts ?? {}),
-            local_skill_docs: localSkillDocs.length,
-        },
-        ...(options.acceptance ? { acceptance: options.acceptance } : {}),
-        artifacts: {
-            reads: [
-                "interf.json",
-                `workflow/${WORKFLOW_SCHEMA_FILE}`,
-                ...(options.extraReadArtifacts ?? []),
-                ...options.stageReadArtifacts,
-                ...localSkillDocs,
-            ],
-            writes: options.stageWriteArtifacts,
-            verifies: [
-                `interf verify stage ${options.stageId} --json`,
-            ],
-        },
-        policies: {
-            execution_mode: "deterministic",
-            status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
-            notes: [
-                `This is the "${options.stageLabel}" stage for the compiled dataset "${options.compiledName}".`,
-                "The workflow package is the authoritative method layer for this run.",
-                `Use \`workflow/${WORKFLOW_SCHEMA_FILE}\` as the deterministic zone-contract reference for this compiled dataset.`,
-                "Honor the declared read and write artifacts instead of inventing a parallel workflow.",
-                "Only create or update files that fall under the declared write targets for this stage.",
-                "The CLI owns `.interf/runtime/` ledgers such as run, state, health, and view-spec files. Read them if needed, but do not create, edit, or replace them in this stage unless the contract explicitly marks a runtime artifact as stage-owned.",
-                "Keep scratch extraction commands single-purpose and non-destructive. Avoid wildcard cleanup and multi-command chains.",
-                ...workflowNotes,
-                ...(localSkillDocs.length > 0
-                    ? [
-                        "Read any local instruction docs listed in the contract before you write artifacts or declare the stage complete.",
-                        options.instructions.effective_mode === "override"
-                            ? "Local stage docs replace the default workflow guidance for this run, but they still do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation."
-                            : "Local stage docs can refine the stage behavior, but they do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation.",
-                    ]
-                    : []),
-            ],
-        },
-    };
-}
+export * from "../packages/compiler/runtime-contracts.js";

package/dist/lib/runtime-inventory.d.ts

@@ -1,7 +1 @@
-import { type CompiledInventory, type CompiledInventoryEntry } from "./schema.js";
-export declare function emptyCompiledInventory(): CompiledInventory;
-export declare function compiledInventoryFromEntries(entries: CompiledInventoryEntry[], stage?: string): CompiledInventory;
-export declare function compiledInventoryEntryCount(inventory: CompiledInventory | null): number;
-export declare function compiledInventoryTotal(inventory: CompiledInventory | null): number;
-export declare function compiledInventoryFrontmatterScannedCount(inventory: CompiledInventory | null): number;
-export declare function compiledInventoryAbstractCoverageCount(inventory: CompiledInventory | null): number;
+export * from "../packages/compiler/runtime-inventory.js";

package/dist/lib/runtime-inventory.js

@@ -1,29 +1 @@
-export function emptyCompiledInventory() {
-    return {
-        kind: "compiled-runtime-ledger",
-        version: 1,
-        entries: [],
-        total: 0,
-    };
-}
-export function compiledInventoryFromEntries(entries, stage) {
-    return {
-        kind: "compiled-runtime-ledger",
-        version: 1,
-        ...(stage ? { stage } : {}),
-        entries,
-        total: entries.length,
-    };
-}
-export function compiledInventoryEntryCount(inventory) {
-    return inventory?.entries.length ?? 0;
-}
-export function compiledInventoryTotal(inventory) {
-    return inventory?.total ?? 0;
-}
-export function compiledInventoryFrontmatterScannedCount(inventory) {
-    return (inventory?.entries ?? []).filter((entry) => entry.metadata?.frontmatter_scanned === true).length;
-}
-export function compiledInventoryAbstractCoverageCount(inventory) {
-    return (inventory?.entries ?? []).filter((entry) => entry.metadata?.abstract_read === true || typeof entry.metadata?.abstract === "string").length;
-}
+export * from "../packages/compiler/runtime-inventory.js";

package/dist/lib/runtime-paths.d.ts

@@ -1,8 +1 @@
-export declare function runPath(dirPath: string): string;
-export declare function runHistoryPath(dirPath: string): string;
-export declare function stageContractPath(dirPath: string): string;
-export declare function archivedStageContractPath(dirPath: string, runId: string): string;
-export declare function logsDirPath(dirPath: string): string;
-export declare function promptLogPath(dirPath: string, runId: string): string;
-export declare function eventLogPath(dirPath: string, runId: string): string;
-export declare function statusLogPath(dirPath: string, runId: string): string;
+export * from "../packages/compiler/runtime-paths.js";

package/dist/lib/runtime-paths.js

@@ -1,26 +1 @@
-import { join } from "node:path";
-import { compiledRuntimeArchivedStageContractPath, compiledRuntimeLogsRoot, compiledRuntimeRunHistoryPath, compiledRuntimeRunPath, compiledRuntimeStageContractPath, } from "./compiled-paths.js";
-export function runPath(dirPath) {
-    return compiledRuntimeRunPath(dirPath);
-}
-export function runHistoryPath(dirPath) {
-    return compiledRuntimeRunHistoryPath(dirPath);
-}
-export function stageContractPath(dirPath) {
-    return compiledRuntimeStageContractPath(dirPath);
-}
-export function archivedStageContractPath(dirPath, runId) {
-    return compiledRuntimeArchivedStageContractPath(dirPath, runId);
-}
-export function logsDirPath(dirPath) {
-    return compiledRuntimeLogsRoot(dirPath);
-}
-export function promptLogPath(dirPath, runId) {
-    return join(logsDirPath(dirPath), `${runId}.prompt.txt`);
-}
-export function eventLogPath(dirPath, runId) {
-    return join(logsDirPath(dirPath), `${runId}.events.ndjson`);
-}
-export function statusLogPath(dirPath, runId) {
-    return join(logsDirPath(dirPath), `${runId}.status.log`);
-}
+export * from "../packages/compiler/runtime-paths.js";

package/dist/lib/runtime-prompt.d.ts

@@ -1,2 +1 @@
-import { type RuntimeStageInstructions } from "./schema.js";
-export declare function buildStagePrompt(instructions: RuntimeStageInstructions, contractPath: string, statusLines: string[]): string;
+export * from "../packages/compiler/runtime-prompt.js";

package/dist/lib/runtime-prompt.js

@@ -1,48 +1 @@
-export function buildStagePrompt(instructions, contractPath, statusLines) {
-    const stageSkillDir = instructions.stage_skill_dir || "stage";
-    const modeNotes = instructions.effective_mode === "override"
-        ? [
-            "Local stage instruction docs are authoritative for this run.",
-            "Do not fall back to bundled workflow heuristics unless the stage contract explicitly leaves room for them.",
-            "Interf still enforces the same required reads, writes, verifier outputs, and runtime reconciliation at stage close.",
-        ]
-        : instructions.effective_mode === "extend"
-            ? [
-                "Use the current compiled workflow docs as the default workflow for this run.",
-                "Then apply any additional local stage instruction docs referenced by the contract as stage-specific extensions.",
-            ]
-            : [
-                "Use the current compiled workflow docs as the default workflow for this run.",
-            ];
-    return [
-        `Interf workflow stage docs: workflow/compile/stages/${stageSkillDir}/`,
-        "",
-        "This is an automated Interf stage run, not an open-ended chat session.",
-        "The user has already invoked this stage through the Interf CLI. Execute it now.",
-        "Do not ask what the user wants, offer help, list tools, or wait for another instruction.",
-        `Read \`${contractPath}\` first. It is the authoritative contract for this stage.`,
-        "If `runtime/paths.json` exists in this shell, read it next. It maps workflow zone ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
-        "For file-zone mounts, `runtime/paths.json` also gives the exact file path inside the `inputs/` or `outputs/` mount root.",
-        "Honor the contract's counts, artifact paths, and policies instead of inventing another workflow.",
-        "Read only the files named by the contract's `artifacts.reads` list plus any paths they explicitly direct you to open.",
-        "Prefer direct file-reading and search tools over shell commands when you inspect inputs, docs, or generated outputs.",
-        "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` for routine file inspection if a native read/search tool can do the same job.",
-        "If the contract lists `instructions.local_docs`, open every one of those files before you write artifacts or declare the stage complete.",
-        "If `AGENTS.md` is listed in the contract, use it only for compiled routing that is directly relevant to this stage.",
-        "`.interf/runtime/run.json`, `.interf/runtime/state.json`, `.interf/runtime/health.json`, and `.interf/runtime/view-spec.json` are CLI-owned runtime artifacts. You may read them, but do not create, edit, or replace them unless the contract explicitly marks a different proof artifact as stage-owned.",
-        "If a contract-listed output file does not exist yet, create it in one whole-file write. Do not attempt patch-style edits against a missing runtime path.",
-        "Stay inside the current compiled dataset. Do not try to open repo docs, repo source files, or other paths outside the compiled dataset unless the stage contract explicitly requires them.",
-        instructions.effective_mode === "override"
-            ? "Do not depend on any repo-root or globally installed skill cache for this run. Local stage instruction docs are the primary workflow layer for this run."
-            : "Do not depend on any repo-root or globally installed skill cache for this run. Use the current compiled workflow docs and the contract as the default behavior.",
-        ...modeNotes,
-        "Do not narrate intentions, plans, or reasoning to the user.",
-        "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
-        "Those status lines are progress hints for the operator. The CLI decides stage completion from artifacts, validation, and reconcile checks rather than trusting status text alone.",
-        "Before any long-running raw inspection or shell-based helper step, emit a STATUS: line that names the current subtask.",
-        "If work stays in progress, do not remain silent for more than about one minute. Emit another STATUS: line when you switch files, page groups, targets, or extraction methods.",
-        "If you respond conversationally instead of executing the stage, the run will be treated as failed.",
-        "As soon as the required proof artifacts are complete, stop. Do not keep browsing or auditing after the contract is satisfied.",
-        ...statusLines,
-    ].join("\n");
-}
+export * from "../packages/compiler/runtime-prompt.js";

package/dist/lib/runtime-reconcile.d.ts

@@ -1,2 +1 @@
-import { type WorkflowStageDefinition } from "./workflow-definitions.js";
-export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<WorkflowStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;
+export * from "../packages/compiler/runtime-reconcile.js";

package/dist/lib/runtime-reconcile.js

@@ -1,193 +1 @@
-import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
-import { extname, join, relative } from "node:path";
-import { listFilesRecursive } from "./filesystem.js";
-import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { parseJsonFrontmatter } from "./parse.js";
-import { loadRuntimeRun } from "./runtime.js";
-import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
-import { compiledInventoryFromEntries } from "./runtime-inventory.js";
-import { compiledRuntimeRoot } from "./compiled-paths.js";
-import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
-function readActiveRunStartedAtMs(dirPath) {
-    const run = loadRuntimeRun(dirPath);
-    if (!run)
-        return null;
-    const startedAtMs = Date.parse(run.started_at);
-    return Number.isFinite(startedAtMs) ? startedAtMs : null;
-}
-function anyPathUpdatedSince(absolutePath, sinceMs) {
-    if (!existsSync(absolutePath))
-        return false;
-    try {
-        const stat = statSync(absolutePath);
-        if (stat.isFile())
-            return stat.mtimeMs >= sinceMs;
-    }
-    catch {
-        return false;
-    }
-    for (const filePath of listFilesRecursive(absolutePath)) {
-        try {
-            if (statSync(filePath).mtimeMs >= sinceMs)
-                return true;
-        }
-        catch {
-            continue;
-        }
-    }
-    return false;
-}
-function zoneArtifactCount(dirPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(dirPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
-}
-function summaryAbstract(content) {
-    const parsed = parseJsonFrontmatter(content);
-    if (!parsed)
-        return null;
-    return extractSynthAbstract(parsed.frontmatter, parsed.body);
-}
-function listZoneArtifacts(dirPath, zone) {
-    const absolutePath = compiledZoneAbsolutePath(dirPath, zone);
-    if (!existsSync(absolutePath) || zone.kind === "runtime")
-        return [];
-    if (zone.kind === "file") {
-        try {
-            return statSync(absolutePath).isFile() ? [absolutePath] : [];
-        }
-        catch {
-            return [];
-        }
-    }
-    return listFilesRecursive(absolutePath);
-}
-function buildInventoryMetadata(options) {
-    const metadata = {
-        zone_id: options.zoneId,
-        zone_kind: options.zoneKind,
-        file_extension: extname(options.filePath).toLowerCase() || null,
-    };
-    if (!options.parsedFrontmatter) {
-        return metadata;
-    }
-    metadata.frontmatter_scanned = true;
-    const abstract = summaryAbstract(readFileSync(options.filePath, "utf8"));
-    if (abstract) {
-        metadata.abstract = abstract;
-        metadata.abstract_read = true;
-    }
-    const frontmatter = options.parsedFrontmatter.frontmatter;
-    if (typeof frontmatter.source_kind === "string") {
-        metadata.source_kind = frontmatter.source_kind;
-    }
-    if (typeof frontmatter.evidence_tier === "string") {
-        metadata.evidence_tier = frontmatter.evidence_tier;
-    }
-    if (typeof frontmatter.truth_mode === "string") {
-        metadata.truth_mode = frontmatter.truth_mode;
-    }
-    return metadata;
-}
-function buildStageInventoryEntries(dirPath, stage) {
-    const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
-    if (!schema)
-        return [];
-    const readableInputZones = stage.reads
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null && zone.kind !== "runtime");
-    const outputZones = stage.writes
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null && zone.kind !== "runtime");
-    if (outputZones.length === 0)
-        return [];
-    const entries = [];
-    for (const outputZone of outputZones) {
-        for (const filePath of listZoneArtifacts(dirPath, outputZone)) {
-            const relativeOutputPath = relative(dirPath, filePath).replaceAll("\\", "/");
-            const parsed = isOutputMarkdownFile(filePath)
-                ? parseJsonFrontmatter(readFileSync(filePath, "utf8"))
-                : null;
-            const sourcePath = typeof parsed?.frontmatter.source === "string"
-                ? parsed.frontmatter.source.trim()
-                : "";
-            const sourceZoneId = typeof parsed?.frontmatter.source_zone === "string"
-                ? parsed.frontmatter.source_zone.trim()
-                : "";
-            const inputZone = sourceZoneId.length > 0
-                ? readableInputZones.find((zone) => zone.id === sourceZoneId) ?? null
-                : readableInputZones.length === 1
-                    ? readableInputZones[0]
-                    : null;
-            entries.push({
-                ...(inputZone && sourcePath.length > 0
-                    ? {
-                        input_zone: inputZone.id,
-                        input_path: sourcePath,
-                    }
-                    : {}),
-                output_zone: outputZone.id,
-                output_path: relativeOutputPath,
-                ...(typeof parsed?.frontmatter.state === "string"
-                    ? { state: parsed.frontmatter.state }
-                    : {}),
-                metadata: buildInventoryMetadata({
-                    zoneId: outputZone.id,
-                    zoneKind: outputZone.kind,
-                    filePath,
-                    parsedFrontmatter: parsed,
-                }),
-            });
-        }
-    }
-    return entries.sort((left, right) => `${left.output_zone}:${left.output_path}`.localeCompare(`${right.output_zone}:${right.output_path}`));
-}
-function writeStageInventory(dirPath, stageId, entries) {
-    writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
-}
-function activeRunCounts(dirPath) {
-    return { ...(loadRuntimeRun(dirPath)?.counts ?? {}) };
-}
-export function reconcileCompiledStageRun(dirPath, stage) {
-    const startedAtMs = readActiveRunStartedAtMs(dirPath);
-    if (startedAtMs === null)
-        return false;
-    const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
-    if (!schema)
-        return false;
-    const writeZones = stage.writes
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null);
-    if (writeZones.length === 0)
-        return false;
-    if (!writeZones.some((zone) => anyPathUpdatedSince(compiledZoneAbsolutePath(dirPath, zone), startedAtMs))) {
-        return false;
-    }
-    writeStageInventory(dirPath, stage.id, buildStageInventoryEntries(dirPath, stage));
-    const currentState = {
-        ...initCompiledState(),
-        ...(loadState(dirPath) ?? {}),
-        stages: {
-            ...(loadState(dirPath)?.stages ?? {}),
-        },
-    };
-    const now = new Date().toISOString();
-    currentState.stages[stage.id] = {
-        contract_type: stage.contractType,
-        status: "succeeded",
-        started_at: loadRuntimeRun(dirPath)?.started_at ?? now,
-        finished_at: now,
-        counts: activeRunCounts(dirPath),
-        zone_counts: Object.fromEntries(writeZones.map((zone) => [zone.id, zoneArtifactCount(dirPath, zone.path, zone.kind)])),
-        artifacts: writeZones.map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`),
-        summary: loadRuntimeRun(dirPath)?.summary ?? null,
-        run_id: loadRuntimeRun(dirPath)?.run_id ?? null,
-    };
-    currentState.last_compile = now;
-    saveState(dirPath, currentState);
-    refreshCompiledArtifacts(dirPath, { ensureViewSpec: true });
-    return true;
-}
+export * from "../packages/compiler/runtime-reconcile.js";