@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/engine/native-run-handlers.js

@@ -2,43 +2,43 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
-import { compileCompiled, } from "./compile/method-runs.js";
+import { buildVerifiableContext, } from "./build/build-plan-runs.js";
 import { readInterfConfig } from "../project/interf.js";
 import { resolveLocalExecutor, } from "./agents/lib/executors.js";
-import { formatMethodExecutionProfile } from "./agents/lib/execution-profile.js";
+import { formatAgentExecutionProfile } from "./agents/lib/execution-profile.js";
 import { loadAgentsRegistry } from "./agents/registry.js";
 import { buildRoleExecutorBundle } from "./agents/role-executors.js";
-import { clearCompiledRuntimeDerivedArtifacts, } from "./compile/reset.js";
-import { formatActiveCompiledMethodStageStep, resolveRequiredCompiledMethodFromConfig, } from "../methods/package/method-definitions.js";
+import { clearBuildRuntimeDerivedArtifacts, } from "./build/reset.js";
+import { formatActiveBuildPlanStageLabel, resolveRequiredBuildPlanFromConfig, } from "../build-plans/package/build-plan-definitions.js";
 import { createRunEventId, createRunEventTimestamp, } from "./execution/events.js";
-import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../project/source-config.js";
-import { runMethodImprovementLoop } from "../methods/authoring/method-improvement.js";
-import { stageExecutionShellsRoot, methodPackagePathForCompiled, } from "./compile/compiled-paths.js";
-import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compile/compiled-schema.js";
-import { initializeCompiledRuntimeState } from "./compile/state.js";
-import { readinessPassRate, runReadinessChecksForExecutor, runSavedPortableContextCheck, } from "./verify/readiness-check-run.js";
-import { runMethodAuthoringDraft, } from "../methods/authoring/method-authoring.js";
+import { loadVerifiableContextPreparationConfig, resolvePreparationBuildMaxAttempts, resolvePreparationBuildMaxLoops, } from "../project/source-config.js";
+import { runBuildPlanImprovementLoop } from "../build-plans/authoring/build-plan-improvement.js";
+import { stageExecutionShellsRoot, buildPlanPackagePathForVerifiableContext, } from "./build/verifiable-context-paths.js";
+import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./build/verifiable-context-schema.js";
+import { initializeBuildRuntimeState } from "./build/state.js";
+import { readinessPassRate, runReadinessChecksForExecutor, runSavedVerifiableContextCheck, } from "./verify/readiness-check-run.js";
+import { runBuildPlanAuthoringDraft, } from "../build-plans/authoring/build-plan-authoring.js";
 import { draftReadinessChecks, } from "./readiness-check-draft.js";
 import { planActionProposalWithExecutor, } from "./action-planner.js";
 import { ActionProposalPlanSchema, } from "./lib/schema.js";
