@interf/compiler 0.21.0 → 0.22.0

package/dist/packages/engine/agents/lib/shells.js

@@ -2,14 +2,14 @@ import { cpSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, re
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, sep as pathSep } from "node:path";
 import { CHART_APPROXIMATION_NOTES } from "./chart-guidance.js";
-import { buildCompiledSourceFiles } from "../../compile/source-files.js";
-import { METHOD_PACKAGE_DIR } from "../../../project/interf-detect.js";
+import { buildVerifiableContextSourceFiles } from "../../build/source-files.js";
+import { BUILD_PLAN_PACKAGE_DIR } from "../../../project/interf-detect.js";
 import { CHECK_KINDS, } from "../../../contracts/lib/schema.js";
-import { CONTEXT_INTERFACE_FILE as METHOD_SCHEMA_FILE, contextInterfaceArtifactAbsolutePath as compiledArtifactAbsolutePath, listContextInterfaceArtifacts, readContextInterface as readCompiledSchemaFile, resolveContextInterfacePath as resolveMethodSchemaPath, } from "../../../methods/package/context-interface.js";
-import { stageExecutionShellsRoot, methodImprovementLoopRoot, methodPackagePathForCompiled, compiledInterfConfigPath, compiledRuntimeRoot, compiledRuntimeSourceSnapshotPath, compiledRuntimeStageInputsPath, } from "../../compile/compiled-paths.js";
-import { ensureCompiledArtifactTargets } from "../../compile/compiled-schema.js";
+import { CONTEXT_INTERFACE_FILE as BUILD_PLAN_SCHEMA_FILE, contextInterfaceArtifactAbsolutePath as verifiableContextArtifactAbsolutePath, listContextInterfaceArtifacts, readContextInterface as readBuildPlanContextFile, resolveContextInterfacePath as resolveBuildPlanSchemaPath, } from "../../../build-plans/package/context-interface.js";
+import { stageExecutionShellsRoot, buildPlanImprovementLoopRoot, buildPlanPackagePathForVerifiableContext, verifiableContextInterfConfigPath, verifiableContextRuntimeRoot, verifiableContextRuntimeSourceSnapshotPath, verifiableContextRuntimeStageInputsPath, } from "../../build/verifiable-context-paths.js";
+import { ensureBuildPlanArtifactTargets } from "../../build/verifiable-context-schema.js";
 import { listFilesRecursive } from "../../../contracts/utils/filesystem.js";
