@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/testing/lib/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type TestCaseExpect, type TestTargetType } from "../../compiler/lib/schema.js";
+import { type TestCaseExpect, type TestTargetType } from "../../contracts/lib/schema.js";
 export declare const TestCaseSchema: z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
@@ -65,7 +65,7 @@ export declare const TestTargetResultSchema: z.ZodObject<{
         }>;
         name: z.ZodString;
         path: z.ZodString;
-        workflow: z.ZodString;
+        method: z.ZodString;
     }, z.core.$strip>;
     sandbox_path: z.ZodOptional<z.ZodString>;
     ok: z.ZodBoolean;
@@ -143,7 +143,7 @@ export declare const TestTargetRunSchema: z.ZodObject<{
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            workflow: z.ZodString;
+            method: z.ZodString;
         }, z.core.$strip>;
         sandbox_path: z.ZodOptional<z.ZodString>;
         ok: z.ZodBoolean;
@@ -189,11 +189,11 @@ export declare const TestRunTargetSummarySchema: z.ZodObject<{
         }>;
         name: z.ZodString;
         path: z.ZodString;
-        workflow: z.ZodString;
+        method: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const TestRunComparisonSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-test-run">;
+export declare const ReadinessCheckRunSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-readiness-check-run">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     mode: z.ZodEnum<{
@@ -203,9 +203,9 @@ export declare const TestRunComparisonSchema: z.ZodObject<{
     }>;
     source_path: z.ZodString;
     checks_fingerprint: z.ZodOptional<z.ZodString>;
