@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/project/interf-detect.d.ts

@@ -1,15 +1,15 @@
 import { type InterfConfig } from "./lib/schema.js";
 export type { InterfConfig } from "./lib/schema.js";
-export interface ResolvedCompiled {
+export interface ResolvedVerifiableContext {
     prepDataDir: string;
-    compiledPath: string;
+    verifiableContextPath: string;
     config: InterfConfig;
 }
 export declare const INTERF_CONTAINER_NAME = "interf";
-export declare const METHOD_CONTAINER_NAME = "methods";
+export declare const BUILD_PLAN_CONTAINER_NAME = "build-plans";
 export declare const TEST_CONTAINER_NAME = "tests";
 export declare const INTERF_CONFIG_FILE = "interf.json";
-export declare const METHOD_PACKAGE_DIR = "method";
+export declare const BUILD_PLAN_PACKAGE_DIR = "build-plan";
 export declare function readInterfConfig(dirPath: string): InterfConfig | null;
 export declare function hasSourceFolderInput(config: InterfConfig | null | undefined): config is InterfConfig & {
     source: {
@@ -25,14 +25,14 @@ export declare function detectInterf(cwd: string): {
     path: string;
     config: InterfConfig;
 } | null;
-export declare function resolveCompiled(cwd: string): ResolvedCompiled | null;
-export declare function resolveSourceFolderPath(compiledPath: string, config?: InterfConfig | null): string;
-export declare function resolveSourceControlPath(compiledPath: string): string;
-export declare function resolveSourceInputPath(compiledPath: string): string;
-export declare function listPortableContextsForSourceFolder(prepDataDir: string): Array<{
+export declare function resolveVerifiableContext(cwd: string): ResolvedVerifiableContext | null;
+export declare function resolveSourceFolderPath(verifiableContextPath: string, config?: InterfConfig | null): string;
+export declare function resolveSourceControlPath(verifiableContextPath: string): string;
+export declare function resolveSourceInputPath(verifiableContextPath: string): string;
+export declare function listVerifiableContextsForSourceFolder(prepDataDir: string): Array<{
     path: string;
     config: InterfConfig;
 }>;
-export declare function assertCompiledContainer(prepDataDir: string): string;
+export declare function assertVerifiableContextContainer(prepDataDir: string): string;
 export declare function assertWritableTargetDir(dirPath: string, label: string): void;
-export declare function assertCompiledName(name: string, label: string): void;
+export declare function assertVerifiableContextName(name: string, label: string): void;

package/dist/packages/project/interf-detect.js

@@ -2,17 +2,17 @@ import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { warnInterf } from "../contracts/utils/logger.js";
 import { readJsonFileUnchecked } from "../contracts/utils/parse.js";
-import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../engine/compile/compiled-paths.js";
+import { asPreparationDataDir, preparationVerifiableContextPath, } from "../contracts/lib/preparation-paths.js";
+import { resolveSourceControlPathForVerifiableContext, verifiableContextInterfConfigPath, } from "../engine/build/verifiable-context-paths.js";
 import { InterfConfigSchema, } from "./lib/schema.js";
 import { assertPathWithinRoot } from "../contracts/utils/path-guards.js";
 export const INTERF_CONTAINER_NAME = "interf";
-export const METHOD_CONTAINER_NAME = "methods";
+export const BUILD_PLAN_CONTAINER_NAME = "build-plans";
 export const TEST_CONTAINER_NAME = "tests";
 export const INTERF_CONFIG_FILE = "interf.json";
-export const METHOD_PACKAGE_DIR = "method";
+export const BUILD_PLAN_PACKAGE_DIR = "build-plan";
 export function readInterfConfig(dirPath) {
-    const configPath = compiledInterfConfigPath(dirPath);
+    const configPath = verifiableContextInterfConfigPath(dirPath);
     if (!existsSync(configPath))
         return null;
     const raw = readJsonFileUnchecked(configPath, "Interf config");
@@ -20,7 +20,7 @@ export function readInterfConfig(dirPath) {
         return null;
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         return null;
-    if (raw.type !== "compiled") {
+    if (raw.type !== "verifiable-context") {
         return null;
     }
     const parsed = InterfConfigSchema.safeParse(raw);
@@ -42,37 +42,37 @@ export function detectInterf(cwd) {
         return { path: cwd, config };
     return null;
 }
-export function resolveCompiled(cwd) {
+export function resolveVerifiableContext(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
         return null;
     return {
         prepDataDir: resolveSourceControlPath(detected.path),
-        compiledPath: detected.path,
+        verifiableContextPath: detected.path,
         config: detected.config,
     };
 }
-export function resolveSourceFolderPath(compiledPath, config = null) {
-    const resolvedConfig = config ?? readInterfConfig(compiledPath);
+export function resolveSourceFolderPath(verifiableContextPath, config = null) {
+    const resolvedConfig = config ?? readInterfConfig(verifiableContextPath);
     if (hasSourcePreparationInput(resolvedConfig)) {
-        return resolve(compiledPath, resolvedConfig.source.preparation_path);
+        return resolve(verifiableContextPath, resolvedConfig.source.preparation_path);
     }
     if (hasSourceFolderInput(resolvedConfig)) {
-        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled source path");
+        return assertPathWithinRoot(verifiableContextPath, resolve(verifiableContextPath, resolvedConfig.source.path), "Verifiable context source path");
     }
-    throw new Error(`Portable Context at ${compiledPath} is missing source.preparation_path or source.path in ${compiledInterfConfigPath(compiledPath)}.`);
+    throw new Error(`Verifiable context at ${verifiableContextPath} is missing source.preparation_path or source.path in ${verifiableContextInterfConfigPath(verifiableContextPath)}.`);
 }
-export function resolveSourceControlPath(compiledPath) {
-    return resolveSourceControlPathForCompiled(compiledPath);
+export function resolveSourceControlPath(verifiableContextPath) {
+    return resolveSourceControlPathForVerifiableContext(verifiableContextPath);
 }
-export function resolveSourceInputPath(compiledPath) {
-    const config = readInterfConfig(compiledPath);
+export function resolveSourceInputPath(verifiableContextPath) {
+    const config = readInterfConfig(verifiableContextPath);
     if (hasSourcePreparationInput(config)) {
-        return resolve(compiledPath, config.source.preparation_path);
+        return resolve(verifiableContextPath, config.source.preparation_path);
     }
-    throw new Error(`Portable context is missing source.preparation_path in ${compiledInterfConfigPath(compiledPath)}.`);
+    throw new Error(`Verifiable context is missing source.preparation_path in ${verifiableContextInterfConfigPath(verifiableContextPath)}.`);
 }
-export function listPortableContextsForSourceFolder(prepDataDir) {
+export function listVerifiableContextsForSourceFolder(prepDataDir) {
     if (!existsSync(prepDataDir))
         return [];
     try {
@@ -85,18 +85,18 @@ export function listPortableContextsForSourceFolder(prepDataDir) {
     }
     return readdirSync(prepDataDir)
         .filter((entry) => !entry.startsWith(".") &&
-        entry !== METHOD_CONTAINER_NAME &&
+        entry !== BUILD_PLAN_CONTAINER_NAME &&
         entry !== TEST_CONTAINER_NAME &&
         entry !== INTERF_CONFIG_FILE)
-        .map((entry) => preparationPortableContextPath(asPreparationDataDir(prepDataDir), entry))
-        .filter((compiledPath) => existsSync(compiledPath))
-        .map((compiledPath) => {
-        const config = readInterfConfig(compiledPath);
-        return config ? { path: compiledPath, config } : null;
+        .map((entry) => preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), entry))
+        .filter((verifiableContextPath) => existsSync(verifiableContextPath))
+        .map((verifiableContextPath) => {
+        const config = readInterfConfig(verifiableContextPath);
+        return config ? { path: verifiableContextPath, config } : null;
     })
         .filter((value) => value !== null);
 }
-export function assertCompiledContainer(prepDataDir) {
+export function assertVerifiableContextContainer(prepDataDir) {
     if (existsSync(prepDataDir)) {
         const stat = statSync(prepDataDir);
         if (!stat.isDirectory()) {
@@ -115,7 +115,7 @@ export function assertCompiledContainer(prepDataDir) {
                     return true;
                 }
             }
-            if (entry === METHOD_CONTAINER_NAME ||
+            if (entry === BUILD_PLAN_CONTAINER_NAME ||
                 entry === TEST_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
@@ -157,7 +157,7 @@ export function assertCompiledContainer(prepDataDir) {
                 return true;
             }
         }
-        if (entry === METHOD_CONTAINER_NAME ||
+        if (entry === BUILD_PLAN_CONTAINER_NAME ||
             entry === TEST_CONTAINER_NAME)
             return false;
         const entryPath = join(prepDataDir, entry);
@@ -187,7 +187,7 @@ export function assertWritableTargetDir(dirPath, label) {
         throw new Error(`${label} target already exists and is not empty: ${dirPath}`);
     }
 }
-export function assertCompiledName(name, label) {
+export function assertVerifiableContextName(name, label) {
     if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
         throw new Error(`${label} name must be a safe slug with lowercase letters, numbers, and dashes only: ${name}`);
     }

package/dist/packages/project/interf-scaffold.d.ts

@@ -1,3 +1,3 @@
-export declare function ensurePortableContextScaffold(prepDataDir: string, preparationName: string, methodId?: string): string;
-export declare function createCompiled(name: string, prepDataDir: string, methodId: string | undefined, about: string | undefined, sourceFolderPath: string): string;
-export declare function defaultCompiledNameForSource(prepDataDir: string): string;
+export declare function ensureVerifiableContextScaffold(prepDataDir: string, preparationName: string, buildPlanId?: string): string;
+export declare function createVerifiableContext(name: string, prepDataDir: string, buildPlanId: string | undefined, about: string | undefined, sourceFolderPath: string): string;
+export declare function defaultVerifiableContextNameForSource(prepDataDir: string): string;

package/dist/packages/project/interf-scaffold.js

@@ -1,16 +1,16 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
-import { getCompiledMethod } from "../methods/package/method-definitions.js";
-import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../methods/package/local-methods.js";
-import { initializeCompiledRuntimeState, } from "../engine/compile/state.js";
-import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
-import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
-import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
-import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { ensureCompiledArtifactTargets, listCompiledSchemaArtifacts, readCompiledSchemaFile } from "../engine/compile/compiled-schema.js";
-import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../engine/compile/compiled-paths.js";
-import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
+import { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
+import { loadBuildPlanDefinitionFromDir, seedLocalDefaultBuildPlan } from "../build-plans/package/local-build-plans.js";
+import { initializeBuildRuntimeState, } from "../engine/build/state.js";
+import { refreshVerifiableContextBootstrapGuidance } from "../engine/agents/lib/verifiable-context-bootstrap.js";
+import { assertVerifiableContextContainer, assertVerifiableContextName, } from "./interf-detect.js";
+import { seedVerifiableContextBuildPlanPackage } from "../build-plans/package/interf-build-plan-package.js";
+import { asPreparationDataDir, preparationVerifiableContextPath, } from "../contracts/lib/preparation-paths.js";
+import { ensureBuildPlanArtifactTargets, listBuildPlanContextArtifacts, readBuildPlanContextFile } from "../engine/build/verifiable-context-schema.js";
+import { findSourcePreparationConfig, loadSourceFolderConfig, buildPlanIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, saveVerifiableContextInterfConfig, } from "./source-config.js";
+import { defaultControlPathForVerifiableContext, testRootForVerifiableContext, buildPlanPackagePathForVerifiableContext } from "../engine/build/verifiable-context-paths.js";
+import { DEFAULT_BUILD_PLAN_ID } from "../build-plans/build-plan-resolution.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
     ".codex/",
@@ -21,19 +21,19 @@ const DEFAULT_INTERFIGNORE = [
     ".interf/runtime/",
     "",
 ].join("\n");
-const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet compiled. Run `interf compile` to build this portable context.";
-function renderUncompiledCompiledFile(compiledName, relativePath, about) {
+const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet built. Run `interf build` to build this verifiable context.";
+function renderUnbuiltVerifiableContextFile(verifiableContextName, relativePath, about) {
     return [
-        `# ${compiledName} — ${relativePath}`,
+        `# ${verifiableContextName} — ${relativePath}`,
         "",
         UNCOMPILED_COMPILED_PLACEHOLDER,
         ...(about ? ["", `About: ${about}`] : []),
         "",
     ].join("\n");
 }
-function compiledGitignoreEntries(compiledPath) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const artifactEntries = (schema ? listCompiledSchemaArtifacts(schema) : [])
+function verifiableContextGitignoreEntries(verifiableContextPath) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
+    const artifactEntries = (schema ? listBuildPlanContextArtifacts(schema) : [])
         .filter((artifact) => artifact.kind !== "runtime")
         .map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`);
     return [
@@ -47,90 +47,90 @@ function compiledGitignoreEntries(compiledPath) {
         ".interf/runtime/",
     ];
 }
-function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
+function scaffoldVerifiableContextOutputs(verifiableContextPath, verifiableContextName, about) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
     if (!schema) {
-        throw new Error(`Missing Method schema at ${methodPackagePathForCompiled(compiledPath)}.`);
+        throw new Error(`Missing Build Plan schema at ${buildPlanPackagePathForVerifiableContext(verifiableContextPath)}.`);
     }
-    ensureCompiledArtifactTargets(compiledPath, schema);
-    for (const artifact of listCompiledSchemaArtifacts(schema)) {
+    ensureBuildPlanArtifactTargets(verifiableContextPath, schema);
+    for (const artifact of listBuildPlanContextArtifacts(schema)) {
         if (!artifact.required || artifact.kind !== "file" || artifact.role !== "output")
             continue;
-        const targetPath = join(compiledPath, artifact.path);
+        const targetPath = join(verifiableContextPath, artifact.path);
         if (existsSync(targetPath))
             continue;
-        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, artifact.path, about));
+        writeFileSync(targetPath, renderUnbuiltVerifiableContextFile(verifiableContextName, artifact.path, about));
     }
 }
-function localMethodMatches(compiledPath, methodId) {
-    const localMethod = loadMethodDefinitionFromDir(methodPackagePathForCompiled(compiledPath));
-    return localMethod?.id === methodId;
+function localBuildPlanMatches(verifiableContextPath, buildPlanId) {
+    const localBuildPlan = loadBuildPlanDefinitionFromDir(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
+    return localBuildPlan?.id === buildPlanId;
 }
-export function ensurePortableContextScaffold(prepDataDir, preparationName, methodId = DEFAULT_METHOD_ID) {
-    assertCompiledName(preparationName, "Portable context");
-    assertCompiledContainer(prepDataDir);
-    const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationName);
-    mkdirSync(compiledPath, { recursive: true });
-    mkdirSync(testRootForCompiled(compiledPath), { recursive: true });
-    if (methodId === "interf-default") {
-        seedLocalDefaultMethod({ prepDataDir });
+export function ensureVerifiableContextScaffold(prepDataDir, preparationName, buildPlanId = DEFAULT_BUILD_PLAN_ID) {
+    assertVerifiableContextName(preparationName, "Verifiable context");
+    assertVerifiableContextContainer(prepDataDir);
+    const verifiableContextPath = preparationVerifiableContextPath(asPreparationDataDir(prepDataDir), preparationName);
+    mkdirSync(verifiableContextPath, { recursive: true });
+    mkdirSync(testRootForVerifiableContext(verifiableContextPath), { recursive: true });
+    if (buildPlanId === "interf-default") {
+        seedLocalDefaultBuildPlan({ prepDataDir });
     }
-    const selectedMethod = getCompiledMethod(methodId, { prepDataDir });
-    if (!localMethodMatches(compiledPath, selectedMethod.id)) {
-        seedCompiledMethodPackage({
-            compiledPath,
+    const selectedBuildPlan = getBuildPlan(buildPlanId, { prepDataDir });
+    if (!localBuildPlanMatches(verifiableContextPath, selectedBuildPlan.id)) {
+        seedVerifiableContextBuildPlanPackage({
+            verifiableContextPath,
             prepDataDir,
-            methodId: selectedMethod.id,
+            buildPlanId: selectedBuildPlan.id,
         });
     }
-    if (!existsSync(join(compiledPath, ".gitignore"))) {
-        writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
+    if (!existsSync(join(verifiableContextPath, ".gitignore"))) {
+        writeFileSync(join(verifiableContextPath, ".gitignore"), [...verifiableContextGitignoreEntries(verifiableContextPath), ""].join("\n"));
     }
-    return compiledPath;
+    return verifiableContextPath;
 }
-export function createCompiled(name, prepDataDir, methodId = DEFAULT_METHOD_ID, about, sourceFolderPath) {
-    assertCompiledName(name, "Portable context");
+export function createVerifiableContext(name, prepDataDir, buildPlanId = DEFAULT_BUILD_PLAN_ID, about, sourceFolderPath) {
+    assertVerifiableContextName(name, "Verifiable context");
     if (!sourceFolderPath || typeof sourceFolderPath !== "string") {
-        throw new Error("createCompiled requires an explicit sourceFolderPath. Pass the absolute Source Folder path the portable context binds to.");
+        throw new Error("createVerifiableContext requires an explicit sourceFolderPath. Pass the absolute Source Folder path the verifiable context binds to.");
     }
-    const savedCompiled = findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), name);
-    const effectiveMethodId = methodIdForSourcePreparationConfig(savedCompiled) ?? methodId;
-    const selectedMethod = getCompiledMethod(effectiveMethodId, { prepDataDir });
-    const compiledPath = ensurePortableContextScaffold(prepDataDir, name, selectedMethod.id);
-    const resolvedAbout = about ?? savedCompiled?.about;
-    const resolvedSourceFolderPath = savedCompiled
-        ? resolveConfiguredSourceFolderPath(prepDataDir) ?? resolveSourcePreparationPath(prepDataDir, savedCompiled)
+    const savedPreparation = findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), name);
+    const effectiveBuildPlanId = buildPlanIdForSourcePreparationConfig(savedPreparation) ?? buildPlanId;
+    const selectedBuildPlan = getBuildPlan(effectiveBuildPlanId, { prepDataDir });
+    const verifiableContextPath = ensureVerifiableContextScaffold(prepDataDir, name, selectedBuildPlan.id);
+    const resolvedAbout = about ?? savedPreparation?.about;
+    const resolvedSourceFolderPath = savedPreparation
+        ? resolveConfiguredSourceFolderPath(prepDataDir) ?? resolveSourcePreparationPath(prepDataDir, savedPreparation)
         : sourceFolderPath;
-    const sourceRelativePath = relative(compiledPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
-    saveCompiledInterfConfig(compiledPath, {
-        type: "compiled",
+    const sourceRelativePath = relative(verifiableContextPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
+    saveVerifiableContextInterfConfig(verifiableContextPath, {
+        type: "verifiable-context",
         name,
         ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        method: selectedMethod.id,
-        ...(typeof savedCompiled?.max_attempts === "number"
-            ? { max_attempts: savedCompiled.max_attempts }
+        build_plan: selectedBuildPlan.id,
+        ...(typeof savedPreparation?.max_attempts === "number"
+            ? { max_attempts: savedPreparation.max_attempts }
             : {}),
-        ...(typeof savedCompiled?.max_loops === "number"
-            ? { max_loops: savedCompiled.max_loops }
+        ...(typeof savedPreparation?.max_loops === "number"
+            ? { max_loops: savedPreparation.max_loops }
             : {}),
-        checks: savedCompiled?.checks ?? [],
-        method_origin: {
-            selected: selectedMethod.id,
+        checks: savedPreparation?.checks ?? [],
+        build_plan_origin: {
+            selected: selectedBuildPlan.id,
             local_draft: false,
         },
         source: {
             path: sourceRelativePath,
-            control_path: defaultControlPathForCompiled(compiledPath),
+            control_path: defaultControlPathForVerifiableContext(verifiableContextPath),
             preparation_path: sourceRelativePath,
         },
     });
-    writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
-    scaffoldCompiledOutputs(compiledPath, name, about);
-    refreshCompiledBootstrapGuidance(compiledPath);
-    writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
-    initializeCompiledRuntimeState(compiledPath);
-    return compiledPath;
+    writeFileSync(join(verifiableContextPath, ".interfignore"), DEFAULT_INTERFIGNORE);
+    scaffoldVerifiableContextOutputs(verifiableContextPath, name, about);
+    refreshVerifiableContextBootstrapGuidance(verifiableContextPath);
+    writeFileSync(join(verifiableContextPath, ".gitignore"), [...verifiableContextGitignoreEntries(verifiableContextPath), ""].join("\n"));
+    initializeBuildRuntimeState(verifiableContextPath);
+    return verifiableContextPath;
 }
-export function defaultCompiledNameForSource(prepDataDir) {
+export function defaultVerifiableContextNameForSource(prepDataDir) {
     return basename(prepDataDir);
 }

package/dist/packages/project/interf.d.ts

@@ -1,4 +1,4 @@
-export { INTERF_CONTAINER_NAME, METHOD_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listPortableContextsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-export type { InterfConfig, ResolvedCompiled } from "./interf-detect.js";
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createCompiled, defaultCompiledNameForSource, ensurePortableContextScaffold, } from "./interf-scaffold.js";
+export { INTERF_CONTAINER_NAME, BUILD_PLAN_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, BUILD_PLAN_PACKAGE_DIR, readInterfConfig, detectInterf, resolveVerifiableContext, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listVerifiableContextsForSourceFolder, hasSourceFolderInput, assertVerifiableContextContainer, assertWritableTargetDir, assertVerifiableContextName, } from "./interf-detect.js";
+export type { InterfConfig, ResolvedVerifiableContext } from "./interf-detect.js";
+export { refreshVerifiableContextBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
+export { createVerifiableContext, defaultVerifiableContextNameForSource, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";

package/dist/packages/project/interf.js

@@ -1,3 +1,3 @@
-export { INTERF_CONTAINER_NAME, METHOD_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listPortableContextsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createCompiled, defaultCompiledNameForSource, ensurePortableContextScaffold, } from "./interf-scaffold.js";
+export { INTERF_CONTAINER_NAME, BUILD_PLAN_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, BUILD_PLAN_PACKAGE_DIR, readInterfConfig, detectInterf, resolveVerifiableContext, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listVerifiableContextsForSourceFolder, hasSourceFolderInput, assertVerifiableContextContainer, assertWritableTargetDir, assertVerifiableContextName, } from "./interf-detect.js";
+export { refreshVerifiableContextBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
+export { createVerifiableContext, defaultVerifiableContextNameForSource, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";

package/dist/packages/project/lib/schema.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { MethodIdSchema, PreparationNameSchema } from "../../contracts/lib/schema.js";
-export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+import { BuildPlanIdSchema, PreparationNameSchema } from "../../contracts/lib/schema.js";
+export { BuildPlanIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 export declare const SourceReadinessCheckSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodString;
@@ -108,7 +108,7 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
     name: z.ZodString;
     path: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    method: z.ZodOptional<z.ZodString>;
+    build_plan: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -178,11 +178,11 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
 export declare const SourceFolderBindingSchema: z.ZodObject<{
     path: z.ZodString;
 }, z.core.$loose>;
-export declare const CompiledInterfConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"compiled">;
+export declare const VerifiableContextInterfConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"verifiable-context">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    method: z.ZodString;
+    build_plan: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -198,7 +198,7 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    method_origin: z.ZodOptional<z.ZodObject<{
+    build_plan_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -209,10 +209,10 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const InterfConfigSchema: z.ZodObject<{
-    type: z.ZodLiteral<"compiled">;
+    type: z.ZodLiteral<"verifiable-context">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    method: z.ZodString;
+    build_plan: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -228,7 +228,7 @@ export declare const InterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    method_origin: z.ZodOptional<z.ZodObject<{
+    build_plan_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -247,7 +247,7 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         name: z.ZodString;
         path: z.ZodString;
         about: z.ZodOptional<z.ZodString>;
-        method: z.ZodOptional<z.ZodString>;
+        build_plan: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
         max_loops: z.ZodOptional<z.ZodNumber>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -322,7 +322,7 @@ export type RequestedArtifactOutput = z.infer<typeof RequestedArtifactOutputSche
 export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
 export type SourceProfile = z.infer<typeof SourceProfileSchema>;
 export type PreparationName = z.infer<typeof PreparationNameSchema>;
-export type MethodId = z.infer<typeof MethodIdSchema>;
+export type BuildPlanId = z.infer<typeof BuildPlanIdSchema>;
 export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;
 export type InterfConfig = z.infer<typeof InterfConfigSchema>;
 export type SourceFolderConfig = z.infer<typeof SourceFolderConfigSchema>;

package/dist/packages/project/lib/schema.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { isAbsolute, normalize } from "node:path";
-import { ArtifactPathShapeSchema, CheckSchema, InterfIdPattern, MethodIdSchema, PreparationNameSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
-export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+import { ArtifactPathShapeSchema, CheckSchema, InterfIdPattern, BuildPlanIdSchema, PreparationNameSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
+export { BuildPlanIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 /**
  * Absolute paths that an attacker-controlled config must never reach. The
- * compiler treats `preparation.path` as a filesystem instruction — letting
+ * build runtime treats `preparation.path` as a filesystem instruction — letting
  * a browser-tab forge `/etc` or `/sys` could mutate or read system state.
  * The list mirrors the CSO review allowlist.
  */
@@ -101,9 +101,9 @@ export const SourcePreparationConfigSchema = z.object({
         message: "Preparation path may not contain `..` segments.",
     }),
     about: z.string().min(1).optional(),
-    method: MethodIdSchema.optional(),
-    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+    build_plan: BuildPlanIdSchema.optional(),
+    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
+    max_loops: SourceBuildMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
     requested_artifacts: z.array(RequestedArtifactSchema).optional(),
     source_profile: SourceProfileSchema.optional(),
@@ -111,16 +111,16 @@ export const SourcePreparationConfigSchema = z.object({
 export const SourceFolderBindingSchema = z.object({
     path: z.string().min(1),
 }).passthrough();
-export const CompiledInterfConfigSchema = z.object({
-    type: z.literal("compiled"),
+export const VerifiableContextInterfConfigSchema = z.object({
+    type: z.literal("verifiable-context"),
     name: PreparationNameSchema,
     about: z.string().optional(),
-    method: MethodIdSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+    build_plan: BuildPlanIdSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema.optional(),
+    max_loops: SourceBuildMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
-    method_origin: z.object({
-        selected: MethodIdSchema,
+    build_plan_origin: z.object({
+        selected: BuildPlanIdSchema,
         local_draft: z.boolean().optional(),
     }).optional(),
     source: z.object({
@@ -129,7 +129,7 @@ export const CompiledInterfConfigSchema = z.object({
         preparation_path: z.string().optional(),
     }),
 }).passthrough();
-export const InterfConfigSchema = CompiledInterfConfigSchema;
+export const InterfConfigSchema = VerifiableContextInterfConfigSchema;
 export const SourceFolderConfigSchema = z.object({
     source_folder: SourceFolderBindingSchema.optional(),
     preparations: z.array(SourcePreparationConfigSchema).default([]),

package/dist/packages/project/preparation-entries.d.ts

@@ -5,7 +5,7 @@ export interface SavedPreparationEntry {
     localDraft: boolean;
 }
 export declare function listSavedPreparationEntries(prepDataDir: string): SavedPreparationEntry[];
-export declare function findBuiltPortableContextPath(prepDataDir: string, preparationName: string): string | null;
+export declare function findBuiltVerifiableContextPath(prepDataDir: string, preparationName: string): string | null;
 export declare function findSavedPreparationConfig(prepDataDir: string, preparationName: string): SourcePreparationConfig | null;
-export declare function createPortableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
-export declare function ensurePortableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
+export declare function createVerifiableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;
+export declare function ensureVerifiableContextFromConfig(prepDataDir: string, preparationConfig: SourcePreparationConfig): string;