@interf/compiler 0.33.0 → 0.50.0

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

@@ -109,8 +109,8 @@ const BUILD_PLAN_AUTHORING_INTERNAL_INSTRUCTION = /Use the attached values as th
 const BUILD_PLAN_AUTHORING_LABELS = [
     "Intent",
     "Context Graph output",
-    "Context Checks",
-    "Checks",
+    "Coverage",
+    "Ready When",
     "CLI preview",
 ];
 function normalizeBuildPlanAuthoringText(value) {
@@ -144,19 +144,19 @@ export function buildPlanAuthoringPromptFallback(message, buildPlanId) {
         .trim();
     const agentWork = extractBuildPlanAuthoringSection(cleaned, "Intent");
     const portableOutput = extractBuildPlanAuthoringSection(cleaned, "Context Graph output");
-    const contextCheckNotes = extractBuildPlanAuthoringSection(cleaned, "Context Checks") ??
-        extractBuildPlanAuthoringSection(cleaned, "Checks");
+    const coverageNotes = extractBuildPlanAuthoringSection(cleaned, "Coverage") ??
+        extractBuildPlanAuthoringSection(cleaned, "Ready When");
     const lines = [
         agentWork ? `Intent: ${stripBuildPlanCommandPrefix(agentWork, buildPlanId)}` : null,
         portableOutput ? `Context Graph output: ${portableOutput}` : null,
-        contextCheckNotes ? `Context Checks: ${contextCheckNotes}` : 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|Context Checks|Checks)\s*:/gi, " "));
+    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();

package/dist/packages/runtime/runtime-resource-builders.d.ts

@@ -37,12 +37,11 @@ export declare function logsForExecutionStageLedger(run: ExecutionStageLedger |
 } | undefined;
 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 readinessStateToProjectReadiness(readiness: Readiness): Readiness;
 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"]): ProjectResource;
+}, sourcePath: string, configPath: string, artifacts?: ProjectResource["artifacts"], updatedAt?: string | null): ProjectResource;
 export declare function buildBuildPlanResource(resource: {
     id: string;
     path: string;
@@ -56,6 +55,9 @@ export declare function buildBuildPlanResource(resource: {
     inputs?: BuildPlanResource["inputs"];
     source_kind: "builtin" | "local";
     built_in: boolean;
+    scope: "builtin" | "user" | "local";
+    created_at?: string | null;
+    updated_at?: string | null;
     active_for_projects: string[];
     artifacts: Artifact[];
     stages: BuildPlanResource["stages"];

package/dist/packages/runtime/runtime-resource-builders.js

@@ -1,6 +1,5 @@
-import { ReadinessSchema, } from "../contracts/lib/schema.js";
 import { buildPlanIdForProjectConfig, } from "../projects/source-config.js";
-import { BuildPlanResourceSchema, ProjectResourceSchema, } from "./schemas/index.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)}`;
@@ -87,7 +86,7 @@ export function readinessSummaryForStatus(status) {
     if (status === "ready")
         return "Ready for agent task.";
     if (status === "not-ready")
-        return "Artifact diagnostics or benchmark checks did not pass.";
+        return "Context Graph is missing required coverage for the agent task.";
     if (status === "stale")
         return "Benchmark result is stale — saved checks have changed since.";
     if (status === "checking")
@@ -99,39 +98,39 @@ export function readinessSummaryForStatus(status) {
     if (status === "not-built")
         return "Context Graph has not been built yet.";
     if (status === "not-configured")
-        return "No checks are configured.";
+        return "Context Graph preparation is not configured.";
     return "Latest Build failed.";
 }
-export function readinessStateToProjectReadiness(readiness) {
-    return ReadinessSchema.parse({
-        ...readiness,
-        checks: readiness.checks.map((check) => ({ ...check })),
-    });
-}
-export function buildProjectResource(project, readiness, latestRunIds, sourcePath, configPath, artifacts = []) {
+export function buildProjectResource(project, readiness, latestRunIds, sourcePath, configPath, artifacts = [], updatedAt = null) {
     const buildPlanId = buildPlanIdForProjectConfig(project);
     const { latestBuildRunId, latestContextGraphBuildRunId, latestTestRunId, } = latestRunIds;
-    return ProjectResourceSchema.parse({
+    // 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,
         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: latestContextGraphBuildRunId,
             latest_benchmark_run_id: latestTestRunId,
         },
         context_graph_path: readiness.context_graph_path,
-        readiness: readinessStateToProjectReadiness(readiness),
+        readiness,
         runs: {
             latest_build_run_id: latestBuildRunId,
             latest_benchmark_run_id: latestTestRunId,
@@ -139,13 +138,16 @@ export function buildProjectResource(project, readiness, latestRunIds, sourcePat
         latest_build_run_id: latestBuildRunId,
         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

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.js

@@ -8,6 +8,7 @@ import { createRunId } from "./runtime-resource-builders.js";
 import { LocalRunHandlerResultSchema, VerifyRunCreateRequestSchema, VerifyRunResourceSchema, } from "./schemas/index.js";
 import { readSavedBenchmarkRun } from "./verify/benchmark-run.js";
 import { createContextGraphTestTarget } from "./verify/verify-targets.js";
+import { isTerminalStatus } from "./runtime-status.js";
 function requestedAgentExecutorInfo(agentName, registry = loadAgentsRegistry()) {
     const requested = agentName?.trim();
     if (!requested)
@@ -30,9 +31,6 @@ export function benchmarkFanoutAgentNames(registry) {
             .filter((agent) => agent.available !== false)
             .map((agent) => agent.name))];
 }
-function isTerminalVerifyStatus(status) {
-    return status === "succeeded" || status === "failed" || status === "cancelled";
-}
 export function latestTopLevelVerifyRun(runs) {
     return runs.find((run) => !run.parent_run_id) ?? runs[0] ?? null;
 }
@@ -40,7 +38,7 @@ export function summarizeVerifyBatch(childRunIds, children) {
     return {
         child_run_ids: childRunIds,
         total_agents: childRunIds.length,
-        completed_agents: children.filter((run) => isTerminalVerifyStatus(run.status)).length,
+        completed_agents: children.filter((run) => isTerminalStatus(run.status)).length,
         succeeded_agents: children.filter((run) => run.status === "succeeded").length,
         failed_agents: children.filter((run) => run.status === "failed" || run.status === "cancelled").length,
     };
@@ -237,7 +235,7 @@ function updateVerifyBatchRun(runtime, projectDataDir, contextGraphPath, parentR
         .filter((run) => run !== null);
     const batch = summarizeVerifyBatch(childRunIds, children);
     const status = statusForBatch(batch);
-    const terminal = isTerminalVerifyStatus(status);
+    const terminal = isTerminalStatus(status);
     const nextWithoutReadiness = VerifyRunResourceSchema.parse({
         ...parent,
         status,
@@ -267,6 +265,9 @@ export function writeVerifyRun(runtime, projectDataDir, contextGraphPath, run) {
     writeJsonFile(verifyRunPath(contextGraphPath, run.run_id), VerifyRunResourceSchema.parse(run));
     runtime.verifyRunCache.invalidateProject(projectDataDir, run.project);
     runtime.readinessCache.invalidateProject(projectDataDir, run.project);
+    // The Context Graph resource embeds the joined readiness verdict and latest
+    // benchmark run id, so bust it whenever a benchmark run is written.
+    runtime.contextGraphResourceCache.invalidateProject(projectDataDir);
 }
 export function readLatestBenchmarkRun(projectDataDir, projectName) {
     return readSavedBenchmarkRun(projectDataDir, projectName);