@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/engine/runtime-caches.js

@@ -4,13 +4,13 @@
  * The local service runtime fronts a filesystem-backed model: every
  * "list" or "get" call walks `.interf/runtime/...`, parses each JSON
  * record through Zod, and returns the typed shape. Polling clients
- * (Compiler UI, CLI status loops) hit those endpoints multiple times
- * per second; on workspaces with hundreds of compile / test runs this
+ * (Interf UI, CLI status loops) hit those endpoints multiple times
+ * per second; on instances with hundreds of build / test runs this
  * shows up as the dominant CPU cost.
  *
  * The caches here memoize the parsed-and-validated results. Each cache
- * is per-workspace so multi-workspace runtimes do not cross-pollinate,
- * and each cache exposes both a read path (`get(...)`) and an explicit
+ * is keyed by Preparation data directory so independent Preparations do
+ * not cross-pollinate, and each cache exposes both a read path (`get(...)`) and an explicit
  * invalidation hook (`invalidate(...)`). The runtime calls
  * `invalidate*` whenever it writes, so the next read repopulates from
  * disk. Invalidation is intentionally broad (per-preparation, not
@@ -21,21 +21,21 @@
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 /**
- * Per-(workspace, preparation) cache for compile run records, plus a
- * runId -> preparation index so `getCompileRun(runId)` can resolve to
+ * Per-(Preparation data directory, preparation) cache for Build run records, plus a
+ * runId -> preparation index so `getBuildRun(runId)` can resolve to
  * the owning preparation without scanning every preparation's runs.
  */
 export class RunListingCache {
     /** prepDataDir -> preparation -> records (newest-first sorted). */
-    byWorkspace = new Map();
+    byPreparationRoot = new Map();
     /** prepDataDir -> runId -> preparation. */
     runIndex = new Map();
     get(prepDataDir, preparation, fill, runIdOf) {
         const wsKey = resolve(prepDataDir);
-        let bucket = this.byWorkspace.get(wsKey);
+        let bucket = this.byPreparationRoot.get(wsKey);
         if (!bucket) {
             bucket = new Map();
-            this.byWorkspace.set(wsKey, bucket);
+            this.byPreparationRoot.set(wsKey, bucket);
         }
         const cached = bucket.get(preparation);
         if (cached)
@@ -60,11 +60,11 @@ export class RunListingCache {
     /** Invalidate a single preparation's cached records and id index. */
     invalidatePreparation(prepDataDir, preparation) {
         const wsKey = resolve(prepDataDir);
-        const bucket = this.byWorkspace.get(wsKey);
+        const bucket = this.byPreparationRoot.get(wsKey);
         if (bucket) {
             bucket.delete(preparation);
             if (bucket.size === 0)
-                this.byWorkspace.delete(wsKey);
+                this.byPreparationRoot.delete(wsKey);
         }
         const index = this.runIndex.get(wsKey);
         if (index) {
@@ -76,27 +76,27 @@ export class RunListingCache {
                 this.runIndex.delete(wsKey);
         }
     }
-    /** Drop everything for a workspace (e.g. after a reset). */
-    invalidateWorkspace(prepDataDir) {
+    /** Drop everything for a Preparation data directory (e.g. after a reset). */
+    invalidatePreparationRoot(prepDataDir) {
         const wsKey = resolve(prepDataDir);
-        this.byWorkspace.delete(wsKey);
+        this.byPreparationRoot.delete(wsKey);
         this.runIndex.delete(wsKey);
     }
 }
 /**
- * Per-(workspace, preparation) readiness cache. Readiness joins compile
+ * Per-(Preparation data directory, preparation) readiness cache. Readiness joins build
  * runs, test runs, readiness-check runs, and the preparation config; it
  * is computed on every poll. The cache invalidates when the runtime
  * writes any of those underlying objects for a given preparation.
  */
 export class ReadinessCache {
-    byWorkspace = new Map();
+    byPreparationRoot = new Map();
     get(prepDataDir, preparation, compute) {
         const wsKey = resolve(prepDataDir);
-        let bucket = this.byWorkspace.get(wsKey);
+        let bucket = this.byPreparationRoot.get(wsKey);
         if (!bucket) {
             bucket = new Map();
-            this.byWorkspace.set(wsKey, bucket);
+            this.byPreparationRoot.set(wsKey, bucket);
         }
         const cached = bucket.get(preparation);
         if (cached !== undefined)
@@ -107,15 +107,15 @@ export class ReadinessCache {
     }
     invalidatePreparation(prepDataDir, preparation) {
         const wsKey = resolve(prepDataDir);
-        const bucket = this.byWorkspace.get(wsKey);
+        const bucket = this.byPreparationRoot.get(wsKey);
         if (bucket) {
             bucket.delete(preparation);
             if (bucket.size === 0)
-                this.byWorkspace.delete(wsKey);
+                this.byPreparationRoot.delete(wsKey);
         }
     }
-    invalidateWorkspace(prepDataDir) {
-        this.byWorkspace.delete(resolve(prepDataDir));
+    invalidatePreparationRoot(prepDataDir) {
+        this.byPreparationRoot.delete(resolve(prepDataDir));
     }
 }
 /**
@@ -154,12 +154,12 @@ export class MtimeListingCache {
     }
 }
 /**
- * Method-package listing cache keyed by the joined mtimes of the
- * builtin / user / workspace method roots. If any of those ticks (a
- * new local Method, an edit to the user library, etc.) the cache
+ * Build Plan listing cache keyed by the joined mtimes of the
+ * bundled / user-library / Preparation-local Build Plan package roots. If
+ * any of those ticks (a new local Build Plan package, an edit to the user library, etc.) the cache
  * misses and we re-resolve.
  */
-export class MethodListingCache {
+export class BuildPlanListingCache {
     cache = new Map();
     get(cacheKey, rootPaths, fill) {
         const fingerprint = rootPaths

package/dist/packages/engine/runtime-event-applier.d.ts

@@ -6,7 +6,7 @@
  * what lets the runtime coordinator stay small: every other handler can
  * compose these without learning the resource shape.
  */
-import { type CompileRun, type InterfRunEvent } from "./execution/lib/schema.js";
+import { type BuildRun, type InterfRunEvent } from "./execution/lib/schema.js";
 import { type LocalJobEvent, type LocalJobRunResource } from "./lib/schema.js";
-export declare function applyEventToCompileRun(run: CompileRun, event: InterfRunEvent): CompileRun;
+export declare function applyEventToBuildRun(run: BuildRun, event: InterfRunEvent): BuildRun;
 export declare function applyEventToLocalJob(run: LocalJobRunResource, event: LocalJobEvent): LocalJobRunResource;

package/dist/packages/engine/runtime-event-applier.js

@@ -1,5 +1,5 @@
 import { uniqueArtifacts } from "./run-observability.js";
-export function applyEventToCompileRun(run, event) {
+export function applyEventToBuildRun(run, event) {
     const now = event.timestamp;
     const stageFor = (stageId) => {
         const existing = run.stages.find((stage) => stage.stage_id === stageId);

package/dist/packages/engine/runtime-persistence.d.ts

@@ -1,10 +1,10 @@
-import { type CompileRun } from "./execution/lib/schema.js";
-import { type RuntimeRun } from "./compile/lib/schema.js";
+import { type BuildRun } from "./execution/lib/schema.js";
+import { type RuntimeRun } from "./build/lib/schema.js";
 import { type ActionProposalResource, type LocalJobRunResource, type VerifyRunResource } from "./lib/schema.js";
-export declare function compileRunsRoot(compiledPath: string): string;
-export declare function compileRunPath(compiledPath: string, runId: string): string;
-export declare function verifyRunsRoot(compiledPath: string): string;
-export declare function verifyRunPath(compiledPath: string, runId: string): string;
+export declare function buildRunsRoot(verifiableContextPath: string): string;
+export declare function buildRunPath(verifiableContextPath: string, runId: string): string;
+export declare function verifyRunsRoot(verifiableContextPath: string): string;
+export declare function verifyRunPath(verifiableContextPath: string, runId: string): string;
 export declare function localJobsRoot(rootPath: string): string;
 export declare function localJobPath(rootPath: string, runId: string): string;
 export declare function actionProposalsRoot(rootPath: string): string;
@@ -20,7 +20,7 @@ export declare function readJsonOrNull<T>(filePath: string, schema: {
     };
 }): T | null;
 export declare function listJsonFiles(dirPath: string): string[];
-export declare function readCompileRunAt(filePath: string): CompileRun | null;
+export declare function readBuildRunAt(filePath: string): BuildRun | null;
 export declare function readVerifyRunAt(filePath: string): VerifyRunResource | null;
 export declare function readLocalJobRunAt(filePath: string): LocalJobRunResource | null;
 export declare function readActionProposalAt(filePath: string): ActionProposalResource | null;
@@ -29,10 +29,10 @@ export declare function readActionProposalAt(filePath: string): ActionProposalRe
  * record; lines that fail to parse are silently skipped so the runtime can
  * tolerate a partially-written tail without crashing.
  */
-export declare function readRuntimeRunHistory(compiledPath: string): RuntimeRun[];
+export declare function readRuntimeRunHistory(verifiableContextPath: string): RuntimeRun[];
 /**
  * Sort items newest-first using `started_at` (with a `finished_at` fallback).
- * Used for compile/test run lists where the canonical order is by activity
+ * Used for build/test run lists where the canonical order is by activity
  * window, not by record-creation time.
  */
 export declare function newestFirst<T extends {

package/dist/packages/engine/runtime-persistence.js

@@ -7,23 +7,23 @@
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
-import { CompileRunSchema, } from "./execution/lib/schema.js";
-import { compiledRuntimeRunHistoryPath, compiledRuntimeRoot, testRootForCompiled, } from "./compile/compiled-paths.js";
-import { RuntimeRunSchema, } from "./compile/lib/schema.js";
+import { BuildRunSchema, } from "./execution/lib/schema.js";
+import { verifiableContextRuntimeRunHistoryPath, verifiableContextRuntimeRoot, testRootForVerifiableContext, } from "./build/verifiable-context-paths.js";
+import { RuntimeRunSchema, } from "./build/lib/schema.js";
 import { asPreparationDataDir, preparationServiceActionProposalsRoot, preparationServiceJobsRoot, } from "../contracts/lib/preparation-paths.js";
 import { ActionProposalResourceSchema, LocalJobRunResourceSchema, VerifyRunResourceSchema, } from "./lib/schema.js";
 // ---- Path helpers --------------------------------------------------------
-export function compileRunsRoot(compiledPath) {
-    return join(compiledRuntimeRoot(compiledPath), "compile-runs");
+export function buildRunsRoot(verifiableContextPath) {
+    return join(verifiableContextRuntimeRoot(verifiableContextPath), "build-runs");
 }
-export function compileRunPath(compiledPath, runId) {
-    return join(compileRunsRoot(compiledPath), `${runId}.json`);
+export function buildRunPath(verifiableContextPath, runId) {
+    return join(buildRunsRoot(verifiableContextPath), `${runId}.json`);
 }
-export function verifyRunsRoot(compiledPath) {
-    return join(testRootForCompiled(compiledPath), "service-runs");
+export function verifyRunsRoot(verifiableContextPath) {
+    return join(testRootForVerifiableContext(verifiableContextPath), "service-runs");
 }
-export function verifyRunPath(compiledPath, runId) {
-    return join(verifyRunsRoot(compiledPath), `${runId}.json`);
+export function verifyRunPath(verifiableContextPath, runId) {
+    return join(verifyRunsRoot(verifiableContextPath), `${runId}.json`);
 }
 export function localJobsRoot(rootPath) {
     return preparationServiceJobsRoot(asPreparationDataDir(rootPath));
@@ -72,8 +72,8 @@ export function listJsonFiles(dirPath) {
         .map((entry) => join(dirPath, entry));
 }
 // ---- Typed readers -------------------------------------------------------
-export function readCompileRunAt(filePath) {
-    return readJsonOrNull(filePath, CompileRunSchema);
+export function readBuildRunAt(filePath) {
+    return readJsonOrNull(filePath, BuildRunSchema);
 }
 export function readVerifyRunAt(filePath) {
     return readJsonOrNull(filePath, VerifyRunResourceSchema);
@@ -89,8 +89,8 @@ export function readActionProposalAt(filePath) {
  * record; lines that fail to parse are silently skipped so the runtime can
  * tolerate a partially-written tail without crashing.
  */
-export function readRuntimeRunHistory(compiledPath) {
-    const historyPath = compiledRuntimeRunHistoryPath(compiledPath);
+export function readRuntimeRunHistory(verifiableContextPath) {
+    const historyPath = verifiableContextRuntimeRunHistoryPath(verifiableContextPath);
     if (!existsSync(historyPath))
         return [];
     try {
@@ -116,7 +116,7 @@ export function readRuntimeRunHistory(compiledPath) {
 // ---- Sort helpers --------------------------------------------------------
 /**
  * Sort items newest-first using `started_at` (with a `finished_at` fallback).
- * Used for compile/test run lists where the canonical order is by activity
+ * Used for build/test run lists where the canonical order is by activity
  * window, not by record-creation time.
  */
 export function newestFirst(items) {

package/dist/packages/engine/runtime-proposal-helpers.d.ts

@@ -1,7 +1,7 @@
 import { type SourcePreparationConfig } from "../project/lib/schema.js";
 import { type ActionProposalPlanActionType, type ActionProposalResource } from "./lib/schema.js";
-export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
-export type LocalTestMode = "source-files" | "compiled" | "both";
+export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Build Plan and I will prepare an approval proposal.";
+export type LocalTestMode = "source-files" | "verifiable-context" | "both";
 export declare function createActionProposalId(): string;
 export declare function sanitizeActionProposalPlan(value: unknown): unknown;
 export declare function configuredAgentName(): string | null;
@@ -19,17 +19,17 @@ export declare function directServiceEndpointForAction(actionType: ActionProposa
 export declare function numberValue(values: Record<string, unknown> | undefined, key: string): number | null;
 export declare function testModeFromValues(values: Record<string, unknown> | undefined): LocalTestMode | null;
 export declare function testModeValue(values: Record<string, unknown> | undefined, defaultMode?: LocalTestMode): LocalTestMode;
-export declare function testModeCliTarget(mode: LocalTestMode): "source-files" | "portable-context" | "both";
-export declare function methodIdForProposal(message: string, values: Record<string, unknown> | undefined): string;
-export declare function actionValueMethodTaskPrompt(values: Record<string, unknown> | undefined): string | null;
-export declare function normalizeMethodAuthoringText(value: string): string;
-export declare function extractMethodAuthoringSection(value: string, label: string): string | null;
-export declare function stripMethodCommandPrefix(value: string, methodId: string): string;
-export declare function methodAuthoringPromptFallback(message: string, methodId: string): string;
-export declare function methodAuthoringHintFromPrompt(prompt: string): string;
-export declare function methodLabelFromId(methodId: string): string;
-export declare function detachMethodFromPreparation(preparation: SourcePreparationConfig, methodId: string): SourcePreparationConfig;
-export declare function requireSelectedMethod(preparation: SourcePreparationConfig): string;
-export declare function actionCommandPreview(actionType: ActionProposalResource["action_type"], preparationName: string | null, methodId: string | null, values: Record<string, unknown> | undefined): string;
-export declare function hasCompiledTestTarget(sourcePath: string, preparationConfig: SourcePreparationConfig): boolean;
+export declare function testModeCliTarget(mode: LocalTestMode): "source-files" | "verifiable-context";
+export declare function buildPlanIdForProposal(message: string, values: Record<string, unknown> | undefined): string;
+export declare function actionValueBuildPlanTaskPrompt(values: Record<string, unknown> | undefined): string | null;
+export declare function normalizeBuildPlanAuthoringText(value: string): string;
+export declare function extractBuildPlanAuthoringSection(value: string, label: string): string | null;
+export declare function stripBuildPlanCommandPrefix(value: string, buildPlanId: string): string;
+export declare function buildPlanAuthoringPromptFallback(message: string, buildPlanId: string): string;
+export declare function buildPlanAuthoringHintFromPrompt(prompt: string): string;
+export declare function buildPlanLabelFromId(buildPlanId: string): string;
+export declare function detachBuildPlanFromPreparation(preparation: SourcePreparationConfig, buildPlanId: string): SourcePreparationConfig;
+export declare function requireSelectedBuildPlan(preparation: SourcePreparationConfig): string;
+export declare function actionCommandPreview(actionType: ActionProposalResource["action_type"], preparationName: string | null, buildPlanId: string | null, values: Record<string, unknown> | undefined): string;
+export declare function hasVerifiableContextTestTarget(sourcePath: string, preparationConfig: SourcePreparationConfig): boolean;
 export declare function actionAssistantMessage(actionType: ActionProposalResource["action_type"], preparationName: string | null, commandPreview: string): string;

package/dist/packages/engine/runtime-proposal-helpers.js

@@ -1,5 +1,5 @@
 /**
- * Pure helpers used by the runtime's action-proposal and method-authoring
+ * Pure helpers used by the runtime's action-proposal and Build Plan authoring
  * paths. None of these depend on runtime state — they shape strings, parse
  * proposal values, and build CLI previews. Keeping them out of runtime.ts
  * lets the coordinator stay small and means future tests can reach these
@@ -9,12 +9,12 @@ import { existsSync } from "node:fs";
 import { AGENTS, } from "./agents/lib/constants.js";
 import { detectAgents, supportsAutomatedRuns, } from "./agents/lib/detection.js";
 import { loadUserConfig, } from "./agents/lib/user-config.js";
-import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../project/source-config.js";
-import { createCompiledTestTarget, } from "./verify/verify-targets.js";
-import { methodAuthoringTaskPrompt, MethodAuthoringActionValuesSchema, } from "./action-values.js";
+import { asPreparationDataDir, preparationVerifiableContextPath, } from "../contracts/lib/preparation-paths.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../project/source-config.js";
+import { createVerifiableContextTestTarget, } from "./verify/verify-targets.js";
+import { buildPlanAuthoringTaskPrompt, BuildPlanAuthoringActionValuesSchema, } from "./action-values.js";
 import { ActionProposalPlanActionTypeSchema, } from "./lib/schema.js";
-export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
+export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Build Plan and I will prepare an approval proposal.";
 export function createActionProposalId() {
     return `action_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -22,7 +22,7 @@ export function sanitizeActionProposalPlan(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;
     const plan = { ...value };
-    for (const key of ["preparation", "method", "title", "summary", "assistant_message", "command_preview"]) {
+    for (const key of ["preparation", "build_plan", "title", "summary", "assistant_message", "command_preview"]) {
         const current = plan[key];
         if (current === null || current === undefined) {
             delete plan[key];
@@ -77,27 +77,27 @@ export function actionTypeFromValues(values) {
             return parsed.data;
     }
     const action = stringValue(values, "action");
-    if (action === "compile" || action === "compile-run" || action === "run-preparation")
-        return "compile";
+    if (action === "build" || action === "build-run" || action === "run-preparation")
+        return "build";
     if (action === "test" || action === "check-readiness")
         return "test";
     if (action === "draft-readiness-checks" || action === "readiness-check-draft")
         return "readiness-check-draft";
-    if (action === "create-method" || action === "method-authoring")
-        return "method-authoring";
-    if (action === "method-duplicate" || action === "method-remove" || action === "method-change")
-        return "method-change";
+    if (action === "create-build-plan" || action === "build-plan-draft")
+        return "build-plan-draft";
+    if (action === "build-plan-duplicate" || action === "build-plan-remove" || action === "build-plan-change")
+        return "build-plan-change";
     if (action === "preparation-remove" || action === "preparation-change")
         return "preparation-change";
-    if (action === "improve-preparation" || action === "method-improvement")
-        return "method-improvement";
+    if (action === "improve-preparation" || action === "build-plan-improvement")
+        return "build-plan-improvement";
     return null;
 }
 export function directServiceEndpointForAction(actionType) {
     if (actionType === "preparation-setup")
         return "/v1/preparation-setups";
-    if (actionType === "method-change")
-        return "/v1/method-changes";
+    if (actionType === "build-plan-change")
+        return "/v1/build-plan-changes";
     if (actionType === "preparation-change")
         return "/v1/preparation-changes";
     return null;
@@ -108,135 +108,131 @@ export function numberValue(values, key) {
 }
 export function testModeFromValues(values) {
     const value = stringValue(values, "mode") ?? stringValue(values, "target");
-    if (value === "portable-context")
-        return "compiled";
-    return value === "source-files" || value === "compiled" || value === "both" ? value : null;
+    return value === "source-files" || value === "verifiable-context" || value === "both" ? value : null;
 }
-export function testModeValue(values, defaultMode = "both") {
+export function testModeValue(values, defaultMode = "verifiable-context") {
     return testModeFromValues(values) ?? defaultMode;
 }
 export function testModeCliTarget(mode) {
     if (mode === "source-files")
         return "source-files";
-    if (mode === "compiled")
-        return "portable-context";
-    return "both";
-}
-export function methodIdForProposal(message, values) {
-    const explicit = stringValue(values, "method_id") ??
-        stringValue(values, "method");
-    const fromMessage = message.match(/\b(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?method\s+([a-z0-9][a-z0-9-]{0,79})\b/i)?.[1];
+    return "verifiable-context";
+}
+export function buildPlanIdForProposal(message, values) {
+    const explicit = stringValue(values, "build_plan_id") ??
+        stringValue(values, "build_plan");
+    const fromMessage = message.match(/\b(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?build\s+plan\s+([a-z0-9][a-z0-9-]{0,79})\b/i)?.[1];
     return explicit ?? fromMessage ?? `custom-${slugFromText(message)}`;
 }
-export function actionValueMethodTaskPrompt(values) {
-    const parsed = MethodAuthoringActionValuesSchema.safeParse(values);
-    return parsed.success ? methodAuthoringTaskPrompt(parsed.data) : null;
+export function actionValueBuildPlanTaskPrompt(values) {
+    const parsed = BuildPlanAuthoringActionValuesSchema.safeParse(values);
+    return parsed.success ? buildPlanAuthoringTaskPrompt(parsed.data) : null;
 }
-const METHOD_AUTHORING_INTERNAL_INSTRUCTION = /Use the attached values as the Method authoring request before proposing the action\.?/gi;
-const METHOD_AUTHORING_LABELS = [
+const BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION = /Use the attached values as the Build Plan authoring request before proposing the action\.?/gi;
+const BUILD_PLAN_AUTHORING_LABELS = [
     "Agent work",
-    "Portable-context output",
+    "Verifiable context output",
     "Readiness checks",
     "CLI preview",
 ];
-export function normalizeMethodAuthoringText(value) {
+export function normalizeBuildPlanAuthoringText(value) {
     return value
         .replace(/[│]+/g, " ")
-        .replace(METHOD_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .replace(BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION, " ")
         .replace(/\s+/g, " ")
         .trim();
 }
-export function extractMethodAuthoringSection(value, label) {
-    const otherLabels = METHOD_AUTHORING_LABELS
+export function extractBuildPlanAuthoringSection(value, label) {
+    const otherLabels = BUILD_PLAN_AUTHORING_LABELS
         .filter((candidate) => candidate !== label)
         .map(escapeRegExp)
         .join("|");
     const match = value.match(new RegExp(`${escapeRegExp(label)}\\s*:\\s*([\\s\\S]*?)(?=\\s*(?:${otherLabels})\\s*:|$)`, "i"));
-    return match?.[1] ? normalizeMethodAuthoringText(match[1]) : null;
+    return match?.[1] ? normalizeBuildPlanAuthoringText(match[1]) : null;
 }
-export function stripMethodCommandPrefix(value, methodId) {
-    const specific = new RegExp(`^(?:create|reate|eate|draft|author|build|make)\\s+(?:a\\s+new\\s+)?(?:interf\\s+)?method\\s+${escapeRegExp(methodId)}\\.?\\s*`, "i");
-    const generic = /^(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?method\b[^.]{0,180}\.\s*/i;
-    const stripped = normalizeMethodAuthoringText(value)
+export function stripBuildPlanCommandPrefix(value, buildPlanId) {
+    const specific = new RegExp(`^(?:create|reate|eate|draft|author|build|make)\\s+(?:a\\s+new\\s+)?(?:interf\\s+)?build\\s+plan\\s+${escapeRegExp(buildPlanId)}\\.?\\s*`, "i");
+    const generic = /^(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?build\s+plan\b[^.]{0,180}\.\s*/i;
+    const stripped = normalizeBuildPlanAuthoringText(value)
         .replace(specific, "")
         .replace(generic, "")
         .trim();
-    return stripped || normalizeMethodAuthoringText(value);
+    return stripped || normalizeBuildPlanAuthoringText(value);
 }
-export function methodAuthoringPromptFallback(message, methodId) {
+export function buildPlanAuthoringPromptFallback(message, buildPlanId) {
     const cleaned = message
         .replace(/[│]+/g, " ")
-        .replace(METHOD_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .replace(BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION, " ")
         .trim();
-    const agentWork = extractMethodAuthoringSection(cleaned, "Agent work");
-    const portableOutput = extractMethodAuthoringSection(cleaned, "Portable-context output");
-    const readinessNotes = extractMethodAuthoringSection(cleaned, "Readiness checks");
+    const agentWork = extractBuildPlanAuthoringSection(cleaned, "Agent work");
+    const portableOutput = extractBuildPlanAuthoringSection(cleaned, "Verifiable context output");
+    const readinessNotes = extractBuildPlanAuthoringSection(cleaned, "Readiness checks");
     const lines = [
-        agentWork ? `Agent work: ${stripMethodCommandPrefix(agentWork, methodId)}` : null,
-        portableOutput ? `Portable-context output: ${portableOutput}` : null,
+        agentWork ? `Agent work: ${stripBuildPlanCommandPrefix(agentWork, buildPlanId)}` : null,
+        portableOutput ? `Verifiable context output: ${portableOutput}` : null,
         readinessNotes ? `Readiness checks: ${readinessNotes}` : null,
     ].filter((line) => Boolean(line));
     if (lines.length > 0)
         return lines.join("\n");
-    return stripMethodCommandPrefix(cleaned, methodId);
+    return stripBuildPlanCommandPrefix(cleaned, buildPlanId);
 }
-export function methodAuthoringHintFromPrompt(prompt) {
-    const plain = normalizeMethodAuthoringText(prompt.replace(/\b(?:Agent work|Portable-context output|Readiness checks)\s*:/gi, " "));
+export function buildPlanAuthoringHintFromPrompt(prompt) {
+    const plain = normalizeBuildPlanAuthoringText(prompt.replace(/\b(?:Agent work|Verifiable context output|Readiness checks)\s*:/gi, " "));
     if (plain.length <= 180)
-        return plain || "Custom Method";
+        return plain || "Custom Build Plan";
     const clipped = plain.slice(0, 177).replace(/\s+\S*$/, "").trim();
     return `${clipped || plain.slice(0, 177)}...`;
 }
-export function methodLabelFromId(methodId) {
-    return methodId
+export function buildPlanLabelFromId(buildPlanId) {
+    return buildPlanId
         .split("-")
         .filter(Boolean)
         .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
-        .join(" ") || methodId;
+        .join(" ") || buildPlanId;
 }
-export function detachMethodFromPreparation(preparation, methodId) {
-    if (methodIdForSourcePreparationConfig(preparation) !== methodId)
+export function detachBuildPlanFromPreparation(preparation, buildPlanId) {
+    if (buildPlanIdForSourcePreparationConfig(preparation) !== buildPlanId)
         return preparation;
-    const { method: _removedMethod, ...detachedPreparation } = preparation;
+    const { build_plan: _removedBuildPlan, ...detachedPreparation } = preparation;
     return detachedPreparation;
 }
-export function requireSelectedMethod(preparation) {
-    const methodId = methodIdForSourcePreparationConfig(preparation);
-    if (methodId)
-        return methodId;
-    throw new Error(`Select a Method for Preparation "${preparation.name}" before preparing it.`);
+export function requireSelectedBuildPlan(preparation) {
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparation);
+    if (buildPlanId)
+        return buildPlanId;
+    throw new Error(`Select a Build Plan for Preparation "${preparation.name}" before building it.`);
 }
-export function actionCommandPreview(actionType, preparationName, methodId, values) {
-    if (actionType === "compile") {
-        const methodSuffix = methodId ? ` # Method: ${methodId}` : "";
+export function actionCommandPreview(actionType, preparationName, buildPlanId, values) {
+    if (actionType === "build") {
+        const buildPlanSuffix = buildPlanId ? ` # Build Plan: ${buildPlanId}` : "";
         return preparationName
-            ? `interf compile --preparation ${preparationName}${methodSuffix}`
-            : `interf compile${methodSuffix}`;
+            ? `interf build ${preparationName}${buildPlanSuffix}`
+            : `interf build${buildPlanSuffix}`;
     }
     if (actionType === "test") {
         const mode = testModeCliTarget(testModeValue(values));
         return preparationName
-            ? `interf test --preparation ${preparationName} --target ${mode}`
+            ? `interf test ${preparationName} --target ${mode}`
             : `interf test --target ${mode}`;
     }
     if (actionType === "readiness-check-draft") {
         return "interf # choose Auto-create readiness checks";
     }
-    if (actionType === "method-authoring" || actionType === "method-improvement") {
-        return "interf create method";
+    if (actionType === "build-plan-draft" || actionType === "build-plan-improvement") {
+        return "interf build-plan draft";
     }
-    return "Try: create a Preparation, prepare, check readiness, draft readiness checks, or draft a Method.";
+    return "Try: create a Preparation, build, check readiness, draft readiness checks, or draft a Build Plan.";
 }
-export function hasCompiledTestTarget(sourcePath, preparationConfig) {
-    const compiledPath = preparationPortableContextPath(asPreparationDataDir(sourcePath), preparationConfig.name);
-    if (!existsSync(compiledPath))
+export function hasVerifiableContextTestTarget(sourcePath, preparationConfig) {
+    const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(sourcePath), preparationConfig.name);
+    if (!existsSync(verifiableContextPath))
         return false;
-    return createCompiledTestTarget(compiledPath, preparationConfig.name, methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID).eligible;
+    return createVerifiableContextTestTarget(verifiableContextPath, preparationConfig.name, buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID).eligible;
 }
 export function actionAssistantMessage(actionType, preparationName, commandPreview) {
     const preparationSuffix = preparationName ? ` for Preparation "${preparationName}"` : "";
-    if (actionType === "compile") {
-        return `Interf prepared a compile-run proposal${preparationSuffix}. Approve to submit it through the local Interf service and watch the run in Interf. CLI equivalent: ${commandPreview}`;
+    if (actionType === "build") {
+        return `Interf prepared a Build run proposal${preparationSuffix}. Approve to submit it through the local Interf service and watch the run in Interf. CLI equivalent: ${commandPreview}`;
     }
     if (actionType === "test") {
         return `Interf prepared a readiness-check proposal${preparationSuffix}. Approve to run the requested target against saved readiness checks. CLI equivalent: ${commandPreview}`;
@@ -244,8 +240,8 @@ export function actionAssistantMessage(actionType, preparationName, commandPrevi
     if (actionType === "readiness-check-draft") {
         return `Interf prepared a proposal to draft readiness checks${preparationSuffix}. Approve to ask the configured local executor to draft saved checks as a visible run. CLI equivalent: ${commandPreview}`;
     }
-    if (actionType === "method-authoring" || actionType === "method-improvement") {
-        return `Interf prepared a Method draft proposal${preparationSuffix}. Approve to draft a reusable local Method as a visible run. CLI equivalent: ${commandPreview}`;
+    if (actionType === "build-plan-draft" || actionType === "build-plan-improvement") {
+        return `Interf prepared a Build Plan proposal${preparationSuffix}. Approve to draft a reusable Build Plan as a visible run. CLI equivalent: ${commandPreview}`;
     }
-    return "I could not map that to a safe Interf action. Ask for one action in plain English, such as create a Preparation, prepare the data, check readiness, draft readiness checks, or draft a Method.";
+    return "I could not map that to a safe Interf action. Ask for one action in plain English, such as create a Preparation, build context, check readiness, draft readiness checks, or draft a Build Plan.";
 }