@interf/compiler 0.21.0 → 0.22.2

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

@@ -0,0 +1,11 @@
+import { type VerifiableContextHealth, type VerifiableContextState, type VerifiableContextViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
+export declare function loadState<T>(dirPath: string): T | null;
+export declare function saveState<T>(dirPath: string, state: T): void;
+export declare function loadVerifiableContextHealth(dirPath: string): VerifiableContextHealth | null;
+export declare function saveVerifiableContextHealth(dirPath: string, health: VerifiableContextHealth): void;
+export declare function loadVerifiableContextViewSpec(dirPath: string): VerifiableContextViewSpec | null;
+export declare function saveVerifiableContextViewSpec(dirPath: string, viewSpec: VerifiableContextViewSpec): void;
+export declare function loadVerifiableContextSourceFiles(dirPath: string): SourceFiles | null;
+export declare function loadVerifiableContextSourceSnapshot(dirPath: string): SourceSnapshot | null;
+export declare function saveEmptyRuntimeInventory(dirPath: string): void;
+export declare function initVerifiableContextState(): VerifiableContextState;

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

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { warnInterf } from "../../contracts/utils/logger.js";
 import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { CompiledHealthSchema, CompiledStateSchema, CompiledViewSpecSchema, SourceFilesSchema, SourceSnapshotSchema, } from "./lib/schema.js";
-import { emptyCompiledInventory, } from "./runtime-inventory.js";
+import { VerifiableContextHealthSchema, VerifiableContextStateSchema, VerifiableContextViewSpecSchema, SourceFilesSchema, SourceSnapshotSchema, } from "./lib/schema.js";
+import { emptyRuntimeInventory, } from "./runtime-inventory.js";
 import { healthPath, sourceFilesPath, sourceSnapshotPath, statePath, viewSpecPath, } from "./state-paths.js";
-import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
+import { verifiableContextRuntimeInventoryPath, verifiableContextRuntimeRoot, } from "./verifiable-context-paths.js";
 export function loadState(dirPath) {
     const path = statePath(dirPath);
     if (!existsSync(path))
@@ -12,7 +12,7 @@ export function loadState(dirPath) {
     const raw = readJsonFileUnchecked(path, "runtime state");
     if (raw === null)
         return null;
-    const parsed = CompiledStateSchema.safeParse(raw);
+    const parsed = VerifiableContextStateSchema.safeParse(raw);
     if (parsed.success) {
         return parsed.data;
     }
@@ -20,52 +20,52 @@ export function loadState(dirPath) {
     return null;
 }
 export function saveState(dirPath, state) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
+    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(statePath(dirPath), JSON.stringify(state, null, 2) + "\n");
 }
-export function loadCompiledHealth(dirPath) {
+export function loadVerifiableContextHealth(dirPath) {
     const path = healthPath(dirPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "compiled health", CompiledHealthSchema);
+    return readJsonFileWithSchema(path, "verifiable-context health", VerifiableContextHealthSchema);
 }
-export function saveCompiledHealth(dirPath, health) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
+export function saveVerifiableContextHealth(dirPath, health) {
+    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(healthPath(dirPath), JSON.stringify(health, null, 2) + "\n");
 }
-export function loadCompiledViewSpec(dirPath) {
+export function loadVerifiableContextViewSpec(dirPath) {
     const path = viewSpecPath(dirPath);
     if (!existsSync(path))
         return null;
-    return loadViewSpec(path, CompiledViewSpecSchema);
+    return loadViewSpec(path, VerifiableContextViewSpecSchema);
 }
-export function saveCompiledViewSpec(dirPath, viewSpec) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
+export function saveVerifiableContextViewSpec(dirPath, viewSpec) {
+    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(viewSpecPath(dirPath), JSON.stringify(viewSpec, null, 2) + "\n");
 }
-export function loadCompiledSourceFiles(dirPath) {
+export function loadVerifiableContextSourceFiles(dirPath) {
     const path = sourceFilesPath(dirPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "compiled source files", SourceFilesSchema);
+    return readJsonFileWithSchema(path, "verifiable-context source files", SourceFilesSchema);
 }
-export function loadCompiledSourceSnapshot(dirPath) {
+export function loadVerifiableContextSourceSnapshot(dirPath) {
     const path = sourceSnapshotPath(dirPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "compiled source snapshot", SourceSnapshotSchema);
+    return readJsonFileWithSchema(path, "verifiable-context source snapshot", SourceSnapshotSchema);
 }
-export function saveEmptyCompiledInventory(dirPath) {
-    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(compiledRuntimeInventoryPath(dirPath), JSON.stringify(emptyCompiledInventory(), null, 2) + "\n");
+export function saveEmptyRuntimeInventory(dirPath) {
+    mkdirSync(verifiableContextRuntimeRoot(dirPath), { recursive: true });
+    writeFileSync(verifiableContextRuntimeInventoryPath(dirPath), JSON.stringify(emptyRuntimeInventory(), null, 2) + "\n");
 }
-export function initCompiledState() {
+export function initVerifiableContextState() {
     return {
         version: 2,
         pending: [],
         stages: {},
         last_add: null,
-        last_compile: null,
+        last_build: null,
         warning_count: 0,
         error_count: 0,
     };

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

@@ -0,0 +1,16 @@
+import { verifiableContextRuntimeHealthPath, verifiableContextRuntimeSourceFilesPath, verifiableContextRuntimeSourceSnapshotPath, verifiableContextRuntimeStatePath, verifiableContextRuntimeViewSpecPath, } from "./verifiable-context-paths.js";
+export function statePath(dirPath) {
+    return verifiableContextRuntimeStatePath(dirPath);
+}
+export function healthPath(dirPath) {
+    return verifiableContextRuntimeHealthPath(dirPath);
+}
+export function viewSpecPath(dirPath) {
+    return verifiableContextRuntimeViewSpecPath(dirPath);
+}
+export function sourceFilesPath(dirPath) {
+    return verifiableContextRuntimeSourceFilesPath(dirPath);
+}
+export function sourceSnapshotPath(dirPath) {
+    return verifiableContextRuntimeSourceSnapshotPath(dirPath);
+}

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

@@ -0,0 +1,5 @@
+import { type VerifiableContextViewSpec, type SourceFiles, type SourceSnapshot } from "./lib/schema.js";
+export declare function ensureVerifiableContextViewSpec(dirPath: string): VerifiableContextViewSpec;
+export declare function ensureVerifiableContextSourceFiles(dirPath: string): SourceFiles;
+export declare function ensureVerifiableContextSourceSnapshot(dirPath: string, sourceFiles?: SourceFiles): SourceSnapshot;
+export declare function normalizeVerifiableContextViewSpec(existing: VerifiableContextViewSpec, defaults?: VerifiableContextViewSpec): VerifiableContextViewSpec;

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

@@ -1,42 +1,42 @@
 import { basename } from "node:path";
 import { readInterfConfig, resolveSourceFolderPath } from "../../project/interf-detect.js";
-import { loadCompiledSourceSnapshot, loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
-import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
-import { writeCompiledSourceFiles, writeCompiledSourceSnapshot, } from "./source-files.js";
-export function ensureCompiledViewSpec(dirPath) {
-    const existing = loadCompiledViewSpec(dirPath);
+import { loadVerifiableContextSourceSnapshot, loadVerifiableContextViewSpec, saveVerifiableContextViewSpec, } from "./state-io.js";
+import { buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
+import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./verifiable-context-schema.js";
+import { getActiveBuildPlan, resolveRequiredBuildPlanFromConfig } from "../../build-plans/package/build-plan-definitions.js";
+import { writeVerifiableContextSourceFiles, writeVerifiableContextSourceSnapshot, } from "./source-files.js";
+export function ensureVerifiableContextViewSpec(dirPath) {
+    const existing = loadVerifiableContextViewSpec(dirPath);
     const now = new Date().toISOString();
-    const compiledName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
-    const defaults = buildDefaultCompiledViewSpec(dirPath, compiledName, now);
+    const verifiableContextName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
+    const defaults = buildDefaultVerifiableContextViewSpec(dirPath, verifiableContextName, now);
     if (existing) {
-        const normalized = normalizeCompiledViewSpec(existing, defaults);
+        const normalized = normalizeVerifiableContextViewSpec(existing, defaults);
         if (JSON.stringify(normalized) !== JSON.stringify(existing)) {
-            saveCompiledViewSpec(dirPath, normalized);
+            saveVerifiableContextViewSpec(dirPath, normalized);
         }
         return normalized;
     }
-    saveCompiledViewSpec(dirPath, defaults);
+    saveVerifiableContextViewSpec(dirPath, defaults);
     return defaults;
 }
-export function ensureCompiledSourceFiles(dirPath) {
+export function ensureVerifiableContextSourceFiles(dirPath) {
     const config = readInterfConfig(dirPath);
-    return writeCompiledSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
+    return writeVerifiableContextSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
 }
-export function ensureCompiledSourceSnapshot(dirPath, sourceFiles) {
-    const existing = loadCompiledSourceSnapshot(dirPath);
+export function ensureVerifiableContextSourceSnapshot(dirPath, sourceFiles) {
+    const existing = loadVerifiableContextSourceSnapshot(dirPath);
     if (existing)
         return existing;
     const config = readInterfConfig(dirPath);
-    const resolvedSourceFiles = sourceFiles ?? writeCompiledSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
-    return writeCompiledSourceSnapshot({
-        compiledPath: dirPath,
+    const resolvedSourceFiles = sourceFiles ?? writeVerifiableContextSourceFiles(dirPath, resolveSourceFolderPath(dirPath, config));
+    return writeVerifiableContextSourceSnapshot({
+        verifiableContextPath: dirPath,
         sourceFiles: resolvedSourceFiles,
         runId: null,
     });
 }
-export function normalizeCompiledViewSpec(existing, defaults) {
+export function normalizeVerifiableContextViewSpec(existing, defaults) {
     const resolvedDefaults = defaults ?? existing;
     return {
         ...resolvedDefaults,
@@ -58,21 +58,21 @@ export function normalizeCompiledViewSpec(existing, defaults) {
             : resolvedDefaults.graph_scope,
     };
 }
-function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
+function buildDefaultVerifiableContextViewSpec(dirPath, verifiableContextName, generatedAt) {
     const config = readInterfConfig(dirPath);
-    resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${dirPath}`);
-    const method = getActiveCompiledMethod(dirPath);
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    const schemaArtifacts = schema ? listCompiledSchemaArtifacts(schema) : [];
+    resolveRequiredBuildPlanFromConfig(config, `.interf/interf.json for ${dirPath}`);
+    const buildPlan = getActiveBuildPlan(dirPath);
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
+    const schemaArtifacts = schema ? listBuildPlanContextArtifacts(schema) : [];
     const outputDocumentPaths = schemaArtifacts
         .filter((artifact) => artifact.role === "output" && artifact.kind !== "runtime")
         .map((artifact) => artifact.path);
     const defaultNote = schemaArtifacts.find((artifact) => artifact.role === "output" && artifact.kind === "file")?.path ?? null;
     return {
-        kind: "compiled-view-spec",
+        kind: "verifiable-context-view-spec",
         version: 2,
         generated_at: generatedAt,
-        target_name: compiledName,
+        target_name: verifiableContextName,
         health_source: ".interf/runtime/health.json",
         state_source: ".interf/runtime/state.json",
         default_note: defaultNote,
@@ -83,12 +83,12 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
             { id: "completed-stages", label: "Completed", metric: "completed_stages", denominator_metric: "stage_total", format: "fraction" },
         ],
         sections: [
-            { id: "status", type: "status", title: "Compile Status", path: ".interf/runtime/health.json" },
+            { id: "status", type: "status", title: "Build Status", path: ".interf/runtime/health.json" },
             { id: "cards", type: "cards", title: "Key Metrics", path: ".interf/runtime/health.json" },
             ...(outputDocumentPaths.length > 0
                 ? [{ id: "outputs", type: "documents", title: "Output Artifacts", paths: outputDocumentPaths }]
                 : []),
-            { id: "method", type: "documents", title: "Method Docs", paths: ["method/README.md", ...method.stages.map((stage) => `method/compile/stages/${stage.skillDir}`)] },
+            { id: "build-plan", type: "documents", title: "Build Plan Docs", paths: ["build-plan/README.md", ...buildPlan.stages.map((stage) => `build-plan/build/stages/${stage.skillDir}`)] },
         ],
     };
 }

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

@@ -0,0 +1,7 @@
+export type { RuntimeStatus, BuildStage, VerifiableContextState, VerifiableContextHealth, ViewSection, ViewCard, VerifiableContextViewSpec, SourceFiles, SourceSnapshot, StageInputs, } from "./lib/schema.js";
+export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
+export { loadState, saveState, loadVerifiableContextHealth, saveVerifiableContextHealth, loadVerifiableContextViewSpec, loadVerifiableContextSourceFiles, loadVerifiableContextSourceSnapshot, saveVerifiableContextViewSpec, initVerifiableContextState, } from "./state-io.js";
+export { refreshVerifiableContextArtifacts, } from "./state-artifacts.js";
+export { computeVerifiableContextHealth, resolveVerifiableContextStatus, resolveBuildStage, } from "./state-health.js";
+export { ensureVerifiableContextViewSpec, ensureVerifiableContextSourceFiles, ensureVerifiableContextSourceSnapshot, normalizeVerifiableContextViewSpec, } from "./state-view.js";
+export declare function initializeBuildRuntimeState(dirPath: string): void;

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

@@ -0,0 +1,12 @@
+export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
+export { loadState, saveState, loadVerifiableContextHealth, saveVerifiableContextHealth, loadVerifiableContextViewSpec, loadVerifiableContextSourceFiles, loadVerifiableContextSourceSnapshot, saveVerifiableContextViewSpec, initVerifiableContextState, } from "./state-io.js";
+export { refreshVerifiableContextArtifacts, } from "./state-artifacts.js";
+export { computeVerifiableContextHealth, resolveVerifiableContextStatus, resolveBuildStage, } from "./state-health.js";
+export { ensureVerifiableContextViewSpec, ensureVerifiableContextSourceFiles, ensureVerifiableContextSourceSnapshot, normalizeVerifiableContextViewSpec, } from "./state-view.js";
+import { saveEmptyRuntimeInventory, initVerifiableContextState, saveState } from "./state-io.js";
+import { refreshVerifiableContextArtifacts } from "./state-artifacts.js";
+export function initializeBuildRuntimeState(dirPath) {
+    saveState(dirPath, initVerifiableContextState());
+    saveEmptyRuntimeInventory(dirPath);
+    refreshVerifiableContextArtifacts(dirPath, { ensureViewSpec: true });
+}

package/dist/packages/engine/build/validate-verifiable-context.d.ts

@@ -0,0 +1,27 @@
+export interface VerifiableContextValidationSummary {
+    config_present: boolean;
+    config_valid: boolean;
+    config_type_match: boolean;
+    build_plan_present: boolean;
+    build_plan_valid: boolean;
+    schema_present: boolean;
+    schema_valid: boolean;
+}
+export interface BuildStageValidation {
+    ok: boolean;
+    required: boolean;
+    stage: string;
+    summary: string;
+    counts: Record<string, number>;
+    checks: Record<string, boolean>;
+    errors: string[];
+}
+export interface VerifiableContextValidation extends BuildStageValidation {
+    stage_results: Record<string, boolean>;
+}
+export declare function validateVerifiableContextSetup(dirPath: string): VerifiableContextValidationSummary;
+export declare function validateBuildStage(dirPath: string, stageId: string): BuildStageValidation;
+export declare function validateVerifiableContext(dirPath: string): VerifiableContextValidation;
+export declare function validateBuildSummarize(dirPath: string): BuildStageValidation;
+export declare function validateVerifiableContextStructure(dirPath: string): BuildStageValidation;
+export declare function validateBuildOutput(dirPath: string): VerifiableContextValidation;

package/dist/packages/engine/{compile/validate-compiled.js → build/validate-verifiable-context.js}

@@ -1,58 +1,58 @@
 import { existsSync } from "node:fs";
 import { discoverSourceFiles } from "./discovery.js";
-import { METHOD_SCHEMA_FILE, findCompiledSchemaArtifact, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
+import { BUILD_PLAN_SCHEMA_FILE, findBuildPlanContextArtifact, readBuildPlanContextFile, buildPlanSchemaExists, } from "./verifiable-context-schema.js";
 import { resolveSourceFolderPath } from "../../project/interf-detect.js";
-import { compiledInterfConfigPath, methodPackagePathForCompiled } from "./compiled-paths.js";
-import { readCompiledConfig } from "./validate.js";
+import { verifiableContextInterfConfigPath, buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
+import { readVerifiableContextConfig } from "./validate.js";
 import { loadState } from "./state.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../../methods/package/method-definitions.js";
-import { countCompiledArtifactsAtPath } from "./artifact-counts.js";
+import { getActiveBuildPlan, resolveRequiredBuildPlanFromConfig, } from "../../build-plans/package/build-plan-definitions.js";
+import { countBuildArtifactsAtPath } from "./artifact-counts.js";
 import { evaluateChecks } from "./check-evaluator.js";
-function methodSchemaPresent(dirPath) {
-    return methodSchemaExists(methodPackagePathForCompiled(dirPath));
+function buildPlanSchemaPresent(dirPath) {
+    return buildPlanSchemaExists(buildPlanPackagePathForVerifiableContext(dirPath));
 }
-function methodJsonPresent(dirPath) {
-    return existsSync(methodPackagePathForCompiled(dirPath) + "/method.json");
+function buildPlanJsonPresent(dirPath) {
+    return existsSync(buildPlanPackagePathForVerifiableContext(dirPath) + "/build-plan.json");
 }
-function readMethodContext(dirPath) {
-    const config = readCompiledConfig(dirPath);
-    const methodId = config.valid
-        ? resolveRequiredCompiledMethodFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
+function readBuildPlanValidationContext(dirPath) {
+    const config = readVerifiableContextConfig(dirPath);
+    const buildPlanId = config.valid
+        ? resolveRequiredBuildPlanFromConfig(config.value, `.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 schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
     const state = loadState(dirPath);
     const sourceTotal = config.valid
         ? discoverSourceFiles(resolveSourceFolderPath(dirPath, config.value), dirPath).totalCount
         : 0;
     return {
         config,
-        method,
+        buildPlan,
         schema,
         state,
         sourceTotal,
-        methodId,
+        buildPlanId,
     };
 }
 function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
     return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
 }
-function artifactWriteCount(compiledPath, schema, stage) {
+function artifactWriteCount(verifiableContextPath, schema, stage) {
     const artifactCounts = {};
     let total = 0;
     for (const artifactId of stage.writes) {
-        const artifact = findCompiledSchemaArtifact(schema, artifactId);
+        const artifact = findBuildPlanContextArtifact(schema, artifactId);
         if (!artifact)
             continue;
-        const count = countCompiledArtifactsAtPath(compiledPath, artifact.path, artifact.kind);
+        const count = countBuildArtifactsAtPath(verifiableContextPath, artifact.path, artifact.kind);
         artifactCounts[artifactId] = count;
         total += count;
     }
@@ -76,7 +76,7 @@ function artifactsBuiltByStage(schema, stage) {
         return artifact.shape.kind === "path" && (stage.writes.includes(artifact.id) || stage.writes.includes(artifact.shape.path));
     });
 }
-function artifactCheckFailures(compiledPath, artifacts, counts) {
+function artifactCheckFailures(verifiableContextPath, artifacts, counts) {
     const failures = [];
     for (const artifact of artifacts) {
         const checks = artifact.checks ?? [];
@@ -84,7 +84,7 @@ function artifactCheckFailures(compiledPath, artifacts, counts) {
             continue;
         const targetPath = artifact.shape.kind === "path" ? artifact.shape.path : undefined;
         const result = evaluateChecks(checks, {
-            rootPath: compiledPath,
+            rootPath: verifiableContextPath,
             targetPath,
             counts,
         });
@@ -107,61 +107,61 @@ function mergeValidationCounts(sourceTotal, stageRecord, artifactCounts) {
     }
     return merged;
 }
-export function validateCompiled(dirPath) {
-    const context = readMethodContext(dirPath);
+export function validateVerifiableContextSetup(dirPath) {
+    const context = readBuildPlanValidationContext(dirPath);
     return {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        method_present: methodJsonPresent(dirPath),
-        method_valid: context.method !== null,
-        schema_present: methodSchemaPresent(dirPath),
+        build_plan_present: buildPlanJsonPresent(dirPath),
+        build_plan_valid: context.buildPlan !== null,
+        schema_present: buildPlanSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
 }
-export function validateCompiledStage(dirPath, stageId) {
-    const context = readMethodContext(dirPath);
+export function validateBuildStage(dirPath, stageId) {
+    const context = readBuildPlanValidationContext(dirPath);
     const checks = {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        method_present: methodJsonPresent(dirPath),
-        method_valid: context.method !== null,
-        schema_present: methodSchemaPresent(dirPath),
+        build_plan_present: buildPlanJsonPresent(dirPath),
+        build_plan_valid: context.buildPlan !== null,
+        schema_present: buildPlanSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
     const errors = [];
     if (!checks.config_present)
-        errors.push(`Missing ${compiledInterfConfigPath(dirPath)}.`);
+        errors.push(`Missing ${verifiableContextInterfConfigPath(dirPath)}.`);
     else if (!checks.config_valid)
-        errors.push(`Could not parse ${compiledInterfConfigPath(dirPath)}.`);
+        errors.push(`Could not parse ${verifiableContextInterfConfigPath(dirPath)}.`);
     else if (!checks.config_type_match)
-        errors.push("Config is not a portable context.");
-    if (!checks.method_present)
-        errors.push("Missing .interf/method/method.json.");
-    else if (!checks.method_valid)
-        errors.push("Could not load the active Method package.");
+        errors.push("Config is not a verifiable context.");
+    if (!checks.build_plan_present)
+        errors.push("Missing .interf/build-plan/build-plan.json.");
+    else if (!checks.build_plan_valid)
+        errors.push("Could not load the active Build Plan package.");
     if (!checks.schema_present)
-        errors.push(`Missing .interf/method/${METHOD_SCHEMA_FILE}.`);
+        errors.push(`Missing .interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}.`);
     else if (!checks.schema_valid)
-        errors.push(`Could not parse .interf/method/${METHOD_SCHEMA_FILE}.`);
-    const methodStage = context.method?.stages.find((stage) => stage.id === stageId) ?? null;
-    checks.stage_present = methodStage !== null;
+        errors.push(`Could not parse .interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}.`);
+    const buildPlanStage = context.buildPlan?.stages.find((stage) => stage.id === stageId) ?? null;
+    checks.stage_present = buildPlanStage !== null;
     if (!checks.stage_present) {
-        errors.push(`Method does not declare stage "${stageId}".`);
+        errors.push(`Build Plan does not declare stage "${stageId}".`);
     }
     const stageRecord = stageRecordFromState(context.state, stageId);
     checks.stage_record_present = stageRecord !== null;
     checks.stage_finished = Boolean(stageRecord?.finished_at);
     checks.stage_succeeded = stageRecord?.status === "succeeded";
-    const writeCounts = methodStage && context.schema
-        ? artifactWriteCount(dirPath, context.schema, methodStage)
+    const writeCounts = buildPlanStage && context.schema
+        ? artifactWriteCount(dirPath, context.schema, buildPlanStage)
         : { total: 0, artifactCounts: {} };
     const artifactCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.artifactCounts);
     const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
     let artifactErrors = [];
-    if (methodStage && context.schema) {
-        const artifacts = artifactsBuiltByStage(context.schema, methodStage);
+    if (buildPlanStage && context.schema) {
+        const artifacts = artifactsBuiltByStage(context.schema, buildPlanStage);
         const failures = artifactCheckFailures(dirPath, artifacts, artifactCounts);
         checks.artifact_checks_ok = failures.length === 0;
         artifactErrors = failures.map((proof) => `Artifact check "${proof.check_id}" failed for ${proof.kind}: ${proof.summary}`);
@@ -192,30 +192,30 @@ export function validateCompiledStage(dirPath, stageId) {
         counts: {
             ...artifactCounts,
             write_artifacts: writeCounts.total,
-            declared_write_artifacts: methodStage?.writes.length ?? 0,
+            declared_write_artifacts: buildPlanStage?.writes.length ?? 0,
         },
         checks,
         errors,
     };
 }
-export function validateCompiledMethod(dirPath) {
-    const context = readMethodContext(dirPath);
+export function validateVerifiableContext(dirPath) {
+    const context = readBuildPlanValidationContext(dirPath);
     const checks = {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        method_present: methodJsonPresent(dirPath),
-        method_valid: context.method !== null,
-        schema_present: methodSchemaPresent(dirPath),
+        build_plan_present: buildPlanJsonPresent(dirPath),
+        build_plan_valid: context.buildPlan !== null,
+        schema_present: buildPlanSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
-    if (!context.method) {
-        const errors = ["Could not load the active Method package."];
+    if (!context.buildPlan) {
+        const errors = ["Could not load the active Build Plan package."];
         return {
             ok: false,
             required: true,
-            stage: "method",
-            summary: `Compiled Method failed — ${errors[0]}`,
+            stage: "build-plan",
+            summary: `Build Plan failed — ${errors[0]}`,
             counts: { source_total: context.sourceTotal, stage_total: 0, completed_stages: 0 },
             checks,
             errors,
@@ -225,9 +225,9 @@ export function validateCompiledMethod(dirPath) {
     const stageResults = {};
     const errors = [];
     let completedStages = 0;
-    let failedStage = "compiled";
-    for (const stage of context.method.stages) {
-        const validation = validateCompiledStage(dirPath, stage.id);
+    let failedStage = "built";
+    for (const stage of context.buildPlan.stages) {
+        const validation = validateBuildStage(dirPath, stage.id);
         stageResults[stage.id] = validation.ok;
         if (validation.ok) {
             completedStages += 1;
@@ -243,11 +243,11 @@ export function validateCompiledMethod(dirPath) {
         required: context.sourceTotal > 0,
         stage: failedStage,
         summary: ok
-            ? `Compiled Method verified — ${completedStages}/${context.method.stages.length} stages satisfied.`
-            : `Compiled Method failed — ${errors[0] ?? "stage artifact checks not satisfied."}`,
+            ? `Build Plan verified — ${completedStages}/${context.buildPlan.stages.length} stages satisfied.`
+            : `Build Plan failed — ${errors[0] ?? "stage artifact checks not satisfied."}`,
         counts: {
             source_total: context.sourceTotal,
-            stage_total: context.method.stages.length,
+            stage_total: context.buildPlan.stages.length,
             completed_stages: completedStages,
         },
         checks,
@@ -255,12 +255,12 @@ export function validateCompiledMethod(dirPath) {
         stage_results: stageResults,
     };
 }
-export function validateCompiledSummarize(dirPath) {
-    return validateCompiledStage(dirPath, "summarize");
+export function validateBuildSummarize(dirPath) {
+    return validateBuildStage(dirPath, "summarize");
 }
-export function validateCompiledStructure(dirPath) {
-    return validateCompiledStage(dirPath, "structure");
+export function validateVerifiableContextStructure(dirPath) {
+    return validateBuildStage(dirPath, "structure");
 }
-export function validateCompiledCompile(dirPath) {
-    return validateCompiledMethod(dirPath);
+export function validateBuildOutput(dirPath) {
+    return validateVerifiableContext(dirPath);
 }

package/dist/packages/engine/{compile → build}/validate.d.ts

@@ -1,5 +1,5 @@
 import { readInterfConfig } from "../../project/interf-detect.js";
-export declare function readCompiledConfig(dirPath: string): {
+export declare function readVerifiableContextConfig(dirPath: string): {
     present: boolean;
     valid: boolean;
     value: ReturnType<typeof readInterfConfig>;
@@ -11,11 +11,11 @@ export declare function validateSynthFiles(files: string[], options?: {
     invalid_frontmatter: number;
     short_abstracts: number;
 };
-export declare function countBrokenWikilinks(compiledRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
+export declare function countBrokenWikilinks(verifiableContextRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
 export declare function asNumber(value: unknown): number;
 export declare function isOutputMarkdownFile(filePath: string): boolean;
 export declare function safeReadText(filePath: string): string | null;
 export declare function extractSynthAbstract(frontmatter: Record<string, unknown>, body: string): string | null;
 export declare function countSynthAbstractWords(frontmatter: Record<string, unknown>, body: string): number;
-export { validateCompiled, validateCompiledStage, validateCompiledMethod, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
-export type { CompiledValidationSummary, CompiledStageValidation, CompiledMethodValidation, } from "./validate-compiled.js";
+export { validateVerifiableContextSetup, validateBuildStage, validateVerifiableContext, validateBuildSummarize, validateVerifiableContextStructure, validateBuildOutput, } from "./validate-verifiable-context.js";
+export type { VerifiableContextValidationSummary, BuildStageValidation, VerifiableContextValidation, } from "./validate-verifiable-context.js";