@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/engine/runtime.js

@@ -1,49 +1,49 @@
 import { existsSync, mkdirSync, rmSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { CompileRunSchema, } from "./execution/lib/schema.js";
+import { BuildRunSchema, } from "./execution/lib/schema.js";
 import { createRunEventId, createRunEventTimestamp, } from "./execution/events.js";
-import { loadState, } from "./compile/state.js";
-import { actionProposalPath, actionProposalsRoot, byCreatedAtDesc, compileRunPath, compileRunsRoot, listJsonFiles, localJobPath, localJobsRoot, newestFirst, readActionProposalAt, readCompileRunAt, readLocalJobRunAt, readRuntimeRunHistory, readVerifyRunAt, verifyRunPath, verifyRunsRoot, timestampKey, writeJsonFile, } from "./runtime-persistence.js";
-import { MethodListingCache, MtimeListingCache, ReadinessCache, RunListingCache, } from "./runtime-caches.js";
-import { applyEventToCompileRun, applyEventToLocalJob, } from "./runtime-event-applier.js";
-import { buildMethodResource, buildPreparationResource, createRunId, logsForRuntimeRun, logsForStageRun, proofForStage, readinessStateToPreparationReadiness, readinessSummaryForStatus, readinessTargetResult, stageArtifactRefs, } from "./runtime-resource-builders.js";
-import { ACTION_PLANNER_CLARIFICATION_MESSAGE, actionAssistantMessage, actionCommandPreview, actionTypeFromValues, actionValueMethodTaskPrompt, configuredAgentName, createActionProposalId, detachMethodFromPreparation, detectedExecutorOptions, directServiceEndpointForAction, hasCompiledTestTarget, methodAuthoringHintFromPrompt, methodAuthoringPromptFallback, methodIdForProposal, methodLabelFromId, numberValue, requireSelectedMethod, sanitizeActionProposalPlan, stringValue, testModeFromValues, } from "./runtime-proposal-helpers.js";
+import { loadState, } from "./build/state.js";
+import { actionProposalPath, actionProposalsRoot, byCreatedAtDesc, buildRunPath, buildRunsRoot, listJsonFiles, localJobPath, localJobsRoot, newestFirst, readActionProposalAt, readBuildRunAt, readLocalJobRunAt, readRuntimeRunHistory, readVerifyRunAt, verifyRunPath, verifyRunsRoot, timestampKey, writeJsonFile, } from "./runtime-persistence.js";
+import { BuildPlanListingCache, MtimeListingCache, ReadinessCache, RunListingCache, } from "./runtime-caches.js";
+import { applyEventToBuildRun, applyEventToLocalJob, } from "./runtime-event-applier.js";
+import { buildBuildPlanResource, buildPreparationResource, createRunId, logsForRuntimeRun, logsForStageRun, proofForStage, readinessStateToPreparationReadiness, readinessSummaryForStatus, readinessTargetResult, stageArtifactRefs, } from "./runtime-resource-builders.js";
+import { ACTION_PLANNER_CLARIFICATION_MESSAGE, actionAssistantMessage, actionCommandPreview, actionTypeFromValues, actionValueBuildPlanTaskPrompt, configuredAgentName, createActionProposalId, detachBuildPlanFromPreparation, detectedExecutorOptions, directServiceEndpointForAction, hasVerifiableContextTestTarget, buildPlanAuthoringHintFromPrompt, buildPlanAuthoringPromptFallback, buildPlanIdForProposal, buildPlanLabelFromId, numberValue, requireSelectedBuildPlan, sanitizeActionProposalPlan, stringValue, testModeFromValues, } from "./runtime-proposal-helpers.js";
 import { ReadinessSchema, } from "../contracts/lib/schema.js";
-import { discoverSourceFiles, } from "./compile/discovery.js";
-import { resetCompiledGeneratedState, } from "./compile/reset.js";
-import { ensurePortableContextScaffold, readInterfConfig, } from "../project/interf.js";
-import { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePreparationConfigs, loadSourceFolderConfig, DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, removeSourcePreparationConfig, saveSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../project/source-config.js";
+import { discoverSourceFiles, } from "./build/discovery.js";
+import { resetBuildGeneratedState, } from "./build/reset.js";
+import { ensureVerifiableContextScaffold, readInterfConfig, } from "../project/interf.js";
+import { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePreparationConfigs, loadSourceFolderConfig, DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, removeSourcePreparationConfig, saveSourceFolderConfig, syncVerifiableContextInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../project/source-config.js";
 import { listSourceFolderChoices, } from "../project/source-folders.js";
-import { asPreparationDataDir, preparationPortableContextPath, userMethodsRoot, preparationConfigPath, preparationMethodPackagePath, preparationMethodsRoot, } from "../contracts/lib/preparation-paths.js";
-import { getCompiledMethod, listCompiledMethodChoices, } from "../methods/package/method-definitions.js";
-import { aggregateArtifactVerdict, computeArtifactStatuses, } from "./compile/artifact-status.js";
-import { JsonlBillingEventSink, buildCompilationEventsForRun, defaultBillingEventLogPath, } from "./compile/billing-events.js";
-import { methodDefinitionPath, resolveMethodPackageSourcePath, } from "../methods/package/local-methods.js";
-import { seedLocalMethodPackageFromBase, } from "../methods/package/interf-method-package.js";
-import { PACKAGE_ROOT } from "../methods/package/lib/package-root.js";
+import { asPreparationDataDir, preparationVerifiableContextPath, userBuildPlansRoot, preparationConfigPath, preparationBuildPlanPackagePath, preparationBuildPlansRoot, } from "../contracts/lib/preparation-paths.js";
+import { getBuildPlan, listBuildPlanChoices, } from "../build-plans/package/build-plan-definitions.js";
+import { aggregateArtifactVerdict, computeArtifactStatuses, } from "./build/artifact-status.js";
+import { JsonlBillingEventSink, buildCompilationEventsForRun, defaultBillingEventLogPath, } from "./build/billing-events.js";
+import { buildPlanDefinitionPath, resolveBuildPlanPackageSourcePath, } from "../build-plans/package/local-build-plans.js";
+import { seedLocalBuildPlanPackageFromBase, } from "../build-plans/package/interf-build-plan-package.js";
+import { PACKAGE_ROOT } from "../build-plans/package/lib/package-root.js";
 import { resolveAgent, detectAgents, supportsAutomatedRuns, } from "./agents/lib/detection.js";
 import { loadUserConfig, saveUserConfig, } from "./agents/lib/user-config.js";
 import { loadAgentsRegistry, registerCustomAgent, unregisterCustomAgent, patchRoleMap, setActiveAgent, } from "./agents/registry.js";
 import { readSavedReadinessCheckRun, } from "./verify/readiness-check-run.js";
-import { createCompiledTestTarget, } from "./verify/verify-targets.js";
-import { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalTypeSchema, CompileRunCreateRequestSchema, CompileRunResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, PortableContextResourceSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, ServiceRegistryWorkspaceSchema, VerifyRunCreateRequestSchema, VerifyRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
+import { createVerifiableContextTestTarget, } from "./verify/verify-targets.js";
+import { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalTypeSchema, BuildRunCreateRequestSchema, BuildRunResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, VerifiableContextResourceSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, BuildPlanChangeCreateRequestSchema, BuildPlanChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, VerifyRunCreateRequestSchema, VerifyRunResourceSchema, BuildPlanAuthoringCreateRequestSchema, BuildPlanAuthoringResultSchema, } from "./lib/schema.js";
 import { buildLocalServiceUrl, } from "./routes.js";
-import { MethodAuthoringActionValuesSchema, PreparationSetupActionValuesSchema, } from "./action-values.js";
-import { compileRunToObservability, jobRunToObservability, verifyRunToObservability, uniqueArtifacts, } from "./run-observability.js";
+import { BuildPlanAuthoringActionValuesSchema, PreparationSetupActionValuesSchema, } from "./action-values.js";
+import { buildRunToObservability, jobRunToObservability, verifyRunToObservability, uniqueArtifacts, } from "./run-observability.js";
 import { artifactRequirementsFromRequestedArtifacts } from "./requested-artifacts.js";
-/** TTL for `POST /v1/compile-runs` idempotency-key dedupe entries. */
+/** TTL for `POS../../build-runs` idempotency-key dedupe entries. */
 const IDEMPOTENCY_TTL_MS = 60 * 60 * 1000;
 /** Idempotency cache size at which to schedule an opportunistic prune. */
 const IDEMPOTENCY_PRUNE_THRESHOLD = 64;
-const INTERRUPTED_COMPILE_RUN_MESSAGE = "Compile run interrupted because the Interf engine stopped before the run reached a terminal state.";
+const INTERRUPTED_COMPILE_RUN_MESSAGE = "Build run interrupted because the Interf engine stopped before the run reached a terminal state.";
 const INTERRUPTED_JOB_RUN_MESSAGE = "Job interrupted because the Interf engine stopped before the job reached a terminal state.";
-function isTerminalCompileRunStatus(status) {
+function isTerminalBuildRunStatus(status) {
     return status === "succeeded" || status === "failed" || status === "cancelled";
 }
 function isTerminalJobStatus(status) {
     return status === "succeeded" || status === "failed" || status === "cancelled";
 }
-function countsFromCompiledState(state) {
+function countsFromVerifiableContextState(state) {
     const counts = {};
     for (const stage of Object.values(state.stages ?? {})) {
         for (const [key, value] of Object.entries(stage.counts ?? {})) {
@@ -66,8 +66,8 @@ export class LocalServiceRuntime {
     /**
      * The seed root path the runtime was constructed with. Used as a
      * non-preparation fallback when a preparation-independent route
-     * (methods, action proposals, runs listings) needs an anchor to load
-     * shared state (user-library methods, bundled methods, etc).
+     * (Build Plans, action proposals, runs listings) needs an anchor to load
+     * shared state (user-library Build Plans, bundled Build Plans, etc).
      */
     rootPath;
     /**
@@ -82,8 +82,8 @@ export class LocalServiceRuntime {
     /** In-flight runs across all preparations. Used for `idle_for_seconds`. */
     activeRunCount = 0;
     /**
-     * Active compile-run cancellation handles, keyed by run id. Populated
-     * when a compile run is launched and cleared once the run reaches a
+     * Active Build run cancellation handles, keyed by run id. Populated
+     * when a Build run is launched and cleared once the run reaches a
      * terminal state. Each entry remembers where the persisted record lives
      * so cancel can mark it without re-resolving the Preparation.
      *
@@ -92,9 +92,9 @@ export class LocalServiceRuntime {
      * need a shared lease store so a replica can take over a run whose
      * owning replica died.
      */
-    activeCompileRuns = new Map();
+    activeBuildRuns = new Map();
     /**
-     * Idempotency-key cache for `POST /v1/compile-runs`. Outer key is the
+     * Idempotency-key cache for `POS../../build-runs`. Outer key is the
      * resolved preparation root; inner key is the client-supplied idempotency
      * value. Namespacing per preparation prevents key collisions across
      * tenants on the same engine (CSO finding: a malicious preparation could
@@ -108,17 +108,17 @@ export class LocalServiceRuntime {
      */
     idempotencyKeyCache = new Map();
     /**
-     * Read-side caches. Polling clients (Compiler UI, CLI status loops)
+     * Read-side caches. Polling clients (Interf UI, CLI status loops)
      * hit list/get endpoints multiple times per second; without these,
      * every request re-walks the filesystem and re-parses every JSON
      * record through Zod. The runtime invalidates each cache on the
      * matching write path. See {@link runtime-caches} for design notes.
      */
-    compileRunCache = new RunListingCache();
+    buildRunCache = new RunListingCache();
     verifyRunCache = new RunListingCache();
     readinessCache = new ReadinessCache();
     sourceFilesCache = new MtimeListingCache();
-    methodListingCache = new MethodListingCache();
+    buildPlanListingCache = new BuildPlanListingCache();
     /**
      * 0.17 — sink for per-Artifact billing events. Set once at construction.
      * Lazy-defaults to a per-run JSONL writer when no override was injected.
@@ -149,7 +149,7 @@ export class LocalServiceRuntime {
         // Auto-register the initial preparation so single-preparation callers
         // (existing tests, the current `interf web` command) work without
         // additional bootstrapping. The constructor seed is the only role
-        // `options.rootPath` plays; runtime methods take `prepDataDir`
+        // `options.rootPath` plays; runtime operations take `prepDataDir`
         // explicitly afterwards.
         this.registerPreparation(this.rootPath);
     }
@@ -191,7 +191,7 @@ export class LocalServiceRuntime {
             lastActivity: now,
         };
         this.preparationContexts.set(resolved, context);
-        this.finalizeInterruptedCompileRuns(resolved);
+        this.finalizeInterruptedBuildRuns(resolved);
         this.finalizeInterruptedJobRuns(resolved);
         this.onRegistryChanged?.();
         return context;
@@ -268,20 +268,6 @@ export class LocalServiceRuntime {
             context.lastActivity = new Date().toISOString();
         }
     }
-    /**
-     * Snapshot of registered preparations for the registry / status output.
-     * Wire shape (`ServiceRegistryWorkspace`) keeps the legacy
-     * "workspace" name for backward compatibility with the public health
-     * response and `~/.interf/services.json`. Synthetic-workspace bridge
-     * code; do not rename without coordinating an API break.
-     */
-    registeredPreparationSnapshots() {
-        return this.listRegisteredPreparations().map((context) => ServiceRegistryWorkspaceSchema.parse({
-            control_path: context.rootPath,
-            registered_at: context.startedAt,
-            last_activity: context.lastActivity,
-        }));
-    }
     /** Seconds since the most recent preparation activity (0 if active). */
     idleForSeconds() {
         const all = this.listRegisteredPreparations();
@@ -314,7 +300,6 @@ export class LocalServiceRuntime {
             started_at: this.startedAt,
             ...(this.packageVersion ? { package_version: this.packageVersion } : {}),
             instance_started_at: this.startedAt,
-            registered_workspaces: this.registeredPreparationSnapshots(),
             active_runs: this.activeRunCount,
             idle_for_seconds: this.idleForSeconds(),
         });
@@ -322,14 +307,14 @@ export class LocalServiceRuntime {
     listPreparations(prepDataDir) {
         const config = loadSourceFolderConfig(prepDataDir);
         return listSourcePreparationConfigs(config).map((preparation) => {
-            const compileRuns = this.listCompileRunsForPreparation(prepDataDir, preparation.name);
+            const buildRuns = this.listBuildRunsForPreparation(prepDataDir, preparation.name);
             const verifyRuns = this.listVerifyRunsForPreparation(prepDataDir, preparation.name);
             const readiness = this.computePreparationReadiness(prepDataDir, preparation);
-            return buildPreparationResource(prepDataDir, preparation, readiness, compileRuns[0]?.run_id ?? null, verifyRuns[0]?.run_id ?? null, 
-            // 0.17 — surface per-Artifact status from the latest compile
+            return buildPreparationResource(prepDataDir, preparation, readiness, buildRuns[0]?.run_id ?? null, verifyRuns[0]?.run_id ?? null, 
+            // 0.17 — surface per-Artifact status from the latest build
             // run so the UI can render artifact rows on the Preparation
             // page without a separate fetch.
-            compileRuns[0]?.artifacts ?? []);
+            buildRuns[0]?.artifacts ?? []);
         });
     }
     getPreparation(prepDataDir, preparationName) {
@@ -355,14 +340,14 @@ export class LocalServiceRuntime {
     }
     computePreparationReadinessUncached(prepDataDir, preparation) {
         const generatedAt = new Date().toISOString();
-        const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
-        const contextExists = existsSync(compiledPath);
-        const compiledTarget = createCompiledTestTarget(compiledPath, preparation.name, methodIdForSourcePreparationConfig(preparation) ?? DEFAULT_METHOD_ID);
-        const contextReady = compiledTarget.eligible;
-        const compileRun = this.listCompileRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
+        const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
+        const contextExists = existsSync(verifiableContextPath);
+        const verifiableContextTarget = createVerifiableContextTestTarget(verifiableContextPath, preparation.name, buildPlanIdForSourcePreparationConfig(preparation) ?? DEFAULT_BUILD_PLAN_ID);
+        const contextReady = verifiableContextTarget.eligible;
+        const buildRun = this.listBuildRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
         const verifyRun = this.listVerifyRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
         const readinessRun = this.readLatestReadinessRun(prepDataDir, preparation.name);
-        const artifactStatuses = compileRun?.artifacts ?? [];
+        const artifactStatuses = buildRun?.artifacts ?? [];
         const hasArtifactContract = artifactStatuses.length > 0;
         const artifactVerdict = aggregateArtifactVerdict(artifactStatuses);
         const artifactFailures = artifactStatuses.filter((artifact) => artifact.status !== "ready");
@@ -373,49 +358,49 @@ export class LocalServiceRuntime {
         const currentFingerprint = configuredChecks > 0 ? fingerprintReadinessChecks(preparation.checks) : null;
         const readinessRunFingerprint = readinessRun?.checks_fingerprint ?? null;
         const sourceResult = readinessTargetResult(readinessRun?.source_files, currentFingerprint, readinessRunFingerprint);
-        const contextResult = readinessTargetResult(readinessRun?.compiled, currentFingerprint, readinessRunFingerprint);
+        const contextResult = readinessTargetResult(readinessRun?.verifiable_context, currentFingerprint, readinessRunFingerprint);
         const checksStale = Boolean(currentFingerprint && readinessRunFingerprint && currentFingerprint !== readinessRunFingerprint);
-        const compileCheck = (() => {
-            if (!compileRun) {
+        const buildCheck = (() => {
+            if (!buildRun) {
                 return {
-                    gate: "compile-run",
+                    gate: "build-run",
                     ok: false,
                     status: "not-built",
-                    summary: "No compile run has built portable context yet.",
-                    artifact_path: contextReady ? compiledPath : null,
+                    summary: "No Build run has built verifiable context yet.",
+                    artifact_path: contextReady ? verifiableContextPath : null,
                 };
             }
-            if (compileRun.status === "succeeded") {
+            if (buildRun.status === "succeeded") {
                 return {
-                    gate: "compile-run",
+                    gate: "build-run",
                     ok: contextReady,
                     status: contextReady ? "built" : "failed",
                     summary: contextReady
-                        ? "Latest compile run built portable context."
-                        : "Latest compile run finished, but portable context is missing.",
-                    run_id: compileRun.run_id,
-                    artifact_path: contextReady ? compiledPath : null,
+                        ? "Latest Build run built verifiable context."
+                        : "Latest Build run finished, but verifiable context is missing.",
+                    run_id: buildRun.run_id,
+                    artifact_path: contextReady ? verifiableContextPath : null,
                 };
             }
-            if (compileRun.status === "queued" || compileRun.status === "running") {
+            if (buildRun.status === "queued" || buildRun.status === "running") {
                 return {
-                    gate: "compile-run",
+                    gate: "build-run",
                     ok: false,
                     status: "building",
-                    summary: "Latest compile run is still building portable context.",
-                    run_id: compileRun.run_id,
-                    artifact_path: contextExists ? compiledPath : null,
+                    summary: "Latest Build run is still building verifiable context.",
+                    run_id: buildRun.run_id,
+                    artifact_path: contextExists ? verifiableContextPath : null,
                 };
             }
             return {
-                gate: "compile-run",
+                gate: "build-run",
                 ok: false,
                 status: "failed",
-                summary: compileRun.status === "cancelled"
-                    ? "Latest compile run was cancelled."
-                    : "Latest compile run failed.",
-                run_id: compileRun.run_id,
-                artifact_path: contextReady ? compiledPath : null,
+                summary: buildRun.status === "cancelled"
+                    ? "Latest Build run was cancelled."
+                    : "Latest Build run failed.",
+                run_id: buildRun.run_id,
+                artifact_path: contextReady ? verifiableContextPath : null,
             };
         })();
         const checks = [
@@ -425,15 +410,15 @@ export class LocalServiceRuntime {
                 summary: "Preparation is saved in this control plane folder.",
             },
             {
-                gate: "portable-context",
+                gate: "verifiable-context",
                 ok: contextReady,
                 status: contextReady ? "built" : "not-built",
                 summary: contextReady
-                    ? "Portable context is built."
-                    : "Portable context has not been built.",
-                artifact_path: contextReady ? compiledPath : null,
+                    ? "Verifiable context is built."
+                    : "Verifiable context has not been built.",
+                artifact_path: contextReady ? verifiableContextPath : null,
             },
-            compileCheck,
+            buildCheck,
             {
                 gate: "artifact-checks",
                 ok: !hasArtifactContract || artifactVerdict === "ready",
@@ -464,13 +449,13 @@ export class LocalServiceRuntime {
             },
         ];
         const status = (() => {
-            if (compileRun?.status === "queued" || compileRun?.status === "running")
+            if (buildRun?.status === "queued" || buildRun?.status === "running")
                 return "building";
             if (verifyRun?.status === "queued" || verifyRun?.status === "running")
                 return "checking";
-            if (compileRun?.status === "failed" || compileRun?.status === "cancelled")
+            if (buildRun?.status === "failed" || buildRun?.status === "cancelled")
                 return "failed";
-            if (!compileRun || !contextReady)
+            if (!buildRun || !contextReady)
                 return "not-built";
             if (hasArtifactContract && artifactVerdict !== "ready")
                 return "not-ready";
@@ -491,15 +476,15 @@ export class LocalServiceRuntime {
             status,
             ready,
             summary: readinessSummaryForStatus(status),
-            portable_context_path: contextReady ? compiledPath : null,
-            latest_compile_run_id: compileRun?.run_id ?? null,
+            verifiable_context_path: contextReady ? verifiableContextPath : null,
+            latest_build_run_id: buildRun?.run_id ?? null,
             latest_test_run_id: verifyRun?.run_id ?? null,
-            compile: compileCheck,
+            build: buildCheck,
             check_results: {
                 configured: configuredChecks,
                 fingerprint: currentFingerprint,
                 source_files: sourceResult,
-                portable_context: contextResult,
+                verifiable_context: contextResult,
             },
             checks,
         });
@@ -510,19 +495,19 @@ export class LocalServiceRuntime {
             .filter((preparation) => !preparationName || preparation.name === preparationName);
         // 0.13+ source binding: the source folder is the user-supplied
         // absolute path on `source_folder.path`. `preparation.path` is the
-        // portable-context name inside `prepDataDir` (legacy field; in the
-        // synthetic-workspace bridge it equals `preparation.name`). Walk
-        // the actual source bytes, not the portable-context subdir.
+        // verifiable-context name inside `prepDataDir` (legacy field; in the
+        // current Preparation layout it equals `preparation.name`). Walk
+        // the actual source bytes, not the verifiable-context subdir.
         const sourceFolderPath = resolveConfiguredSourceFolderPath(prepDataDir, config) ?? prepDataDir;
         return preparations.flatMap((preparation) => {
-            const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
+            const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
             // Cache by source-folder root mtime so identical UI polls do not
             // re-walk and re-stat the entire tree. The cache imposes a short
             // TTL (see runtime-caches.ts) so deeper changes are still picked
             // up promptly.
-            const cacheKey = `${preparation.name}\0${sourceFolderPath}\0${compiledPath}`;
+            const cacheKey = `${preparation.name}\0${sourceFolderPath}\0${verifiableContextPath}`;
             return this.sourceFilesCache.get(cacheKey, sourceFolderPath, () => {
-                return discoverSourceFiles(sourceFolderPath, compiledPath).sourceFiles.map((relativePath) => {
+                return discoverSourceFiles(sourceFolderPath, verifiableContextPath).sourceFiles.map((relativePath) => {
                     const absolutePath = join(sourceFolderPath, relativePath);
                     let sizeBytes = 0;
                     let modifiedAt = null;
@@ -547,57 +532,34 @@ export class LocalServiceRuntime {
             });
         });
     }
-    listWorkspaceFiles(prepDataDir) {
-        const sourceFolderPath = resolveConfiguredSourceFolderPath(prepDataDir) ?? prepDataDir;
-        return discoverSourceFiles(sourceFolderPath, prepDataDir).sourceFiles.map((relativePath) => {
-            const absolutePath = join(sourceFolderPath, relativePath);
-            let sizeBytes = 0;
-            let modifiedAt = null;
-            try {
-                const stat = statSync(absolutePath);
-                sizeBytes = stat.size;
-                modifiedAt = stat.mtime.toISOString();
-            }
-            catch {
-                sizeBytes = 0;
-                modifiedAt = null;
-            }
-            return WorkspaceFileResourceSchema.parse({
-                path: relativePath,
-                absolute_path: absolutePath,
-                size_bytes: sizeBytes,
-                modified_at: modifiedAt,
-            });
-        });
-    }
-    listMethods(prepDataDir) {
-        // The Method choices list is dominated by repeated reads of
-        // method.json + context-interface across builtin / user / workspace
-        // method roots. Key the cache off mtimes for the three roots; if
-        // any of them changes (a new local Method, an edit to the user
+    listBuildPlans(prepDataDir) {
+        // The Build Plan choices list is dominated by repeated reads of
+        // build-plan.json + context-interface across bundled, user-library, and
+        // Preparation-local Build Plan package roots. Key the cache off mtimes; if
+        // any of them changes (a new local Build Plan, an edit to the user
         // library, etc.) the cache misses and we re-resolve.
-        const builtinRoot = join(PACKAGE_ROOT, "public-repo", "methods");
-        const localRoot = preparationMethodsRoot(asPreparationDataDir(prepDataDir));
-        const userRoot = userMethodsRoot();
-        return this.methodListingCache.get(prepDataDir, [builtinRoot, localRoot, userRoot], () => {
+        const builtinRoot = join(PACKAGE_ROOT, "public-repo", "build-plans");
+        const localRoot = preparationBuildPlansRoot(asPreparationDataDir(prepDataDir));
+        const userRoot = userBuildPlansRoot();
+        return this.buildPlanListingCache.get(prepDataDir, [builtinRoot, localRoot, userRoot], () => {
             const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
-            const choices = listCompiledMethodChoices(prepDataDir);
-            return choices.map((method) => {
+            const choices = listBuildPlanChoices(prepDataDir);
+            return choices.map((buildPlan) => {
                 const activeForPreparations = preparations
-                    .filter((preparation) => methodIdForSourcePreparationConfig(preparation) === method.id)
+                    .filter((preparation) => buildPlanIdForSourcePreparationConfig(preparation) === buildPlan.id)
                     .map((preparation) => preparation.name);
-                return buildMethodResource({
-                    id: method.id,
-                    path: resolveMethodPackageSourcePath(prepDataDir, method.id) ?? method.id,
-                    label: method.label,
-                    hint: method.hint,
-                    purpose: method.purpose,
-                    inputs: method.inputs,
-                    source_kind: method.scope === "builtin" ? "builtin" : "local",
-                    built_in: method.scope === "builtin",
+                return buildBuildPlanResource({
+                    id: buildPlan.id,
+                    path: resolveBuildPlanPackageSourcePath(prepDataDir, buildPlan.id) ?? buildPlan.id,
+                    label: buildPlan.label,
+                    hint: buildPlan.hint,
+                    purpose: buildPlan.purpose,
+                    inputs: buildPlan.inputs,
+                    source_kind: buildPlan.scope === "builtin" ? "builtin" : "local",
+                    built_in: buildPlan.scope === "builtin",
                     active_for_preparations: activeForPreparations,
-                    artifacts: method.contextInterface?.artifacts ?? [],
-                    stages: method.stages.map((stage) => ({
+                    artifacts: buildPlan.contextInterface?.artifacts ?? [],
+                    stages: buildPlan.stages.map((stage) => ({
                         id: stage.id,
                         label: stage.label,
                         description: stage.description,
@@ -611,8 +573,8 @@ export class LocalServiceRuntime {
             });
         });
     }
-    getMethod(prepDataDir, methodId) {
-        return this.listMethods(prepDataDir).find((method) => method.id === methodId) ?? null;
+    getBuildPlanResource(prepDataDir, buildPlanId) {
+        return this.listBuildPlans(prepDataDir).find((buildPlan) => buildPlan.id === buildPlanId) ?? null;
     }
     listJobs(prepDataDir) {
         return byCreatedAtDesc(listJsonFiles(localJobsRoot(prepDataDir))
@@ -797,7 +759,7 @@ export class LocalServiceRuntime {
     }
     listRunObservability(prepDataDir) {
         return [
-            ...this.listCompileRuns(prepDataDir).map((resource) => compileRunToObservability({
+            ...this.listBuildRuns(prepDataDir).map((resource) => buildRunToObservability({
                 ...resource.run,
                 readiness: this.getReadiness(prepDataDir, resource.run.preparation),
             })),
@@ -813,17 +775,17 @@ export class LocalServiceRuntime {
         return this.listRunObservability(prepDataDir).find((run) => run.run_id === runId) ?? null;
     }
     /**
-     * Method Activity runs: every method-authoring or method-improvement job
-     * whose `method` matches `methodId`. Surfaced through
-     * `GET /v1/methods/<id>/runs` so Method Detail can show the full audit
-     * trail of authoring + improvement work for a Method.
+     * Build Plan Activity runs: every Build Plan draft or improvement job whose
+     * Build Plan id matches `buildPlanId`. Surfaced through
+     * `GET /v1/build-plans/<id>/runs` so Build Plan detail can show the full
+     * audit trail of authoring + improvement work.
      */
-    listMethodRuns(prepDataDir, methodId) {
+    listBuildPlanRuns(prepDataDir, buildPlanId) {
         return this.listRunObservability(prepDataDir).filter((run) => {
-            if (run.method !== methodId)
+            if (run.build_plan !== buildPlanId)
                 return false;
-            return (run.run_type === "method-authoring" ||
-                run.run_type === "method-improvement");
+            return (run.run_type === "build-plan-draft" ||
+                run.run_type === "build-plan-improvement");
         });
     }
     createJobRun(prepDataDir, requestValue) {
@@ -838,7 +800,7 @@ export class LocalServiceRuntime {
             status: "running",
             title: request.title,
             ...(request.preparation !== undefined ? { preparation: request.preparation } : {}),
-            ...(request.method !== undefined ? { method: request.method } : {}),
+            ...(request.build_plan !== undefined ? { build_plan: request.build_plan } : {}),
             ...(request.source_path !== undefined ? { source_path: request.source_path } : {}),
             ...(request.output_path !== undefined ? { output_path: request.output_path } : {}),
             ...(request.agent !== undefined ? { agent: request.agent } : {}),
@@ -941,115 +903,116 @@ export class LocalServiceRuntime {
         void this.runReadinessCheckDraftInBackground(prepDataDir, request, job.run_id);
         return this.getJob(prepDataDir, job.run_id) ?? job;
     }
-    applyMethodChange(prepDataDir, requestValue) {
-        const request = MethodChangeCreateRequestSchema.parse(requestValue);
+    applyBuildPlanChange(prepDataDir, requestValue) {
+        const request = BuildPlanChangeCreateRequestSchema.parse(requestValue);
+        const buildPlanId = request.build_plan;
         const outputPath = request.operation === "duplicate"
-            ? methodDefinitionPath(prepDataDir, request.new_method_id)
-            : methodDefinitionPath(prepDataDir, request.method);
+            ? buildPlanDefinitionPath(prepDataDir, request.new_build_plan_id)
+            : buildPlanDefinitionPath(prepDataDir, buildPlanId);
         if (request.operation === "duplicate") {
-            if (resolveMethodPackageSourcePath(prepDataDir, request.new_method_id)) {
-                throw new Error(`Method "${request.new_method_id}" already exists.`);
+            if (resolveBuildPlanPackageSourcePath(prepDataDir, request.new_build_plan_id)) {
+                throw new Error(`Build Plan "${request.new_build_plan_id}" already exists.`);
             }
-            if (!resolveMethodPackageSourcePath(prepDataDir, request.method)) {
-                throw new Error(`Method "${request.method}" does not exist.`);
+            if (!resolveBuildPlanPackageSourcePath(prepDataDir, buildPlanId)) {
+                throw new Error(`Build Plan "${buildPlanId}" does not exist.`);
             }
-            const label = request.label ?? methodLabelFromId(request.new_method_id);
-            const hint = request.hint ?? `Duplicate of ${request.method}`;
-            const methodPath = seedLocalMethodPackageFromBase({
+            const label = request.label ?? buildPlanLabelFromId(request.new_build_plan_id);
+            const hint = request.hint ?? `Duplicate of ${buildPlanId}`;
+            const buildPlanPath = seedLocalBuildPlanPackageFromBase({
                 prepDataDir,
-                baseMethodId: request.method,
-                methodId: request.new_method_id,
+                baseBuildPlanId: buildPlanId,
+                buildPlanId: request.new_build_plan_id,
                 label,
                 hint,
             });
-            this.methodListingCache.invalidate(prepDataDir);
-            return MethodChangeResultSchema.parse({
-                kind: "interf-method-change-result",
+            this.buildPlanListingCache.invalidate(prepDataDir);
+            return BuildPlanChangeResultSchema.parse({
+                kind: "interf-build-plan-change-result",
                 version: 1,
                 operation: "duplicate",
-                method: request.method,
-                new_method_id: request.new_method_id,
+                build_plan: buildPlanId,
+                new_build_plan_id: request.new_build_plan_id,
                 updated_preparations: [],
-                method_path: methodPath,
+                build_plan_path: buildPlanPath,
                 changed: true,
-                message: `Duplicated Method ${request.method} as ${request.new_method_id}.`,
+                message: `Duplicated Build Plan ${buildPlanId} as ${request.new_build_plan_id}.`,
             });
         }
-        if (request.confirmation !== request.method) {
-            throw new Error(`Type ${request.method} to confirm Method removal.`);
+        if (request.confirmation !== buildPlanId) {
+            throw new Error(`Type ${buildPlanId} to confirm Build Plan removal.`);
         }
-        const localMethodPath = methodDefinitionPath(prepDataDir, request.method);
-        if (request.method === DEFAULT_METHOD_ID || !existsSync(localMethodPath)) {
-            throw new Error(`Method "${request.method}" is not a removable local Method.`);
+        const localBuildPlanPath = buildPlanDefinitionPath(prepDataDir, buildPlanId);
+        if (buildPlanId === DEFAULT_BUILD_PLAN_ID || !existsSync(localBuildPlanPath)) {
+            throw new Error(`Build Plan "${buildPlanId}" is not a removable local Build Plan.`);
         }
         const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
         const updatedPreparations = preparations
-            .filter((preparation) => methodIdForSourcePreparationConfig(preparation) === request.method);
+            .filter((preparation) => buildPlanIdForSourcePreparationConfig(preparation) === buildPlanId);
         if (updatedPreparations.length > 0) {
             saveSourceFolderConfig(prepDataDir, {
-                preparations: preparations.map((preparation) => detachMethodFromPreparation(preparation, request.method)),
+                preparations: preparations.map((preparation) => detachBuildPlanFromPreparation(preparation, buildPlanId)),
             });
-            // Detaching a Method changes readiness shape for those Preparations.
+            // Detaching a Build Plan changes readiness shape for those Preparations.
             for (const preparation of updatedPreparations) {
                 this.readinessCache.invalidatePreparation(prepDataDir, preparation.name);
             }
         }
         rmSync(outputPath, { recursive: true, force: true });
-        this.methodListingCache.invalidate(prepDataDir);
-        return MethodChangeResultSchema.parse({
-            kind: "interf-method-change-result",
+        this.buildPlanListingCache.invalidate(prepDataDir);
+        return BuildPlanChangeResultSchema.parse({
+            kind: "interf-build-plan-change-result",
             version: 1,
             operation: "remove",
-            method: request.method,
+            build_plan: buildPlanId,
             updated_preparations: updatedPreparations.map((preparation) => preparation.name),
-            method_path: outputPath,
+            build_plan_path: outputPath,
             changed: true,
             message: updatedPreparations.length > 0
-                ? `Removed Method ${request.method} and cleared it from ${updatedPreparations.length} Preparation(s).`
-                : `Removed Method ${request.method}.`,
+                ? `Removed Build Plan ${buildPlanId} and cleared it from ${updatedPreparations.length} Preparation(s).`
+                : `Removed Build Plan ${buildPlanId}.`,
         });
     }
     applyPreparationSetup(prepDataDir, requestValue) {
         const request = PreparationSetupCreateRequestSchema.parse(requestValue);
         const preparationConfig = request.preparation;
-        const methodId = methodIdForSourcePreparationConfig(preparationConfig);
-        if (request.setup_mode === "select-method" && !methodId) {
+        const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig);
+        if (request.setup_mode === "select-build-plan" && !buildPlanId) {
             throw new Error("Build Plan is required when selecting a Build Plan for a Preparation.");
         }
-        const normalizedPreparationConfig = methodId
-            ? { ...preparationConfig, method: methodId }
+        const normalizedPreparationConfig = buildPlanId
+            ? { ...preparationConfig, build_plan: buildPlanId }
             : (() => {
-                const { method: _method, ...withoutMethod } = preparationConfig;
-                return withoutMethod;
+                const { build_plan: _ignoredBuildPlan, ...withoutBuildPlan } = preparationConfig;
+                return withoutBuildPlan;
             })();
         const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, normalizedPreparationConfig);
         if (!existsSync(sourceFolderPath) || !statSync(sourceFolderPath).isDirectory()) {
             throw new Error(`Source folder "${preparationConfig.path}" is not available.`);
         }
         upsertSourcePreparationConfig(prepDataDir, normalizedPreparationConfig);
-        // The Preparation's bound source folder + Method may have changed:
-        // bust the per-preparation readiness, runs, and method-listing
+        // The Preparation's bound source folder + Build Plan may have changed:
+        // bust the per-preparation readiness, runs, and Build Plan listing
         // caches so the next read reflects the new shape.
         this.readinessCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
-        this.compileRunCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
+        this.buildRunCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
         this.verifyRunCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
-        this.methodListingCache.invalidate(prepDataDir);
-        const operation = request.setup_mode === "select-method" ? "select-method" : "create";
+        this.buildPlanListingCache.invalidate(prepDataDir);
+        const operation = request.setup_mode === "select-build-plan" ? "select-build-plan" : "create";
         return PreparationSetupResultSchema.parse({
             kind: "interf-preparation-setup-result",
             version: 1,
             operation,
             preparation: normalizedPreparationConfig.name,
-            method: methodId ?? null,
+            build_plan: buildPlanId ?? null,
             source_folder_path: sourceFolderPath,
             config_path: preparationConfigPath(asPreparationDataDir(prepDataDir)),
-            portable_context_path: preparationPortableContextPath(asPreparationDataDir(prepDataDir), normalizedPreparationConfig.name),
+            verifiable_context_path: preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), normalizedPreparationConfig.name),
             changed: true,
-            message: operation === "select-method"
-                ? `Preparation ${normalizedPreparationConfig.name} now uses Build Plan ${methodId}.`
-                : methodId
-                    ? `Preparation ${normalizedPreparationConfig.name} is saved with Build Plan ${methodId}.`
-                    : `Preparation ${normalizedPreparationConfig.name} is saved. Draft or select a Build Plan before compiling.`,
+            message: operation === "select-build-plan"
+                ? `Preparation ${normalizedPreparationConfig.name} now uses Build Plan ${buildPlanId}.`
+                : buildPlanId
+                    ? `Preparation ${normalizedPreparationConfig.name} is saved with Build Plan ${buildPlanId}.`
+                    : `Preparation ${normalizedPreparationConfig.name} is saved. Draft or select a Build Plan before building.`,
         });
     }
     applyPreparationChange(prepDataDir, requestValue) {
@@ -1063,19 +1026,19 @@ export class LocalServiceRuntime {
         }
         removeSourcePreparationConfig(prepDataDir, request.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, request.preparation);
-        this.compileRunCache.invalidatePreparation(prepDataDir, request.preparation);
+        this.buildRunCache.invalidatePreparation(prepDataDir, request.preparation);
         this.verifyRunCache.invalidatePreparation(prepDataDir, request.preparation);
-        this.methodListingCache.invalidate(prepDataDir);
+        this.buildPlanListingCache.invalidate(prepDataDir);
         return PreparationChangeResultSchema.parse({
             kind: "interf-preparation-change-result",
             version: 1,
             operation: "remove",
             preparation: request.preparation,
             config_path: preparationConfigPath(asPreparationDataDir(prepDataDir)),
-            portable_context_path: preparationPortableContextPath(asPreparationDataDir(prepDataDir), request.preparation),
-            portable_context_retained: true,
+            verifiable_context_path: preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), request.preparation),
+            verifiable_context_retained: true,
             changed: true,
-            message: `Removed Preparation ${request.preparation}. Portable Context files were retained.`,
+            message: `Removed Preparation ${request.preparation}. Verifiable context files were retained.`,
         });
     }
     applyReset(prepDataDir, requestValue) {
@@ -1084,13 +1047,13 @@ export class LocalServiceRuntime {
         if (!preparation) {
             throw new Error(`Preparation "${request.preparation}" is not saved.`);
         }
-        const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), request.preparation);
-        if (!existsSync(compiledPath)) {
-            throw new Error(`Portable Context for Preparation "${request.preparation}" does not exist.`);
+        const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), request.preparation);
+        if (!existsSync(verifiableContextPath)) {
+            throw new Error(`Verifiable context for Preparation "${request.preparation}" does not exist.`);
         }
-        resetCompiledGeneratedState(compiledPath, request.scope);
-        // Reset wipes generated state, including saved compile/test/readiness records.
-        this.compileRunCache.invalidatePreparation(prepDataDir, request.preparation);
+        resetBuildGeneratedState(verifiableContextPath, request.scope);
+        // Reset wipes generated state, including saved build/test/readiness records.
+        this.buildRunCache.invalidatePreparation(prepDataDir, request.preparation);
         this.verifyRunCache.invalidatePreparation(prepDataDir, request.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, request.preparation);
         return ResetResultSchema.parse({
@@ -1098,13 +1061,13 @@ export class LocalServiceRuntime {
             version: 1,
             preparation: request.preparation,
             scope: request.scope,
-            portable_context_path: compiledPath,
+            verifiable_context_path: verifiableContextPath,
             changed: true,
             message: `Reset ${request.scope} state for Preparation ${request.preparation}.`,
         });
     }
-    async createMethodAuthoringRun(prepDataDir, requestValue, jobType = "method-authoring") {
-        const parsedRequest = MethodAuthoringCreateRequestSchema.parse(requestValue);
+    async createBuildPlanAuthoringRun(prepDataDir, requestValue, jobType = "build-plan-draft") {
+        const parsedRequest = BuildPlanAuthoringCreateRequestSchema.parse(requestValue);
         const savedPreparation = parsedRequest.preparation
             ? findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), parsedRequest.preparation)
             : null;
@@ -1115,14 +1078,14 @@ export class LocalServiceRuntime {
                 : savedPreparation?.requested_artifacts ?? [],
             source_profile: parsedRequest.source_profile ?? savedPreparation?.source_profile ?? null,
         };
-        const isImprovement = jobType === "method-improvement";
+        const isImprovement = jobType === "build-plan-improvement";
         const job = this.createJobRun(prepDataDir, {
             job_type: jobType,
-            title: isImprovement ? `Improve Method ${request.method_id}` : `Draft Method ${request.method_id}`,
+            title: isImprovement ? `Improve Build Plan ${request.build_plan_id}` : `Draft Build Plan ${request.build_plan_id}`,
             preparation: request.preparation ?? null,
-            method: request.method_id,
+            build_plan: request.build_plan_id,
             source_path: request.source_folder_path,
-            output_path: preparationMethodPackagePath(asPreparationDataDir(prepDataDir), request.method_id),
+            output_path: preparationBuildPlanPackagePath(asPreparationDataDir(prepDataDir), request.build_plan_id),
             steps: [
                 {
                     id: "inspect-source",
@@ -1136,9 +1099,9 @@ export class LocalServiceRuntime {
                 },
                 {
                     id: "draft-package",
-                    label: isImprovement ? "Improve Method package" : "Draft Method package",
+                    label: isImprovement ? "Improve Build Plan definition" : "Draft Build Plan definition",
                     input: {
-                        method_id: request.method_id,
+                        build_plan_id: request.build_plan_id,
                         label: request.label,
                         task_prompt: request.task_prompt,
                         requested_artifacts: request.requested_artifacts.length,
@@ -1147,9 +1110,9 @@ export class LocalServiceRuntime {
                 },
                 {
                     id: "validate-package",
-                    label: "Validate Method package",
+                    label: "Validate Build Plan definition",
                     input: {
-                        method_id: request.method_id,
+                        build_plan_id: request.build_plan_id,
                     },
                 },
             ],
@@ -1157,7 +1120,7 @@ export class LocalServiceRuntime {
         this.appendJobRunEvent(prepDataDir, job.run_id, {
             type: "step.started",
             step_id: "inspect-source",
-            message: isImprovement ? "Inspecting source files for Method improvement." : "Inspecting source files for Method drafting.",
+            message: isImprovement ? "Inspecting source files for Build Plan improvement." : "Inspecting source files for Build Plan drafting.",
             input: {
                 preparation: request.preparation ?? null,
                 source_folder_path: request.source_folder_path,
@@ -1178,118 +1141,118 @@ export class LocalServiceRuntime {
         this.appendJobRunEvent(prepDataDir, job.run_id, {
             type: "step.started",
             step_id: "draft-package",
-            message: isImprovement ? "Improving Method package." : "Drafting Method package.",
+            message: isImprovement ? "Improving Build Plan definition." : "Drafting Build Plan definition.",
             input: {
-                method_id: request.method_id,
+                build_plan_id: request.build_plan_id,
                 label: request.label,
                 task_prompt: request.task_prompt,
                 requested_artifacts: request.requested_artifacts.length,
                 artifact_requirements: request.artifact_requirements.length,
             },
         });
-        void this.runMethodAuthoringInBackground(prepDataDir, request, job.run_id);
+        void this.runBuildPlanAuthoringInBackground(prepDataDir, request, job.run_id);
         return this.getJob(prepDataDir, job.run_id) ?? job;
     }
-    listPortableContexts(prepDataDir) {
+    listVerifiableContexts(prepDataDir) {
         return listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir))
-            .map((preparation) => this.getPortableContext(prepDataDir, preparation.name))
+            .map((preparation) => this.getVerifiableContext(prepDataDir, preparation.name))
             .filter((context) => context !== null);
     }
-    getPortableContext(prepDataDir, preparationName) {
+    getVerifiableContext(prepDataDir, preparationName) {
         const preparation = findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), preparationName);
         if (!preparation)
             return null;
-        const path = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
+        const path = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
         const config = readInterfConfig(path);
-        const compileRuns = this.listCompileRunsForPreparation(prepDataDir, preparation.name);
+        const buildRuns = this.listBuildRunsForPreparation(prepDataDir, preparation.name);
         const verifyRuns = this.listVerifyRunsForPreparation(prepDataDir, preparation.name);
         const readiness = this.computePreparationReadiness(prepDataDir, preparation);
-        const method = config?.method ?? methodIdForSourcePreparationConfig(preparation);
-        return PortableContextResourceSchema.parse({
+        const buildPlan = config?.build_plan ?? buildPlanIdForSourcePreparationConfig(preparation);
+        return VerifiableContextResourceSchema.parse({
             preparation: preparation.name,
             path,
             exists: existsSync(path),
             readiness,
-            method,
-            latest_compile_run_id: compileRuns[0]?.run_id ?? null,
+            build_plan: buildPlan,
+            latest_build_run_id: buildRuns[0]?.run_id ?? null,
             latest_test_run_id: verifyRuns[0]?.run_id ?? null,
-            artifacts: uniqueArtifacts(compileRuns[0]?.stages.flatMap((stage) => stage.artifacts) ?? []),
+            artifacts: uniqueArtifacts(buildRuns[0]?.stages.flatMap((stage) => stage.artifacts) ?? []),
         });
     }
-    listCompileRuns(prepDataDir) {
+    listBuildRuns(prepDataDir) {
         return byCreatedAtDesc(listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir))
-            .flatMap((preparation) => this.listCompileRunsForPreparation(prepDataDir, preparation.name))).map((run) => CompileRunResourceSchema.parse({ run }));
-    }
-    listCompileRunsForPreparation(prepDataDir, preparationName) {
-        return this.compileRunCache.get(prepDataDir, preparationName, () => {
-            const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationName);
-            return byCreatedAtDesc(listJsonFiles(compileRunsRoot(compiledPath))
-                .map(readCompileRunAt)
-                .filter((run) => run !== null)).map((run) => this.hydrateCompileRunFromRuntime(prepDataDir, compiledPath, run));
+            .flatMap((preparation) => this.listBuildRunsForPreparation(prepDataDir, preparation.name))).map((run) => BuildRunResourceSchema.parse({ run }));
+    }
+    listBuildRunsForPreparation(prepDataDir, preparationName) {
+        return this.buildRunCache.get(prepDataDir, preparationName, () => {
+            const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparationName);
+            return byCreatedAtDesc(listJsonFiles(buildRunsRoot(verifiableContextPath))
+                .map(readBuildRunAt)
+                .filter((run) => run !== null)).map((run) => this.hydrateBuildRunFromRuntime(prepDataDir, verifiableContextPath, run));
         }, (run) => run.run_id);
     }
-    getCompileRun(prepDataDir, runId) {
+    getBuildRun(prepDataDir, runId) {
         // Fast path: if the runId was seen during a recent listing, look up
         // its owning preparation directly and return that preparation's
         // cached entry instead of scanning every preparation on disk.
-        const known = this.compileRunCache.preparationFor(prepDataDir, runId);
+        const known = this.buildRunCache.preparationFor(prepDataDir, runId);
         if (known) {
-            const found = this.listCompileRunsForPreparation(prepDataDir, known).find((entry) => entry.run_id === runId);
+            const found = this.listBuildRunsForPreparation(prepDataDir, known).find((entry) => entry.run_id === runId);
             if (found)
-                return CompileRunResourceSchema.parse({ run: found });
+                return BuildRunResourceSchema.parse({ run: found });
         }
         // Slow path: scan all preparations. Falls through after a cache
         // miss for an in-flight run created before this process restarted.
-        for (const resource of this.listCompileRuns(prepDataDir)) {
+        for (const resource of this.listBuildRuns(prepDataDir)) {
             if (resource.run.run_id === runId)
                 return resource;
         }
         return null;
     }
-    getCompileRunEvents(prepDataDir, runId) {
-        return this.getCompileRun(prepDataDir, runId)?.run.events ?? null;
+    getBuildRunEvents(prepDataDir, runId) {
+        return this.getBuildRun(prepDataDir, runId)?.run.events ?? null;
     }
-    getCompileRunProof(prepDataDir, runId) {
-        const run = this.getCompileRun(prepDataDir, runId)?.run;
+    getBuildRunProof(prepDataDir, runId) {
+        const run = this.getBuildRun(prepDataDir, runId)?.run;
         if (!run)
             return null;
         return run.stages
             .map((stage) => stage.latest_proof ?? null)
             .filter((proof) => proof !== null);
     }
-    getCompileRunArtifacts(prepDataDir, runId) {
-        const run = this.getCompileRun(prepDataDir, runId)?.run;
+    getBuildRunArtifacts(prepDataDir, runId) {
+        const run = this.getBuildRun(prepDataDir, runId)?.run;
         if (!run)
             return null;
         return uniqueArtifacts(run.stages.flatMap((stage) => stage.artifacts));
     }
-    async createCompileRun(prepDataDir, requestValue) {
-        const request = CompileRunCreateRequestSchema.parse(requestValue);
+    async createBuildRun(prepDataDir, requestValue) {
+        const request = BuildRunCreateRequestSchema.parse(requestValue);
         const preparationConfig = this.resolvePreparationConfig(prepDataDir, request.preparation, {
-            method: request.method,
+            build_plan: request.build_plan,
             max_attempts: request.max_attempts,
             max_loops: request.max_loops,
         });
-        const compiledPath = this.ensureCompiledForRun(prepDataDir, preparationConfig);
-        const runId = createRunId("compile");
+        const verifiableContextPath = this.ensureVerifiableContextForRun(prepDataDir, preparationConfig);
+        const runId = createRunId("build");
         const now = new Date().toISOString();
-        const method = getCompiledMethod(requireSelectedMethod(preparationConfig), {
+        const buildPlan = getBuildPlan(requireSelectedBuildPlan(preparationConfig), {
             prepDataDir,
         });
-        const stageTotal = method.stages.length;
-        const run = CompileRunSchema.parse({
-            kind: "interf-compile-run",
+        const stageTotal = buildPlan.stages.length;
+        const run = BuildRunSchema.parse({
+            kind: "interf-build-run",
             version: 1,
             run_id: runId,
             status: "running",
             preparation: preparationConfig.name,
-            method: method.id,
+            build_plan: buildPlan.id,
             backend: "native",
             source_path: resolveSourcePreparationPath(prepDataDir, preparationConfig),
-            portable_context_path: compiledPath,
+            verifiable_context_path: verifiableContextPath,
             created_at: now,
             started_at: now,
-            stages: method.stages
+            stages: buildPlan.stages
                 .map((stage, index) => {
                 return {
                     run_id: runId,
@@ -1310,45 +1273,45 @@ export class LocalServiceRuntime {
             }),
             events: [],
         });
-        this.writeCompileRun(prepDataDir, compiledPath, run);
-        this.activeCompileRuns.set(runId, {
+        this.writeBuildRun(prepDataDir, verifiableContextPath, run);
+        this.activeBuildRuns.set(runId, {
             prepDataDir,
-            compiledPath,
+            verifiableContextPath,
             preparation: preparationConfig.name,
             cancelled: false,
         });
-        await this.recordCompileRunEvent(prepDataDir, compiledPath, runId, {
+        await this.recordBuildRunEvent(prepDataDir, verifiableContextPath, runId, {
             type: "run.started",
             event_id: createRunEventId("event"),
             run_id: runId,
             timestamp: now,
             preparation: preparationConfig.name,
-            method: method.id,
-            portable_context_path: compiledPath,
+            build_plan: buildPlan.id,
+            verifiable_context_path: verifiableContextPath,
             backend: "native",
         });
         const sink = {
-            emit: (event) => this.recordCompileRunEvent(prepDataDir, compiledPath, runId, event),
+            emit: (event) => this.recordBuildRunEvent(prepDataDir, verifiableContextPath, runId, event),
         };
-        void this.runCompileInBackground(prepDataDir, request, {
+        void this.runBuildInBackground(prepDataDir, request, {
             runId,
             sourcePath: prepDataDir,
-            compiledPath,
+            verifiableContextPath,
             preparationConfig,
             events: sink,
         });
-        const saved = this.readCompileRun(compiledPath, runId) ?? run;
-        return CompileRunResourceSchema.parse({ run: saved });
+        const saved = this.readBuildRun(verifiableContextPath, runId) ?? run;
+        return BuildRunResourceSchema.parse({ run: saved });
     }
     /**
-     * Cancel an in-flight compile run. Marks the persisted record as
+     * Cancel an in-flight Build run. Marks the persisted record as
      * `cancelled`, emits a `run.cancelled` event to capture the cancellation in
      * the run timeline, and clears the active handle so retries may start a
      * fresh run. If the run already finished, returns
      * `{ cancelled: false, reason: "already finished" }` and persists nothing.
      */
-    cancelCompileRun(runId) {
-        const handle = this.activeCompileRuns.get(runId);
+    cancelBuildRun(runId) {
+        const handle = this.activeBuildRuns.get(runId);
         if (!handle) {
             // Either unknown or already terminal. The server route already 404s
             // unknown ids before calling this, so anything reaching here is a run
@@ -1361,14 +1324,14 @@ export class LocalServiceRuntime {
         const cancelledAt = new Date().toISOString();
         handle.cancelled = true;
         handle.cancelledAt = cancelledAt;
-        const current = this.readCompileRun(handle.compiledPath, runId);
-        if (current && !isTerminalCompileRunStatus(current.status)) {
-            this.writeCompileRun(handle.prepDataDir, handle.compiledPath, applyEventToCompileRun(current, {
+        const current = this.readBuildRun(handle.verifiableContextPath, runId);
+        if (current && !isTerminalBuildRunStatus(current.status)) {
+            this.writeBuildRun(handle.prepDataDir, handle.verifiableContextPath, applyEventToBuildRun(current, {
                 type: "run.cancelled",
                 event_id: createRunEventId("event"),
                 run_id: runId,
                 timestamp: cancelledAt,
-                reason: "Compile run cancelled by request.",
+                reason: "Build run cancelled by request.",
             }));
         }
         return { cancelled: true };
@@ -1379,7 +1342,7 @@ export class LocalServiceRuntime {
      * elapsed. The preparation argument is required so that the same key in
      * two different preparations always returns two different runs.
      */
-    findIdempotentCompileRun(prepDataDir, key) {
+    findIdempotentBuildRun(prepDataDir, key) {
         const resolvedRoot = resolve(prepDataDir);
         const bucket = this.idempotencyKeyCache.get(resolvedRoot);
         if (!bucket)
@@ -1390,7 +1353,7 @@ export class LocalServiceRuntime {
         if (entry.expiresAt <= Date.now()) {
             // Opportunistic single-key prune. The bulk prune runs on writes
             // when the cache crosses the size threshold (see
-            // {@link recordIdempotentCompileRun}).
+            // {@link recordIdempotentBuildRun}).
             bucket.delete(key);
             if (bucket.size === 0)
                 this.idempotencyKeyCache.delete(resolvedRoot);
@@ -1405,7 +1368,7 @@ export class LocalServiceRuntime {
      * every read AND write, which was O(N) per request. Now we only sweep
      * when the cache grows past {@link IDEMPOTENCY_PRUNE_THRESHOLD}.
      */
-    recordIdempotentCompileRun(prepDataDir, key, runId) {
+    recordIdempotentBuildRun(prepDataDir, key, runId) {
         const resolvedRoot = resolve(prepDataDir);
         let bucket = this.idempotencyKeyCache.get(resolvedRoot);
         if (!bucket) {
@@ -1461,8 +1424,8 @@ export class LocalServiceRuntime {
     }
     listVerifyRunsForPreparation(prepDataDir, preparationName) {
         return this.verifyRunCache.get(prepDataDir, preparationName, () => {
-            const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationName);
-            return newestFirst(listJsonFiles(verifyRunsRoot(compiledPath))
+            const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparationName);
+            return newestFirst(listJsonFiles(verifyRunsRoot(verifiableContextPath))
                 .map(readVerifyRunAt)
                 .filter((run) => run !== null));
         }, (run) => run.run_id);
@@ -1479,8 +1442,8 @@ export class LocalServiceRuntime {
     async createVerifyRun(prepDataDir, requestValue) {
         const request = VerifyRunCreateRequestSchema.parse(requestValue);
         const preparationConfig = this.resolvePreparationConfig(prepDataDir, request.preparation);
-        const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationConfig.name);
-        const compiledTarget = createCompiledTestTarget(compiledPath, preparationConfig.name, methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID);
+        const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparationConfig.name);
+        const verifiableContextTarget = createVerifiableContextTestTarget(verifiableContextPath, preparationConfig.name, buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID);
         const runId = createRunId("verify");
         const now = new Date().toISOString();
         const initial = VerifyRunResourceSchema.parse({
@@ -1488,74 +1451,74 @@ export class LocalServiceRuntime {
             status: "running",
             preparation: preparationConfig.name,
             source_path: prepDataDir,
-            portable_context_path: compiledTarget.eligible ? compiledPath : null,
+            verifiable_context_path: verifiableContextTarget.eligible ? verifiableContextPath : null,
             started_at: now,
             readiness_run: null,
             events: [],
         });
-        this.writeVerifyRun(prepDataDir, compiledPath, initial);
+        this.writeVerifyRun(prepDataDir, verifiableContextPath, initial);
         void this.runTestInBackground(prepDataDir, request, {
             runId,
             sourcePath: prepDataDir,
-            compiledPath,
+            verifiableContextPath,
             preparationConfig,
         }, initial);
         return initial;
     }
-    async runCompileInBackground(prepDataDir, request, context) {
+    async runBuildInBackground(prepDataDir, request, context) {
         this.beginActiveRun();
         try {
-            if (!this.handlers.createCompileRun) {
-                throw new Error("No compile-run handler is configured for this local service.");
+            if (!this.handlers.createBuildRun) {
+                throw new Error("No build-run handler is configured for this local service.");
             }
-            const result = LocalRunHandlerResultSchema.parse(await this.handlers.createCompileRun(request, context));
-            const wasCancelled = this.activeCompileRuns.get(context.runId)?.cancelled === true;
+            const result = LocalRunHandlerResultSchema.parse(await this.handlers.createBuildRun(request, context));
+            const wasCancelled = this.activeBuildRuns.get(context.runId)?.cancelled === true;
             if (wasCancelled) {
                 // The run was cancelled while the handler was still running. The
                 // cancellation path already wrote a `cancelled` record; just refresh
                 // observability and skip emitting a second terminal event.
-                this.refreshCompileRunFromRuntime(prepDataDir, context.compiledPath, context.runId);
-                await this.emitRuntimeDerivedEvents(prepDataDir, context.compiledPath, context.runId);
-                await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
+                this.refreshBuildRunFromRuntime(prepDataDir, context.verifiableContextPath, context.runId);
+                await this.emitRuntimeDerivedEvents(prepDataDir, context.verifiableContextPath, context.runId);
+                await this.recordBuildRunEvent(prepDataDir, context.verifiableContextPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
                 return;
             }
-            this.refreshCompileRunFromRuntime(prepDataDir, context.compiledPath, context.runId);
-            await this.emitRuntimeDerivedEvents(prepDataDir, context.compiledPath, context.runId);
+            this.refreshBuildRunFromRuntime(prepDataDir, context.verifiableContextPath, context.runId);
+            await this.emitRuntimeDerivedEvents(prepDataDir, context.verifiableContextPath, context.runId);
             if (!result.ok) {
-                await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, {
+                await this.recordBuildRunEvent(prepDataDir, context.verifiableContextPath, context.runId, {
                     type: "run.failed",
                     event_id: createRunEventId("event"),
                     run_id: context.runId,
                     timestamp: createRunEventTimestamp(),
-                    error: result.error ?? "Compile run failed.",
+                    error: result.error ?? "Build run failed.",
                 });
             }
             else {
-                await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, {
+                await this.recordBuildRunEvent(prepDataDir, context.verifiableContextPath, context.runId, {
                     type: "run.completed",
                     event_id: createRunEventId("event"),
                     run_id: context.runId,
                     timestamp: createRunEventTimestamp(),
-                    summary: "Portable context ready.",
+                    summary: "Verifiable context ready.",
                 });
             }
-            await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
+            await this.recordBuildRunEvent(prepDataDir, context.verifiableContextPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
             // 0.17 — emit per-Artifact billing events (stub form: JSONL).
             // Production sink (Metronome HTTP) wires in 0.18+.
             this.emitBillingEventsForRun(prepDataDir, context);
         }
         catch (error) {
-            await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, {
+            await this.recordBuildRunEvent(prepDataDir, context.verifiableContextPath, context.runId, {
                 type: "run.failed",
                 event_id: createRunEventId("event"),
                 run_id: context.runId,
                 timestamp: createRunEventTimestamp(),
                 error: error instanceof Error ? error.message : String(error),
             });
-            await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
+            await this.recordBuildRunEvent(prepDataDir, context.verifiableContextPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
         }
         finally {
-            this.activeCompileRuns.delete(context.runId);
+            this.activeBuildRuns.delete(context.runId);
             this.endActiveRun();
         }
     }
@@ -1578,7 +1541,7 @@ export class LocalServiceRuntime {
                 events: resultEvent ? [resultEvent] : [],
                 ...(!result.ok ? { error: result.error ?? "Readiness check failed." } : {}),
             });
-            this.writeVerifyRun(prepDataDir, context.compiledPath, nextWithoutReadiness);
+            this.writeVerifyRun(prepDataDir, context.verifiableContextPath, nextWithoutReadiness);
             const readiness = this.computePreparationReadiness(prepDataDir, context.preparationConfig);
             const next = VerifyRunResourceSchema.parse({
                 ...nextWithoutReadiness,
@@ -1588,7 +1551,7 @@ export class LocalServiceRuntime {
                     this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, readiness),
                 ],
             });
-            this.writeVerifyRun(prepDataDir, context.compiledPath, next);
+            this.writeVerifyRun(prepDataDir, context.verifiableContextPath, next);
         }
         catch (error) {
             const failedWithoutReadiness = VerifyRunResourceSchema.parse({
@@ -1597,14 +1560,14 @@ export class LocalServiceRuntime {
                 finished_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
             });
-            this.writeVerifyRun(prepDataDir, context.compiledPath, failedWithoutReadiness);
+            this.writeVerifyRun(prepDataDir, context.verifiableContextPath, failedWithoutReadiness);
             const readiness = this.computePreparationReadiness(prepDataDir, context.preparationConfig);
             const next = VerifyRunResourceSchema.parse({
                 ...failedWithoutReadiness,
                 readiness,
                 events: [this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, readiness)],
             });
-            this.writeVerifyRun(prepDataDir, context.compiledPath, next);
+            this.writeVerifyRun(prepDataDir, context.verifiableContextPath, next);
         }
         finally {
             this.endActiveRun();
@@ -1668,18 +1631,18 @@ export class LocalServiceRuntime {
             });
         }
     }
-    async runMethodAuthoringInBackground(prepDataDir, request, runId) {
+    async runBuildPlanAuthoringInBackground(prepDataDir, request, runId) {
         this.beginActiveRun();
-        return this.runMethodAuthoringInBackgroundInner(prepDataDir, request, runId).finally(() => {
+        return this.runBuildPlanAuthoringInBackgroundInner(prepDataDir, request, runId).finally(() => {
             this.endActiveRun();
         });
     }
-    async runMethodAuthoringInBackgroundInner(prepDataDir, request, runId) {
+    async runBuildPlanAuthoringInBackgroundInner(prepDataDir, request, runId) {
         try {
-            if (!this.handlers.createMethodAuthoringRun) {
-                throw new Error("No Method-authoring handler is configured for this local service.");
+            if (!this.handlers.createBuildPlanAuthoringRun) {
+                throw new Error("No Build Plan-authoring handler is configured for this local service.");
             }
-            const result = MethodAuthoringResultSchema.parse(await this.handlers.createMethodAuthoringRun(request, this.jobRunContext(prepDataDir, runId)));
+            const result = BuildPlanAuthoringResultSchema.parse(await this.handlers.createBuildPlanAuthoringRun(request, this.jobRunContext(prepDataDir, runId)));
             this.setJobRunResult(prepDataDir, runId, result);
             this.appendJobRunEvent(prepDataDir, runId, {
                 type: result.status === "executor-failed" ? "step.failed" : "step.completed",
@@ -1688,36 +1651,36 @@ export class LocalServiceRuntime {
                 output: {
                     status: result.status,
                     changed: result.changed,
-                    method_path: result.method_path,
+                    build_plan_path: result.build_plan_path,
                     shell_path: result.shell_path,
                 },
             });
             this.appendJobRunEvent(prepDataDir, runId, {
                 type: "step.started",
                 step_id: "validate-package",
-                message: "Validating Method package structure and stage contract.",
+                message: "Validating Build Plan package structure and stage contract.",
                 input: {
-                    method_path: result.method_path,
+                    build_plan_path: result.build_plan_path,
                 },
             });
             if (result.status === "updated" || result.status === "no-change") {
                 let selectedPreparation = null;
                 if (request.preparation) {
                     const selected = this.resolvePreparationConfig(prepDataDir, request.preparation, {
-                        method: request.method_id,
+                        build_plan: request.build_plan_id,
                     });
                     upsertSourcePreparationConfig(prepDataDir, selected);
                     this.readinessCache.invalidatePreparation(prepDataDir, selected.name);
-                    this.compileRunCache.invalidatePreparation(prepDataDir, selected.name);
+                    this.buildRunCache.invalidatePreparation(prepDataDir, selected.name);
                     this.verifyRunCache.invalidatePreparation(prepDataDir, selected.name);
-                    this.methodListingCache.invalidate(prepDataDir);
+                    this.buildPlanListingCache.invalidate(prepDataDir);
                     selectedPreparation = selected.name;
                 }
                 this.appendJobRunEvent(prepDataDir, runId, {
                     type: "step.completed",
                     step_id: "validate-package",
                     message: selectedPreparation
-                        ? `${result.summary} Selected Build Plan ${request.method_id} for Preparation ${selectedPreparation}.`
+                        ? `${result.summary} Selected Build Plan ${request.build_plan_id} for Preparation ${selectedPreparation}.`
                         : result.summary,
                     output: {
                         status: result.status,
@@ -1728,7 +1691,7 @@ export class LocalServiceRuntime {
                 this.appendJobRunEvent(prepDataDir, runId, {
                     type: "job.completed",
                     message: selectedPreparation
-                        ? `${result.summary} Selected Build Plan ${request.method_id} for Preparation ${selectedPreparation}.`
+                        ? `${result.summary} Selected Build Plan ${request.build_plan_id} for Preparation ${selectedPreparation}.`
                         : result.summary,
                 });
             }
@@ -1796,13 +1759,13 @@ export class LocalServiceRuntime {
                 preparations,
                 preparationHealth: preparations.map((preparation) => {
                     const readinessChecks = preparation.checks?.length ?? 0;
-                    const portableContextReady = hasCompiledTestTarget(prepDataDir, preparation);
+                    const verifiableContextReady = hasVerifiableContextTestTarget(prepDataDir, preparation);
                     return {
                         name: preparation.name,
                         readiness_checks: readinessChecks,
-                        portable_context_ready: portableContextReady,
-                        can_check_readiness: readinessChecks > 0 && portableContextReady,
-                        recommended_next_actions: portableContextReady
+                        verifiable_context_ready: verifiableContextReady,
+                        can_check_readiness: readinessChecks > 0 && verifiableContextReady,
+                        recommended_next_actions: verifiableContextReady
                             ? readinessChecks > 0
                                 ? ["check readiness", "improve", "prepare again"]
                                 : ["draft readiness checks", "prepare again"]
@@ -1836,8 +1799,8 @@ export class LocalServiceRuntime {
         }
         const label = options.actionType === "preparation-setup"
             ? "Preparation setup"
-            : options.actionType === "method-change"
-                ? "Method change"
+            : options.actionType === "build-plan-change"
+                ? "Build Plan change"
                 : "Preparation change";
         const now = new Date().toISOString();
         return ActionProposalResourceSchema.parse({
@@ -1851,7 +1814,7 @@ export class LocalServiceRuntime {
             assistant_message: `${label} must be submitted directly to ${endpoint}. Action proposals are only for freeform planning or async local-agent-backed work.`,
             message: options.message,
             preparation: options.preparation ?? null,
-            method: options.method ?? null,
+            build_plan: options.buildPlan ?? null,
             request: {
                 message: options.message,
                 endpoint,
@@ -1869,7 +1832,7 @@ export class LocalServiceRuntime {
     }
     async buildActionProposal(prepDataDir, request) {
         const structuredPreparationSetup = PreparationSetupActionValuesSchema.safeParse(request.values);
-        const structuredMethodAuthoring = MethodAuthoringActionValuesSchema.safeParse(request.values);
+        const structuredBuildPlanAuthoring = BuildPlanAuthoringActionValuesSchema.safeParse(request.values);
         const structuredActionType = actionTypeFromValues(request.values);
         const structuredDirectActionType = structuredPreparationSetup.success
             ? "preparation-setup"
@@ -1880,12 +1843,14 @@ export class LocalServiceRuntime {
             return this.directServiceActionClarification({
                 actionType: structuredDirectActionType,
                 message: request.message,
-                method: stringValue(request.values, "method") ?? stringValue(request.values, "new_method_id"),
+                buildPlan: stringValue(request.values, "build_plan") ??
+                    stringValue(request.values, "build_plan_id") ??
+                    stringValue(request.values, "new_build_plan_id"),
                 preparation: request.preparation ?? stringValue(request.values, "preparation") ?? stringValue(request.values, "name"),
                 values: request.values,
             });
         }
-        const structuredPlanActionType = structuredMethodAuthoring.success ? "method-authoring" : structuredActionType;
+        const structuredPlanActionType = structuredBuildPlanAuthoring.success ? "build-plan-draft" : structuredActionType;
         // Typed UI/CLI actions already carry the service contract; only freeform chat needs planner inference.
         const plan = structuredPlanActionType
             ? ActionProposalPlanSchema.parse({
@@ -1898,7 +1863,11 @@ export class LocalServiceRuntime {
             return this.directServiceActionClarification({
                 actionType,
                 message: request.message,
-                method: plan.method ?? stringValue(plan.values, "method") ?? stringValue(request.values, "method"),
+                buildPlan: plan.build_plan ??
+                    stringValue(plan.values, "build_plan") ??
+                    stringValue(plan.values, "build_plan_id") ??
+                    stringValue(request.values, "build_plan") ??
+                    stringValue(request.values, "build_plan_id"),
                 preparation: plan.preparation ?? request.preparation ?? stringValue(plan.values, "preparation") ?? stringValue(request.values, "preparation"),
                 values: {
                     ...(plan.values ?? {}),
@@ -1921,7 +1890,7 @@ export class LocalServiceRuntime {
                 ...(plan.command_preview ? { command_preview: plan.command_preview } : {}),
                 message: request.message,
                 preparation: plan.preparation ?? request.preparation ?? null,
-                method: plan.method ?? null,
+                build_plan: plan.build_plan ?? null,
                 request: {
                     message: request.message,
                     ...(plan.values ? { values: plan.values } : {}),
@@ -1939,7 +1908,7 @@ export class LocalServiceRuntime {
             ...(plan.values ?? {}),
             ...(request.values ?? {}),
         };
-        if (actionType === "method-authoring" || actionType === "method-improvement") {
+        if (actionType === "build-plan-draft" || actionType === "build-plan-improvement") {
             const requestedPreparationName = plan.preparation ?? request.preparation ?? null;
             const fallbackPreparation = requestedPreparationName
                 ? null
@@ -1950,23 +1919,27 @@ export class LocalServiceRuntime {
             const preparationPath = preparationConfig
                 ? resolveSourcePreparationPath(prepDataDir, preparationConfig)
                 : resolveConfiguredSourceFolderPath(prepDataDir) ?? prepDataDir;
-            const requestedMethodId = stringValue(request.values, "method_id") ??
-                stringValue(request.values, "method");
-            const plannedMethodId = plan.method ??
-                stringValue(plan.values, "method_id") ??
-                stringValue(plan.values, "method");
-            const methodId = requestedMethodId ?? plannedMethodId ?? methodIdForProposal(request.message, proposalValues);
-            const taskPrompt = actionValueMethodTaskPrompt(proposalValues) ??
+            const requestedBuildPlanId = stringValue(request.values, "build_plan_id") ??
+                stringValue(request.values, "build_plan");
+            const plannedBuildPlanId = plan.build_plan ??
+                stringValue(plan.values, "build_plan_id") ??
+                stringValue(plan.values, "build_plan");
+            const buildPlanId = requestedBuildPlanId ?? plannedBuildPlanId ?? buildPlanIdForProposal(request.message, proposalValues);
+            const taskPrompt = actionValueBuildPlanTaskPrompt(proposalValues) ??
                 stringValue(proposalValues, "task_prompt") ??
-                methodAuthoringPromptFallback(request.message, methodId);
-            const hint = stringValue(proposalValues, "hint") ?? methodAuthoringHintFromPrompt(taskPrompt);
+                buildPlanAuthoringPromptFallback(request.message, buildPlanId);
+            const hint = stringValue(proposalValues, "hint") ?? buildPlanAuthoringHintFromPrompt(taskPrompt);
             const actionRequest = {
                 preparation: preparationConfig?.name ?? null,
                 source_folder_path: preparationPath,
-                method_id: methodId,
-                ...(stringValue(proposalValues, "base_method_id") ? { base_method_id: stringValue(proposalValues, "base_method_id") } : {}),
-                ...(stringValue(proposalValues, "reference_method_id") ? { reference_method_id: stringValue(proposalValues, "reference_method_id") } : {}),
-                label: stringValue(proposalValues, "label") ?? methodLabelFromId(methodId),
+                build_plan_id: buildPlanId,
+                ...(stringValue(proposalValues, "base_build_plan_id") ?? stringValue(proposalValues, "base_build_plan_id")
+                    ? { base_build_plan_id: stringValue(proposalValues, "base_build_plan_id") ?? stringValue(proposalValues, "base_build_plan_id") }
+                    : {}),
+                ...(stringValue(proposalValues, "reference_build_plan_id") ?? stringValue(proposalValues, "reference_build_plan_id")
+                    ? { reference_build_plan_id: stringValue(proposalValues, "reference_build_plan_id") ?? stringValue(proposalValues, "reference_build_plan_id") }
+                    : {}),
+                label: stringValue(proposalValues, "label") ?? buildPlanLabelFromId(buildPlanId),
                 hint,
                 task_prompt: taskPrompt,
                 checks: preparationConfig?.checks ?? [],
@@ -1975,21 +1948,21 @@ export class LocalServiceRuntime {
                 artifact_requirements: artifactRequirementsFromRequestedArtifacts(preparationConfig?.requested_artifacts ?? []),
             };
             const commandPreview = (usePlannerText ? plan.command_preview : undefined) ??
-                actionCommandPreview(actionType, preparationConfig?.name ?? null, methodId, proposalValues);
+                actionCommandPreview(actionType, preparationConfig?.name ?? null, buildPlanId, proposalValues);
             return ActionProposalResourceSchema.parse({
                 kind: "interf-action-proposal",
                 version: 1,
                 proposal_id: createActionProposalId(),
                 status: "awaiting_approval",
                 action_type: actionType,
-                title: (usePlannerText ? plan.title : undefined) ?? `Draft Method ${methodId}`,
-                summary: (usePlannerText ? plan.summary : undefined) ?? "Ask the configured local executor to create a reusable local Method.",
+                title: (usePlannerText ? plan.title : undefined) ?? `Draft Build Plan ${buildPlanId}`,
+                summary: (usePlannerText ? plan.summary : undefined) ?? "Ask the configured local executor to create a reusable Build Plan.",
                 assistant_message: (usePlannerText ? plan.assistant_message : undefined) ??
                     actionAssistantMessage(actionType, preparationConfig?.name ?? null, commandPreview),
                 command_preview: commandPreview,
                 message: request.message,
                 preparation: preparationConfig?.name ?? null,
-                method: methodId,
+                build_plan: buildPlanId,
                 request: actionRequest,
                 created_at: now,
                 updated_at: now,
@@ -2003,12 +1976,12 @@ export class LocalServiceRuntime {
         const preparationConfig = this.resolvePreparationConfig(prepDataDir, plan.preparation ?? request.preparation ?? this.defaultPreparationName(prepDataDir));
         const proposalActionType = ActionProposalTypeSchema.parse(actionType);
         const preparationPath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
-        const requestedMethodId = stringValue(request.values, "method_id") ??
-            stringValue(request.values, "method");
-        const plannedMethodId = plan.method ??
-            stringValue(plan.values, "method_id") ??
-            stringValue(plan.values, "method");
-        const methodId = requestedMethodId ?? plannedMethodId ?? methodIdForSourcePreparationConfig(preparationConfig);
+        const requestedBuildPlanId = stringValue(request.values, "build_plan_id") ??
+            stringValue(request.values, "build_plan");
+        const plannedBuildPlanId = plan.build_plan ??
+            stringValue(plan.values, "build_plan_id") ??
+            stringValue(plan.values, "build_plan");
+        const buildPlanId = requestedBuildPlanId ?? plannedBuildPlanId ?? buildPlanIdForSourcePreparationConfig(preparationConfig);
         const clarifyResolvedAction = (options) => ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
             version: 1,
@@ -2020,7 +1993,7 @@ export class LocalServiceRuntime {
             assistant_message: options.assistantMessage,
             message: request.message,
             preparation: preparationConfig.name,
-            method: methodId ?? null,
+            build_plan: buildPlanId ?? null,
             request: {
                 message: request.message,
                 ...(proposalValues ? { values: proposalValues } : {}),
@@ -2036,7 +2009,7 @@ export class LocalServiceRuntime {
         if (actionType === "test") {
             const requestedMode = testModeFromValues(proposalValues);
             const hasReadinessChecks = (preparationConfig.checks ?? []).length > 0;
-            const portableContextReady = hasCompiledTestTarget(prepDataDir, preparationConfig);
+            const verifiableContextReady = hasVerifiableContextTestTarget(prepDataDir, preparationConfig);
             if (!hasReadinessChecks) {
                 return clarifyResolvedAction({
                     title: `Add readiness checks for ${preparationConfig.name}`,
@@ -2044,24 +2017,24 @@ export class LocalServiceRuntime {
                     assistantMessage: `Preparation "${preparationConfig.name}" does not have saved readiness checks yet. Ask me to draft readiness checks after the Source Folder is prepared, or add readiness guidance first.`,
                 });
             }
-            if (!portableContextReady && requestedMode !== "source-files") {
+            if (!verifiableContextReady && requestedMode !== "source-files") {
                 return clarifyResolvedAction({
-                    title: `Prepare ${preparationConfig.name} first`,
-                    summary: "Readiness checks need portable context unless you explicitly ask for a source-files-only baseline.",
-                    assistantMessage: `Preparation "${preparationConfig.name}" has no prepared portable context yet. Prepare it first; after that Interf can check readiness. If you specifically want a source-files-only baseline, ask for source files only.`,
+                    title: `Build ${preparationConfig.name} first`,
+                    summary: "Readiness checks need verifiable context unless you explicitly ask for a source-files-only baseline.",
+                    assistantMessage: `Preparation "${preparationConfig.name}" has no built verifiable context yet. Build it first; after that Interf can check readiness. If you specifically want a source-files-only baseline, ask for source files only.`,
                 });
             }
         }
         const actionRequest = (() => {
-            if (actionType === "compile") {
+            if (actionType === "build") {
                 return {
                     preparation: preparationConfig.name,
-                    ...(methodId ? { method: methodId } : {}),
+                    ...(buildPlanId ? { build_plan: buildPlanId } : {}),
                 };
             }
             if (actionType === "test") {
-                // 0.15 — verify runs always judge against the compiled
-                // portable context. The legacy `mode` field is gone from the
+                // 0.15 — verify runs always judge against the verifiable context
+                // verifiable context. The legacy `mode` field is gone from the
                 // wire request shape.
                 return {
                     preparation: preparationConfig.name,
@@ -2075,18 +2048,22 @@ export class LocalServiceRuntime {
                     target_count: Math.max(1, Math.min(8, Math.round(numberValue(proposalValues, "target_count") ?? 4))),
                 };
             }
-            const fallbackMethodId = methodId ?? methodIdForProposal(request.message, proposalValues);
-            const taskPrompt = actionValueMethodTaskPrompt(proposalValues) ??
+            const fallbackBuildPlanId = buildPlanId ?? buildPlanIdForProposal(request.message, proposalValues);
+            const taskPrompt = actionValueBuildPlanTaskPrompt(proposalValues) ??
                 stringValue(proposalValues, "task_prompt") ??
-                methodAuthoringPromptFallback(request.message, fallbackMethodId);
-            const hint = stringValue(proposalValues, "hint") ?? methodAuthoringHintFromPrompt(taskPrompt);
+                buildPlanAuthoringPromptFallback(request.message, fallbackBuildPlanId);
+            const hint = stringValue(proposalValues, "hint") ?? buildPlanAuthoringHintFromPrompt(taskPrompt);
             return {
                 preparation: preparationConfig.name,
                 source_folder_path: preparationPath,
-                method_id: fallbackMethodId,
-                ...(stringValue(proposalValues, "base_method_id") ? { base_method_id: stringValue(proposalValues, "base_method_id") } : {}),
-                ...(stringValue(proposalValues, "reference_method_id") ? { reference_method_id: stringValue(proposalValues, "reference_method_id") } : {}),
-                label: stringValue(proposalValues, "label") ?? methodLabelFromId(fallbackMethodId),
+                build_plan_id: fallbackBuildPlanId,
+                ...(stringValue(proposalValues, "base_build_plan_id") ?? stringValue(proposalValues, "base_build_plan_id")
+                    ? { base_build_plan_id: stringValue(proposalValues, "base_build_plan_id") ?? stringValue(proposalValues, "base_build_plan_id") }
+                    : {}),
+                ...(stringValue(proposalValues, "reference_build_plan_id") ?? stringValue(proposalValues, "reference_build_plan_id")
+                    ? { reference_build_plan_id: stringValue(proposalValues, "reference_build_plan_id") ?? stringValue(proposalValues, "reference_build_plan_id") }
+                    : {}),
+                label: stringValue(proposalValues, "label") ?? buildPlanLabelFromId(fallbackBuildPlanId),
                 hint,
                 task_prompt: taskPrompt,
                 checks: preparationConfig.checks ?? [],
@@ -2098,27 +2075,27 @@ export class LocalServiceRuntime {
         const title = (() => {
             if (plan.title)
                 return plan.title;
-            if (proposalActionType === "compile")
-                return `Prepare ${preparationConfig.name}`;
+            if (proposalActionType === "build")
+                return `Build ${preparationConfig.name}`;
             if (proposalActionType === "test")
                 return `Check readiness for ${preparationConfig.name}`;
             if (proposalActionType === "readiness-check-draft")
                 return `Draft readiness checks for ${preparationConfig.name}`;
-            return `Draft Method ${methodId}`;
+            return `Draft Build Plan ${buildPlanId}`;
         })();
         const summary = (() => {
             if (plan.summary)
                 return plan.summary;
-            if (proposalActionType === "compile")
-                return "Build portable context agents can use.";
+            if (proposalActionType === "build")
+                return "Build verifiable context agents can use.";
             if (proposalActionType === "test")
-                return "Run readiness checks against source files and portable context.";
+                return "Run readiness checks against source files and verifiable context.";
             if (proposalActionType === "readiness-check-draft")
                 return "Ask the configured local executor to draft saved readiness checks.";
-            return "Ask the configured local executor to create a reusable local Method.";
+            return "Ask the configured local executor to create a reusable Build Plan.";
         })();
         const previewValues = proposalValues;
-        const commandPreview = plan.command_preview ?? actionCommandPreview(proposalActionType, preparationConfig.name, methodId, previewValues);
+        const commandPreview = plan.command_preview ?? actionCommandPreview(proposalActionType, preparationConfig.name, buildPlanId, previewValues);
         return ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
             version: 1,
@@ -2131,7 +2108,7 @@ export class LocalServiceRuntime {
             command_preview: commandPreview,
             message: request.message,
             preparation: preparationConfig.name,
-            method: methodId,
+            build_plan: buildPlanId,
             request: actionRequest,
             created_at: now,
             updated_at: now,
@@ -2146,11 +2123,11 @@ export class LocalServiceRuntime {
         if (proposal.action_type === "clarification") {
             throw new Error("Clarification proposals cannot be submitted.");
         }
-        if (proposal.action_type === "compile") {
-            const resource = await this.createCompileRun(prepDataDir, proposal.request);
+        if (proposal.action_type === "build") {
+            const resource = await this.createBuildRun(prepDataDir, proposal.request);
             return {
                 runId: resource.run.run_id,
-                runType: "compile-run",
+                runType: "build-run",
             };
         }
         if (proposal.action_type === "test") {
@@ -2171,7 +2148,7 @@ export class LocalServiceRuntime {
         if (directEndpoint) {
             throw new Error(`Action "${proposal.action_type}" must be submitted directly to ${directEndpoint}.`);
         }
-        const job = await this.createMethodAuthoringRun(prepDataDir, proposal.request, proposal.action_type === "method-improvement" ? "method-improvement" : "method-authoring");
+        const job = await this.createBuildPlanAuthoringRun(prepDataDir, proposal.request, proposal.action_type === "build-plan-improvement" ? "build-plan-improvement" : "build-plan-draft");
         return {
             runId: job.run_id,
             runType: "job-run",
@@ -2182,30 +2159,30 @@ export class LocalServiceRuntime {
         if (!preparation) {
             throw new Error(`Preparation "${preparationName}" is not saved in this control plane folder.`);
         }
-        const method = overrides.method ?? methodIdForSourcePreparationConfig(preparation) ?? undefined;
+        const buildPlan = overrides.build_plan ?? buildPlanIdForSourcePreparationConfig(preparation) ?? undefined;
         return {
             ...preparation,
-            ...(method ? { method } : {}),
+            ...(buildPlan ? { build_plan: buildPlan } : {}),
             ...(typeof overrides.max_attempts === "number" ? { max_attempts: overrides.max_attempts } : {}),
             ...(typeof overrides.max_loops === "number" ? { max_loops: overrides.max_loops } : {}),
         };
     }
-    ensureCompiledForRun(prepDataDir, preparationConfig) {
-        const methodId = requireSelectedMethod(preparationConfig);
-        const compiledPath = ensurePortableContextScaffold(prepDataDir, preparationConfig.name, methodId);
-        syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
-        return compiledPath;
+    ensureVerifiableContextForRun(prepDataDir, preparationConfig) {
+        const buildPlanId = requireSelectedBuildPlan(preparationConfig);
+        const verifiableContextPath = ensureVerifiableContextScaffold(prepDataDir, preparationConfig.name, buildPlanId);
+        syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig);
+        return verifiableContextPath;
     }
-    readCompileRun(compiledPath, runId) {
-        return readCompileRunAt(compileRunPath(compiledPath, runId));
+    readBuildRun(verifiableContextPath, runId) {
+        return readBuildRunAt(buildRunPath(verifiableContextPath, runId));
     }
-    hydrateCompileRunFromRuntime(prepDataDir, compiledPath, run) {
-        if (!isTerminalCompileRunStatus(run.status))
+    hydrateBuildRunFromRuntime(prepDataDir, verifiableContextPath, run) {
+        if (!isTerminalBuildRunStatus(run.status))
             return run;
-        this.refreshCompileRunFromRuntime(prepDataDir, compiledPath, run.run_id);
-        return this.readCompileRun(compiledPath, run.run_id) ?? run;
+        this.refreshBuildRunFromRuntime(prepDataDir, verifiableContextPath, run.run_id);
+        return this.readBuildRun(verifiableContextPath, run.run_id) ?? run;
     }
-    finalizeInterruptedCompileRuns(prepDataDir) {
+    finalizeInterruptedBuildRuns(prepDataDir) {
         let preparations;
         try {
             preparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
@@ -2214,11 +2191,11 @@ export class LocalServiceRuntime {
             return;
         }
         for (const preparation of preparations) {
-            const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
-            for (const run of listJsonFiles(compileRunsRoot(compiledPath))
-                .map(readCompileRunAt)
+            const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
+            for (const run of listJsonFiles(buildRunsRoot(verifiableContextPath))
+                .map(readBuildRunAt)
                 .filter((entry) => entry !== null)) {
-                if (isTerminalCompileRunStatus(run.status) || this.activeCompileRuns.has(run.run_id))
+                if (isTerminalBuildRunStatus(run.status) || this.activeBuildRuns.has(run.run_id))
                     continue;
                 const timestamp = createRunEventTimestamp();
                 const interruptedRun = {
@@ -2235,7 +2212,7 @@ export class LocalServiceRuntime {
                         };
                     }),
                 };
-                this.writeCompileRun(prepDataDir, compiledPath, applyEventToCompileRun(interruptedRun, {
+                this.writeBuildRun(prepDataDir, verifiableContextPath, applyEventToBuildRun(interruptedRun, {
                     type: "run.cancelled",
                     event_id: createRunEventId("event"),
                     run_id: run.run_id,
@@ -2273,7 +2250,7 @@ export class LocalServiceRuntime {
         }
     }
     /**
-     * 0.17 — emit per-Artifact billing events when a compile run reaches
+     * 0.17 — emit per-Artifact billing events when a Build run reaches
      * a terminal state. STUB FORM: writes a JSONL file alongside the run
      * record by default. Production sink (Metronome HTTP) wires in 0.18+.
      * The JSONL output is observability/dev fixture, NOT production
@@ -2281,7 +2258,7 @@ export class LocalServiceRuntime {
      */
     emitBillingEventsForRun(prepDataDir, context) {
         try {
-            const run = this.readCompileRun(context.compiledPath, context.runId);
+            const run = this.readBuildRun(context.verifiableContextPath, context.runId);
             if (!run || run.artifacts.length === 0)
                 return;
             const sink = this.billingEventSink ?? new JsonlBillingEventSink(defaultBillingEventLogPath({
@@ -2292,7 +2269,7 @@ export class LocalServiceRuntime {
             const events = buildCompilationEventsForRun({
                 runId: context.runId,
                 preparation: run.preparation,
-                methodId: run.method,
+                buildPlanId: run.build_plan,
                 accountId: null, // 0.17 — loopback only; cloud variant fills via tokenValidator (B4.3).
                 artifacts: run.artifacts,
                 startedAt: run.started_at ?? null,
@@ -2304,17 +2281,17 @@ export class LocalServiceRuntime {
         }
         catch {
             // Billing is observability-only in 0.17; never let stub failures
-            // block a successful compile.
+            // block a successful build.
         }
     }
-    writeCompileRun(prepDataDir, compiledPath, run) {
-        mkdirSync(compileRunsRoot(compiledPath), { recursive: true });
-        writeJsonFile(compileRunPath(compiledPath, run.run_id), CompileRunSchema.parse(run));
+    writeBuildRun(prepDataDir, verifiableContextPath, run) {
+        mkdirSync(buildRunsRoot(verifiableContextPath), { recursive: true });
+        writeJsonFile(buildRunPath(verifiableContextPath, run.run_id), BuildRunSchema.parse(run));
         // Bust per-preparation list + readiness caches so the next read
         // reflects the write. We invalidate broadly (per-preparation, not
         // per-record) because list recompute cost is bounded by run count
         // and the simpler model avoids fan-out bugs.
-        this.compileRunCache.invalidatePreparation(prepDataDir, run.preparation);
+        this.buildRunCache.invalidatePreparation(prepDataDir, run.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, run.preparation);
     }
     writeJobRun(prepDataDir, run) {
@@ -2341,24 +2318,24 @@ export class LocalServiceRuntime {
             result: normalizedResult,
         }));
     }
-    async recordCompileRunEvent(prepDataDir, compiledPath, runId, event) {
-        const current = this.readCompileRun(compiledPath, runId);
+    async recordBuildRunEvent(prepDataDir, verifiableContextPath, runId, event) {
+        const current = this.readBuildRun(verifiableContextPath, runId);
         if (!current)
             return;
-        this.writeCompileRun(prepDataDir, compiledPath, applyEventToCompileRun(current, event));
+        this.writeBuildRun(prepDataDir, verifiableContextPath, applyEventToBuildRun(current, event));
         if (event.type === "stage.passed" || event.type === "stage.failed") {
-            this.refreshCompileRunFromRuntime(prepDataDir, compiledPath, runId);
+            this.refreshBuildRunFromRuntime(prepDataDir, verifiableContextPath, runId);
         }
     }
-    refreshCompileRunFromRuntime(prepDataDir, compiledPath, runId) {
-        const current = this.readCompileRun(compiledPath, runId);
+    refreshBuildRunFromRuntime(prepDataDir, verifiableContextPath, runId) {
+        const current = this.readBuildRun(verifiableContextPath, runId);
         if (!current)
             return;
-        const state = loadState(compiledPath);
+        const state = loadState(verifiableContextPath);
         if (!state?.stages)
             return;
         const historyByStage = new Map();
-        for (const run of readRuntimeRunHistory(compiledPath)) {
+        for (const run of readRuntimeRunHistory(verifiableContextPath)) {
             if (run.target_name !== current.preparation)
                 continue;
             const existing = historyByStage.get(run.stage);
@@ -2397,25 +2374,25 @@ export class LocalServiceRuntime {
             }),
         };
         next.latest_proof = [...next.stages].reverse().find((stage) => Boolean(stage.latest_proof))?.latest_proof ?? next.latest_proof;
-        // Recompute per-Artifact status whenever the compile run is
+        // Recompute per-Artifact status whenever the Build run is
         // refreshed from runtime state.
         try {
-            const method = getCompiledMethod(current.method, { prepDataDir });
+            const buildPlan = getBuildPlan(current.build_plan, { prepDataDir });
             next.artifacts = computeArtifactStatuses({
-                method,
-                compiledPath,
+                buildPlan,
+                verifiableContextPath,
                 stageRuns: next.stages,
-                counts: countsFromCompiledState(state),
+                counts: countsFromVerifiableContextState(state),
             });
         }
         catch {
             next.artifacts = current.artifacts ?? [];
         }
-        this.writeCompileRun(prepDataDir, compiledPath, next);
+        this.writeBuildRun(prepDataDir, verifiableContextPath, next);
     }
-    async emitRuntimeDerivedEvents(prepDataDir, compiledPath, runId) {
-        const state = loadState(compiledPath);
-        const run = this.readCompileRun(compiledPath, runId);
+    async emitRuntimeDerivedEvents(prepDataDir, verifiableContextPath, runId) {
+        const state = loadState(verifiableContextPath);
+        const run = this.readBuildRun(verifiableContextPath, runId);
         if (!state?.stages || !run)
             return;
         for (const stage of run.stages) {
@@ -2424,7 +2401,7 @@ export class LocalServiceRuntime {
                 continue;
             const artifacts = stageArtifactRefs(stage.stage_id, stageState.artifacts);
             for (const artifact of artifacts) {
-                await this.recordCompileRunEvent(prepDataDir, compiledPath, runId, {
+                await this.recordBuildRunEvent(prepDataDir, verifiableContextPath, runId, {
                     type: "artifact.written",
                     event_id: createRunEventId("event"),
                     run_id: runId,
@@ -2433,7 +2410,7 @@ export class LocalServiceRuntime {
                     artifact,
                 });
             }
-            await this.recordCompileRunEvent(prepDataDir, compiledPath, runId, {
+            await this.recordBuildRunEvent(prepDataDir, verifiableContextPath, runId, {
                 type: "proof.updated",
                 event_id: createRunEventId("event"),
                 run_id: runId,
@@ -2453,7 +2430,7 @@ export class LocalServiceRuntime {
         return readSavedReadinessCheckRun(prepDataDir, preparationName);
     }
     checksEvaluatedEvent(runId, readinessRun) {
-        const target = readinessRun.compiled ?? readinessRun.source_files;
+        const target = readinessRun.verifiable_context ?? readinessRun.source_files;
         return {
             type: "checks.evaluated",
             event_id: createRunEventId("event"),
@@ -2474,9 +2451,9 @@ export class LocalServiceRuntime {
             readiness,
         };
     }
-    writeVerifyRun(prepDataDir, compiledPath, run) {
-        mkdirSync(verifyRunsRoot(compiledPath), { recursive: true });
-        writeJsonFile(verifyRunPath(compiledPath, run.run_id), VerifyRunResourceSchema.parse(run));
+    writeVerifyRun(prepDataDir, verifiableContextPath, run) {
+        mkdirSync(verifyRunsRoot(verifiableContextPath), { recursive: true });
+        writeJsonFile(verifyRunPath(verifiableContextPath, run.run_id), VerifyRunResourceSchema.parse(run));
         this.verifyRunCache.invalidatePreparation(prepDataDir, run.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, run.preparation);
     }