-function printCompileFailure(compiledPath, failedStage) {
-    resolveRequiredCompiledMethodFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
-    let failedStageLabel = failedStage ? `Stage "${failedStage}"` : "Compile";
+function printBuildFailure(verifiableContextPath, failedStage) {
+    resolveRequiredBuildPlanFromConfig(readInterfConfig(verifiableContextPath), `.interf/interf.json for ${verifiableContextPath}`);
+    let failedStageLabel = failedStage ? `Stage "${failedStage}"` : "Build";
     try {
-        failedStageLabel = formatActiveCompiledMethodStageStep(compiledPath, failedStage ?? "compile");
+        failedStageLabel = formatActiveBuildPlanStageLabel(verifiableContextPath, failedStage ?? "build");
     }
     catch {
-        // Keep the original failure visible even when the failure is outside a declared Method stage.
+        // Keep the original failure visible even when the failure is outside a declared Build Plan stage.
     }
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
-async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
+async function buildVerifiableContextWithReporter(executor, verifiableContextPath, options = {}) {
     console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building Portable Context..."}`));
-    const profileLabel = formatMethodExecutionProfile(executor.executionProfile);
+    console.log(chalk.bold(`  ${options.heading ?? "Building Verifiable Context..."}`));
+    const profileLabel = formatAgentExecutionProfile(executor.executionProfile);
     if (profileLabel) {
         console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
     }
@@ -47,10 +47,10 @@ async function compileCompiledWithReporter(executor, compiledPath, options = {})
         line: (message) => console.log(chalk.dim(`  ${message}`)),
         blankLine: () => console.log(),
     };
-    const result = await compileCompiled({
+    const result = await buildVerifiableContext({
         executor,
         resolveStageExecutor: options.resolveStageExecutor,
-        compiledPath,
+        verifiableContextPath,
         reporter,
         preserveStageShells: options.preserveStageShells,
         runId: options.runId,
@@ -59,7 +59,7 @@ async function compileCompiledWithReporter(executor, compiledPath, options = {})
     if (!result.ok)
         return result;
     console.log();
-    console.log(chalk.green(`  ${options.successMessage ?? "Portable Context ready."}`));
+    console.log(chalk.green(`  ${options.successMessage ?? "Verifiable context ready."}`));
     return result;
 }
 function printSavedReadinessOutcome(prefix, outcome) {
@@ -85,9 +85,9 @@ function printSavedReadinessOutcome(prefix, outcome) {
     }
     console.log(chalk.dim(`  Saved run: ${outcome.displayRunPath ?? outcome.runPath}`));
 }
-function bestVariationRestorePaths(compiledPath) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const artifactPaths = (schema ? listCompiledSchemaArtifacts(schema) : [])
+function bestVariationRestorePaths(verifiableContextPath) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
+    const artifactPaths = (schema ? listBuildPlanContextArtifacts(schema) : [])
         .filter((artifact) => artifact.kind !== "runtime")
         .map((artifact) => artifact.path);
     return [
@@ -98,7 +98,7 @@ function bestVariationRestorePaths(compiledPath) {
         ".agents",
         ".cursor",
         ".interf/interf.json",
-        ".interf/method",
+        ".interf/build-plan",
         ...artifactPaths,
     ];
 }
@@ -114,23 +114,23 @@ function copyRelativePathIfPresent(sourceRoot, targetRoot, relativePath) {
         errorOnExist: false,
     });
 }
-function snapshotCompiledBestState(compiledPath) {
-    const snapshotRoot = mkdtempSync(join(tmpdir(), "interf-compile-attempt-"));
-    const snapshotPath = join(snapshotRoot, "compiled");
-    for (const relativePath of bestVariationRestorePaths(compiledPath)) {
-        copyRelativePathIfPresent(compiledPath, snapshotPath, relativePath);
+function snapshotBestBuildState(verifiableContextPath) {
+    const snapshotRoot = mkdtempSync(join(tmpdir(), "interf-build-attempt-"));
+    const snapshotPath = join(snapshotRoot, "verifiable-context");
+    for (const relativePath of bestVariationRestorePaths(verifiableContextPath)) {
+        copyRelativePathIfPresent(verifiableContextPath, snapshotPath, relativePath);
     }
     return snapshotPath;
 }
-function restoreCompiledBestState(snapshotPath, compiledPath) {
-    for (const relativePath of bestVariationRestorePaths(compiledPath)) {
-        rmSync(join(compiledPath, relativePath), { recursive: true, force: true });
-        copyRelativePathIfPresent(snapshotPath, compiledPath, relativePath);
+function restoreBestBuildState(snapshotPath, verifiableContextPath) {
+    for (const relativePath of bestVariationRestorePaths(verifiableContextPath)) {
+        rmSync(join(verifiableContextPath, relativePath), { recursive: true, force: true });
+        copyRelativePathIfPresent(snapshotPath, verifiableContextPath, relativePath);
     }
-    clearCompiledRuntimeDerivedArtifacts(compiledPath);
-    initializeCompiledRuntimeState(compiledPath);
+    clearBuildRuntimeDerivedArtifacts(verifiableContextPath);
+    initializeBuildRuntimeState(verifiableContextPath);
 }
-async function runMethodVariation(options) {
+async function runBuildPlanVariation(options) {
     let bestOutcome = null;
     let bestSnapshotPath = null;
     let bestAttempt = 0;
@@ -138,23 +138,23 @@ async function runMethodVariation(options) {
     try {
         for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
             attemptsRun = attempt;
-            const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
+            const result = await buildVerifiableContextWithReporter(options.executor, options.verifiableContextPath, {
                 heading: options.maxAttempts > 1
-                    ? `Building Portable Context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building Portable Context (${options.variationLabel})...`,
+                    ? `Building Verifiable Context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building Verifiable Context (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Portable Context ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Portable Context ready for ${options.variationLabel}.`,
+                    ? `Verifiable context ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Verifiable context ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
                 runId: options.runId,
                 events: options.events,
                 resolveStageExecutor: options.resolveStageExecutor,
             });
             if (!result.ok) {
-                printCompileFailure(options.compiledPath, result.failedStage);
-                printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "failure");
+                printBuildFailure(options.verifiableContextPath, result.failedStage);
+                printStageShellReviewHint(options.verifiableContextPath, options.preserveStageShells, "failure");
                 if (attempt < options.maxAttempts) {
-                    console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} failed. Retrying with a fresh compile.`));
+                    console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} failed. Retrying with a fresh build.`));
                     continue;
                 }
                 return {
@@ -167,11 +167,11 @@ async function runMethodVariation(options) {
                     fatalError: null,
                 };
             }
-            const outcome = await runSavedPortableContextCheck({
+            const outcome = await runSavedVerifiableContextCheck({
                 sourcePath: options.sourcePath,
-                preparationConfig: options.compiledConfig,
+                preparationConfig: options.verifiableContextConfig,
                 executor: options.testExecutor,
-                portableContextPath: options.compiledPath,
+                verifiableContextPath: options.verifiableContextPath,
                 preserveSandboxes: options.preserveStageShells === "always" ? "always" : "on-failure",
             });
             if (!outcome) {
@@ -182,7 +182,7 @@ async function runMethodVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run saved readiness checks against the Portable Context after compile.",
+                    fatalError: "Could not run saved readiness checks against verifiable context after build.",
                 };
             }
             console.log();
@@ -192,13 +192,13 @@ async function runMethodVariation(options) {
                     rmSync(bestSnapshotPath, { recursive: true, force: true });
                 }
                 bestOutcome = outcome;
-                bestSnapshotPath = snapshotCompiledBestState(options.compiledPath);
+                bestSnapshotPath = snapshotBestBuildState(options.verifiableContextPath);
                 bestAttempt = attempt;
             }
             if (outcome.result.ok) {
                 console.log();
-                console.log(chalk.green(`  Portable Context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
-                printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "success");
+                console.log(chalk.green(`  Verifiable context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                printStageShellReviewHint(options.verifiableContextPath, options.preserveStageShells, "success");
                 return {
                     passed: true,
                     attemptsRun,
@@ -211,7 +211,7 @@ async function runMethodVariation(options) {
             }
             if (attempt < options.maxAttempts) {
                 console.log();
-                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same Method.`));
+                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same Build Plan.`));
             }
         }
         return {
@@ -236,7 +236,7 @@ async function runMethodVariation(options) {
         };
     }
 }
-function summarizeMethodVariation(options) {
+function summarizeBuildPlanVariation(options) {
     const passedChecks = options.result.bestOutcome?.result.passedCases ?? 0;
     const totalChecks = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalChecks;
     const summary = options.result.passed
@@ -244,8 +244,8 @@ function summarizeMethodVariation(options) {
         : options.result.bestOutcome
             ? `Best result: ${passedChecks}/${totalChecks} readiness checks passed.`
             : options.result.failedStage
-                ? `Compile failed at stage ${options.result.failedStage} before any saved readiness result.`
-                : "Method variation did not produce a passing result.";
+                ? `Build failed at stage ${options.result.failedStage} before any saved readiness result.`
+                : "Build Plan variation did not produce a passing result.";
     return {
         variation: options.variation,
         kind: options.kind,
@@ -261,8 +261,8 @@ function summarizeMethodVariation(options) {
         summary,
     };
 }
-function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
-    const reviewRoot = stageExecutionShellsRoot(compiledPath);
+function printStageShellReviewHint(verifiableContextPath, preserveStageShells, result) {
+    const reviewRoot = stageExecutionShellsRoot(verifiableContextPath);
     if (preserveStageShells === "always") {
         console.log(chalk.dim(`  Stage shells are saved under: ${reviewRoot}`));
         return;
@@ -271,26 +271,26 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
         console.log(chalk.dim(`  Review failed stage shells under: ${reviewRoot}`));
     }
 }
-function printPostCompileNextStep(options) {
-    console.log(chalk.dim(`  Portable Context: ${options.compiledPath}`));
+function printPostBuildNextStep(options) {
+    console.log(chalk.dim(`  Verifiable context: ${options.verifiableContextPath}`));
     if (options.checks === 0) {
         console.log(chalk.dim("  Next: run `interf` to add readiness checks, then `interf test`."));
         return;
     }
-    if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, or run `interf test` if you also want readiness evidence for source files and Portable Context."));
+    if (options.testedDuringBuild) {
+        console.log(chalk.dim("  Next: inspect the verifiable context agents will use, or run `interf test` if you also want readiness evidence for source files and verifiable context."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf test` to collect readiness evidence for source files and Portable Context."));
+    console.log(chalk.dim("  Next: run `interf test` to collect readiness evidence for source files and verifiable context."));
 }
 function formatVariationReadinessSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
 }
-function printMethodVariationSummary(summaries) {
+function printBuildPlanVariationSummary(summaries) {
     if (summaries.length === 0)
         return;
     console.log();
-    console.log(chalk.bold("  Method variation summary"));
+    console.log(chalk.bold("  Build Plan variation summary"));
     console.log();
     console.log("  | Variation | Kind | Readiness checks | Result |");
     console.log("  | --- | --- | --- | --- |");
@@ -298,39 +298,39 @@ function printMethodVariationSummary(summaries) {
         console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationReadinessSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
     }
 }
-function printCompiledLocalMethodOwnership(compiledPath, bestVariation) {
+function printSelectedBuildPlanOwnership(verifiableContextPath, bestVariation) {
     if (bestVariation <= 1)
         return;
     console.log();
-    console.log(chalk.dim(`  Best Method variation now lives in: ${methodPackagePathForCompiled(compiledPath)}`));
-    console.log(chalk.dim("  The project-level Method selection was not changed automatically."));
-    console.log(chalk.dim("  Recompiling this existing Portable Context reuses that local Method draft."));
+    console.log(chalk.dim(`  Best Build Plan variation now lives in: ${buildPlanPackagePathForVerifiableContext(verifiableContextPath)}`));
+    console.log(chalk.dim("  The project-level Build Plan selection was not changed automatically."));
+    console.log(chalk.dim("  Rebuilding this existing verifiable context reuses that local Build Plan draft."));
 }
-export async function runConfiguredCompiledCompile(options) {
+export async function runConfiguredBuild(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
-    const configuredMaxAttempts = resolvePreparationCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
-    const maxLoops = resolvePreparationCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const configuredMaxAttempts = resolvePreparationBuildMaxAttempts(options.verifiableContextConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolvePreparationBuildMaxLoops(options.verifiableContextConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
     const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
     const loopEnabled = maxAttempts != null;
-    const checks = options.compiledConfig?.checks ?? [];
+    const checks = options.verifiableContextConfig?.checks ?? [];
     if (loopEnabled && checks.length === 0) {
         console.log(chalk.yellow("  Retry and self-improving modes need saved readiness checks. Building once without those loops."));
     }
     else if (loopEnabled) {
         if (maxAttempts > 1) {
-            console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf will rerun the same Method variation, check the Portable Context agents can use, and stop early if it passes."));
+            console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} build attempts.`));
+            console.log(chalk.dim("  Interf will rerun the same Build Plan variation, check the verifiable context agents can use, and stop early if it passes."));
         }
         else {
-            console.log(chalk.dim("  Compile mode: 1 attempt per Method variation."));
+            console.log(chalk.dim("  Build mode: 1 attempt per Build Plan variation."));
         }
         if (maxLoops != null) {
-            console.log(chalk.dim(`  Method improvement: up to ${maxLoops} Method edits after retries fail.`));
-            console.log(chalk.dim("  Interf will review failed runs, edit the Build Plan, and test new Method variations."));
+            console.log(chalk.dim(`  Build Plan improvement: up to ${maxLoops} Build Plan edits after retries fail.`));
+            console.log(chalk.dim("  Interf will review failed runs, edit the Build Plan, and test new Build Plan variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {
-        const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
+        const result = await buildVerifiableContextWithReporter(options.executor, options.verifiableContextPath, {
             preserveStageShells,
             runId: options.runId,
             events: options.events,
@@ -338,15 +338,15 @@ export async function runConfiguredCompiledCompile(options) {
         });
         if (!result.ok) {
             process.exitCode = 1;
-            printCompileFailure(options.compiledPath, result.failedStage);
-            printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
+            printBuildFailure(options.verifiableContextPath, result.failedStage);
+            printStageShellReviewHint(options.verifiableContextPath, preserveStageShells, "failure");
             return false;
         }
-        printStageShellReviewHint(options.compiledPath, preserveStageShells, "success");
-        printPostCompileNextStep({
-            compiledPath: options.compiledPath,
+        printStageShellReviewHint(options.verifiableContextPath, preserveStageShells, "success");
+        printPostBuildNextStep({
+            verifiableContextPath: options.verifiableContextPath,
             checks: checks.length,
-            testedDuringCompile: false,
+            testedDuringBuild: false,
         });
         return true;
     }
@@ -357,10 +357,10 @@ export async function runConfiguredCompiledCompile(options) {
     const previousVariations = [];
     const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
     try {
-        const compiledConfig = options.compiledConfig
-            ?? loadCompiledPreparationConfig(options.compiledPath)
+        const verifiableContextConfig = options.verifiableContextConfig
+            ?? loadVerifiableContextPreparationConfig(options.verifiableContextPath)
             ?? {
-                name: readInterfConfig(options.compiledPath)?.name ?? "preparation",
+                name: readInterfConfig(options.verifiableContextPath)?.name ?? "preparation",
                 path: "./source-folder",
                 checks: [],
             };
@@ -380,17 +380,17 @@ export async function runConfiguredCompiledCompile(options) {
                 result.bestSnapshotPath = null;
             }
         };
-        const baseline = await runMethodVariation({
+        const baseline = await runBuildPlanVariation({
             executor: options.executor,
             testExecutor: options.testExecutor,
             resolveStageExecutor: options.resolveStageExecutor,
-            compiledPath: options.compiledPath,
+            verifiableContextPath: options.verifiableContextPath,
             sourcePath: options.sourcePath,
-            compiledConfig,
+            verifiableContextConfig,
             executionProfile: options.executionProfile,
             preserveStageShells,
             maxAttempts,
-            variationLabel: "baseline Method",
+            variationLabel: "baseline Build Plan",
             runId: options.runId,
             events: options.events,
         });
@@ -400,37 +400,37 @@ export async function runConfiguredCompiledCompile(options) {
             return false;
         }
         adoptVariationBest(1, baseline);
-        previousVariations.push(summarizeMethodVariation({
+        previousVariations.push(summarizeBuildPlanVariation({
             variation: 1,
             kind: "baseline",
             result: baseline,
             defaultTotalChecks: checks.length,
         }));
         if (baseline.passed) {
-            printMethodVariationSummary(previousVariations);
-            printPostCompileNextStep({
-                compiledPath: options.compiledPath,
+            printBuildPlanVariationSummary(previousVariations);
+            printPostBuildNextStep({
+                verifiableContextPath: options.verifiableContextPath,
                 checks: checks.length,
-                testedDuringCompile: true,
+                testedDuringBuild: true,
             });
             return true;
         }
         if (maxLoops != null) {
             for (let loopIndex = 1; loopIndex <= maxLoops; loopIndex += 1) {
                 console.log();
-                console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the Method.`));
-                const improvement = await runMethodImprovementLoop({
+                console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the Build Plan.`));
+                const improvement = await runBuildPlanImprovementLoop({
                     executor: options.executor,
-                    compiledPath: options.compiledPath,
-                    methodId: resolveRequiredCompiledMethodFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
-                    compiledConfig,
+                    verifiableContextPath: options.verifiableContextPath,
+                    buildPlanId: resolveRequiredBuildPlanFromConfig(readInterfConfig(options.verifiableContextPath), `.interf/interf.json for ${options.verifiableContextPath}`),
+                    verifiableContextConfig,
                     runId: improvementRunId,
                     loopIndex,
                     maxLoops,
                     maxAttempts,
                     previousVariations,
                 });
-                console.log(chalk.dim(`  Method improvement shell: ${improvement.shellPath}`));
+                console.log(chalk.dim(`  Build Plan improvement shell: ${improvement.shellPath}`));
                 if (improvement.status === "executor-failed") {
                     process.exitCode = 1;
                     console.log(chalk.red(`  ${improvement.summary}`));
@@ -440,17 +440,17 @@ export async function runConfiguredCompiledCompile(options) {
                     console.log(chalk.yellow(`  ${improvement.summary}`));
                     continue;
                 }
-                const variation = await runMethodVariation({
+                const variation = await runBuildPlanVariation({
                     executor: options.executor,
                     testExecutor: options.testExecutor,
                     resolveStageExecutor: options.resolveStageExecutor,
-                    compiledPath: options.compiledPath,
+                    verifiableContextPath: options.verifiableContextPath,
                     sourcePath: options.sourcePath,
-                    compiledConfig,
+                    verifiableContextConfig,
                     executionProfile: options.executionProfile,
                     preserveStageShells,
                     maxAttempts,
-                    variationLabel: `Method variation ${loopIndex + 1}`,
+                    variationLabel: `Build Plan variation ${loopIndex + 1}`,
                     runId: options.runId,
                     events: options.events,
                 });
@@ -460,43 +460,43 @@ export async function runConfiguredCompiledCompile(options) {
                     return false;
                 }
                 adoptVariationBest(loopIndex + 1, variation);
-                previousVariations.push(summarizeMethodVariation({
+                previousVariations.push(summarizeBuildPlanVariation({
                     variation: loopIndex + 1,
                     kind: "edited",
                     result: variation,
                     defaultTotalChecks: checks.length,
                 }));
                 if (variation.passed) {
-                    printMethodVariationSummary(previousVariations);
-                    printCompiledLocalMethodOwnership(options.compiledPath, bestVariation);
-                    printPostCompileNextStep({
-                        compiledPath: options.compiledPath,
+                    printBuildPlanVariationSummary(previousVariations);
+                    printSelectedBuildPlanOwnership(options.verifiableContextPath, bestVariation);
+                    printPostBuildNextStep({
+                        verifiableContextPath: options.verifiableContextPath,
                         checks: checks.length,
-                        testedDuringCompile: true,
+                        testedDuringBuild: true,
                     });
                     return true;
                 }
             }
         }
         if (bestSnapshotPath && bestVariation > 0) {
-            restoreCompiledBestState(bestSnapshotPath, options.compiledPath);
+            restoreBestBuildState(bestSnapshotPath, options.verifiableContextPath);
             console.log();
-            console.log(chalk.dim(`  Restored the best-performing Portable Context from variation ${bestVariation}, attempt ${bestAttempt}.`));
+            console.log(chalk.dim(`  Restored the best-performing verifiable context from variation ${bestVariation}, attempt ${bestAttempt}.`));
         }
         process.exitCode = 1;
         console.log();
-        printMethodVariationSummary(previousVariations);
-        printCompiledLocalMethodOwnership(options.compiledPath, bestVariation);
+        printBuildPlanVariationSummary(previousVariations);
+        printSelectedBuildPlanOwnership(options.verifiableContextPath, bestVariation);
         if (maxLoops != null) {
-            console.log(chalk.red(`  Portable Context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} Method-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Verifiable context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} Build Plan improvement loop${maxLoops === 1 ? "" : "s"}.`));
         }
         else {
-            console.log(chalk.red(`  Portable Context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Verifiable context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
             console.log(chalk.dim(`  Best attempt readiness-check pass rate: ${readinessPassRate(bestOutcome)}%.`));
         }
-        printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
+        printStageShellReviewHint(options.verifiableContextPath, preserveStageShells, "failure");
         return false;
     }
     finally {
@@ -533,7 +533,7 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 executor: resolved.executor,
             });
         },
-        async createCompileRun(request, context) {
+        async createBuildRun(request, context) {
             const executor = resolveHandlerExecutor(options.executor);
             const testExecutor = resolveHandlerExecutor(options.testExecutor ?? options.executor);
             const registry = loadAgentsRegistry();
@@ -543,7 +543,7 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 activeAgent: registry.activeAgent,
                 defaultExecutor: executor,
             });
-            const ok = await runConfiguredCompiledCompile({
+            const ok = await runConfiguredBuild({
                 executor,
                 testExecutor,
                 resolveStageExecutor(stage) {
@@ -568,9 +568,9 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                     }
                     return stageExecutor;
                 },
-                compiledPath: context.compiledPath,
+                verifiableContextPath: context.verifiableContextPath,
                 sourcePath: context.sourcePath,
-                compiledConfig: context.preparationConfig,
+                verifiableContextConfig: context.preparationConfig,
                 maxAttemptsOverride: request.max_attempts ?? null,
                 maxLoopsOverride: request.max_loops ?? null,
                 preserveStageShells: request.preserve_stage_shells,
@@ -589,24 +589,24 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 defaultExecutor: fallbackExecutor,
             });
             // Verify runs always use the `verifier` role. We resolve here
-            // for symmetry with compile runs — verify-run events are not
+            // for symmetry with Build runs — verify-run events are not
             // streamed in 0.15, so the resolution shows up only in the
             // executor field on the saved test run record.
             const { executor } = bundle.resolveExecutorForRole("verifier");
             const result = await runReadinessChecksForExecutor({
                 sourcePath: context.sourcePath,
                 preparationConfig: context.preparationConfig,
-                portableContextPath: context.compiledPath,
+                verifiableContextPath: context.verifiableContextPath,
                 executor,
                 target: request.target,
             });
             const outcome = request.target === "source-files"
                 ? result.sourceFilesOutcome
-                : result.compiledOutcome;
+                : result.verifiableContextOutcome;
             if (!outcome) {
                 const targetLabel = request.target === "source-files"
                     ? "Source files"
-                    : "Portable Context";
+                    : "Verifiable context";
                 return {
                     ok: false,
                     readiness_run: result.readinessRun,
@@ -644,18 +644,18 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 checks: drafted.checks,
             };
         },
-        async createMethodAuthoringRun(request, context) {
+        async createBuildPlanAuthoringRun(request, context) {
             const executor = resolveHandlerExecutor(options.executor);
             context.emit({
                 type: "log.appended",
                 step_id: "draft-package",
-                message: `Using ${executor.displayName} for Method authoring.`,
+                message: `Using ${executor.displayName} for Build Plan authoring.`,
             });
-            const result = await runMethodAuthoringDraft({
+            const result = await runBuildPlanAuthoringDraft({
                 prepDataDir: context.sourcePath,
                 sourceFolderPath: request.source_folder_path,
-                baseMethodId: request.reference_method_id ?? request.base_method_id,
-                methodId: request.method_id,
+                baseBuildPlanId: request.reference_build_plan_id ?? request.base_build_plan_id,
+                buildPlanId: request.build_plan_id,
                 label: request.label,
                 hint: request.hint,
                 taskPrompt: request.task_prompt,
@@ -675,7 +675,7 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 changed: result.changed,
                 summary: result.summary,
                 validation: result.validation,
-                method_path: result.methodPath,
+                build_plan_path: result.buildPlanPath,
                 shell_path: result.shellPath,
             };
         },