@interf/compiler 0.3.4 → 0.4.1

package/dist/commands/test-flow.js

@@ -1,20 +1,47 @@
 import chalk from "chalk";
-import { createRawBenchmarkTarget, listBenchmarkTargets, runBenchmarkAuto, saveBenchmarkRun, } from "../lib/benchmark.js";
-import { buildBenchmarkSpecFromSourceFolderConfig } from "../lib/source-config.js";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createRawTestTarget, createWorkspaceTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "../lib/test.js";
+import { resolveWorkspaceRawPath, syncWorkspaceRawSnapshot } from "../lib/interf.js";
+import { buildTestSpecFromWorkspaceConfig } from "../lib/source-config.js";
+import { testRootForWorkspace, testRunsRootForWorkspace, } from "../lib/workspace-paths.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { findBuiltWorkspacePath } from "./workspace-flow.js";
+import { ensureWorkspaceFromConfig, findBuiltWorkspacePath } from "./workspace-flow.js";
 export function questionPassRate(outcome) {
     return outcome.result.totalCases > 0
         ? Math.round((outcome.result.passedCases / outcome.result.totalCases) * 100)
         : 0;
 }
+function summarizeSavedTestOutcome(label, outcome) {
+    return {
+        label,
+        run_path: outcome.runPath,
+        ok: outcome.result.ok,
+        passed_cases: outcome.result.passedCases,
+        total_cases: outcome.result.totalCases,
+        passed_checks: outcome.result.passedChecks,
+        total_checks: outcome.result.totalChecks,
+        target: outcome.target,
+    };
+}
+function normalizeTestRunId(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
 function specNeedsExecutor(spec) {
     return spec.cases.some((entry) => !entry.file || Boolean(entry.answer));
 }
-async function resolveExecutorForSpec(spec, executionProfile) {
+async function resolveExecutorForSpec(spec, executor, executionProfile) {
     if (!specNeedsExecutor(spec)) {
         return { executor: null, error: undefined };
     }
+    if (executor) {
+        return { executor, error: undefined };
+    }
     return resolveOrConfigureLocalExecutor({
         preflight: true,
         executionProfile,
@@ -44,7 +71,7 @@ export function printSavedTestOutcome(prefix, outcome) {
     }
     console.log(chalk.dim(`  Saved run: ${outcome.runPath}`));
 }
-export function printSavedTestComparison(rawOutcome, workspaceOutcome) {
+export function printSavedTestComparison(rawOutcome, workspaceOutcome, comparisonRunPath) {
     if (!rawOutcome && !workspaceOutcome)
         return;
     console.log();
@@ -65,17 +92,52 @@ export function printSavedTestComparison(rawOutcome, workspaceOutcome) {
         console.log();
         console.log(color(`  Truth-check pass rate ${direction} from ${rawQuestions}% to ${workspaceQuestions}%.`));
     }
+    if (comparisonRunPath) {
+        console.log();
+        console.log(chalk.dim(`  Saved comparison: ${comparisonRunPath}`));
+    }
+}
+export function saveTestComparisonRun(options) {
+    const generatedAt = new Date().toISOString();
+    const runRoot = join(testRunsRootForWorkspace(options.workspacePath), `${generatedAt.replace(/[:.]/g, "-")}-${normalizeTestRunId(options.workspaceName)}`);
+    mkdirSync(runRoot, { recursive: true });
+    const rawPassRate = options.rawOutcome ? questionPassRate(options.rawOutcome) : null;
+    const workspacePassRate = options.workspaceOutcome ? questionPassRate(options.workspaceOutcome) : null;
+    const payload = {
+        kind: "interf-test-run",
+        version: 1,
+        generated_at: generatedAt,
+        mode: options.mode,
+        source_path: options.sourcePath,
+        workspace: {
+            name: options.workspaceName,
+            path: options.workspacePath,
+        },
+        raw: options.rawOutcome ? summarizeSavedTestOutcome("Raw files", options.rawOutcome) : null,
+        compiled_workspace: options.workspaceOutcome
+            ? summarizeSavedTestOutcome("Compiled workspace", options.workspaceOutcome)
+            : null,
+        summary: {
+            raw_pass_rate: rawPassRate,
+            compiled_pass_rate: workspacePassRate,
+            pass_rate_delta: rawPassRate !== null && workspacePassRate !== null ? workspacePassRate - rawPassRate : null,
+        },
+    };
+    const runPath = join(runRoot, "run.json");
+    writeFileSync(runPath, `${JSON.stringify(payload, null, 2)}\n`);
+    writeFileSync(join(testRootForWorkspace(options.workspacePath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
+    return runPath;
 }
 export async function runSavedRawTest(options) {
-    const spec = buildBenchmarkSpecFromSourceFolderConfig({
-        sourcePath: options.sourcePath,
-        targetName: options.workspaceConfig.name,
+    const workspacePath = options.workspacePath ?? ensureWorkspaceFromConfig(options.sourcePath, options.workspaceConfig);
+    const spec = buildTestSpecFromWorkspaceConfig({
+        workspacePath,
         targetType: "raw",
     });
     if (!spec) {
         return null;
     }
-    const { executor, error } = await resolveExecutorForSpec(spec, options.executionProfile);
+    const { executor, error } = await resolveExecutorForSpec(spec, options.executor, options.executionProfile);
     if (!executor && !error) {
         return null;
     }
@@ -84,38 +146,42 @@ export async function runSavedRawTest(options) {
         console.log(chalk.red(error));
         return null;
     }
-    const target = createRawBenchmarkTarget(options.sourcePath);
-    const run = await runBenchmarkAuto(options.sourcePath, spec, [target], {
+    syncWorkspaceRawSnapshot(workspacePath, options.sourcePath);
+    const target = createRawTestTarget(resolveWorkspaceRawPath(workspacePath));
+    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
         executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
+        artifactRootPath: workspacePath,
     });
     const result = run.results[0];
     if (!result)
         return null;
     return {
-        runPath: saveBenchmarkRun(options.sourcePath, run),
+        runPath: saveTargetTestRun(workspacePath, run),
         target,
         result,
     };
 }
 export async function runSavedWorkspaceTest(options) {
-    const spec = buildBenchmarkSpecFromSourceFolderConfig({
-        sourcePath: options.sourcePath,
-        targetName: options.workspaceConfig.name,
+    const workspacePath = options.workspacePath ?? findBuiltWorkspacePath(options.sourcePath, options.workspaceConfig.name);
+    if (!workspacePath) {
+        return null;
+    }
+    const spec = buildTestSpecFromWorkspaceConfig({
+        workspacePath,
         targetType: "workspace",
     });
     if (!spec) {
         return null;
     }
-    const workspacePath = options.workspacePath ?? findBuiltWorkspacePath(options.sourcePath, options.workspaceConfig.name);
-    if (!workspacePath) {
+    const target = createWorkspaceTestTarget(workspacePath, options.workspaceConfig.name, options.workspaceConfig.workflow ?? "interf");
+    if (!target) {
         return null;
     }
-    const target = listBenchmarkTargets(options.sourcePath).find((entry) => entry.path === workspacePath && entry.eligible);
-    if (!target) {
+    if (!target.eligible) {
         return null;
     }
-    const { executor, error } = await resolveExecutorForSpec(spec, options.executionProfile);
+    const { executor, error } = await resolveExecutorForSpec(spec, options.executor, options.executionProfile);
     if (!executor && !error) {
         return null;
     }
@@ -124,17 +190,17 @@ export async function runSavedWorkspaceTest(options) {
         console.log(chalk.red(error));
         return null;
     }
-    const run = await runBenchmarkAuto(options.sourcePath, spec, [target], {
+    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
         executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
+        artifactRootPath: workspacePath,
     });
     const result = run.results[0];
     if (!result)
         return null;
     return {
-        runPath: saveBenchmarkRun(options.sourcePath, run),
+        runPath: saveTargetTestRun(workspacePath, run),
         target,
         result,
     };
 }
-//# sourceMappingURL=test-flow.js.map

package/dist/commands/test.d.ts

@@ -1,4 +1,3 @@
 import type { CommandModule } from "yargs";
 export declare const testCommand: CommandModule;
 export declare function runTestCommand(argv?: Record<string, unknown>): Promise<void>;
-//# sourceMappingURL=test.d.ts.map

package/dist/commands/test.js

@@ -1,18 +1,21 @@
 import chalk from "chalk";
-import * as p from "@clack/prompts";
 import { detectInterf, resolveSourceControlPath, } from "../lib/interf.js";
-import { loadSourceFolderConfig } from "../lib/source-config.js";
+import { sourceWorkspaceConfigFromInterfConfig, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { chooseWorkspaceConfigToBuild, findBuiltWorkspacePath, findSavedWorkspaceConfig, } from "./workspace-flow.js";
-import { printSavedTestComparison, runSavedRawTest, runSavedWorkspaceTest, } from "./test-flow.js";
+import { chooseWorkspaceConfigToBuild, ensureWorkspaceFromConfig, findBuiltWorkspacePath, findSavedWorkspaceConfig, } from "./workspace-flow.js";
+import { printSavedTestComparison, runSavedRawTest, runSavedWorkspaceTest, saveTestComparisonRun, } from "./test-flow.js";
 export const testCommand = {
     command: "test",
-    aliases: ["benchmark"],
-    describe: "Run saved truth checks on raw data or a workspace",
-    builder: (yargs) => addExecutionProfileOptions(yargs).option("keep-sandboxes", {
+    describe: "Compare raw files and a compiled workspace on saved truth checks",
+    builder: (yargs) => addExecutionProfileOptions(yargs)
+        .option("target", {
+        choices: ["both", "raw", "workspace"],
+        describe: "Test raw files, the compiled workspace, or both. Default: both when a compiled workspace exists, otherwise raw.",
+    })
+        .option("keep-sandboxes", {
         type: "boolean",
         default: false,
-        describe: "Keep every raw or workspace test sandbox under interf/benchmarks/sandboxes for review instead of pruning successful runs",
+        describe: "Keep every raw or workspace test sandbox under .interf/tests/targets/sandboxes for review instead of pruning successful runs",
     }),
     handler: async (argv) => {
         await runTestCommand(argv);
@@ -22,64 +25,16 @@ function readSandboxRetentionMode(argv) {
     const enabled = argv["keep-sandboxes"] ?? argv.keepSandboxes ?? false;
     return enabled ? "always" : "on-failure";
 }
-async function chooseTestMode(options) {
-    if (!options.hasBuiltWorkspace) {
-        const selected = await p.select({
-            message: `Test "${options.workspaceName}" against what?`,
-            options: [
-                {
-                    value: "raw",
-                    label: "Raw files",
-                    hint: "Run a baseline test on the raw files only",
-                },
-                {
-                    value: "workspace",
-                    label: "Compiled workspace",
-                    hint: "Build it first with `interf compile`",
-                },
-            ],
-        });
-        if (p.isCancel(selected))
-            return null;
-        return selected;
-    }
-    const selected = await p.select({
-        message: `Test "${options.workspaceName}" against what?`,
-        options: [
-            {
-                value: "both",
-                label: "Raw files and compiled workspace (Recommended)",
-                hint: "Run the same questions against both and compare",
-            },
-            {
-                value: "raw",
-                label: "Raw files",
-                hint: "Run the baseline only",
-            },
-            {
-                value: "workspace",
-                label: "Compiled workspace",
-                hint: "Run the saved test against the workspace only",
-            },
-        ],
-    });
-    if (p.isCancel(selected))
-        return null;
-    return selected;
+function readRequestedMode(argv) {
+    const value = argv.target;
+    return value === "raw" || value === "workspace" || value === "both" ? value : null;
 }
 export async function runTestCommand(argv = {}) {
     const cwd = process.cwd();
     const detected = detectInterf(cwd);
     const sourcePath = detected ? resolveSourceControlPath(detected.path) : cwd;
-    const config = loadSourceFolderConfig(sourcePath);
-    if (!config) {
-        process.exitCode = 1;
-        console.log(chalk.red("  This folder does not have any saved workspace setup yet."));
-        console.log(chalk.dim("  Start with `interf` or `interf init`."));
-        return;
-    }
     const selectedWorkspace = detected
-        ? (findSavedWorkspaceConfig(sourcePath, detected.config.name) ?? null)
+        ? (findSavedWorkspaceConfig(sourcePath, detected.config.name) ?? sourceWorkspaceConfigFromInterfConfig(detected.config))
         : await chooseWorkspaceConfigToBuild({
             sourcePath,
             selectMessage: "Which workspace do you want to test?",
@@ -102,24 +57,26 @@ export async function runTestCommand(argv = {}) {
     const preserveSandboxes = readSandboxRetentionMode(argv);
     const builtWorkspacePath = detected?.path ?? findBuiltWorkspacePath(sourcePath, selectedWorkspace.name);
     const hasBuiltWorkspace = Boolean(builtWorkspacePath);
-    const mode = detected
-        ? "workspace"
-        : await chooseTestMode({
-            workspaceName: selectedWorkspace.name,
-            hasBuiltWorkspace,
-        });
-    if (!mode)
-        return;
-    if (mode === "workspace" && !hasBuiltWorkspace) {
+    const requestedMode = readRequestedMode(argv);
+    const selectedMode = requestedMode ?? (hasBuiltWorkspace ? "both" : "raw");
+    if (selectedMode === "workspace" && !hasBuiltWorkspace) {
         process.exitCode = 1;
         console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" is not compiled yet.`));
         console.log(chalk.dim("  Run `interf compile` first."));
         return;
     }
+    if (selectedMode === "both" && !hasBuiltWorkspace) {
+        console.log(chalk.dim(`  Workspace "${selectedWorkspace.name}" is not compiled yet. Running the raw files only.`));
+    }
+    const mode = selectedMode === "both" && !hasBuiltWorkspace
+        ? "raw"
+        : selectedMode;
+    const artifactWorkspacePath = builtWorkspacePath ?? ensureWorkspaceFromConfig(sourcePath, selectedWorkspace);
     const rawOutcome = mode === "raw" || mode === "both"
         ? await runSavedRawTest({
             sourcePath,
             workspaceConfig: selectedWorkspace,
+            workspacePath: artifactWorkspacePath,
             executionProfile,
             preserveSandboxes,
         })
@@ -129,7 +86,7 @@ export async function runTestCommand(argv = {}) {
             sourcePath,
             workspaceConfig: selectedWorkspace,
             executionProfile,
-            workspacePath: builtWorkspacePath,
+            workspacePath: artifactWorkspacePath,
             preserveSandboxes,
         })
         : null;
@@ -139,6 +96,13 @@ export async function runTestCommand(argv = {}) {
         console.log(chalk.dim("  Run `interf compile` first."));
         return;
     }
-    printSavedTestComparison(rawOutcome, workspaceOutcome);
+    const comparisonRunPath = saveTestComparisonRun({
+        sourcePath,
+        workspacePath: artifactWorkspacePath,
+        workspaceName: selectedWorkspace.name,
+        mode,
+        rawOutcome,
+        workspaceOutcome,
+    });
+    printSavedTestComparison(rawOutcome, workspaceOutcome, comparisonRunPath);
 }
-//# sourceMappingURL=test.js.map

package/dist/commands/verify.d.ts

@@ -1,3 +1,2 @@
 import type { CommandModule } from "yargs";
 export declare const verifyCommand: CommandModule;
-//# sourceMappingURL=verify.d.ts.map

package/dist/commands/verify.js

@@ -83,4 +83,3 @@ export const verifyCommand = {
         }
     },
 };
-//# sourceMappingURL=verify.js.map

package/dist/commands/workspace-flow.d.ts

@@ -5,6 +5,7 @@ import type { WorkspaceCompileResult } from "../lib/workflows.js";
 export interface SavedWorkspaceEntry {
     config: SourceWorkspaceConfig;
     path: string | null;
+    localDraft: boolean;
 }
 export declare function listSavedWorkspaceEntries(sourcePath: string): SavedWorkspaceEntry[];
 export declare function findBuiltWorkspacePath(sourcePath: string, workspaceName: string): string | null;
@@ -13,11 +14,10 @@ export declare function chooseWorkspaceConfigToBuild(options: {
     sourcePath: string;
     selectMessage: string;
 }): Promise<SourceWorkspaceConfig | null | undefined>;
-export declare function createWorkspaceFromConfig(sourcePath: string, workspaceConfig: Pick<SourceWorkspaceConfig, "name" | "about" | "workflow">): string;
-export declare function ensureWorkspaceFromConfig(sourcePath: string, workspaceConfig: Pick<SourceWorkspaceConfig, "name" | "about" | "workflow">): string;
+export declare function createWorkspaceFromConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig): string;
+export declare function ensureWorkspaceFromConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig): string;
 export declare function compileWorkspaceWithReporter(executor: WorkflowExecutor, workspacePath: string, options?: {
     heading?: string;
     successMessage?: string;
     preserveStageShells?: StageShellRetentionMode;
 }): Promise<WorkspaceCompileResult>;
-//# sourceMappingURL=workspace-flow.d.ts.map

package/dist/commands/workspace-flow.js

@@ -2,29 +2,46 @@ import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { listWorkspacesForSourceFolder } from "../lib/interf.js";
 import { addWorkspace } from "../lib/registry.js";
-import { findSourceWorkspaceConfig, listSourceWorkspaceConfigs, loadSourceFolderConfig, } from "../lib/source-config.js";
+import { listSourceWorkspaceConfigs, loadWorkspaceControlConfig, loadSourceFolderConfig, sourceWorkspaceConfigFromInterfConfig, syncWorkspaceInterfConfigFromSourceWorkspaceConfig, } from "../lib/source-config.js";
 import { compileWorkspace, createWorkspace, } from "../lib/workflows.js";
 import { formatWorkflowExecutionProfile } from "../lib/execution-profile.js";
-function formatSavedWorkspaceHint(config) {
+function formatSavedWorkspaceHint(entry) {
+    const config = entry.config;
     const checkCount = config.checks.length;
+    const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
     if (config.about)
-        return config.about;
+        return `${config.about} · ${workflowHint}`;
     if (checkCount === 0)
         return "No saved truth checks yet";
-    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"}`;
+    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
 }
 export function listSavedWorkspaceEntries(sourcePath) {
-    const builtByName = new Map(listWorkspacesForSourceFolder(sourcePath).map((entry) => [entry.config.name, entry.path]));
-    return listSourceWorkspaceConfigs(loadSourceFolderConfig(sourcePath)).map((config) => ({
-        config,
-        path: builtByName.get(config.name) ?? null,
-    }));
+    const entries = new Map();
+    for (const builtWorkspace of listWorkspacesForSourceFolder(sourcePath)) {
+        const workspaceConfig = loadWorkspaceControlConfig(builtWorkspace.path)
+            ?? sourceWorkspaceConfigFromInterfConfig(builtWorkspace.config);
+        entries.set(builtWorkspace.config.name, {
+            config: workspaceConfig,
+            path: builtWorkspace.path,
+            localDraft: builtWorkspace.config.workflow_origin?.local_draft === true,
+        });
+    }
+    for (const config of listSourceWorkspaceConfigs(loadSourceFolderConfig(sourcePath))) {
+        if (entries.has(config.name))
+            continue;
+        entries.set(config.name, {
+            config,
+            path: null,
+            localDraft: false,
+        });
+    }
+    return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
 export function findBuiltWorkspacePath(sourcePath, workspaceName) {
     return listSavedWorkspaceEntries(sourcePath).find((entry) => entry.config.name === workspaceName)?.path ?? null;
 }
 export function findSavedWorkspaceConfig(sourcePath, workspaceName) {
-    return findSourceWorkspaceConfig(loadSourceFolderConfig(sourcePath), workspaceName);
+    return listSavedWorkspaceEntries(sourcePath).find((entry) => entry.config.name === workspaceName)?.config ?? null;
 }
 export async function chooseWorkspaceConfigToBuild(options) {
     const savedEntries = listSavedWorkspaceEntries(options.sourcePath);
@@ -40,7 +57,7 @@ export async function chooseWorkspaceConfigToBuild(options) {
             value: entry.config.name,
             label: entry.config.name,
             hint: [
-                formatSavedWorkspaceHint(entry.config),
+                formatSavedWorkspaceHint(entry),
                 entry.path ? "built" : "not built yet",
             ].join(" · "),
         })),
@@ -52,12 +69,14 @@ export async function chooseWorkspaceConfigToBuild(options) {
 export function createWorkspaceFromConfig(sourcePath, workspaceConfig) {
     const workflowId = workspaceConfig.workflow ?? "interf";
     const workspacePath = createWorkspace(workspaceConfig.name, sourcePath, workflowId, workspaceConfig.about);
+    syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath, workspaceConfig);
     addWorkspace(workspaceConfig.name, workspacePath, workflowId);
     return workspacePath;
 }
 export function ensureWorkspaceFromConfig(sourcePath, workspaceConfig) {
     const existingPath = findBuiltWorkspacePath(sourcePath, workspaceConfig.name);
     if (existingPath) {
+        syncWorkspaceInterfConfigFromSourceWorkspaceConfig(existingPath, workspaceConfig);
         addWorkspace(workspaceConfig.name, existingPath, workspaceConfig.workflow ?? "interf");
         return existingPath;
     }
@@ -88,4 +107,3 @@ export async function compileWorkspaceWithReporter(executor, workspacePath, opti
     console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled workspace ready."}`));
     return result;
 }
-//# sourceMappingURL=workspace-flow.js.map

package/dist/index.d.ts

@@ -1,12 +1,11 @@
 export { createWorkspace, compileWorkspace, runWorkspaceSummarize, runWorkspaceCompile, } from "./lib/workflows.js";
-export { createRawBenchmarkTarget, listBenchmarkSpecs, loadBenchmarkSpec, loadBenchmarkSpecFromFile, writeBenchmarkSpec, listBenchmarkTargets, runBenchmark, runBenchmarkWithJudge, runBenchmarkAuto, saveBenchmarkRun, } from "./lib/benchmark.js";
+export { createRawTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
 export { computeWorkspaceHealth, } from "./lib/state.js";
-export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildBenchmarkSpecFromSourceFolderConfig, } from "./lib/source-config.js";
+export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildTestSpecFromSourceFolderConfig, } from "./lib/source-config.js";
 export { validateWorkspaceSummarize, validateWorkspaceCompile, } from "./lib/validate.js";
-export { InterfConfigSchema, BenchmarkSpecSchema, SourceFolderConfigSchema, WorkspaceHealthSchema, } from "./lib/schema.js";
+export { InterfConfigSchema, TestSpecSchema, SourceFolderConfigSchema, WorkspaceHealthSchema, } from "./lib/schema.js";
 export type { InterfConfig } from "./lib/interf.js";
-export type { BenchmarkCaseExpect, BenchmarkCase, BenchmarkSpec, BenchmarkCheckResult, BenchmarkCaseResult, BenchmarkTargetResult, BenchmarkRunResult, LoadedBenchmarkSpec, BenchmarkTargetCandidate, } from "./lib/benchmark.js";
-export type { SourceEvalCase, SourceWorkspaceConfig, SourceFolderConfig, WorkspaceHealth, } from "./lib/schema.js";
+export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, LoadedTestSpec, TestTargetCandidate, } from "./lib/test.js";
+export type { SourceTruthCheck, SourceWorkspaceConfig, SourceFolderConfig, WorkspaceHealth, } from "./lib/schema.js";
 export type { WorkspaceSummarizeValidation, WorkspaceCompileValidation, } from "./lib/validate.js";
 export type { WorkspaceSummarizeResult, WorkspaceCompileResult, } from "./lib/workflows.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,6 @@
 export { createWorkspace, compileWorkspace, runWorkspaceSummarize, runWorkspaceCompile, } from "./lib/workflows.js";
-export { createRawBenchmarkTarget, listBenchmarkSpecs, loadBenchmarkSpec, loadBenchmarkSpecFromFile, writeBenchmarkSpec, listBenchmarkTargets, runBenchmark, runBenchmarkWithJudge, runBenchmarkAuto, saveBenchmarkRun, } from "./lib/benchmark.js";
+export { createRawTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
 export { computeWorkspaceHealth, } from "./lib/state.js";
-export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildBenchmarkSpecFromSourceFolderConfig, } from "./lib/source-config.js";
+export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildTestSpecFromSourceFolderConfig, } from "./lib/source-config.js";
 export { validateWorkspaceSummarize, validateWorkspaceCompile, } from "./lib/validate.js";
-export { InterfConfigSchema, BenchmarkSpecSchema, SourceFolderConfigSchema, WorkspaceHealthSchema, } from "./lib/schema.js";
-//# sourceMappingURL=index.js.map
+export { InterfConfigSchema, TestSpecSchema, SourceFolderConfigSchema, WorkspaceHealthSchema, } from "./lib/schema.js";

package/dist/lib/agent-args.d.ts

@@ -1,4 +1,3 @@
 import type { WorkflowExecutionProfile } from "./executors.js";
 import type { Agent } from "./agent-types.js";
 export declare function buildAgentArgs(agent: Agent, prompt: string, executionProfile?: WorkflowExecutionProfile): string[];
-//# sourceMappingURL=agent-args.d.ts.map

package/dist/lib/agent-args.js

@@ -39,4 +39,3 @@ export function buildAgentArgs(agent, prompt, executionProfile = {}) {
     }
     throw new Error(`Agent "${agent.displayName}" is not yet supported for automated compile runs.`);
 }
-//# sourceMappingURL=agent-args.js.map

package/dist/lib/agent-constants.d.ts

@@ -3,4 +3,3 @@ export declare const SHOW_AGENT_TOOL_EVENTS: boolean;
 export declare const AGENTS: Agent[];
 export declare const CODEX_NOISE_PATTERNS: RegExp[];
 export declare const VISIBLE_STATUS_PREFIXES: string[];
-//# sourceMappingURL=agent-constants.d.ts.map

package/dist/lib/agent-constants.js

@@ -26,4 +26,3 @@ export const CODEX_NOISE_PATTERNS = [
     /codex_core::codex: failed to load skill .*\/gstack\/SKILL\.md: invalid description: exceeds maximum length of 1024 characters/,
 ];
 export const VISIBLE_STATUS_PREFIXES = ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"];
-//# sourceMappingURL=agent-constants.js.map

package/dist/lib/agent-detection.d.ts

@@ -5,4 +5,3 @@ export declare function resolveAgent(): {
     agent: Agent | null;
     error?: string;
 };
-//# sourceMappingURL=agent-detection.d.ts.map

package/dist/lib/agent-detection.js

@@ -63,4 +63,3 @@ export function resolveAgent() {
     }
     return { agent: detected[0] };
 }
-//# sourceMappingURL=agent-detection.js.map

package/dist/lib/agent-execution.d.ts

@@ -1,3 +1,2 @@
 import type { Agent, SpawnAgentOptions } from "./agent-types.js";
 export declare function spawnAgent(agent: Agent, dirPath: string, prompt: string, options?: SpawnAgentOptions): Promise<number>;
-//# sourceMappingURL=agent-execution.d.ts.map