@interf/compiler 0.3.4 → 0.4.0

package/dist/lib/runtime-reconcile.js

@@ -5,6 +5,8 @@ import { parseJsonFrontmatter, readJsonFileUnchecked } from "./parse.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { initWorkspaceState, loadState, refreshWorkspaceArtifacts, saveState, } from "./state.js";
 import { validateWorkspace, validateWorkspaceCompile, validateWorkspaceStructure, validateWorkspaceSummarize, } from "./validate.js";
+import { workspaceHomeIsShaped } from "./workspace-home.js";
+import { workspaceRuntimeRoot } from "./workspace-paths.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);
     if (!run)
@@ -100,7 +102,7 @@ function buildWorkspaceInventoryEntries(dirPath) {
         .sort((left, right) => left.source.localeCompare(right.source));
 }
 function writeWorkspaceInventory(dirPath, entries) {
-    writeFileSync(join(dirPath, ".interf", "inventory.json"), JSON.stringify({
+    writeFileSync(join(workspaceRuntimeRoot(dirPath), "inventory.json"), JSON.stringify({
         entries,
         total: entries.length,
     }, null, 2) + "\n");
@@ -109,7 +111,7 @@ export function reconcileWorkspaceSummarizeRun(dirPath, expectedSummaryTotal) {
     const startedAtMs = readActiveRunStartedAtMs(dirPath);
     if (startedAtMs === null)
         return false;
-    const plan = readJsonFileUnchecked(join(dirPath, ".interf", "summarize-targets.json"), "summarize plan");
+    const plan = readJsonFileUnchecked(join(workspaceRuntimeRoot(dirPath), "summarize-targets.json"), "summarize plan");
     if (!plan || plan.targetCount === 0)
         return false;
     if (!plan.targets.every((target) => pathUpdatedSince(dirPath, target.output, startedAtMs))) {
@@ -203,6 +205,9 @@ export function reconcileWorkspaceShapeRun(dirPath) {
     if (!pathUpdatedSince(dirPath, "home.md", startedAtMs)) {
         return false;
     }
+    if (!workspaceHomeIsShaped(dirPath)) {
+        return false;
+    }
     const summaryCount = countFilesRecursive(join(dirPath, "summaries"));
     const inventoryEntries = buildWorkspaceInventoryEntries(dirPath);
     if (summaryCount > 0 && inventoryEntries.length < summaryCount) {
@@ -239,4 +244,3 @@ export function reconcileWorkspaceShapeRun(dirPath) {
     refreshWorkspaceArtifacts(dirPath, { ensureViewSpec: true });
     return validateWorkspaceCompile(dirPath).ok;
 }
-//# sourceMappingURL=runtime-reconcile.js.map

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

@@ -9,4 +9,3 @@ export declare function beginRuntimeRun(dirPath: string, run: RuntimeRun): Runti
 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;
-//# sourceMappingURL=runtime-runs.d.ts.map

package/dist/lib/runtime-runs.js

@@ -1,5 +1,5 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { join, relative } from "node:path";
+import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import chalk from "chalk";
 import { countFilesRecursive } from "./filesystem.js";
 import { buildRuntimeExecutorInfo } from "./executors.js";
@@ -24,11 +24,11 @@ export function loadRuntimeRun(dirPath) {
     }
 }
 export function saveRuntimeRun(dirPath, run) {
-    mkdirSync(join(dirPath, ".interf"), { recursive: true });
+    mkdirSync(dirname(runPath(dirPath)), { recursive: true });
     writeFileSync(runPath(dirPath), JSON.stringify(run, null, 2) + "\n");
 }
 export function writeStageContract(dirPath, contract) {
-    mkdirSync(join(dirPath, ".interf"), { recursive: true });
+    mkdirSync(dirname(stageContractPath(dirPath)), { recursive: true });
     const path = stageContractPath(dirPath);
     writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
     return path;
@@ -342,4 +342,3 @@ function replaceOrAppendRunHistoryEntry(dirPath, run) {
         nextLines.push(JSON.stringify(run));
     writeFileSync(historyPath, `${nextLines.join("\n")}\n`);
 }
-//# sourceMappingURL=runtime-runs.js.map

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

@@ -50,4 +50,3 @@ export interface WorkspaceShapeContractOptions extends WorkspaceKnowledgeContrac
 }
 export interface RuntimeRunPatch extends Partial<Pick<RuntimeRun, "counts" | "summary" | "status" | "error" | "exit_code" | "finished_at">> {
 }
-//# sourceMappingURL=runtime-types.d.ts.map

package/dist/lib/runtime-types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=runtime-types.js.map

package/dist/lib/runtime.d.ts

@@ -4,4 +4,3 @@ export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildWorkspaceSummarizeContract, buildWorkspaceStructureContract, buildWorkspaceShapeContract, } from "./runtime-contracts.js";
 export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";
-//# sourceMappingURL=runtime.d.ts.map

package/dist/lib/runtime.js

@@ -3,4 +3,3 @@ export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildWorkspaceSummarizeContract, buildWorkspaceStructureContract, buildWorkspaceShapeContract, } from "./runtime-contracts.js";
 export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";
-//# sourceMappingURL=runtime.js.map

package/dist/lib/schema.d.ts

@@ -4,9 +4,9 @@ export type WorkspaceStage = "idle" | "summarize" | "structure" | "shape" | "com
 export declare const RuntimeTargetTypeSchema: z.ZodEnum<{
     workspace: "workspace";
 }>;
-export declare const BenchmarkTargetTypeSchema: z.ZodEnum<{
-    workspace: "workspace";
+export declare const TestTargetTypeSchema: z.ZodEnum<{
     raw: "raw";
+    workspace: "workspace";
 }>;
 export declare const WorkflowIdPattern: RegExp;
 export declare const RuntimeStageSchema: z.ZodString;
@@ -17,24 +17,11 @@ export declare const RuntimeContractTypeSchema: z.ZodEnum<{
 }>;
 export declare const WorkflowIdSchema: z.ZodString;
 export declare const WorkflowZoneIdSchema: z.ZodString;
-export declare const WorkspaceInterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
-    type: z.ZodLiteral<"workspace">;
-    name: z.ZodString;
-    about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
-    source: z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$loose>>;
-export declare const InterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
-    type: z.ZodLiteral<"workspace">;
-    name: z.ZodString;
-    about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
-    source: z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$loose>>;
+export declare const WorkflowWorkspaceZoneKindSchema: z.ZodEnum<{
+    runtime: "runtime";
+    directory: "directory";
+    file: "file";
+}>;
 export declare const WorkspaceStateSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     pending: z.ZodArray<z.ZodString>;
@@ -92,12 +79,12 @@ export declare const WorkspaceHealthSchema: z.ZodObject<{
         failed: "failed";
     }>;
     stage: z.ZodEnum<{
-        idle: "idle";
-        compiled: "compiled";
-        failed: "failed";
         summarize: "summarize";
         structure: "structure";
         shape: "shape";
+        idle: "idle";
+        compiled: "compiled";
+        failed: "failed";
     }>;
     summary: z.ZodString;
     metrics: z.ZodObject<{
@@ -177,9 +164,9 @@ export declare const WorkflowWorkspaceZoneSchema: z.ZodObject<{
     id: z.ZodString;
     path: z.ZodString;
     kind: z.ZodEnum<{
-        file: "file";
-        directory: "directory";
         runtime: "runtime";
+        directory: "directory";
+        file: "file";
     }>;
     required: z.ZodBoolean;
     owned_by: z.ZodArray<z.ZodString>;
@@ -194,9 +181,9 @@ export declare const WorkflowWorkspaceSchemaSchema: z.ZodObject<{
         id: z.ZodString;
         path: z.ZodString;
         kind: z.ZodEnum<{
-            file: "file";
-            directory: "directory";
             runtime: "runtime";
+            directory: "directory";
+            file: "file";
         }>;
         required: z.ZodBoolean;
         owned_by: z.ZodArray<z.ZodString>;
@@ -414,14 +401,14 @@ export declare const WorkspaceInventorySchema: z.ZodUnion<readonly [z.ZodObject<
     total: z.ZodOptional<z.ZodNumber>;
     summary_total: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>]>;
-export declare const BenchmarkCaseExpectSchema: z.ZodObject<{
+export declare const TestCaseExpectSchema: z.ZodObject<{
     must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
     must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     min_words: z.ZodOptional<z.ZodNumber>;
     max_words: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const BenchmarkCaseSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const TestCaseSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
     file: z.ZodOptional<z.ZodString>;
@@ -435,10 +422,10 @@ export declare const BenchmarkCaseSchema: z.ZodPipe<z.ZodTransform<unknown, unkn
     }, z.core.$strip>>;
     strictness: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
-export declare const BenchmarkSpecSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const TestSpecSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     type: z.ZodEnum<{
-        workspace: "workspace";
         raw: "raw";
+        workspace: "workspace";
     }>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -457,7 +444,7 @@ export declare const BenchmarkSpecSchema: z.ZodPipe<z.ZodTransform<unknown, unkn
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>>;
-export declare const SourceEvalCaseSchema: z.ZodObject<{
+export declare const SourceTruthCheckSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodString;
     answer: z.ZodOptional<z.ZodString>;
@@ -471,12 +458,14 @@ export declare const SourceEvalCaseSchema: z.ZodObject<{
     strictness: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const SourceWorkspaceMaxAttemptsSchema: z.ZodNumber;
+export declare const SourceWorkspaceMaxLoopsSchema: z.ZodNumber;
 export declare const SourceWorkspaceConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
     workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
+    max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         question: z.ZodString;
@@ -491,6 +480,239 @@ export declare const SourceWorkspaceConfigSchema: z.ZodPipe<z.ZodTransform<unkno
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>>;
+export declare const WorkspaceInterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    type: z.ZodLiteral<"workspace">;
+    name: z.ZodString;
+    about: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    max_attempts: z.ZodOptional<z.ZodNumber>;
+    max_loops: z.ZodOptional<z.ZodNumber>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        question: z.ZodString;
+        answer: z.ZodOptional<z.ZodString>;
+        expect: z.ZodOptional<z.ZodObject<{
+            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            min_words: z.ZodOptional<z.ZodNumber>;
+            max_words: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        strictness: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    workflow_origin: z.ZodOptional<z.ZodObject<{
+        selected: z.ZodString;
+        local_draft: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    source: z.ZodObject<{
+        path: z.ZodString;
+        control_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$loose>>;
+export declare const InterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    type: z.ZodLiteral<"workspace">;
+    name: z.ZodString;
+    about: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    max_attempts: z.ZodOptional<z.ZodNumber>;
+    max_loops: z.ZodOptional<z.ZodNumber>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        question: z.ZodString;
+        answer: z.ZodOptional<z.ZodString>;
+        expect: z.ZodOptional<z.ZodObject<{
+            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            min_words: z.ZodOptional<z.ZodNumber>;
+            max_words: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        strictness: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    workflow_origin: z.ZodOptional<z.ZodObject<{
+        selected: z.ZodString;
+        local_draft: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    source: z.ZodObject<{
+        path: z.ZodString;
+        control_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$loose>>;
+export declare const WorkflowImprovementLoopSummarySchema: z.ZodObject<{
+    variation: z.ZodNumber;
+    kind: z.ZodEnum<{
+        baseline: "baseline";
+        edited: "edited";
+    }>;
+    attempts_run: z.ZodNumber;
+    passed: z.ZodBoolean;
+    passed_questions: z.ZodNumber;
+    total_questions: z.ZodNumber;
+    failed_stage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    test_run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    test_sandbox_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    summary: z.ZodString;
+}, z.core.$strip>;
+export declare const WorkflowImprovementContextSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-workflow-improvement-loop">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    target_name: z.ZodString;
+    workflow_id: z.ZodString;
+    loop_index: z.ZodNumber;
+    max_loops: z.ZodNumber;
+    max_attempts: z.ZodNumber;
+    review_paths: z.ZodObject<{
+        workflow_root: z.ZodString;
+        workspace_runtime: z.ZodNullable<z.ZodString>;
+        test_comparisons: z.ZodNullable<z.ZodString>;
+        execution_shells: z.ZodNullable<z.ZodString>;
+        test_runs: z.ZodNullable<z.ZodString>;
+        test_sandboxes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    truth_checks: z.ZodObject<{
+        count: z.ZodNumber;
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    previous_variations: z.ZodArray<z.ZodObject<{
+        variation: z.ZodNumber;
+        kind: z.ZodEnum<{
+            baseline: "baseline";
+            edited: "edited";
+        }>;
+        attempts_run: z.ZodNumber;
+        passed: z.ZodBoolean;
+        passed_questions: z.ZodNumber;
+        total_questions: z.ZodNumber;
+        failed_stage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        test_run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        test_sandbox_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        summary: z.ZodString;
+    }, z.core.$strip>>;
+    latest_failure: z.ZodNullable<z.ZodObject<{
+        variation: z.ZodNumber;
+        kind: z.ZodEnum<{
+            baseline: "baseline";
+            edited: "edited";
+        }>;
+        attempts_run: z.ZodNumber;
+        passed: z.ZodBoolean;
+        passed_questions: z.ZodNumber;
+        total_questions: z.ZodNumber;
+        failed_stage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        test_run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        test_sandbox_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        summary: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkflowImprovementLoopSummary = z.infer<typeof WorkflowImprovementLoopSummarySchema>;
+export type WorkflowImprovementContext = z.infer<typeof WorkflowImprovementContextSchema>;
+export declare const PreservedShellTypeSchema: z.ZodEnum<{
+    "stage-execution": "stage-execution";
+    "workflow-improvement": "workflow-improvement";
+}>;
+export declare const PreservedShellSnapshotSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-preserved-shell">;
+    version: z.ZodLiteral<1>;
+    shell_type: z.ZodEnum<{
+        "stage-execution": "stage-execution";
+        "workflow-improvement": "workflow-improvement";
+    }>;
+    generated_at: z.ZodString;
+    root_path: z.ZodString;
+    materialized_symlinks: z.ZodNumber;
+}, z.core.$strip>;
+export declare const WorkflowPackageValidationSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    summary: z.ZodString;
+    errors: z.ZodArray<z.ZodString>;
+    counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export declare const WorkflowImprovementLoopRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-workflow-improvement-loop-record">;
+    version: z.ZodLiteral<1>;
+    recorded_at: z.ZodString;
+    run_id: z.ZodString;
+    loop_index: z.ZodNumber;
+    target_name: z.ZodString;
+    workflow_id: z.ZodString;
+    result: z.ZodEnum<{
+        updated: "updated";
+        "no-change": "no-change";
+        invalid: "invalid";
+        "executor-failed": "executor-failed";
+    }>;
+    changed: z.ZodBoolean;
+    applied: z.ZodBoolean;
+    summary: z.ZodString;
+    shell_path: z.ZodString;
+    loop_root_path: z.ZodString;
+    context_path: z.ZodString;
+    workflow_before_path: z.ZodString;
+    workflow_after_path: z.ZodString;
+    prompt_log_path: z.ZodString;
+    event_log_path: z.ZodString;
+    status_log_path: z.ZodString;
+    preserved_shell_manifest_path: z.ZodNullable<z.ZodString>;
+    validation: z.ZodNullable<z.ZodObject<{
+        ok: z.ZodBoolean;
+        summary: z.ZodString;
+        errors: z.ZodArray<z.ZodString>;
+        counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const WorkflowImprovementRunLedgerSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-workflow-improvement-run">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    updated_at: z.ZodString;
+    run_id: z.ZodString;
+    target_name: z.ZodString;
+    workflow_id: z.ZodString;
+    max_loops: z.ZodNumber;
+    max_attempts: z.ZodNumber;
+    loops: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"interf-workflow-improvement-loop-record">;
+        version: z.ZodLiteral<1>;
+        recorded_at: z.ZodString;
+        run_id: z.ZodString;
+        loop_index: z.ZodNumber;
+        target_name: z.ZodString;
+        workflow_id: z.ZodString;
+        result: z.ZodEnum<{
+            updated: "updated";
+            "no-change": "no-change";
+            invalid: "invalid";
+            "executor-failed": "executor-failed";
+        }>;
+        changed: z.ZodBoolean;
+        applied: z.ZodBoolean;
+        summary: z.ZodString;
+        shell_path: z.ZodString;
+        loop_root_path: z.ZodString;
+        context_path: z.ZodString;
+        workflow_before_path: z.ZodString;
+        workflow_after_path: z.ZodString;
+        prompt_log_path: z.ZodString;
+        event_log_path: z.ZodString;
+        status_log_path: z.ZodString;
+        preserved_shell_manifest_path: z.ZodNullable<z.ZodString>;
+        validation: z.ZodNullable<z.ZodObject<{
+            ok: z.ZodBoolean;
+            summary: z.ZodString;
+            errors: z.ZodArray<z.ZodString>;
+            counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PreservedShellType = z.infer<typeof PreservedShellTypeSchema>;
+export type PreservedShellSnapshot = z.infer<typeof PreservedShellSnapshotSchema>;
+export type WorkflowPackageValidation = z.infer<typeof WorkflowPackageValidationSchema>;
+export type WorkflowImprovementLoopRecord = z.infer<typeof WorkflowImprovementLoopRecordSchema>;
+export type WorkflowImprovementRunLedger = z.infer<typeof WorkflowImprovementRunLedgerSchema>;
 export declare const SourceFolderConfigSchema: z.ZodObject<{
     workspaces: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
@@ -498,6 +720,7 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         about: z.ZodOptional<z.ZodString>;
         workflow: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
+        max_loops: z.ZodOptional<z.ZodNumber>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             question: z.ZodString;
@@ -513,12 +736,12 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>>>>;
 }, z.core.$strict>;
-export declare const BenchmarkCheckResultSchema: z.ZodObject<{
+export declare const TestCheckResultSchema: z.ZodObject<{
     label: z.ZodString;
     ok: z.ZodBoolean;
     detail: z.ZodString;
 }, z.core.$strip>;
-export declare const BenchmarkCaseResultSchema: z.ZodObject<{
+export declare const TestCaseResultSchema: z.ZodObject<{
     caseId: z.ZodString;
     question: z.ZodString;
     file: z.ZodOptional<z.ZodString>;
@@ -534,11 +757,11 @@ export declare const BenchmarkCaseResultSchema: z.ZodObject<{
     answer: z.ZodOptional<z.ZodString>;
     trace: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
-export declare const BenchmarkTargetResultSchema: z.ZodObject<{
+export declare const TestTargetResultSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
-            workspace: "workspace";
             raw: "raw";
+            workspace: "workspace";
         }>;
         name: z.ZodString;
         path: z.ZodString;
@@ -567,16 +790,16 @@ export declare const BenchmarkTargetResultSchema: z.ZodObject<{
         trace: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const BenchmarkRunResultSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-benchmark-run">;
+export declare const TestTargetRunSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-test-target-run">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
-    benchmark: z.ZodObject<{
+    spec: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         type: z.ZodEnum<{
-            workspace: "workspace";
             raw: "raw";
+            workspace: "workspace";
         }>;
         file: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
@@ -615,8 +838,8 @@ export declare const BenchmarkRunResultSchema: z.ZodObject<{
     results: z.ZodArray<z.ZodObject<{
         target: z.ZodObject<{
             type: z.ZodEnum<{
-                workspace: "workspace";
                 raw: "raw";
+                workspace: "workspace";
             }>;
             name: z.ZodString;
             path: z.ZodString;
@@ -646,6 +869,85 @@ export declare const BenchmarkRunResultSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+export declare const TestRunModeSchema: z.ZodEnum<{
+    raw: "raw";
+    workspace: "workspace";
+    both: "both";
+}>;
+export declare const TestRunTargetSummarySchema: z.ZodObject<{
+    label: z.ZodString;
+    run_path: z.ZodString;
+    ok: z.ZodBoolean;
+    passed_cases: z.ZodNumber;
+    total_cases: z.ZodNumber;
+    passed_checks: z.ZodNumber;
+    total_checks: z.ZodNumber;
+    target: z.ZodObject<{
+        type: z.ZodEnum<{
+            raw: "raw";
+            workspace: "workspace";
+        }>;
+        name: z.ZodString;
+        path: z.ZodString;
+        workflow: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TestRunComparisonSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-test-run">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    mode: z.ZodEnum<{
+        raw: "raw";
+        workspace: "workspace";
+        both: "both";
+    }>;
+    source_path: z.ZodString;
+    workspace: z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>;
+    raw: z.ZodNullable<z.ZodObject<{
+        label: z.ZodString;
+        run_path: z.ZodString;
+        ok: z.ZodBoolean;
+        passed_cases: z.ZodNumber;
+        total_cases: z.ZodNumber;
+        passed_checks: z.ZodNumber;
+        total_checks: z.ZodNumber;
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                raw: "raw";
+                workspace: "workspace";
+            }>;
+            name: z.ZodString;
+            path: z.ZodString;
+            workflow: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    compiled_workspace: z.ZodNullable<z.ZodObject<{
+        label: z.ZodString;
+        run_path: z.ZodString;
+        ok: z.ZodBoolean;
+        passed_cases: z.ZodNumber;
+        total_cases: z.ZodNumber;
+        passed_checks: z.ZodNumber;
+        total_checks: z.ZodNumber;
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                raw: "raw";
+                workspace: "workspace";
+            }>;
+            name: z.ZodString;
+            path: z.ZodString;
+            workflow: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        raw_pass_rate: z.ZodNullable<z.ZodNumber>;
+        compiled_pass_rate: z.ZodNullable<z.ZodNumber>;
+        pass_rate_delta: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const InterfUserConfigSchema: z.ZodObject<{
     agent: z.ZodString;
     agentCommand: z.ZodString;
@@ -665,12 +967,13 @@ export type WorkspaceViewSpec = z.infer<typeof WorkspaceViewSpecSchema>;
 export type WorkspaceRawSnapshot = z.infer<typeof WorkspaceRawSnapshotSchema>;
 export type WorkflowWorkspaceZone = z.infer<typeof WorkflowWorkspaceZoneSchema>;
 export type WorkflowWorkspaceSchema = z.infer<typeof WorkflowWorkspaceSchemaSchema>;
+export type WorkflowWorkspaceZoneKind = z.infer<typeof WorkflowWorkspaceZoneKindSchema>;
 export type WorkflowZoneId = z.infer<typeof WorkflowZoneIdSchema>;
 export type ExecutionShellZoneMount = z.infer<typeof ExecutionShellZoneMountSchema>;
 export type ExecutionShellPaths = z.infer<typeof ExecutionShellPathsSchema>;
 export type RuntimeExecutorInfo = z.infer<typeof RuntimeExecutorInfoSchema>;
 export type RuntimeTargetType = z.infer<typeof RuntimeTargetTypeSchema>;
-export type BenchmarkTargetType = z.infer<typeof BenchmarkTargetTypeSchema>;
+export type TestTargetType = z.infer<typeof TestTargetTypeSchema>;
 export type RuntimeStage = z.infer<typeof RuntimeStageSchema>;
 export type RuntimeContractType = z.infer<typeof RuntimeContractTypeSchema>;
 export type WorkflowId = z.infer<typeof WorkflowIdSchema>;
@@ -681,15 +984,17 @@ export type RuntimeStageAcceptance = z.infer<typeof RuntimeStageAcceptanceSchema
 export type RuntimeStageContract = z.infer<typeof RuntimeStageContractSchema>;
 export type RuntimeRun = z.infer<typeof RuntimeRunSchema>;
 export type WorkspaceInventory = z.infer<typeof WorkspaceInventorySchema>;
-export type BenchmarkCaseExpect = z.infer<typeof BenchmarkCaseExpectSchema>;
-export type BenchmarkCase = z.infer<typeof BenchmarkCaseSchema>;
-export type BenchmarkSpec = z.infer<typeof BenchmarkSpecSchema>;
-export type SourceEvalCase = z.infer<typeof SourceEvalCaseSchema>;
+export type TestCaseExpect = z.infer<typeof TestCaseExpectSchema>;
+export type TestCase = z.infer<typeof TestCaseSchema>;
+export type TestSpec = z.infer<typeof TestSpecSchema>;
+export type SourceTruthCheck = z.infer<typeof SourceTruthCheckSchema>;
 export type SourceWorkspaceConfig = z.infer<typeof SourceWorkspaceConfigSchema>;
 export type SourceFolderConfig = z.infer<typeof SourceFolderConfigSchema>;
-export type BenchmarkCheckResult = z.infer<typeof BenchmarkCheckResultSchema>;
-export type BenchmarkCaseResult = z.infer<typeof BenchmarkCaseResultSchema>;
-export type BenchmarkTargetResult = z.infer<typeof BenchmarkTargetResultSchema>;
-export type BenchmarkRunResult = z.infer<typeof BenchmarkRunResultSchema>;
+export type TestCheckResult = z.infer<typeof TestCheckResultSchema>;
+export type TestCaseResult = z.infer<typeof TestCaseResultSchema>;
+export type TestTargetResult = z.infer<typeof TestTargetResultSchema>;
+export type TestTargetRun = z.infer<typeof TestTargetRunSchema>;
+export type TestRunMode = z.infer<typeof TestRunModeSchema>;
+export type TestRunTargetSummary = z.infer<typeof TestRunTargetSummarySchema>;
+export type TestRunComparison = z.infer<typeof TestRunComparisonSchema>;
 export type InterfUserConfig = z.infer<typeof InterfUserConfigSchema>;
-//# sourceMappingURL=schema.d.ts.map