@interf/compiler 0.6.1 → 0.6.4

package/dist/packages/compiler/lib/schema.js

@@ -0,0 +1,363 @@
+import { z } from "zod";
+import { COMPILED_ZONE_KINDS, } from "../workflow-primitives.js";
+const JsonRecordSchema = z.record(z.string(), z.unknown());
+const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
+function isCompiledRelativePath(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 RuntimeTargetTypeSchema = z.enum(["compiled"]);
+export const TestTargetTypeSchema = z.enum(["compiled", "raw"]);
+export const WorkflowIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
+export const RuntimeStageSchema = z.string().regex(WorkflowIdPattern);
+export const RuntimeContractTypeSchema = z.string().regex(WorkflowIdPattern);
+export const WorkflowIdSchema = z.string().regex(WorkflowIdPattern);
+export const WorkflowZoneIdSchema = z.string().regex(WorkflowIdPattern);
+export const WorkflowCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
+export const WorkflowZoneRoleSchema = z.enum(["input", "working", "output", "runtime"]);
+export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
+export const SourceCompiledMaxAttemptsSchema = z.number().int().min(1).max(5);
+export const SourceCompiledMaxLoopsSchema = z.number().int().min(1).max(3);
+export const CompiledStageStateSchema = z.object({
+    contract_type: RuntimeContractTypeSchema.optional(),
+    status: CompiledStageStatusSchema.optional(),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    counts: z.record(z.string(), z.number()).optional(),
+    zone_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 CompiledStateSchema = z.object({
+    version: z.number().int().min(1),
+    pending: z.array(z.string()),
+    stages: z.record(z.string().regex(WorkflowIdPattern), CompiledStageStateSchema).optional(),
+    last_add: z.string().nullable().optional(),
+    last_compile: 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 CompiledHealthSchema = z.object({
+    kind: z.literal("compiled-health"),
+    version: z.number().int().min(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    status: z.enum(["idle", "running", "compiled", "stale", "failed"]),
+    stage: z.union([
+        z.enum(["idle", "compiled", "failed"]),
+        RuntimeStageSchema,
+    ]),
+    summary: z.string(),
+    metrics: z.record(z.string(), z.number()),
+    checks: z.record(z.string(), z.boolean()),
+});
+export const CompiledViewSpecSchema = z.object({
+    kind: z.literal("compiled-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 CompiledRawSnapshotSchema = z.object({
+    kind: z.literal("compiled-raw-snapshot"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    source_root: z.string(),
+    raw_root: z.string(),
+    source_total: z.number(),
+    sample_files: z.array(z.string()),
+});
+export const WorkflowPurposeSchema = z.object({
+    label: z.string().min(1),
+    task_hint: z.string().min(1),
+}).strict();
+export const WorkflowZoneSchema = z.object({
+    id: WorkflowZoneIdSchema,
+    role: WorkflowZoneRoleSchema,
+    path: z.string().min(1).refine(isCompiledRelativePath, {
+        message: "Zone paths must stay inside the compiled root",
+    }),
+    kind: WorkflowCompiledZoneKindSchema,
+    required: z.boolean(),
+    owned_by: z.array(z.string().regex(WorkflowIdPattern)),
+    description: z.string().min(1),
+});
+export const WorkflowCompiledZoneSchema = WorkflowZoneSchema;
+// Persisted schema for the workflow-defined context interface that one
+// compiled context must implement on disk.
+export const WorkflowSchemaSchema = z.object({
+    kind: z.literal("workflow-schema"),
+    version: z.literal(1),
+    target_type: z.literal("compiled"),
+    label: z.string().min(1),
+    zones: z.array(WorkflowZoneSchema).min(1),
+});
+export const WorkflowCompiledSchemaSchema = WorkflowSchemaSchema;
+export const WorkflowCompilerApiSchema = z.object({
+    kind: z.literal("compiled"),
+    version: z.literal(1),
+});
+export const WorkflowStageZoneAccessSchema = z.array(WorkflowZoneIdSchema).min(1);
+export const ExecutionShellZoneMountSchema = z.object({
+    zone_id: WorkflowZoneIdSchema,
+    compiled_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),
+    workflow: WorkflowIdSchema,
+    stage: RuntimeStageSchema,
+    reads: z.array(ExecutionShellZoneMountSchema),
+    writes: z.array(ExecutionShellZoneMountSchema),
+});
+export const RuntimeExecutorInfoSchema = z.object({
+    kind: z.enum(["local-agent", "connected-provider", "managed"]),
+    name: z.string(),
+    display_name: z.string(),
+    command: z.string().nullable(),
+    model: z.string().nullable().optional(),
+    effort: z.string().nullable().optional(),
+    profile: z.string().nullable().optional(),
+    timeout_ms: z.number().nullable().optional(),
+});
+export const RuntimeStageInstructionsSchema = z.object({
+    stage_skill_dir: z.string().regex(WorkflowIdPattern),
+    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 RuntimeStageAcceptanceSchema = z.object({
+    artifacts_exist: z.array(z.string()).optional(),
+    stage_truthy: z.array(z.string()).optional(),
+    stage_equals_counts: z.record(z.string(), z.string()).optional(),
+    stage_at_least: z.record(z.string(), z.number()).optional(),
+    stage_at_least_counts: z.record(z.string(), z.string()).optional(),
+    zone_counts_at_least: z.record(z.string().regex(WorkflowIdPattern), z.number()).optional(),
+    zone_counts_at_least_counts: z.record(z.string().regex(WorkflowIdPattern), z.string()).optional(),
+    markdown_frontmatter_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
+    frontmatter_required_keys_in_zones: z.record(WorkflowZoneIdSchema, z.array(z.string().min(1)).min(1)).optional(),
+    markdown_abstract_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
+    wikilinks_valid_in_zones: z.array(WorkflowZoneIdSchema).optional(),
+    artifacts_must_not_contain: z.record(z.string(), z.array(z.string().min(1))).optional(),
+}).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(),
+    workflow: z.object({
+        id: WorkflowIdSchema,
+        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()),
+    acceptance: RuntimeStageAcceptanceSchema.optional(),
+    artifacts: z.object({
+        reads: z.array(z.string()),
+        writes: z.array(z.string()),
+        verifies: z.array(z.string()).optional(),
+    }),
+    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(),
+    workflow: WorkflowIdSchema,
+    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 CompiledInventoryEntrySchema = z.object({
+    input_zone: WorkflowZoneIdSchema.optional(),
+    input_path: z.string().min(1).optional(),
+    output_zone: WorkflowZoneIdSchema,
+    output_path: z.string().min(1),
+    state: z.string().min(1).optional(),
+    metadata: JsonRecordSchema.optional(),
+}).strict();
+export const CompiledInventorySchema = z.object({
+    kind: z.literal("compiled-runtime-ledger").optional(),
+    version: z.number().int().min(1).optional(),
+    stage: RuntimeStageSchema.optional(),
+    entries: z.array(CompiledInventoryEntrySchema),
+    total: z.number().int().nonnegative(),
+});
+export const TestCaseExpectSchema = z.object({
+    must_include: z.array(z.string().min(1)).optional(),
+    must_include_one_of: z.array(z.array(z.string().min(1)).min(1)).optional(),
+    must_not_include: z.array(z.string().min(1)).optional(),
+    min_words: z.number().int().nonnegative().optional(),
+    max_words: z.number().int().nonnegative().optional(),
+}).refine((value) => value.min_words === undefined ||
+    value.max_words === undefined ||
+    value.max_words >= value.min_words, {
+    message: "max_words must be greater than or equal to min_words",
+}).refine((value) => (value.must_include?.length ?? 0) > 0 ||
+    (value.must_include_one_of?.length ?? 0) > 0 ||
+    (value.must_not_include?.length ?? 0) > 0 ||
+    value.min_words !== undefined ||
+    value.max_words !== undefined, {
+    message: "Test expectations must include at least one check",
+});
+export const WorkflowImprovementLoopSummarySchema = 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 WorkflowImprovementContextSchema = z.object({
+    kind: z.literal("interf-workflow-improvement-loop"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    workflow_id: WorkflowIdSchema,
+    loop_index: z.number().int().min(1),
+    max_loops: SourceCompiledMaxLoopsSchema,
+    max_attempts: SourceCompiledMaxAttemptsSchema,
+    review_paths: z.object({
+        workflow_root: z.string(),
+        compiled_runtime: z.string().nullable(),
+        test_comparisons: z.string().nullable(),
+        execution_shells: z.string().nullable(),
+        test_runs: z.string().nullable(),
+        test_sandboxes: z.string().nullable(),
+    }),
+    truth_checks: z.object({
+        count: z.number().int().min(0),
+        questions: z.array(z.object({
+            id: z.string(),
+            question: z.string(),
+        })),
+    }),
+    previous_variations: z.array(WorkflowImprovementLoopSummarySchema),
+    latest_failure: WorkflowImprovementLoopSummarySchema.nullable(),
+});
+export const PreservedShellTypeSchema = z.enum([
+    "stage-execution",
+    "workflow-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 WorkflowPackageValidationSchema = z.object({
+    ok: z.boolean(),
+    summary: z.string(),
+    errors: z.array(z.string()),
+    counts: z.record(z.string(), z.number()),
+});
+export const WorkflowImprovementLoopRecordSchema = z.object({
+    kind: z.literal("interf-workflow-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(),
+    workflow_id: WorkflowIdSchema,
+    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(),
+    workflow_before_path: z.string(),
+    workflow_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: WorkflowPackageValidationSchema.nullable(),
+});
+export const WorkflowImprovementRunLedgerSchema = z.object({
+    kind: z.literal("interf-workflow-improvement-run"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    updated_at: z.string(),
+    run_id: z.string(),
+    target_name: z.string(),
+    workflow_id: WorkflowIdSchema,
+    max_loops: SourceCompiledMaxLoopsSchema,
+    max_attempts: SourceCompiledMaxAttemptsSchema,
+    loops: z.array(WorkflowImprovementLoopRecordSchema),
+});

package/dist/packages/compiler/raw-snapshot.d.ts

@@ -0,0 +1,49 @@
+import type { InterfConfig } from "../project-model/lib/schema.js";
+export interface CompiledRawSyncResult {
+    sourceTotal: number;
+    copied: number;
+    removed: number;
+}
+type RawSnapshotMaterializeMode = "copy" | "link-or-copy";
+export declare function resolveCompiledRawPath(compiledPath: string, config?: {
+    [x: string]: unknown;
+    type: "compiled";
+    name: string;
+    workflow: string;
+    checks: {
+        question: string;
+        id?: string | undefined;
+        answer?: string | undefined;
+        expect?: {
+            must_include?: string[] | undefined;
+            must_include_one_of?: string[][] | undefined;
+            must_not_include?: string[] | undefined;
+            min_words?: number | undefined;
+            max_words?: number | undefined;
+        } | undefined;
+        strictness?: string | undefined;
+    }[];
+    source: {
+        path: string;
+        dataset_path: string;
+        control_path?: string | undefined;
+    };
+    about?: string | undefined;
+    max_attempts?: number | undefined;
+    max_loops?: number | undefined;
+    workflow_origin?: {
+        selected: string;
+        local_draft?: boolean | undefined;
+    } | undefined;
+} | null): string;
+export declare function syncCompiledRawSnapshot(compiledPath: string, sourcePath?: string): CompiledRawSyncResult;
+export declare function ensureCompiledRawBinding(compiledPath: string): InterfConfig | null;
+export declare function projectRawSnapshot(options: {
+    sourcePath: string;
+    destinationPath: string;
+    compiledPath: string;
+    mode?: RawSnapshotMaterializeMode;
+    prune?: boolean;
+    preserveTimestamps?: boolean;
+}): CompiledRawSyncResult;
+export {};

package/dist/packages/compiler/raw-snapshot.js

@@ -0,0 +1,102 @@
+import { cpSync, existsSync, linkSync, mkdirSync, rmSync, statSync, } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { listFilesRecursive } from "../shared/filesystem.js";
+import { assertPathWithinRoot } from "../shared/path-guards.js";
+import { discoverSourceFiles } from "./discovery.js";
+import { defaultControlPathForCompiled } from "./compiled-paths.js";
+import { readInterfConfig, resolveSourceInputPath, } from "../project-model/interf-detect.js";
+import { saveCompiledInterfConfig } from "../project-model/source-config.js";
+export function resolveCompiledRawPath(compiledPath, config = readInterfConfig(compiledPath)) {
+    const configuredPath = typeof config?.source?.path === "string" && config.source.path.length > 0
+        ? config.source.path
+        : "raw";
+    return assertPathWithinRoot(compiledPath, resolve(compiledPath, configuredPath), "Compiled raw path");
+}
+export function syncCompiledRawSnapshot(compiledPath, sourcePath = resolveSourceInputPath(compiledPath)) {
+    ensureCompiledRawBinding(compiledPath);
+    const rawPath = resolveCompiledRawPath(compiledPath);
+    return projectRawSnapshot({
+        sourcePath,
+        destinationPath: rawPath,
+        compiledPath,
+        mode: "copy",
+        prune: true,
+        preserveTimestamps: true,
+    });
+}
+export function ensureCompiledRawBinding(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (!config)
+        return null;
+    if (config.source?.path === "./raw")
+        return config;
+    const nextConfig = {
+        ...config,
+        source: {
+            ...(config.source ?? {}),
+            path: "./raw",
+            control_path: config.source?.control_path ?? defaultControlPathForCompiled(compiledPath),
+            ...(config.source?.dataset_path ? { dataset_path: config.source.dataset_path } : {}),
+        },
+    };
+    return saveCompiledInterfConfig(compiledPath, nextConfig);
+}
+function filesMatch(sourcePath, targetPath) {
+    if (!existsSync(targetPath))
+        return false;
+    try {
+        const sourceStat = statSync(sourcePath);
+        const targetStat = statSync(targetPath);
+        return sourceStat.size === targetStat.size && sourceStat.mtimeMs === targetStat.mtimeMs;
+    }
+    catch {
+        return false;
+    }
+}
+function materializeRawSnapshotFile(sourcePath, targetPath, options) {
+    mkdirSync(dirname(targetPath), { recursive: true });
+    rmSync(targetPath, { force: true });
+    if (options.mode === "link-or-copy") {
+        try {
+            linkSync(sourcePath, targetPath);
+            return;
+        }
+        catch {
+            // fall through to copy
+        }
+    }
+    cpSync(sourcePath, targetPath, { preserveTimestamps: options.preserveTimestamps });
+}
+export function projectRawSnapshot(options) {
+    const discovery = discoverSourceFiles(options.sourcePath, options.compiledPath);
+    const expectedFiles = new Set(discovery.sourceFiles);
+    mkdirSync(options.destinationPath, { recursive: true });
+    let removed = 0;
+    if (options.prune !== false) {
+        for (const existingPath of listFilesRecursive(options.destinationPath)) {
+            const relativePath = relative(options.destinationPath, existingPath);
+            if (expectedFiles.has(relativePath))
+                continue;
+            rmSync(existingPath, { force: true });
+            removed += 1;
+        }
+    }
+    let copied = 0;
+    for (const relativePath of discovery.sourceFiles) {
+        const sourceFilePath = join(options.sourcePath, relativePath);
+        const targetFilePath = join(options.destinationPath, relativePath);
+        if (filesMatch(sourceFilePath, targetFilePath)) {
+            continue;
+        }
+        materializeRawSnapshotFile(sourceFilePath, targetFilePath, {
+            mode: options.mode ?? "copy",
+            preserveTimestamps: options.preserveTimestamps ?? true,
+        });
+        copied += 1;
+    }
+    return {
+        sourceTotal: discovery.totalCount,
+        copied,
+        removed,
+    };
+}

package/dist/packages/compiler/reset.d.ts

@@ -0,0 +1,2 @@
+export declare function clearCompiledRuntimeDerivedArtifacts(compiledPath: string): void;
+export declare function resetCompiledGeneratedState(compiledPath: string, scope?: "compile" | "all"): void;

package/dist/packages/compiler/reset.js

@@ -0,0 +1,72 @@
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { initializeCompiledRuntimeState } from "./state.js";
+import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, workflowPackagePathForCompiled, } from "./compiled-paths.js";
+function removeIfExists(path) {
+    if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+    }
+}
+const COMPILE_RUNTIME_RESET_ENTRIES = [
+    "state.json",
+    "health.json",
+    "view-spec.json",
+    "inventory.json",
+    "run.json",
+    "raw-snapshot.json",
+    "stage-contract.json",
+];
+const PRESERVED_COMPILED_ROOTS = new Set([
+    ".agents",
+    ".claude",
+    ".codex",
+    ".cursor",
+    ".gitignore",
+    ".interf",
+    ".interfignore",
+    "AGENTS.md",
+    "CLAUDE.md",
+]);
+export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
+    const runtimeRoot = compiledRuntimeRoot(compiledPath);
+    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
+        removeIfExists(join(runtimeRoot, entry));
+    }
+    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
+}
+function activeCompiledInputRoots(compiledPath) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const roots = new Set();
+    for (const zone of schema?.zones ?? []) {
+        if (zone.role !== "input")
+            continue;
+        const root = zone.path.split("/")[0]?.trim();
+        if (root)
+            roots.add(root);
+    }
+    return roots;
+}
+function resetCompiledGeneratedOutputs(compiledPath) {
+    const preservedInputRoots = activeCompiledInputRoots(compiledPath);
+    for (const entry of readdirSync(compiledPath)) {
+        if (PRESERVED_COMPILED_ROOTS.has(entry))
+            continue;
+        if (preservedInputRoots.has(entry))
+            continue;
+        removeIfExists(join(compiledPath, entry));
+    }
+}
+export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
+    resetCompiledGeneratedOutputs(compiledPath);
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
+    if (scope === "all") {
+        removeIfExists(stageExecutionShellsRoot(compiledPath));
+        removeIfExists(workflowImprovementLoopsRoot(compiledPath));
+        removeIfExists(compiledRuntimeLogsRoot(compiledPath));
+        removeIfExists(join(compiledRuntimeRoot(compiledPath), "run-history.jsonl"));
+        removeIfExists(testRootForCompiled(compiledPath));
+        removeIfExists(testTargetsRootForCompiled(compiledPath));
+    }
+}

package/dist/packages/compiler/runtime-acceptance.d.ts

@@ -0,0 +1,9 @@
+import { type CompiledState, type RuntimeStageAcceptance, type RuntimeStageContract } from "./lib/schema.js";
+import { type RuntimeStageAcceptanceValidation } from "./runtime-types.js";
+export declare function stageRecordFromState(state: CompiledState | null, stageId: string): Record<string, unknown> | null;
+export declare function validateResolvedStageAcceptance(dirPath: string, options: {
+    stageId: string;
+    acceptance?: RuntimeStageAcceptance;
+    counts?: Record<string, number>;
+}): RuntimeStageAcceptanceValidation;
+export declare function validateStageContractAcceptance(dirPath: string, contract?: RuntimeStageContract | null): RuntimeStageAcceptanceValidation;