@interf/compiler 0.18.0 → 0.22.0

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

@@ -1,13 +1,13 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { extname, join, relative } from "node:path";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { compiledArtifactAbsolutePath, findCompiledSchemaArtifact, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { verifiableContextArtifactAbsolutePath, findBuildPlanContextArtifact, readBuildPlanContextFile, } from "./verifiable-context-schema.js";
 import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { loadRuntimeRun } from "./runtime.js";
-import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
-import { compiledInventoryFromEntries } from "./runtime-inventory.js";
+import { initVerifiableContextState, loadState, refreshVerifiableContextArtifacts, saveState, } from "./state.js";
+import { buildInventoryFromEntries } from "./runtime-inventory.js";
 import { STANDARD_EVIDENCE_FRONTMATTER_KEYS, } from "../../contracts/lib/schema.js";
-import { compiledRuntimeRoot, methodPackagePathForCompiled } from "./compiled-paths.js";
+import { verifiableContextRuntimeRoot, buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
 import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);
@@ -39,7 +39,7 @@ function anyPathUpdatedSince(absolutePath, sinceMs) {
     return false;
 }
 function artifactCount(dirPath, artifactPath, kind) {
-    const absolutePath = compiledArtifactAbsolutePath(dirPath, { path: artifactPath });
+    const absolutePath = verifiableContextArtifactAbsolutePath(dirPath, { path: artifactPath });
     if (!existsSync(absolutePath))
         return 0;
     if (kind === "file")
@@ -53,7 +53,7 @@ function summaryAbstract(content) {
     return extractSynthAbstract(parsed.frontmatter, parsed.body);
 }
 function listZoneArtifacts(dirPath, artifact) {
-    const absolutePath = compiledArtifactAbsolutePath(dirPath, artifact);
+    const absolutePath = verifiableContextArtifactAbsolutePath(dirPath, artifact);
     if (!existsSync(absolutePath) || artifact.kind === "runtime")
         return [];
     if (artifact.kind === "file") {
@@ -82,7 +82,7 @@ function buildInventoryMetadata(options) {
         metadata.abstract_read = true;
     }
     // Project the standard evidence frontmatter keys onto the inventory
-    // metadata. Method authors that emit the canonical evidence keys
+    // metadata. Build Plan authors that emit the canonical evidence keys
     // (`STANDARD_EVIDENCE_FRONTMATTER_KEYS` in contracts) get them
     // surfaced on stage inventory entries; non-standard keys are ignored.
     const frontmatter = options.parsedFrontmatter.frontmatter;
@@ -95,14 +95,14 @@ function buildInventoryMetadata(options) {
     return metadata;
 }
 function buildStageInventoryEntries(dirPath, stage) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
     if (!schema)
         return [];
     const readableInputArtifacts = stage.reads
-        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .map((artifactId) => findBuildPlanContextArtifact(schema, artifactId))
         .filter((artifact) => artifact !== null && artifact.kind !== "runtime");
     const outputArtifacts = stage.writes
-        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .map((artifactId) => findBuildPlanContextArtifact(schema, artifactId))
         .filter((artifact) => artifact !== null && artifact.kind !== "runtime");
     if (outputArtifacts.length === 0)
         return [];
@@ -148,29 +148,29 @@ function buildStageInventoryEntries(dirPath, stage) {
     return entries.sort((left, right) => `${left.output_artifact}:${left.output_path}`.localeCompare(`${right.output_artifact}:${right.output_path}`));
 }
 function writeStageInventory(dirPath, stageId, entries) {
-    writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
+    writeFileSync(join(verifiableContextRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(buildInventoryFromEntries(entries, stageId), null, 2) + "\n");
 }
 function activeRunCounts(dirPath) {
     return { ...(loadRuntimeRun(dirPath)?.counts ?? {}) };
 }
-export function reconcileCompiledStageRun(dirPath, stage) {
+export function reconcileBuildStageRun(dirPath, stage) {
     const startedAtMs = readActiveRunStartedAtMs(dirPath);
     if (startedAtMs === null)
         return false;
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
     if (!schema)
         return false;
     const writeArtifacts = stage.writes
-        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .map((artifactId) => findBuildPlanContextArtifact(schema, artifactId))
         .filter((artifact) => artifact !== null);
     if (writeArtifacts.length === 0)
         return false;
-    if (!writeArtifacts.some((artifact) => anyPathUpdatedSince(compiledArtifactAbsolutePath(dirPath, artifact), startedAtMs))) {
+    if (!writeArtifacts.some((artifact) => anyPathUpdatedSince(verifiableContextArtifactAbsolutePath(dirPath, artifact), startedAtMs))) {
         return false;
     }
     writeStageInventory(dirPath, stage.id, buildStageInventoryEntries(dirPath, stage));
     const currentState = {
-        ...initCompiledState(),
+        ...initVerifiableContextState(),
         ...(loadState(dirPath) ?? {}),
         stages: {
             ...(loadState(dirPath)?.stages ?? {}),
@@ -188,8 +188,8 @@ export function reconcileCompiledStageRun(dirPath, stage) {
         summary: loadRuntimeRun(dirPath)?.summary ?? null,
         run_id: loadRuntimeRun(dirPath)?.run_id ?? null,
     };
-    currentState.last_compile = now;
+    currentState.last_build = now;
     saveState(dirPath, currentState);
-    refreshCompiledArtifacts(dirPath, { ensureViewSpec: true });
+    refreshVerifiableContextArtifacts(dirPath, { ensureViewSpec: true });
     return true;
 }

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

@@ -2,7 +2,7 @@ import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } f
 import { dirname, relative } from "node:path";
 import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
 import { RuntimeRunSchema, } from "./lib/schema.js";
-import { getMethodStageDefinition, getMethodStagePosition, getMethodStages, } from "../../methods/package/method-definitions.js";
+import { getBuildPlanStageDefinition, getBuildPlanStagePosition, getBuildPlanStages, } from "../../build-plans/package/build-plan-definitions.js";
 import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 import { warnInterf } from "../../contracts/utils/logger.js";
 export function loadRuntimeRun(dirPath) {
@@ -41,15 +41,15 @@ function writeArchivedStageContract(dirPath, runId, contract) {
 export async function runExecutorStage(options) {
     const startedRun = startRuntimeRun(options);
     const prompt = options.buildPrompt(startedRun.activeContractPath);
-    writeRuntimeRunPrompt(options.compiledPath, startedRun.run.run_id, prompt);
-    const executionPath = options.executionPath ?? options.compiledPath;
+    writeRuntimeRunPrompt(options.verifiableContextPath, startedRun.run.run_id, prompt);
+    const executionPath = options.executionPath ?? options.verifiableContextPath;
     const code = await options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
+        eventLogPath: eventLogPath(options.verifiableContextPath, startedRun.run.run_id),
+        statusLogPath: statusLogPath(options.verifiableContextPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
         onStatus: options.onStatus,
     });
-    finalizeRuntimeRun(options.compiledPath, code);
+    finalizeRuntimeRun(options.verifiableContextPath, code);
     return code;
 }
 export function beginRuntimeRun(dirPath, run) {
@@ -107,21 +107,21 @@ export function markRuntimeRunSucceededAfterValidation(dirPath, summary) {
 function startRuntimeRun(options) {
     const runId = createRunId();
     const generatedAt = new Date().toISOString();
-    const methodStages = getMethodStages(options.method, options.methodSourcePath);
-    const stagePosition = getMethodStagePosition(options.method, options.stage, options.methodSourcePath);
-    const stageDefinition = getMethodStageDefinition(options.method, options.stage, options.methodSourcePath);
+    const buildPlanStages = getBuildPlanStages(options.buildPlan, options.buildPlanSourcePath);
+    const stagePosition = getBuildPlanStagePosition(options.buildPlan, options.stage, options.buildPlanSourcePath);
+    const stageDefinition = getBuildPlanStageDefinition(options.buildPlan, options.stage, options.buildPlanSourcePath);
     const contract = {
         kind: "interf-stage-contract",
         version: 1,
         generated_at: generatedAt,
         run_id: runId,
-        target_type: "compiled",
-        target_name: options.compiledName,
-        method: {
-            id: options.method,
+        target_type: "verifiable-context",
+        target_name: options.verifiableContextName,
+        build_plan: {
+            id: options.buildPlan,
             stage_index: stagePosition?.stageIndex ?? null,
-            stage_total: stagePosition?.stageTotal ?? methodStages.length,
-            stages: stagePosition?.stages ?? methodStages,
+            stage_total: stagePosition?.stageTotal ?? buildPlanStages.length,
+            stages: stagePosition?.stages ?? buildPlanStages,
         },
         stage: options.stage,
         stage_label: stageDefinition?.label ?? options.stageLabel,
@@ -132,15 +132,15 @@ function startRuntimeRun(options) {
         artifacts: options.contract.artifacts,
         policies: options.contract.policies,
     };
-    const activeContractPath = writeStageContract(options.compiledPath, contract);
-    const archivedContractPath = writeArchivedStageContract(options.compiledPath, runId, contract);
+    const activeContractPath = writeStageContract(options.verifiableContextPath, contract);
+    const archivedContractPath = writeArchivedStageContract(options.verifiableContextPath, runId, contract);
     const run = {
         kind: "interf-run",
         version: 1,
         run_id: runId,
-        target_type: "compiled",
-        target_name: options.compiledName,
-        method: options.method,
+        target_type: "verifiable-context",
+        target_name: options.verifiableContextName,
+        build_plan: options.buildPlan,
         stage: options.stage,
         stage_label: stageDefinition?.label ?? options.stageLabel,
         contract_type: options.contractType,
@@ -149,24 +149,24 @@ function startRuntimeRun(options) {
         started_at: generatedAt,
         updated_at: generatedAt,
         finished_at: null,
-        contract_path: relative(options.compiledPath, archivedContractPath),
-        ...(options.executionPath ? { execution_path: relative(options.compiledPath, options.executionPath) } : {}),
+        contract_path: relative(options.verifiableContextPath, archivedContractPath),
+        ...(options.executionPath ? { execution_path: relative(options.verifiableContextPath, options.executionPath) } : {}),
         counts: { ...contract.counts },
         output_artifacts: [...contract.artifacts.writes],
         logs: {
-            prompt_path: relative(options.compiledPath, promptLogPath(options.compiledPath, runId)),
-            event_stream_path: relative(options.compiledPath, eventLogPath(options.compiledPath, runId)),
-            status_path: relative(options.compiledPath, statusLogPath(options.compiledPath, runId)),
+            prompt_path: relative(options.verifiableContextPath, promptLogPath(options.verifiableContextPath, runId)),
+            event_stream_path: relative(options.verifiableContextPath, eventLogPath(options.verifiableContextPath, runId)),
+            status_path: relative(options.verifiableContextPath, statusLogPath(options.verifiableContextPath, runId)),
         },
         summary: options.summary,
         exit_code: null,
         error: null,
     };
     return {
-        run: beginRuntimeRun(options.compiledPath, run),
+        run: beginRuntimeRun(options.verifiableContextPath, run),
         activeContractPath: options.executionPath
             ? "runtime/stage-contract.json"
-            : relative(options.compiledPath, activeContractPath),
+            : relative(options.verifiableContextPath, activeContractPath),
     };
 }
 function finalizeRuntimeRun(dirPath, code) {

package/dist/packages/engine/{compile → build}/runtime-types.d.ts

@@ -1,15 +1,15 @@
-import { type MethodExecutor } from "../agents/lib/executors.js";
+import { type AgentExecutor } from "../agents/lib/executors.js";
 import { type RuntimeRun, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
-import type { Check, MethodId, RuntimeContractType, RuntimeStage } from "../../contracts/lib/schema.js";
+import type { Check, BuildPlanId, RuntimeContractType, RuntimeStage } from "../../contracts/lib/schema.js";
 export type RuntimeRunStatus = "running" | "succeeded" | "failed";
-export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "method" | "stage" | "stage_label" | "contract_type" | "executor">;
+export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "build_plan" | "stage" | "stage_label" | "contract_type" | "executor">;
 export interface RuntimeStageExecutionOptions {
-    executor: MethodExecutor;
-    compiledPath: string;
+    executor: AgentExecutor;
+    verifiableContextPath: string;
     executionPath?: string;
-    compiledName: string;
-    method: MethodId;
-    methodSourcePath?: string;
+    verifiableContextName: string;
+    buildPlan: BuildPlanId;
+    buildPlanSourcePath?: string;
     stage: RuntimeStage;
     stageLabel: string;
     contractType: RuntimeContractType;
@@ -20,7 +20,7 @@ export interface RuntimeStageExecutionOptions {
     onStatus?: (line: string) => void;
 }
 export interface RuntimeStageContractOptions {
-    compiledName: string;
+    verifiableContextName: string;
     stageId: string;
     stageLabel: string;
     counts?: Record<string, number>;
@@ -32,7 +32,7 @@ export interface RuntimeStageContractOptions {
         path: string;
         checks: Check[];
     }>;
-    methodNotes?: string[];
+    buildPlanNotes?: string[];
     localSkillDocs?: string[];
     instructions: RuntimeStageInstructions;
 }

package/dist/packages/engine/build/source-files.d.ts

@@ -0,0 +1,46 @@
+import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../../contracts/lib/schema.js";
+export declare function buildVerifiableContextSourceFiles(verifiableContextPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
+export declare function writeVerifiableContextSourceFiles(verifiableContextPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
+export declare function buildVerifiableContextSourceSnapshot(options: {
+    verifiableContextPath: string;
+    sourceFiles?: SourceFiles;
+    sourcePath?: string;
+    runId?: string | null;
+    generatedAt?: string;
+}): SourceSnapshot;
+export declare function writeVerifiableContextSourceSnapshot(options: {
+    verifiableContextPath: string;
+    sourceFiles?: SourceFiles;
+    sourcePath?: string;
+    runId?: string | null;
+    generatedAt?: string;
+}): SourceSnapshot;
+export declare function buildBuildStageInputs(options: {
+    buildPlanId: string;
+    stageId: string;
+    snapshot: SourceSnapshot;
+    runId?: string | null;
+    generatedAt?: string;
+}): StageInputs;
+export declare function writeBuildStageInputs(options: {
+    verifiableContextPath: string;
+    buildPlanId: string;
+    stageId: string;
+    snapshot: SourceSnapshot;
+    runId?: string | null;
+    generatedAt?: string;
+}): StageInputs;
+export declare function writeBuildSourceRuntime(options: {
+    verifiableContextPath: string;
+    buildPlanId: string;
+    stageIds: string[];
+    sourcePath?: string;
+    runId?: string | null;
+}): {
+    sourceFiles: SourceFiles;
+    snapshot: SourceSnapshot;
+    stageInputs: StageInputs[];
+};
+export declare function loadVerifiableContextSourceFiles(verifiableContextPath: string): SourceFiles | null;
+export declare function loadVerifiableContextSourceSnapshot(verifiableContextPath: string): SourceSnapshot | null;
+export declare function loadBuildStageInputs(verifiableContextPath: string, stageId: string): StageInputs | null;

package/dist/packages/engine/{compile → build}/source-files.js

@@ -4,7 +4,7 @@ import { dirname, resolve } from "node:path";
 import { SourceFilesSchema, SourceSnapshotSchema, StageInputsSchema, } from "../../contracts/lib/schema.js";
 import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { discoverSourceFiles } from "./discovery.js";
-import { compiledRuntimeSourceFilesPath, compiledRuntimeSourceSnapshotPath, compiledRuntimeStageInputsPath, } from "./compiled-paths.js";
+import { verifiableContextRuntimeSourceFilesPath, verifiableContextRuntimeSourceSnapshotPath, verifiableContextRuntimeStageInputsPath, } from "./verifiable-context-paths.js";
 import { resolveSourceInputPath } from "../../project/interf-detect.js";
 function shortHash(value, length = 16) {
     return createHash("sha256")
@@ -44,8 +44,8 @@ function writeJson(filePath, value) {
     mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
-export function buildCompiledSourceFiles(compiledPath, sourcePath = resolveSourceInputPath(compiledPath), generatedAt = new Date().toISOString()) {
-    const discovery = discoverSourceFiles(sourcePath, compiledPath);
+export function buildVerifiableContextSourceFiles(verifiableContextPath, sourcePath = resolveSourceInputPath(verifiableContextPath), generatedAt = new Date().toISOString()) {
+    const discovery = discoverSourceFiles(sourcePath, verifiableContextPath);
     const source = buildSource(sourcePath);
     const files = discovery.sourceFiles.map((relativePath) => buildSourceFile(source, sourcePath, relativePath));
     return {
@@ -57,16 +57,16 @@ export function buildCompiledSourceFiles(compiledPath, sourcePath = resolveSourc
         files,
     };
 }
-export function writeCompiledSourceFiles(compiledPath, sourcePath = resolveSourceInputPath(compiledPath), generatedAt = new Date().toISOString()) {
-    const sourceFiles = buildCompiledSourceFiles(compiledPath, sourcePath, generatedAt);
+export function writeVerifiableContextSourceFiles(verifiableContextPath, sourcePath = resolveSourceInputPath(verifiableContextPath), generatedAt = new Date().toISOString()) {
+    const sourceFiles = buildVerifiableContextSourceFiles(verifiableContextPath, sourcePath, generatedAt);
     const parsed = SourceFilesSchema.parse(sourceFiles);
-    writeJson(compiledRuntimeSourceFilesPath(compiledPath), parsed);
+    writeJson(verifiableContextRuntimeSourceFilesPath(verifiableContextPath), parsed);
     return parsed;
 }
-export function buildCompiledSourceSnapshot(options) {
+export function buildVerifiableContextSourceSnapshot(options) {
     const generatedAt = options.generatedAt ?? new Date().toISOString();
     const sourceFiles = options.sourceFiles
-        ?? buildCompiledSourceFiles(options.compiledPath, options.sourcePath ?? resolveSourceInputPath(options.compiledPath), generatedAt);
+        ?? buildVerifiableContextSourceFiles(options.verifiableContextPath, options.sourcePath ?? resolveSourceInputPath(options.verifiableContextPath), generatedAt);
     return {
         kind: "interf-source-snapshot",
         version: 1,
@@ -82,19 +82,19 @@ export function buildCompiledSourceSnapshot(options) {
         files: sourceFiles.files,
     };
 }
-export function writeCompiledSourceSnapshot(options) {
-    const snapshot = SourceSnapshotSchema.parse(buildCompiledSourceSnapshot(options));
-    writeJson(compiledRuntimeSourceSnapshotPath(options.compiledPath), snapshot);
+export function writeVerifiableContextSourceSnapshot(options) {
+    const snapshot = SourceSnapshotSchema.parse(buildVerifiableContextSourceSnapshot(options));
+    writeJson(verifiableContextRuntimeSourceSnapshotPath(options.verifiableContextPath), snapshot);
     return snapshot;
 }
-export function buildCompiledStageInputs(options) {
+export function buildBuildStageInputs(options) {
     const generatedAt = options.generatedAt ?? new Date().toISOString();
     return {
         kind: "interf-stage-inputs",
         version: 1,
         generated_at: generatedAt,
         run_id: options.runId ?? options.snapshot.run_id ?? null,
-        method: options.methodId,
+        build_plan: options.buildPlanId,
         stage: options.stageId,
         source_snapshot_id: options.snapshot.snapshot_id,
         input_total: options.snapshot.files.length,
@@ -105,23 +105,23 @@ export function buildCompiledStageInputs(options) {
         })),
     };
 }
-export function writeCompiledStageInputs(options) {
-    const stageInputs = StageInputsSchema.parse(buildCompiledStageInputs(options));
-    writeJson(compiledRuntimeStageInputsPath(options.compiledPath, options.stageId), stageInputs);
+export function writeBuildStageInputs(options) {
+    const stageInputs = StageInputsSchema.parse(buildBuildStageInputs(options));
+    writeJson(verifiableContextRuntimeStageInputsPath(options.verifiableContextPath, options.stageId), stageInputs);
     return stageInputs;
 }
-export function writeCompiledSourceRuntime(options) {
+export function writeBuildSourceRuntime(options) {
     const generatedAt = new Date().toISOString();
-    const sourceFiles = writeCompiledSourceFiles(options.compiledPath, options.sourcePath ?? resolveSourceInputPath(options.compiledPath), generatedAt);
-    const snapshot = writeCompiledSourceSnapshot({
-        compiledPath: options.compiledPath,
+    const sourceFiles = writeVerifiableContextSourceFiles(options.verifiableContextPath, options.sourcePath ?? resolveSourceInputPath(options.verifiableContextPath), generatedAt);
+    const snapshot = writeVerifiableContextSourceSnapshot({
+        verifiableContextPath: options.verifiableContextPath,
         sourceFiles,
         runId: options.runId ?? null,
         generatedAt,
     });
-    const stageInputs = options.stageIds.map((stageId) => writeCompiledStageInputs({
-        compiledPath: options.compiledPath,
-        methodId: options.methodId,
+    const stageInputs = options.stageIds.map((stageId) => writeBuildStageInputs({
+        verifiableContextPath: options.verifiableContextPath,
+        buildPlanId: options.buildPlanId,
         stageId,
         snapshot,
         runId: options.runId ?? null,
@@ -129,21 +129,21 @@ export function writeCompiledSourceRuntime(options) {
     }));
     return { sourceFiles, snapshot, stageInputs };
 }
-export function loadCompiledSourceFiles(compiledPath) {
-    const filePath = compiledRuntimeSourceFilesPath(compiledPath);
+export function loadVerifiableContextSourceFiles(verifiableContextPath) {
+    const filePath = verifiableContextRuntimeSourceFilesPath(verifiableContextPath);
     if (!existsSync(filePath))
         return null;
-    return readJsonFileWithSchema(filePath, "compiled source files", SourceFilesSchema);
+    return readJsonFileWithSchema(filePath, "verifiable-context source files", SourceFilesSchema);
 }
-export function loadCompiledSourceSnapshot(compiledPath) {
-    const filePath = compiledRuntimeSourceSnapshotPath(compiledPath);
+export function loadVerifiableContextSourceSnapshot(verifiableContextPath) {
+    const filePath = verifiableContextRuntimeSourceSnapshotPath(verifiableContextPath);
     if (!existsSync(filePath))
         return null;
-    return readJsonFileWithSchema(filePath, "compiled source snapshot", SourceSnapshotSchema);
+    return readJsonFileWithSchema(filePath, "verifiable-context source snapshot", SourceSnapshotSchema);
 }
-export function loadCompiledStageInputs(compiledPath, stageId) {
-    const filePath = compiledRuntimeStageInputsPath(compiledPath, stageId);
+export function loadBuildStageInputs(verifiableContextPath, stageId) {
+    const filePath = verifiableContextRuntimeStageInputsPath(verifiableContextPath, stageId);
     if (!existsSync(filePath))
         return null;
-    return readJsonFileWithSchema(filePath, "compiled stage inputs", StageInputsSchema);
+    return readJsonFileWithSchema(filePath, "verifiable-context stage inputs", StageInputsSchema);
 }

package/dist/packages/engine/build/state-artifacts.d.ts

@@ -0,0 +1,9 @@
+import { type VerifiableContextHealth, type VerifiableContextViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
+export declare function refreshVerifiableContextArtifacts(dirPath: string, options?: {
+    ensureViewSpec?: boolean;
+}): {
+    health: VerifiableContextHealth;
+    viewSpec?: VerifiableContextViewSpec;
+    sourceFiles: SourceFiles;
+    sourceSnapshot: SourceSnapshot;
+};

package/dist/packages/engine/build/state-artifacts.js

@@ -0,0 +1,14 @@
+import { saveVerifiableContextHealth, } from "./state-io.js";
+import { computeVerifiableContextHealth, } from "./state-health.js";
+import { ensureVerifiableContextSourceFiles, ensureVerifiableContextSourceSnapshot, ensureVerifiableContextViewSpec, } from "./state-view.js";
+export function refreshVerifiableContextArtifacts(dirPath, options) {
+    const health = computeVerifiableContextHealth(dirPath);
+    saveVerifiableContextHealth(dirPath, health);
+    const sourceFiles = ensureVerifiableContextSourceFiles(dirPath);
+    const sourceSnapshot = ensureVerifiableContextSourceSnapshot(dirPath, sourceFiles);
+    let viewSpec;
+    if (options?.ensureViewSpec) {
+        viewSpec = ensureVerifiableContextViewSpec(dirPath);
+    }
+    return { health, viewSpec, sourceFiles, sourceSnapshot };
+}

package/dist/packages/engine/build/state-health.d.ts

@@ -0,0 +1,4 @@
+import { type VerifiableContextHealth, type BuildStage, type RuntimeStatus } from "./lib/schema.js";
+export declare function computeVerifiableContextHealth(dirPath: string): VerifiableContextHealth;
+export declare function resolveVerifiableContextStatus(..._args: unknown[]): RuntimeStatus;
+export declare function resolveBuildStage(...args: unknown[]): BuildStage;

package/dist/packages/engine/{compile → build}/state-health.js

@@ -3,52 +3,52 @@ import { readInterfConfig, resolveSourceFolderPath, } from "../../project/interf
 import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { loadState } from "./state-io.js";
-import { validateCompiled, validateCompiledStage, validateCompiledMethod, } from "./validate.js";
-import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
-import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
-import { countCompiledArtifactsAtPath } from "./artifact-counts.js";
-export function computeCompiledHealth(dirPath) {
+import { validateVerifiableContextSetup, validateBuildStage, validateVerifiableContext, } from "./validate.js";
+import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./verifiable-context-schema.js";
+import { buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
+import { getActiveBuildPlan, resolveRequiredBuildPlanFromConfig } from "../../build-plans/package/build-plan-definitions.js";
+import { countBuildArtifactsAtPath } from "./artifact-counts.js";
+export function computeVerifiableContextHealth(dirPath) {
     const now = new Date().toISOString();
     const config = readInterfConfig(dirPath);
     const targetName = config?.name ?? basename(dirPath);
     const sourcePath = config ? resolveSourceFolderPath(dirPath, config) : dirPath;
     const sourceTotal = config ? discoverSourceFiles(sourcePath, dirPath).totalCount : 0;
     const state = loadState(dirPath);
-    const validation = validateCompiled(dirPath);
+    const validation = validateVerifiableContextSetup(dirPath);
     const activeRun = loadRuntimeRun(dirPath);
-    const methodId = config
-        ? resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${dirPath}`)
+    const buildPlanId = config
+        ? resolveRequiredBuildPlanFromConfig(config, `.interf/interf.json for ${dirPath}`)
         : null;
-    let method = null;
-    if (methodId) {
+    let buildPlan = null;
+    if (buildPlanId) {
         try {
-            method = getActiveCompiledMethod(dirPath);
+            buildPlan = getActiveBuildPlan(dirPath);
         }
         catch {
-            method = null;
+            buildPlan = null;
         }
     }
-    const stageResults = method?.stages.map((stage) => ({
+    const stageResults = buildPlan?.stages.map((stage) => ({
         stage,
-        validation: validateCompiledStage(dirPath, stage.id),
+        validation: validateBuildStage(dirPath, stage.id),
     })) ?? [];
     const completedStages = stageResults.filter((entry) => entry.validation.ok).length;
     const firstFailed = stageResults.find((entry) => !entry.validation.ok) ?? null;
-    const methodValidation = validateCompiledMethod(dirPath);
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    const artifactMetrics = Object.fromEntries((schema ? listCompiledSchemaArtifacts(schema) : []).map((artifact) => [
+    const buildPlanValidation = validateVerifiableContext(dirPath);
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
+    const artifactMetrics = Object.fromEntries((schema ? listBuildPlanContextArtifacts(schema) : []).map((artifact) => [
         `artifact_${artifact.id}`,
-        countCompiledArtifactsAtPath(dirPath, artifact.path, artifact.kind),
+        countBuildArtifactsAtPath(dirPath, artifact.path, artifact.kind),
     ]));
     let status = "idle";
     let stage = "idle";
-    let summary = "Idle — no source files have been compiled yet.";
-    const errors = methodValidation.errors.length;
-    if (!validation.config_present || !validation.config_valid || !validation.config_type_match || !validation.method_valid || !validation.schema_valid) {
+    let summary = "Idle — no source files have been built yet.";
+    const errors = buildPlanValidation.errors.length;
+    if (!validation.config_present || !validation.config_valid || !validation.config_type_match || !validation.build_plan_valid || !validation.schema_valid) {
         status = "failed";
         stage = "failed";
-        summary = methodValidation.summary;
+        summary = buildPlanValidation.summary;
     }
     else if (activeRun?.status === "running") {
         status = "running";
@@ -58,34 +58,34 @@ export function computeCompiledHealth(dirPath) {
     else if (sourceTotal === 0 && completedStages === 0) {
         status = "idle";
         stage = "idle";
-        summary = "Idle — no source files have been compiled yet.";
+        summary = "Idle — no source files have been built yet.";
     }
     else if (activeRun?.status === "failed") {
         status = "failed";
         stage = activeRun.stage;
         summary = activeRun.error ?? activeRun.summary;
     }
-    else if (methodValidation.ok) {
-        status = "compiled";
-        stage = "compiled";
-        summary = `Compiled — ${completedStages}/${method?.stages.length ?? 0} method stages satisfied.`;
+    else if (buildPlanValidation.ok) {
+        status = "built";
+        stage = "built";
+        summary = `Built — ${completedStages}/${buildPlan?.stages.length ?? 0} Build Plan stages satisfied.`;
     }
     else {
         status = "stale";
-        stage = firstFailed?.stage.id ?? "compiled";
-        summary = firstFailed?.validation.summary ?? methodValidation.summary;
+        stage = firstFailed?.stage.id ?? "built";
+        summary = firstFailed?.validation.summary ?? buildPlanValidation.summary;
     }
     const checks = {
         ...validation,
-        ...(method
-            ? Object.fromEntries(method.stages.map((methodStage) => [
-                `stage_${methodStage.id}_ok`,
-                stageResults.find((entry) => entry.stage.id === methodStage.id)?.validation.ok ?? false,
+        ...(buildPlan
+            ? Object.fromEntries(buildPlan.stages.map((buildPlanStage) => [
+                `stage_${buildPlanStage.id}_ok`,
+                stageResults.find((entry) => entry.stage.id === buildPlanStage.id)?.validation.ok ?? false,
             ]))
             : {}),
     };
     return {
-        kind: "compiled-health",
+        kind: "verifiable-context-health",
         version: 2,
         generated_at: now,
         target_name: targetName,
@@ -94,7 +94,7 @@ export function computeCompiledHealth(dirPath) {
         summary,
         metrics: {
             source_total: sourceTotal,
-            stage_total: method?.stages.length ?? 0,
+            stage_total: buildPlan?.stages.length ?? 0,
             completed_stages: completedStages,
             warnings: state?.warning_count ?? 0,
             errors: (state?.error_count ?? 0) + errors,
@@ -103,21 +103,21 @@ export function computeCompiledHealth(dirPath) {
         checks,
     };
 }
-export function resolveCompiledStatus(..._args) {
+export function resolveVerifiableContextStatus(..._args) {
     const state = _args[_args.length - 1];
     if (state?.error_count && state.error_count > 0)
         return "failed";
     if (!state?.stages || Object.keys(state.stages).length === 0)
         return "idle";
     const allSucceeded = Object.values(state.stages).every((stage) => stage.status === "succeeded");
-    return allSucceeded ? "compiled" : "stale";
+    return allSucceeded ? "built" : "stale";
 }
-export function resolveCompiledStage(...args) {
+export function resolveBuildStage(...args) {
     const state = args[0];
     if (state?.error_count && state.error_count > 0)
         return "failed";
     if (!state?.stages || Object.keys(state.stages).length === 0)
         return "idle";
     const failedStage = Object.entries(state.stages).find(([, stage]) => stage.status !== "succeeded");
-    return failedStage?.[0] ?? "compiled";
+    return failedStage?.[0] ?? "built";
 }