@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/engine/agents/lib/types.d.ts

@@ -1,4 +1,4 @@
-import type { MethodExecutionProfile } from "./executors.js";
+import type { AgentExecutionProfile } from "./executors.js";
 export interface Agent {
     name: string;
     displayName: string;
@@ -25,7 +25,7 @@ export interface AgentAutomationReadiness {
 export interface SpawnAgentOptions {
     eventLogPath?: string | null;
     statusLogPath?: string | null;
-    executionProfile?: MethodExecutionProfile;
+    executionProfile?: AgentExecutionProfile;
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
 }

package/dist/packages/engine/agents/lib/verifiable-context-bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { renderClaudeBootstrap } from "./shells.js";
+export { renderClaudeBootstrap };
+export declare function refreshVerifiableContextBootstrapGuidance(dirPath: string): boolean;

package/dist/packages/engine/agents/lib/verifiable-context-bootstrap.js

@@ -0,0 +1,19 @@
+import { basename } from "node:path";
+import { readInterfConfig } from "../../../project/interf-detect.js";
+import { resolveBuildPlanId } from "../../../build-plans/build-plan-resolution.js";
+import { projectVerifiableContextQueryShell, renderClaudeBootstrap } from "./shells.js";
+export { renderClaudeBootstrap };
+export function refreshVerifiableContextBootstrapGuidance(dirPath) {
+    const config = readInterfConfig(dirPath);
+    if (!config)
+        return false;
+    const verifiableContextName = config.name ?? basename(dirPath);
+    const buildPlanId = resolveBuildPlanId(config);
+    const buildPlanOriginSelected = config.build_plan_origin?.selected ?? buildPlanId;
+    const buildPlanLocalDraft = config.build_plan_origin?.local_draft === true;
+    const about = typeof config.about === "string" && config.about.length > 0 ? config.about : undefined;
+    return projectVerifiableContextQueryShell(dirPath, verifiableContextName, buildPlanId, about, {
+        buildPlanOriginSelected,
+        buildPlanLocalDraft,
+    });
+}

package/dist/packages/engine/agents/role-executors.d.ts

@@ -1,11 +1,11 @@
 import type { AgentRecord, RoleMap } from "../../contracts/lib/schema.js";
-import type { MethodExecutionProfile, MethodExecutor } from "./lib/executors.js";
+import type { AgentExecutionProfile, AgentExecutor } from "./lib/executors.js";
 import { type ResolvedAgent, type RoleResolutionContext } from "./role-router.js";
 export interface RoleExecutorBundle {
-    /** Map agent name → method executor. */
-    executors: Map<string, MethodExecutor>;
+    /** Map agent name to Build Plan executor. */
+    executors: Map<string, AgentExecutor>;
     /** Default fallback executor — usually the active agent. */
-    defaultExecutor: MethodExecutor;
+    defaultExecutor: AgentExecutor;
     /** The registry context we built this bundle from. */
     context: RoleResolutionContext;
     /**
@@ -13,7 +13,7 @@ export interface RoleExecutorBundle {
      * through `general` and the default executor before raising.
      */
     resolveExecutorForRole(role: string): {
-        executor: MethodExecutor;
+        executor: AgentExecutor;
         resolved: ResolvedAgent;
     };
 }
@@ -23,8 +23,8 @@ export interface BuildRoleExecutorBundleInput {
     /** The agent the role-map's `general` row points at, or fallback. */
     activeAgent: AgentRecord | null;
     /** The fallback executor — used when role resolution yields the active. */
-    defaultExecutor: MethodExecutor;
-    executionProfile?: MethodExecutionProfile;
+    defaultExecutor: AgentExecutor;
+    executionProfile?: AgentExecutionProfile;
 }
 /**
  * Build a per-role executor bundle from a registry snapshot. The

package/dist/packages/engine/agents/role-executors.js

@@ -2,9 +2,9 @@
  * Role-aware executor factory.
  *
  * Bridges the registry layer (`AgentRecord` / `RoleMap`) to the runtime
- * layer (`MethodExecutor`). Builds a per-agent-name `MethodExecutor`
+ * layer (`AgentExecutor`). Builds a per-agent-name `AgentExecutor`
  * map up front and exposes a `resolveExecutorForRole(role)` helper that
- * the compile / readiness-check pipelines can call per-stage.
+ * the build / readiness-check pipelines can call per-stage.
  *
  * Falls back gracefully: when a role isn't mapped, or the mapped agent
  * is missing, we fall through to `general` and ultimately to the

package/dist/packages/engine/agents/role-router.d.ts

@@ -1,7 +1,7 @@
 /**
  * Role router — picks which connected agent runs a given stage role.
  *
- * The compile pipeline calls `resolveAgentForRole` for each agent-typed
+ * The build pipeline calls `resolveAgentForRole` for each agent-typed
  * stage, passing the stage's declared role and the current registry +
  * active agent. The verify pipeline always passes role `"verifier"`.
  *
@@ -48,7 +48,7 @@ export type RoleResolutionError = {
  */
 export declare function resolveAgentForRole(role: string, context: RoleResolutionContext): ResolvedAgent | RoleResolutionError;
 /**
- * Resolve every role declared by a Method's stages. Useful for
+ * Resolve every role declared by a Build Plan's stages. Useful for
  * pre-flight: returns either `{ resolutions }` (one entry per stage)
  * or `{ error, role }` if any stage cannot resolve.
  */

package/dist/packages/engine/agents/role-router.js

@@ -56,7 +56,7 @@ export function resolveAgentForRole(role, context) {
     };
 }
 /**
- * Resolve every role declared by a Method's stages. Useful for
+ * Resolve every role declared by a Build Plan's stages. Useful for
  * pre-flight: returns either `{ resolutions }` (one entry per stage)
  * or `{ error, role }` if any stage cannot resolve.
  */

package/dist/packages/engine/build/artifact-counts.d.ts

@@ -0,0 +1 @@
+export declare function countBuildArtifactsAtPath(verifiableContextPath: string, artifactPath: string, kind: "directory" | "file" | "runtime"): number;

package/dist/packages/engine/{compile → build}/artifact-counts.js

@@ -1,11 +1,11 @@
 import { existsSync, readFileSync } from "node:fs";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { compiledArtifactAbsolutePath } from "./compiled-schema.js";
+import { verifiableContextArtifactAbsolutePath } from "./verifiable-context-schema.js";
 const SCAFFOLD_PLACEHOLDER_SNIPPETS = [
-    "Not yet compiled. Run `interf compile` to build the portable context.",
-    "Not yet compiled. Run `interf compile` to build this portable context.",
-    "Not yet compiled. Run `interf compile` to build the portable context.",
-    "Not yet compiled. Run `interf compile` to build this portable context.",
+    "Not yet built. Run `interf build` to build the verifiable context.",
+    "Not yet built. Run `interf build` to build this verifiable context.",
+    "Not yet built. Run `interf build` to build the verifiable context.",
+    "Not yet built. Run `interf build` to build this verifiable context.",
 ];
 function isScaffoldPlaceholderFile(filePath) {
     try {
@@ -16,8 +16,8 @@ function isScaffoldPlaceholderFile(filePath) {
         return false;
     }
 }
-export function countCompiledArtifactsAtPath(compiledPath, artifactPath, kind) {
-    const absolutePath = compiledArtifactAbsolutePath(compiledPath, { path: artifactPath });
+export function countBuildArtifactsAtPath(verifiableContextPath, artifactPath, kind) {
+    const absolutePath = verifiableContextArtifactAbsolutePath(verifiableContextPath, { path: artifactPath });
     if (!existsSync(absolutePath))
         return 0;
     if (kind === "file")

package/dist/packages/engine/{compile → build}/artifact-status.d.ts

@@ -1,18 +1,18 @@
 import type { ArtifactStatus } from "../../contracts/lib/schema.js";
-import type { MethodDefinition } from "../../methods/package/method-definitions.js";
+import type { BuildPlanDefinition } from "../../build-plans/package/build-plan-definitions.js";
 import type { StageRun } from "../execution/lib/schema.js";
 /**
- * 0.17 — compute per-Artifact status for a compile run.
+ * 0.17 — compute per-Artifact status for a Build run.
  *
- * Walks the Method's declared `artifacts[]` and decides
+ * Walks the Build Plan's declared `artifacts[]` and decides
  * `ready | not_ready | failed | skipped` for each.
  *
  * Mapping rules:
  * - **shape kind = "path"**: the artifact is `ready` when the declared
- *   path exists inside `compiledPath` with the declared artifact kind,
+ *   path exists inside `verifiableContextPath` with the declared artifact kind,
  *   `not_ready` otherwise. Future shape kinds (value, remote-handle,
  *   confirmation) slot in here.
- * - **`built_by_stages`** is preserved from the Method declaration when
+ * - **`built_by_stages`** is preserved from the Build Plan declaration when
  *   present, otherwise inferred from stage `writes` that match the
  *   artifact's path.
  * - **proofs** carries structured evidence from the shared check
@@ -23,12 +23,12 @@ import type { StageRun } from "../execution/lib/schema.js";
  * the run record carries the real causal signal.
  */
 export declare function computeArtifactStatuses(options: {
-    method: Pick<MethodDefinition<string>, "stages" | "contextInterface" | "schema">;
-    compiledPath: string;
+    buildPlan: Pick<BuildPlanDefinition<string>, "stages" | "contextInterface" | "schema">;
+    verifiableContextPath: string;
     stageRuns: StageRun[];
     /**
      * Optional runtime counts (e.g. `source_total`) passed to checks
-     * that compare against source. Threaded through from the compile
+     * that compare against source. Threaded through from the build
      * runtime; absent for ad-hoc evaluations.
      */
     counts?: Record<string, number>;

package/dist/packages/engine/{compile → build}/artifact-status.js

@@ -2,17 +2,17 @@ import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { evaluateChecks } from "./check-evaluator.js";
 /**
- * 0.17 — compute per-Artifact status for a compile run.
+ * 0.17 — compute per-Artifact status for a Build run.
  *
- * Walks the Method's declared `artifacts[]` and decides
+ * Walks the Build Plan's declared `artifacts[]` and decides
  * `ready | not_ready | failed | skipped` for each.
  *
  * Mapping rules:
  * - **shape kind = "path"**: the artifact is `ready` when the declared
- *   path exists inside `compiledPath` with the declared artifact kind,
+ *   path exists inside `verifiableContextPath` with the declared artifact kind,
  *   `not_ready` otherwise. Future shape kinds (value, remote-handle,
  *   confirmation) slot in here.
- * - **`built_by_stages`** is preserved from the Method declaration when
+ * - **`built_by_stages`** is preserved from the Build Plan declaration when
  *   present, otherwise inferred from stage `writes` that match the
  *   artifact's path.
  * - **proofs** carries structured evidence from the shared check
@@ -23,22 +23,22 @@ import { evaluateChecks } from "./check-evaluator.js";
  * the run record carries the real causal signal.
  */
 export function computeArtifactStatuses(options) {
-    const schema = pickContextInterface(options.method);
+    const schema = pickContextInterface(options.buildPlan);
     const artifacts = schema?.artifacts ?? [];
     if (artifacts.length === 0)
         return [];
-    const stageWriteIndex = buildStageWriteIndex(options.method.stages);
+    const stageWriteIndex = buildStageWriteIndex(options.buildPlan.stages);
     const anyStageFailed = options.stageRuns.some((stage) => stage.status === "failed");
     return artifacts.map((artifact) => buildArtifactStatus({
         artifact,
-        compiledPath: options.compiledPath,
+        verifiableContextPath: options.verifiableContextPath,
         stageWriteIndex,
         anyStageFailed,
         counts: options.counts,
     }));
 }
-function pickContextInterface(method) {
-    return method.contextInterface ?? method.schema;
+function pickContextInterface(buildPlan) {
+    return buildPlan.contextInterface ?? buildPlan.schema;
 }
 function buildStageWriteIndex(stages) {
     const index = new Map();
@@ -53,13 +53,13 @@ function buildStageWriteIndex(stages) {
     return index;
 }
 function buildArtifactStatus(options) {
-    const { artifact, compiledPath, stageWriteIndex, anyStageFailed, counts } = options;
+    const { artifact, verifiableContextPath, stageWriteIndex, anyStageFailed, counts } = options;
     const builtBy = artifact.built_by_stages.length > 0
         ? artifact.built_by_stages
         : inferBuiltByStages(artifact, stageWriteIndex);
     const shapeStatus = resolveStatusValue({
         artifact,
-        compiledPath,
+        verifiableContextPath,
         anyStageFailed,
     });
     // Run the locked CheckKind evaluator against artifact.checks. Proofs
@@ -68,12 +68,12 @@ function buildArtifactStatus(options) {
     // shape itself isn't built yet).
     const targetPath = artifact.shape.kind === "path" ? artifact.shape.path : undefined;
     // `artifact.checks` is `default([])` in the schema, but raw objects
-    // (test fixtures, hand-edited Methods loaded without parsing) may
+    // (test fixtures, hand-edited Build Plans loaded without parsing) may
     // omit the field entirely.
     const declaredChecks = artifact.checks ?? [];
     const checkResult = declaredChecks.length > 0
         ? evaluateChecks(declaredChecks, {
-            rootPath: compiledPath,
+            rootPath: verifiableContextPath,
             targetPath,
             counts,
         })
@@ -116,17 +116,17 @@ function inferBuiltByStages(artifact, stageWriteIndex) {
     return pathOwners ?? [];
 }
 function resolveStatusValue(options) {
-    const { artifact, compiledPath, anyStageFailed } = options;
+    const { artifact, verifiableContextPath, anyStageFailed } = options;
     if (artifact.shape.kind !== "path")
         return "skipped";
-    const compiledRoot = resolve(compiledPath);
-    const absolutePath = resolve(compiledRoot, artifact.shape.path);
+    const verifiableContextRoot = resolve(verifiableContextPath);
+    const absolutePath = resolve(verifiableContextRoot, artifact.shape.path);
     // Defense in depth: the schema-level `isInterfRelativePath` refine
     // already rejects `..` and absolute paths in `ArtifactPathShape.path`,
-    // but Method packages can land on disk before the schema validates
+    // but Build Plan packages can land on disk before the schema validates
     // (hand-edited drafts can still bypass normal package validation).
-    // Reject any resolved path that escapes the portable-context root.
-    if (absolutePath !== compiledRoot && !absolutePath.startsWith(`${compiledRoot}/`)) {
+    // Reject any resolved path that escapes the verifiable-context root.
+    if (absolutePath !== verifiableContextRoot && !absolutePath.startsWith(`${verifiableContextRoot}/`)) {
         return "failed";
     }
     if (!existsSync(absolutePath)) {

package/dist/packages/engine/{compile → build}/billing-events.d.ts

@@ -3,7 +3,7 @@ import type { ArtifactStatus } from "../../contracts/lib/schema.js";
 /**
  * 0.17 — per-Artifact billing event record.
  *
- * Emitted once per Artifact each time a compile run produces it.
+ * Emitted once per Artifact each time a Build run produces it.
  * `account_id` is `null` for loopback (no auth); the cloud variant
  * fills it from the `tokenValidator` (B4.3) result.
  *
@@ -22,7 +22,7 @@ export declare const CompilationEventSchema: z.ZodObject<{
     run_id: z.ZodString;
     preparation: z.ZodString;
     artifact_id: z.ZodString;
-    method_id: z.ZodString;
+    build_plan_id: z.ZodString;
     account_id: z.ZodNullable<z.ZodString>;
     event_kind: z.ZodEnum<{
         fresh: "fresh";
@@ -61,7 +61,7 @@ export declare class JsonlBillingEventSink implements BillingEventSink {
     emit(event: CompilationEvent): void;
 }
 /**
- * Default sink path for a run. Each compile run gets its own JSONL
+ * Default sink path for a run. Each Build run gets its own JSONL
  * file alongside its other on-disk artifacts.
  */
 export declare function defaultBillingEventLogPath(options: {
@@ -80,7 +80,7 @@ export declare function defaultBillingEventLogPath(options: {
 export declare function buildCompilationEventsForRun(options: {
     runId: string;
     preparation: string;
-    methodId: string;
+    buildPlanId: string;
     accountId: string | null;
     artifacts: readonly ArtifactStatus[];
     startedAt?: string | null;

package/dist/packages/engine/{compile → build}/billing-events.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 /**
  * 0.17 — per-Artifact billing event record.
  *
- * Emitted once per Artifact each time a compile run produces it.
+ * Emitted once per Artifact each time a Build run produces it.
  * `account_id` is `null` for loopback (no auth); the cloud variant
  * fills it from the `tokenValidator` (B4.3) result.
  *
@@ -20,7 +20,7 @@ export const CompilationEventSchema = z.object({
     run_id: z.string().min(1),
     preparation: z.string().min(1),
     artifact_id: z.string().min(1),
-    method_id: z.string().min(1),
+    build_plan_id: z.string().min(1),
     account_id: z.string().min(1).nullable(),
     event_kind: BillingEventKindSchema,
     size_class: z.enum(["small", "medium", "large"]).optional(),
@@ -38,7 +38,7 @@ export class JsonlBillingEventSink {
     }
 }
 /**
- * Default sink path for a run. Each compile run gets its own JSONL
+ * Default sink path for a run. Each Build run gets its own JSONL
  * file alongside its other on-disk artifacts.
  */
 export function defaultBillingEventLogPath(options) {
@@ -66,7 +66,7 @@ export function buildCompilationEventsForRun(options) {
         run_id: options.runId,
         preparation: options.preparation,
         artifact_id: status.artifact_id,
-        method_id: options.methodId,
+        build_plan_id: options.buildPlanId,
         account_id: options.accountId,
         event_kind: "fresh",
         ...(durationMs !== undefined ? { duration_ms: durationMs } : {}),

package/dist/packages/engine/build/build-execution.d.ts

@@ -0,0 +1,4 @@
+export * from "./build-target.js";
+export * from "./build-stage-plan.js";
+export * from "./build-stage-runner.js";
+export * from "./build-pipeline.js";

package/dist/packages/engine/build/build-execution.js

@@ -0,0 +1,4 @@
+export * from "./build-target.js";
+export * from "./build-stage-plan.js";
+export * from "./build-stage-runner.js";
+export * from "./build-pipeline.js";

package/dist/packages/engine/build/build-pipeline.d.ts

@@ -0,0 +1,56 @@
+import { type AgentExecutor } from "../agents/lib/executors.js";
+import { type BuildPlanReporter, type BuildPlanStageResult } from "../../build-plans/package/build-plan-helpers.js";
+import { type BuildStageExecutionDefinition } from "./build-target.js";
+import type { RunEventSink } from "../execution/events.js";
+export interface BuildSummarizeResult extends BuildPlanStageResult {
+    plan: {
+        sourceCount: number;
+        summaryCount: number;
+        targetCount: number;
+    };
+}
+export interface BuildResult {
+    ok: boolean;
+    stageResults: Record<string, BuildPlanStageResult>;
+    failedStage: string | null;
+}
+export type StageShellRetentionMode = "on-failure" | "always";
+/**
+ * Per-stage executor resolver. When provided, the pipeline calls this
+ * for each stage and uses the returned executor instead of the
+ * top-level `executor`. The top-level `executor` stays as the default
+ * fallback so single-active-agent setups keep working without any
+ * resolver wired up.
+ */
+export type ResolveStageExecutor = (stage: BuildStageExecutionDefinition) => AgentExecutor;
+export declare function runBuildSummarize(options: {
+    executor: AgentExecutor;
+    resolveStageExecutor?: ResolveStageExecutor;
+    verifiableContextPath: string;
+    reporter?: BuildPlanReporter;
+    reportSummary?: boolean;
+    reportStep?: boolean;
+    stageDefinition?: BuildStageExecutionDefinition;
+    fullPass?: boolean;
+    runId?: string;
+    events?: RunEventSink;
+}): Promise<BuildSummarizeResult>;
+export declare function runBuildStages(options: {
+    executor: AgentExecutor;
+    resolveStageExecutor?: ResolveStageExecutor;
+    verifiableContextPath: string;
+    reporter?: BuildPlanReporter;
+    reportStep?: boolean;
+    preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
+}): Promise<BuildPlanStageResult>;
+export declare function buildVerifiableContext(options: {
+    executor: AgentExecutor;
+    resolveStageExecutor?: ResolveStageExecutor;
+    verifiableContextPath: string;
+    reporter?: BuildPlanReporter;
+    preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
+}): Promise<BuildResult>;

package/dist/packages/engine/{compile/compiled-pipeline.js → build/build-pipeline.js}

@@ -1,15 +1,15 @@
-import { refreshCompiledBootstrapGuidance, } from "../agents/lib/compiled-bootstrap.js";
-import { validateMethodPackage } from "../../methods/package/local-methods.js";
-import { reportValidationFailure, } from "../../methods/package/method-helpers.js";
-import { validateCompiledMethod, } from "./validate.js";
+import { refreshVerifiableContextBootstrapGuidance, } from "../agents/lib/verifiable-context-bootstrap.js";
+import { validateBuildPlanPackage } from "../../build-plans/package/local-build-plans.js";
+import { reportValidationFailure, } from "../../build-plans/package/build-plan-helpers.js";
+import { validateVerifiableContext, } from "./validate.js";
 import { pruneStageExecutionShells, } from "../agents/lib/shells.js";
-import { resetCompiledGeneratedState } from "./reset.js";
-import { compiledExecutionStages, resolveCompiledContext, } from "./compiled-target.js";
+import { resetBuildGeneratedState } from "./reset.js";
+import { buildExecutionStages, resolveBuildContext, } from "./build-target.js";
 import { discoverSourceFiles } from "./discovery.js";
-import { runCompiledStage } from "./compiled-stage-runner.js";
+import { runBuildStage } from "./build-stage-runner.js";
 import { resolveSourceInputPath } from "../../project/interf-detect.js";
-import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { writeCompiledSourceRuntime } from "./source-files.js";
+import { buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
+import { writeBuildSourceRuntime } from "./source-files.js";
 function pickStageExecutor(fallback, stage, resolve) {
     if (!resolve)
         return fallback;
@@ -20,29 +20,29 @@ function pickStageExecutor(fallback, stage, resolve) {
         return fallback;
     }
 }
-export async function runCompiledSummarize(options) {
-    const context = resolveCompiledContext(options.compiledPath);
+export async function runBuildSummarize(options) {
+    const context = resolveBuildContext(options.verifiableContextPath);
     const stageDefinition = options.stageDefinition
-        ?? compiledExecutionStages(context.methodId, options.compiledPath).find((stage) => stage.id === "summarize");
+        ?? buildExecutionStages(context.buildPlanId, options.verifiableContextPath).find((stage) => stage.id === "summarize");
     if (!stageDefinition) {
         return {
             ok: false,
             code: 1,
             plan: { sourceCount: 0, summaryCount: 0, targetCount: 0 },
-            summary: "Method does not declare a summarize stage.",
+            summary: "Build Plan does not declare a summarize stage.",
         };
     }
-    const sourceCount = discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount;
-    writeCompiledSourceRuntime({
-        compiledPath: options.compiledPath,
-        methodId: context.methodId,
+    const sourceCount = discoverSourceFiles(context.sourcePath, options.verifiableContextPath).totalCount;
+    writeBuildSourceRuntime({
+        verifiableContextPath: options.verifiableContextPath,
+        buildPlanId: context.buildPlanId,
         stageIds: [stageDefinition.id],
         sourcePath: context.sourcePath,
         runId: options.runId ?? null,
     });
-    const result = await runCompiledStage({
+    const result = await runBuildStage({
         executor: pickStageExecutor(options.executor, stageDefinition, options.resolveStageExecutor),
-        compiledPath: options.compiledPath,
+        verifiableContextPath: options.verifiableContextPath,
         reporter: options.reporter,
         reportStep: options.reportStep,
         stageDefinition,
@@ -58,26 +58,26 @@ export async function runCompiledSummarize(options) {
         },
     };
 }
-export async function runCompiledCompile(options) {
+export async function runBuildStages(options) {
     const preserveMode = options.preserveStageShells ?? "on-failure";
     if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.compiledPath);
+        pruneStageExecutionShells(options.verifiableContextPath);
     }
     let lastResult = { ok: true, code: 0 };
     try {
-        const context = resolveCompiledContext(options.compiledPath);
-        const stages = compiledExecutionStages(context.methodId, options.compiledPath);
-        writeCompiledSourceRuntime({
-            compiledPath: options.compiledPath,
-            methodId: context.methodId,
+        const context = resolveBuildContext(options.verifiableContextPath);
+        const stages = buildExecutionStages(context.buildPlanId, options.verifiableContextPath);
+        writeBuildSourceRuntime({
+            verifiableContextPath: options.verifiableContextPath,
+            buildPlanId: context.buildPlanId,
             stageIds: stages.map((stage) => stage.id),
             sourcePath: context.sourcePath,
             runId: options.runId ?? null,
         });
         for (const [index, stageDefinition] of stages.entries()) {
-            const result = await runCompiledStage({
+            const result = await runBuildStage({
                 executor: pickStageExecutor(options.executor, stageDefinition, options.resolveStageExecutor),
-                compiledPath: options.compiledPath,
+                verifiableContextPath: options.verifiableContextPath,
                 reporter: options.reporter,
                 reportStep: options.reportStep,
                 stageDefinition,
@@ -94,15 +94,15 @@ export async function runCompiledCompile(options) {
     }
     finally {
         if (preserveMode !== "always" && lastResult.ok) {
-            pruneStageExecutionShells(options.compiledPath);
+            pruneStageExecutionShells(options.verifiableContextPath);
         }
     }
 }
-export async function compileCompiled(options) {
+export async function buildVerifiableContext(options) {
     const preserveMode = options.preserveStageShells ?? "on-failure";
-    resetCompiledGeneratedState(options.compiledPath, "compile");
+    resetBuildGeneratedState(options.verifiableContextPath, "build");
     if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.compiledPath);
+        pruneStageExecutionShells(options.verifiableContextPath);
     }
     let result = {
         ok: true,
@@ -110,38 +110,38 @@ export async function compileCompiled(options) {
         failedStage: null,
     };
     try {
-        refreshCompiledBootstrapGuidance(options.compiledPath);
-        const methodValidation = validateMethodPackage(methodPackagePathForCompiled(options.compiledPath));
-        if (!methodValidation.ok) {
-            reportValidationFailure(options.reporter, methodValidation.summary, methodValidation.errors);
+        refreshVerifiableContextBootstrapGuidance(options.verifiableContextPath);
+        const buildPlanValidation = validateBuildPlanPackage(buildPlanPackagePathForVerifiableContext(options.verifiableContextPath));
+        if (!buildPlanValidation.ok) {
+            reportValidationFailure(options.reporter, buildPlanValidation.summary, buildPlanValidation.errors);
             return {
                 ...result,
                 ok: false,
-                failedStage: "method",
+                failedStage: "build-plan",
                 stageResults: {
                     ...result.stageResults,
-                    method: {
+                    "build-plan": {
                         ok: false,
                         code: 1,
-                        summary: methodValidation.summary,
+                        summary: buildPlanValidation.summary,
                     },
                 },
             };
         }
-        const context = resolveCompiledContext(options.compiledPath);
-        const sourceInputPath = resolveSourceInputPath(options.compiledPath);
-        const stages = compiledExecutionStages(context.methodId, options.compiledPath);
-        writeCompiledSourceRuntime({
-            compiledPath: options.compiledPath,
-            methodId: context.methodId,
+        const context = resolveBuildContext(options.verifiableContextPath);
+        const sourceInputPath = resolveSourceInputPath(options.verifiableContextPath);
+        const stages = buildExecutionStages(context.buildPlanId, options.verifiableContextPath);
+        writeBuildSourceRuntime({
+            verifiableContextPath: options.verifiableContextPath,
+            buildPlanId: context.buildPlanId,
             stageIds: stages.map((stage) => stage.id),
             sourcePath: sourceInputPath,
             runId: options.runId ?? null,
         });
         for (const [index, stageDefinition] of stages.entries()) {
-            const stageResult = await runCompiledStage({
+            const stageResult = await runBuildStage({
                 executor: pickStageExecutor(options.executor, stageDefinition, options.resolveStageExecutor),
-                compiledPath: options.compiledPath,
+                verifiableContextPath: options.verifiableContextPath,
                 reporter: options.reporter,
                 reportStep: true,
                 stageDefinition,
@@ -157,19 +157,19 @@ export async function compileCompiled(options) {
                 return result;
             }
         }
-        const methodValidationResult = validateCompiledMethod(options.compiledPath);
-        result.ok = methodValidationResult.ok;
-        result.failedStage = methodValidationResult.ok ? null : methodValidationResult.stage;
-        result.stageResults.compiled = {
-            ok: methodValidationResult.ok,
-            code: methodValidationResult.ok ? 0 : 1,
-            summary: methodValidationResult.summary,
+        const buildPlanValidationResult = validateVerifiableContext(options.verifiableContextPath);
+        result.ok = buildPlanValidationResult.ok;
+        result.failedStage = buildPlanValidationResult.ok ? null : buildPlanValidationResult.stage;
+        result.stageResults["verifiable-context"] = {
+            ok: buildPlanValidationResult.ok,
+            code: buildPlanValidationResult.ok ? 0 : 1,
+            summary: buildPlanValidationResult.summary,
         };
         return result;
     }
     finally {
         if (preserveMode !== "always" && result.ok) {
-            pruneStageExecutionShells(options.compiledPath);
+            pruneStageExecutionShells(options.verifiableContextPath);
         }
     }
 }

package/dist/packages/engine/build/build-plan-primitives.d.ts

@@ -0,0 +1,2 @@
+export declare const BUILD_PLAN_ARTIFACT_KINDS: readonly ["directory", "file", "runtime"];
+export type BuildPlanArtifactKind = typeof BUILD_PLAN_ARTIFACT_KINDS[number];