-    dataset: z.ZodObject<{
+    preparation: z.ZodObject<{
         name: z.ZodString;
-        compiled_path: z.ZodNullable<z.ZodString>;
+        portable_context_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
     raw: z.ZodNullable<z.ZodObject<{
         label: z.ZodString;
@@ -222,7 +222,7 @@ export declare const TestRunComparisonSchema: z.ZodObject<{
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            workflow: z.ZodString;
+            method: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
     compiled: z.ZodNullable<z.ZodObject<{
@@ -240,7 +240,7 @@ export declare const TestRunComparisonSchema: z.ZodObject<{
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            workflow: z.ZodString;
+            method: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
@@ -258,4 +258,4 @@ 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 ReadinessCheckRun = z.infer<typeof ReadinessCheckRunSchema>;

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

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { RuntimeExecutorInfoSchema, TestCaseExpectSchema, TestTargetTypeSchema, } from "../../compiler/lib/schema.js";
-import { DatasetNameSchema } from "../../project-model/lib/schema.js";
+import { RuntimeExecutorInfoSchema, TestCaseExpectSchema, TestTargetTypeSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 const TestCaseCoreSchema = z.object({
     id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,79}$/),
     question: z.string().min(1),
@@ -47,7 +46,7 @@ export const TestTargetResultSchema = z.object({
         type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
-        workflow: z.string(),
+        method: z.string(),
     }),
     sandbox_path: z.string().optional(),
     ok: z.boolean(),
@@ -95,19 +94,19 @@ export const TestRunTargetSummarySchema = z.object({
         type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
-        workflow: z.string(),
+        method: z.string(),
     }),
 });
-export const TestRunComparisonSchema = z.object({
-    kind: z.literal("interf-test-run"),
+export const ReadinessCheckRunSchema = z.object({
+    kind: z.literal("interf-readiness-check-run"),
     version: z.literal(1),
     generated_at: z.string(),
     mode: TestRunModeSchema,
     source_path: z.string(),
     checks_fingerprint: z.string().min(1).optional(),
-    dataset: z.object({
-        name: DatasetNameSchema,
-        compiled_path: z.string().nullable(),
+    preparation: z.object({
+        name: PreparationNameSchema,
+        portable_context_path: z.string().nullable(),
     }),
     raw: TestRunTargetSummarySchema.nullable(),
     compiled: TestRunTargetSummarySchema.nullable(),

package/dist/packages/testing/readiness-check-run.d.ts

@@ -0,0 +1,67 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type TestTargetCandidate, type TestTargetResult } from "./test.js";
+import type { TestSandboxRetentionMode } from "./test-sandbox.js";
+import { type ReadinessCheckRun, type TestRunMode } from "./lib/schema.js";
+export interface SavedReadinessCheckOutcome {
+    runPath: string;
+    displayRunPath?: string;
+    target: TestTargetCandidate;
+    result: TestTargetResult;
+}
+export interface ReadinessCheckRunResult {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    portableContextPath: string | null;
+    mode: TestRunMode;
+    rawOutcome: SavedReadinessCheckOutcome | null;
+    compiledOutcome: SavedReadinessCheckOutcome | null;
+    comparisonRunPath: string | null;
+    comparison: ReadinessCheckRun | null;
+}
+export declare function readinessPassRate(outcome: SavedReadinessCheckOutcome): number;
+export declare function readSavedReadinessCheckRun(projectPath: string, preparationName: string): ReadinessCheckRun | null;
+export declare function parseReadinessCheckRun(value: unknown): ReadinessCheckRun | null;
+export declare function readReadinessCheckRunAtPath(filePath: string, label?: string): ReadinessCheckRun | null;
+export declare function readCurrentSavedReadinessCheckRun(options: {
+    projectPath: string;
+    preparationName: string;
+    checks: SourcePreparationConfig["checks"];
+}): {
+    comparison: ReadinessCheckRun | null;
+    stale: boolean;
+};
+export declare function saveReadinessCheckRun(options: {
+    sourcePath: string;
+    portableContextPath: string | null;
+    preparationName: string;
+    checksFingerprint: string;
+    mode: TestRunMode;
+    rawOutcome: SavedReadinessCheckOutcome | null;
+    compiledOutcome: SavedReadinessCheckOutcome | null;
+}): string;
+export declare function runSavedSourceFilesCheck(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+}): Promise<SavedReadinessCheckOutcome | null>;
+export declare function runSavedPortableContextCheck(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    portableContextPath?: string | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+}): Promise<SavedReadinessCheckOutcome | null>;
+export declare function runReadinessChecksForExecutor(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    portableContextPath: string | null;
+    mode: TestRunMode;
+    executor?: MethodExecutor | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+    saveLatest?: boolean;
+}): Promise<ReadinessCheckRunResult>;

package/dist/packages/testing/readiness-check-run.js

@@ -0,0 +1,258 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { buildTestSpecFromCompiledPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveSourcePreparationPath, } from "../project-model/source-config.js";
+import { preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, portableContextPath, } from "../project-model/project-paths.js";
+import { testRootForCompiled } from "../compiler/compiled-paths.js";
+import { readJsonFileWithSchema } from "../shared/parse.js";
+import { resolveMethodId } from "../methods/method-resolution.js";
+import { createCompiledTestTarget, createRawTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
+import { ReadinessCheckRunSchema, } from "./lib/schema.js";
+export function readinessPassRate(outcome) {
+    return outcome.result.totalCases > 0
+        ? Math.round((outcome.result.passedCases / outcome.result.totalCases) * 100)
+        : 0;
+}
+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 writePreparationTargetRun(options) {
+    const dirPath = preparationTestRunsRoot(options.projectPath, options.preparationName, options.target);
+    mkdirSync(dirPath, { recursive: true });
+    const runPath = preparationTestRunPath(options.projectPath, options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
+    return runPath;
+}
+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`;
+}
+export function readSavedReadinessCheckRun(projectPath, preparationName) {
+    const latestPath = preparationLatestReadinessRunPath(projectPath, preparationName);
+    if (!existsSync(latestPath))
+        return null;
+    return readReadinessCheckRunAtPath(latestPath, "latest readiness-check run");
+}
+export function parseReadinessCheckRun(value) {
+    const parsed = ReadinessCheckRunSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+export function readReadinessCheckRunAtPath(filePath, label = "readiness-check run") {
+    return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
+}
+export function readCurrentSavedReadinessCheckRun(options) {
+    const latestComparison = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
+    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 };
+}
+export function saveReadinessCheckRun(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-readiness-check-run",
+        version: 1,
+        generated_at: generatedAt,
+        mode: effectiveMode,
+        source_path: options.sourcePath,
+        checks_fingerprint: options.checksFingerprint,
+        preparation: {
+            name: options.preparationName,
+            portable_context_path: options.portableContextPath,
+        },
+        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 = preparationLatestReadinessRunPath(options.sourcePath, options.preparationName);
+    mkdirSync(dirname(latestStatePath), { recursive: true });
+    writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
+    writeFileSync(preparationLatestReadinessSummaryPath(options.sourcePath, options.preparationName), renderLatestSummaryMarkdown(payload));
+    if (options.portableContextPath) {
+        mkdirSync(testRootForCompiled(options.portableContextPath), { recursive: true });
+        writeFileSync(join(testRootForCompiled(options.portableContextPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
+    }
+    return latestStatePath;
+}
+export async function runSavedSourceFilesCheck(options) {
+    const spec = buildTestSpecFromSourceFolderConfig({
+        sourcePath: options.sourcePath,
+        targetName: options.preparationConfig.name,
+        targetType: "raw",
+    });
+    if (!spec)
+        return null;
+    const sourceFolderPath = resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
+    const target = createRawTestTarget(sourceFolderPath);
+    const artifactRoot = preparationLatestReadinessRunPath(options.sourcePath, options.preparationConfig.name);
+    const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
+        executor: options.executor,
+        preserveSandboxes: options.preserveSandboxes ?? "on-failure",
+        artifactRootPath: dirname(artifactRoot),
+    });
+    const result = run.results[0];
+    if (!result)
+        return null;
+    const preparationRunPath = writePreparationTargetRun({
+        projectPath: options.sourcePath,
+        preparationName: options.preparationConfig.name,
+        target: "file-as-is",
+        generatedAt: run.generated_at,
+        runId: normalizePreparationTestRunId(spec.id),
+        runSuffix: options.runSuffix,
+        payload: run,
+    });
+    return {
+        runPath: preparationRunPath,
+        target,
+        result,
+    };
+}
+export async function runSavedPortableContextCheck(options) {
+    const portableContextPath = options.portableContextPath
+        ?? portableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
+    const spec = buildTestSpecFromCompiledPreparationConfig({
+        compiledPath: portableContextPath,
+        targetType: "compiled",
+    });
+    if (!spec)
+        return null;
+    const target = createCompiledTestTarget(portableContextPath, options.preparationConfig.name, resolveMethodId(options.preparationConfig));
+    if (!target.eligible)
+        return null;
+    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
+        executor: options.executor,
+        preserveSandboxes: options.preserveSandboxes ?? "on-failure",
+        artifactRootPath: portableContextPath,
+    });
+    const result = run.results[0];
+    if (!result)
+        return null;
+    const compiledRunPath = saveTargetTestRun(portableContextPath, run);
+    const preparationRunPath = writePreparationTargetRun({
+        projectPath: options.sourcePath,
+        preparationName: options.preparationConfig.name,
+        target: "compiled",
+        generatedAt: run.generated_at,
+        runId: normalizePreparationTestRunId(spec.id),
+        runSuffix: options.runSuffix,
+        payload: run,
+    });
+    return {
+        runPath: compiledRunPath,
+        displayRunPath: preparationRunPath,
+        target,
+        result,
+    };
+}
+export async function runReadinessChecksForExecutor(options) {
+    const rawPromise = options.mode === "raw" || options.mode === "both"
+        ? runSavedSourceFilesCheck({
+            sourcePath: options.sourcePath,
+            preparationConfig: options.preparationConfig,
+            executor: options.executor,
+            preserveSandboxes: options.preserveSandboxes,
+            runSuffix: options.runSuffix,
+        })
+        : Promise.resolve(null);
+    const compiledPromise = options.mode === "compiled" || options.mode === "both"
+        ? runSavedPortableContextCheck({
+            sourcePath: options.sourcePath,
+            preparationConfig: options.preparationConfig,
+            executor: options.executor,
+            portableContextPath: options.portableContextPath,
+            preserveSandboxes: options.preserveSandboxes,
+            runSuffix: options.runSuffix,
+        })
+        : Promise.resolve(null);
+    const [rawOutcome, compiledOutcome] = await Promise.all([rawPromise, compiledPromise]);
+    const modeSatisfied = (options.mode !== "raw" || Boolean(rawOutcome)) &&
+        (options.mode !== "compiled" || Boolean(compiledOutcome)) &&
+        (options.mode !== "both" || (Boolean(rawOutcome) && Boolean(compiledOutcome)));
+    const shouldSave = options.saveLatest !== false;
+    const comparisonRunPath = shouldSave && modeSatisfied
+        ? saveReadinessCheckRun({
+            sourcePath: options.sourcePath,
+            portableContextPath: options.portableContextPath,
+            preparationName: options.preparationConfig.name,
+            checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
+            mode: options.mode,
+            rawOutcome,
+            compiledOutcome,
+        })
+        : null;
+    const comparison = shouldSave && modeSatisfied
+        ? readSavedReadinessCheckRun(options.sourcePath, options.preparationConfig.name)
+        : null;
+    return {
+        sourcePath: options.sourcePath,
+        preparationConfig: options.preparationConfig,
+        portableContextPath: options.portableContextPath,
+        mode: options.mode,
+        rawOutcome,
+        compiledOutcome,
+        comparisonRunPath,
+        comparison,
+    };
+}
+function portableContextPathForPreparation(sourcePath, preparationName) {
+    return portableContextPath(sourcePath, preparationName);
+}

package/dist/packages/testing/test-execution.d.ts

@@ -1,13 +1,13 @@
-import { type WorkflowExecutor } from "../agents/lib/executors.js";
+import { type MethodExecutor } from "../agents/lib/executors.js";
 import type { TestTargetRun, TestTargetCandidate, LoadedTestSpec } from "./test-types.js";
 import { type TestSandboxRetentionMode } from "./test-sandbox.js";
 export declare function runTargetTests(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[]): TestTargetRun;
-export declare function runTargetTestsWithJudge(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], executor: WorkflowExecutor, options?: {
+export declare function runTargetTestsWithJudge(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], executor: MethodExecutor, options?: {
     preserveSandboxes?: TestSandboxRetentionMode;
     artifactRootPath?: string;
 }): Promise<TestTargetRun>;
 export declare function runTargetTestsAuto(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], options?: {
-    executor?: WorkflowExecutor | null;
+    executor?: MethodExecutor | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     artifactRootPath?: string;
 }): Promise<TestTargetRun>;

package/dist/packages/testing/test-execution.js

@@ -197,28 +197,28 @@ async function runTargetTestsJudge(testCase, executor, candidateLabel, candidate
 function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
     const header = target.type === "compiled"
         ? [
-            "You are running an Interf test inside an isolated sandboxed compiled context.",
+            "You are running an Interf test inside an isolated sandboxed portable context.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this portable context.",
             "Answer the check question the same way you would answer a real user inside this portable context.",
-            "Prefer the workflow-declared context outputs before raw fallback.",
-            "This sandbox is self-contained: the copied portable context has its own sanitized `raw/` fallback via `.interf/interf.json` `source.path`.",
-            "The original project root is intentionally absent from this sandbox. Work only from this sandboxed compiled context and its embedded raw files.",
+            "Prefer the Method-declared portable-context outputs before consulting `raw/`.",
+            "This sandbox is self-contained: the copied portable context has sanitized source files under `raw/` via `.interf/interf.json` `source.path`.",
+            "The original Interf Workspace is intentionally absent from this sandbox. Work only from this sandboxed portable context and its embedded raw files.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated raw test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
-            "There is no compiled context in this sandbox.",
+            "There is no portable context in this sandbox.",
             "Answer only from `raw/` inside this shell.",
-            "The original project root is intentionally absent from this sandbox.",
+            "The original control plane folder is intentionally absent from this sandbox.",
         ];
     return [
         ...header,
         "Emit only STATUS:, DONE:, BLOCKED:, or ERROR: lines.",
         "Do not ask follow-up questions.",
         `Write the answer to ${JSON.stringify(answerPath)}.`,
-        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, raw_paths_read, used_raw_fallback, answer_summary.`,
+        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, raw_paths_read, used_source_files, answer_summary.`,
         `Set \`case_id\` to ${JSON.stringify(testCase.id)}.`,
         `Set \`target\` to ${JSON.stringify(target.type)}.`,
         `Question: ${testCase.question}`,
@@ -383,7 +383,7 @@ function buildTestTargetResult(target, caseResults, options = {}) {
             type: target.type,
             name: target.name,
             path: target.path,
-            workflow: target.workflow,
+            method: target.method,
         },
         ...(options.sandboxPath ? { sandbox_path: options.sandboxPath } : {}),
         ok: passedCases === caseResults.length,

package/dist/packages/testing/test-paths.js

@@ -4,25 +4,23 @@ import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, comp
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
 export function testSpecRootPath(sourcePath) {
-    return join(sourcePath, "interf", "tests", "matrix", "specs");
+    return join(sourcePath, "interf", "tests", "specs");
 }
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
-function isDatasetTestsRootPath(artifactRootPath) {
-    const portableContextTestsRoot = basename(artifactRootPath) === "tests" &&
+function isPreparationTestsRootPath(artifactRootPath) {
+    return basename(artifactRootPath) === "tests" &&
         basename(dirname(artifactRootPath)) === ".interf";
-    const legacyProjectTestsRoot = basename(dirname(artifactRootPath)) === "tests";
-    return portableContextTestsRoot || legacyProjectTestsRoot;
 }
 export function targetTestRunsPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestRunsRootForCompiled(compiledPath), type);
     }
-    if (isDatasetTestsRootPath(compiledPath)) {
+    if (isPreparationTestsRootPath(compiledPath)) {
         return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/<dataset>/.interf/tests root.`);
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }
 export function targetTestRunGitignorePath(compiledPath, type) {
     return join(targetTestRunsPath(compiledPath, type), ".gitignore");
@@ -31,10 +29,10 @@ export function targetTestSandboxesPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestSandboxesRootForCompiled(compiledPath), type);
     }
-    if (isDatasetTestsRootPath(compiledPath)) {
+    if (isPreparationTestsRootPath(compiledPath)) {
         return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/<dataset>/.interf/tests root.`);
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }
 export function targetTestSandboxGitignorePath(compiledPath, type) {
     return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");

package/dist/packages/testing/test-profile-presets.js

@@ -25,10 +25,10 @@ export const TestProfilePresets = {
     }),
     "release-codex-high": TestProfilePresetValueSchema.parse({
         agent: "codex",
-        model: "gpt-5.4-mini",
+        model: "gpt-5.3-codex",
         effort: "high",
         timeout_ms: 480000,
-        label: "Codex (GPT-5.4 Mini, high)",
+        label: "Codex (GPT-5.3 Codex, high)",
     }),
     "tier1-max-claude": TestProfilePresetValueSchema.parse({
         agent: "claude-code",

package/dist/packages/testing/test-sandbox.js

@@ -2,13 +2,13 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from
 import { tmpdir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { readInterfConfig, resolveCompiledRawPath } from "../project-model/interf.js";
+import { readInterfConfig } from "../project-model/interf.js";
 import { projectRawTestQueryShell } from "../agents/lib/shells.js";
-import { compiledCompiledPathForDataset } from "../project-model/project-paths.js";
+import { portableContextPath } from "../project-model/project-paths.js";
 import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { projectRawSnapshot } from "../compiler/raw-snapshot.js";
+import { projectRawSnapshot, resolveCompiledRawPath } from "../compiler/raw-snapshot.js";
 import { refreshCompiledArtifacts } from "../compiler/state.js";
-import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
 function toPortableRelativePath(fromPath, toPath) {
     return relative(fromPath, toPath).split(sep).join("/");
 }
@@ -17,7 +17,7 @@ function sanitizeCompiledArtifacts(compiledPath) {
         testRootForCompiled(compiledPath),
         targetTestSandboxesRootForCompiled(compiledPath),
         stageExecutionShellsRoot(compiledPath),
-        workflowImprovementLoopsRoot(compiledPath),
+        methodImprovementLoopsRoot(compiledPath),
         compiledRuntimeLogsRoot(compiledPath),
         compiledQueryAcceptanceRoot(compiledPath),
     ]) {
@@ -28,13 +28,13 @@ export function createTestSandbox(target) {
     let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
     const sandboxCompiledPath = () => (target.type === "compiled"
-        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
+        ? portableContextPath(sandboxRoot, target.name)
         : null);
     const sandboxRawPath = () => (target.type === "compiled"
-        ? join(compiledCompiledPathForDataset(sandboxRoot, target.name), "raw")
+        ? join(portableContextPath(sandboxRoot, target.name), "raw")
         : join(sandboxRoot, "raw"));
     const sandboxTargetPath = () => (target.type === "compiled"
-        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
+        ? portableContextPath(sandboxRoot, target.name)
         : sandboxRoot);
     try {
         if (target.type === "compiled") {
@@ -43,17 +43,16 @@ export function createTestSandbox(target) {
             sanitizeCompiledArtifacts(sandboxTargetPath());
             const sandboxConfig = readInterfConfig(sandboxTargetPath());
             if (!sandboxConfig) {
-                throw new Error(`Sandbox compiled context is missing interf.json: ${sandboxTargetPath()}`);
+                throw new Error(`Sandbox portable context is missing interf.json: ${sandboxTargetPath()}`);
             }
             if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                throw new Error(`Sandbox compiled context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the compiled context before testing it.`);
+                throw new Error(`Sandbox portable context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the portable context before testing it.`);
             }
             saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
                     path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
-                    dataset_path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
                 },
             });
             refreshCompiledBootstrapGuidance(sandboxTargetPath());

package/dist/packages/testing/test-targets.d.ts

@@ -1,5 +1,5 @@
 import type { TestTargetCandidate } from "./test-types.js";
 export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
-export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, workflowId?: string): TestTargetCandidate;
+export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, methodId?: string): TestTargetCandidate;
 export declare function createRawTestTarget(sourcePath: string): TestTargetCandidate;
 export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];