@interf/compiler 0.22.0 → 0.33.0

package/dist/packages/engine/build/check-evaluator.js

@@ -1,298 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { CheckKindSchema, } from "../../contracts/lib/schema.js";
-import { countBrokenWikilinks, isOutputMarkdownFile, validateSynthFiles, } from "./validate.js";
-/**
- * Build a Proof envelope from an evaluator outcome. Centralizes the
- * timestamp + required-flag plumbing so individual evaluators can
- * focus on the pass/fail decision and a one-line summary.
- */
-function makeProof(check, passed, summary, details) {
-    return {
-        check_id: check.id,
-        kind: check.kind,
-        passed,
-        required: check.required,
-        summary,
-        ...(details !== undefined ? { details } : {}),
-        evaluated_at: new Date().toISOString(),
-    };
-}
-function resolveTargetPath(check, context) {
-    const target = context.targetPath;
-    if (!target)
-        return null;
-    const root = resolve(context.rootPath);
-    const absolute = resolve(root, target);
-    // Defense in depth — schema-level validation already rejects path
-    // traversal, but a hand-edited Build Plan or stale on-disk fixture could
-    // slip through. Reject anything that escapes the root.
-    if (absolute !== root && !absolute.startsWith(`${root}/`)) {
-        return null;
-    }
-    return absolute;
-}
-function listMarkdownFiles(absolutePath) {
-    if (!existsSync(absolutePath))
-        return [];
-    try {
-        const stats = statSync(absolutePath);
-        if (stats.isFile()) {
-            return isOutputMarkdownFile(absolutePath) ? [absolutePath] : [];
-        }
-        if (stats.isDirectory()) {
-            return listFilesRecursive(absolutePath, isOutputMarkdownFile);
-        }
-    }
-    catch {
-        return [];
-    }
-    return [];
-}
-function countFiles(absolutePath) {
-    if (!existsSync(absolutePath))
-        return 0;
-    try {
-        const stats = statSync(absolutePath);
-        if (stats.isFile())
-            return 1;
-        if (stats.isDirectory()) {
-            return listFilesRecursive(absolutePath, () => true).length;
-        }
-    }
-    catch {
-        return 0;
-    }
-    return 0;
-}
-const EVALUATORS = {
-    file_exists(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target) {
-            return makeProof(check, false, "No target path provided for file_exists check.");
-        }
-        if (!existsSync(target)) {
-            return makeProof(check, false, "File or directory does not exist.", { path: context.targetPath });
-        }
-        try {
-            const stats = statSync(target);
-            if (stats.isFile() && stats.size === 0) {
-                return makeProof(check, false, "File exists but is empty.", { path: context.targetPath });
-            }
-            return makeProof(check, true, `Path exists (${stats.isDirectory() ? "directory" : "file"}).`);
-        }
-        catch {
-            return makeProof(check, false, "Could not stat target path.", { path: context.targetPath });
-        }
-    },
-    min_file_count(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target) {
-            return makeProof(check, false, "No target path provided for min_file_count check.");
-        }
-        const min = typeof check.params?.min === "number" ? check.params.min : 1;
-        const actual = countFiles(target);
-        if (actual >= min) {
-            return makeProof(check, true, `${actual} file(s) (≥ ${min}).`, { actual, min });
-        }
-        return makeProof(check, false, `Found ${actual} file(s); expected at least ${min}.`, { actual, min });
-    },
-    min_file_count_matches_source(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target) {
-            return makeProof(check, false, "No target path provided for min_file_count_matches_source check.");
-        }
-        const matchKey = typeof check.params?.match === "string" ? check.params.match : "source_total";
-        const expected = context.counts?.[matchKey];
-        if (typeof expected !== "number") {
-            return makeProof(check, false, `Cannot evaluate: count "${matchKey}" not available in context.`, { matchKey });
-        }
-        const actual = countFiles(target);
-        if (actual >= expected) {
-            return makeProof(check, true, `${actual} of ${expected} source files covered.`, { actual, expected });
-        }
-        return makeProof(check, false, `Only ${actual} of ${expected} source files covered.`, { actual, expected, matchKey });
-    },
-    frontmatter_valid(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target) {
-            return makeProof(check, false, "No target path provided for frontmatter_valid check.");
-        }
-        const files = listMarkdownFiles(target);
-        if (files.length === 0) {
-            return makeProof(check, true, "No markdown files to validate.");
-        }
-        const validation = validateSynthFiles(files);
-        if (validation.invalid_frontmatter === 0) {
-            return makeProof(check, true, `${files.length} markdown file(s) have valid frontmatter.`);
-        }
-        return makeProof(check, false, `${validation.invalid_frontmatter} of ${files.length} markdown file(s) have invalid frontmatter.`, { invalid: validation.invalid_frontmatter, total: files.length });
-    },
-    frontmatter_required_keys(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target) {
-            return makeProof(check, false, "No target path provided for frontmatter_required_keys check.");
-        }
-        const keys = Array.isArray(check.params?.keys) ? check.params.keys.filter((k) => typeof k === "string") : [];
-        if (keys.length === 0) {
-            return makeProof(check, false, "frontmatter_required_keys check requires `params.keys: string[]`.");
-        }
-        const files = listMarkdownFiles(target);
-        if (files.length === 0) {
-            return makeProof(check, true, "No markdown files to validate.");
-        }
-        const validation = validateSynthFiles(files, { requiredFrontmatterKeys: keys });
-        if (validation.invalid_frontmatter === 0) {
-            return makeProof(check, true, `All ${files.length} markdown file(s) have required keys: ${keys.join(", ")}.`);
-        }
-        return makeProof(check, false, `${validation.invalid_frontmatter} of ${files.length} file(s) missing required keys (${keys.join(", ")}).`, { invalid: validation.invalid_frontmatter, total: files.length, requiredKeys: keys });
-    },
-    wikilinks_valid(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target) {
-            return makeProof(check, false, "No target path provided for wikilinks_valid check.");
-        }
-        const broken = countBrokenWikilinks(context.rootPath, [context.rootPath], [target]);
-        if (broken === 0) {
-            return makeProof(check, true, "All wikilinks resolve.");
-        }
-        return makeProof(check, false, `${broken} broken wikilink(s).`, { broken });
-    },
-    must_not_contain(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target || !existsSync(target)) {
-            return makeProof(check, false, "Target path does not exist.", { path: context.targetPath });
-        }
-        const phrases = Array.isArray(check.params?.phrases)
-            ? check.params.phrases.filter((p) => typeof p === "string")
-            : [];
-        if (phrases.length === 0) {
-            return makeProof(check, false, "must_not_contain check requires `params.phrases: string[]`.");
-        }
-        try {
-            const stats = statSync(target);
-            const files = stats.isFile() ? [target] : listFilesRecursive(target, () => true);
-            const offenders = [];
-            for (const file of files) {
-                const content = readFileSync(file, "utf8");
-                for (const phrase of phrases) {
-                    if (content.includes(phrase)) {
-                        offenders.push(`${file}: contains "${phrase}"`);
-                        break;
-                    }
-                }
-            }
-            if (offenders.length === 0) {
-                return makeProof(check, true, `No forbidden phrases found across ${files.length} file(s).`);
-            }
-            return makeProof(check, false, `${offenders.length} file(s) contain forbidden phrases.`, { offenders, phrases });
-        }
-        catch (error) {
-            return makeProof(check, false, `Error reading target: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-    must_contain(check, context) {
-        const target = resolveTargetPath(check, context);
-        if (!target || !existsSync(target)) {
-            return makeProof(check, false, "Target path does not exist.", { path: context.targetPath });
-        }
-        const phrases = Array.isArray(check.params?.phrases)
-            ? check.params.phrases.filter((p) => typeof p === "string")
-            : [];
-        if (phrases.length === 0) {
-            return makeProof(check, false, "must_contain check requires `params.phrases: string[]`.");
-        }
-        try {
-            const stats = statSync(target);
-            // For directories, must_contain checks across ALL files (every phrase
-            // must appear in at least one file). For files, all phrases must
-            // appear in that single file.
-            if (stats.isFile()) {
-                const content = readFileSync(target, "utf8");
-                const missing = phrases.filter((phrase) => !content.includes(phrase));
-                if (missing.length === 0) {
-                    return makeProof(check, true, `All ${phrases.length} required phrase(s) present.`);
-                }
-                return makeProof(check, false, `${missing.length} required phrase(s) missing.`, { missing });
-            }
-            const files = listFilesRecursive(target, () => true);
-            const remaining = new Set(phrases);
-            for (const file of files) {
-                const content = readFileSync(file, "utf8");
-                for (const phrase of [...remaining]) {
-                    if (content.includes(phrase))
-                        remaining.delete(phrase);
-                }
-                if (remaining.size === 0)
-                    break;
-            }
-            if (remaining.size === 0) {
-                return makeProof(check, true, `All ${phrases.length} required phrase(s) found across files.`);
-            }
-            return makeProof(check, false, `${remaining.size} required phrase(s) missing across all files.`, { missing: [...remaining] });
-        }
-        catch (error) {
-            return makeProof(check, false, `Error reading target: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-    qa_match(check, context) {
-        const expected = typeof check.params?.expected === "string" ? check.params.expected : "";
-        const strictness = typeof check.params?.strictness === "string" ? check.params.strictness : "loose";
-        const answer = context.agentAnswer ?? "";
-        if (!expected) {
-            return makeProof(check, false, "qa_match check requires `params.expected: string`.");
-        }
-        if (!answer) {
-            return makeProof(check, false, "No agent answer available for qa_match evaluation.");
-        }
-        if (strictness === "strict") {
-            const passed = answer.trim() === expected.trim();
-            return makeProof(check, passed, passed ? "Answer matches expected exactly." : "Answer does not match expected.");
-        }
-        // Loose: case-insensitive substring match either direction.
-        const a = answer.trim().toLowerCase();
-        const e = expected.trim().toLowerCase();
-        const passed = a.includes(e) || e.includes(a);
-        return makeProof(check, passed, passed ? "Answer matches expected (loose)." : "Answer does not match expected.");
-    },
-};
-/**
- * Evaluate a single Check against a context, returning a Proof.
- */
-export function evaluateCheck(check, context) {
-    const evaluator = EVALUATORS[check.kind];
-    if (!evaluator) {
-        return {
-            check_id: check.id,
-            kind: check.kind,
-            passed: false,
-            required: check.required,
-            summary: `Unknown check kind: ${check.kind}`,
-            evaluated_at: new Date().toISOString(),
-        };
-    }
-    return evaluator(check, context);
-}
-/**
- * Evaluate a list of checks. Aggregate ready/not_ready verdict over
- * the proofs: `ready` if every required check passed, otherwise
- * `not_ready`. Soft checks (required: false) that fail produce a
- * proof but don't change the verdict.
- */
-export function evaluateChecks(checks, context) {
-    const proofs = checks.map((check) => evaluateCheck(check, context));
-    const failures = proofs.filter((proof) => !proof.passed && proof.required);
-    return {
-        proofs,
-        ready: failures.length === 0,
-        failures,
-    };
-}
-/**
- * Type guard for the canonical CheckKinds. Useful at parse boundaries
- * where a string came from on-disk JSON.
- */
-export function isCheckKind(value) {
-    return CheckKindSchema.safeParse(value).success;
-}

package/dist/packages/engine/build/reset.d.ts

@@ -1,2 +0,0 @@
-export declare function clearBuildRuntimeDerivedArtifacts(verifiableContextPath: string): void;
-export declare function resetBuildGeneratedState(verifiableContextPath: string, scope?: "build" | "all"): void;

package/dist/packages/engine/build/reset.js

@@ -1,74 +0,0 @@
-import { existsSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./verifiable-context-schema.js";
-import { initializeBuildRuntimeState } from "./state.js";
-import { stageExecutionShellsRoot, testRootForVerifiableContext, testTargetsRootForVerifiableContext, buildPlanImprovementLoopsRoot, verifiableContextQueryAcceptanceRoot, verifiableContextRuntimeRoot, verifiableContextRuntimeLogsRoot, buildPlanPackagePathForVerifiableContext, } from "./verifiable-context-paths.js";
-function removeIfExists(path) {
-    if (existsSync(path)) {
-        rmSync(path, { recursive: true, force: true });
-    }
-}
-const BUILD_RUNTIME_RESET_ENTRIES = [
-    "state.json",
-    "health.json",
-    "view-spec.json",
-    "inventory.json",
-    "run.json",
-    "source-files.json",
-    "source-snapshot.json",
-    "stage-contract.json",
-    "stages",
-];
-const PRESERVED_COMPILED_ROOTS = new Set([
-    ".agents",
-    ".claude",
-    ".codex",
-    ".cursor",
-    ".gitignore",
-    ".interf",
-    ".interfignore",
-    "AGENTS.md",
-    "CLAUDE.md",
-]);
-export function clearBuildRuntimeDerivedArtifacts(verifiableContextPath) {
-    const runtimeRoot = verifiableContextRuntimeRoot(verifiableContextPath);
-    for (const entry of BUILD_RUNTIME_RESET_ENTRIES) {
-        removeIfExists(join(runtimeRoot, entry));
-    }
-    removeIfExists(verifiableContextQueryAcceptanceRoot(verifiableContextPath));
-}
-function activeBuildInputRoots(verifiableContextPath) {
-    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
-    const roots = new Set();
-    for (const artifact of schema ? listBuildPlanContextArtifacts(schema) : []) {
-        if (artifact.role !== "input")
-            continue;
-        const root = artifact.path.split("/")[0]?.trim();
-        if (root)
-            roots.add(root);
-    }
-    return roots;
-}
-function resetBuildGeneratedOutputs(verifiableContextPath) {
-    const preservedInputRoots = activeBuildInputRoots(verifiableContextPath);
-    for (const entry of readdirSync(verifiableContextPath)) {
-        if (PRESERVED_COMPILED_ROOTS.has(entry))
-            continue;
-        if (preservedInputRoots.has(entry))
-            continue;
-        removeIfExists(join(verifiableContextPath, entry));
-    }
-}
-export function resetBuildGeneratedState(verifiableContextPath, scope = "build") {
-    resetBuildGeneratedOutputs(verifiableContextPath);
-    clearBuildRuntimeDerivedArtifacts(verifiableContextPath);
-    initializeBuildRuntimeState(verifiableContextPath);
-    if (scope === "all") {
-        removeIfExists(stageExecutionShellsRoot(verifiableContextPath));
-        removeIfExists(buildPlanImprovementLoopsRoot(verifiableContextPath));
-        removeIfExists(verifiableContextRuntimeLogsRoot(verifiableContextPath));
-        removeIfExists(join(verifiableContextRuntimeRoot(verifiableContextPath), "run-history.jsonl"));
-        removeIfExists(testRootForVerifiableContext(verifiableContextPath));
-        removeIfExists(testTargetsRootForVerifiableContext(verifiableContextPath));
-    }
-}

package/dist/packages/engine/build/runtime-inventory.d.ts

@@ -1,7 +0,0 @@
-import { type RuntimeInventory, type RuntimeInventoryEntry } from "./lib/schema.js";
-export declare function emptyRuntimeInventory(): RuntimeInventory;
-export declare function buildInventoryFromEntries(entries: RuntimeInventoryEntry[], stage?: string): RuntimeInventory;
-export declare function buildInventoryEntryCount(inventory: RuntimeInventory | null): number;
-export declare function buildInventoryTotal(inventory: RuntimeInventory | null): number;
-export declare function buildInventoryFrontmatterScannedCount(inventory: RuntimeInventory | null): number;
-export declare function buildInventoryAbstractCoverageCount(inventory: RuntimeInventory | null): number;

package/dist/packages/engine/build/runtime-runs.d.ts

@@ -1,10 +0,0 @@
-import { type RuntimeRun, type RuntimeStageContract } from "./lib/schema.js";
-import { type RuntimeRunPatch, type RuntimeStageExecutionOptions } from "./runtime-types.js";
-export declare function loadRuntimeRun(dirPath: string): RuntimeRun | null;
-export declare function saveRuntimeRun(dirPath: string, run: RuntimeRun): void;
-export declare function writeStageContract(dirPath: string, contract: RuntimeStageContract): string;
-export declare function runExecutorStage(options: RuntimeStageExecutionOptions): Promise<number>;
-export declare function beginRuntimeRun(dirPath: string, run: RuntimeRun): RuntimeRun;
-export declare function updateRuntimeRun(dirPath: string, patch: RuntimeRunPatch): RuntimeRun | null;
-export declare function markRuntimeRunFailedAfterValidation(dirPath: string, summary: string): RuntimeRun | null;
-export declare function markRuntimeRunSucceededAfterValidation(dirPath: string, summary: string): RuntimeRun | null;

package/dist/packages/engine/build/runtime-runs.js

@@ -1,224 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { dirname, relative } from "node:path";
-import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
-import { RuntimeRunSchema, } from "./lib/schema.js";
-import { getBuildPlanStageDefinition, getBuildPlanStagePosition, getBuildPlanStages, } from "../../build-plans/package/build-plan-definitions.js";
-import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-import { warnInterf } from "../../contracts/utils/logger.js";
-export function loadRuntimeRun(dirPath) {
-    const path = runPath(dirPath);
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        const parsed = RuntimeRunSchema.safeParse(raw);
-        if (parsed.success)
-            return parsed.data;
-        warnInterf(`Warning: failed to validate runtime run at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-        return null;
-    }
-    catch (error) {
-        warnInterf(`Warning: failed to read runtime run at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-export function saveRuntimeRun(dirPath, run) {
-    mkdirSync(dirname(runPath(dirPath)), { recursive: true });
-    writeFileSync(runPath(dirPath), JSON.stringify(run, null, 2) + "\n");
-}
-export function writeStageContract(dirPath, contract) {
-    mkdirSync(dirname(stageContractPath(dirPath)), { recursive: true });
-    const path = stageContractPath(dirPath);
-    writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
-    return path;
-}
-function writeArchivedStageContract(dirPath, runId, contract) {
-    const path = archivedStageContractPath(dirPath, runId);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
-    return path;
-}
-export async function runExecutorStage(options) {
-    const startedRun = startRuntimeRun(options);
-    const prompt = options.buildPrompt(startedRun.activeContractPath);
-    writeRuntimeRunPrompt(options.verifiableContextPath, startedRun.run.run_id, prompt);
-    const executionPath = options.executionPath ?? options.verifiableContextPath;
-    const code = await options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.verifiableContextPath, startedRun.run.run_id),
-        statusLogPath: statusLogPath(options.verifiableContextPath, startedRun.run.run_id),
-        completionCheck: options.completionCheck,
-        onStatus: options.onStatus,
-    });
-    finalizeRuntimeRun(options.verifiableContextPath, code);
-    return code;
-}
-export function beginRuntimeRun(dirPath, run) {
-    saveRuntimeRun(dirPath, run);
-    return run;
-}
-export function updateRuntimeRun(dirPath, patch) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const next = {
-        ...current,
-        ...patch,
-        updated_at: new Date().toISOString(),
-    };
-    saveRuntimeRun(dirPath, next);
-    return next;
-}
-export function markRuntimeRunFailedAfterValidation(dirPath, summary) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = current.finished_at ?? new Date().toISOString();
-    const next = {
-        ...current,
-        status: "failed",
-        updated_at: new Date().toISOString(),
-        finished_at: finishedAt,
-        exit_code: 1,
-        error: summary,
-        summary,
-    };
-    saveRuntimeRun(dirPath, next);
-    replaceOrAppendRunHistoryEntry(dirPath, next);
-    return next;
-}
-export function markRuntimeRunSucceededAfterValidation(dirPath, summary) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = current.finished_at ?? new Date().toISOString();
-    const next = {
-        ...current,
-        status: "succeeded",
-        updated_at: new Date().toISOString(),
-        finished_at: finishedAt,
-        exit_code: 0,
-        error: null,
-        summary,
-    };
-    saveRuntimeRun(dirPath, next);
-    replaceOrAppendRunHistoryEntry(dirPath, next);
-    return next;
-}
-function startRuntimeRun(options) {
-    const runId = createRunId();
-    const generatedAt = new Date().toISOString();
-    const buildPlanStages = getBuildPlanStages(options.buildPlan, options.buildPlanSourcePath);
-    const stagePosition = getBuildPlanStagePosition(options.buildPlan, options.stage, options.buildPlanSourcePath);
-    const stageDefinition = getBuildPlanStageDefinition(options.buildPlan, options.stage, options.buildPlanSourcePath);
-    const contract = {
-        kind: "interf-stage-contract",
-        version: 1,
-        generated_at: generatedAt,
-        run_id: runId,
-        target_type: "verifiable-context",
-        target_name: options.verifiableContextName,
-        build_plan: {
-            id: options.buildPlan,
-            stage_index: stagePosition?.stageIndex ?? null,
-            stage_total: stagePosition?.stageTotal ?? buildPlanStages.length,
-            stages: stagePosition?.stages ?? buildPlanStages,
-        },
-        stage: options.stage,
-        stage_label: stageDefinition?.label ?? options.stageLabel,
-        contract_type: options.contractType,
-        executor: buildRuntimeExecutorInfo(options.executor),
-        instructions: options.contract.instructions,
-        counts: options.contract.counts,
-        artifacts: options.contract.artifacts,
-        policies: options.contract.policies,
-    };
-    const activeContractPath = writeStageContract(options.verifiableContextPath, contract);
-    const archivedContractPath = writeArchivedStageContract(options.verifiableContextPath, runId, contract);
-    const run = {
-        kind: "interf-run",
-        version: 1,
-        run_id: runId,
-        target_type: "verifiable-context",
-        target_name: options.verifiableContextName,
-        build_plan: options.buildPlan,
-        stage: options.stage,
-        stage_label: stageDefinition?.label ?? options.stageLabel,
-        contract_type: options.contractType,
-        status: "running",
-        executor: buildRuntimeExecutorInfo(options.executor),
-        started_at: generatedAt,
-        updated_at: generatedAt,
-        finished_at: null,
-        contract_path: relative(options.verifiableContextPath, archivedContractPath),
-        ...(options.executionPath ? { execution_path: relative(options.verifiableContextPath, options.executionPath) } : {}),
-        counts: { ...contract.counts },
-        output_artifacts: [...contract.artifacts.writes],
-        logs: {
-            prompt_path: relative(options.verifiableContextPath, promptLogPath(options.verifiableContextPath, runId)),
-            event_stream_path: relative(options.verifiableContextPath, eventLogPath(options.verifiableContextPath, runId)),
-            status_path: relative(options.verifiableContextPath, statusLogPath(options.verifiableContextPath, runId)),
-        },
-        summary: options.summary,
-        exit_code: null,
-        error: null,
-    };
-    return {
-        run: beginRuntimeRun(options.verifiableContextPath, run),
-        activeContractPath: options.executionPath
-            ? "runtime/stage-contract.json"
-            : relative(options.verifiableContextPath, activeContractPath),
-    };
-}
-function finalizeRuntimeRun(dirPath, code) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = new Date().toISOString();
-    const next = {
-        ...current,
-        status: code === 0 ? "succeeded" : "failed",
-        updated_at: finishedAt,
-        finished_at: finishedAt,
-        exit_code: code,
-        error: code === 0 ? null : `Executor exited with code ${code}.`,
-        summary: code === 0
-            ? `${current.stage_label} completed successfully.`
-            : `${current.stage_label} failed with exit code ${code}.`,
-    };
-    saveRuntimeRun(dirPath, next);
-    appendFileSync(runHistoryPath(dirPath), JSON.stringify(next) + "\n");
-    return next;
-}
-function writeRuntimeRunPrompt(dirPath, runId, prompt) {
-    mkdirSync(logsDirPath(dirPath), { recursive: true });
-    writeFileSync(promptLogPath(dirPath, runId), `${prompt}\n`);
-}
-function createRunId() {
-    return `run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function replaceOrAppendRunHistoryEntry(dirPath, run) {
-    const historyPath = runHistoryPath(dirPath);
-    if (!existsSync(historyPath)) {
-        appendFileSync(historyPath, JSON.stringify(run) + "\n");
-        return;
-    }
-    const raw = readFileSync(historyPath, "utf8");
-    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
-    let replaced = false;
-    const nextLines = lines.map((line) => {
-        try {
-            const entry = JSON.parse(line);
-            if (entry.run_id === run.run_id) {
-                replaced = true;
-                return JSON.stringify(run);
-            }
-        }
-        catch {
-            // preserve malformed history lines as-is
-        }
-        return line;
-    });
-    if (!replaced)
-        nextLines.push(JSON.stringify(run));
-    writeFileSync(historyPath, `${nextLines.join("\n")}\n`);
-}

package/dist/packages/engine/build/runtime.d.ts

@@ -1,5 +0,0 @@
-export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
-export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-export { buildStagePrompt } from "./runtime-prompt.js";
-export { buildRuntimeStageContract, } from "./runtime-contracts.js";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/packages/engine/build/runtime.js

@@ -1,4 +0,0 @@
-export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-export { buildStagePrompt } from "./runtime-prompt.js";
-export { buildRuntimeStageContract, } from "./runtime-contracts.js";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/packages/engine/build/source-files.d.ts

@@ -1,46 +0,0 @@
-import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../../contracts/lib/schema.js";
-export declare function buildVerifiableContextSourceFiles(verifiableContextPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
-export declare function writeVerifiableContextSourceFiles(verifiableContextPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
-export declare function buildVerifiableContextSourceSnapshot(options: {
-    verifiableContextPath: string;
-    sourceFiles?: SourceFiles;
-    sourcePath?: string;
-    runId?: string | null;
-    generatedAt?: string;
-}): SourceSnapshot;
-export declare function writeVerifiableContextSourceSnapshot(options: {
-    verifiableContextPath: string;
-    sourceFiles?: SourceFiles;
-    sourcePath?: string;
-    runId?: string | null;
-    generatedAt?: string;
-}): SourceSnapshot;
-export declare function buildBuildStageInputs(options: {
-    buildPlanId: string;
-    stageId: string;
-    snapshot: SourceSnapshot;
-    runId?: string | null;
-    generatedAt?: string;
-}): StageInputs;
-export declare function writeBuildStageInputs(options: {
-    verifiableContextPath: string;
-    buildPlanId: string;
-    stageId: string;
-    snapshot: SourceSnapshot;
-    runId?: string | null;
-    generatedAt?: string;
-}): StageInputs;
-export declare function writeBuildSourceRuntime(options: {
-    verifiableContextPath: string;
-    buildPlanId: string;
-    stageIds: string[];
-    sourcePath?: string;
-    runId?: string | null;
-}): {
-    sourceFiles: SourceFiles;
-    snapshot: SourceSnapshot;
-    stageInputs: StageInputs[];
-};
-export declare function loadVerifiableContextSourceFiles(verifiableContextPath: string): SourceFiles | null;
-export declare function loadVerifiableContextSourceSnapshot(verifiableContextPath: string): SourceSnapshot | null;
-export declare function loadBuildStageInputs(verifiableContextPath: string, stageId: string): StageInputs | null;