@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/build-plans/package/user-build-plans.d.ts

@@ -0,0 +1,17 @@
+import { type LocalBuildPlanDefinition } from "./local-build-plans.js";
+export declare function userBuildPlanPath(id: string): string;
+export declare function userBuildPlanExists(id: string): boolean;
+export declare function listUserBuildPlanDefinitions(): LocalBuildPlanDefinition[];
+export declare function loadUserBuildPlanDefinition(id: string): LocalBuildPlanDefinition | null;
+export interface InstallUserBuildPlanOptions {
+    sourceDir: string;
+    id?: string;
+    overwrite?: boolean;
+}
+export interface InstallUserBuildPlanResult {
+    id: string;
+    path: string;
+    overwritten: boolean;
+}
+export declare function installUserBuildPlan(options: InstallUserBuildPlanOptions): InstallUserBuildPlanResult;
+export declare function removeUserBuildPlan(id: string): boolean;

package/dist/packages/build-plans/package/user-build-plans.js

@@ -0,0 +1,77 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { userBuildPlanPackagePath, userBuildPlansRoot, } from "../../contracts/lib/preparation-paths.js";
+import { loadBuildPlanDefinitionFromDir, } from "./local-build-plans.js";
+export function userBuildPlanPath(id) {
+    return userBuildPlanPackagePath(id);
+}
+export function userBuildPlanExists(id) {
+    return existsSync(join(userBuildPlanPath(id), "build-plan.json"));
+}
+export function listUserBuildPlanDefinitions() {
+    const root = userBuildPlansRoot();
+    if (!existsSync(root))
+        return [];
+    const definitions = [];
+    for (const entry of readdirSync(root)) {
+        const entryPath = join(root, entry);
+        try {
+            if (!statSync(entryPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const definition = loadBuildPlanDefinitionFromDir(entryPath);
+        if (definition)
+            definitions.push(definition);
+    }
+    return definitions.sort((a, b) => a.label.localeCompare(b.label));
+}
+export function loadUserBuildPlanDefinition(id) {
+    return loadBuildPlanDefinitionFromDir(userBuildPlanPath(id));
+}
+export function installUserBuildPlan(options) {
+    const sourceDir = resolve(options.sourceDir);
+    if (!existsSync(join(sourceDir, "build-plan.json"))) {
+        throw new Error(`No build-plan.json found at ${sourceDir}.`);
+    }
+    const definition = loadBuildPlanDefinitionFromDir(sourceDir);
+    if (!definition) {
+        throw new Error(`Could not load Build Plan package at ${sourceDir}.`);
+    }
+    const id = options.id ?? definition.id;
+    if (!id)
+        throw new Error("Build Plan id is required.");
+    const targetPath = userBuildPlanPath(id);
+    const existed = existsSync(targetPath);
+    if (existed && !options.overwrite) {
+        throw new Error(`User Build Plan "${id}" already exists at ${targetPath}. Pass overwrite to replace it.`);
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    if (existed)
+        rmSync(targetPath, { recursive: true, force: true });
+    cpSync(sourceDir, targetPath, { recursive: true, force: true });
+    if (id !== definition.id) {
+        const targetBuildPlanJson = join(targetPath, "build-plan.json");
+        const raw = readFileSync(targetBuildPlanJson, "utf8");
+        const parsed = JSON.parse(raw);
+        parsed.id = id;
+        writeFileSync(targetBuildPlanJson, `${JSON.stringify(parsed, null, 2)}\n`);
+    }
+    return { id, path: targetPath, overwritten: existed };
+}
+export function removeUserBuildPlan(id) {
+    const target = userBuildPlanPath(id);
+    if (!existsSync(target))
+        return false;
+    try {
+        rmSync(target, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        warnInterf(`Warning: failed to remove user Build Plan ${id} at ${target}: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}

package/dist/packages/contracts/index.d.ts

@@ -1,3 +1,3 @@
 export * as schema from "./lib/schema.js";
-export type { AgentRecord, AgentsRegistry, Artifact, ArtifactId, ArtifactShape, ArtifactStatus, CanonicalRole, Check, CheckKind, GateStatus, Locator, LocatorKind, MethodId, PreparationName, Proof, ReadinessGate, ReadinessStatus, Readiness, ReadyVerdict, RoleMap, RuntimeContractType, RuntimeExecutorInfo, RuntimeStage, RuntimeTargetType, Source, SourceFile, SourceFiles, SourceKind, SourceSnapshot, StageInput, StageInputs, StandardEvidenceFrontmatterKey, TestCaseExpect, TestTargetType, VerifyTargetResult, } from "./lib/schema.js";
+export type { AgentRecord, AgentsRegistry, Artifact, ArtifactId, ArtifactShape, ArtifactStatus, CanonicalRole, Check, CheckKind, GateStatus, Locator, LocatorKind, BuildPlanId, PreparationName, Proof, ReadinessGate, ReadinessStatus, Readiness, ReadyVerdict, RoleMap, RuntimeContractType, RuntimeExecutorInfo, RuntimeStage, RuntimeTargetType, Source, SourceFile, SourceFiles, SourceKind, SourceSnapshot, StageInput, StageInputs, StandardEvidenceFrontmatterKey, TestCaseExpect, TestTargetType, VerifyTargetResult, } from "./lib/schema.js";
 export { CANONICAL_ROLES, CHECK_KINDS, STANDARD_EVIDENCE_FRONTMATTER_KEYS, } from "./lib/schema.js";

package/dist/packages/contracts/lib/preparation-paths.d.ts

@@ -9,9 +9,9 @@
  *
  * Two roots:
  * - **Interf Home** (`~/.interf/`): per-user, cross-preparation state. Holds
- *   the user-level Method library and the central service registry.
+ *   the user-level Build Plan library and the central service registry.
  * - **Preparation Data Dir**: a directory that IS a preparation's state
- *   root. Holds `interf.json`, `methods/`, the portable context output, and
+ *   root. Holds `interf.json`, `build-plans/`, the verifiable context output, and
  *   the service-internal `.service/` scratch dir. The user's Source Folders
  *   are passed as `--source <path>` — they are inputs, not part of the
  *   preparation data dir.
@@ -30,16 +30,16 @@ export type PreparationDataDir = string & {
 export type SourceFolderPath = string & {
     readonly __brand: "SourceFolderPath";
 };
-/** Absolute path to a portable-context output directory. */
-export type PortableContextPath = string & {
-    readonly __brand: "PortableContextPath";
+/** Absolute path to a verifiable-context output directory. */
+export type VerifiableContextPath = string & {
+    readonly __brand: "VerifiableContextPath";
 };
 /** Preparation config filename. Kept as `interf.json` for back-compat with existing fixtures. */
 export declare const PREPARATION_CONFIG_FILENAME = "interf.json";
-/** The portable-context state directory name (lives at `<portable-context>/.interf/`). */
-export declare const PORTABLE_CONTEXT_STATE_DIR = ".interf";
-/** Method packages directory name (preparation drafts and user library). */
-export declare const METHODS_DIR = "methods";
+/** The verifiable-context state directory name (lives at `<verifiable-context>/.interf/`). */
+export declare const VERIFIABLE_CONTEXT_STATE_DIR = ".interf";
+/** Build Plan packages directory name (preparation drafts and user library). */
+export declare const BUILD_PLANS_DIR = "build-plans";
 /** Service-internal directory inside a preparation data dir. */
 export declare const SERVICE_DIR = ".service";
 /** Service registry filename inside Interf Home. */
@@ -54,33 +54,33 @@ export declare const SERVICE_ACTION_PLANS_DIR = "action-plans";
 export declare const PREPARATION_TESTS_DIR = "tests";
 /** Tests-spec subdir. */
 export declare const PREPARATION_TESTS_SPECS_DIR = "specs";
-/** Per-portable-context tests directory. */
-export declare const PORTABLE_CONTEXT_TESTS_DIR = "tests";
-/** Per-portable-context runtime directory. */
-export declare const PORTABLE_CONTEXT_RUNTIME_DIR = "runtime";
-/** Per-portable-context method package directory. */
-export declare const PORTABLE_CONTEXT_METHOD_DIR = "method";
+/** Per-verifiable-context tests directory. */
+export declare const VERIFIABLE_CONTEXT_TESTS_DIR = "tests";
+/** Per-verifiable-context runtime directory. */
+export declare const VERIFIABLE_CONTEXT_RUNTIME_DIR = "runtime";
+/** Per-verifiable-context Build Plan package directory. */
+export declare const VERIFIABLE_CONTEXT_BUILD_PLAN_DIR = "build-plan";
 /** Environment variable that overrides Interf Home for tests. */
 export declare const INTERF_USER_HOME_ENV = "INTERF_USER_HOME";
 export declare function asPreparationDataDir(path: string): PreparationDataDir;
 /** `~/.interf/` (or `INTERF_USER_HOME` override). */
 export declare function interfHomeRoot(): InterfHomeRoot;
-/** `~/.interf/methods/` — user-level Method library root. */
-export declare function userMethodsRoot(): string;
-/** `~/.interf/methods/<id>/` — a specific user-library Method package. */
-export declare function userMethodPackagePath(methodId: string): string;
+/** `~/.interf/build-plans/` — user-level Build Plan library root. */
+export declare function userBuildPlansRoot(): string;
+/** `~/.interf/build-plans/<id>/` — a specific user-library Build Plan package. */
+export declare function userBuildPlanPackagePath(buildPlanId: string): string;
 /** `~/.interf/services.json` — central service registry. */
 export declare function serviceRegistryPath(): string;
 /** `~/.interf/<basename>/` — per-source-folder default preparation data dir. */
 export declare function defaultPreparationDataDirForSourceBasename(basename: string): PreparationDataDir;
 /** `<prep-data>/interf.json` — preparation config source of truth. */
 export declare function preparationConfigPath(prepDataDir: PreparationDataDir): string;
-/** `<prep-data>/methods/` — preparation-draft Method packages root. */
-export declare function preparationMethodsRoot(prepDataDir: PreparationDataDir): string;
-/** `<prep-data>/methods/<id>/` — a preparation-draft Method package. */
-export declare function preparationMethodPackagePath(prepDataDir: PreparationDataDir, methodId: string): string;
-/** `<prep-data>/<preparation-name>/` — a preparation's portable context root. */
-export declare function preparationPortableContextPath(prepDataDir: PreparationDataDir, preparationName: string): PortableContextPath;
+/** `<prep-data>/build-plans/` — preparation-draft Build Plan packages root. */
+export declare function preparationBuildPlansRoot(prepDataDir: PreparationDataDir): string;
+/** `<prep-data>/build-plans/<id>/` — a preparation-draft Build Plan package. */
+export declare function preparationBuildPlanPackagePath(prepDataDir: PreparationDataDir, buildPlanId: string): string;
+/** `<prep-data>/<preparation-name>/` — a preparation's verifiable context root. */
+export declare function preparationVerifiableContextPath(prepDataDir: PreparationDataDir, preparationName: string): VerifiableContextPath;
 /** `<prep-data>/.service/` — service-owned scratch dir for jobs and proposals. */
 export declare function preparationServiceRoot(prepDataDir: PreparationDataDir): string;
 /** `<prep-data>/.service/jobs/`. */
@@ -91,18 +91,18 @@ export declare function preparationServiceActionProposalsRoot(prepDataDir: Prepa
 export declare function preparationServiceActionPlansRoot(prepDataDir: PreparationDataDir): string;
 /** `<prep-data>/tests/specs/` — saved readiness check specs. */
 export declare function preparationTestsSpecsRoot(prepDataDir: PreparationDataDir): string;
-/** `<portable-context>/.interf/`. */
-export declare function portableContextStateRoot(portableContext: PortableContextPath): string;
-/** `<portable-context>/.interf/interf.json` — runtime contract. */
-export declare function portableContextConfigPath(portableContext: PortableContextPath): string;
-/** `<portable-context>/.interf/method/` — active Method package inside portable context. */
-export declare function portableContextMethodPath(portableContext: PortableContextPath): string;
-/** `<portable-context>/.interf/runtime/`. */
-export declare function portableContextRuntimeRoot(portableContext: PortableContextPath): string;
-/** `<portable-context>/.interf/tests/`. */
-export declare function portableContextTestsRoot(portableContext: PortableContextPath): string;
-/** Test target labels: source-files (raw input) vs compiled (portable context). */
-export type PreparationTestTargetLabel = "source-files" | "compiled";
+/** `<verifiable-context>/.interf/`. */
+export declare function verifiableContextStateRoot(verifiableContext: VerifiableContextPath): string;
+/** `<verifiable-context>/.interf/interf.json` — runtime contract. */
+export declare function verifiableContextConfigPath(verifiableContext: VerifiableContextPath): string;
+/** `<verifiable-context>/.interf/build-plan/` — active Build Plan package inside verifiable context. */
+export declare function verifiableContextBuildPlanPath(verifiableContext: VerifiableContextPath): string;
+/** `<verifiable-context>/.interf/runtime/`. */
+export declare function verifiableContextRuntimeRoot(verifiableContext: VerifiableContextPath): string;
+/** `<verifiable-context>/.interf/tests/`. */
+export declare function verifiableContextTestsRoot(verifiableContext: VerifiableContextPath): string;
+/** Test target labels: source-files (raw input) vs verifiable context. */
+export type PreparationTestTargetLabel = "source-files" | "verifiable-context";
 /** `<prep-data>/<prep>/.interf/tests/`. */
 export declare function preparationTestsRoot(prepDataDir: PreparationDataDir, preparationName: string): string;
 /** `<prep-data>/<prep>/.interf/tests/<target>/runs/`. */

package/dist/packages/contracts/lib/preparation-paths.js

@@ -9,9 +9,9 @@
  *
  * Two roots:
  * - **Interf Home** (`~/.interf/`): per-user, cross-preparation state. Holds
- *   the user-level Method library and the central service registry.
+ *   the user-level Build Plan library and the central service registry.
  * - **Preparation Data Dir**: a directory that IS a preparation's state
- *   root. Holds `interf.json`, `methods/`, the portable context output, and
+ *   root. Holds `interf.json`, `build-plans/`, the verifiable context output, and
  *   the service-internal `.service/` scratch dir. The user's Source Folders
  *   are passed as `--source <path>` — they are inputs, not part of the
  *   preparation data dir.
@@ -25,10 +25,10 @@ import { join } from "node:path";
 // ───────────────────────────────────────────────────────────────────────────
 /** Preparation config filename. Kept as `interf.json` for back-compat with existing fixtures. */
 export const PREPARATION_CONFIG_FILENAME = "interf.json";
-/** The portable-context state directory name (lives at `<portable-context>/.interf/`). */
-export const PORTABLE_CONTEXT_STATE_DIR = ".interf";
-/** Method packages directory name (preparation drafts and user library). */
-export const METHODS_DIR = "methods";
+/** The verifiable-context state directory name (lives at `<verifiable-context>/.interf/`). */
+export const VERIFIABLE_CONTEXT_STATE_DIR = ".interf";
+/** Build Plan packages directory name (preparation drafts and user library). */
+export const BUILD_PLANS_DIR = "build-plans";
 /** Service-internal directory inside a preparation data dir. */
 export const SERVICE_DIR = ".service";
 /** Service registry filename inside Interf Home. */
@@ -43,12 +43,12 @@ export const SERVICE_ACTION_PLANS_DIR = "action-plans";
 export const PREPARATION_TESTS_DIR = "tests";
 /** Tests-spec subdir. */
 export const PREPARATION_TESTS_SPECS_DIR = "specs";
-/** Per-portable-context tests directory. */
-export const PORTABLE_CONTEXT_TESTS_DIR = "tests";
-/** Per-portable-context runtime directory. */
-export const PORTABLE_CONTEXT_RUNTIME_DIR = "runtime";
-/** Per-portable-context method package directory. */
-export const PORTABLE_CONTEXT_METHOD_DIR = "method";
+/** Per-verifiable-context tests directory. */
+export const VERIFIABLE_CONTEXT_TESTS_DIR = "tests";
+/** Per-verifiable-context runtime directory. */
+export const VERIFIABLE_CONTEXT_RUNTIME_DIR = "runtime";
+/** Per-verifiable-context Build Plan package directory. */
+export const VERIFIABLE_CONTEXT_BUILD_PLAN_DIR = "build-plan";
 /** Environment variable that overrides Interf Home for tests. */
 export const INTERF_USER_HOME_ENV = "INTERF_USER_HOME";
 // ───────────────────────────────────────────────────────────────────────────
@@ -67,13 +67,13 @@ export function interfHomeRoot() {
         return override;
     return join(homedir(), ".interf");
 }
-/** `~/.interf/methods/` — user-level Method library root. */
-export function userMethodsRoot() {
-    return join(interfHomeRoot(), METHODS_DIR);
+/** `~/.interf/build-plans/` — user-level Build Plan library root. */
+export function userBuildPlansRoot() {
+    return join(interfHomeRoot(), BUILD_PLANS_DIR);
 }
-/** `~/.interf/methods/<id>/` — a specific user-library Method package. */
-export function userMethodPackagePath(methodId) {
-    return join(userMethodsRoot(), methodId);
+/** `~/.interf/build-plans/<id>/` — a specific user-library Build Plan package. */
+export function userBuildPlanPackagePath(buildPlanId) {
+    return join(userBuildPlansRoot(), buildPlanId);
 }
 /** `~/.interf/services.json` — central service registry. */
 export function serviceRegistryPath() {
@@ -90,16 +90,16 @@ export function defaultPreparationDataDirForSourceBasename(basename) {
 export function preparationConfigPath(prepDataDir) {
     return join(prepDataDir, PREPARATION_CONFIG_FILENAME);
 }
-/** `<prep-data>/methods/` — preparation-draft Method packages root. */
-export function preparationMethodsRoot(prepDataDir) {
-    return join(prepDataDir, METHODS_DIR);
+/** `<prep-data>/build-plans/` — preparation-draft Build Plan packages root. */
+export function preparationBuildPlansRoot(prepDataDir) {
+    return join(prepDataDir, BUILD_PLANS_DIR);
 }
-/** `<prep-data>/methods/<id>/` — a preparation-draft Method package. */
-export function preparationMethodPackagePath(prepDataDir, methodId) {
-    return join(preparationMethodsRoot(prepDataDir), methodId);
+/** `<prep-data>/build-plans/<id>/` — a preparation-draft Build Plan package. */
+export function preparationBuildPlanPackagePath(prepDataDir, buildPlanId) {
+    return join(preparationBuildPlansRoot(prepDataDir), buildPlanId);
 }
-/** `<prep-data>/<preparation-name>/` — a preparation's portable context root. */
-export function preparationPortableContextPath(prepDataDir, preparationName) {
+/** `<prep-data>/<preparation-name>/` — a preparation's verifiable context root. */
+export function preparationVerifiableContextPath(prepDataDir, preparationName) {
     return join(prepDataDir, preparationName);
 }
 /** `<prep-data>/.service/` — service-owned scratch dir for jobs and proposals. */
@@ -123,31 +123,31 @@ export function preparationTestsSpecsRoot(prepDataDir) {
     return join(prepDataDir, PREPARATION_TESTS_DIR, PREPARATION_TESTS_SPECS_DIR);
 }
 // ───────────────────────────────────────────────────────────────────────────
-// Portable Context paths (one per Preparation, lives under prep data dir state)
+// Verifiable-context paths (one per Preparation, lives under prep data dir state)
 // ───────────────────────────────────────────────────────────────────────────
-/** `<portable-context>/.interf/`. */
-export function portableContextStateRoot(portableContext) {
-    return join(portableContext, PORTABLE_CONTEXT_STATE_DIR);
+/** `<verifiable-context>/.interf/`. */
+export function verifiableContextStateRoot(verifiableContext) {
+    return join(verifiableContext, VERIFIABLE_CONTEXT_STATE_DIR);
 }
-/** `<portable-context>/.interf/interf.json` — runtime contract. */
-export function portableContextConfigPath(portableContext) {
-    return join(portableContextStateRoot(portableContext), PREPARATION_CONFIG_FILENAME);
+/** `<verifiable-context>/.interf/interf.json` — runtime contract. */
+export function verifiableContextConfigPath(verifiableContext) {
+    return join(verifiableContextStateRoot(verifiableContext), PREPARATION_CONFIG_FILENAME);
 }
-/** `<portable-context>/.interf/method/` — active Method package inside portable context. */
-export function portableContextMethodPath(portableContext) {
-    return join(portableContextStateRoot(portableContext), PORTABLE_CONTEXT_METHOD_DIR);
+/** `<verifiable-context>/.interf/build-plan/` — active Build Plan package inside verifiable context. */
+export function verifiableContextBuildPlanPath(verifiableContext) {
+    return join(verifiableContextStateRoot(verifiableContext), VERIFIABLE_CONTEXT_BUILD_PLAN_DIR);
 }
-/** `<portable-context>/.interf/runtime/`. */
-export function portableContextRuntimeRoot(portableContext) {
-    return join(portableContextStateRoot(portableContext), PORTABLE_CONTEXT_RUNTIME_DIR);
+/** `<verifiable-context>/.interf/runtime/`. */
+export function verifiableContextRuntimeRoot(verifiableContext) {
+    return join(verifiableContextStateRoot(verifiableContext), VERIFIABLE_CONTEXT_RUNTIME_DIR);
 }
-/** `<portable-context>/.interf/tests/`. */
-export function portableContextTestsRoot(portableContext) {
-    return join(portableContextStateRoot(portableContext), PORTABLE_CONTEXT_TESTS_DIR);
+/** `<verifiable-context>/.interf/tests/`. */
+export function verifiableContextTestsRoot(verifiableContext) {
+    return join(verifiableContextStateRoot(verifiableContext), VERIFIABLE_CONTEXT_TESTS_DIR);
 }
 /** `<prep-data>/<prep>/.interf/tests/`. */
 export function preparationTestsRoot(prepDataDir, preparationName) {
-    return portableContextTestsRoot(preparationPortableContextPath(prepDataDir, preparationName));
+    return verifiableContextTestsRoot(preparationVerifiableContextPath(prepDataDir, preparationName));
 }
 /** `<prep-data>/<prep>/.interf/tests/<target>/runs/`. */
 export function preparationTestRunsRoot(prepDataDir, preparationName, target) {

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

@@ -2,21 +2,21 @@ import { z } from "zod";
 export declare const InterfIdPattern: RegExp;
 export declare const PreparationNamePattern: RegExp;
 export declare const PreparationNameSchema: z.ZodString;
-export declare const MethodIdSchema: z.ZodString;
+export declare const BuildPlanIdSchema: z.ZodString;
 /**
- * Method-declared artifact identifier. Same shape as `MethodIdSchema`
+ * Build Plan-declared artifact identifier. Same shape as `BuildPlanIdSchema`
  * but conceptually distinct — it identifies a produced thing inside
- * one Method, while `MethodIdSchema` identifies the Method itself.
+ * one Build Plan, while `BuildPlanIdSchema` identifies the Build Plan itself.
  */
 export declare const ArtifactIdSchema: z.ZodString;
 export declare const RuntimeStageSchema: z.ZodString;
 export declare const RuntimeContractTypeSchema: z.ZodString;
 export declare const RuntimeTargetTypeSchema: z.ZodEnum<{
-    compiled: "compiled";
+    "verifiable-context": "verifiable-context";
 }>;
 export declare const TestTargetTypeSchema: z.ZodEnum<{
+    "verifiable-context": "verifiable-context";
     "source-files": "source-files";
-    compiled: "compiled";
 }>;
 export declare function isInterfRelativePath(value: string): boolean;
 /**
@@ -109,7 +109,7 @@ export declare const StageInputsSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     run_id: z.ZodNullable<z.ZodString>;
-    method: z.ZodString;
+    build_plan: z.ZodString;
     stage: z.ZodString;
     source_snapshot_id: z.ZodString;
     input_total: z.ZodNumber;
@@ -119,13 +119,13 @@ export declare const StageInputsSchema: z.ZodObject<{
         locator: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const SourceCompiledMaxAttemptsSchema: z.ZodNumber;
-export declare const SourceCompiledMaxLoopsSchema: z.ZodNumber;
+export declare const SourceBuildMaxAttemptsSchema: z.ZodNumber;
+export declare const SourceBuildMaxLoopsSchema: z.ZodNumber;
 /**
  * Canonical check kinds the engine knows how to evaluate.
  *
  * Adding a new kind requires an engine release (the evaluator must
- * implement it). Methods and user checks pick from this list; they
+ * implement it). Build Plans and user checks pick from this list; they
  * cannot invent custom kinds.
  *
  *   file_exists                    — file is present and non-empty
@@ -218,8 +218,8 @@ export declare const ReadyVerdictSchema: z.ZodEnum<{
 }>;
 export type ReadyVerdict = z.infer<typeof ReadyVerdictSchema>;
 /**
- * Standard frontmatter key list used by Methods that emit markdown
- * summaries of source files. Method authors that adopt this evidence
+ * Standard frontmatter key list used by Build Plans that emit markdown
+ * summaries of source files. Build Plan authors that adopt this evidence
  * convention reference this constant in `frontmatter_required_keys`
  * check params rather than re-typing the list.
  */
@@ -228,7 +228,7 @@ export type StandardEvidenceFrontmatterKey = typeof STANDARD_EVIDENCE_FRONTMATTE
 /**
  * Where an Artifact materializes. Discriminated union so future kinds
  * (literal value, remote handle, confirmation-only) slot in without a
- * schema break. `path` is always relative to the portable-context root,
+ * schema break. `path` is always relative to the verifiable-context root,
  * and `artifact_kind` tells consumers whether the target materializes
  * as a file or directory.
  */
@@ -251,11 +251,11 @@ export declare const ArtifactShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type ArtifactPathShape = z.infer<typeof ArtifactPathShapeSchema>;
 export type ArtifactShape = z.infer<typeof ArtifactShapeSchema>;
 /**
- * Method-declared Artifact — a produced thing.
+ * Build Plan-declared Artifact — a produced thing.
  *
  * `checks[]` is the locked vocabulary: an array of `Check` (with
  * `kind` from `CHECK_KINDS`). The runtime evaluates them via the
- * shared check evaluator and produces `Proof[]` on each compile run.
+ * shared check evaluator and produces `Proof[]` on each Build run.
  */
 export declare const ArtifactSchema: z.ZodObject<{
     id: z.ZodString;
@@ -289,7 +289,7 @@ export declare const ArtifactSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type Artifact = z.infer<typeof ArtifactSchema>;
 /**
- * Per-Artifact runtime status. Lives on compile-run resources and on
+ * Per-Artifact runtime status. Lives on Build run resources and on
  * preparation resources. `proofs[]` carries the structured evidence
  * emitted by the shared check evaluator.
  */
@@ -343,24 +343,24 @@ export declare const ReadinessStatusSchema: z.ZodEnum<{
     stale: "stale";
 }>;
 export declare const ReadinessGateSchema: z.ZodEnum<{
-    "portable-context": "portable-context";
+    "verifiable-context": "verifiable-context";
     "preparation-config": "preparation-config";
-    "compile-run": "compile-run";
+    "build-run": "build-run";
     "artifact-checks": "artifact-checks";
     "readiness-checks": "readiness-checks";
     "checks-current": "checks-current";
 }>;
 /**
  * Per-gate status — one row in the readiness summary. A gate is a
- * high-level layer (is config valid? is portable context built? did
- * latest compile succeed?). Gate failures are aggregated alongside
+ * high-level layer (is config valid? is verifiable context built? did
+ * latest Build run succeed?). Gate failures are aggregated alongside
  * artifact-check failures into the overall `Readiness` verdict.
  */
 export declare const GateStatusSchema: z.ZodObject<{
     gate: z.ZodEnum<{
-        "portable-context": "portable-context";
+        "verifiable-context": "verifiable-context";
         "preparation-config": "preparation-config";
-        "compile-run": "compile-run";
+        "build-run": "build-run";
         "artifact-checks": "artifact-checks";
         "readiness-checks": "readiness-checks";
         "checks-current": "checks-current";
@@ -391,14 +391,7 @@ export declare const VerifyTargetResultSchema: z.ZodObject<{
     run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
-/**
- * Preparation-level readiness verdict.
- *
- * Field names retain the preparation-readiness wire shape
- * (`latest_test_run_id`, `check_results`, `checks`). The exported type
- * name is `Readiness`.
- */
-export declare const ReadinessSchema: z.ZodObject<{
+export declare const ReadinessSchema: z.ZodPreprocess<z.ZodObject<{
     kind: z.ZodLiteral<"interf-readiness-state">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
@@ -416,14 +409,14 @@ export declare const ReadinessSchema: z.ZodObject<{
     }>;
     ready: z.ZodBoolean;
     summary: z.ZodString;
-    portable_context_path: z.ZodNullable<z.ZodString>;
-    latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verifiable_context_path: z.ZodNullable<z.ZodString>;
+    latest_build_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    compile: z.ZodNullable<z.ZodObject<{
+    build: z.ZodNullable<z.ZodObject<{
         gate: z.ZodEnum<{
-            "portable-context": "portable-context";
+            "verifiable-context": "verifiable-context";
             "preparation-config": "preparation-config";
-            "compile-run": "compile-run";
+            "build-run": "build-run";
             "artifact-checks": "artifact-checks";
             "readiness-checks": "readiness-checks";
             "checks-current": "checks-current";
@@ -457,7 +450,7 @@ export declare const ReadinessSchema: z.ZodObject<{
             run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strict>>;
-        portable_context: z.ZodNullable<z.ZodObject<{
+        verifiable_context: z.ZodNullable<z.ZodObject<{
             passed: z.ZodNumber;
             total: z.ZodNumber;
             pass_rate: z.ZodNullable<z.ZodNumber>;
@@ -469,9 +462,9 @@ export declare const ReadinessSchema: z.ZodObject<{
     }, z.core.$strict>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         gate: z.ZodEnum<{
-            "portable-context": "portable-context";
+            "verifiable-context": "verifiable-context";
             "preparation-config": "preparation-config";
-            "compile-run": "compile-run";
+            "build-run": "build-run";
             "artifact-checks": "artifact-checks";
             "readiness-checks": "readiness-checks";
             "checks-current": "checks-current";
@@ -493,7 +486,7 @@ export declare const ReadinessSchema: z.ZodObject<{
         run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>>>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 export declare const TestCaseExpectSchema: z.ZodObject<{
     must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
@@ -516,13 +509,13 @@ export declare const RuntimeExecutorInfoSchema: z.ZodObject<{
     timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 /**
- * The 5 canonical roles a Method stage can declare. Methods MAY declare
+ * The 5 canonical roles a Build Plan stage can declare. Build Plans MAY declare
  * custom role names; the engine treats any unknown role as `general`.
  */
 export declare const CANONICAL_ROLES: readonly ["extractor", "summarizer", "structurer", "verifier", "general"];
 export type CanonicalRole = typeof CANONICAL_ROLES[number];
 /**
- * Open-ended role identifier. Methods invent role names freely; the
+ * Open-ended role identifier. Build Plans invent role names freely; the
  * role-router maps unknown names to `general` at run time.
  */
 export declare const RoleSchema: z.ZodString;
@@ -559,7 +552,7 @@ export declare const AgentsRegistrySchema: z.ZodObject<{
 }, z.core.$strict>;
 export type AgentsRegistry = z.infer<typeof AgentsRegistrySchema>;
 export type PreparationName = z.infer<typeof PreparationNameSchema>;
-export type MethodId = z.infer<typeof MethodIdSchema>;
+export type BuildPlanId = z.infer<typeof BuildPlanIdSchema>;
 export type ArtifactId = z.infer<typeof ArtifactIdSchema>;
 export type RuntimeStage = z.infer<typeof RuntimeStageSchema>;
 export type RuntimeContractType = z.infer<typeof RuntimeContractTypeSchema>;