@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/runtime-proposal-helpers.d.ts

@@ -0,0 +1,22 @@
+import { type ProjectConfig } from "../projects/lib/schema.js";
+import { type ActionProposalPlanActionType, type ActionProposalResource } from "./schemas/index.js";
+export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Project, build a Context Graph, run a benchmark, improve a Build Plan, or draft a Build Plan and I will prepare an approval proposal.";
+export type LocalTestMode = "source-files" | "context-graph" | "both";
+export declare function createActionProposalId(): string;
+export declare function sanitizeActionProposalPlan(value: unknown): unknown;
+export declare function stringValue(values: Record<string, unknown> | undefined, key: string): string | null;
+export declare function actionTypeFromValues(values: Record<string, unknown> | undefined): ActionProposalPlanActionType | null;
+export declare function directServiceEndpointForAction(actionType: ActionProposalPlanActionType, options?: {
+    project?: string | null;
+}): string | null;
+export declare function numberValue(values: Record<string, unknown> | undefined, key: string): number | null;
+export declare function benchmarkModeFromValues(values: Record<string, unknown> | undefined): LocalTestMode | null;
+export declare function buildPlanIdForProposal(message: string, values: Record<string, unknown> | undefined): string;
+export declare function actionValueBuildPlanIntent(values: Record<string, unknown> | undefined): string | null;
+export declare function buildPlanAuthoringPromptFallback(message: string, buildPlanId: string): string;
+export declare function buildPlanAuthoringHintFromPrompt(prompt: string): string;
+export declare function buildPlanLabelFromId(buildPlanId: string): string;
+export declare function requireSelectedBuildPlan(project: ProjectConfig): string;
+export declare function actionCommandPreview(actionType: ActionProposalResource["action_type"], projectName: string | null, buildPlanId: string | null, values: Record<string, unknown> | undefined): string;
+export declare function hasContextGraphBenchmarkTarget(sourcePath: string, projectConfig: ProjectConfig): boolean;
+export declare function actionAssistantMessage(actionType: ActionProposalResource["action_type"], projectName: string | null, commandPreview: string): string;

package/dist/packages/runtime/runtime-proposal-helpers.js

