@interf/compiler 0.22.2 → 0.50.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/lib/schema.js

@@ -1,316 +0,0 @@
-import { z } from "zod";
-import { BUILD_PLAN_ARTIFACT_KINDS, } from "../build-plan-primitives.js";
-import { ArtifactIdSchema, ArtifactSchema, CheckSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, InterfIdPattern, BuildPlanIdSchema, } from "../../../contracts/lib/schema.js";
-// `ArtifactSchema` is used internally below in `BuildPlanContextRawSchema`'s
-// `artifacts[]` field. The other Artifact* schemas/types are NOT
-// re-exported through this module — callers import them directly
-// from `contracts/lib/schema.js`. The 0.17 PR cross-check pruned
-// re-exports that had zero consumers.
-export { GateStatusSchema, ReadinessGateSchema, ReadinessSchema, ReadinessStatusSchema, VerifyTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, BuildPlanIdSchema, } from "../../../contracts/lib/schema.js";
-const JsonRecordSchema = z.record(z.string(), z.unknown());
-const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
-function isVerifiableContextRelativePath(value) {
-    if (value.length === 0)
-        return false;
-    if (value.startsWith("/") || value.startsWith("\\"))
-        return false;
-    return value
-        .split(/[\\/]+/)
-        .every((segment) => COMPILED_RELATIVE_PATH_SEGMENT.test(segment));
-}
-export const BuildPlanArtifactIdSchema = z.string().regex(InterfIdPattern);
-export const BuildPlanArtifactKindSchema = z.enum(BUILD_PLAN_ARTIFACT_KINDS);
-export const BuildPlanArtifactRoleSchema = z.enum(["input", "working", "output", "runtime"]);
-export const BuildStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
-export const VerifiableContextStageStateSchema = z.object({
-    contract_type: RuntimeContractTypeSchema.optional(),
-    status: BuildStageStatusSchema.optional(),
-    started_at: z.string().nullable().optional(),
-    finished_at: z.string().nullable().optional(),
-    counts: z.record(z.string(), z.number()).optional(),
-    artifact_counts: z.record(z.string(), z.number()).optional(),
-    artifacts: z.array(z.string()).optional(),
-    summary: z.string().nullable().optional(),
-    run_id: z.string().nullable().optional(),
-});
-export const VerifiableContextStateSchema = z.object({
-    version: z.number().int().min(1),
-    pending: z.array(z.string()),
-    stages: z.record(z.string().regex(InterfIdPattern), VerifiableContextStageStateSchema).optional(),
-    last_add: z.string().nullable().optional(),
-    last_build: z.string().nullable().optional(),
-    warning_count: z.number().optional(),
-    error_count: z.number().optional(),
-}).strict();
-export const ViewSectionSchema = z.object({
-    id: z.string(),
-    type: z.enum(["status", "cards", "graph", "documents", "table"]),
-    title: z.string(),
-    path: z.string().optional(),
-    paths: z.array(z.string()).optional(),
-});
-export const ViewCardSchema = z.object({
-    id: z.string(),
-    label: z.string(),
-    metric: z.string(),
-    denominator_metric: z.string().optional(),
-    format: z.enum(["number", "fraction", "timestamp"]),
-});
-export const VerifiableContextHealthSchema = z.object({
-    kind: z.literal("verifiable-context-health"),
-    version: z.number().int().min(1),
-    generated_at: z.string(),
-    target_name: z.string(),
-    status: z.enum(["idle", "running", "built", "stale", "failed"]),
-    stage: z.union([
-        z.enum(["idle", "built", "failed"]),
-        RuntimeStageSchema,
-    ]),
-    summary: z.string(),
-    metrics: z.record(z.string(), z.number()),
-    checks: z.record(z.string(), z.boolean()),
-});
-export const VerifiableContextViewSpecSchema = z.object({
-    kind: z.literal("verifiable-context-view-spec"),
-    version: z.number().int().min(1),
-    generated_at: z.string(),
-    target_name: z.string(),
-    health_source: z.string(),
-    state_source: z.string(),
-    default_note: z.string().nullable(),
-    graph_scope: z.array(z.string()),
-    cards: z.array(ViewCardSchema),
-    sections: z.array(ViewSectionSchema),
-});
-export const BuildPlanPurposeSchema = z.object({
-    label: z.string().min(1),
-    task_hint: z.string().min(1),
-}).strict();
-export const BuildPlanArtifactProjectionSchema = z.object({
-    id: BuildPlanArtifactIdSchema,
-    role: BuildPlanArtifactRoleSchema,
-    path: z.string().min(1).refine(isVerifiableContextRelativePath, {
-        message: "Artifact paths must stay inside the verifiable context root",
-    }),
-    kind: BuildPlanArtifactKindSchema,
-    required: z.boolean(),
-    owned_by: z.array(z.string().regex(InterfIdPattern)),
-    description: z.string().min(1),
-});
-export const BuildPlanArtifactSchema = BuildPlanArtifactProjectionSchema;
-// Persisted schema for the Build Plan-defined artifact interface that one
-// verifiable context must implement on disk.
-export const BuildPlanContextRawSchema = z.object({
-    kind: z.literal("build-plan-schema"),
-    version: z.literal(1),
-    target_type: z.literal("verifiable-context"),
-    label: z.string().min(1),
-    artifacts: z.array(ArtifactSchema).min(1),
-}).strict();
-export const BuildPlanContextSchemaSchema = BuildPlanContextRawSchema;
-export const BuildPlanEngineApiSchema = z.object({
-    kind: z.literal("build"),
-    version: z.literal(1),
-});
-export const BuildPlanStageArtifactReadAccessSchema = z.array(ArtifactIdSchema);
-export const BuildPlanStageArtifactWriteAccessSchema = z.array(ArtifactIdSchema).min(1);
-export const ExecutionShellArtifactMountSchema = z.object({
-    artifact_id: ArtifactIdSchema,
-    artifact_path: z.string(),
-    shell_root_path: z.string(),
-    input_mount_path: z.string().nullable(),
-    output_mount_path: z.string().nullable(),
-});
-export const ExecutionShellPathsSchema = z.object({
-    kind: z.literal("interf-execution-shell"),
-    version: z.literal(1),
-    build_plan: BuildPlanIdSchema,
-    stage: RuntimeStageSchema,
-    reads: z.array(ExecutionShellArtifactMountSchema),
-    writes: z.array(ExecutionShellArtifactMountSchema),
-});
-export const RuntimeStageInstructionsSchema = z.object({
-    stage_skill_dir: z.string().regex(InterfIdPattern),
-    effective_mode: z.enum(["builtin", "extend", "override"]),
-    local_mode: z.enum(["extend", "override"]).nullable(),
-    local_docs: z.array(z.string()),
-    mode_sources: z.array(z.string()),
-}).strict();
-export const RuntimeStageContractSchema = z.object({
-    kind: z.literal("interf-stage-contract"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    run_id: z.string(),
-    target_type: RuntimeTargetTypeSchema,
-    target_name: z.string(),
-    build_plan: z.object({
-        id: BuildPlanIdSchema,
-        stage_index: z.number().nullable(),
-        stage_total: z.number(),
-        stages: z.array(RuntimeStageSchema),
-    }),
-    stage: RuntimeStageSchema,
-    stage_label: z.string(),
-    contract_type: RuntimeContractTypeSchema,
-    executor: RuntimeExecutorInfoSchema,
-    instructions: RuntimeStageInstructionsSchema,
-    counts: z.record(z.string(), z.number()),
-    artifacts: z.object({
-        reads: z.array(z.string()),
-        writes: z.array(z.string()),
-        write_contracts: z.array(z.object({
-            artifact_id: ArtifactIdSchema,
-            path: z.string().min(1),
-            checks: z.array(CheckSchema),
-        }).strict()).default([]),
-    }),
-    policies: z.object({
-        execution_mode: z.literal("deterministic"),
-        status_prefixes: z.array(z.string()),
-        notes: z.array(z.string()),
-        evidence_weighting: z.object({
-            required_fields: z.array(z.string()),
-            preserve_tiers: z.boolean(),
-        }).optional(),
-        working_set: z.object({
-            target_context_fraction: z.number(),
-            strategy: z.string(),
-        }).optional(),
-    }),
-});
-export const RuntimeRunSchema = z.object({
-    kind: z.literal("interf-run"),
-    version: z.literal(1),
-    run_id: z.string(),
-    target_type: RuntimeTargetTypeSchema,
-    target_name: z.string(),
-    build_plan: BuildPlanIdSchema,
-    stage: RuntimeStageSchema,
-    stage_label: z.string(),
-    contract_type: RuntimeContractTypeSchema,
-    status: z.enum(["running", "succeeded", "failed"]),
-    executor: RuntimeExecutorInfoSchema,
-    started_at: z.string(),
-    updated_at: z.string(),
-    finished_at: z.string().nullable(),
-    contract_path: z.string(),
-    execution_path: z.string().optional(),
-    counts: z.record(z.string(), z.number()),
-    output_artifacts: z.array(z.string()),
-    logs: z.object({
-        prompt_path: z.string(),
-        event_stream_path: z.string(),
-        status_path: z.string().optional(),
-    }).optional(),
-    summary: z.string(),
-    exit_code: z.number().nullable(),
-    error: z.string().nullable(),
-});
-export const RuntimeInventoryEntrySchema = z.object({
-    input_artifact: ArtifactIdSchema.optional(),
-    input_path: z.string().min(1).optional(),
-    output_artifact: ArtifactIdSchema,
-    output_path: z.string().min(1),
-    state: z.string().min(1).optional(),
-    metadata: JsonRecordSchema.optional(),
-}).strict();
-export const RuntimeInventorySchema = z.object({
-    kind: z.literal("verifiable-context-runtime-ledger").optional(),
-    version: z.number().int().min(1).optional(),
-    stage: RuntimeStageSchema.optional(),
-    entries: z.array(RuntimeInventoryEntrySchema),
-    total: z.number().int().nonnegative(),
-});
-export const BuildPlanImprovementLoopSummarySchema = z.object({
-    variation: z.number().int().min(1),
-    kind: z.enum(["baseline", "edited"]),
-    attempts_run: z.number().int().min(1),
-    passed: z.boolean(),
-    passed_questions: z.number().int().min(0),
-    total_questions: z.number().int().min(0),
-    failed_stage: z.string().nullable().optional(),
-    test_run_path: z.string().nullable().optional(),
-    test_sandbox_path: z.string().nullable().optional(),
-    summary: z.string().min(1),
-});
-export const BuildPlanImprovementContextSchema = z.object({
-    kind: z.literal("interf-build-plan-improvement-loop"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    target_name: z.string(),
-    build_plan_id: BuildPlanIdSchema,
-    loop_index: z.number().int().min(1),
-    max_loops: SourceBuildMaxLoopsSchema,
-    max_attempts: SourceBuildMaxAttemptsSchema,
-    review_paths: z.object({
-        build_plan_root: z.string(),
-        verifiable_context_runtime: z.string().nullable(),
-        readiness_runs: z.string().nullable(),
-        execution_shells: z.string().nullable(),
-        test_runs: z.string().nullable(),
-        test_sandboxes: z.string().nullable(),
-    }),
-    readiness_checks: z.object({
-        count: z.number().int().min(0),
-        questions: z.array(z.object({
-            id: z.string(),
-            question: z.string(),
-        })),
-    }),
-    previous_variations: z.array(BuildPlanImprovementLoopSummarySchema),
-    latest_failure: BuildPlanImprovementLoopSummarySchema.nullable(),
-});
-export const PreservedShellTypeSchema = z.enum([
-    "stage-execution",
-    "build-plan-authoring",
-    "build-plan-improvement",
-]);
-export const PreservedShellSnapshotSchema = z.object({
-    kind: z.literal("interf-preserved-shell"),
-    version: z.literal(1),
-    shell_type: PreservedShellTypeSchema,
-    generated_at: z.string(),
-    root_path: z.string(),
-    materialized_symlinks: z.number().int().min(0),
-});
-export const BuildPlanPackageValidationSchema = z.object({
-    ok: z.boolean(),
-    summary: z.string(),
-    errors: z.array(z.string()),
-    counts: z.record(z.string(), z.number()),
-});
-export const BuildPlanImprovementLoopRecordSchema = z.object({
-    kind: z.literal("interf-build-plan-improvement-loop-record"),
-    version: z.literal(1),
-    recorded_at: z.string(),
-    run_id: z.string(),
-    loop_index: z.number().int().min(1),
-    target_name: z.string(),
-    build_plan_id: BuildPlanIdSchema,
-    result: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
-    changed: z.boolean(),
-    applied: z.boolean(),
-    summary: z.string(),
-    shell_path: z.string(),
-    loop_root_path: z.string(),
-    context_path: z.string(),
-    build_plan_before_path: z.string(),
-    build_plan_after_path: z.string(),
-    prompt_log_path: z.string(),
-    event_log_path: z.string(),
-    status_log_path: z.string(),
-    preserved_shell_manifest_path: z.string().nullable(),
-    validation: BuildPlanPackageValidationSchema.nullable(),
-});
-export const BuildPlanImprovementRunLedgerSchema = z.object({
-    kind: z.literal("interf-build-plan-improvement-run"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    updated_at: z.string(),
-    run_id: z.string(),
-    target_name: z.string(),
-    build_plan_id: BuildPlanIdSchema,
-    max_loops: SourceBuildMaxLoopsSchema,
-    max_attempts: SourceBuildMaxAttemptsSchema,
-    loops: z.array(BuildPlanImprovementLoopRecordSchema),
-});

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));
-    }
-}