@interf/compiler 0.22.0 → 0.33.0

package/dist/packages/{engine/build/validate-verifiable-context.js → runtime/build/validate-context-graph.js}

@@ -1,21 +1,20 @@
 import { existsSync } from "node:fs";
-import { discoverSourceFiles } from "./discovery.js";
-import { BUILD_PLAN_SCHEMA_FILE, findBuildPlanContextArtifact, readBuildPlanContextFile, buildPlanSchemaExists, } from "./verifiable-context-schema.js";
-import { resolveSourceFolderPath } from "../../project/interf-detect.js";
-import { verifiableContextInterfConfigPath, buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
-import { readVerifiableContextConfig } from "./validate.js";
+import { BUILD_PLAN_SCHEMA_FILE, findBuildPlanContextArtifact, readBuildPlanContextFile, buildPlanSchemaExists, } from "./context-graph-schema.js";
+import { contextGraphInterfConfigPath, buildPlanPackagePathForContextGraph } from "./context-graph-paths.js";
+import { readContextGraphConfig } from "./validate.js";
 import { loadState } from "./state.js";
 import { getActiveBuildPlan, resolveRequiredBuildPlanFromConfig, } from "../../build-plans/package/build-plan-definitions.js";
 import { countBuildArtifactsAtPath } from "./artifact-counts.js";
 import { evaluateChecks } from "./check-evaluator.js";
+import { loadContextGraphSourceManifest } from "./source-manifest.js";
 function buildPlanSchemaPresent(dirPath) {
-    return buildPlanSchemaExists(buildPlanPackagePathForVerifiableContext(dirPath));
+    return buildPlanSchemaExists(buildPlanPackagePathForContextGraph(dirPath));
 }
 function buildPlanJsonPresent(dirPath) {
-    return existsSync(buildPlanPackagePathForVerifiableContext(dirPath) + "/build-plan.json");
+    return existsSync(buildPlanPackagePathForContextGraph(dirPath) + "/build-plan.json");
 }
 function readBuildPlanValidationContext(dirPath) {
-    const config = readVerifiableContextConfig(dirPath);
+    const config = readContextGraphConfig(dirPath);
     const buildPlanId = config.valid
         ? resolveRequiredBuildPlanFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
         : null;
@@ -28,16 +27,16 @@ function readBuildPlanValidationContext(dirPath) {
             buildPlan = null;
         }
     }
-    const schema = readBuildPlanContextFile(buildPlanPackagePathForVerifiableContext(dirPath));
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForContextGraph(dirPath));
     const state = loadState(dirPath);
-    const sourceTotal = config.valid
-        ? discoverSourceFiles(resolveSourceFolderPath(dirPath, config.value), dirPath).totalCount
-        : 0;
+    const sourceManifest = loadContextGraphSourceManifest(dirPath);
+    const sourceTotal = sourceManifest?.source_total ?? 0;
     return {
         config,
         buildPlan,
         schema,
         state,
+        sourceManifest,
         sourceTotal,
         buildPlanId,
     };
@@ -45,14 +44,14 @@ function readBuildPlanValidationContext(dirPath) {
 function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
     return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
 }
-function artifactWriteCount(verifiableContextPath, schema, stage) {
+function artifactWriteCount(contextGraphPath, schema, stage) {
     const artifactCounts = {};
     let total = 0;
     for (const artifactId of stage.writes) {
         const artifact = findBuildPlanContextArtifact(schema, artifactId);
         if (!artifact)
             continue;
-        const count = countBuildArtifactsAtPath(verifiableContextPath, artifact.path, artifact.kind);
+        const count = countBuildArtifactsAtPath(contextGraphPath, artifact.path, artifact.kind);
         artifactCounts[artifactId] = count;
         total += count;
     }
@@ -76,7 +75,7 @@ function artifactsBuiltByStage(schema, stage) {
         return artifact.shape.kind === "path" && (stage.writes.includes(artifact.id) || stage.writes.includes(artifact.shape.path));
     });
 }
