@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/engine/service-registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Central service registry at `~/.interf/services.json`.
+ *
+ * One running `interf web` instance can serve N workspaces. Every running
+ * instance writes an entry here on start and removes it on close. CLI/UX
+ * code consults this registry to decide whether a fresh `interf web` should
+ * register a workspace with an existing instance instead of starting a
+ * second engine.
+ *
+ * Entry shape:
+ *   {
+ *     pid, host, port, url, started_at,
+ *     workspaces: [{ control_path, registered_at, last_activity }],
+ *   }
+ *
+ * Atomic write: write to a sibling tmp file, then rename. Concurrent
+ * `interf web` invocations get last-writer-wins semantics; pruning of
+ * stale entries makes that self-healing.
+ */
+import { interfHomeRoot, serviceRegistryPath } from "../contracts/lib/preparation-paths.js";
+import { type ServiceRegistryEntry, type ServiceRegistryWorkspace } from "./lib/schema.js";
+/**
+ * Read the service registry. Removes entries whose pid is no longer alive
+ * before returning. Does not health-check the HTTP endpoint — that is too
+ * expensive for the synchronous read path; callers that care can verify
+ * with a fetch.
+ */
+export declare function readServiceRegistry(): ServiceRegistryEntry[];
+/** Overwrite the registry with the given list of services. */
+export declare function writeServiceRegistry(services: ServiceRegistryEntry[]): void;
+/**
+ * Insert or update the entry for this process's pid. If the pid was
+ * already registered, replaces it (so callers can use this to update the
+ * workspace list).
+ */
+export declare function registerServiceLocally(entry: ServiceRegistryEntry): ServiceRegistryEntry;
+/** Remove the registry entry for the given pid. */
+export declare function unregisterService(pid: number): void;
+/** Update the workspaces array on the entry for this process's pid. */
+export declare function updateLocalServiceWorkspaces(pid: number, options: {
+    host: string;
+    port: number;
+    url: string;
+    started_at: string;
+    workspaces: ServiceRegistryWorkspace[];
+}): ServiceRegistryEntry;
+export { interfHomeRoot, serviceRegistryPath };

package/dist/packages/engine/service-registry.js

