@interf/compiler 0.21.0 → 0.22.2

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

@@ -195,21 +195,21 @@ async function runTargetTestsJudge(testCase, executor, candidateLabel, candidate
     return { verdict, error: executionError };
 }
 function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
-    const header = target.type === "compiled"
+    const header = target.type === "verifiable-context"
         ? [
-            "You are running an Interf test inside an isolated sandboxed portable context.",
+            "You are running an Interf test inside an isolated sandboxed verifiable-context copy.",
             "Read `AGENTS.md` first.",
-            "Use the local native `interf-query` skill available in this portable context.",
-            "Answer the check question the same way you would answer a real user inside this portable context.",
-            "Prefer the Method-declared portable-context outputs before consulting source references.",
-            "This sandbox is self-contained: the copied portable context has source references in `.interf/runtime/source-snapshot.json`.",
-            "The original Interf instance state is intentionally absent from this sandbox. Use the source locators only when the portable context needs verification.",
+            "Use the local native `interf-query` skill available in this verifiable context.",
+            "Answer the check question the same way you would answer a real user inside this verifiable context.",
+            "Prefer the Build Plan-declared verifiable-context outputs before consulting source references.",
+            "This sandbox is self-contained: the copied verifiable context has source references in `.interf/runtime/source-snapshot.json`.",
+            "The original Interf instance state is intentionally absent from this sandbox. Use the source locators only when the verifiable context needs verification.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated source-files test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
-            "There is no portable context in this sandbox.",
+            "There is no verifiable context in this sandbox.",
             "Answer only from source references listed in `runtime/source-files.json` inside this shell.",
             "The original control plane folder is intentionally absent from this sandbox.",
         ];
