@interf/compiler 0.21.0 → 0.22.2

package/dist/packages/engine/{compile → build}/lib/schema.js

@@ -1,15 +1,15 @@
 import { z } from "zod";
-import { COMPILED_ARTIFACT_KINDS, } from "../method-primitives.js";
-import { ArtifactIdSchema, ArtifactSchema, CheckSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, InterfIdPattern, MethodIdSchema, } from "../../../contracts/lib/schema.js";
-// `ArtifactSchema` is used internally below in `MethodSchemaSchema`'s
+import { BUILD_PLAN_ARTIFACT_KINDS, } from "../build-plan-primitives.js";
+import { ArtifactIdSchema, ArtifactSchema, CheckSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, InterfIdPattern, BuildPlanIdSchema, } from "../../../contracts/lib/schema.js";
+// `ArtifactSchema` is used internally below in `BuildPlanContextRawSchema`'s
 // `artifacts[]` field. The other Artifact* schemas/types are NOT
 // re-exported through this module — callers import them directly
 // from `contracts/lib/schema.js`. The 0.17 PR cross-check pruned
 // re-exports that had zero consumers.
-export { GateStatusSchema, ReadinessGateSchema, ReadinessSchema, ReadinessStatusSchema, VerifyTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../../contracts/lib/schema.js";
+export { GateStatusSchema, ReadinessGateSchema, ReadinessSchema, ReadinessStatusSchema, VerifyTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, BuildPlanIdSchema, } from "../../../contracts/lib/schema.js";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
 const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
-function isCompiledRelativePath(value) {
+function isVerifiableContextRelativePath(value) {
     if (value.length === 0)
         return false;
     if (value.startsWith("/") || value.startsWith("\\"))
@@ -18,13 +18,13 @@ function isCompiledRelativePath(value) {
         .split(/[\\/]+/)
         .every((segment) => COMPILED_RELATIVE_PATH_SEGMENT.test(segment));
 }
-export const MethodArtifactIdSchema = z.string().regex(InterfIdPattern);
-export const MethodCompiledArtifactKindSchema = z.enum(COMPILED_ARTIFACT_KINDS);
-export const MethodArtifactRoleSchema = z.enum(["input", "working", "output", "runtime"]);
-export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
-export const CompiledStageStateSchema = z.object({
+export const BuildPlanArtifactIdSchema = z.string().regex(InterfIdPattern);
+export const BuildPlanArtifactKindSchema = z.enum(BUILD_PLAN_ARTIFACT_KINDS);
+export const BuildPlanArtifactRoleSchema = z.enum(["input", "working", "output", "runtime"]);
+export const BuildStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
+export const VerifiableContextStageStateSchema = z.object({
     contract_type: RuntimeContractTypeSchema.optional(),
-    status: CompiledStageStatusSchema.optional(),
+    status: BuildStageStatusSchema.optional(),
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
     counts: z.record(z.string(), z.number()).optional(),
@@ -33,12 +33,12 @@ export const CompiledStageStateSchema = z.object({
     summary: z.string().nullable().optional(),
     run_id: z.string().nullable().optional(),
 });
-export const CompiledStateSchema = z.object({
+export const VerifiableContextStateSchema = z.object({
     version: z.number().int().min(1),
     pending: z.array(z.string()),
-    stages: z.record(z.string().regex(InterfIdPattern), CompiledStageStateSchema).optional(),
+    stages: z.record(z.string().regex(InterfIdPattern), VerifiableContextStageStateSchema).optional(),
     last_add: z.string().nullable().optional(),
-    last_compile: z.string().nullable().optional(),
+    last_build: z.string().nullable().optional(),
     warning_count: z.number().optional(),
     error_count: z.number().optional(),
 }).strict();
@@ -56,22 +56,22 @@ export const ViewCardSchema = z.object({
     denominator_metric: z.string().optional(),
     format: z.enum(["number", "fraction", "timestamp"]),
 });
-export const CompiledHealthSchema = z.object({
-    kind: z.literal("compiled-health"),
+export const VerifiableContextHealthSchema = z.object({
+    kind: z.literal("verifiable-context-health"),
     version: z.number().int().min(1),
     generated_at: z.string(),
     target_name: z.string(),
-    status: z.enum(["idle", "running", "compiled", "stale", "failed"]),
+    status: z.enum(["idle", "running", "built", "stale", "failed"]),
     stage: z.union([
-        z.enum(["idle", "compiled", "failed"]),
+        z.enum(["idle", "built", "failed"]),
         RuntimeStageSchema,
     ]),
     summary: z.string(),
     metrics: z.record(z.string(), z.number()),
     checks: z.record(z.string(), z.boolean()),
 });
-export const CompiledViewSpecSchema = z.object({
-    kind: z.literal("compiled-view-spec"),
+export const VerifiableContextViewSpecSchema = z.object({
+    kind: z.literal("verifiable-context-view-spec"),
     version: z.number().int().min(1),
     generated_at: z.string(),
     target_name: z.string(),
@@ -82,38 +82,38 @@ export const CompiledViewSpecSchema = z.object({
     cards: z.array(ViewCardSchema),
     sections: z.array(ViewSectionSchema),
 });
-export const MethodPurposeSchema = z.object({
+export const BuildPlanPurposeSchema = z.object({
     label: z.string().min(1),
     task_hint: z.string().min(1),
 }).strict();
-export const MethodCompiledArtifactProjectionSchema = z.object({
-    id: MethodArtifactIdSchema,
-    role: MethodArtifactRoleSchema,
-    path: z.string().min(1).refine(isCompiledRelativePath, {
-        message: "Artifact paths must stay inside the compiled root",
+export const BuildPlanArtifactProjectionSchema = z.object({
+    id: BuildPlanArtifactIdSchema,
+    role: BuildPlanArtifactRoleSchema,
+    path: z.string().min(1).refine(isVerifiableContextRelativePath, {
+        message: "Artifact paths must stay inside the verifiable context root",
     }),
-    kind: MethodCompiledArtifactKindSchema,
+    kind: BuildPlanArtifactKindSchema,
     required: z.boolean(),
     owned_by: z.array(z.string().regex(InterfIdPattern)),
     description: z.string().min(1),
 });
-export const MethodCompiledArtifactSchema = MethodCompiledArtifactProjectionSchema;
-// Persisted schema for the method-defined artifact interface that one
-// portable context must implement on disk.
-export const MethodSchemaSchema = z.object({
-    kind: z.literal("method-schema"),
+export const BuildPlanArtifactSchema = BuildPlanArtifactProjectionSchema;
+// Persisted schema for the Build Plan-defined artifact interface that one
+// verifiable context must implement on disk.
+export const BuildPlanContextRawSchema = z.object({
+    kind: z.literal("build-plan-schema"),
     version: z.literal(1),
-    target_type: z.literal("compiled"),
+    target_type: z.literal("verifiable-context"),
     label: z.string().min(1),
     artifacts: z.array(ArtifactSchema).min(1),
 }).strict();
-export const MethodCompiledSchemaSchema = MethodSchemaSchema;
-export const MethodCompilerApiSchema = z.object({
-    kind: z.literal("compiled"),
+export const BuildPlanContextSchemaSchema = BuildPlanContextRawSchema;
+export const BuildPlanEngineApiSchema = z.object({
+    kind: z.literal("build"),
     version: z.literal(1),
 });
-export const MethodStageArtifactReadAccessSchema = z.array(ArtifactIdSchema);
-export const MethodStageArtifactWriteAccessSchema = z.array(ArtifactIdSchema).min(1);
+export const BuildPlanStageArtifactReadAccessSchema = z.array(ArtifactIdSchema);
+export const BuildPlanStageArtifactWriteAccessSchema = z.array(ArtifactIdSchema).min(1);
 export const ExecutionShellArtifactMountSchema = z.object({
     artifact_id: ArtifactIdSchema,
     artifact_path: z.string(),
@@ -124,7 +124,7 @@ export const ExecutionShellArtifactMountSchema = z.object({
 export const ExecutionShellPathsSchema = z.object({
     kind: z.literal("interf-execution-shell"),
     version: z.literal(1),
-    method: MethodIdSchema,
+    build_plan: BuildPlanIdSchema,
     stage: RuntimeStageSchema,
     reads: z.array(ExecutionShellArtifactMountSchema),
     writes: z.array(ExecutionShellArtifactMountSchema),
@@ -143,8 +143,8 @@ export const RuntimeStageContractSchema = z.object({
     run_id: z.string(),
     target_type: RuntimeTargetTypeSchema,
     target_name: z.string(),
-    method: z.object({
-        id: MethodIdSchema,
+    build_plan: z.object({
+        id: BuildPlanIdSchema,
         stage_index: z.number().nullable(),
         stage_total: z.number(),
         stages: z.array(RuntimeStageSchema),
@@ -184,7 +184,7 @@ export const RuntimeRunSchema = z.object({
     run_id: z.string(),
     target_type: RuntimeTargetTypeSchema,
     target_name: z.string(),
-    method: MethodIdSchema,
+    build_plan: BuildPlanIdSchema,
     stage: RuntimeStageSchema,
     stage_label: z.string(),
     contract_type: RuntimeContractTypeSchema,
@@ -206,7 +206,7 @@ export const RuntimeRunSchema = z.object({
     exit_code: z.number().nullable(),
     error: z.string().nullable(),
 });
-export const CompiledInventoryEntrySchema = z.object({
+export const RuntimeInventoryEntrySchema = z.object({
     input_artifact: ArtifactIdSchema.optional(),
     input_path: z.string().min(1).optional(),
     output_artifact: ArtifactIdSchema,
@@ -214,14 +214,14 @@ export const CompiledInventoryEntrySchema = z.object({
     state: z.string().min(1).optional(),
     metadata: JsonRecordSchema.optional(),
 }).strict();
-export const CompiledInventorySchema = z.object({
-    kind: z.literal("compiled-runtime-ledger").optional(),
+export const RuntimeInventorySchema = z.object({
+    kind: z.literal("verifiable-context-runtime-ledger").optional(),
     version: z.number().int().min(1).optional(),
     stage: RuntimeStageSchema.optional(),
-    entries: z.array(CompiledInventoryEntrySchema),
+    entries: z.array(RuntimeInventoryEntrySchema),
     total: z.number().int().nonnegative(),
 });
-export const MethodImprovementLoopSummarySchema = z.object({
+export const BuildPlanImprovementLoopSummarySchema = z.object({
     variation: z.number().int().min(1),
     kind: z.enum(["baseline", "edited"]),
     attempts_run: z.number().int().min(1),
@@ -233,18 +233,18 @@ export const MethodImprovementLoopSummarySchema = z.object({
     test_sandbox_path: z.string().nullable().optional(),
     summary: z.string().min(1),
 });
-export const MethodImprovementContextSchema = z.object({
-    kind: z.literal("interf-method-improvement-loop"),
+export const BuildPlanImprovementContextSchema = z.object({
+    kind: z.literal("interf-build-plan-improvement-loop"),
     version: z.literal(1),
     generated_at: z.string(),
     target_name: z.string(),
-    method_id: MethodIdSchema,
+    build_plan_id: BuildPlanIdSchema,
     loop_index: z.number().int().min(1),
-    max_loops: SourceCompiledMaxLoopsSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema,
+    max_loops: SourceBuildMaxLoopsSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema,
     review_paths: z.object({
-        method_root: z.string(),
-        compiled_runtime: z.string().nullable(),
+        build_plan_root: z.string(),
+        verifiable_context_runtime: z.string().nullable(),
         readiness_runs: z.string().nullable(),
         execution_shells: z.string().nullable(),
         test_runs: z.string().nullable(),
@@ -257,13 +257,13 @@ export const MethodImprovementContextSchema = z.object({
             question: z.string(),
         })),
     }),
-    previous_variations: z.array(MethodImprovementLoopSummarySchema),
-    latest_failure: MethodImprovementLoopSummarySchema.nullable(),
+    previous_variations: z.array(BuildPlanImprovementLoopSummarySchema),
+    latest_failure: BuildPlanImprovementLoopSummarySchema.nullable(),
 });
 export const PreservedShellTypeSchema = z.enum([
     "stage-execution",
-    "method-authoring",
-    "method-improvement",
+    "build-plan-authoring",
+    "build-plan-improvement",
 ]);
 export const PreservedShellSnapshotSchema = z.object({
     kind: z.literal("interf-preserved-shell"),
@@ -273,20 +273,20 @@ export const PreservedShellSnapshotSchema = z.object({
     root_path: z.string(),
     materialized_symlinks: z.number().int().min(0),
 });
-export const MethodPackageValidationSchema = z.object({
+export const BuildPlanPackageValidationSchema = z.object({
     ok: z.boolean(),
     summary: z.string(),
     errors: z.array(z.string()),
     counts: z.record(z.string(), z.number()),
 });
-export const MethodImprovementLoopRecordSchema = z.object({
-    kind: z.literal("interf-method-improvement-loop-record"),
+export const BuildPlanImprovementLoopRecordSchema = z.object({
+    kind: z.literal("interf-build-plan-improvement-loop-record"),
     version: z.literal(1),
     recorded_at: z.string(),
     run_id: z.string(),
     loop_index: z.number().int().min(1),
     target_name: z.string(),
-    method_id: MethodIdSchema,
+    build_plan_id: BuildPlanIdSchema,
     result: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
     changed: z.boolean(),
     applied: z.boolean(),
@@ -294,23 +294,23 @@ export const MethodImprovementLoopRecordSchema = z.object({
     shell_path: z.string(),
     loop_root_path: z.string(),
     context_path: z.string(),
-    method_before_path: z.string(),
-    method_after_path: z.string(),
+    build_plan_before_path: z.string(),
+    build_plan_after_path: z.string(),
     prompt_log_path: z.string(),
     event_log_path: z.string(),
     status_log_path: z.string(),
     preserved_shell_manifest_path: z.string().nullable(),
-    validation: MethodPackageValidationSchema.nullable(),
+    validation: BuildPlanPackageValidationSchema.nullable(),
 });
-export const MethodImprovementRunLedgerSchema = z.object({
-    kind: z.literal("interf-method-improvement-run"),
+export const BuildPlanImprovementRunLedgerSchema = z.object({
+    kind: z.literal("interf-build-plan-improvement-run"),
     version: z.literal(1),
     generated_at: z.string(),
     updated_at: z.string(),
     run_id: z.string(),
     target_name: z.string(),
-    method_id: MethodIdSchema,
-    max_loops: SourceCompiledMaxLoopsSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema,
-    loops: z.array(MethodImprovementLoopRecordSchema),
+    build_plan_id: BuildPlanIdSchema,
+    max_loops: SourceBuildMaxLoopsSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema,
+    loops: z.array(BuildPlanImprovementLoopRecordSchema),
 });

package/dist/packages/engine/build/reset.d.ts

@@ -0,0 +1,2 @@
+export declare function clearBuildRuntimeDerivedArtifacts(verifiableContextPath: string): void;
+export declare function resetBuildGeneratedState(verifiableContextPath: string, scope?: "build" | "all"): void;

package/dist/packages/engine/build/reset.js

@@ -0,0 +1,74 @@
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./verifiable-context-schema.js";
+import { initializeBuildRuntimeState } from "./state.js";
+import { stageExecutionShellsRoot, testRootForVerifiableContext, testTargetsRootForVerifiableContext, buildPlanImprovementLoopsRoot, verifiableContextQueryAcceptanceRoot, verifiableContextRuntimeRoot, verifiableContextRuntimeLogsRoot, buildPlanPackagePathForVerifiableContext, } from "./verifiable-context-paths.js";
+function removeIfExists(path) {
+    if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+    }
+}
+const BUILD_RUNTIME_RESET_ENTRIES = [
+    "state.json",
+    "health.json",
+    "view-spec.json",
+    "inventory.json",
+    "run.json",
+    "source-files.json",
+    "source-snapshot.json",
+    "stage-contract.json",
+    "stages",
+];
+const PRESERVED_COMPILED_ROOTS = new Set([
+    ".agents",
+    ".claude",
+    ".codex",
+    ".cursor",
+    ".gitignore",
+    ".interf",
+    ".interfignore",
+    "AGENTS.md",
+    "CLAUDE.md",
+]);
+export function clearBuildRuntimeDerivedArtifacts(verifiableContextPath) {
+    const runtimeRoot = verifiableContextRuntimeRoot(verifiableContextPath);
+    for (const entry of BUILD_RUNTIME_RESET_ENTRIES) {
+        removeIfExists(join(runtimeRoot, entry));
+    }
+    removeIfExists(verifiableContextQueryAcceptanceRoot(verifiableContextPath));
+}
+function activeBuildInputRoots(verifiableContextPath) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(verifiableContextPath));
+    const roots = new Set();
+    for (const artifact of schema ? listBuildPlanContextArtifacts(schema) : []) {
+        if (artifact.role !== "input")
+            continue;
+        const root = artifact.path.split("/")[0]?.trim();
+        if (root)
+            roots.add(root);
+    }
+    return roots;
+}
+function resetBuildGeneratedOutputs(verifiableContextPath) {
+    const preservedInputRoots = activeBuildInputRoots(verifiableContextPath);
+    for (const entry of readdirSync(verifiableContextPath)) {
+        if (PRESERVED_COMPILED_ROOTS.has(entry))
+            continue;
+        if (preservedInputRoots.has(entry))
+            continue;
+        removeIfExists(join(verifiableContextPath, entry));
+    }
+}
+export function resetBuildGeneratedState(verifiableContextPath, scope = "build") {
+    resetBuildGeneratedOutputs(verifiableContextPath);
+    clearBuildRuntimeDerivedArtifacts(verifiableContextPath);
+    initializeBuildRuntimeState(verifiableContextPath);
+    if (scope === "all") {
+        removeIfExists(stageExecutionShellsRoot(verifiableContextPath));
+        removeIfExists(buildPlanImprovementLoopsRoot(verifiableContextPath));
+        removeIfExists(verifiableContextRuntimeLogsRoot(verifiableContextPath));
+        removeIfExists(join(verifiableContextRuntimeRoot(verifiableContextPath), "run-history.jsonl"));
+        removeIfExists(testRootForVerifiableContext(verifiableContextPath));
+        removeIfExists(testTargetsRootForVerifiableContext(verifiableContextPath));
+    }
+}

package/dist/packages/engine/{compile → build}/runtime-contracts.js

@@ -1,7 +1,7 @@
-import { METHOD_SCHEMA_FILE } from "./compiled-schema.js";
+import { BUILD_PLAN_SCHEMA_FILE } from "./verifiable-context-schema.js";
 export function buildRuntimeStageContract(options) {
     const localSkillDocs = options.localSkillDocs ?? [];
-    const methodNotes = options.methodNotes ?? [];
+    const buildPlanNotes = options.buildPlanNotes ?? [];
     return {
         instructions: options.instructions,
         counts: {
@@ -11,7 +11,7 @@ export function buildRuntimeStageContract(options) {
         artifacts: {
             reads: [
                 "interf.json",
-                `method/${METHOD_SCHEMA_FILE}`,
+                `build-plan/${BUILD_PLAN_SCHEMA_FILE}`,
                 ...(options.extraReadArtifacts ?? []),
                 ...options.stageReadArtifacts,
                 ...localSkillDocs,
@@ -23,20 +23,20 @@ export function buildRuntimeStageContract(options) {
             execution_mode: "deterministic",
             status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
             notes: [
-                `This is the "${options.stageLabel}" stage for the portable context "${options.compiledName}".`,
-                "The Method package is the authoritative method layer for this run.",
-                `Use \`method/${METHOD_SCHEMA_FILE}\` as the deterministic context-interface reference for this portable context.`,
+                `This is the "${options.stageLabel}" stage for the verifiable context "${options.verifiableContextName}".`,
+                "The Build Plan is the authoritative plan layer for this run.",
+                `Use \`build-plan/${BUILD_PLAN_SCHEMA_FILE}\` as the deterministic context-interface reference for this verifiable context.`,
                 "Honor the declared read and write artifacts instead of inventing a parallel process.",
                 "Only create or update files that fall under the declared write targets for this stage.",
                 "Before emitting DONE, satisfy every check listed under `artifacts.write_contracts[]` for the write Artifacts this stage owns.",
                 "Interf writes `.interf/runtime/` ledgers such as run, state, health, and view-spec files. Read them if needed, but do not create, edit, or replace them in this stage unless the contract explicitly marks a runtime artifact as stage-owned.",
                 "Keep scratch extraction commands single-purpose and non-destructive. Avoid wildcard cleanup and multi-command chains.",
-                ...methodNotes,
+                ...buildPlanNotes,
                 ...(localSkillDocs.length > 0
                     ? [
                         "Read any local instruction docs listed in the contract before you write artifacts or declare the stage complete.",
                         options.instructions.effective_mode === "override"
-                            ? "Local stage docs replace the default method guidance for this run, but they still do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation."
+                            ? "Local stage docs replace the default Build Plan guidance for this run, but they still do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation."
                             : "Local stage docs can refine the stage behavior, but they do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation.",
                     ]
                     : []),

package/dist/packages/engine/build/runtime-inventory.d.ts

@@ -0,0 +1,7 @@
+import { type RuntimeInventory, type RuntimeInventoryEntry } from "./lib/schema.js";
+export declare function emptyRuntimeInventory(): RuntimeInventory;
+export declare function buildInventoryFromEntries(entries: RuntimeInventoryEntry[], stage?: string): RuntimeInventory;
+export declare function buildInventoryEntryCount(inventory: RuntimeInventory | null): number;
+export declare function buildInventoryTotal(inventory: RuntimeInventory | null): number;
+export declare function buildInventoryFrontmatterScannedCount(inventory: RuntimeInventory | null): number;
+export declare function buildInventoryAbstractCoverageCount(inventory: RuntimeInventory | null): number;

package/dist/packages/engine/{compile → build}/runtime-inventory.js

@@ -1,29 +1,29 @@
-export function emptyCompiledInventory() {
+export function emptyRuntimeInventory() {
     return {
-        kind: "compiled-runtime-ledger",
+        kind: "verifiable-context-runtime-ledger",
         version: 1,
         entries: [],
         total: 0,
     };
 }
-export function compiledInventoryFromEntries(entries, stage) {
+export function buildInventoryFromEntries(entries, stage) {
     return {
-        kind: "compiled-runtime-ledger",
+        kind: "verifiable-context-runtime-ledger",
         version: 1,
         ...(stage ? { stage } : {}),
         entries,
         total: entries.length,
     };
 }
-export function compiledInventoryEntryCount(inventory) {
+export function buildInventoryEntryCount(inventory) {
     return inventory?.entries.length ?? 0;
 }
-export function compiledInventoryTotal(inventory) {
+export function buildInventoryTotal(inventory) {
     return inventory?.total ?? 0;
 }
-export function compiledInventoryFrontmatterScannedCount(inventory) {
+export function buildInventoryFrontmatterScannedCount(inventory) {
     return (inventory?.entries ?? []).filter((entry) => entry.metadata?.frontmatter_scanned === true).length;
 }
-export function compiledInventoryAbstractCoverageCount(inventory) {
+export function buildInventoryAbstractCoverageCount(inventory) {
     return (inventory?.entries ?? []).filter((entry) => entry.metadata?.abstract_read === true || typeof entry.metadata?.abstract === "string").length;
 }

package/dist/packages/engine/{compile → build}/runtime-paths.js

@@ -1,19 +1,19 @@
 import { join } from "node:path";
-import { compiledRuntimeArchivedStageContractPath, compiledRuntimeLogsRoot, compiledRuntimeRunHistoryPath, compiledRuntimeRunPath, compiledRuntimeStageContractPath, } from "./compiled-paths.js";
+import { verifiableContextRuntimeArchivedStageContractPath, verifiableContextRuntimeLogsRoot, verifiableContextRuntimeRunHistoryPath, verifiableContextRuntimeRunPath, verifiableContextRuntimeStageContractPath, } from "./verifiable-context-paths.js";
 export function runPath(dirPath) {
-    return compiledRuntimeRunPath(dirPath);
+    return verifiableContextRuntimeRunPath(dirPath);
 }
 export function runHistoryPath(dirPath) {
-    return compiledRuntimeRunHistoryPath(dirPath);
+    return verifiableContextRuntimeRunHistoryPath(dirPath);
 }
 export function stageContractPath(dirPath) {
-    return compiledRuntimeStageContractPath(dirPath);
+    return verifiableContextRuntimeStageContractPath(dirPath);
 }
 export function archivedStageContractPath(dirPath, runId) {
-    return compiledRuntimeArchivedStageContractPath(dirPath, runId);
+    return verifiableContextRuntimeArchivedStageContractPath(dirPath, runId);
 }
 export function logsDirPath(dirPath) {
-    return compiledRuntimeLogsRoot(dirPath);
+    return verifiableContextRuntimeLogsRoot(dirPath);
 }
 export function promptLogPath(dirPath, runId) {
     return join(logsDirPath(dirPath), `${runId}.prompt.txt`);

package/dist/packages/engine/{compile → build}/runtime-prompt.js

@@ -3,45 +3,45 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
     const modeNotes = instructions.effective_mode === "override"
         ? [
             "Local stage instruction docs are authoritative for this run.",
-            "Use bundled Method heuristics only when the stage contract explicitly permits them.",
+            "Use bundled Build Plan heuristics only when the stage contract explicitly permits them.",
             "Interf still enforces the same required reads, writes, verifier outputs, and runtime reconciliation at stage close.",
         ]
         : instructions.effective_mode === "extend"
             ? [
-                "Use the current compiled Method docs as the default Method for this run.",
+                "Use the current Build Plan docs as the default plan for this run.",
                 "Then apply any additional local stage instruction docs referenced by the contract as stage-specific extensions.",
             ]
             : [
-                "Use the current compiled Method docs as the default Method for this run.",
+                "Use the current Build Plan stage docs as the default behavior for this run.",
             ];
     return [
-        `Interf Method stage docs: method/compile/stages/${stageSkillDir}/`,
+        `Interf Build Plan stage docs: build-plan/build/stages/${stageSkillDir}/`,
         "",
         "This is an automated Interf stage run, not an open-ended chat session.",
         "The user has already invoked this stage through the Interf CLI. Execute it now.",
         "Do not ask what the user wants, offer help, list tools, or wait for another instruction.",
         `Read \`${contractPath}\` first. It is the authoritative contract for this stage.`,
-        "If `runtime/paths.json` exists in this shell, read it next. It maps Method Artifact ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
+        "If `runtime/paths.json` exists in this shell, read it next. It maps Build Plan Artifact ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
         "For file Artifact mounts, `runtime/paths.json` also gives the exact file path inside the `inputs/` or `outputs/` mount root.",
-        "Honor the contract's counts, artifact paths, and policies instead of inventing another Method.",
+        "Honor the contract's counts, artifact paths, and policies instead of inventing another Build Plan.",
         "The contract's `artifacts.write_contracts[]` lists the checks Interf will run against the Artifacts this stage writes. Treat those checks as required output constraints.",
         "Read only the files named by the contract's `artifacts.reads` list plus any paths they explicitly direct you to open.",
         "Prefer direct file-reading and search tools over shell commands when you inspect inputs, docs, or generated outputs.",
         "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` for routine file inspection if a native read/search tool can do the same job.",
         "If the contract lists `instructions.local_docs`, open every one of those files before you write artifacts or declare the stage complete.",
-        "If `AGENTS.md` is listed in the contract, use it only for portable-context routing that is directly relevant to this stage.",
+        "If `AGENTS.md` is listed in the contract, use it only for verifiable-context routing that is directly relevant to this stage.",
         "`.interf/runtime/run.json`, `.interf/runtime/state.json`, `.interf/runtime/health.json`, and `.interf/runtime/view-spec.json` are runtime artifacts written by Interf. You may read them, but do not create, edit, or replace them unless the contract explicitly marks a different proof artifact as stage-owned.",
         "If a contract-listed output file does not exist yet, create it in one whole-file write. Do not attempt patch-style edits against a missing runtime path.",
-        "Stay inside the current portable context. Do not try to open repo docs, repo source files, or other paths outside the portable context unless the stage contract explicitly requires them.",
+        "Stay inside the current verifiable context. Do not try to open repo docs, repo source files, or other paths outside this context unless the stage contract explicitly requires them.",
         instructions.effective_mode === "override"
-            ? "Do not depend on any repo-root or globally installed skill cache for this run. Local stage instruction docs are the primary Method layer for this run."
-            : "Do not depend on any repo-root or globally installed skill cache for this run. Use the current compiled Method docs and the contract as the default behavior.",
+            ? "Do not depend on any repo-root or globally installed skill cache for this run. Local stage instruction docs are the primary Build Plan layer for this run."
+            : "Do not depend on any repo-root or globally installed skill cache for this run. Use the current Build Plan stage docs and the contract as the default behavior.",
         ...modeNotes,
         "Do not narrate intentions, plans, or reasoning to the user.",
         "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
         "Those status lines are progress hints for the operator. The CLI decides stage completion from artifacts, validation, and reconcile checks rather than trusting status text alone.",
         "Before any long-running source inspection or shell-based helper step, emit a STATUS: line that names the current subtask.",
-        "If work stays in progress, do not remain silent for more than about one minute. Emit another STATUS: line when you switch files, page groups, targets, or extraction methods.",
+        "If work stays in progress, do not remain silent for more than about one minute. Emit another STATUS: line when you switch files, page groups, targets, or extraction passes.",
         "If you respond conversationally instead of executing the stage, the run will be treated as failed.",
         "As soon as the required proof artifacts are complete, stop. Do not keep browsing or auditing after the contract is satisfied.",
         ...statusLines,

package/dist/packages/engine/build/runtime-reconcile.d.ts

@@ -0,0 +1,2 @@
+import { type BuildPlanStageDefinition } from "../../build-plans/package/build-plan-definitions.js";
+export declare function reconcileBuildStageRun(dirPath: string, stage: Pick<BuildPlanStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;