@@ -0,0 +1,137 @@
+/**
+ * Central service registry at `~/.interf/services.json`.
+ *
+ * One running `interf web` instance can serve N workspaces. Every running
+ * instance writes an entry here on start and removes it on close. CLI/UX
+ * code consults this registry to decide whether a fresh `interf web` should
+ * register a workspace with an existing instance instead of starting a
+ * second engine.
+ *
+ * Entry shape:
+ *   {
+ *     pid, host, port, url, started_at,
+ *     workspaces: [{ control_path, registered_at, last_activity }],
+ *   }
+ *
+ * Atomic write: write to a sibling tmp file, then rename. Concurrent
+ * `interf web` invocations get last-writer-wins semantics; pruning of
+ * stale entries makes that self-healing.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+import { interfHomeRoot, serviceRegistryPath, } from "../contracts/lib/preparation-paths.js";
+import { ServiceRegistrySchema, ServiceRegistryEntrySchema, ServiceRegistryWorkspaceSchema, } from "./lib/schema.js";
+/** Returns true when the OS still has a process with this pid. */
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error?.code;
+        // EPERM means the process exists but we can't signal it — still alive.
+        return code === "EPERM";
+    }
+}
+function readRegistryRaw() {
+    const path = serviceRegistryPath();
+    if (!existsSync(path))
+        return { services: [] };
+    try {
+        const raw = readFileSync(path, "utf8");
+        if (!raw.trim())
+            return { services: [] };
+        const parsed = ServiceRegistrySchema.safeParse(JSON.parse(raw));
+        if (parsed.success)
+            return parsed.data;
+        return { services: [] };
+    }
+    catch {
+        return { services: [] };
+    }
+}
+function writeRegistryRaw(registry) {
+    const path = serviceRegistryPath();
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    const parsed = ServiceRegistrySchema.parse(registry);
+    writeFileSync(tmpPath, `${JSON.stringify(parsed, null, 2)}\n`);
+    try {
+        renameSync(tmpPath, path);
+    }
+    catch (error) {
+        try {
+            rmSync(tmpPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        throw error;
+    }
+}
+/**
+ * Read the service registry. Removes entries whose pid is no longer alive
+ * before returning. Does not health-check the HTTP endpoint — that is too
+ * expensive for the synchronous read path; callers that care can verify
+ * with a fetch.
+ */
+export function readServiceRegistry() {
+    const raw = readRegistryRaw();
+    const live = [];
+    let pruned = false;
+    for (const service of raw.services) {
+        if (isProcessAlive(service.pid)) {
+            live.push(service);
+        }
+        else {
+            pruned = true;
+        }
+    }
+    if (pruned) {
+        try {
+            writeRegistryRaw({ services: live });
+        }
+        catch {
+            // best effort; another writer may have raced us
+        }
+    }
+    return live;
+}
+/** Overwrite the registry with the given list of services. */
+export function writeServiceRegistry(services) {
+    writeRegistryRaw({ services });
+}
+/**
+ * Insert or update the entry for this process's pid. If the pid was
+ * already registered, replaces it (so callers can use this to update the
+ * workspace list).
+ */
+export function registerServiceLocally(entry) {
+    const parsed = ServiceRegistryEntrySchema.parse(entry);
+    const existing = readServiceRegistry().filter((service) => service.pid !== parsed.pid);
+    const next = [...existing, parsed];
+    writeServiceRegistry(next);
+    return parsed;
+}
+/** Remove the registry entry for the given pid. */
+export function unregisterService(pid) {
+    const remaining = readServiceRegistry().filter((service) => service.pid !== pid);
+    writeServiceRegistry(remaining);
+}
+/** Update the workspaces array on the entry for this process's pid. */
+export function updateLocalServiceWorkspaces(pid, options) {
+    return registerServiceLocally(ServiceRegistryEntrySchema.parse({
+        pid,
+        host: options.host,
+        port: options.port,
+        url: options.url,
+        started_at: options.started_at,
+        workspaces: options.workspaces.map((workspace) => ServiceRegistryWorkspaceSchema.parse(workspace)),
+    }));
+}
+export { interfHomeRoot, serviceRegistryPath };

package/dist/packages/{testing → engine/verify}/lib/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type TestCaseExpect, type TestTargetType } from "../../contracts/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;
@@ -16,8 +16,8 @@ export declare const TestCaseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const TestSpecSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        "source-files": "source-files";
         compiled: "compiled";
-        raw: "raw";
     }>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -60,8 +60,8 @@ export declare const TestCaseResultSchema: z.ZodObject<{
 export declare const TestTargetResultSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>;
         name: z.ZodString;
         path: z.ZodString;
@@ -98,8 +98,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         type: z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>;
         file: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
@@ -138,8 +138,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
     results: z.ZodArray<z.ZodObject<{
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "source-files": "source-files";
                 compiled: "compiled";
-                raw: "raw";
             }>;
             name: z.ZodString;
             path: z.ZodString;
@@ -170,8 +170,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const TestRunModeSchema: z.ZodEnum<{
+    "source-files": "source-files";
     compiled: "compiled";
-    raw: "raw";
     both: "both";
 }>;
 export declare const TestRunTargetSummarySchema: z.ZodObject<{
@@ -184,8 +184,8 @@ export declare const TestRunTargetSummarySchema: z.ZodObject<{
     total_checks: z.ZodNumber;
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>;
         name: z.ZodString;
         path: z.ZodString;
@@ -197,8 +197,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     mode: z.ZodEnum<{
+        "source-files": "source-files";
         compiled: "compiled";
-        raw: "raw";
         both: "both";
     }>;
     source_path: z.ZodString;
@@ -207,7 +207,7 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         name: z.ZodString;
         portable_context_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
-    raw: z.ZodNullable<z.ZodObject<{
+    source_files: z.ZodNullable<z.ZodObject<{
         label: z.ZodString;
         run_path: z.ZodString;
         ok: z.ZodBoolean;
@@ -217,8 +217,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         total_checks: z.ZodNumber;
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "source-files": "source-files";
                 compiled: "compiled";
-                raw: "raw";
             }>;
             name: z.ZodString;
             path: z.ZodString;
@@ -235,8 +235,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         total_checks: z.ZodNumber;
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "source-files": "source-files";
                 compiled: "compiled";
-                raw: "raw";
             }>;
             name: z.ZodString;
             path: z.ZodString;

package/dist/packages/{testing → engine/verify}/lib/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { RuntimeExecutorInfoSchema, TestCaseExpectSchema, TestTargetTypeSchema, PreparationNameSchema, } from "../../contracts/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),
@@ -81,7 +81,7 @@ export const TestTargetRunSchema = z.object({
     target_count: z.number(),
     results: z.array(TestTargetResultSchema),
 });
-export const TestRunModeSchema = z.enum(["raw", "compiled", "both"]);
+export const TestRunModeSchema = z.enum(["source-files", "compiled", "both"]);
 export const TestRunTargetSummarySchema = z.object({
     label: z.string(),
     run_path: z.string(),
@@ -108,7 +108,7 @@ export const ReadinessCheckRunSchema = z.object({
         name: PreparationNameSchema,
         portable_context_path: z.string().nullable(),
     }),
-    raw: TestRunTargetSummarySchema.nullable(),
+    source_files: TestRunTargetSummarySchema.nullable(),
     compiled: TestRunTargetSummarySchema.nullable(),
     summary: z.object({
         source_files_pass_rate: z.number().nullable(),

package/dist/packages/{testing → engine/verify}/readiness-check-run.d.ts

@@ -1,8 +1,8 @@
 import type { MethodExecutor } from "../agents/lib/executors.js";
-import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import type { SourcePreparationConfig } from "../../project/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";
+import { type ReadinessCheckRun } from "./lib/schema.js";
 export interface SavedReadinessCheckOutcome {
     runPath: string;
     displayRunPath?: string;
@@ -13,18 +13,21 @@ export interface ReadinessCheckRunResult {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
     portableContextPath: string | null;
-    mode: TestRunMode;
-    rawOutcome: SavedReadinessCheckOutcome | null;
+    /**
+     * 0.15 — `sourceFilesOutcome` is always `null`. Kept on the type so
+     * older readers parse cleanly during the rollout; remove in 0.16+.
+     */
+    sourceFilesOutcome: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
     readinessRunPath: string | null;
     readinessRun: ReadinessCheckRun | null;
 }
 export declare function readinessPassRate(outcome: SavedReadinessCheckOutcome): number;
-export declare function readSavedReadinessCheckRun(projectPath: string, preparationName: string): ReadinessCheckRun | null;
+export declare function readSavedReadinessCheckRun(prepDataDir: 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;
+    prepDataDir: string;
     preparationName: string;
     checks: SourcePreparationConfig["checks"];
 }): {
@@ -36,17 +39,8 @@ export declare function saveReadinessCheckRun(options: {
     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;
@@ -59,7 +53,6 @@ export declare function runReadinessChecksForExecutor(options: {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
     portableContextPath: string | null;
-    mode: TestRunMode;
     executor?: MethodExecutor | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;

package/dist/packages/{testing → engine/verify}/readiness-check-run.js

@@ -1,11 +1,11 @@
 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 { buildTestSpecFromCompiledPreparationConfig, fingerprintReadinessChecks, } from "../../project/source-config.js";
+import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { testRootForCompiled } from "../compile/compiled-paths.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { resolveMethodId } from "../../methods/method-resolution.js";
+import { createCompiledTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
 import { ReadinessCheckRunSchema, } from "./lib/schema.js";
 export function readinessPassRate(outcome) {
     return outcome.result.totalCases > 0
@@ -28,9 +28,9 @@ function summarizeSavedTestOutcome(label, outcome) {
     };
 }
 function writePreparationTargetRun(options) {
-    const dirPath = preparationTestRunsRoot(options.projectPath, options.preparationName, options.target);
+    const dirPath = preparationTestRunsRoot(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target);
     mkdirSync(dirPath, { recursive: true });
-    const runPath = preparationTestRunPath(options.projectPath, options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    const runPath = preparationTestRunPath(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
     writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
     return runPath;
 }
@@ -41,23 +41,23 @@ function renderLatestSummaryMarkdown(payload) {
         "| Target | Readiness checks |",
         "| --- | --- |",
     ];
-    if (payload.raw) {
-        lines.push(`| Source files | \`${payload.raw.passed_cases}/${payload.raw.total_cases}\` |`);
+    if (payload.source_files) {
+        lines.push(`| Source files | \`${payload.source_files.passed_cases}/${payload.source_files.total_cases}\` |`);
     }
     if (payload.compiled) {
         lines.push(`| Portable Context | \`${payload.compiled.passed_cases}/${payload.compiled.total_cases}\` |`);
     }
     lines.push("");
-    if (payload.raw) {
-        lines.push(`- Latest source-files run: ${payload.raw.run_path}`);
+    if (payload.source_files) {
+        lines.push(`- Latest source-files run: ${payload.source_files.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);
+export function readSavedReadinessCheckRun(prepDataDir, preparationName) {
+    const latestPath = preparationLatestReadinessRunPath(asPreparationDataDir(prepDataDir), preparationName);
     if (!existsSync(latestPath))
         return null;
     return readReadinessCheckRunAtPath(latestPath, "latest readiness-check run");
@@ -70,7 +70,7 @@ export function readReadinessCheckRunAtPath(filePath, label = "readiness-check r
     return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
 }
 export function readCurrentSavedReadinessCheckRun(options) {
-    const latestRun = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
+    const latestRun = readSavedReadinessCheckRun(options.prepDataDir, options.preparationName);
     if (!latestRun) {
         return { readinessRun: null, stale: false };
     }
@@ -82,20 +82,9 @@ export function readCurrentSavedReadinessCheckRun(options) {
 }
 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;
@@ -103,64 +92,33 @@ export function saveReadinessCheckRun(options) {
         kind: "interf-readiness-check-run",
         version: 1,
         generated_at: generatedAt,
-        mode: effectiveMode,
+        // 0.15 — verify always runs in compiled-only mode. We keep the
+        // `mode: "compiled"` literal in the saved payload so existing
+        // dashboards / consumers that expect the field still parse.
+        mode: "compiled",
         source_path: options.sourcePath,
         checks_fingerprint: options.checksFingerprint,
         preparation: {
             name: options.preparationName,
             portable_context_path: options.portableContextPath,
         },
-        raw: rawSummary,
+        source_files: null,
         compiled: compiledSummary,
         summary: {
-            source_files_pass_rate: rawPassRate,
+            source_files_pass_rate: null,
             portable_context_pass_rate: compiledPassRate,
         },
     };
-    const latestStatePath = preparationLatestReadinessRunPath(options.sourcePath, options.preparationName);
+    const latestStatePath = preparationLatestReadinessRunPath(asPreparationDataDir(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));
+    writeFileSync(preparationLatestReadinessSummaryPath(asPreparationDataDir(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);
@@ -183,7 +141,7 @@ export async function runSavedPortableContextCheck(options) {
         return null;
     const compiledRunPath = saveTargetTestRun(portableContextPath, run);
     const preparationRunPath = writePreparationTargetRun({
-        projectPath: options.sourcePath,
+        prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
         target: "compiled",
         generatedAt: run.generated_at,
@@ -199,29 +157,18 @@ export async function runSavedPortableContextCheck(options) {
     };
 }
 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)));
+    // 0.15 — verify runs always judge against the compiled portable
+    // context. The legacy `source-files` and `both` modes were retired
+    // in 0.13.1 and removed from the wire shape here.
+    const compiledOutcome = await runSavedPortableContextCheck({
+        sourcePath: options.sourcePath,
+        preparationConfig: options.preparationConfig,
+        executor: options.executor,
+        portableContextPath: options.portableContextPath,
+        preserveSandboxes: options.preserveSandboxes,
+        runSuffix: options.runSuffix,
+    });
+    const modeSatisfied = Boolean(compiledOutcome);
     const shouldSave = options.saveLatest !== false;
     const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
@@ -229,8 +176,6 @@ export async function runReadinessChecksForExecutor(options) {
             portableContextPath: options.portableContextPath,
             preparationName: options.preparationConfig.name,
             checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
-            mode: options.mode,
-            rawOutcome,
             compiledOutcome,
         })
         : null;
@@ -241,13 +186,12 @@ export async function runReadinessChecksForExecutor(options) {
         sourcePath: options.sourcePath,
         preparationConfig: options.preparationConfig,
         portableContextPath: options.portableContextPath,
-        mode: options.mode,
-        rawOutcome,
+        sourceFilesOutcome: null,
         compiledOutcome,
         readinessRunPath,
         readinessRun,
     };
 }
 function portableContextPathForPreparation(sourcePath, preparationName) {
-    return portableContextPath(sourcePath, preparationName);
+    return preparationPortableContextPath(asPreparationDataDir(sourcePath), preparationName);
 }

package/dist/packages/{testing → engine/verify}/test-execution.js

@@ -201,16 +201,16 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "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 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.",
+            "Prefer the Method-declared portable-context outputs before consulting source references.",
+            "This sandbox is self-contained: the copied portable context has source references in `.interf/runtime/source-snapshot.json`.",
+            "The original Interf Workspace is intentionally absent from this sandbox. Use the source locators only when the portable context needs verification.",
         ]
         : [
-            "You are running an Interf baseline test inside an isolated raw test shell.",
+            "You are running an Interf baseline test inside an isolated source-files test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
             "There is no portable context in this sandbox.",
-            "Answer only from `raw/` inside this shell.",
+            "Answer only from source references listed in `runtime/source-files.json` inside this shell.",
             "The original control plane folder is intentionally absent from this sandbox.",
         ];
     return [
@@ -218,7 +218,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
         "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_source_files, answer_summary.`,
+        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, source_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}`,