@@ -353,7 +353,7 @@ async function runTestCaseWithJudge(target, testCase, executor) {
     });
     checks.push(...evaluated.checks);
     if (testCase.answer) {
-        const judged = await runTargetTestsJudge(testCase, executor, `compiled file ${outputPath}`, content);
+        const judged = await runTargetTestsJudge(testCase, executor, `verifiable context file ${outputPath}`, content);
         checks.push({
             label: "judge verdict",
             ok: judged.verdict?.pass === true,
@@ -383,7 +383,7 @@ function buildTestTargetResult(target, caseResults, options = {}) {
             type: target.type,
             name: target.name,
             path: target.path,
-            method: target.method,
+            build_plan: target.build_plan,
         },
         ...(options.sandboxPath ? { sandbox_path: options.sandboxPath } : {}),
         ok: passedCases === caseResults.length,

package/dist/packages/engine/verify/verify-paths.d.ts

@@ -2,10 +2,10 @@ import type { TestTargetType } from "./verify-types.js";
 export declare const TEST_SPEC_EXTENSIONS: Set<string>;
 export declare function testSpecRootPath(sourcePath: string): string;
 export declare function testSpecTypePath(sourcePath: string, type: TestTargetType): string;
-export declare function targetTestRunsPath(compiledPath: string, type: TestTargetType): string;
-export declare function targetTestRunGitignorePath(compiledPath: string, type: TestTargetType): string;
-export declare function targetTestSandboxesPath(compiledPath: string, type: TestTargetType): string;
-export declare function targetTestSandboxGitignorePath(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestRunsPath(verifiableContextPath: string, type: TestTargetType): string;
+export declare function targetTestRunGitignorePath(verifiableContextPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxesPath(verifiableContextPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxGitignorePath(verifiableContextPath: string, type: TestTargetType): string;
 export declare function testSpecFilePath(sourcePath: string, type: TestTargetType, id: string): string;
 export declare function normalizeTestId(input: string): string;
 export declare function assertTestId(id: string): void;

package/dist/packages/engine/verify/verify-paths.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compile/compiled-paths.js";
+import { targetTestRunsRootForVerifiableContext, targetTestSandboxesRootForVerifiableContext, verifiableContextInterfConfigPath, } from "../build/verifiable-context-paths.js";
 import { asPreparationDataDir, preparationTestsSpecsRoot, } from "../../contracts/lib/preparation-paths.js";
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
@@ -14,29 +14,29 @@ function isPreparationTestsRootPath(artifactRootPath) {
     return basename(artifactRootPath) === "tests" &&
         basename(dirname(artifactRootPath)) === ".interf";
 }
-export function targetTestRunsPath(compiledPath, type) {
-    if (existsSync(compiledInterfConfigPath(compiledPath))) {
-        return join(targetTestRunsRootForCompiled(compiledPath), type);
+export function targetTestRunsPath(verifiableContextPath, type) {
+    if (existsSync(verifiableContextInterfConfigPath(verifiableContextPath))) {
+        return join(targetTestRunsRootForVerifiableContext(verifiableContextPath), type);
     }
-    if (isPreparationTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "source-files" ? "source-files" : "compiled", "runs");
+    if (isPreparationTestsRootPath(verifiableContextPath)) {
+        return join(verifiableContextPath, type === "source-files" ? "source-files" : "verifiable-context", "runs");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
+    throw new Error(`Unsupported test artifact root: ${verifiableContextPath}. Expected verifiable context or interf/<preparation>/.interf/tests root.`);
 }
-export function targetTestRunGitignorePath(compiledPath, type) {
-    return join(targetTestRunsPath(compiledPath, type), ".gitignore");
+export function targetTestRunGitignorePath(verifiableContextPath, type) {
+    return join(targetTestRunsPath(verifiableContextPath, type), ".gitignore");
 }
-export function targetTestSandboxesPath(compiledPath, type) {
-    if (existsSync(compiledInterfConfigPath(compiledPath))) {
-        return join(targetTestSandboxesRootForCompiled(compiledPath), type);
+export function targetTestSandboxesPath(verifiableContextPath, type) {
+    if (existsSync(verifiableContextInterfConfigPath(verifiableContextPath))) {
+        return join(targetTestSandboxesRootForVerifiableContext(verifiableContextPath), type);
     }
-    if (isPreparationTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "source-files" ? "source-files" : "compiled", "sandboxes");
+    if (isPreparationTestsRootPath(verifiableContextPath)) {
+        return join(verifiableContextPath, type === "source-files" ? "source-files" : "verifiable-context", "sandboxes");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
+    throw new Error(`Unsupported test artifact root: ${verifiableContextPath}. Expected verifiable context or interf/<preparation>/.interf/tests root.`);
 }
-export function targetTestSandboxGitignorePath(compiledPath, type) {
-    return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");
+export function targetTestSandboxGitignorePath(verifiableContextPath, type) {
+    return join(targetTestSandboxesPath(verifiableContextPath, type), ".gitignore");
 }
 export function testSpecFilePath(sourcePath, type, id) {
     return join(testSpecTypePath(sourcePath, type), `${id}.json`);

package/dist/packages/engine/verify/verify-sandbox.d.ts

@@ -3,7 +3,7 @@ export type TestSandboxRetentionMode = "on-failure" | "always";
 export interface TestSandbox {
     rootPath: string;
     targetPath: string;
-    compiledPath: string | null;
+    verifiableContextPath: string | null;
     preserve(destinationPath: string): string;
     cleanup(): void;
 }

package/dist/packages/engine/verify/verify-sandbox.js

@@ -1,22 +1,22 @@
 import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { refreshVerifiableContextBootstrapGuidance } from "../agents/lib/verifiable-context-bootstrap.js";
 import { readInterfConfig, resolveSourceInputPath } from "../../project/interf.js";
 import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
-import { asPreparationDataDir, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
-import { saveCompiledInterfConfig } from "../../project/source-config.js";
-import { buildCompiledSourceFiles } from "../compile/source-files.js";
-import { refreshCompiledArtifacts } from "../compile/state.js";
-import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compile/compiled-paths.js";
-function sanitizeCompiledArtifacts(compiledPath) {
+import { asPreparationDataDir, preparationVerifiableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { saveVerifiableContextInterfConfig } from "../../project/source-config.js";
+import { buildVerifiableContextSourceFiles } from "../build/source-files.js";
+import { refreshVerifiableContextArtifacts } from "../build/state.js";
+import { testRootForVerifiableContext, stageExecutionShellsRoot, targetTestSandboxesRootForVerifiableContext, buildPlanImprovementLoopsRoot, verifiableContextQueryAcceptanceRoot, verifiableContextRuntimeLogsRoot, } from "../build/verifiable-context-paths.js";
+function sanitizeVerifiableContextArtifacts(verifiableContextPath) {
     for (const absolutePath of [
-        testRootForCompiled(compiledPath),
-        targetTestSandboxesRootForCompiled(compiledPath),
-        stageExecutionShellsRoot(compiledPath),
-        methodImprovementLoopsRoot(compiledPath),
-        compiledRuntimeLogsRoot(compiledPath),
-        compiledQueryAcceptanceRoot(compiledPath),
+        testRootForVerifiableContext(verifiableContextPath),
+        targetTestSandboxesRootForVerifiableContext(verifiableContextPath),
+        stageExecutionShellsRoot(verifiableContextPath),
+        buildPlanImprovementLoopsRoot(verifiableContextPath),
+        verifiableContextRuntimeLogsRoot(verifiableContextPath),
+        verifiableContextQueryAcceptanceRoot(verifiableContextPath),
     ]) {
         rmSync(absolutePath, { recursive: true, force: true });
     }
@@ -24,23 +24,23 @@ function sanitizeCompiledArtifacts(compiledPath) {
 export function createTestSandbox(target) {
     let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
-    const sandboxCompiledPath = () => (target.type === "compiled"
-        ? preparationPortableContextPath(asPreparationDataDir(sandboxRoot), target.name)
+    const sandboxVerifiableContextPath = () => (target.type === "verifiable-context"
+        ? preparationVerifiableContextPath(asPreparationDataDir(sandboxRoot), target.name)
         : null);
-    const sandboxTargetPath = () => (target.type === "compiled"
-        ? preparationPortableContextPath(asPreparationDataDir(sandboxRoot), target.name)
+    const sandboxTargetPath = () => (target.type === "verifiable-context"
+        ? preparationVerifiableContextPath(asPreparationDataDir(sandboxRoot), target.name)
         : sandboxRoot);
     try {
-        if (target.type === "compiled") {
+        if (target.type === "verifiable-context") {
             const sourceInputPath = resolveSourceInputPath(target.path);
             mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
             cpSync(target.path, sandboxTargetPath(), { recursive: true });
-            sanitizeCompiledArtifacts(sandboxTargetPath());
+            sanitizeVerifiableContextArtifacts(sandboxTargetPath());
             const sandboxConfig = readInterfConfig(sandboxTargetPath());
             if (!sandboxConfig) {
-                throw new Error(`Sandbox portable context is missing interf.json: ${sandboxTargetPath()}`);
+                throw new Error(`Sandbox verifiable context is missing interf.json: ${sandboxTargetPath()}`);
             }
-            saveCompiledInterfConfig(sandboxTargetPath(), {
+            saveVerifiableContextInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
@@ -48,12 +48,12 @@ export function createTestSandbox(target) {
                     preparation_path: sourceInputPath,
                 },
             });
-            refreshCompiledBootstrapGuidance(sandboxTargetPath());
-            refreshCompiledArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
+            refreshVerifiableContextBootstrapGuidance(sandboxTargetPath());
+            refreshVerifiableContextArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
         }
         else {
             mkdirSync(join(sandboxTargetPath(), "runtime"), { recursive: true });
-            writeFileSync(join(sandboxTargetPath(), "runtime", "source-files.json"), `${JSON.stringify(buildCompiledSourceFiles(sandboxTargetPath(), target.path), null, 2)}\n`);
+            writeFileSync(join(sandboxTargetPath(), "runtime", "source-files.json"), `${JSON.stringify(buildVerifiableContextSourceFiles(sandboxTargetPath(), target.path), null, 2)}\n`);
             projectSourceFilesTestQueryShell(sandboxTargetPath());
         }
     }
@@ -68,8 +68,8 @@ export function createTestSandbox(target) {
         get targetPath() {
             return sandboxTargetPath();
         },
-        get compiledPath() {
-            return sandboxCompiledPath();
+        get verifiableContextPath() {
+            return sandboxVerifiableContextPath();
         },
         preserve(destinationPath) {
             mkdirSync(dirname(destinationPath), { recursive: true });

package/dist/packages/engine/verify/verify-targets.d.ts

@@ -1,5 +1,5 @@
 import type { TestTargetCandidate } from "./verify-types.js";
-export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
-export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, methodId?: string): TestTargetCandidate;
+export declare function listVerifiableContextTestTargets(sourcePath: string): TestTargetCandidate[];
+export declare function createVerifiableContextTestTarget(verifiableContextPath: string, verifiableContextName: string, buildPlanId?: string): TestTargetCandidate;
 export declare function createSourceFilesTestTarget(sourcePath: string): TestTargetCandidate;
 export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];

package/dist/packages/engine/verify/verify-targets.js

@@ -1,25 +1,25 @@
-import { listPortableContextsForSourceFolder } from "../../project/interf-detect.js";
-import { computeCompiledHealth } from "../compile/state.js";
-import { DEFAULT_METHOD_ID, resolveMethodId } from "../../methods/method-resolution.js";
+import { listVerifiableContextsForSourceFolder } from "../../project/interf-detect.js";
+import { computeVerifiableContextHealth } from "../build/state.js";
+import { DEFAULT_BUILD_PLAN_ID, resolveBuildPlanId } from "../../build-plans/build-plan-resolution.js";
 function summarizeTargetSortKey(target) {
-    return `${target.name}\u0000${target.method}`;
+    return `${target.name}\u0000${target.build_plan}`;
 }
-export function listCompiledTestTargets(sourcePath) {
-    return listPortableContextsForSourceFolder(sourcePath)
-        .map(({ path, config }) => createCompiledTestTarget(path, config.name, resolveMethodId(config)))
+export function listVerifiableContextTestTargets(sourcePath) {
+    return listVerifiableContextsForSourceFolder(sourcePath)
+        .map(({ path, config }) => createVerifiableContextTestTarget(path, config.name, resolveBuildPlanId(config)))
         .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
 }
-export function createCompiledTestTarget(compiledPath, compiledName, methodId = DEFAULT_METHOD_ID) {
-    const health = computeCompiledHealth(compiledPath);
+export function createVerifiableContextTestTarget(verifiableContextPath, verifiableContextName, buildPlanId = DEFAULT_BUILD_PLAN_ID) {
+    const health = computeVerifiableContextHealth(verifiableContextPath);
     return {
-        type: "compiled",
-        name: compiledName,
-        path: compiledPath,
-        method: methodId,
+        type: "verifiable-context",
+        name: verifiableContextName,
+        path: verifiableContextPath,
+        build_plan: buildPlanId,
         status: health.status,
         stage: health.stage,
         summary: health.summary,
-        eligible: health.status === "compiled",
+        eligible: health.status === "built",
     };
 }
 export function createSourceFilesTestTarget(sourcePath) {
@@ -27,13 +27,13 @@ export function createSourceFilesTestTarget(sourcePath) {
         type: "source-files",
         name: "source-files",
         path: sourcePath,
-        method: "source-files",
-        status: "compiled",
+        build_plan: "source-files",
+        status: "built",
         stage: "source-files",
         summary: "Run the checks against source file references in an isolated test shell.",
         eligible: true,
     };
 }
 export function listTestTargets(sourcePath) {
-    return listCompiledTestTargets(sourcePath);
+    return listVerifiableContextTestTargets(sourcePath);
 }

package/dist/packages/engine/verify/verify-types.d.ts

@@ -8,8 +8,8 @@ export interface TestTargetCandidate {
     type: TestTargetType;
     name: string;
     path: string;
-    method: string;
-    status: "idle" | "running" | "compiled" | "stale" | "failed";
+    build_plan: string;
+    status: "idle" | "running" | "built" | "stale" | "failed";
     stage: string;
     summary: string;
     eligible: boolean;

package/dist/packages/engine/verify/verify.d.ts

@@ -1,4 +1,4 @@
 export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./verify-types.js";
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./verify-specs.js";
-export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./verify-targets.js";
+export { createSourceFilesTestTarget, createVerifiableContextTestTarget, listVerifiableContextTestTargets, listTestTargets, } from "./verify-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./verify-execution.js";

package/dist/packages/engine/verify/verify.js

@@ -1,3 +1,3 @@
 export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./verify-specs.js";
-export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./verify-targets.js";
+export { createSourceFilesTestTarget, createVerifiableContextTestTarget, listVerifiableContextTestTargets, listTestTargets, } from "./verify-targets.js";
 export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./verify-execution.js";

package/dist/packages/engine/wire-schemas.d.ts

@@ -1,11 +1,11 @@
 /**
- * 0.17 — private wire-shape registry for the Compiler UI.
+ * 0.17 — private wire-shape registry for the Interf UI.
  *
  * The UI consumes the local-service API at `/v1/...`. Before 0.17 it
  * cast each `getJson` response to a TypeScript type without runtime
  * validation, which let the 0.16 prepRuns shape-mismatch bug
- * (UI typed `{ runs: CompileRunResource[] }`, API returns
- * `{ runs: CompileRun[] }`) ship to production. This module exposes
+ * (UI typed `{ runs: BuildRunResource[] }`, API returns
+ * `{ runs: BuildRun[] }`) ship to production. This module exposes
  * the response schemas the UI needs so `getJson` can validate at the
  * fetch boundary.
  *
@@ -14,21 +14,21 @@
  * subpath. 0.16 just pruned three subpath exports
  * (`./contracts`, `./execution`, `./local-service`); adding wire
  * schemas to the public ABI would reverse that direction-of-travel.
- * The Compiler UI builds inside the same repo and imports these
+ * The Interf UI builds inside the same repo and imports these
  * schemas via relative path — no public ABI change.
  */
 import { z } from "zod";
-import { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema } from "./lib/schema.js";
-export { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, };
+import { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, BuildPlanListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema } from "./lib/schema.js";
+export { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, BuildPlanListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, };
 /**
- * `GET /v1/preparations/<id>/runs` returns a flat list of compile runs.
- * The 0.16 bug came from typing this as `{ runs: CompileRunResource[] }`
- * (the wrapped form `{ run: CompileRun }`) when the API returns the
+ * `GET /v1/preparations/<id>/runs` returns a flat list of Build runs.
+ * The 0.16 bug came from typing this as `{ runs: BuildRunResource[] }`
+ * (the wrapped form `{ run: BuildRun }`) when the API returns the
  * unwrapped form. Pinning the schema here prevents the regression.
  */
-export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
+export declare const PreparationBuildRunListResponseSchema: z.ZodObject<{
     runs: z.ZodArray<z.ZodObject<{
-        kind: z.ZodLiteral<"interf-compile-run">;
+        kind: z.ZodLiteral<"interf-build-run">;
         version: z.ZodLiteral<1>;
         run_id: z.ZodString;
         status: z.ZodEnum<{
@@ -39,13 +39,12 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
             queued: "queued";
         }>;
         preparation: z.ZodString;
-        method: z.ZodString;
+        build_plan: z.ZodString;
         backend: z.ZodEnum<{
             native: "native";
-            "workflow-sdk": "workflow-sdk";
         }>;
         source_path: z.ZodString;
-        portable_context_path: z.ZodString;
+        verifiable_context_path: z.ZodString;
         created_at: z.ZodString;
         started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -139,11 +138,10 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
             timestamp: z.ZodString;
             type: z.ZodLiteral<"run.started">;
             preparation: z.ZodString;
-            method: z.ZodString;
-            portable_context_path: z.ZodString;
+            build_plan: z.ZodOptional<z.ZodString>;
+            verifiable_context_path: z.ZodOptional<z.ZodString>;
             backend: z.ZodEnum<{
                 native: "native";
-                "workflow-sdk": "workflow-sdk";
             }>;
         }, z.core.$strict>, z.ZodObject<{
             event_id: z.ZodString;
@@ -264,8 +262,8 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
             passed: z.ZodNumber;
             total: z.ZodNumber;
             target: z.ZodOptional<z.ZodEnum<{
+                "verifiable-context": "verifiable-context";
                 "source-files": "source-files";
-                compiled: "compiled";
             }>>;
             checks_fingerprint: z.ZodOptional<z.ZodString>;
             stale: z.ZodOptional<z.ZodBoolean>;
@@ -276,7 +274,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
             timestamp: z.ZodString;
             type: z.ZodLiteral<"readiness.updated">;
             preparation: z.ZodString;
-            readiness: z.ZodObject<{
+            readiness: z.ZodPreprocess<z.ZodObject<{
                 kind: z.ZodLiteral<"interf-readiness-state">;
                 version: z.ZodLiteral<1>;
                 generated_at: z.ZodString;
@@ -294,14 +292,14 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                 }>;
                 ready: z.ZodBoolean;
                 summary: z.ZodString;
-                portable_context_path: z.ZodNullable<z.ZodString>;
-                latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                verifiable_context_path: z.ZodNullable<z.ZodString>;
+                latest_build_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                compile: z.ZodNullable<z.ZodObject<{
+                build: z.ZodNullable<z.ZodObject<{
                     gate: z.ZodEnum<{
-                        "portable-context": "portable-context";
+                        "verifiable-context": "verifiable-context";
                         "preparation-config": "preparation-config";
-                        "compile-run": "compile-run";
+                        "build-run": "build-run";
                         "artifact-checks": "artifact-checks";
                         "readiness-checks": "readiness-checks";
                         "checks-current": "checks-current";
@@ -335,7 +333,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                         run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                         run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strict>>;
-                    portable_context: z.ZodNullable<z.ZodObject<{
+                    verifiable_context: z.ZodNullable<z.ZodObject<{
                         passed: z.ZodNumber;
                         total: z.ZodNumber;
                         pass_rate: z.ZodNullable<z.ZodNumber>;
@@ -347,9 +345,9 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                 }, z.core.$strict>;
                 checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
                     gate: z.ZodEnum<{
-                        "portable-context": "portable-context";
+                        "verifiable-context": "verifiable-context";
                         "preparation-config": "preparation-config";
-                        "compile-run": "compile-run";
+                        "build-run": "build-run";
                         "artifact-checks": "artifact-checks";
                         "readiness-checks": "readiness-checks";
                         "checks-current": "checks-current";
@@ -371,7 +369,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                     run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 }, z.core.$strict>>>;
-            }, z.core.$strict>;
+            }, z.core.$strict>>;
         }, z.core.$strict>], "type">>>;
         latest_proof: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
@@ -400,7 +398,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                 detail: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
-        readiness: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        readiness: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodObject<{
             kind: z.ZodLiteral<"interf-readiness-state">;
             version: z.ZodLiteral<1>;
             generated_at: z.ZodString;
@@ -418,14 +416,14 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
             }>;
             ready: z.ZodBoolean;
             summary: z.ZodString;
-            portable_context_path: z.ZodNullable<z.ZodString>;
-            latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            verifiable_context_path: z.ZodNullable<z.ZodString>;
+            latest_build_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            compile: z.ZodNullable<z.ZodObject<{
+            build: z.ZodNullable<z.ZodObject<{
                 gate: z.ZodEnum<{
-                    "portable-context": "portable-context";
+                    "verifiable-context": "verifiable-context";
                     "preparation-config": "preparation-config";
-                    "compile-run": "compile-run";
+                    "build-run": "build-run";
                     "artifact-checks": "artifact-checks";
                     "readiness-checks": "readiness-checks";
                     "checks-current": "checks-current";
@@ -459,7 +457,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                     run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 }, z.core.$strict>>;
-                portable_context: z.ZodNullable<z.ZodObject<{
+                verifiable_context: z.ZodNullable<z.ZodObject<{
                     passed: z.ZodNumber;
                     total: z.ZodNumber;
                     pass_rate: z.ZodNullable<z.ZodNumber>;
@@ -471,9 +469,9 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
             }, z.core.$strict>;
             checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 gate: z.ZodEnum<{
-                    "portable-context": "portable-context";
+                    "verifiable-context": "verifiable-context";
                     "preparation-config": "preparation-config";
-                    "compile-run": "compile-run";
+                    "build-run": "build-run";
                     "artifact-checks": "artifact-checks";
                     "readiness-checks": "readiness-checks";
                     "checks-current": "checks-current";
@@ -495,7 +493,7 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
                 run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strict>>>;
-        }, z.core.$strict>>>;
+        }, z.core.$strict>>>>;
         artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
             artifact_id: z.ZodString;
             status: z.ZodEnum<{
@@ -528,14 +526,14 @@ export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type PreparationCompileRunListResponse = z.infer<typeof PreparationCompileRunListResponseSchema>;
+export type PreparationBuildRunListResponse = z.infer<typeof PreparationBuildRunListResponseSchema>;
 /**
  * Thrown when `getJson` parses a response that fails the registered
  * schema. Surfaces the request path and the zod issue list so the UI
  * can render an actionable error rather than a stack trace.
  *
  * `issues` is typed as `unknown[]` so the class works across both
- * `zod` dependency trees in the monorepo (root + `src/apps/compiler-ui`).
+ * `zod` dependency trees in the monorepo (root + `src/apps/interf-ui`).
  * Callers cast or render structurally as needed.
  */
 export declare class WireShapeError extends Error {

package/dist/packages/engine/wire-schemas.js

@@ -1,11 +1,11 @@
 /**
- * 0.17 — private wire-shape registry for the Compiler UI.
+ * 0.17 — private wire-shape registry for the Interf UI.
  *
  * The UI consumes the local-service API at `/v1/...`. Before 0.17 it
  * cast each `getJson` response to a TypeScript type without runtime
  * validation, which let the 0.16 prepRuns shape-mismatch bug
- * (UI typed `{ runs: CompileRunResource[] }`, API returns
- * `{ runs: CompileRun[] }`) ship to production. This module exposes
+ * (UI typed `{ runs: BuildRunResource[] }`, API returns
+ * `{ runs: BuildRun[] }`) ship to production. This module exposes
  * the response schemas the UI needs so `getJson` can validate at the
  * fetch boundary.
  *
@@ -14,21 +14,21 @@
  * subpath. 0.16 just pruned three subpath exports
  * (`./contracts`, `./execution`, `./local-service`); adding wire
  * schemas to the public ABI would reverse that direction-of-travel.
- * The Compiler UI builds inside the same repo and imports these
+ * The Interf UI builds inside the same repo and imports these
  * schemas via relative path — no public ABI change.
  */
 import { z } from "zod";
-import { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, } from "./lib/schema.js";
-import { CompileRunSchema, } from "./execution/lib/schema.js";
-export { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, };
+import { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, BuildPlanListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, } from "./lib/schema.js";
+import { BuildRunSchema, } from "./execution/lib/schema.js";
+export { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, BuildPlanListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, };
 /**
- * `GET /v1/preparations/<id>/runs` returns a flat list of compile runs.
- * The 0.16 bug came from typing this as `{ runs: CompileRunResource[] }`
- * (the wrapped form `{ run: CompileRun }`) when the API returns the
+ * `GET /v1/preparations/<id>/runs` returns a flat list of Build runs.
+ * The 0.16 bug came from typing this as `{ runs: BuildRunResource[] }`
+ * (the wrapped form `{ run: BuildRun }`) when the API returns the
  * unwrapped form. Pinning the schema here prevents the regression.
  */
-export const PreparationCompileRunListResponseSchema = z.object({
-    runs: z.array(CompileRunSchema),
+export const PreparationBuildRunListResponseSchema = z.object({
+    runs: z.array(BuildRunSchema),
 }).strict();
 /**
  * Thrown when `getJson` parses a response that fails the registered
@@ -36,7 +36,7 @@ export const PreparationCompileRunListResponseSchema = z.object({
  * can render an actionable error rather than a stack trace.
  *
  * `issues` is typed as `unknown[]` so the class works across both
- * `zod` dependency trees in the monorepo (root + `src/apps/compiler-ui`).
+ * `zod` dependency trees in the monorepo (root + `src/apps/interf-ui`).
  * Callers cast or render structurally as needed.
  */
 export class WireShapeError extends Error {

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

@@ -6,4 +6,4 @@ export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
 export * as preparationEntries from "./preparation-entries.js";
-export type { InterfConfig, MethodId, PreparationName, SourceFolderBinding, SourcePreparationConfig, SourceReadinessCheck, SourceFolderConfig, } from "./lib/schema.js";
+export type { InterfConfig, BuildPlanId, PreparationName, SourceFolderBinding, SourcePreparationConfig, SourceReadinessCheck, SourceFolderConfig, } from "./lib/schema.js";

package/dist/packages/project/interf-bootstrap.d.ts

@@ -1 +1 @@
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/compiled-bootstrap.js";
+export { refreshVerifiableContextBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/verifiable-context-bootstrap.js";

package/dist/packages/project/interf-bootstrap.js

@@ -1 +1 @@
-export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/compiled-bootstrap.js";
+export { refreshVerifiableContextBootstrapGuidance, renderClaudeBootstrap, } from "../engine/agents/lib/verifiable-context-bootstrap.js";