@interf/compiler 0.9.1 → 0.9.4

package/dist/cli/commands/source-config-wizard.js

@@ -4,11 +4,11 @@ import { slugify } from "../../packages/shared/naming.js";
 import { submitReadinessCheckDraftToLocalService, } from "../../packages/local-service/index.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 import { draftReadinessChecks } from "./check-draft.js";
-export const DEFAULT_COMPILED_NAME = "dataset1";
+export const DEFAULT_PREPARATION_NAME = "default";
 export const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "An agent-work-critical check you can already verify from this Source Folder";
 export const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
 export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
-export const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
+export const DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER = "./source-files";
 export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
 const DEFAULT_SELF_IMPROVING_ATTEMPTS = 1;
@@ -18,20 +18,20 @@ function normalizeOptionalPromptText(value) {
     const normalized = value.trim();
     return normalized.length > 0 ? normalized : undefined;
 }
-export function normalizeDatasetPathForConfig(projectPath, value) {
-    return projectSourceFolders.normalizeSourceDatasetPathForConfig(projectPath, value);
+export function normalizeSourceFolderPathForConfig(projectPath, value) {
+    return projectSourceFolders.normalizeSourcePreparationPathForConfig(projectPath, value);
 }
-function defaultDatasetNameForPath(datasetPath) {
-    return projectSourceFolders.defaultDatasetNameForPath(datasetPath);
+function defaultPreparationNameForPath(sourceFolderPath) {
+    return projectSourceFolders.defaultPreparationNameForPath(sourceFolderPath);
 }
-export function listDatasetFolderChoices(cwd = process.cwd()) {
+export function listSourceFolderChoices(cwd = process.cwd()) {
     return projectSourceFolders.listSourceFolderChoices(cwd);
 }
-export function defaultDatasetPathForPrompt(name, introStyle, cwd = process.cwd()) {
-    return projectSourceFolders.defaultSourceDatasetPathForPrompt(name, introStyle, cwd);
+export function defaultSourceFolderPathForPrompt(name, introStyle, cwd = process.cwd()) {
+    return projectSourceFolders.defaultSourcePreparationPathForPrompt(name, introStyle, cwd);
 }
-async function promptDatasetFolderPath(options) {
-    const folderChoices = listDatasetFolderChoices(options.projectPath);
+async function promptSourceFolderPath(options) {
+    const folderChoices = listSourceFolderChoices(options.projectPath);
     if (folderChoices.length > 0) {
         const selected = await p.select({
             message: "Which Source Folder should Interf use?",
@@ -51,7 +51,7 @@ async function promptDatasetFolderPath(options) {
             return null;
         if (selected !== "__manual__") {
             try {
-                return normalizeDatasetPathForConfig(options.projectPath, String(selected));
+                return normalizeSourceFolderPathForConfig(options.projectPath, String(selected));
             }
             catch (error) {
                 p.log.error(error instanceof Error ? error.message : String(error));
@@ -59,16 +59,16 @@ async function promptDatasetFolderPath(options) {
             }
         }
     }
-    const datasetPath = await p.text({
+    const sourceFolderPath = await p.text({
         message: "Which Source Folder should Interf use?",
-        placeholder: DEFAULT_DATASET_PATH_PLACEHOLDER,
+        placeholder: DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER,
         initialValue: options.initialPath,
         validate: (value) => {
             const normalized = value.trim();
             if (normalized.length === 0)
                 return "Source Folder is required";
             try {
-                normalizeDatasetPathForConfig(options.projectPath, normalized);
+                normalizeSourceFolderPathForConfig(options.projectPath, normalized);
                 return undefined;
             }
             catch (error) {
@@ -76,11 +76,11 @@ async function promptDatasetFolderPath(options) {
             }
         },
     });
-    if (p.isCancel(datasetPath))
+    if (p.isCancel(sourceFolderPath))
         return null;
-    return normalizeDatasetPathForConfig(options.projectPath, String(datasetPath));
+    return normalizeSourceFolderPathForConfig(options.projectPath, String(sourceFolderPath));
 }
-export function datasetAboutPromptMessage(introStyle) {
+export function preparationAboutPromptMessage(introStyle) {
     if (introStyle === "edit") {
         return "What agent work should this Preparation stay focused on?";
     }
@@ -173,12 +173,12 @@ function printDraftReadinessChecks(checks) {
     }
 }
 async function promptDraftReadinessChecks(options) {
-    let resolvedDatasetPath;
+    let resolvedSourceFolderPath;
     try {
-        const datasetConfig = {
-            path: options.datasetPath,
+        const preparationPathConfig = {
+            path: options.sourceFolderPath,
         };
-        resolvedDatasetPath = projectSourceConfig.resolveSourceDatasetPath(options.projectPath, datasetConfig);
+        resolvedSourceFolderPath = projectSourceConfig.resolveSourcePreparationPath(options.projectPath, preparationPathConfig);
     }
     catch (error) {
         p.log.error(error instanceof Error ? error.message : String(error));
@@ -190,8 +190,8 @@ async function promptDraftReadinessChecks(options) {
         const serviceRun = await submitReadinessCheckDraftToLocalService({
             projectPath: options.projectPath,
             request: {
-                preparation: options.datasetName,
-                source_folder_path: resolvedDatasetPath,
+                preparation: options.preparationName,
+                source_folder_path: resolvedSourceFolderPath,
                 about: options.about,
                 target_count: 4,
             },
@@ -247,8 +247,8 @@ async function promptDraftReadinessChecks(options) {
                         : "skip";
                 }
                 return draftReadinessChecks({
-                    datasetName: options.datasetName,
-                    datasetPath: resolvedDatasetPath,
+                    preparationName: options.preparationName,
+                    sourceFolderPath: resolvedSourceFolderPath,
                     about: options.about,
                     executor: resolved.executor,
                     targetCount: 4,
@@ -358,8 +358,8 @@ async function promptCompiledChecks(options) {
         if (mode === "draft") {
             const drafted = await promptDraftReadinessChecks({
                 projectPath: options.projectPath,
-                datasetName: options.datasetName,
-                datasetPath: options.datasetPath,
+                preparationName: options.preparationName,
+                sourceFolderPath: options.sourceFolderPath,
                 about: options.initialAbout,
             });
             if (drafted === null)
@@ -430,8 +430,8 @@ async function promptCompiledChecks(options) {
     if (mode === "redraft") {
         const drafted = await promptDraftReadinessChecks({
             projectPath: options.projectPath,
-            datasetName: options.datasetName,
-            datasetPath: options.datasetPath,
+            preparationName: options.preparationName,
+            sourceFolderPath: options.sourceFolderPath,
             about: options.initialAbout,
         });
         if (drafted === null)
@@ -589,29 +589,29 @@ export async function promptSingleCompiledConfig(options = {}) {
     }
     let about = normalizeOptionalPromptText(initial?.about);
     const projectPath = options.projectPath ?? process.cwd();
-    const defaultNameSeed = slugify(String(initial?.name ?? DEFAULT_COMPILED_NAME)) || DEFAULT_COMPILED_NAME;
-    const defaultDatasetPath = initial?.path ?? defaultDatasetPathForPrompt(defaultNameSeed, introStyle, projectPath);
-    const normalizedDatasetPath = options.fixedPath
+    const defaultNameSeed = slugify(String(initial?.name ?? DEFAULT_PREPARATION_NAME)) || DEFAULT_PREPARATION_NAME;
+    const defaultSourceFolderPath = initial?.path ?? defaultSourceFolderPathForPrompt(defaultNameSeed, introStyle, projectPath);
+    const normalizedSourceFolderPath = options.fixedPath
         ? (() => {
             try {
-                return normalizeDatasetPathForConfig(projectPath, options.fixedPath);
+                return normalizeSourceFolderPathForConfig(projectPath, options.fixedPath);
             }
             catch (error) {
                 p.log.error(error instanceof Error ? error.message : String(error));
                 return null;
             }
         })()
-        : await promptDatasetFolderPath({
+        : await promptSourceFolderPath({
             projectPath,
-            initialPath: defaultDatasetPath,
+            initialPath: defaultSourceFolderPath,
         });
-    if (!normalizedDatasetPath)
+    if (!normalizedSourceFolderPath)
         return null;
     if (options.fixedPath) {
-        p.log.info(`Source Folder: ${normalizedDatasetPath}`);
+        p.log.info(`Source Folder: ${normalizedSourceFolderPath}`);
     }
     if (!name) {
-        const suggestedName = defaultDatasetNameForPath(normalizedDatasetPath);
+        const suggestedName = defaultPreparationNameForPath(normalizedSourceFolderPath);
         const rawName = await p.text({
             message: "Preparation name?",
             placeholder: suggestedName,
@@ -635,7 +635,7 @@ export async function promptSingleCompiledConfig(options = {}) {
     };
     if (!(options.skipAboutPrompt && initial?.about)) {
         const aboutInput = await p.text({
-            message: datasetAboutPromptMessage(introStyle),
+            message: preparationAboutPromptMessage(introStyle),
             placeholder: DEFAULT_COMPILED_ABOUT_PLACEHOLDER,
             initialValue: about ?? "",
         });
@@ -645,8 +645,8 @@ export async function promptSingleCompiledConfig(options = {}) {
     }
     const checks = await promptCompiledChecks({
         projectPath: options.projectPath ?? process.cwd(),
-        datasetName: name,
-        datasetPath: normalizedDatasetPath,
+        preparationName: name,
+        sourceFolderPath: normalizedSourceFolderPath,
         initialAbout: about,
         initialChecks: initial?.checks,
     });
@@ -667,7 +667,7 @@ export async function promptSingleCompiledConfig(options = {}) {
     }
     return {
         name,
-        path: normalizedDatasetPath,
+        path: normalizedSourceFolderPath,
         ...(about ? { about } : {}),
         ...(typeof compileLoopSelection.max_attempts === "number"
             ? { max_attempts: compileLoopSelection.max_attempts }

package/dist/cli/commands/status.js

@@ -1,8 +1,8 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, listCompiledDatasetsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { detectInterf, listPortableContextsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
 import { computeCompiledHealth } from "../../packages/compiler/state.js";
-import { sourceDatasetConfigFromInterfConfig, loadCompiledDatasetConfig, } from "../../packages/project-model/source-config.js";
+import { sourcePreparationConfigFromInterfConfig, loadCompiledPreparationConfig, } from "../../packages/project-model/source-config.js";
 import { printSavedTestComparisonState, readCurrentSavedTestComparison } from "./test-flow.js";
 import { findLocalService, readLocalServiceRunSnapshot, } from "../../packages/local-service/index.js";
 import { resolveCommandControlPath } from "./control-path.js";
@@ -18,6 +18,33 @@ function statusColor(status) {
             return chalk.dim;
     }
 }
+function publicReadinessStatus(status) {
+    return status === "compiled" ? "ready" : "not ready";
+}
+function publicPrepareState(status) {
+    if (status === "compiled")
+        return "prepared";
+    if (status === "idle")
+        return "not prepared";
+    return status;
+}
+function publicHealthSummary(health) {
+    const completedStages = health.metrics.completed_stages;
+    const stageTotal = health.metrics.stage_total;
+    if (typeof completedStages === "number" && typeof stageTotal === "number") {
+        if (health.status === "compiled") {
+            return `Portable Context ready — ${completedStages}/${stageTotal} Method stages satisfied.`;
+        }
+        if (health.status === "stale") {
+            return `Portable Context not ready — ${completedStages}/${stageTotal} Method stages satisfied.`;
+        }
+    }
+    return health.summary
+        .replace(/\bCompiled\b/g, "Prepared")
+        .replace(/\bcompiled\b/g, "prepared")
+        .replace(/\bmethod stages\b/g, "Method stages")
+        .replace(/\bmethod stage\b/g, "Method stage");
+}
 export const statusCommand = {
     command: "status",
     describe: "Show deterministic health for the Portable Context agents use",
@@ -46,7 +73,7 @@ export const statusCommand = {
         }
         else {
             const sourcePath = resolveCommandControlPath();
-            const local = listCompiledDatasetsForSourceFolder(sourcePath).map(({ path, config }) => ({
+            const local = listPortableContextsForSourceFolder(sourcePath).map(({ path, config }) => ({
                 path,
                 name: config.name,
             }));
@@ -73,17 +100,17 @@ export const statusCommand = {
         const color = statusColor(health.status);
         console.log();
         console.log(color(`  ${health.target_name}`));
-        console.log(chalk.dim(`  status: ${health.status}`));
-        console.log(chalk.dim(`  stage: ${health.stage}`));
-        console.log(chalk.dim(`  ${health.summary}`));
+        console.log(chalk.dim(`  readiness: ${publicReadinessStatus(health.status)}`));
+        console.log(chalk.dim(`  prepare state: ${publicPrepareState(health.status)}`));
+        console.log(chalk.dim(`  ${publicHealthSummary(health)}`));
         const compiledConfig = readInterfConfig(compiledPath);
         const sourcePath = resolveSourceControlPath(compiledPath);
         const latestComparisonState = compiledConfig
             ? readCurrentSavedTestComparison({
                 projectPath: sourcePath,
-                datasetName: compiledConfig.name,
-                checks: (loadCompiledDatasetConfig(compiledPath)
-                    ?? sourceDatasetConfigFromInterfConfig(compiledConfig)).checks,
+                preparationName: compiledConfig.name,
+                checks: (loadCompiledPreparationConfig(compiledPath)
+                    ?? sourcePreparationConfigFromInterfConfig(compiledConfig)).checks,
             })
             : { comparison: null, stale: false };
         const latestComparison = latestComparisonState.comparison;

package/dist/cli/commands/test-flow.d.ts

@@ -1,8 +1,8 @@
-import { type TestTargetCandidate, type TestTargetResult } from "../../packages/testing/test.js";
-import type { WorkflowExecutionProfile, WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { TestTargetCandidate, TestTargetResult } from "../../packages/testing/test.js";
+import type { MethodExecutionProfile, MethodExecutor } from "../../packages/agents/lib/executors.js";
 import type { TestSandboxRetentionMode } from "../../packages/testing/test-sandbox.js";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
-import type { TestRunComparison, TestRunMode } from "../../packages/testing/lib/schema.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+import type { ReadinessCheckRun, TestRunMode } from "../../packages/testing/lib/schema.js";
 export interface SavedTestOutcome {
     runPath: string;
     displayRunPath?: string;
@@ -15,16 +15,16 @@ export interface AgentTestMatrixRow {
     compiledOutcome?: SavedTestOutcome | null;
 }
 export declare function readinessPassRate(outcome: SavedTestOutcome): number;
-export declare function readSavedTestComparison(projectPath: string, datasetName: string): TestRunComparison | null;
+export declare function readSavedTestComparison(projectPath: string, preparationName: string): ReadinessCheckRun | null;
 export declare function readCurrentSavedTestComparison(options: {
     projectPath: string;
-    datasetName: string;
-    checks: SourceDatasetConfig["checks"];
+    preparationName: string;
+    checks: SourcePreparationConfig["checks"];
 }): {
-    comparison: TestRunComparison | null;
+    comparison: ReadinessCheckRun | null;
     stale: boolean;
 };
-export declare function printSavedTestComparisonState(payload: TestRunComparison, comparisonRunPath?: string | null): void;
+export declare function printSavedTestComparisonState(payload: ReadinessCheckRun, comparisonRunPath?: string | null): void;
 export declare function printAgentTestMatrix(rows: AgentTestMatrixRow[]): void;
 export declare function printAgentTestFailures(rows: AgentTestMatrixRow[]): void;
 export declare function printSavedTestOutcome(prefix: string, outcome: SavedTestOutcome): void;
@@ -41,17 +41,17 @@ export declare function saveTestComparisonRun(options: {
 }): string;
 export declare function runSavedRawTest(options: {
     sourcePath: string;
-    datasetConfig: SourceDatasetConfig;
-    executor?: WorkflowExecutor | null;
-    executionProfile?: WorkflowExecutionProfile;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    executionProfile?: MethodExecutionProfile;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
 }): Promise<SavedTestOutcome | null>;
 export declare function runSavedCompiledTest(options: {
     sourcePath: string;
-    datasetConfig: SourceDatasetConfig;
-    executor?: WorkflowExecutor | null;
-    executionProfile?: WorkflowExecutionProfile;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    executionProfile?: MethodExecutionProfile;
     compiledPath?: string | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;

package/dist/cli/commands/test-flow.js

@@ -1,87 +1,24 @@
 import chalk from "chalk";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { createRawTestTarget, createCompiledTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "../../packages/testing/test.js";
-import { buildTestSpecFromSourceFolderConfig, buildTestSpecFromCompiledDatasetConfig, fingerprintReadinessChecks, resolveSourceDatasetPath, } from "../../packages/project-model/source-config.js";
-import { ensurePortableContextScaffold, } from "../../packages/project-model/interf.js";
-import { datasetLatestTestStatePath, datasetLatestTestSummaryPath, normalizeDatasetTestRunId, datasetTestRunPath, datasetTestRunsRoot, } from "../../packages/project-model/project-paths.js";
-import { testRootForCompiled } from "../../packages/project-model/compiled-paths.js";
-import { readJsonFileWithSchema } from "../../packages/shared/parse.js";
-import { TestRunComparisonSchema } from "../../packages/testing/lib/schema.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { readinessPassRate as readinessPassRateForOutcome, readCurrentSavedReadinessCheckRun, readSavedReadinessCheckRun, runSavedPortableContextCheck, runSavedSourceFilesCheck, saveReadinessCheckRun, } from "../../packages/testing/readiness-check-run.js";
 import { findBuiltCompiledPath } from "./compiled-flow.js";
 export function readinessPassRate(outcome) {
-    return outcome.result.totalCases > 0
-        ? Math.round((outcome.result.passedCases / outcome.result.totalCases) * 100)
-        : 0;
+    return readinessPassRateForOutcome(outcome);
 }
 function visibleRunPath(outcome) {
     return outcome.displayRunPath ?? outcome.runPath;
 }
-function summarizeSavedTestOutcome(label, outcome) {
-    return {
-        label,
-        run_path: visibleRunPath(outcome),
-        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 loadLatestComparison(projectPath, preparationName) {
+    return readSavedReadinessCheckRun(projectPath, preparationName);
 }
-function writeDatasetTargetRun(options) {
-    const dirPath = datasetTestRunsRoot(options.projectPath, options.datasetName, options.target);
-    mkdirSync(dirPath, { recursive: true });
-    const runPath = datasetTestRunPath(options.projectPath, options.datasetName, options.target, options.generatedAt, options.runId, options.runSuffix);
-    writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
-    return runPath;
-}
-function loadLatestComparison(projectPath, datasetName) {
-    const latestPath = datasetLatestTestStatePath(projectPath, datasetName);
-    if (!existsSync(latestPath))
-        return null;
-    return readJsonFileWithSchema(latestPath, "latest test comparison", TestRunComparisonSchema);
-}
-export function readSavedTestComparison(projectPath, datasetName) {
-    return loadLatestComparison(projectPath, datasetName);
+export function readSavedTestComparison(projectPath, preparationName) {
+    return loadLatestComparison(projectPath, preparationName);
 }
 export function readCurrentSavedTestComparison(options) {
-    const latestComparison = readSavedTestComparison(options.projectPath, options.datasetName);
-    if (!latestComparison) {
-        return { comparison: null, stale: false };
-    }
-    const currentFingerprint = fingerprintReadinessChecks(options.checks);
-    if (!latestComparison.checks_fingerprint || latestComparison.checks_fingerprint !== currentFingerprint) {
-        return { comparison: null, stale: true };
-    }
-    return { comparison: latestComparison, stale: false };
-}
-function renderLatestSummaryMarkdown(payload) {
-    const lines = [
-        "# Latest Readiness Results",
-        "",
-        "| Target | Readiness checks |",
-        "| --- | --- |",
-    ];
-    if (payload.raw) {
-        lines.push(`| Source files | \`${payload.raw.passed_cases}/${payload.raw.total_cases}\` |`);
-    }
-    if (payload.compiled) {
-        lines.push(`| Portable Context | \`${payload.compiled.passed_cases}/${payload.compiled.total_cases}\` |`);
-    }
-    lines.push("");
-    if (payload.summary.raw_pass_rate != null && payload.summary.compiled_pass_rate != null) {
-        const direction = (payload.summary.pass_rate_delta ?? 0) >= 0 ? "improved" : "decreased";
-        lines.push(`Readiness-check pass rate ${direction} from ${payload.summary.raw_pass_rate}% to ${payload.summary.compiled_pass_rate}%.`, "");
-    }
-    if (payload.raw) {
-        lines.push(`- Latest source-files run: ${payload.raw.run_path}`);
-    }
-    if (payload.compiled) {
-        lines.push(`- Latest portable-context run: ${payload.compiled.run_path}`);
-    }
-    return `${lines.join("\n")}\n`;
+    return readCurrentSavedReadinessCheckRun({
+        projectPath: options.projectPath,
+        preparationName: options.preparationName,
+        checks: options.checks,
+    });
 }
 export function printSavedTestComparisonState(payload, comparisonRunPath) {
     console.log();
@@ -184,22 +121,6 @@ export function printAgentTestFailures(rows) {
         }
     }
 }
-function specNeedsExecutor(spec) {
-    return spec.cases.some((entry) => !entry.file || Boolean(entry.answer));
-}
-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,
-        purpose: "test",
-    });
-}
 export function printSavedTestOutcome(prefix, outcome) {
     const color = outcome.result.ok ? chalk.green : chalk.red;
     const status = outcome.result.ok ? chalk.green("PASS") : chalk.red("FAIL");
@@ -278,144 +199,33 @@ export function printSavedTestComparisonSummary(rawOutcome, compiledOutcome, com
     }
 }
 export function saveTestComparisonRun(options) {
-    const generatedAt = new Date().toISOString();
-    const rawSummary = options.rawOutcome
-        ? summarizeSavedTestOutcome("Source files", options.rawOutcome)
-        : null;
-    const compiledSummary = options.compiledOutcome
-        ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
-        : null;
-    const effectiveMode = rawSummary && compiledSummary
-        ? "both"
-        : rawSummary
-            ? "raw"
-            : "compiled";
-    const rawPassRate = rawSummary
-        ? Math.round((rawSummary.passed_cases / rawSummary.total_cases) * 100)
-        : null;
-    const compiledPassRate = compiledSummary
-        ? Math.round((compiledSummary.passed_cases / compiledSummary.total_cases) * 100)
-        : null;
-    const payload = {
-        kind: "interf-test-run",
-        version: 1,
-        generated_at: generatedAt,
-        mode: effectiveMode,
-        source_path: options.sourcePath,
-        checks_fingerprint: options.checksFingerprint,
-        dataset: {
-            name: options.compiledName,
-            compiled_path: options.compiledPath,
-        },
-        raw: rawSummary,
-        compiled: compiledSummary,
-        summary: {
-            raw_pass_rate: rawPassRate,
-            compiled_pass_rate: compiledPassRate,
-            pass_rate_delta: rawPassRate !== null && compiledPassRate !== null ? compiledPassRate - rawPassRate : null,
-        },
-    };
-    const latestStatePath = datasetLatestTestStatePath(options.sourcePath, options.compiledName);
-    mkdirSync(dirname(latestStatePath), { recursive: true });
-    writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
-    writeFileSync(datasetLatestTestSummaryPath(options.sourcePath, options.compiledName), renderLatestSummaryMarkdown(payload));
-    if (options.compiledPath) {
-        mkdirSync(testRootForCompiled(options.compiledPath), { recursive: true });
-        writeFileSync(join(testRootForCompiled(options.compiledPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
-    }
-    return latestStatePath;
+    return saveReadinessCheckRun({
+        sourcePath: options.sourcePath,
+        portableContextPath: options.compiledPath,
+        preparationName: options.compiledName,
+        checksFingerprint: options.checksFingerprint,
+        mode: options.mode,
+        rawOutcome: options.rawOutcome,
+        compiledOutcome: options.compiledOutcome,
+    });
 }
 export async function runSavedRawTest(options) {
-    const spec = buildTestSpecFromSourceFolderConfig({
+    return runSavedSourceFilesCheck({
         sourcePath: options.sourcePath,
-        targetName: options.datasetConfig.name,
-        targetType: "raw",
-    });
-    if (!spec) {
-        return null;
-    }
-    const { executor, error } = await resolveExecutorForSpec(spec, options.executor, options.executionProfile);
-    if (!executor && !error) {
-        return null;
-    }
-    if (!executor && error) {
-        process.exitCode = 1;
-        console.log(chalk.red(error));
-        return null;
-    }
-    const datasetSourcePath = resolveSourceDatasetPath(options.sourcePath, options.datasetConfig);
-    const portableContextPath = ensurePortableContextScaffold(options.sourcePath, options.datasetConfig.name, options.datasetConfig.workflow ?? "interf");
-    const target = createRawTestTarget(datasetSourcePath);
-    const run = await runTargetTestsAuto(datasetSourcePath, spec, [target], {
-        executor,
+        preparationConfig: options.preparationConfig,
+        executor: options.executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: testRootForCompiled(portableContextPath),
-    });
-    const result = run.results[0];
-    if (!result)
-        return null;
-    const datasetRunPath = writeDatasetTargetRun({
-        projectPath: options.sourcePath,
-        datasetName: options.datasetConfig.name,
-        target: "file-as-is",
-        generatedAt: run.generated_at,
-        runId: normalizeDatasetTestRunId(spec.id),
         runSuffix: options.runSuffix,
-        payload: run,
     });
-    return {
-        runPath: datasetRunPath,
-        target,
-        result,
-    };
 }
 export async function runSavedCompiledTest(options) {
-    const compiledPath = options.compiledPath ?? findBuiltCompiledPath(options.sourcePath, options.datasetConfig.name);
-    if (!compiledPath) {
-        return null;
-    }
-    const spec = buildTestSpecFromCompiledDatasetConfig({
-        compiledPath,
-        targetType: "compiled",
-    });
-    if (!spec) {
-        return null;
-    }
-    const target = createCompiledTestTarget(compiledPath, options.datasetConfig.name, options.datasetConfig.workflow ?? "interf");
-    if (!target || !target.eligible) {
-        return null;
-    }
-    const { executor, error } = await resolveExecutorForSpec(spec, options.executor, options.executionProfile);
-    if (!executor && !error) {
-        return null;
-    }
-    if (!executor && error) {
-        process.exitCode = 1;
-        console.log(chalk.red(error));
-        return null;
-    }
-    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
-        executor,
+    const compiledPath = options.compiledPath ?? findBuiltCompiledPath(options.sourcePath, options.preparationConfig.name);
+    return runSavedPortableContextCheck({
+        sourcePath: options.sourcePath,
+        preparationConfig: options.preparationConfig,
+        executor: options.executor,
+        portableContextPath: compiledPath,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: compiledPath,
-    });
-    const result = run.results[0];
-    if (!result)
-        return null;
-    const compiledRunPath = saveTargetTestRun(compiledPath, run);
-    const datasetRunPath = writeDatasetTargetRun({
-        projectPath: options.sourcePath,
-        datasetName: options.datasetConfig.name,
-        target: "compiled",
-        generatedAt: run.generated_at,
-        runId: normalizeDatasetTestRunId(spec.id),
         runSuffix: options.runSuffix,
-        payload: run,
     });
-    return {
-        runPath: compiledRunPath,
-        displayRunPath: datasetRunPath,
-        target,
-        result,
-    };
 }

package/dist/cli/commands/test.d.ts

@@ -1,10 +1,10 @@
 import type { CommandModule } from "yargs";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
 import { type AgentTestMatrixRow } from "./test-flow.js";
 type TestMode = "raw" | "compiled" | "both";
 export interface TestCommandResult {
     sourcePath: string;
-    datasetConfig: SourceDatasetConfig;
+    preparationConfig: SourcePreparationConfig;
     builtCompiledPath: string | null;
     mode: TestMode;
     rows: AgentTestMatrixRow[];