-import { resolveMethodImprovementReviewSourcePaths } from "../../../methods/package/method-review-paths.js";
+import { resolveBuildPlanImprovementReviewSourcePaths } from "../../../build-plans/package/build-plan-review-paths.js";
 const LOCAL_SKILL_ROOTS = [
     ".claude/skills",
     ".codex/skills",
@@ -24,25 +24,25 @@ export function writeNativeAgentSurface(rootPath, agentsContent, skillName, skil
     changed = writeNativeSkillCopies(rootPath, skillName, skillContent) || changed;
     return changed;
 }
-function compiledQuerySkillSourcePath(compiledPath) {
-    return join(methodPackagePathForCompiled(compiledPath), "use", "query", "SKILL.md");
+function verifiableContextQuerySkillSourcePath(verifiableContextPath) {
+    return join(buildPlanPackagePathForVerifiableContext(verifiableContextPath), "use", "query", "SKILL.md");
 }
-function compiledArtifactSummaryLines(compiledPath) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
+function verifiableContextArtifactSummaryLines(verifiableContextPath) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
     if (!schema)
-        return ["- No Method schema is available yet."];
+        return ["- No Build Plan schema is available yet."];
     return listContextInterfaceArtifacts(schema)
         .filter((artifact) => artifact.kind !== "runtime")
         .map((artifact) => `- \`${artifact.id}\` -> \`${artifact.path}\` (${artifact.role} ${artifact.kind})`);
 }
-export function renderCompiledAgents(compiledPath, name, methodId, about, options = {}) {
-    const methodOriginSelected = options.methodOriginSelected ?? methodId;
-    const methodLocalDraft = options.methodLocalDraft === true;
-    const artifactLines = compiledArtifactSummaryLines(compiledPath);
+export function renderVerifiableContextAgents(verifiableContextPath, name, buildPlanId, about, options = {}) {
+    const buildPlanOriginSelected = options.buildPlanOriginSelected ?? buildPlanId;
+    const buildPlanLocalDraft = options.buildPlanLocalDraft === true;
+    const artifactLines = verifiableContextArtifactSummaryLines(verifiableContextPath);
     return [
         `# ${name}`,
         "",
-        "This is portable context built by Interf.",
+        "This is verifiable context built by Interf.",
         "This folder gives agents prepared evidence, structure, and cross-file connections so they do not have to rediscover the full picture from source files during the job.",
         "",
         ...(about
@@ -51,78 +51,78 @@ export function renderCompiledAgents(compiledPath, name, methodId, about, option
                 "",
             ]
             : []),
-        "## How to use this portable context",
+        "## How to use this verifiable context",
         "",
-        "1. Use the local native `interf-query` skill that Interf generated for this portable context.",
-        "2. Let the Method docs and declared Artifacts guide retrieval instead of assuming a fixed note layout.",
+        "1. Use the local native `interf-query` skill that Interf generated for this verifiable context.",
+        "2. Let the Build Plan docs and declared Artifacts guide retrieval instead of assuming a fixed note layout.",
         "3. Use `.interf/runtime/source-snapshot.json` when you need to inspect the source references behind the output.",
         "",
-        "## How this portable context works",
+        "## How this verifiable context works",
         "",
-        "- The Method package defines the context interface this portable context implements on disk.",
+        "- The Build Plan defines the context interface this verifiable context implements on disk.",
         "- `.interf/interf.json` records the selected Source binding and Preparation metadata.",
-        `- Method seed: \`${methodOriginSelected}\`.`,
-        ...(methodLocalDraft
-            ? ["- This portable context now carries a local Method draft improved from that seed. Recompiling this portable context reuses the local `.interf/method/` package."]
+        `- Build Plan seed: \`${buildPlanOriginSelected}\`.`,
+        ...(buildPlanLocalDraft
+            ? ["- This verifiable context now carries a local Build Plan draft improved from that seed. Rebuilding this verifiable context reuses the local `.interf/build-plan/` package."]
             : []),
-        `- Selected Build Plan / Method package id: \`${methodId}\`.`,
-        "- `.interf/method/` is the local editable Method package for this portable context.",
-        `- \`.interf/method/${METHOD_SCHEMA_FILE}\` is the deterministic context interface for this portable context.`,
-        "- `.interf/method/improve/` is the editable source for Method-improvement loops.",
-        "- `.interf/method/use/query/` is the editable source for the generated native query shell.",
-        "- `.interf/method/compile/stages/` defines stage-specific docs that Interf projects into native execution shells for automated runs.",
+        `- Selected Build Plan id: \`${buildPlanId}\`.`,
+        "- `.interf/build-plan/` is the local editable Build Plan package for this verifiable context.",
+        `- \`.interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}\` is the deterministic context interface for this verifiable context.`,
+        "- `.interf/build-plan/improve/` is the editable source for Build Plan improvement loops.",
+        "- `.interf/build-plan/use/query/` is the editable source for the generated native query shell.",
+        "- `.interf/build-plan/build/stages/` defines stage-specific docs that Interf projects into native execution shells for automated runs.",
         "- Native local query skills are generated under local agent skill directories such as `.claude/skills/` and `.codex/skills/`.",
         "- `.interf/runtime/source-snapshot.json` records the source files assigned to the latest runtime snapshot.",
-        `- Method Artifacts are declared in \`.interf/method/${METHOD_SCHEMA_FILE}\`.`,
+        `- Build Plan Artifacts are declared in \`.interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}\`.`,
         ...artifactLines,
         "- `.interf/runtime/` holds runtime artifacts written by Interf.",
         "- `.interf/tests/` mirrors the latest saved readiness-check run and keeps detailed target runs plus preserved sandboxes.",
-        "- `.interf/tests/targets/` holds detailed source-files and compiled target runs plus preserved test sandboxes.",
+        "- `.interf/tests/targets/` holds detailed source-files and verifiable-context target runs plus preserved test sandboxes.",
         "",
         "## Manual query rules",
         "",
-        "- Prefer the Method-declared context outputs before source re-checks.",
-        "- Use the generated native `interf-query` skill for manual querying. The editable source lives at `.interf/method/use/query/SKILL.md`.",
-        "- Treat `.interf/` as method/runtime metadata, not answer evidence, unless explicitly asked to inspect Method or test history.",
-        "- Use `.interf/runtime/source-snapshot.json` to find source references for quotes, verification, ambiguity, or evidence the portable context does not expose well.",
+        "- Prefer the Build Plan-declared context outputs before source re-checks.",
+        "- Use the generated native `interf-query` skill for manual querying. The editable source lives at `.interf/build-plan/use/query/SKILL.md`.",
+        "- Treat `.interf/` as Build Plan/runtime metadata, not answer evidence, unless explicitly asked to inspect Build Plan or test history.",
+        "- Use `.interf/runtime/source-snapshot.json` to find source references for quotes, verification, ambiguity, or evidence the verifiable context does not expose well.",
         "- If exact chart, table, or image-derived evidence matters, inspect the source reference and say whether the answer was text-derived, table-derived, or chart-derived.",
         "",
         "## Commands",
         "",
         "```",
-        "interf compile            build this portable context",
-        "interf test               run readiness checks against this portable context",
+        "interf build <prep-id>    build this verifiable context",
+        "interf test               run readiness checks against this verifiable context",
         "interf status             show deterministic health",
         "```",
         "",
         "## Rules",
         "",
-        "- Do not modify source files while answering from this portable context.",
+        "- Do not modify source files while answering from this verifiable context.",
         "- Treat prepared notes as working context, not final truth.",
         "- When confidence is low, verify against the source references before answering strongly.",
         "",
     ].join("\n");
 }
-export function renderCompiledQuerySkill() {
+export function renderVerifiableContextQuerySkill() {
     return [
         "# Manual Query Loop",
         "",
         "This file is the editable authoring source for the generated native local `interf-query` skill.",
         "",
         "Default loop:",
-        "1. Read `.interf/method/README.md` and this file first.",
-        `2. Use the Method Artifacts declared in \`.interf/method/${METHOD_SCHEMA_FILE}\` before consulting source references.`,
-        "3. Use `.interf/runtime/source-snapshot.json` for direct quotes, verification, exact lookups, and cases where the portable context is missing the needed evidence or is ambiguous.",
+        "1. Read `.interf/build-plan/README.md` and this file first.",
+        `2. Use the Build Plan Artifacts declared in \`.interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}\` before consulting source references.`,
+        "3. Use `.interf/runtime/source-snapshot.json` for direct quotes, verification, exact lookups, and cases where the verifiable context is missing the needed evidence or is ambiguous.",
         "",
         "Answering rule:",
         "- do not modify source files while answering",
-        "- treat the Method as the portable-context contract and use its Artifacts as the working retrieval surface",
+        "- treat the Build Plan as the verifiable-context contract and use its Artifacts as the working retrieval surface",
         "- say explicitly when an answer depends on approximation, bounded inference, or a source re-check",
-        "- use source references to confirm source page, metric family, provenance, or exact wording when the portable context is missing the needed evidence or is ambiguous",
-        "- do not invent navigation or note structure beyond what this Method declares",
-        "- when the portable context is insufficient, verify against source references and then answer",
+        "- use source references to confirm source page, metric family, provenance, or exact wording when the verifiable context is missing the needed evidence or is ambiguous",
+        "- do not invent navigation or note structure beyond what this Build Plan declares",
+        "- when the verifiable context is insufficient, verify against source references and then answer",
         "",
-        "You can edit this file to bias manual question-answering behavior for this portable context.",
+        "You can edit this file to bias manual question-answering behavior for this verifiable context.",
         "",
     ].join("\n");
 }
@@ -132,7 +132,7 @@ function renderSourceFilesTestAgents() {
         "# Source Files Test Shell",
         "",
         "This is an isolated source-files test shell generated by Interf.",
-        "There is no portable context in this shell.",
+        "There is no verifiable context in this shell.",
         "",
         "## How to use this shell",
         "",
@@ -143,7 +143,7 @@ function renderSourceFilesTestAgents() {
         "## Rules",
         "",
         "- Answer only from source files listed in `runtime/source-files.json`.",
-        "- There is no portable context here, so do not assume any portable-context Artifacts exist.",
+        "- There is no verifiable context here, so do not assume any verifiable-context Artifacts exist.",
         "- Do not treat hidden runtime files or test artifacts as evidence.",
         ...chartNotes,
         "- Write the requested answer and trace files, then stop.",
@@ -168,19 +168,19 @@ function renderSourceFilesTestQuerySkill() {
         "1. Read `runtime/source-files.json`.",
         "2. Verify exact claims against the listed source locators before answering strongly.",
         ...chartNotes,
-        "8. Do not rely on portable-context artifacts because they do not exist in this shell.",
+        "8. Do not rely on verifiable-context artifacts because they do not exist in this shell.",
         "",
     ].join("\n");
 }
-function readCompiledQuerySkillSource(compiledPath) {
-    const filePath = compiledQuerySkillSourcePath(compiledPath);
+function readVerifiableContextQuerySkillSource(verifiableContextPath) {
+    const filePath = verifiableContextQuerySkillSourcePath(verifiableContextPath);
     if (!existsSync(filePath)) {
-        throw new Error(`Missing compiled query skill source at ${filePath}. Interf compile runs the local Method package directly, so reseed or repair this portable context instead of auto-healing query docs.`);
+        throw new Error(`Missing verifiable-context query skill source at ${filePath}. Interf build runs the local Build Plan package directly, so reseed or repair this verifiable context instead of auto-healing query docs.`);
     }
     return readFileSync(filePath, "utf8").trim();
 }
-function stageShellMethodRoot(shellRoot) {
-    return join(shellRoot, METHOD_PACKAGE_DIR);
+function stageShellBuildPlanRoot(shellRoot) {
+    return join(shellRoot, BUILD_PLAN_PACKAGE_DIR);
 }
 function shellInputArtifactPath(shellRoot, artifactId) {
     return join(shellRoot, "inputs", artifactId);
@@ -233,11 +233,11 @@ function linkRelativePath(targetPath, linkPathname) {
     mkdirSync(dirname(linkPathname), { recursive: true });
     symlinkSync(relative(dirname(linkPathname), targetPath), linkPathname);
 }
-function loadCompiledSchema(compiledPath) {
-    const methodRoot = methodPackagePathForCompiled(compiledPath);
-    const schema = readCompiledSchemaFile(methodRoot);
+function loadVerifiableContextSchema(verifiableContextPath) {
+    const buildPlanRoot = buildPlanPackagePathForVerifiableContext(verifiableContextPath);
+    const schema = readBuildPlanContextFile(buildPlanRoot);
     if (!schema) {
-        throw new Error(`Missing Method schema at ${join(methodRoot, METHOD_SCHEMA_FILE)}`);
+        throw new Error(`Missing Build Plan schema at ${join(buildPlanRoot, BUILD_PLAN_SCHEMA_FILE)}`);
     }
     return schema;
 }
@@ -247,7 +247,7 @@ function artifactMap(schema) {
 function artifactOrThrow(artifacts, artifactId) {
     const artifact = artifacts.get(artifactId);
     if (!artifact) {
-        throw new Error(`Missing Method schema Artifact "${artifactId}" for stage shell projection.`);
+        throw new Error(`Missing Build Plan schema Artifact "${artifactId}" for stage shell projection.`);
     }
     return artifact;
 }
@@ -301,25 +301,25 @@ function ensureShellLocalProjection(sourcePath, targetPath, artifact) {
     }
     mkdirSync(targetPath, { recursive: true });
 }
-function ensureCompiledExecutionSurface(compiledPath) {
-    mkdirSync(compiledRuntimeRoot(compiledPath), { recursive: true });
-    mkdirSync(methodPackagePathForCompiled(compiledPath), { recursive: true });
-    const schema = loadCompiledSchema(compiledPath);
-    ensureCompiledArtifactTargets(compiledPath, schema);
+function ensureBuildExecutionSurface(verifiableContextPath) {
+    mkdirSync(verifiableContextRuntimeRoot(verifiableContextPath), { recursive: true });
+    mkdirSync(buildPlanPackagePathForVerifiableContext(verifiableContextPath), { recursive: true });
+    const schema = loadVerifiableContextSchema(verifiableContextPath);
+    ensureBuildPlanArtifactTargets(verifiableContextPath, schema);
     return schema;
 }
-function readStageMethodDoc(compiledPath, stage) {
-    const path = join(methodPackagePathForCompiled(compiledPath), "compile", "stages", stage.skillDir, "SKILL.md");
+function readStageBuildPlanDoc(verifiableContextPath, stage) {
+    const path = join(buildPlanPackagePathForVerifiableContext(verifiableContextPath), "build", "stages", stage.skillDir, "SKILL.md");
     if (!existsSync(path))
         return null;
     return readFileSync(path, "utf8").trim();
 }
-function stageMethodDocsPath(compiledPath, stage) {
-    return join(methodPackagePathForCompiled(compiledPath), "compile", "stages", stage.skillDir);
+function stageBuildPlanDocsPath(verifiableContextPath, stage) {
+    return join(buildPlanPackagePathForVerifiableContext(verifiableContextPath), "build", "stages", stage.skillDir);
 }
-function renderStageExecutionAgents(compiledName, methodId, stage) {
+function renderStageExecutionAgents(verifiableContextName, buildPlanId, stage) {
     return [
-        `# ${compiledName} — ${stage.label} Execution Shell`,
+        `# ${verifiableContextName} — ${stage.label} Execution Shell`,
         "",
         "This is an ephemeral stage-execution shell generated by Interf.",
         "It is for automated pipeline execution only, not for manual querying.",
@@ -339,16 +339,16 @@ function renderStageExecutionAgents(compiledName, methodId, stage) {
         "- For file Artifacts, `runtime/paths.json` points to the exact file path inside those mount roots.",
         "- `runtime/source-snapshot.json` = source references captured for this run.",
         "- `runtime/stage-inputs.json` = exact source references assigned to this stage.",
-        "- declared Artifact paths are also projected at the shell root so Method-relative contract paths stay valid.",
+        "- declared Artifact paths are also projected at the shell root so Build Plan-relative contract paths stay valid.",
         "- `runtime/` = stage contract and machine-readable path map for this shell.",
-        "- `method/` = Method metadata, `method.schema.json`, and docs for the current stage only.",
+        "- `build-plan/` = Build Plan metadata, `build-plan.schema.json`, and docs for the current stage only.",
         "",
         "## Boundaries",
         "",
-        `- Method: \`${methodId}\`.`,
+        `- Build Plan: \`${buildPlanId}\`.`,
         `- Contract type: \`${stage.contractType}\`.`,
-        "- This shell has its own AGENTS/CLAUDE/native skills. It does not inherit the portable-context query shell.",
-        "- The portable context root itself is not linked into this shell.",
+        "- This shell has its own AGENTS/CLAUDE/native skills. It does not inherit the verifiable-context query shell.",
+        "- The verifiable-context root itself is not linked into this shell.",
         "- Do not switch into query mode or act like a user-facing assistant.",
         "- Do not modify files under `inputs/` unless the same Artifact is also mounted under `outputs/`.",
         "",
@@ -366,7 +366,7 @@ function renderStageExecutionAgents(compiledName, methodId, stage) {
         "",
     ].join("\n");
 }
-function renderStageExecutionSkill(stage, stageMethodDoc) {
+function renderStageExecutionSkill(stage, stageBuildPlanDoc) {
     return [
         "---",
         "name: interf-stage",
@@ -390,64 +390,64 @@ function renderStageExecutionSkill(stage, stageMethodDoc) {
         `- contract type: \`${stage.contractType}\``,
         `- reads: ${stage.reads.join(", ")}`,
         `- writes: ${stage.writes.join(", ")}`,
-        `- editable source: \`method/compile/stages/${stage.skillDir}/SKILL.md\``,
+        `- editable source: \`build-plan/build/stages/${stage.skillDir}/SKILL.md\``,
         "",
-        ...(stageMethodDoc
+        ...(stageBuildPlanDoc
             ? [
-                "## Stage Method",
+                "## Stage Build Plan",
                 "",
-                stageMethodDoc,
+                stageBuildPlanDoc,
                 "",
             ]
             : []),
     ].join("\n");
 }
-function renderCompiledQueryNativeSkill(querySkillContent) {
+function renderVerifiableContextQueryNativeSkill(querySkillContent) {
     return [
         "---",
         "name: interf-query",
         "description: >",
-        "  Native local query skill for this portable context built by Interf.",
-        "  Use it for manual questions against the portable context and source references.",
+        "  Native local query skill for verifiable context built by Interf.",
+        "  Use it for manual questions against verifiable context and source references.",
         "---",
         "",
         "# Interf Query",
         "",
-        "This is the native local query skill for portable context built by Interf.",
-        "Use it when reading this portable context manually.",
-        "Editable source: `.interf/method/use/query/SKILL.md`.",
+        "This is the native local query skill for verifiable context built by Interf.",
+        "Use it when reading this verifiable context manually.",
+        "Editable source: `.interf/build-plan/use/query/SKILL.md`.",
         "",
         querySkillContent.trim(),
         "",
     ].join("\n");
 }
-function projectMethodMetadata(compiledPath, shellRoot, stage) {
-    const shellMethodRoot = stageShellMethodRoot(shellRoot);
-    mkdirSync(join(shellMethodRoot, "compile", "stages"), { recursive: true });
-    const compiledMethodRoot = methodPackagePathForCompiled(compiledPath);
-    const methodJsonPath = join(compiledMethodRoot, "method.json");
-    if (existsSync(methodJsonPath)) {
-        linkPath(methodJsonPath, join(shellMethodRoot, "method.json"));
+function projectBuildPlanMetadata(verifiableContextPath, shellRoot, stage) {
+    const shellBuildPlanRoot = stageShellBuildPlanRoot(shellRoot);
+    mkdirSync(join(shellBuildPlanRoot, "build", "stages"), { recursive: true });
+    const verifiableContextBuildPlanRoot = buildPlanPackagePathForVerifiableContext(verifiableContextPath);
+    const buildPlanJsonPath = join(verifiableContextBuildPlanRoot, "build-plan.json");
+    if (existsSync(buildPlanJsonPath)) {
+        linkPath(buildPlanJsonPath, join(shellBuildPlanRoot, "build-plan.json"));
     }
-    const compiledSchemaPath = resolveMethodSchemaPath(compiledMethodRoot);
-    if (compiledSchemaPath) {
-        linkPath(compiledSchemaPath, join(shellMethodRoot, METHOD_SCHEMA_FILE));
+    const buildPlanSchemaPath = resolveBuildPlanSchemaPath(verifiableContextBuildPlanRoot);
+    if (buildPlanSchemaPath) {
+        linkPath(buildPlanSchemaPath, join(shellBuildPlanRoot, BUILD_PLAN_SCHEMA_FILE));
     }
-    const readmePath = join(compiledMethodRoot, "README.md");
+    const readmePath = join(verifiableContextBuildPlanRoot, "README.md");
     if (existsSync(readmePath)) {
-        linkPath(readmePath, join(shellMethodRoot, "README.md"));
+        linkPath(readmePath, join(shellBuildPlanRoot, "README.md"));
     }
-    const stageDocsPath = stageMethodDocsPath(compiledPath, stage);
+    const stageDocsPath = stageBuildPlanDocsPath(verifiableContextPath, stage);
     if (existsSync(stageDocsPath)) {
-        linkPath(stageDocsPath, join(shellMethodRoot, "compile", "stages", stage.skillDir));
+        linkPath(stageDocsPath, join(shellBuildPlanRoot, "build", "stages", stage.skillDir));
     }
 }
-function projectCompiledSchemaArtifacts(compiledPath, shellRoot, schema, artifactIds, materializedArtifactIds) {
+function projectVerifiableContextSchemaArtifacts(verifiableContextPath, shellRoot, schema, artifactIds, materializedArtifactIds) {
     const allowedArtifactIds = artifactIds ? new Set(artifactIds) : null;
     for (const artifact of listContextInterfaceArtifacts(schema)) {
         if (allowedArtifactIds && !allowedArtifactIds.has(artifact.id))
             continue;
-        const sourcePath = compiledArtifactAbsolutePath(compiledPath, artifact);
+        const sourcePath = verifiableContextArtifactAbsolutePath(verifiableContextPath, artifact);
         const targetPath = join(shellRoot, artifact.path);
         if (materializedArtifactIds?.has(artifact.id)) {
             ensureShellLocalProjection(sourcePath, targetPath, artifact);
@@ -456,7 +456,7 @@ function projectCompiledSchemaArtifacts(compiledPath, shellRoot, schema, artifac
         linkPath(sourcePath, targetPath);
     }
 }
-function buildStageArtifactMounts(compiledPath, shellRoot, stage, schema) {
+function buildStageArtifactMounts(verifiableContextPath, shellRoot, stage, schema) {
     const artifacts = artifactMap(schema);
     const mountFor = (artifactId) => {
         const artifact = artifactOrThrow(artifacts, artifactId);
@@ -490,19 +490,19 @@ function projectStageArtifactMountAliases(shellRoot, stage, schema) {
         }
     }
 }
-function writeExecutionShellPathsFile(shellRoot, methodId, stage, mounts) {
+function writeExecutionShellPathsFile(shellRoot, buildPlanId, stage, mounts) {
     const paths = {
         kind: "interf-execution-shell",
         version: 1,
-        method: methodId,
+        build_plan: buildPlanId,
         stage: stage.id,
         reads: mounts.reads,
         writes: mounts.writes,
     };
     writeFileSync(shellRuntimePath(shellRoot, "paths.json"), `${JSON.stringify(paths, null, 2)}\n`);
 }
-export function syncStageExecutionShellWrites(compiledPath, shellRoot, stage, writeArtifacts = []) {
-    const schema = ensureCompiledExecutionSurface(compiledPath);
+export function syncStageExecutionShellWrites(verifiableContextPath, shellRoot, stage, writeArtifacts = []) {
+    const schema = ensureBuildExecutionSurface(verifiableContextPath);
     const artifacts = artifactMap(schema);
     const stageWriteArtifacts = Array.from(stageWriteArtifactSet(schema, stage))
         .map((artifactId) => artifactOrThrow(artifacts, artifactId));
@@ -519,25 +519,25 @@ export function syncStageExecutionShellWrites(compiledPath, shellRoot, stage, wr
         const shellArtifactStat = lstatSync(shellArtifactPath);
         if (shellArtifactStat.isSymbolicLink())
             continue;
-        const compiledArtifactPath = compiledArtifactAbsolutePath(compiledPath, artifact);
+        const verifiableContextArtifactPath = verifiableContextArtifactAbsolutePath(verifiableContextPath, artifact);
         if (shellArtifactStat.isDirectory()) {
             const shellArtifactFiles = listFilesRecursive(shellArtifactPath);
-            const compiledArtifactFiles = existsSync(compiledArtifactPath)
-                ? listFilesRecursive(compiledArtifactPath)
+            const verifiableContextArtifactFiles = existsSync(verifiableContextArtifactPath)
+                ? listFilesRecursive(verifiableContextArtifactPath)
                 : [];
-            if (shellArtifactFiles.length === 0 && compiledArtifactFiles.length > 0) {
+            if (shellArtifactFiles.length === 0 && verifiableContextArtifactFiles.length > 0) {
                 continue;
             }
-            rmSync(compiledArtifactPath, { recursive: true, force: true });
-            mkdirSync(dirname(compiledArtifactPath), { recursive: true });
-            cpSync(shellArtifactPath, compiledArtifactPath, {
+            rmSync(verifiableContextArtifactPath, { recursive: true, force: true });
+            mkdirSync(dirname(verifiableContextArtifactPath), { recursive: true });
+            cpSync(shellArtifactPath, verifiableContextArtifactPath, {
                 recursive: true,
                 force: true,
             });
             continue;
         }
-        mkdirSync(dirname(compiledArtifactPath), { recursive: true });
-        copyFileSync(shellArtifactPath, compiledArtifactPath);
+        mkdirSync(dirname(verifiableContextArtifactPath), { recursive: true });
+        copyFileSync(shellArtifactPath, verifiableContextArtifactPath);
     }
     for (const artifactPath of writeArtifacts) {
         const normalizedArtifactPath = normalizeArtifactRelativePath(artifactPath);
@@ -548,21 +548,21 @@ export function syncStageExecutionShellWrites(compiledPath, shellRoot, stage, wr
         const shellArtifactPath = join(shellRoot, normalizedArtifactPath);
         if (!existsSync(shellArtifactPath))
             continue;
-        const compiledArtifactPath = join(compiledPath, normalizedArtifactPath);
+        const verifiableContextArtifactPath = join(verifiableContextPath, normalizedArtifactPath);
         const shellArtifactStat = lstatSync(shellArtifactPath);
         if (shellArtifactStat.isSymbolicLink())
             continue;
         if (shellArtifactStat.isDirectory()) {
-            rmSync(compiledArtifactPath, { recursive: true, force: true });
-            mkdirSync(dirname(compiledArtifactPath), { recursive: true });
-            cpSync(shellArtifactPath, compiledArtifactPath, {
+            rmSync(verifiableContextArtifactPath, { recursive: true, force: true });
+            mkdirSync(dirname(verifiableContextArtifactPath), { recursive: true });
+            cpSync(shellArtifactPath, verifiableContextArtifactPath, {
                 recursive: true,
                 force: true,
             });
             continue;
         }
-        mkdirSync(dirname(compiledArtifactPath), { recursive: true });
-        copyFileSync(shellArtifactPath, compiledArtifactPath);
+        mkdirSync(dirname(verifiableContextArtifactPath), { recursive: true });
+        copyFileSync(shellArtifactPath, verifiableContextArtifactPath);
     }
 }
 function preservedShellManifestPath(rootPath) {
@@ -578,14 +578,14 @@ function shouldSkipFrozenStageShellRelativePath(relativePath) {
         normalized.includes("/improvement-loops/");
 }
 /**
- * System path prefixes a malicious symlink in a Method package must
+ * System path prefixes a malicious symlink in a Build Plan package must
  * never reach. Without this, the freeze-snapshot logic could be
  * tricked into copying anything the running user has access to —
  * `/etc/passwd`, `~/.ssh/id_rsa`, etc. (CSO finding).
  *
  * We deliberately allow targets that escape the immediate freeze
  * root: legitimate execution shells contain symlinks pointing back
- * to the parent workspace's `interf.json`. The threat is only links
+ * to the parent Preparation's `interf.json`. The threat is only links
  * that resolve into truly system-level paths.
  */
 const FORBIDDEN_SYMLINK_TARGET_PREFIXES = [
@@ -637,7 +637,7 @@ function copyResolvedTree(options) {
         // Refuse symlinks resolving into system paths (CSO finding). We
         // deliberately allow links that escape the immediate freeze root
         // because legitimate execution shells contain links back to the
-        // parent workspace's interf.json — the only thing we care about
+        // parent Preparation's interf.json — the only thing we care about
         // is that the realpath does not land in /etc, /sys, /proc, etc.
         ensureSymlinkTargetSafe(realTarget, options.sourcePath);
         const realStat = statSync(realTarget);
@@ -725,30 +725,30 @@ export function renderClaudeBootstrap(content) {
         "",
     ].join("\n");
 }
-function renderMethodAuthoringAgents(options) {
+function renderBuildPlanAuthoringAgents(options) {
     return [
-        `# ${options.label} — Method Authoring Shell`,
+        `# ${options.label} — Build Plan Authoring Shell`,
         "",
-        "This is an automated Method-authoring shell generated by Interf.",
-        "It exists to create one standalone Method package from the source data, desired portable-context outputs, and proof requirements in this task.",
+        "This is an automated Build Plan authoring shell generated by Interf.",
+        "It exists to create one standalone Build Plan package from the source data, desired verifiable-context outputs, and proof requirements in this task.",
         "",
         "## Start Here",
         "",
         "1. Read `runtime/authoring-context.json` now.",
-        `2. Read \`method/README.md\`, \`method/method.json\`, and \`method/${METHOD_SCHEMA_FILE}\` now.`,
+        `2. Read \`build-plan/README.md\`, \`build-plan/build-plan.json\`, and \`build-plan/${BUILD_PLAN_SCHEMA_FILE}\` now.`,
         "3. Read `runtime/source-files.json` and review the listed source locators.",
-        "4. Use the local native `interf-method-author` skill now.",
+        "4. Use the local native `interf-build-plan-author` skill now.",
         "",
         "## Boundaries",
         "",
-        `- New Method package id: \`${options.methodId}\`.`,
+        `- New Build Plan id: \`${options.buildPlanId}\`.`,
         "- Authoring mode: from scratch.",
-        ...(options.referenceMethodId
-            ? [`- Reference Method package id: \`${options.referenceMethodId}\` (context only, not a seed).`]
+        ...(options.referenceBuildPlanId
+            ? [`- Reference Build Plan id: \`${options.referenceBuildPlanId}\` (context only, not a seed).`]
             : []),
-        "- Edit only files under `method/`.",
+        "- Edit only files under `build-plan/`.",
         "- Do not edit source artifacts.",
-        "- Keep the Method package valid for the current compiler API and `method.schema.json`.",
+        "- Keep the Build Plan package valid for the current build API and `build-plan.schema.json`.",
         "- Use kebab-case ids everywhere: stage ids, skill_dir values, Artifact ids, reads/writes values, and package ids. Never use underscores.",
         "- Put deterministic validation on Artifact `checks[]`; do not add stage `acceptance` blocks.",
         "- Prefer direct file-reading and search tools over shell commands for routine file inspection.",
@@ -756,32 +756,32 @@ function renderMethodAuthoringAgents(options) {
         "",
         "## Goal",
         "",
-        "- produce one standalone Method package tuned to the source data, desired outputs, and checks in this task",
+        "- produce one standalone Build Plan package tuned to the source data, desired outputs, and checks in this task",
         "- replace the neutral scaffold topology with the stage graph this agent work needs",
         "- define Artifacts and checks so Interf can show whether the data is ready",
         "- satisfy every `artifact_requirements[]` entry from `runtime/authoring-context.json` when entries are present",
         "- otherwise draft the Build Plan Artifacts from every `requested_artifacts[]` entry; do not ignore or truncate them",
         "- preserve deterministic stage and context-interface contracts",
-        "- stop once the Method edits are complete",
+        "- stop once the Build Plan edits are complete",
         "",
     ].join("\n");
 }
-function renderMethodAuthoringSkill() {
+function renderBuildPlanAuthoringSkill() {
     return [
         "---",
-        "name: interf-method-author",
+        "name: interf-build-plan-author",
         "description: >",
-        "  Native local Method-authoring skill for an automated Interf Method draft run.",
+        "  Native local Build Plan authoring skill for an automated Interf Build Plan draft run.",
         "---",
         "",
-        "# Interf Method Authoring",
+        "# Interf Build Plan Authoring",
         "",
         "Read `runtime/authoring-context.json` first.",
-        "Then review the neutral Method package scaffold under `method/`, read `runtime/source-files.json`, and inspect the listed source locators when needed.",
+        "Then review the neutral Build Plan package scaffold under `build-plan/`, read `runtime/source-files.json`, and inspect the listed source locators when needed.",
         "",
         "Rules:",
-        "- edit only `method/`",
-        `- keep \`method.json\`, \`${METHOD_SCHEMA_FILE}\`, and any changed stage docs aligned`,
+        "- edit only `build-plan/`",
+        `- keep \`build-plan.json\`, \`${BUILD_PLAN_SCHEMA_FILE}\`, and any changed stage docs aligned`,
         "- put deterministic validation on Artifact `checks[]`; do not add stage `acceptance` blocks",
         "- use only CheckKind values listed in `runtime/authoring-context.json`; do not invent aliases",
         "- keep Artifact checks aligned with produced outputs; use stage docs to describe the output contract without requiring exact source-specific phrases in the stage docs",
@@ -789,34 +789,34 @@ function renderMethodAuthoringSkill() {
         "- otherwise draft the Build Plan Artifacts from every `requested_artifacts[]` entry; do not ignore or truncate them",
         "- design the stage graph from the source data and preparation-and-evidence brief",
         "- use kebab-case ids everywhere: stage ids, skill_dir values, Artifact ids, reads/writes values, and package ids; never use underscores",
-        "- replace the placeholder `prepare` stage unless that exact stage is truly the final method",
+        "- replace the placeholder `prepare` stage unless that exact stage is truly the final Build Plan",
         "- keep the package standalone; do not introduce runtime inheritance or hidden source-package assumptions",
-        "- do not introduce wikilinks unless the Method also creates the target note by exact basename or explicit relative path",
+        "- do not introduce wikilinks unless the Build Plan also creates the target note by exact basename or explicit relative path",
         "- respect stage boundaries: do not make structure outputs link to notes or entrypoints first created by later stages",
         "- prefer conservative routing changes over speculative note sprawl",
         "- prefer direct file-reading and search tools over shell commands for routine file inspection",
         "- do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files",
-        "- do not hardcode readiness-check answers into reusable Method docs",
+        "- do not hardcode readiness-check answers into reusable Build Plan docs",
         "- do not edit source artifacts",
         "",
     ].join("\n");
 }
-function improvementMethodDocsPath(compiledPath) {
-    return join(methodPackagePathForCompiled(compiledPath), "improve");
+function improvementBuildPlanDocsPath(verifiableContextPath) {
+    return join(buildPlanPackagePathForVerifiableContext(verifiableContextPath), "improve");
 }
-export function createMethodAuthoringShell(options) {
-    const shellRoot = mkdtempSync(join(tmpdir(), `interf-method-author-${options.methodId}-`));
+export function createBuildPlanAuthoringShell(options) {
+    const shellRoot = mkdtempSync(join(tmpdir(), `interf-build-plan-author-${options.buildPlanId}-`));
     mkdirSync(join(shellRoot, "runtime"), { recursive: true });
     mkdirSync(join(shellRoot, "artifacts"), { recursive: true });
     mkdirSync(join(shellRoot, "logs"), { recursive: true });
     const context = {
-        kind: "interf-method-authoring",
+        kind: "interf-build-plan-authoring",
         version: 1,
         generated_at: new Date().toISOString(),
         authoring_mode: "from-scratch",
-        method_id: options.methodId,
-        method_label: options.label,
-        ...(options.referenceMethodId ? { reference_method_id: options.referenceMethodId } : {}),
+        build_plan_id: options.buildPlanId,
+        build_plan_label: options.label,
+        ...(options.referenceBuildPlanId ? { reference_build_plan_id: options.referenceBuildPlanId } : {}),
         task_prompt: options.taskPrompt,
         allowed_check_kinds: CHECK_KINDS,
         requested_artifacts: options.requestedArtifacts ?? [],
@@ -834,88 +834,88 @@ export function createMethodAuthoringShell(options) {
         },
     };
     writeFileSync(join(shellRoot, "runtime", "authoring-context.json"), `${JSON.stringify(context, null, 2)}\n`);
-    writeFileSync(join(shellRoot, "runtime", "source-files.json"), `${JSON.stringify(buildCompiledSourceFiles(shellRoot, options.sourceFolderPath), null, 2)}\n`);
+    writeFileSync(join(shellRoot, "runtime", "source-files.json"), `${JSON.stringify(buildVerifiableContextSourceFiles(shellRoot, options.sourceFolderPath), null, 2)}\n`);
     copyResolvedTree({
-        sourcePath: options.methodPath,
-        targetPath: join(shellRoot, "method"),
-        shellType: "method-authoring",
+        sourcePath: options.buildPlanPath,
+        targetPath: join(shellRoot, "build-plan"),
+        shellType: "build-plan-authoring",
     });
-    writeNativeAgentSurface(shellRoot, renderMethodAuthoringAgents({
-        methodId: options.methodId,
+    writeNativeAgentSurface(shellRoot, renderBuildPlanAuthoringAgents({
+        buildPlanId: options.buildPlanId,
         label: options.label,
-        referenceMethodId: options.referenceMethodId ?? null,
-    }), "interf-method-author", renderMethodAuthoringSkill());
+        referenceBuildPlanId: options.referenceBuildPlanId ?? null,
+    }), "interf-build-plan-author", renderBuildPlanAuthoringSkill());
     return {
         rootPath: shellRoot,
-        methodBeforePath: join(shellRoot, "artifacts", "method-before"),
-        methodAfterPath: join(shellRoot, "artifacts", "method-after"),
-        promptLogPath: join(shellRoot, "logs", "method-author.prompt.txt"),
-        eventLogPath: join(shellRoot, "logs", "method-author.events.ndjson"),
-        statusLogPath: join(shellRoot, "logs", "method-author.status.log"),
+        buildPlanBeforePath: join(shellRoot, "artifacts", "build-plan-before"),
+        buildPlanAfterPath: join(shellRoot, "artifacts", "build-plan-after"),
+        promptLogPath: join(shellRoot, "logs", "build-plan-author.prompt.txt"),
+        eventLogPath: join(shellRoot, "logs", "build-plan-author.events.ndjson"),
+        statusLogPath: join(shellRoot, "logs", "build-plan-author.status.log"),
     };
 }
-function renderMethodImprovementAgents(compiledName, methodId, loopIndex) {
+function renderBuildPlanImprovementAgents(verifiableContextName, buildPlanId, loopIndex) {
     return [
-        `# ${compiledName} — Method Improvement Shell`,
+        `# ${verifiableContextName} — Build Plan Improvement Shell`,
         "",
-        "This is an automated Method-improvement shell generated by Interf.",
-        "It exists to review failed compile/test runs and edit the Method package for the next variation.",
+        "This is an automated Build Plan improvement shell generated by Interf.",
+        "It exists to review failed Build/check runs and edit the Build Plan package for the next variation.",
         "",
         "## Start Here",
         "",
         "1. Read `runtime/loop-context.json` now.",
-        `2. Read \`method/README.md\`, \`method/method.json\`, and \`method/${METHOD_SCHEMA_FILE}\` now.`,
-        "3. Read `method/improve/SKILL.md` now.",
-        "4. Use the local native `interf-method-improver` skill now.",
+        `2. Read \`build-plan/README.md\`, \`build-plan/build-plan.json\`, and \`build-plan/${BUILD_PLAN_SCHEMA_FILE}\` now.`,
+        "3. Read `build-plan/improve/SKILL.md` now.",
+        "4. Use the local native `interf-build-plan-improver` skill now.",
         "",
         "## Boundaries",
         "",
-        `- Method: \`${methodId}\`.`,
+        `- Build Plan: \`${buildPlanId}\`.`,
         `- Improvement loop: ${loopIndex}.`,
-        "- Edit only files under `method/`.",
+        "- Edit only files under `build-plan/`.",
         "- Do not edit checks, test specs, source files, or generated context outputs.",
-        "- Review context outputs under `artifacts/compiled-view/` and test/runtime evidence under `artifacts/`.",
-        "- Keep the Method package valid for the current compiler API and `method.schema.json`.",
+        "- Review verifiable-context outputs under `artifacts/verifiable-context-view/` and test/runtime evidence under `artifacts/`.",
+        "- Keep the Build Plan package valid for the current build API and `build-plan.schema.json`.",
         "- Put deterministic validation on Artifact `checks[]`; do not add stage `acceptance` blocks.",
         "",
         "## Goal",
         "",
-        "- create a better Method variation for this kind of agent work",
-        "- preserve deterministic portable-context structure",
-        "- stop after the Method edits are complete",
+        "- create a better Build Plan variation for this kind of agent work",
+        "- preserve deterministic verifiable-context structure",
+        "- stop after the Build Plan edits are complete",
         "",
     ].join("\n");
 }
-function readMethodImprovementDoc(compiledPath) {
-    const path = join(improvementMethodDocsPath(compiledPath), "SKILL.md");
+function readBuildPlanImprovementDoc(verifiableContextPath) {
+    const path = join(improvementBuildPlanDocsPath(verifiableContextPath), "SKILL.md");
     if (!existsSync(path))
         return null;
     return readFileSync(path, "utf8").trim();
 }
-function renderMethodImprovementSkill(methodId, loopIndex, improvementDoc) {
+function renderBuildPlanImprovementSkill(buildPlanId, loopIndex, improvementDoc) {
     return [
         "---",
-        "name: interf-method-improver",
+        "name: interf-build-plan-improver",
         "description: >",
-        "  Native local Method-improvement skill for this Interf run.",
-        "  Use it only inside an automated Method-improvement shell.",
+        "  Native local Build Plan improvement skill for this Interf run.",
+        "  Use it only inside an automated Build Plan improvement shell.",
         "---",
         "",
-        `# Interf Method Improvement — ${methodId}`,
+        `# Interf Build Plan Improvement — ${buildPlanId}`,
         "",
-        "This local native skill exists for automated Method-improvement loops.",
+        "This local native skill exists for automated Build Plan improvement loops.",
         "Read `runtime/loop-context.json` first.",
-        "Then review the linked Method package, `artifacts/compiled-view/`, preserved stage shells, runtime logs, and saved test outputs before editing `method/`.",
+        "Then review the linked Build Plan package, `artifacts/verifiable-context-view/`, preserved stage shells, runtime logs, and saved test outputs before editing `build-plan/`.",
         "",
         "## Current Loop",
         "",
-        `- method: \`${methodId}\``,
+        `- Build Plan: \`${buildPlanId}\``,
         `- loop index: ${loopIndex}`,
-        "- editable source: `method/improve/SKILL.md`",
+        "- editable source: `build-plan/improve/SKILL.md`",
         "",
         ...(improvementDoc
             ? [
-                "## Improvement Method",
+                "## Improvement Guidance",
                 "",
                 improvementDoc,
                 "",
@@ -923,19 +923,19 @@ function renderMethodImprovementSkill(methodId, loopIndex, improvementDoc) {
             : []),
     ].join("\n");
 }
-function projectCompiledReviewArtifactsSnapshot(compiledPath, shellRoot, schema) {
-    const compiledViewRoot = join(shellRoot, "artifacts", "compiled-view");
-    mkdirSync(compiledViewRoot, { recursive: true });
+function projectVerifiableContextReviewArtifactsSnapshot(verifiableContextPath, shellRoot, schema) {
+    const verifiableContextViewRoot = join(shellRoot, "artifacts", "verifiable-context-view");
+    mkdirSync(verifiableContextViewRoot, { recursive: true });
     for (const artifact of listContextInterfaceArtifacts(schema)) {
         if (artifact.kind === "runtime" || artifact.path === "source-files")
             continue;
-        const sourcePath = compiledArtifactAbsolutePath(compiledPath, artifact);
+        const sourcePath = verifiableContextArtifactAbsolutePath(verifiableContextPath, artifact);
         if (!existsSync(sourcePath))
             continue;
         copyResolvedTree({
             sourcePath,
-            targetPath: join(compiledViewRoot, artifact.path),
-            shellType: "method-improvement",
+            targetPath: join(verifiableContextViewRoot, artifact.path),
+            shellType: "build-plan-improvement",
         });
     }
 }
@@ -948,10 +948,10 @@ function copyIfExists(sourcePath, targetPath, shellType) {
         shellType,
     });
 }
-function projectCompiledRuntimeArtifacts(compiledPath, shellRoot) {
-    const runtimeTarget = join(shellRoot, "artifacts", "compiled-runtime");
+function projectVerifiableContextRuntimeArtifacts(verifiableContextPath, shellRoot) {
+    const runtimeTarget = join(shellRoot, "artifacts", "verifiable-context-runtime");
     mkdirSync(runtimeTarget, { recursive: true });
-    const runtimeRoot = compiledRuntimeRoot(compiledPath);
+    const runtimeRoot = verifiableContextRuntimeRoot(verifiableContextPath);
     const artifactNames = [
         "run.json",
         "run-history.jsonl",
@@ -964,40 +964,40 @@ function projectCompiledRuntimeArtifacts(compiledPath, shellRoot) {
         "logs",
     ];
     for (const artifactName of artifactNames) {
-        copyIfExists(join(runtimeRoot, artifactName), join(runtimeTarget, artifactName), "method-improvement");
+        copyIfExists(join(runtimeRoot, artifactName), join(runtimeTarget, artifactName), "build-plan-improvement");
     }
 }
-export function pruneStageExecutionShells(compiledPath) {
-    rmSync(stageExecutionShellsRoot(compiledPath), { recursive: true, force: true });
+export function pruneStageExecutionShells(verifiableContextPath) {
+    rmSync(stageExecutionShellsRoot(verifiableContextPath), { recursive: true, force: true });
 }
-export function projectCompiledQueryShell(compiledPath, compiledName, methodId, about, options) {
-    const agentsContent = renderCompiledAgents(compiledPath, compiledName, methodId, about, options);
-    const querySkillContent = readCompiledQuerySkillSource(compiledPath);
-    return writeNativeAgentSurface(compiledPath, agentsContent, "interf-query", renderCompiledQueryNativeSkill(querySkillContent));
+export function projectVerifiableContextQueryShell(verifiableContextPath, verifiableContextName, buildPlanId, about, options) {
+    const agentsContent = renderVerifiableContextAgents(verifiableContextPath, verifiableContextName, buildPlanId, about, options);
+    const querySkillContent = readVerifiableContextQuerySkillSource(verifiableContextPath);
+    return writeNativeAgentSurface(verifiableContextPath, agentsContent, "interf-query", renderVerifiableContextQueryNativeSkill(querySkillContent));
 }
 export function projectSourceFilesTestQueryShell(rootPath) {
     return writeNativeAgentSurface(rootPath, renderSourceFilesTestAgents(), "interf-query", renderSourceFilesTestQuerySkill());
 }
-export function createStageExecutionShell(compiledPath, compiledName, methodId, stage, writeArtifacts = []) {
-    const schema = ensureCompiledExecutionSurface(compiledPath);
+export function createStageExecutionShell(verifiableContextPath, verifiableContextName, buildPlanId, stage, writeArtifacts = []) {
+    const schema = ensureBuildExecutionSurface(verifiableContextPath);
     const materializedArtifacts = stageMaterializedArtifactSet(schema, stage, writeArtifacts);
-    const shellsRoot = stageExecutionShellsRoot(compiledPath);
+    const shellsRoot = stageExecutionShellsRoot(verifiableContextPath);
     const shellRoot = join(shellsRoot, `${stage.id}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
     mkdirSync(shellRoot, { recursive: true });
     mkdirSync(join(shellRoot, "runtime"), { recursive: true });
     mkdirSync(join(shellRoot, ".interf", "runtime"), { recursive: true });
     mkdirSync(join(shellRoot, "inputs"), { recursive: true });
     mkdirSync(join(shellRoot, "outputs"), { recursive: true });
-    linkPath(compiledInterfConfigPath(compiledPath), join(shellRoot, "interf.json"));
-    linkPath(join(compiledRuntimeRoot(compiledPath), "stage-contract.json"), shellRuntimePath(shellRoot, "stage-contract.json"));
-    linkIfExists(compiledRuntimeSourceSnapshotPath(compiledPath), shellRuntimePath(shellRoot, "source-snapshot.json"));
-    linkIfExists(compiledRuntimeStageInputsPath(compiledPath, stage.id), shellRuntimePath(shellRoot, "stage-inputs.json"));
-    projectCompiledSchemaArtifacts(compiledPath, shellRoot, schema, new Set([...stage.reads, ...stage.writes]), materializedArtifacts);
-    projectMethodMetadata(compiledPath, shellRoot, stage);
+    linkPath(verifiableContextInterfConfigPath(verifiableContextPath), join(shellRoot, "interf.json"));
+    linkPath(join(verifiableContextRuntimeRoot(verifiableContextPath), "stage-contract.json"), shellRuntimePath(shellRoot, "stage-contract.json"));
+    linkIfExists(verifiableContextRuntimeSourceSnapshotPath(verifiableContextPath), shellRuntimePath(shellRoot, "source-snapshot.json"));
+    linkIfExists(verifiableContextRuntimeStageInputsPath(verifiableContextPath, stage.id), shellRuntimePath(shellRoot, "stage-inputs.json"));
+    projectVerifiableContextSchemaArtifacts(verifiableContextPath, shellRoot, schema, new Set([...stage.reads, ...stage.writes]), materializedArtifacts);
+    projectBuildPlanMetadata(verifiableContextPath, shellRoot, stage);
     projectStageArtifactMountAliases(shellRoot, stage, schema);
-    writeExecutionShellPathsFile(shellRoot, methodId, stage, buildStageArtifactMounts(compiledPath, shellRoot, stage, schema));
-    const agentsContent = renderStageExecutionAgents(compiledName, methodId, stage);
-    writeNativeAgentSurface(shellRoot, agentsContent, "interf-stage", renderStageExecutionSkill(stage, readStageMethodDoc(compiledPath, stage)));
+    writeExecutionShellPathsFile(shellRoot, buildPlanId, stage, buildStageArtifactMounts(verifiableContextPath, shellRoot, stage, schema));
+    const agentsContent = renderStageExecutionAgents(verifiableContextName, buildPlanId, stage);
+    writeNativeAgentSurface(shellRoot, agentsContent, "interf-stage", renderStageExecutionSkill(stage, readStageBuildPlanDoc(verifiableContextPath, stage)));
     return {
         rootPath: shellRoot,
     };
@@ -1005,48 +1005,48 @@ export function createStageExecutionShell(compiledPath, compiledName, methodId,
 export function freezeStageExecutionShell(rootPath) {
     return freezePreservedShell(rootPath, "stage-execution");
 }
-export function createMethodImprovementShell(options) {
-    const schema = ensureCompiledExecutionSurface(options.compiledPath);
-    const loopRootPath = methodImprovementLoopRoot(options.compiledPath, options.runId, options.loopIndex);
+export function createBuildPlanImprovementShell(options) {
+    const schema = ensureBuildExecutionSurface(options.verifiableContextPath);
+    const loopRootPath = buildPlanImprovementLoopRoot(options.verifiableContextPath, options.runId, options.loopIndex);
     const shellRoot = join(loopRootPath, "shell");
     mkdirSync(shellRoot, { recursive: true });
     mkdirSync(join(shellRoot, "runtime"), { recursive: true });
     mkdirSync(join(shellRoot, "artifacts"), { recursive: true });
     mkdirSync(join(loopRootPath, "logs"), { recursive: true });
     writeFileSync(join(shellRoot, "runtime", "loop-context.json"), `${JSON.stringify(options.context, null, 2)}\n`);
-    projectCompiledReviewArtifactsSnapshot(options.compiledPath, shellRoot, schema);
+    projectVerifiableContextReviewArtifactsSnapshot(options.verifiableContextPath, shellRoot, schema);
     copyResolvedTree({
-        sourcePath: methodPackagePathForCompiled(options.compiledPath),
-        targetPath: join(shellRoot, "method"),
-        shellType: "method-improvement",
+        sourcePath: buildPlanPackagePathForVerifiableContext(options.verifiableContextPath),
+        targetPath: join(shellRoot, "build-plan"),
+        shellType: "build-plan-improvement",
     });
-    copyIfExists(compiledInterfConfigPath(options.compiledPath), join(shellRoot, "interf.json"), "method-improvement");
-    projectCompiledRuntimeArtifacts(options.compiledPath, shellRoot);
-    const reviewSources = resolveMethodImprovementReviewSourcePaths(options.compiledPath);
+    copyIfExists(verifiableContextInterfConfigPath(options.verifiableContextPath), join(shellRoot, "interf.json"), "build-plan-improvement");
+    projectVerifiableContextRuntimeArtifacts(options.verifiableContextPath, shellRoot);
+    const reviewSources = resolveBuildPlanImprovementReviewSourcePaths(options.verifiableContextPath);
     if (reviewSources.executionShells) {
-        copyIfExists(reviewSources.executionShells, join(shellRoot, "artifacts", "execution-shells"), "method-improvement");
+        copyIfExists(reviewSources.executionShells, join(shellRoot, "artifacts", "execution-shells"), "build-plan-improvement");
     }
     if (reviewSources.readinessRuns) {
-        copyIfExists(reviewSources.readinessRuns, join(shellRoot, "artifacts", "readiness-runs"), "method-improvement");
+        copyIfExists(reviewSources.readinessRuns, join(shellRoot, "artifacts", "readiness-runs"), "build-plan-improvement");
     }
     if (reviewSources.targetTestRuns) {
-        copyIfExists(reviewSources.targetTestRuns, join(shellRoot, "artifacts", "test-runs"), "method-improvement");
+        copyIfExists(reviewSources.targetTestRuns, join(shellRoot, "artifacts", "test-runs"), "build-plan-improvement");
     }
     if (reviewSources.targetTestSandboxes) {
-        copyIfExists(reviewSources.targetTestSandboxes, join(shellRoot, "artifacts", "test-sandboxes"), "method-improvement");
+        copyIfExists(reviewSources.targetTestSandboxes, join(shellRoot, "artifacts", "test-sandboxes"), "build-plan-improvement");
     }
-    const agentsContent = renderMethodImprovementAgents(options.compiledName, options.methodId, options.loopIndex);
-    writeNativeAgentSurface(shellRoot, agentsContent, "interf-method-improver", renderMethodImprovementSkill(options.methodId, options.loopIndex, readMethodImprovementDoc(options.compiledPath)));
+    const agentsContent = renderBuildPlanImprovementAgents(options.verifiableContextName, options.buildPlanId, options.loopIndex);
+    writeNativeAgentSurface(shellRoot, agentsContent, "interf-build-plan-improver", renderBuildPlanImprovementSkill(options.buildPlanId, options.loopIndex, readBuildPlanImprovementDoc(options.verifiableContextPath)));
     return {
         rootPath: shellRoot,
         loopRootPath,
-        methodBeforePath: join(loopRootPath, "method-before"),
-        methodAfterPath: join(loopRootPath, "method-after"),
-        promptLogPath: join(loopRootPath, "logs", "method-improver.prompt.txt"),
-        eventLogPath: join(loopRootPath, "logs", "method-improver.events.ndjson"),
-        statusLogPath: join(loopRootPath, "logs", "method-improver.status.log"),
+        buildPlanBeforePath: join(loopRootPath, "build-plan-before"),
+        buildPlanAfterPath: join(loopRootPath, "build-plan-after"),
+        promptLogPath: join(loopRootPath, "logs", "build-plan-improver.prompt.txt"),
+        eventLogPath: join(loopRootPath, "logs", "build-plan-improver.events.ndjson"),
+        statusLogPath: join(loopRootPath, "logs", "build-plan-improver.status.log"),
     };
 }
-export function freezeMethodImprovementShell(rootPath) {
-    return freezePreservedShell(rootPath, "method-improvement");
+export function freezeBuildPlanImprovementShell(rootPath) {
+    return freezePreservedShell(rootPath, "build-plan-improvement");
 }