-function artifactCheckFailures(verifiableContextPath, artifacts, counts) {
+function artifactCheckFailures(contextGraphPath, artifacts, counts) {
     const failures = [];
     for (const artifact of artifacts) {
         const checks = artifact.checks ?? [];
@@ -84,7 +83,7 @@ function artifactCheckFailures(verifiableContextPath, artifacts, counts) {
             continue;
         const targetPath = artifact.shape.kind === "path" ? artifact.shape.path : undefined;
         const result = evaluateChecks(checks, {
-            rootPath: verifiableContextPath,
+            rootPath: contextGraphPath,
             targetPath,
             counts,
         });
@@ -107,7 +106,7 @@ function mergeValidationCounts(sourceTotal, stageRecord, artifactCounts) {
     }
     return merged;
 }
-export function validateVerifiableContextSetup(dirPath) {
+export function validateContextGraphSetup(dirPath) {
     const context = readBuildPlanValidationContext(dirPath);
     return {
         config_present: context.config.present,
@@ -132,11 +131,11 @@ export function validateBuildStage(dirPath, stageId) {
     };
     const errors = [];
     if (!checks.config_present)
-        errors.push(`Missing ${verifiableContextInterfConfigPath(dirPath)}.`);
+        errors.push(`Missing ${contextGraphInterfConfigPath(dirPath)}.`);
     else if (!checks.config_valid)
-        errors.push(`Could not parse ${verifiableContextInterfConfigPath(dirPath)}.`);
+        errors.push(`Could not parse ${contextGraphInterfConfigPath(dirPath)}.`);
     else if (!checks.config_type_match)
-        errors.push("Config is not a verifiable context.");
+        errors.push("Config is not a context graph.");
     if (!checks.build_plan_present)
         errors.push("Missing .interf/build-plan/build-plan.json.");
     else if (!checks.build_plan_valid)
@@ -145,6 +144,11 @@ export function validateBuildStage(dirPath, stageId) {
         errors.push(`Missing .interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}.`);
     else if (!checks.schema_valid)
         errors.push(`Could not parse .interf/build-plan/${BUILD_PLAN_SCHEMA_FILE}.`);
+    checks.source_files_present = context.sourceTotal > 0;
+    checks.source_manifest_valid = context.sourceManifest !== null && context.sourceTotal > 0;
+    if (!checks.source_files_present) {
+        errors.push("No Source Manifest has been recorded for this Context Graph.");
+    }
     const buildPlanStage = context.buildPlan?.stages.find((stage) => stage.id === stageId) ?? null;
     checks.stage_present = buildPlanStage !== null;
     if (!checks.stage_present) {
@@ -163,14 +167,17 @@ export function validateBuildStage(dirPath, stageId) {
     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}`);
+        checks.artifact_diagnostics_ok = failures.length === 0;
+        artifactErrors = failures.map((result) => `Artifact diagnostic "${result.check_id}" failed for ${result.kind}: ${result.summary}`);
     }
     else {
-        checks.artifact_checks_ok = false;
+        checks.artifact_diagnostics_ok = false;
     }
     if (required && checks.stage_record_present && !checks.stage_finished) {
-        errors.push(`Stage "${stageId}" has no finished_at proof in runtime state.`);
+        errors.push(`Stage "${stageId}" has no finished_at evidence in runtime state.`);
+    }
+    if (required && !checks.stage_record_present) {
+        errors.push(`Stage "${stageId}" has no runtime state record.`);
     }
     if (required && checks.stage_record_present && !checks.stage_succeeded) {
         errors.push(`Stage "${stageId}" is not marked succeeded in runtime state.`);
@@ -178,12 +185,12 @@ export function validateBuildStage(dirPath, stageId) {
     if (required) {
         errors.push(...artifactErrors);
     }
-    const ok = required ? errors.length === 0 : errors.length === 0;
-    const summary = !required
-        ? `Stage "${stageId}" is not required yet.`
-        : ok
-            ? `Stage "${stageId}" verified.`
-            : `Stage "${stageId}" failed — ${errors[0] ?? "artifact checks not satisfied."}`;
+    const ok = errors.length === 0;
+    const summary = ok
+        ? required
+            ? `Stage "${stageId}" checks passed.`
+            : `Stage "${stageId}" is not required yet.`
+        : `Stage "${stageId}" failed — ${errors[0] ?? "Artifact diagnostics not satisfied."}`;
     return {
         ok,
         required,
@@ -198,7 +205,7 @@ export function validateBuildStage(dirPath, stageId) {
         errors,
     };
 }
-export function validateVerifiableContext(dirPath) {
+export function validateContextGraph(dirPath) {
     const context = readBuildPlanValidationContext(dirPath);
     const checks = {
         config_present: context.config.present,
@@ -208,6 +215,8 @@ export function validateVerifiableContext(dirPath) {
         build_plan_valid: context.buildPlan !== null,
         schema_present: buildPlanSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
+        source_files_present: context.sourceTotal > 0,
+        source_manifest_valid: context.sourceManifest !== null && context.sourceTotal > 0,
     };
     if (!context.buildPlan) {
         const errors = ["Could not load the active Build Plan package."];
@@ -226,6 +235,10 @@ export function validateVerifiableContext(dirPath) {
     const errors = [];
     let completedStages = 0;
     let failedStage = "built";
+    if (!checks.source_files_present) {
+        errors.push("No Source Manifest has been recorded for this Context Graph.");
+        failedStage = "source";
+    }
     for (const stage of context.buildPlan.stages) {
         const validation = validateBuildStage(dirPath, stage.id);
         stageResults[stage.id] = validation.ok;
@@ -243,8 +256,8 @@ export function validateVerifiableContext(dirPath) {
         required: context.sourceTotal > 0,
         stage: failedStage,
         summary: ok
-            ? `Build Plan verified — ${completedStages}/${context.buildPlan.stages.length} stages satisfied.`
-            : `Build Plan failed — ${errors[0] ?? "stage artifact checks not satisfied."}`,
+            ? `Build Plan checks passed — ${completedStages}/${context.buildPlan.stages.length} stages satisfied.`
+            : `Build Plan failed — ${errors[0] ?? "stage Artifact diagnostics not satisfied."}`,
         counts: {
             source_total: context.sourceTotal,
             stage_total: context.buildPlan.stages.length,
@@ -258,9 +271,9 @@ export function validateVerifiableContext(dirPath) {
 export function validateBuildSummarize(dirPath) {
     return validateBuildStage(dirPath, "summarize");
 }
-export function validateVerifiableContextStructure(dirPath) {
+export function validateContextGraphStructure(dirPath) {
     return validateBuildStage(dirPath, "structure");
 }
 export function validateBuildOutput(dirPath) {
-    return validateVerifiableContext(dirPath);
+    return validateContextGraph(dirPath);
 }

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

@@ -1,5 +1,5 @@
-import { readInterfConfig } from "../../project/interf-detect.js";
-export declare function readVerifiableContextConfig(dirPath: string): {
+import { readInterfConfig } from "../../projects/interf-detect.js";
+export declare function readContextGraphConfig(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(verifiableContextRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
+export declare function countBrokenWikilinks(contextGraphRoot: 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 { validateVerifiableContextSetup, validateBuildStage, validateVerifiableContext, validateBuildSummarize, validateVerifiableContextStructure, validateBuildOutput, } from "./validate-verifiable-context.js";
-export type { VerifiableContextValidationSummary, BuildStageValidation, VerifiableContextValidation, } from "./validate-verifiable-context.js";
+export { validateContextGraphSetup, validateBuildStage, validateContextGraph, validateBuildSummarize, validateContextGraphStructure, validateBuildOutput, } from "./validate-context-graph.js";
+export type { ContextGraphValidationSummary, BuildStageValidation, ContextGraphValidation, } from "./validate-context-graph.js";

package/dist/packages/{engine → runtime}/build/validate.js

@@ -1,15 +1,15 @@
 import { existsSync, readFileSync, statSync, } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
-import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./verifiable-context-schema.js";
-import { buildPlanPackagePathForVerifiableContext } from "./verifiable-context-paths.js";
+import { listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./context-graph-schema.js";
+import { buildPlanPackagePathForContextGraph } from "./context-graph-paths.js";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { readInterfConfig } from "../../project/interf-detect.js";
+import { readInterfConfig } from "../../projects/interf-detect.js";
 import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
-import { verifiableContextInterfConfigPath } from "./verifiable-context-paths.js";
+import { contextGraphInterfConfigPath } from "./context-graph-paths.js";
 const MIN_ABSTRACT_WORDS = 5;
 const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
-export function readVerifiableContextConfig(dirPath) {
-    const configPath = verifiableContextInterfConfigPath(dirPath);
+export function readContextGraphConfig(dirPath) {
+    const configPath = contextGraphInterfConfigPath(dirPath);
     const value = readInterfConfig(dirPath);
     const present = existsSync(configPath);
     if (!present) {
@@ -25,7 +25,7 @@ export function readVerifiableContextConfig(dirPath) {
         valid: value !== null,
         value,
         typeMatch() {
-            return value?.type === "verifiable-context" && typeof value?.source?.path === "string";
+            return value?.type === "context-graph" && typeof value?.source?.path === "string";
         },
     };
 }
@@ -51,9 +51,9 @@ export function validateSynthFiles(files, options) {
         short_abstracts: shortAbstracts,
     };
 }
-export function countBrokenWikilinks(verifiableContextRoot, noteIndexRoots, linkScanRoots) {
-    const artifactPathById = verifiableContextArtifactDirectoryPaths(verifiableContextRoot);
-    const directoryLeafParents = verifiableContextDirectoryLeafParents(artifactPathById);
+export function countBrokenWikilinks(contextGraphRoot, noteIndexRoots, linkScanRoots) {
+    const artifactPathById = contextGraphArtifactDirectoryPaths(contextGraphRoot);
+    const directoryLeafParents = contextGraphDirectoryLeafParents(artifactPathById);
     const noteIndex = new Set();
     for (const filePath of dedupeFiles(noteIndexRoots)) {
         for (const target of collectWikilinkTargets(filePath)) {
@@ -74,15 +74,15 @@ export function countBrokenWikilinks(verifiableContextRoot, noteIndexRoots, link
             if (!target)
                 continue;
             if (target.includes("/")) {
-                if (!wikilinkPathExists(verifiableContextRoot, target, artifactPathById, directoryLeafParents, filePath)) {
+                if (!wikilinkPathExists(contextGraphRoot, target, artifactPathById, directoryLeafParents, filePath)) {
                     brokenLinks += 1;
                 }
                 continue;
             }
             if (!noteIndex.has(target.toLowerCase()) &&
                 !noteIndex.has(noteName(target).toLowerCase()) &&
-                !wikilinkPathExists(verifiableContextRoot, target, artifactPathById, directoryLeafParents, filePath) &&
-                !wikilinkPathExists(verifiableContextRoot, noteName(target), artifactPathById, directoryLeafParents, filePath)) {
+                !wikilinkPathExists(contextGraphRoot, target, artifactPathById, directoryLeafParents, filePath) &&
+                !wikilinkPathExists(contextGraphRoot, noteName(target), artifactPathById, directoryLeafParents, filePath)) {
                 brokenLinks += 1;
             }
         }
@@ -171,28 +171,28 @@ function countWords(text) {
 function noteName(filePath) {
     return basename(filePath, extname(filePath));
 }
-function wikilinkPathExists(verifiableContextRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
-    return linkPathCandidates(verifiableContextRoot, target, artifactPathById, directoryLeafParents, sourceFilePath)
+function wikilinkPathExists(contextGraphRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
+    return linkPathCandidates(contextGraphRoot, target, artifactPathById, directoryLeafParents, sourceFilePath)
         .some((candidate) => existsSync(candidate));
 }
-function linkPathCandidates(verifiableContextRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
+function linkPathCandidates(contextGraphRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
     const candidates = new Set();
-    addPathCandidate(candidates, join(verifiableContextRoot, target));
+    addPathCandidate(candidates, join(contextGraphRoot, target));
     if (sourceFilePath && (target.startsWith("./") || target.startsWith("../"))) {
-        addPathCandidateIfInside(candidates, verifiableContextRoot, resolve(dirname(sourceFilePath), target));
+        addPathCandidateIfInside(candidates, contextGraphRoot, resolve(dirname(sourceFilePath), target));
     }
     const [firstSegment] = target.split("/");
     if (firstSegment) {
         const parentPath = directoryLeafParents.get(firstSegment);
         if (parentPath) {
-            addPathCandidate(candidates, join(verifiableContextRoot, parentPath, target));
+            addPathCandidate(candidates, join(contextGraphRoot, parentPath, target));
         }
     }
     if (firstSegment) {
         const normalizedPrefix = artifactPathById.get(firstSegment);
         if (normalizedPrefix) {
             const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
-            addPathCandidate(candidates, join(verifiableContextRoot, normalizedPrefix, remainder));
+            addPathCandidate(candidates, join(contextGraphRoot, normalizedPrefix, remainder));
         }
     }
     return Array.from(candidates);
@@ -201,15 +201,15 @@ function addPathCandidate(candidates, absolutePath) {
     candidates.add(absolutePath);
     candidates.add(`${absolutePath}.md`);
 }
-function addPathCandidateIfInside(candidates, verifiableContextRoot, absolutePath) {
-    const root = resolve(verifiableContextRoot);
+function addPathCandidateIfInside(candidates, contextGraphRoot, absolutePath) {
+    const root = resolve(contextGraphRoot);
     const candidate = resolve(absolutePath);
     if (candidate !== root && !candidate.startsWith(`${root}/`))
         return;
     addPathCandidate(candidates, candidate);
 }
-function verifiableContextArtifactDirectoryPaths(verifiableContextRoot) {
-    const buildPlanRoot = buildPlanPackagePathForVerifiableContext(verifiableContextRoot);
+function contextGraphArtifactDirectoryPaths(contextGraphRoot) {
+    const buildPlanRoot = buildPlanPackagePathForContextGraph(contextGraphRoot);
     const schema = readBuildPlanContextFile(buildPlanRoot);
     if (!schema)
         return new Map();
@@ -217,7 +217,7 @@ function verifiableContextArtifactDirectoryPaths(verifiableContextRoot) {
         .filter((artifact) => artifact.kind === "directory")
         .map((artifact) => [artifact.id, artifact.path]));
 }
-function verifiableContextDirectoryLeafParents(artifactPathById) {
+function contextGraphDirectoryLeafParents(artifactPathById) {
     const parents = new Map();
     for (const artifactPath of artifactPathById.values()) {
         const [root, leaf, ...rest] = artifactPath.split("/");
@@ -256,4 +256,4 @@ function addFrontmatterLinkTarget(targets, value) {
         }
     }
 }
-export { validateVerifiableContextSetup, validateBuildStage, validateVerifiableContext, validateBuildSummarize, validateVerifiableContextStructure, validateBuildOutput, } from "./validate-verifiable-context.js";
+export { validateContextGraphSetup, validateBuildStage, validateContextGraph, validateBuildSummarize, validateContextGraphStructure, validateBuildOutput, } from "./validate-context-graph.js";

package/dist/packages/{engine → runtime}/client.d.ts

@@ -1,4 +1,4 @@
-import { type ActionProposalApprovalRequest, type ActionProposalCreateRequest, type ActionProposalResource, type BuildRunCreateRequest, type BuildRunResource, type LocalJobRunResource, type LocalServiceHealth, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ResetRequest, type ResetResult, type VerifyRunCreateRequest, type VerifyRunResource, type BuildPlanAuthoringCreateRequest, type BuildPlanAuthoringResult } from "./lib/schema.js";
+import { type ActionProposalApprovalRequest, type ActionProposalCreateRequest, type ActionProposalResource, type BuildRunCreateRequest, type BuildRunResource, type LocalJobRunResource, type LocalServiceHealth, type BenchmarkQuestionDraftCreateRequest, type BenchmarkQuestionDraftResult, type ResetRequest, type ResetResult, type VerifyRunCreateRequest, type VerifyRunResource, type BuildPlanAuthoringCreateRequest, type BuildPlanAuthoringResult } from "./schemas/index.js";
 export interface FindOrStartLocalServiceOptions {
     url?: string;
     authToken?: string;
@@ -20,21 +20,21 @@ export interface LocalServiceJobSubmitted {
 }
 export declare function configuredLocalServiceUrl(): string;
 /**
- * Resolve the bearer token for the active connection. In 0.13 there is
- * exactly one source of truth: `~/.interf/connection.json` (or the
- * `INTERF_SERVICE_TOKEN` env override).
+ * Resolve the bearer token for the active connection. There is exactly
+ * one source of truth: `~/.interf/connection.json` (or the
+ * `INTERF_AUTH_TOKEN` env override).
  */
 export declare function resolveLocalServiceAuthToken(): string | null;
 /**
- * Resolve a connection. In 0.13 this is the only path to the engine — read
- * `~/.interf/connection.json` (written by `interf web`) or honor the
- * `INTERF_SERVICE_URL` / `INTERF_SERVICE_TOKEN` env overrides.
+ * Resolve a connection — the only path to the engine. Read
+ * `~/.interf/connection.json` (written by `interf runtime`) or honor the
+ * `INTERF_SERVICE_URL` / `INTERF_AUTH_TOKEN` env overrides.
  */
 export declare function findLocalService(options?: {
     timeoutMs?: number;
 }): Promise<LocalServiceConnection | null>;
 export declare function submitBuildRunToLocalService(options: {
-    preparationId: string;
+    projectId: string;
     request: BuildRunCreateRequest;
     idempotencyKey?: string;
 }): Promise<{
@@ -42,14 +42,14 @@ export declare function submitBuildRunToLocalService(options: {
     resource: BuildRunResource;
 } | null>;
 export declare function submitVerifyRunToLocalService(options: {
-    preparationId: string;
+    projectId: string;
     request: VerifyRunCreateRequest;
 }): Promise<{
     serviceUrl: string;
     resource: VerifyRunResource;
 } | null>;
 export declare function submitResetToLocalService(options: {
-    preparationId: string;
+    projectId: string;
     request: ResetRequest;
 }): Promise<{
     serviceUrl: string;
@@ -128,14 +128,14 @@ export declare function waitForLocalJobRun(options: {
     authToken?: string | null;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalJobRunResource>;
-export declare function submitReadinessCheckDraftToLocalService(options: {
-    preparationId: string;
-    request: ReadinessCheckDraftCreateRequest;
+export declare function submitBenchmarkQuestionDraftToLocalService(options: {
+    projectId: string;
+    request: BenchmarkQuestionDraftCreateRequest;
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;
-}): Promise<LocalServiceJobSubmission<ReadinessCheckDraftResult> | null>;
+}): Promise<LocalServiceJobSubmission<BenchmarkQuestionDraftResult> | null>;
 export declare function submitBuildPlanAuthoringRunToLocalService(options: {
-    preparationId: string;
+    projectId: string;
     request: BuildPlanAuthoringCreateRequest;
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;

package/dist/packages/{engine → runtime}/client.js

@@ -1,6 +1,6 @@
-import { BuildRunCreateRequestSchema, BuildRunResourceSchema, ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalResourceSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, VerifyRunCreateRequestSchema, VerifyRunResourceSchema, BuildPlanAuthoringCreateRequestSchema, BuildPlanAuthoringResultSchema, } from "./lib/schema.js";
-import { LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, preparationSubresourcePath, } from "./routes.js";
-import { readActiveConnection } from "./connection-config.js";
+import { BuildRunCreateRequestSchema, BuildRunListResponseSchema, BuildRunResourceSchema, RunObservabilityResourceSchema, ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalResourceSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, BenchmarkQuestionDraftCreateRequestSchema, BenchmarkQuestionDraftResultSchema, ResetRequestSchema, ResetResultSchema, VerifyRunCreateRequestSchema, VerifyRunResourceSchema, BuildPlanAuthoringCreateRequestSchema, BuildPlanAuthoringResultSchema, } from "./schemas/index.js";
+import { LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, projectSubresourcePath, } from "./service/routes.js";
+import { INTERF_AUTH_TOKEN_ENV, readActiveConnection } from "./connection-config.js";
 async function connectOrNull(options = {}) {
     const conn = readActiveConnection({
         urlOverride: options.url ?? null,
@@ -34,12 +34,12 @@ export function configuredLocalServiceUrl() {
     return buildLocalServiceUrl();
 }
 /**
- * Resolve the bearer token for the active connection. In 0.13 there is
- * exactly one source of truth: `~/.interf/connection.json` (or the
- * `INTERF_SERVICE_TOKEN` env override).
+ * Resolve the bearer token for the active connection. There is exactly
+ * one source of truth: `~/.interf/connection.json` (or the
+ * `INTERF_AUTH_TOKEN` env override).
  */
 export function resolveLocalServiceAuthToken() {
-    const explicit = process.env.INTERF_SERVICE_TOKEN?.trim();
+    const explicit = process.env[INTERF_AUTH_TOKEN_ENV]?.trim();
     if (explicit)
         return explicit;
     const conn = readActiveConnection();
@@ -68,9 +68,9 @@ async function fetchJson(url, options = {}) {
     }
 }
 /**
- * Resolve a connection. In 0.13 this is the only path to the engine — read
- * `~/.interf/connection.json` (written by `interf web`) or honor the
- * `INTERF_SERVICE_URL` / `INTERF_SERVICE_TOKEN` env overrides.
+ * Resolve a connection — the only path to the engine. Read
+ * `~/.interf/connection.json` (written by `interf runtime`) or honor the
+ * `INTERF_SERVICE_URL` / `INTERF_AUTH_TOKEN` env overrides.
  */
 export async function findLocalService(options = {}) {
     void options.timeoutMs;
@@ -80,7 +80,7 @@ function authHeaders(authToken) {
     return authToken ? { authorization: `Bearer ${authToken}` } : {};
 }
 // ─────────────────────────────────────────────────────────────────────────
-// Preparation-keyed run submission helpers (0.13)
+// Project-keyed run submission helpers
 // ─────────────────────────────────────────────────────────────────────────
 export async function submitBuildRunToLocalService(options) {
     const connection = await connectOrNull();
@@ -91,7 +91,7 @@ export async function submitBuildRunToLocalService(options) {
         ...authHeaders(connection.authToken),
         ...(options.idempotencyKey ? { "x-interf-idempotency-key": options.idempotencyKey } : {}),
     };
-    const url = `${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "buildRuns")}`;
+    const url = `${connection.serviceUrl}${projectSubresourcePath(options.projectId, "buildRuns")}`;
     const resource = BuildRunResourceSchema.parse(await fetchJson(url, {
         method: "POST",
         body: JSON.stringify(request),
@@ -107,7 +107,7 @@ export async function submitVerifyRunToLocalService(options) {
     if (!connection)
         return null;
     const request = VerifyRunCreateRequestSchema.parse(options.request);
-    const url = `${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "verifyRuns")}`;
+    const url = `${connection.serviceUrl}${projectSubresourcePath(options.projectId, "verifyRuns")}`;
     const resource = VerifyRunResourceSchema.parse(await fetchJson(url, {
         method: "POST",
         body: JSON.stringify(request),
@@ -123,7 +123,7 @@ export async function submitResetToLocalService(options) {
     if (!connection)
         return null;
     const request = ResetRequestSchema.parse(options.request);
-    const url = `${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "reset")}`;
+    const url = `${connection.serviceUrl}${projectSubresourcePath(options.projectId, "reset")}`;
     const result = ResetResultSchema.parse(await fetchJson(url, {
         method: "POST",
         body: JSON.stringify(request),
@@ -186,11 +186,28 @@ function isTerminalRunStatus(status) {
     return status === "succeeded" || status === "failed" || status === "cancelled";
 }
 export async function getLocalBuildRun(options) {
-    return BuildRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}/v1/build-runs/${encodeURIComponent(options.runId)}`, {
+    const headers = authHeaders(options.authToken ?? resolveLocalServiceAuthToken());
+    const runValue = await fetchJson(`${options.serviceUrl}/v1/runs/${encodeURIComponent(options.runId)}`, {
         method: "GET",
         timeoutMs: 2000,
-        headers: authHeaders(options.authToken ?? resolveLocalServiceAuthToken()),
+        headers,
+    });
+    const direct = BuildRunResourceSchema.safeParse(runValue);
+    if (direct.success)
+        return direct.data;
+    const observable = RunObservabilityResourceSchema.parse(runValue);
+    if (observable.run_type !== "build" || !observable.project) {
+        throw new Error(`Run ${options.runId} is not a Build run.`);
+    }
+    const projectRuns = BuildRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}/v1/projects/${encodeURIComponent(observable.project)}/runs`, {
+        method: "GET",
+        timeoutMs: 2000,
+        headers,
     }));
+    const run = projectRuns.runs.find((candidate) => candidate.run_id === options.runId);
+    if (!run)
+        throw new Error(`Build run ${options.runId} was not found in Project ${observable.project}.`);
+    return BuildRunResourceSchema.parse({ run });
 }
 /**
  * Ask the local service to cancel a running Build run by id. Resolves
@@ -198,7 +215,7 @@ export async function getLocalBuildRun(options) {
  * returns 404 (unknown run id) or any non-2xx status.
  */
 export async function cancelLocalBuildRun(options) {
-    const value = await fetchJson(`${options.serviceUrl}/v1/build-runs/${encodeURIComponent(options.runId)}/cancel`, {
+    const value = await fetchJson(`${options.serviceUrl}/v1/runs/${encodeURIComponent(options.runId)}/cancel`, {
         method: "POST",
         timeoutMs: options.timeoutMs ?? 2000,
         headers: authHeaders(options.authToken ?? resolveLocalServiceAuthToken()),
@@ -294,12 +311,12 @@ function resultError(job, defaultMessage) {
     }
     return job.error ?? defaultMessage;
 }
-export async function submitReadinessCheckDraftToLocalService(options) {
+export async function submitBenchmarkQuestionDraftToLocalService(options) {
     const connection = await connectOrNull();
     if (!connection)
         return null;
-    const request = ReadinessCheckDraftCreateRequestSchema.parse(options.request);
-    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "readinessCheckDrafts")}`, {
+    const request = BenchmarkQuestionDraftCreateRequestSchema.parse(options.request);
+    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${projectSubresourcePath(options.projectId, "benchmarkQuestionDrafts")}`, {
         method: "POST",
         body: JSON.stringify(request),
         headers: authHeaders(connection.authToken),
@@ -319,16 +336,16 @@ export async function submitReadinessCheckDraftToLocalService(options) {
             serviceUrl: connection.serviceUrl,
             job,
             result: null,
-            error: resultError(job, "Drafting readiness checks failed in the local Interf service."),
+            error: resultError(job, "Drafting benchmark questions failed in the local Interf service."),
         };
     }
-    const parsed = ReadinessCheckDraftResultSchema.safeParse(job.result);
+    const parsed = BenchmarkQuestionDraftResultSchema.safeParse(job.result);
     if (!parsed.success) {
         return {
             serviceUrl: connection.serviceUrl,
             job,
             result: null,
-            error: "Drafting readiness checks finished without a valid result.",
+            error: "Drafting benchmark questions finished without a valid result.",
         };
     }
     return {
@@ -342,7 +359,7 @@ export async function submitBuildPlanAuthoringRunToLocalService(options) {
     if (!connection)
         return null;
     const request = BuildPlanAuthoringCreateRequestSchema.parse(options.request);
-    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "buildPlanDraftRuns")}`, {
+    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${projectSubresourcePath(options.projectId, "buildPlanDraftRuns")}`, {
         method: "POST",
         body: JSON.stringify(request),
         headers: authHeaders(connection.authToken),

package/dist/packages/{engine → runtime}/connection-config.d.ts

@@ -2,8 +2,9 @@
  * Single CLI connection record at `~/.interf/connection.json`.
  *
  * The CLI is a thin authorized client of one connected instance. Switch by
- * starting `interf web` (writes a local connection), `interf login` (writes a
- * remote connection), or by passing `--url` / env vars to override per-call.
+ * starting `interf runtime` (writes a local connection), `interf login`
+ * (writes a remote connection), or by passing `--url` / env vars to override
+ * per-call.
  *
  * No per-folder pointer files. No registry of multiple connections.
  */