@interf/compiler 0.21.0 → 0.22.2

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

@@ -1,16 +1,13 @@
 /**
  * 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.
+ * Every running `interf web` instance writes an entry here on start and
+ * removes it on close. CLI/UX code consults this registry for explicit
+ * `interf web stop` lookup.
  *
  * 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
@@ -18,7 +15,7 @@
  * stale entries makes that self-healing.
  */
 import { interfHomeRoot, serviceRegistryPath } from "../contracts/lib/preparation-paths.js";
-import { type ServiceRegistryEntry, type ServiceRegistryWorkspace } from "./lib/schema.js";
+import { type ServiceRegistryEntry } 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
@@ -30,18 +27,9 @@ export declare function readServiceRegistry(): ServiceRegistryEntry[];
 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).
+ * already registered, replaces it.
  */
 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

@@ -1,16 +1,13 @@
 /**
  * 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.
+ * Every running `interf web` instance writes an entry here on start and
+ * removes it on close. CLI/UX code consults this registry for explicit
+ * `interf web stop` lookup.
  *
  * 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
@@ -20,7 +17,7 @@
 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";
+import { ServiceRegistrySchema, ServiceRegistryEntrySchema, } 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)
@@ -108,8 +105,7 @@ export function writeServiceRegistry(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).
+ * already registered, replaces it.
  */
 export function registerServiceLocally(entry) {
     const parsed = ServiceRegistryEntrySchema.parse(entry);
@@ -123,15 +119,4 @@ 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/engine/verify/lib/schema.d.ts

@@ -16,8 +16,8 @@ export declare const TestCaseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const TestSpecSchema: z.ZodObject<{
     type: z.ZodEnum<{
+        "verifiable-context": "verifiable-context";
         "source-files": "source-files";
-        compiled: "compiled";
     }>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -60,12 +60,12 @@ export declare const TestCaseResultSchema: z.ZodObject<{
 export declare const TestTargetResultSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            "verifiable-context": "verifiable-context";
             "source-files": "source-files";
-            compiled: "compiled";
         }>;
         name: z.ZodString;
         path: z.ZodString;
-        method: z.ZodString;
+        build_plan: z.ZodString;
     }, z.core.$strip>;
     sandbox_path: z.ZodOptional<z.ZodString>;
     ok: z.ZodBoolean;
@@ -98,8 +98,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         type: z.ZodEnum<{
+            "verifiable-context": "verifiable-context";
             "source-files": "source-files";
-            compiled: "compiled";
         }>;
         file: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
@@ -138,12 +138,12 @@ export declare const TestTargetRunSchema: z.ZodObject<{
     results: z.ZodArray<z.ZodObject<{
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "verifiable-context": "verifiable-context";
                 "source-files": "source-files";
-                compiled: "compiled";
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            method: z.ZodString;
+            build_plan: z.ZodString;
         }, z.core.$strip>;
         sandbox_path: z.ZodOptional<z.ZodString>;
         ok: z.ZodBoolean;
@@ -170,8 +170,8 @@ export declare const TestTargetRunSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const TestRunModeSchema: z.ZodEnum<{
+    "verifiable-context": "verifiable-context";
     "source-files": "source-files";
-    compiled: "compiled";
     both: "both";
 }>;
 export declare const TestRunTargetSummarySchema: z.ZodObject<{
@@ -184,28 +184,28 @@ export declare const TestRunTargetSummarySchema: z.ZodObject<{
     total_checks: z.ZodNumber;
     target: z.ZodObject<{
         type: z.ZodEnum<{
+            "verifiable-context": "verifiable-context";
             "source-files": "source-files";
-            compiled: "compiled";
         }>;
         name: z.ZodString;
         path: z.ZodString;
-        method: z.ZodString;
+        build_plan: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const ReadinessCheckRunSchema: z.ZodObject<{
+export declare const ReadinessCheckRunSchema: z.ZodPreprocess<z.ZodObject<{
     kind: z.ZodLiteral<"interf-readiness-check-run">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     mode: z.ZodEnum<{
+        "verifiable-context": "verifiable-context";
         "source-files": "source-files";
-        compiled: "compiled";
         both: "both";
     }>;
     source_path: z.ZodString;
     checks_fingerprint: z.ZodOptional<z.ZodString>;
     preparation: z.ZodObject<{
         name: z.ZodString;
-        portable_context_path: z.ZodNullable<z.ZodString>;
+        verifiable_context_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
     source_files: z.ZodNullable<z.ZodObject<{
         label: z.ZodString;
@@ -217,15 +217,15 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         total_checks: z.ZodNumber;
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "verifiable-context": "verifiable-context";
                 "source-files": "source-files";
-                compiled: "compiled";
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            method: z.ZodString;
+            build_plan: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
-    compiled: z.ZodNullable<z.ZodObject<{
+    verifiable_context: z.ZodNullable<z.ZodObject<{
         label: z.ZodString;
         run_path: z.ZodString;
         ok: z.ZodBoolean;
@@ -235,19 +235,19 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         total_checks: z.ZodNumber;
         target: z.ZodObject<{
             type: z.ZodEnum<{
+                "verifiable-context": "verifiable-context";
                 "source-files": "source-files";
-                compiled: "compiled";
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            method: z.ZodString;
+            build_plan: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
         source_files_pass_rate: z.ZodNullable<z.ZodNumber>;
-        portable_context_pass_rate: z.ZodNullable<z.ZodNumber>;
+        verifiable_context_pass_rate: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>;
-}, z.core.$strip>;
+}, z.core.$strip>>;
 export type { TestCaseExpect, TestTargetType };
 export type TestCase = z.infer<typeof TestCaseSchema>;
 export type TestSpec = z.infer<typeof TestSpecSchema>;

package/dist/packages/engine/verify/lib/schema.js

@@ -46,7 +46,7 @@ export const TestTargetResultSchema = z.object({
         type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
-        method: z.string(),
+        build_plan: z.string(),
     }),
     sandbox_path: z.string().optional(),
     ok: z.boolean(),
@@ -81,7 +81,7 @@ export const TestTargetRunSchema = z.object({
     target_count: z.number(),
     results: z.array(TestTargetResultSchema),
 });
-export const TestRunModeSchema = z.enum(["source-files", "compiled", "both"]);
+export const TestRunModeSchema = z.enum(["source-files", "verifiable-context", "both"]);
 export const TestRunTargetSummarySchema = z.object({
     label: z.string(),
     run_path: z.string(),
@@ -94,10 +94,38 @@ export const TestRunTargetSummarySchema = z.object({
         type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
-        method: z.string(),
+        build_plan: z.string(),
     }),
 });
-export const ReadinessCheckRunSchema = z.object({
+function mapReadinessCheckRun(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const record = value;
+    const preparation = record.preparation && typeof record.preparation === "object" && !Array.isArray(record.preparation)
+        ? record.preparation
+        : null;
+    const summary = record.summary && typeof record.summary === "object" && !Array.isArray(record.summary)
+        ? record.summary
+        : null;
+    return {
+        ...record,
+        mode: record.mode,
+        preparation: preparation
+            ? {
+                ...preparation,
+                verifiable_context_path: preparation.verifiable_context_path,
+            }
+            : record.preparation,
+        verifiable_context: record.verifiable_context,
+        summary: summary
+            ? {
+                ...summary,
+                verifiable_context_pass_rate: summary.verifiable_context_pass_rate,
+            }
+            : record.summary,
+    };
+}
+export const ReadinessCheckRunSchema = z.preprocess(mapReadinessCheckRun, z.object({
     kind: z.literal("interf-readiness-check-run"),
     version: z.literal(1),
     generated_at: z.string(),
@@ -106,12 +134,12 @@ export const ReadinessCheckRunSchema = z.object({
     checks_fingerprint: z.string().min(1).optional(),
     preparation: z.object({
         name: PreparationNameSchema,
-        portable_context_path: z.string().nullable(),
+        verifiable_context_path: z.string().nullable(),
     }),
     source_files: TestRunTargetSummarySchema.nullable(),
-    compiled: TestRunTargetSummarySchema.nullable(),
+    verifiable_context: TestRunTargetSummarySchema.nullable(),
     summary: z.object({
         source_files_pass_rate: z.number().nullable(),
-        portable_context_pass_rate: z.number().nullable(),
+        verifiable_context_pass_rate: z.number().nullable(),
     }),
-});
+}));

package/dist/packages/engine/verify/readiness-check-run.d.ts

@@ -1,4 +1,4 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { AgentExecutor } from "../agents/lib/executors.js";
 import type { SourcePreparationConfig } from "../../project/lib/schema.js";
 import type { TestTargetType } from "../../contracts/lib/schema.js";
 import { type TestTargetCandidate, type TestTargetResult } from "./verify.js";
@@ -13,14 +13,14 @@ export interface SavedReadinessCheckOutcome {
 export interface ReadinessCheckRunResult {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
-    portableContextPath: string | null;
+    verifiableContextPath: string | null;
     /**
      * 0.17 — restored. Populated when the verify run targets
-     * `source-files`; null when targeting `compiled`. Aggregates back
+     * `source-files`; null when targeting verifiable context. Aggregates back
      * onto the saved `ReadinessCheckRun` payload's `source_files` field.
      */
     sourceFilesOutcome: SavedReadinessCheckOutcome | null;
-    compiledOutcome: SavedReadinessCheckOutcome | null;
+    verifiableContextOutcome: SavedReadinessCheckOutcome | null;
     readinessRunPath: string | null;
     readinessRun: ReadinessCheckRun | null;
 }
@@ -38,46 +38,45 @@ export declare function readCurrentSavedReadinessCheckRun(options: {
 };
 export declare function saveReadinessCheckRun(options: {
     sourcePath: string;
-    portableContextPath: string | null;
+    verifiableContextPath: string | null;
     preparationName: string;
     checksFingerprint: string;
     sourceFilesOutcome?: SavedReadinessCheckOutcome | null;
-    compiledOutcome: SavedReadinessCheckOutcome | null;
+    verifiableContextOutcome: SavedReadinessCheckOutcome | null;
 }): string;
-export declare function runSavedPortableContextCheck(options: {
+export declare function runSavedVerifiableContextCheck(options: {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
-    executor?: MethodExecutor | null;
-    portableContextPath?: string | null;
+    executor?: AgentExecutor | null;
+    verifiableContextPath?: string | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
 }): Promise<SavedReadinessCheckOutcome | null>;
 /**
  * 0.17 — restored. Runs the saved readiness checks against the source
- * folder baseline (no portable-context indirection) so users can see how
- * much value the Method actually adds. The lower-level `verify-execution`
+ * folder baseline (no verifiable-context indirection) so users can see how
+ * much value the Build Plan actually adds. The lower-level `verify-execution`
  * + `verify-sandbox` source-files paths have stayed in tree since 0.13;
  * this is the orchestrator hook that was missing.
  */
 export declare function runSavedSourceFilesCheck(options: {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
-    executor?: MethodExecutor | null;
+    executor?: AgentExecutor | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
 }): Promise<SavedReadinessCheckOutcome | null>;
 export declare function runReadinessChecksForExecutor(options: {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
-    portableContextPath: string | null;
-    executor?: MethodExecutor | null;
+    verifiableContextPath: string | null;
+    executor?: AgentExecutor | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
     saveLatest?: boolean;
     /**
      * 0.17 — selects which target the readiness checks judge against.
-     * Defaults to `compiled` for backward compatibility with existing
-     * callers.
+     * Defaults to verifiable context.
      */
     target?: TestTargetType;
 }): Promise<ReadinessCheckRunResult>;

package/dist/packages/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, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, } from "../../project/source-config.js";
-import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, preparationTestsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
-import { testRootForCompiled } from "../compile/compiled-paths.js";
+import { buildTestSpecFromPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, } from "../../project/source-config.js";
+import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, preparationTestsRoot, normalizePreparationTestRunId, preparationVerifiableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { testRootForVerifiableContext } from "../build/verifiable-context-paths.js";
 import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { resolveMethodId } from "../../methods/method-resolution.js";
-import { createCompiledTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./verify.js";
+import { resolveBuildPlanId } from "../../build-plans/build-plan-resolution.js";
+import { createVerifiableContextTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./verify.js";
 import { ReadinessCheckRunSchema, } from "./lib/schema.js";
 export function readinessPassRate(outcome) {
     return outcome.result.totalCases > 0
@@ -44,15 +44,15 @@ function renderLatestSummaryMarkdown(payload) {
     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}\` |`);
+    if (payload.verifiable_context) {
+        lines.push(`| Verifiable Context | \`${payload.verifiable_context.passed_cases}/${payload.verifiable_context.total_cases}\` |`);
     }
     lines.push("");
     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}`);
+    if (payload.verifiable_context) {
+        lines.push(`- Latest verifiable-context run: ${payload.verifiable_context.run_path}`);
     }
     return `${lines.join("\n")}\n`;
 }
@@ -80,12 +80,12 @@ export function readCurrentSavedReadinessCheckRun(options) {
     }
     return { readinessRun: latestRun, stale: false };
 }
-function modeForOutcomes(sourceFilesOutcome, compiledOutcome) {
-    if (sourceFilesOutcome && compiledOutcome)
+function modeForOutcomes(sourceFilesOutcome, verifiableContextOutcome) {
+    if (sourceFilesOutcome && verifiableContextOutcome)
         return "both";
     if (sourceFilesOutcome)
         return "source-files";
-    return "compiled";
+    return "verifiable-context";
 }
 function passRateOf(summary) {
     if (!summary)
@@ -100,8 +100,8 @@ export function saveReadinessCheckRun(options) {
     const sourceFilesSummary = sourceFilesOutcome
         ? summarizeSavedTestOutcome("Source Files", sourceFilesOutcome)
         : null;
-    const compiledSummary = options.compiledOutcome
-        ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
+    const verifiableContextSummary = options.verifiableContextOutcome
+        ? summarizeSavedTestOutcome("Verifiable Context", options.verifiableContextOutcome)
         : null;
     const payload = {
         kind: "interf-readiness-check-run",
@@ -109,63 +109,63 @@ export function saveReadinessCheckRun(options) {
         generated_at: generatedAt,
         // 0.17 — verify carries the target it ran against on the wire so
         // dashboards and the UI can show source-files baselines alongside
-        // compiled judgments. `both` is reserved for future combined runs.
-        mode: modeForOutcomes(sourceFilesOutcome, options.compiledOutcome),
+        // verifiable-context judgments. `both` is reserved for future combined runs.
+        mode: modeForOutcomes(sourceFilesOutcome, options.verifiableContextOutcome),
         source_path: options.sourcePath,
         checks_fingerprint: options.checksFingerprint,
         preparation: {
             name: options.preparationName,
-            portable_context_path: options.portableContextPath,
+            verifiable_context_path: options.verifiableContextPath,
         },
         source_files: sourceFilesSummary,
-        compiled: compiledSummary,
+        verifiable_context: verifiableContextSummary,
         summary: {
             source_files_pass_rate: passRateOf(sourceFilesSummary),
-            portable_context_pass_rate: passRateOf(compiledSummary),
+            verifiable_context_pass_rate: passRateOf(verifiableContextSummary),
         },
     };
     const latestStatePath = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationName);
     mkdirSync(dirname(latestStatePath), { recursive: true });
     writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
     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`);
+    if (options.verifiableContextPath) {
+        mkdirSync(testRootForVerifiableContext(options.verifiableContextPath), { recursive: true });
+        writeFileSync(join(testRootForVerifiableContext(options.verifiableContextPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
     }
     return latestStatePath;
 }
-export async function runSavedPortableContextCheck(options) {
-    const portableContextPath = options.portableContextPath
-        ?? portableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
-    const spec = buildTestSpecFromCompiledPreparationConfig({
-        compiledPath: portableContextPath,
-        targetType: "compiled",
+export async function runSavedVerifiableContextCheck(options) {
+    const verifiableContextPath = options.verifiableContextPath
+        ?? verifiableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
+    const spec = buildTestSpecFromPreparationConfig({
+        verifiableContextPath: verifiableContextPath,
+        targetType: "verifiable-context",
     });
     if (!spec)
         return null;
-    const target = createCompiledTestTarget(portableContextPath, options.preparationConfig.name, resolveMethodId(options.preparationConfig));
+    const target = createVerifiableContextTestTarget(verifiableContextPath, options.preparationConfig.name, resolveBuildPlanId(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,
+        artifactRootPath: verifiableContextPath,
     });
     const result = run.results[0];
     if (!result)
         return null;
-    const compiledRunPath = saveTargetTestRun(portableContextPath, run);
+    const verifiableContextRunPath = saveTargetTestRun(verifiableContextPath, run);
     const preparationRunPath = writePreparationTargetRun({
         prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
-        target: "compiled",
+        target: "verifiable-context",
         generatedAt: run.generated_at,
         runId: normalizePreparationTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });
     return {
-        runPath: compiledRunPath,
+        runPath: verifiableContextRunPath,
         displayRunPath: preparationRunPath,
         target,
         result,
@@ -173,8 +173,8 @@ export async function runSavedPortableContextCheck(options) {
 }
 /**
  * 0.17 — restored. Runs the saved readiness checks against the source
- * folder baseline (no portable-context indirection) so users can see how
- * much value the Method actually adds. The lower-level `verify-execution`
+ * folder baseline (no verifiable-context indirection) so users can see how
+ * much value the Build Plan actually adds. The lower-level `verify-execution`
  * + `verify-sandbox` source-files paths have stayed in tree since 0.13;
  * this is the orchestrator hook that was missing.
  */
@@ -215,13 +215,13 @@ export async function runSavedSourceFilesCheck(options) {
     };
 }
 export async function runReadinessChecksForExecutor(options) {
-    const target = options.target ?? "compiled";
-    const compiledOutcome = target === "compiled"
-        ? await runSavedPortableContextCheck({
+    const target = options.target ?? "verifiable-context";
+    const verifiableContextOutcome = target === "verifiable-context"
+        ? await runSavedVerifiableContextCheck({
             sourcePath: options.sourcePath,
             preparationConfig: options.preparationConfig,
             executor: options.executor,
-            portableContextPath: options.portableContextPath,
+            verifiableContextPath: options.verifiableContextPath,
             preserveSandboxes: options.preserveSandboxes,
             runSuffix: options.runSuffix,
         })
@@ -235,16 +235,16 @@ export async function runReadinessChecksForExecutor(options) {
             runSuffix: options.runSuffix,
         })
         : null;
-    const modeSatisfied = Boolean(compiledOutcome) || Boolean(sourceFilesOutcome);
+    const modeSatisfied = Boolean(verifiableContextOutcome) || Boolean(sourceFilesOutcome);
     const shouldSave = options.saveLatest !== false;
     const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
             sourcePath: options.sourcePath,
-            portableContextPath: options.portableContextPath,
+            verifiableContextPath: options.verifiableContextPath,
             preparationName: options.preparationConfig.name,
             checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
             sourceFilesOutcome,
-            compiledOutcome,
+            verifiableContextOutcome,
         })
         : null;
     const readinessRun = shouldSave && modeSatisfied
@@ -253,13 +253,13 @@ export async function runReadinessChecksForExecutor(options) {
     return {
         sourcePath: options.sourcePath,
         preparationConfig: options.preparationConfig,
-        portableContextPath: options.portableContextPath,
+        verifiableContextPath: options.verifiableContextPath,
         sourceFilesOutcome,
-        compiledOutcome,
+        verifiableContextOutcome,
         readinessRunPath,
         readinessRun,
     };
 }
-function portableContextPathForPreparation(sourcePath, preparationName) {
-    return preparationPortableContextPath(asPreparationDataDir(sourcePath), preparationName);
+function verifiableContextPathForPreparation(sourcePath, preparationName) {
+    return preparationVerifiableContextPath(asPreparationDataDir(sourcePath), preparationName);
 }

package/dist/packages/engine/verify/verify-execution.d.ts

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