@@ -0,0 +1,223 @@
+/**
+ * Pure helpers used by the runtime's action-proposal and Build Plan authoring
+ * paths. None of these depend on runtime state — they shape strings, parse
+ * proposal values, and build CLI previews. Keeping them out of runtime.ts
+ * lets the coordinator stay small and means future tests can reach these
+ * helpers without booting a runtime.
+ */
+import { existsSync } from "node:fs";
+import { asProjectDataDir, projectContextGraphPath, projectRunContextGraphPath, } from "../contracts/lib/project-paths.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForProjectConfig, } from "../projects/source-config.js";
+import { createContextGraphTestTarget, } from "./verify/verify-targets.js";
+import { buildPlanAuthoringIntentBrief, BuildPlanAuthoringActionValuesSchema, } from "./action-values.js";
+import { ActionProposalPlanActionTypeSchema, } from "./schemas/index.js";
+export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Project, build a Context Graph, run a benchmark, improve a Build Plan, or draft a Build Plan and I will prepare an approval proposal.";
+export function createActionProposalId() {
+    return `action_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export function sanitizeActionProposalPlan(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const plan = { ...value };
+    for (const key of ["project", "build_plan", "title", "summary", "assistant_message", "command_preview"]) {
+        const current = plan[key];
+        if (current === null || current === undefined) {
+            delete plan[key];
+            continue;
+        }
+        if (typeof current === "string" && current.trim().length === 0) {
+            delete plan[key];
+        }
+    }
+    return plan;
+}
+function slugFromText(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 42)
+        .replace(/-+$/g, "");
+    return slug || "custom";
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function stringValue(values, key) {
+    const value = values?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+export function actionTypeFromValues(values) {
+    const explicit = stringValue(values, "action_type") ?? stringValue(values, "service_action");
+    if (explicit) {
+        const parsed = ActionProposalPlanActionTypeSchema.safeParse(explicit);
+        if (parsed.success && parsed.data !== "clarification")
+            return parsed.data;
+    }
+    const action = stringValue(values, "action");
+    if (action === "build" || action === "build-run" || action === "run-project")
+        return "build";
+    if (action === "benchmark" || action === "run-benchmark")
+        return "benchmark";
+    if (action === "draft-benchmark-questions" || action === "benchmark-question-draft")
+        return "benchmark-question-draft";
+    if (action === "create-build-plan" || action === "build-plan-draft")
+        return "build-plan-draft";
+    if (action === "build-plan-duplicate" || action === "build-plan-remove" || action === "build-plan-change")
+        return "build-plan-change";
+    if (action === "project-remove" || action === "project-change")
+        return "project-change";
+    if (action === "improve-project" || action === "build-plan-improvement")
+        return "build-plan-improvement";
+    return null;
+}
+export function directServiceEndpointForAction(actionType, options) {
+    const project = options?.project?.trim() || null;
+    if (actionType === "project-setup")
+        return "/v1/projects";
+    if (actionType === "build-plan-change") {
+        return project
+            ? `/v1/projects/${encodeURIComponent(project)}/build-plan-changes`
+            : "/v1/projects/<project>/build-plan-changes";
+    }
+    if (actionType === "project-change") {
+        return project
+            ? `/v1/projects/${encodeURIComponent(project)}`
+            : "/v1/projects/<project>";
+    }
+    return null;
+}
+export function numberValue(values, key) {
+    const value = values?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+export function benchmarkModeFromValues(values) {
+    const value = stringValue(values, "mode") ?? stringValue(values, "target");
+    return value === "source-files" || value === "context-graph" || value === "both" ? value : null;
+}
+export function buildPlanIdForProposal(message, values) {
+    const explicit = stringValue(values, "build_plan_id") ??
+        stringValue(values, "build_plan");
+    const fromMessage = message.match(/\b(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?build\s+plan\s+([a-z0-9][a-z0-9-]{0,79})\b/i)?.[1];
+    return explicit ?? fromMessage ?? `custom-${slugFromText(message)}`;
+}
+export function actionValueBuildPlanIntent(values) {
+    const parsed = BuildPlanAuthoringActionValuesSchema.safeParse(values);
+    return parsed.success ? buildPlanAuthoringIntentBrief(parsed.data) : null;
+}
+const BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION = /Use the attached values as the Build Plan authoring request before proposing the action\.?/gi;
+const BUILD_PLAN_AUTHORING_LABELS = [
+    "Intent",
+    "Context Graph output",
+    "Coverage",
+    "Ready When",
+    "CLI preview",
+];
+function normalizeBuildPlanAuthoringText(value) {
+    return value
+        .replace(/[│]+/g, " ")
+        .replace(BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function extractBuildPlanAuthoringSection(value, label) {
+    const otherLabels = BUILD_PLAN_AUTHORING_LABELS
+        .filter((candidate) => candidate !== label)
+        .map(escapeRegExp)
+        .join("|");
+    const match = value.match(new RegExp(`${escapeRegExp(label)}\\s*:\\s*([\\s\\S]*?)(?=\\s*(?:${otherLabels})\\s*:|$)`, "i"));
+    return match?.[1] ? normalizeBuildPlanAuthoringText(match[1]) : null;
+}
+function stripBuildPlanCommandPrefix(value, buildPlanId) {
+    const specific = new RegExp(`^(?:create|reate|eate|draft|author|build|make)\\s+(?:a\\s+new\\s+)?(?:interf\\s+)?build\\s+plan\\s+${escapeRegExp(buildPlanId)}\\.?\\s*`, "i");
+    const generic = /^(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?build\s+plan\b[^.]{0,180}\.\s*/i;
+    const stripped = normalizeBuildPlanAuthoringText(value)
+        .replace(specific, "")
+        .replace(generic, "")
+        .trim();
+    return stripped || normalizeBuildPlanAuthoringText(value);
+}
+export function buildPlanAuthoringPromptFallback(message, buildPlanId) {
+    const cleaned = message
+        .replace(/[│]+/g, " ")
+        .replace(BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .trim();
+    const agentWork = extractBuildPlanAuthoringSection(cleaned, "Intent");
+    const portableOutput = extractBuildPlanAuthoringSection(cleaned, "Context Graph output");
+    const coverageNotes = extractBuildPlanAuthoringSection(cleaned, "Coverage") ??
+        extractBuildPlanAuthoringSection(cleaned, "Ready When");
+    const lines = [
+        agentWork ? `Intent: ${stripBuildPlanCommandPrefix(agentWork, buildPlanId)}` : null,
+        portableOutput ? `Context Graph output: ${portableOutput}` : null,
+        coverageNotes ? `Coverage: ${coverageNotes}` : null,
+    ].filter((line) => Boolean(line));
+    if (lines.length > 0)
+        return lines.join("\n");
+    return stripBuildPlanCommandPrefix(cleaned, buildPlanId);
+}
+export function buildPlanAuthoringHintFromPrompt(prompt) {
+    const plain = normalizeBuildPlanAuthoringText(prompt.replace(/\b(?:Intent|Context Graph output|Coverage|Ready When)\s*:/gi, " "));
+    if (plain.length <= 180)
+        return plain || "Custom Build Plan";
+    const clipped = plain.slice(0, 177).replace(/\s+\S*$/, "").trim();
+    return `${clipped || plain.slice(0, 177)}...`;
+}
+export function buildPlanLabelFromId(buildPlanId) {
+    return buildPlanId
+        .split("-")
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(" ") || buildPlanId;
+}
+export function requireSelectedBuildPlan(project) {
+    const buildPlanId = buildPlanIdForProjectConfig(project);
+    if (buildPlanId)
+        return buildPlanId;
+    throw new Error(`Select a Build Plan for Project "${project.name}" before building it.`);
+}
+export function actionCommandPreview(actionType, projectName, buildPlanId, values) {
+    if (actionType === "build") {
+        const buildPlanSuffix = buildPlanId ? ` # Build Plan: ${buildPlanId}` : "";
+        return projectName
+            ? `interf build ${projectName}${buildPlanSuffix}`
+            : `interf build${buildPlanSuffix}`;
+    }
+    if (actionType === "benchmark") {
+        const mode = benchmarkModeFromValues(values) ?? "both";
+        return projectName
+            ? `interf benchmark ${projectName} --target ${mode}`
+            : `interf benchmark --target ${mode}`;
+    }
+    if (actionType === "benchmark-question-draft") {
+        return "interf # choose Draft benchmark questions";
+    }
+    if (actionType === "build-plan-draft" || actionType === "build-plan-improvement") {
+        return "interf plan draft";
+    }
+    return "Try: create a Project, build a Context Graph, run a benchmark, draft benchmark questions, or draft a Build Plan.";
+}
+export function hasContextGraphBenchmarkTarget(sourcePath, projectConfig) {
+    const projectDataDir = asProjectDataDir(sourcePath);
+    const contextGraphPath = projectConfig.latest_context_graph_run_id
+        ? projectRunContextGraphPath(projectDataDir, projectConfig.latest_context_graph_run_id)
+        : projectContextGraphPath(projectDataDir, projectConfig.name);
+    if (!existsSync(contextGraphPath))
+        return false;
+    return createContextGraphTestTarget(contextGraphPath, projectConfig.name, buildPlanIdForProjectConfig(projectConfig) ?? DEFAULT_BUILD_PLAN_ID).eligible;
+}
+export function actionAssistantMessage(actionType, projectName, commandPreview) {
+    const projectSuffix = projectName ? ` for Project "${projectName}"` : "";
+    if (actionType === "build") {
+        return `Interf prepared a Build proposal${projectSuffix}. Approve to submit it through the local Interf service and watch the run in Interf. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "benchmark") {
+        return `Interf prepared a benchmark/evaluation proposal${projectSuffix}. Approve to run the requested Q&A / fact-check target. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "benchmark-question-draft") {
+        return `Interf prepared a proposal to draft benchmark questions${projectSuffix}. Approve to ask the configured local executor to draft saved Q&A / fact-check evaluation questions as a visible run. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "build-plan-draft" || actionType === "build-plan-improvement") {
+        return `Interf prepared a Build Plan proposal${projectSuffix}. Approve to draft a Build Plan as a visible run. CLI equivalent: ${commandPreview}`;
+    }
+    return "I could not map that to a safe Interf action. Ask for one action in plain English, such as create a Project, build a Context Graph, run a benchmark, draft benchmark questions, or draft a Build Plan.";
+}

package/dist/packages/{engine → runtime}/runtime-resource-builders.d.ts

@@ -1,44 +1,47 @@
 /**
  * Pure shaping helpers used by the runtime to assemble resource payloads
- * (preparations, Build Plans, proof, log paths, readiness summaries) from
+ * (projects, Build Plans, evidence, log paths, readiness summaries) from
  * raw state/run records. No I/O, no `this` — every input is passed in.
  *
  * Splitting these out keeps the runtime coordinator focused on
  * orchestration rather than payload formatting.
  */
-import { type ArtifactRef, type ProofRecord } from "./execution/lib/schema.js";
-import { type VerifiableContextState } from "./build/state.js";
-import { type RuntimeRun } from "./build/lib/schema.js";
+import { type ArtifactRef, type EvidenceRecord } from "./execution/lib/schema.js";
+import { type ContextGraphState } from "./build/state.js";
+import { type ExecutionStageLedger } from "./build/lib/schema.js";
 import { type Artifact, type Readiness, type VerifyTargetResult } from "../contracts/lib/schema.js";
 import { type TestRunTargetSummary } from "./verify/lib/schema.js";
-import { type SourcePreparationConfig } from "../project/lib/schema.js";
-import { type BuildPlanResource, type PreparationResource } from "./lib/schema.js";
+import { type ProjectConfig } from "../projects/lib/schema.js";
+import { type BuildPlanResource, type ProjectResource } from "./schemas/index.js";
 export declare function createRunId(prefix: "build" | "verify" | "job"): string;
 export declare function stageArtifactRefs(stageId: string, artifacts: string[] | undefined): ArtifactRef[];
-export declare function proofForStage(options: {
+export declare function evidenceForStage(options: {
     runId: string;
     stageId: string;
     summary?: string | null;
-    stageState: NonNullable<VerifiableContextState["stages"]>[string];
+    stageState: NonNullable<ContextGraphState["stages"]>[string];
     artifacts: ArtifactRef[];
-}): ProofRecord;
-export declare function logsForStageRun(stageState: NonNullable<VerifiableContextState["stages"]>[string] | undefined): {
+}): EvidenceRecord;
+export declare function logsForStageRun(stageState: NonNullable<ContextGraphState["stages"]>[string] | undefined): {
     prompt_path: string;
     event_stream_path: string;
     status_path: string;
     contract_path: string;
 } | undefined;
-export declare function logsForRuntimeRun(run: RuntimeRun | undefined): {
+export declare function logsForExecutionStageLedger(run: ExecutionStageLedger | undefined): {
+    evidence_path?: string | undefined;
     contract_path: string;
     status_path?: string | undefined;
     event_stream_path?: string | undefined;
     prompt_path?: string | undefined;
 } | undefined;
-export declare function passRate(passed: number, total: number): number | null;
-export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): VerifyTargetResult | null;
+export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, benchmarkRunFingerprint: string | null | undefined): VerifyTargetResult | null;
 export declare function readinessSummaryForStatus(status: Readiness["status"]): string;
-export declare function readinessStateToPreparationReadiness(readiness: Readiness): Readiness;
-export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: Readiness, latestBuildRunId: string | null, latestTestRunId: string | null, artifacts?: PreparationResource["artifacts"]): PreparationResource;
+export declare function buildProjectResource(project: ProjectConfig, readiness: Readiness, latestRunIds: {
+    latestBuildRunId: string | null;
+    latestContextGraphBuildRunId: string | null;
+    latestTestRunId: string | null;
+}, sourcePath: string, configPath: string, artifacts?: ProjectResource["artifacts"], updatedAt?: string | null): ProjectResource;
 export declare function buildBuildPlanResource(resource: {
     id: string;
     path: string;
@@ -48,10 +51,14 @@ export declare function buildBuildPlanResource(resource: {
         label: string;
         taskHint: string;
     };
+    brief?: BuildPlanResource["brief"];
     inputs?: BuildPlanResource["inputs"];
     source_kind: "builtin" | "local";
     built_in: boolean;
-    active_for_preparations: string[];
+    scope: "builtin" | "user" | "local";
+    created_at?: string | null;
+    updated_at?: string | null;
+    active_for_projects: string[];
     artifacts: Artifact[];
     stages: BuildPlanResource["stages"];
 }): BuildPlanResource;

package/dist/packages/{engine → runtime}/runtime-resource-builders.js

@@ -1,6 +1,6 @@
-import { ReadinessSchema, } from "../contracts/lib/schema.js";
-import { buildPlanIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project/source-config.js";
-import { BuildPlanResourceSchema, PreparationResourceSchema, } from "./lib/schema.js";
+import { buildPlanIdForProjectConfig, } from "../projects/source-config.js";
+import { BuildPlanResourceSchema, } from "./schemas/index.js";
+import { buildPlanContextChecks, } from "./context-checks.js";
 export function createRunId(prefix) {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -12,9 +12,9 @@ export function stageArtifactRefs(stageId, artifacts) {
         label: path,
     }));
 }
-export function proofForStage(options) {
+export function evidenceForStage(options) {
     return {
-        id: `${options.runId}-${options.stageId}-proof`,
+        id: `${options.runId}-${options.stageId}-evidence`,
         run_id: options.runId,
         stage_id: options.stageId,
         generated_at: options.stageState.finished_at ?? new Date().toISOString(),
@@ -52,7 +52,7 @@ export function logsForStageRun(stageState) {
         contract_path: `.interf/runtime/logs/${runId}.stage-contract.json`,
     };
 }
-export function logsForRuntimeRun(run) {
+export function logsForExecutionStageLedger(run) {
     if (!run)
         return undefined;
     return {
@@ -60,17 +60,18 @@ export function logsForRuntimeRun(run) {
         ...(run.logs?.event_stream_path ? { event_stream_path: run.logs.event_stream_path } : {}),
         ...(run.logs?.status_path ? { status_path: run.logs.status_path } : {}),
         contract_path: run.contract_path,
+        ...(run.evidence_path ? { evidence_path: run.evidence_path } : {}),
     };
 }
-export function passRate(passed, total) {
+function passRate(passed, total) {
     if (total <= 0)
         return null;
     return Math.round((passed / total) * 100);
 }
-export function readinessTargetResult(summary, currentFingerprint, readinessRunFingerprint) {
+export function readinessTargetResult(summary, currentFingerprint, benchmarkRunFingerprint) {
     if (!summary)
         return null;
-    const resultFingerprint = readinessRunFingerprint ?? null;
+    const resultFingerprint = benchmarkRunFingerprint ?? null;
     return {
         passed: summary.passed_cases,
         total: summary.total_cases,
@@ -83,64 +84,70 @@ export function readinessTargetResult(summary, currentFingerprint, readinessRunF
 }
 export function readinessSummaryForStatus(status) {
     if (status === "ready")
-        return "Ready for agent work.";
+        return "Ready for agent task.";
     if (status === "not-ready")
-        return "Artifact or readiness checks did not pass.";
+        return "Context Graph is missing required coverage for the agent task.";
     if (status === "stale")
-        return "Readiness checks are stale for the current saved checks.";
+        return "Benchmark result is stale — saved checks have changed since.";
     if (status === "checking")
-        return "Readiness checks are running.";
+        return "Benchmark checks are running.";
     if (status === "building")
-        return "Verifiable context is building.";
+        return "Build is in progress.";
     if (status === "built")
-        return "Verifiable context is built; readiness has not been proven yet.";
+        return "Context Graph is built; benchmark checks have not run yet.";
     if (status === "not-built")
-        return "Verifiable context has not been built yet.";
+        return "Context Graph has not been built yet.";
     if (status === "not-configured")
-        return "No checks are configured.";
-    return "Latest preparation failed.";
+        return "Context Graph preparation is not configured.";
+    return "Latest Build failed.";
 }
-export function readinessStateToPreparationReadiness(readiness) {
-    return ReadinessSchema.parse({
-        ...readiness,
-        checks: readiness.checks.map((check) => ({ ...check })),
-    });
-}
-export function buildPreparationResource(rootPath, preparation, readiness, latestBuildRunId, latestTestRunId, artifacts = []) {
-    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparation);
-    return PreparationResourceSchema.parse({
-        id: preparation.name,
-        name: preparation.name,
-        preparation,
-        source_path: resolveSourcePreparationPath(rootPath, preparation),
+export function buildProjectResource(project, readiness, latestRunIds, sourcePath, configPath, artifacts = [], updatedAt = null) {
+    const buildPlanId = buildPlanIdForProjectConfig(project);
+    const { latestBuildRunId, latestContextGraphBuildRunId, latestTestRunId, } = latestRunIds;
+    // Inputs are already contract-typed (ProjectConfig, Readiness, ArtifactStatus[]),
+    // so re-parsing the assembled object through ProjectResourceSchema can't catch
+    // any error the type checker doesn't already catch. Return a typed literal.
+    return {
+        id: project.name,
+        name: project.name,
+        source: {
+            kind: "local-folder",
+            locator: sourcePath,
+        },
+        intent: project.intent ?? "",
+        config: project,
+        config_path: configPath,
+        source_path: sourcePath,
+        updated_at: updatedAt,
         build_plan_id: buildPlanId,
-        checks: preparation.checks,
-        requested_artifacts: preparation.requested_artifacts ?? [],
-        source_profile: preparation.source_profile ?? null,
-        verifiable_context: {
-            preparation: preparation.name,
-            path: readiness.verifiable_context_path,
-            exists: readiness.verifiable_context_path !== null,
+        context_graph: {
+            project: project.name,
+            path: readiness.context_graph_path,
+            exists: readiness.context_graph_path !== null,
+            intent: project.intent ?? "",
             build_plan_id: buildPlanId,
-            latest_build_run_id: latestBuildRunId,
-            latest_test_run_id: latestTestRunId,
+            latest_build_run_id: latestContextGraphBuildRunId,
+            latest_benchmark_run_id: latestTestRunId,
         },
-        verifiable_context_path: readiness.verifiable_context_path,
-        readiness: readinessStateToPreparationReadiness(readiness),
+        context_graph_path: readiness.context_graph_path,
+        readiness,
         runs: {
             latest_build_run_id: latestBuildRunId,
-            latest_test_run_id: latestTestRunId,
+            latest_benchmark_run_id: latestTestRunId,
         },
         latest_build_run_id: latestBuildRunId,
-        latest_test_run_id: latestTestRunId,
+        latest_benchmark_run_id: latestTestRunId,
         artifacts,
-    });
+    };
 }
 export function buildBuildPlanResource(resource) {
     return BuildPlanResourceSchema.parse({
         id: resource.id,
         build_plan_id: resource.id,
         path: resource.path,
+        scope: resource.scope,
+        created_at: resource.created_at ?? null,
+        updated_at: resource.updated_at ?? null,
         ...(resource.label ? { label: resource.label } : {}),
         ...(resource.hint ? { hint: resource.hint } : {}),
         ...(resource.purpose
@@ -151,10 +158,15 @@ export function buildBuildPlanResource(resource) {
                 },
             }
             : {}),
+        ...(resource.brief ? { brief: resource.brief } : {}),
         inputs: resource.inputs ?? [],
         source_kind: resource.source_kind,
         built_in: resource.built_in,
-        active_for_preparations: resource.active_for_preparations,
+        active_for_projects: resource.active_for_projects,
+        context_checks: buildPlanContextChecks({
+            brief: resource.brief ?? null,
+            artifacts: resource.artifacts,
+        }),
         artifacts: resource.artifacts,
         stages: resource.stages,
     });

package/dist/packages/runtime/runtime-status.d.ts

@@ -0,0 +1,14 @@
+import type { LocalJobStatus } from "./schemas/jobs.js";
+/**
+ * Single source of truth for the terminal-status three-state check.
+ *
+ * A Run/Job is terminal when it has reached `succeeded`, `failed`, or
+ * `cancelled` — the same set across every record model (LocalJobRun,
+ * BuildRun, VerifyRun), all of which share the canonical run-status enum
+ * (`RunStatusSchema` in `schemas/jobs.ts`, re-aliased as
+ * `BuildRunStatusSchema`/`VerifyRunStatusSchema`).
+ *
+ * Accepts a plain `string` so callers that only have a wire-level status
+ * string can reuse the same predicate without re-implementing it.
+ */
+export declare function isTerminalStatus(status: LocalJobStatus | string): boolean;

package/dist/packages/runtime/runtime-status.js

@@ -0,0 +1,15 @@
+/**
+ * Single source of truth for the terminal-status three-state check.
+ *
+ * A Run/Job is terminal when it has reached `succeeded`, `failed`, or
+ * `cancelled` — the same set across every record model (LocalJobRun,
+ * BuildRun, VerifyRun), all of which share the canonical run-status enum
+ * (`RunStatusSchema` in `schemas/jobs.ts`, re-aliased as
+ * `BuildRunStatusSchema`/`VerifyRunStatusSchema`).
+ *
+ * Accepts a plain `string` so callers that only have a wire-level status
+ * string can reuse the same predicate without re-implementing it.
+ */
+export function isTerminalStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "cancelled";
+}

package/dist/packages/runtime/runtime-verify-runs.d.ts

@@ -0,0 +1,84 @@
+import { type ResolvedRegistry } from "./agents/registry.js";
+import { type VerifyRunResource } from "./schemas/index.js";
+import type { InterfRunEvent } from "./execution/lib/schema.js";
+import type { Readiness } from "../contracts/lib/schema.js";
+import type { LocalServiceRuntime } from "./runtime.js";
+export declare function benchmarkFanoutAgentNames(registry: Pick<ResolvedRegistry, "agents">): string[];
+export declare function latestTopLevelVerifyRun(runs: VerifyRunResource[]): VerifyRunResource | null;
+export declare function summarizeVerifyBatch(childRunIds: string[], children: VerifyRunResource[]): NonNullable<VerifyRunResource["batch"]>;
+export declare function listVerifyRuns(runtime: LocalServiceRuntime, projectDataDir: string): VerifyRunResource[];
+export declare function listVerifyRunsForProject(runtime: LocalServiceRuntime, projectDataDir: string, projectName: string): VerifyRunResource[];
+export declare function getVerifyRun(runtime: LocalServiceRuntime, projectDataDir: string, runId: string): VerifyRunResource | null;
+export declare function createVerifyRun(runtime: LocalServiceRuntime, projectDataDir: string, requestValue: unknown): Promise<VerifyRunResource>;
+export declare function createVerifyRunForRegistry(runtime: LocalServiceRuntime, projectDataDir: string, requestValue: unknown, registry: Pick<ResolvedRegistry, "agents">): Promise<VerifyRunResource>;
+export declare function writeVerifyRun(runtime: LocalServiceRuntime, projectDataDir: string, contextGraphPath: string, run: VerifyRunResource): void;
+export declare function readLatestBenchmarkRun(projectDataDir: string, projectName: string): {
+    kind: "interf-benchmark-run";
+    version: 1;
+    generated_at: string;
+    mode: "source-files" | "context-graph" | "both";
+    source_path: string;
+    project: {
+        name: string;
+        context_graph_path: string | null;
+    };
+    source_files: {
+        label: string;
+        run_path: string;
+        ok: boolean;
+        passed_cases: number;
+        total_cases: number;
+        passed_checks: number;
+        total_checks: number;
+        source_usage: "unknown" | "source-baseline" | "graph-only" | "graph-source-verified";
+        target: {
+            type: "source-files" | "context-graph";
+            name: string;
+            path: string;
+            build_plan: string;
+        };
+        executor?: {
+            kind: "local-agent" | "connected-provider" | "managed";
+            name: string;
+            display_name: string;
+            command: string | null;
+            model?: string | null | undefined;
+            effort?: string | null | undefined;
+            profile?: string | null | undefined;
+            timeout_ms?: number | null | undefined;
+        } | null | undefined;
+    } | null;
+    context_graph: {
+        label: string;
+        run_path: string;
+        ok: boolean;
+        passed_cases: number;
+        total_cases: number;
+        passed_checks: number;
+        total_checks: number;
+        source_usage: "unknown" | "source-baseline" | "graph-only" | "graph-source-verified";
+        target: {
+            type: "source-files" | "context-graph";
+            name: string;
+            path: string;
+            build_plan: string;
+        };
+        executor?: {
+            kind: "local-agent" | "connected-provider" | "managed";
+            name: string;
+            display_name: string;
+            command: string | null;
+            model?: string | null | undefined;
+            effort?: string | null | undefined;
+            profile?: string | null | undefined;
+            timeout_ms?: number | null | undefined;
+        } | null | undefined;
+    } | null;
+    summary: {
+        source_files_pass_rate: number | null;
+        context_graph_pass_rate: number | null;
+    };
+    checks_fingerprint?: string | undefined;
+} | null;
+export declare function checksEvaluatedEvent(runId: string, benchmarkRun: NonNullable<ReturnType<typeof readLatestBenchmarkRun>>): InterfRunEvent;
+export declare function readinessUpdatedEvent(runId: string, project: string, readiness: Readiness): InterfRunEvent;