@interf/compiler 0.22.2 → 0.33.0

package/dist/packages/{engine → runtime}/run-observability.js

@@ -1,10 +1,10 @@
 import { createRunEventTimestamp, } from "./execution/events.js";
-import { RunObservabilityResourceSchema, } from "./lib/schema.js";
+import { RunObservabilityResourceSchema, RunStatusResourceSchema, } from "./schemas/index.js";
 export function uniqueArtifacts(artifacts) {
     const seen = new Set();
     const result = [];
     for (const artifact of artifacts) {
-        const key = `${artifact.role}:${artifact.stage_id ?? ""}:${artifact.path}`;
+        const key = `${artifact.stage_id ?? ""}:${artifact.path}`;
         if (seen.has(key))
             continue;
         seen.add(key);
@@ -12,6 +12,52 @@ export function uniqueArtifacts(artifacts) {
     }
     return result;
 }
+function compactTraceEvent(event) {
+    if (!event)
+        return null;
+    return {
+        event_id: event.eventId,
+        event_type: event.eventType,
+        created_at: event.createdAt,
+        correlation_id: event.correlationId ?? null,
+    };
+}
+function compactTraceStream(stream) {
+    if (!stream?.text)
+        return null;
+    return {
+        stream_id: stream.streamId,
+        chunk_id: stream.chunkId,
+        index: stream.index,
+        created_at: stream.createdAt,
+        text: stream.text.length > 600 ? `${stream.text.slice(0, 600)}...` : stream.text,
+    };
+}
+export function runObservabilityToStatus(run) {
+    const latestEvent = run.trace.events.at(-1);
+    const latestLog = [...run.trace.streams].reverse().find((stream) => stream.text.trim().length > 0);
+    return RunStatusResourceSchema.parse({
+        kind: "interf-run-status",
+        version: 1,
+        run_id: run.run_id,
+        run_type: run.run_type,
+        title: run.title,
+        status: run.status,
+        project: run.project ?? null,
+        build_plan: run.build_plan ?? null,
+        created_at: run.created_at,
+        started_at: run.started_at ?? null,
+        finished_at: run.finished_at ?? null,
+        metrics: run.metrics.slice(0, 8),
+        artifact_count: run.artifacts.length,
+        check_count: run.checks.length,
+        context_check_count: run.context_checks.length,
+        readiness: run.readiness ?? null,
+        latest_event: compactTraceEvent(latestEvent),
+        latest_log: compactTraceStream(latestLog),
+        detail_hint: "Poll this compact status until terminal. If a Run fails or is cancelled, report it and ask before retrying.",
+    });
+}
 function observableRunStatus(status) {
     if (status === "queued" || status === "pending")
         return "queued";
@@ -82,8 +128,8 @@ function buildTraceStreamChunks(runId, events) {
         message: event.message ?? event.summary ?? event.error ?? event.reason ?? event.type,
     }), event));
 }
-function proofChecksForBuildRun(run) {
-    return run.stages.flatMap((stage) => (stage.latest_proof?.checks ?? []).map((check) => ({
+function runChecksForBuildRun(run) {
+    return run.stages.flatMap((stage) => (stage.latest_evidence?.checks ?? []).map((check) => ({
         ...check,
         detail: check.detail ?? `${stage.stage_label ?? stage.stage_id} / ${stage.status}`,
     })));
@@ -92,8 +138,8 @@ function agentLabelForJob(job) {
     return job.agent?.display_name ?? job.agent?.name ?? null;
 }
 function jobTypeLabelForMetric(type) {
-    if (type === "readiness-check-draft")
-        return "Draft readiness checks";
+    if (type === "benchmark-question-draft")
+        return "Draft benchmark questions";
     if (type === "build-plan-draft")
         return "Build Plan draft";
     if (type === "build-plan-improvement")
@@ -106,23 +152,23 @@ function stageTracePayload(stage) {
         ...(stage.summary ? { summary: stage.summary } : {}),
         ...(stage.artifacts.length > 0 ? { artifacts: stage.artifacts } : {}),
         ...(stage.logs ? { logs: stage.logs } : {}),
-        ...(stage.latest_proof ? { proof: stage.latest_proof } : {}),
+        ...(stage.latest_evidence ? { evidence: stage.latest_evidence } : {}),
     };
 }
 function buildPlanForRun(run) {
     return run.build_plan;
 }
-function verifiableContextPathForRun(run) {
-    return run.verifiable_context_path;
+function contextGraphPathForRun(run) {
+    return run.context_graph_path;
 }
 export function buildRunToObservability(run) {
     const artifacts = uniqueArtifacts(run.stages.flatMap((stage) => stage.artifacts));
-    const proof = proofChecksForBuildRun(run);
+    const checks = runChecksForBuildRun(run);
     const executor = run.stages.find((stage) => stage.executor)?.executor ?? null;
     const traceStatus = runTraceStatus(run.status);
     const buildPlan = buildPlanForRun(run);
-    const verifiableContextPath = verifiableContextPathForRun(run);
-    const traceName = interfTraceName("build", `Build ${run.preparation}`);
+    const contextGraphPath = contextGraphPathForRun(run);
+    const traceName = interfTraceName("build", `Build ${run.project}`);
     const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
         ? run.started_at ?? run.created_at
         : undefined);
@@ -133,7 +179,7 @@ export function buildRunToObservability(run) {
             traceName,
             input: {
                 kind: "build",
-                preparation: run.preparation,
+                project: run.project,
                 build_plan: buildPlan,
                 source_path: run.source_path,
             },
@@ -147,7 +193,7 @@ export function buildRunToObservability(run) {
         events.push(traceEvent(run.run_id, "run_started", run.started_at, eventIndex++, {
             traceName,
             input: {
-                preparation: run.preparation,
+                project: run.project,
                 build_plan: buildPlan,
             },
             executionContext: {
@@ -193,16 +239,16 @@ export function buildRunToObservability(run) {
     if (traceStatus === "completed") {
         events.push(traceEvent(run.run_id, "run_completed", completedAt, eventIndex++, {
             output: {
-                verifiable_context_path: verifiableContextPath,
+                context_graph_path: contextGraphPath,
                 artifacts,
-                proof,
-                latest_proof: run.latest_proof ?? null,
+                checks,
+                latest_evidence: run.latest_evidence ?? null,
             },
         }));
     }
     else if (traceStatus === "failed") {
         events.push(traceEvent(run.run_id, "run_failed", completedAt, eventIndex++, {
-            error: structuredRunTraceError(run.stages.find((stage) => stage.failure)?.failure ?? run.latest_proof?.summary),
+            error: structuredRunTraceError(run.stages.find((stage) => stage.failure)?.failure ?? run.latest_evidence?.summary),
         }));
     }
     else if (traceStatus === "cancelled") {
@@ -213,12 +259,12 @@ export function buildRunToObservability(run) {
         version: 1,
         run_id: run.run_id,
         run_type: "build",
-        title: `Build ${run.preparation}`,
+        title: `Build ${run.project}`,
         status: observableRunStatus(run.status),
-        preparation: run.preparation,
+        project: run.project,
         build_plan: buildPlan,
         source_path: run.source_path,
-        output_path: verifiableContextPath,
+        output_path: contextGraphPath,
         executor,
         agent_label: executor?.display_name ?? run.backend,
         created_at: run.created_at,
@@ -226,15 +272,19 @@ export function buildRunToObservability(run) {
         finished_at: run.finished_at ?? null,
         readiness: run.readiness ?? null,
         metrics: [
-            { label: "Preparation", value: run.preparation },
+            { label: "Project", value: run.project },
             { label: "Build Plan", value: buildPlan },
             { label: "Executor", value: executor?.display_name ?? run.backend },
             { label: "Stages", value: `${run.stages.filter((stage) => stage.status === "succeeded").length}/${run.stages.length}` },
-            { label: "Stage proof", value: `${proof.filter((check) => check.ok).length}/${proof.length}` },
+            {
+                label: "Context Checks",
+                value: `${(run.context_checks ?? []).filter((check) => check.status === "passed").length}/${(run.context_checks ?? []).length}`,
+            },
             { label: "Artifacts", value: String(artifacts.length) },
         ],
         artifacts,
-        proof,
+        checks,
+        context_checks: run.context_checks ?? [],
         trace: {
             run: {
                 runId: run.run_id,
@@ -245,22 +295,22 @@ export function buildRunToObservability(run) {
                 executionContext: {
                     product: "Interf",
                     run_type: "build",
-                    preparation: run.preparation,
+                    project: run.project,
                     build_plan: buildPlan,
                     backend: run.backend,
                     executor,
                 },
                 input: {
-                    preparation: run.preparation,
+                    project: run.project,
                     build_plan: buildPlan,
                     source_path: run.source_path,
                 },
                 ...(traceStatus === "completed"
                     ? {
                         output: {
-                            verifiable_context_path: verifiableContextPath,
+                            context_graph_path: contextGraphPath,
                             artifacts,
-                            proof,
+                            checks,
                         },
                     }
                     : {}),
@@ -277,36 +327,39 @@ export function buildRunToObservability(run) {
 }
 export function verifyRunToObservability(run) {
     const traceStatus = runTraceStatus(run.status);
-    const title = `Check readiness ${run.preparation}`;
+    const batch = run.batch ?? null;
+    const title = batch ? `Benchmark ${run.project} (${batch.total_agents} agents)` : `Benchmark ${run.project}`;
     const traceName = interfTraceName("verify", title);
     const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
         ? run.started_at ?? new Date().toISOString()
         : undefined);
-    const readinessRun = run.readiness_run;
-    const sourceFiles = readinessRun?.source_files ?? null;
-    const verifiableContext = readinessRun?.verifiable_context ?? null;
-    const proofCandidates = [
+    const benchmarkRun = run.benchmark_run;
+    const sourceFiles = benchmarkRun?.source_files ?? null;
+    const contextGraph = benchmarkRun?.context_graph ?? null;
+    const executor = run.executor ?? contextGraph?.executor ?? sourceFiles?.executor ?? null;
+    const agentLabel = run.agent_label ?? executor?.display_name ?? null;
+    const checkCandidates = [
         sourceFiles
             ? {
                 id: `${run.run_id}-source-files`,
                 label: "source files baseline",
                 ok: sourceFiles.ok ?? sourceFiles.passed_cases === sourceFiles.total_cases,
-                detail: `${sourceFiles.passed_cases}/${sourceFiles.total_cases} checks`,
+                detail: `${sourceFiles.passed_cases}/${sourceFiles.total_cases} benchmark checks`,
             }
             : null,
-        verifiableContext
+        contextGraph
             ? {
-                id: `${run.run_id}-verifiable-context`,
-                label: "verifiable context",
-                ok: verifiableContext.ok ?? verifiableContext.passed_cases === verifiableContext.total_cases,
-                detail: `${verifiableContext.passed_cases}/${verifiableContext.total_cases} checks`,
+                id: `${run.run_id}-context-graph`,
+                label: "Context Graph",
+                ok: contextGraph.ok ?? contextGraph.passed_cases === contextGraph.total_cases,
+                detail: `${contextGraph.passed_cases}/${contextGraph.total_cases} benchmark checks`,
             }
             : null,
     ];
-    const proof = proofCandidates.filter((value) => value !== null);
+    const checks = checkCandidates.filter((value) => value !== null);
     const artifacts = uniqueArtifacts([
-        ...(sourceFiles?.run_path ? [{ path: sourceFiles.run_path, role: "test", label: "source files readiness run" }] : []),
-        ...(verifiableContext?.run_path ? [{ path: verifiableContext.run_path, role: "test", label: "verifiable context readiness run" }] : []),
+        ...(sourceFiles?.run_path ? [{ path: sourceFiles.run_path, role: "benchmark", label: "source files benchmark run" }] : []),
+        ...(contextGraph?.run_path ? [{ path: contextGraph.run_path, role: "benchmark", label: "Context Graph benchmark run" }] : []),
     ]);
     let eventIndex = 0;
     const events = [
@@ -315,9 +368,8 @@ export function verifyRunToObservability(run) {
             traceName,
             input: {
                 kind: "verify",
-                preparation: run.preparation,
-                // 0.15 - verify runs always judge against verifiable context.
-                mode: "built",
+                project: run.project,
+                target: run.target ?? "both",
             },
         }),
     ];
@@ -325,12 +377,29 @@ export function verifyRunToObservability(run) {
         events.push(traceEvent(run.run_id, "run_started", run.started_at, eventIndex++, {
             traceName,
             input: {
-                preparation: run.preparation,
-                mode: "built",
+                project: run.project,
+                target: run.target ?? "both",
             },
         }));
     }
     const targetStepCandidates = [
+        batch
+            ? {
+                id: "benchmark-agents",
+                label: "Benchmark agents",
+                status: run.status === "failed" || run.status === "cancelled"
+                    ? "failed"
+                    : run.status === "queued" || run.status === "running"
+                        ? "running"
+                        : "succeeded",
+                input: {
+                    project: run.project,
+                    target: run.target ?? "both",
+                    child_run_ids: batch.child_run_ids,
+                },
+                output: batch,
+            }
+            : null,
         sourceFiles
             ? {
                 id: "source-files-baseline",
@@ -340,27 +409,31 @@ export function verifyRunToObservability(run) {
                 output: sourceFiles,
             }
             : null,
-        verifiableContext
+        contextGraph
             ? {
-                id: "verifiable-context-check",
-                label: "Verifiable context",
-                status: verifiableContext.ok ?? verifiableContext.passed_cases === verifiableContext.total_cases ? "succeeded" : "failed",
-                input: verifiableContext.target ?? { type: "verifiable-context", path: run.verifiable_context_path ?? null },
-                output: verifiableContext,
+                id: "context-graph-check",
+                label: "Context Graph",
+                status: contextGraph.ok ?? contextGraph.passed_cases === contextGraph.total_cases ? "succeeded" : "failed",
+                input: contextGraph.target ?? { type: "context-graph", path: run.context_graph_path ?? null },
+                output: contextGraph,
             }
             : null,
     ];
     const targetSteps = targetStepCandidates.filter((value) => value !== null);
     if (targetSteps.length === 0) {
         targetSteps.push({
-            id: "check-readiness",
-            label: "Run readiness checks",
-            status: run.status === "failed" ? "failed" : "succeeded",
+            id: "run-benchmark",
+            label: "Run benchmark/evaluation",
+            status: run.status === "failed" || run.status === "cancelled"
+                ? "failed"
+                : run.status === "queued" || run.status === "running"
+                    ? "running"
+                    : "succeeded",
             input: {
-                preparation: run.preparation,
-                mode: "built",
+                project: run.project,
+                target: run.target ?? "both",
             },
-            output: readinessRun ?? null,
+            output: benchmarkRun ?? null,
         });
     }
     for (const step of targetSteps) {
@@ -372,6 +445,8 @@ export function verifyRunToObservability(run) {
         events.push(traceEvent(run.run_id, "step_started", timestamp, eventIndex++, {
             attempt: 1,
         }, step.id));
+        if (step.status === "running")
+            continue;
         events.push(traceEvent(run.run_id, step.status === "failed" ? "step_failed" : "step_completed", run.finished_at ?? timestamp, eventIndex++, step.status === "failed"
             ? { error: structuredRunTraceError(run.error ?? `${step.label} did not pass.`), output: step.output }
             : { result: step.output }, step.id));
@@ -379,8 +454,8 @@ export function verifyRunToObservability(run) {
     if (traceStatus === "completed") {
         events.push(traceEvent(run.run_id, "run_completed", completedAt, eventIndex++, {
             output: {
-                readiness_run: readinessRun,
-                proof,
+                benchmark_run: benchmarkRun,
+                checks,
             },
         }));
     }
@@ -399,23 +474,30 @@ export function verifyRunToObservability(run) {
         run_type: "verify",
         title,
         status: observableRunStatus(run.status),
-        preparation: run.preparation,
-        build_plan: verifiableContext?.target?.build_plan ?? null,
+        project: run.project,
+        build_plan: contextGraph?.target?.build_plan ?? null,
         source_path: run.source_path ?? null,
-        output_path: run.verifiable_context_path ?? null,
+        output_path: run.context_graph_path ?? null,
+        executor,
+        agent_label: agentLabel,
         created_at: run.started_at ?? completedAt ?? new Date().toISOString(),
         started_at: run.started_at ?? null,
         finished_at: run.finished_at ?? null,
         readiness: run.readiness ?? null,
         metrics: [
-            { label: "Preparation", value: run.preparation },
-            { label: "Mode", value: "verifiable context" },
-            { label: "Readiness checks", value: verifiableContext ? `${verifiableContext.passed_cases}/${verifiableContext.total_cases}` : sourceFiles ? `${sourceFiles.passed_cases}/${sourceFiles.total_cases}` : "0/0" },
+            { label: "Project", value: run.project },
+            ...(batch ? [
+                { label: "Agents", value: `${batch.completed_agents}/${batch.total_agents}` },
+                { label: "Succeeded", value: String(batch.succeeded_agents) },
+                { label: "Failed", value: String(batch.failed_agents) },
+            ] : []),
+            { label: "Target", value: run.target === "source-files" ? "Source files" : run.target === "context-graph" ? "Context Graph" : "Both" },
+            { label: "Benchmark checks", value: contextGraph ? `${contextGraph.passed_cases}/${contextGraph.total_cases}` : sourceFiles ? `${sourceFiles.passed_cases}/${sourceFiles.total_cases}` : "0/0" },
             { label: "Source files", value: sourceFiles ? `${sourceFiles.passed_cases}/${sourceFiles.total_cases}` : "-" },
-            { label: "Verifiable context", value: verifiableContext ? `${verifiableContext.passed_cases}/${verifiableContext.total_cases}` : "-" },
+            { label: "Context Graph", value: contextGraph ? `${contextGraph.passed_cases}/${contextGraph.total_cases}` : "-" },
         ],
         artifacts,
-        proof,
+        checks,
         trace: {
             run: {
                 runId: run.run_id,
@@ -426,16 +508,16 @@ export function verifyRunToObservability(run) {
                 executionContext: {
                     product: "Interf",
                     run_type: "verify",
-                    preparation: run.preparation,
-                    mode: "built",
+                    project: run.project,
+                    target: run.target ?? "both",
                 },
                 input: {
-                    preparation: run.preparation,
-                    mode: "built",
+                    project: run.project,
+                    target: run.target ?? "both",
                     source_path: run.source_path ?? null,
-                    verifiable_context_path: run.verifiable_context_path ?? null,
+                    context_graph_path: run.context_graph_path ?? null,
                 },
-                ...(traceStatus === "completed" ? { output: { readiness_run: readinessRun, proof } } : {}),
+                ...(traceStatus === "completed" ? { output: { benchmark_run: benchmarkRun, checks } } : {}),
                 ...(traceStatus === "failed" ? { error: structuredRunTraceError(run.error) } : {}),
                 ...(run.started_at ? { startedAt: run.started_at } : {}),
                 ...(completedAt ? { completedAt } : {}),
@@ -448,8 +530,8 @@ export function verifyRunToObservability(run) {
     });
 }
 export function jobRunToObservability(job) {
-    const runType = (job.job_type === "readiness-check-draft"
-        ? "readiness-check-draft"
+    const runType = (job.job_type === "benchmark-question-draft"
+        ? "benchmark-question-draft"
         : job.job_type === "build-plan-draft"
             ? "build-plan-draft"
             : job.job_type === "build-plan-improvement"
@@ -476,7 +558,7 @@ export function jobRunToObservability(job) {
             traceName,
             input: {
                 job_type: job.job_type,
-                preparation: job.preparation ?? null,
+                project: job.project ?? null,
                 build_plan: buildPlanId,
             },
             executionContext: {
@@ -489,7 +571,7 @@ export function jobRunToObservability(job) {
             traceName,
             input: {
                 job_type: job.job_type,
-                preparation: job.preparation ?? null,
+                project: job.project ?? null,
             },
             executionContext: {
                 executor,
@@ -550,7 +632,7 @@ export function jobRunToObservability(job) {
         run_type: runType,
         title: job.title,
         status: observableRunStatus(job.status),
-        preparation: job.preparation ?? null,
+        project: job.project ?? null,
         build_plan: buildPlanId,
         source_path: job.source_path ?? null,
         output_path: outputPath,
@@ -563,11 +645,11 @@ export function jobRunToObservability(job) {
             { label: "Kind", value: jobTypeLabelForMetric(job.job_type) },
             { label: "Executor", value: agentLabelForJob(job) ?? "local executor" },
             { label: "Phases", value: `${job.steps.filter((step) => step.status === "succeeded").length}/${job.steps.length}` },
-            { label: "Preparation", value: job.preparation ?? "-" },
+            { label: "Project", value: job.project ?? "-" },
             { label: "Build Plan", value: buildPlanId ?? "-" },
         ],
         artifacts,
-        proof: [],
+        checks: [],
         trace: {
             run: {
                 runId: job.run_id,
@@ -579,13 +661,13 @@ export function jobRunToObservability(job) {
                     product: "Interf",
                     run_type: runType,
                     job_type: job.job_type,
-                    preparation: job.preparation ?? null,
+                    project: job.project ?? null,
                     build_plan: buildPlanId,
                     executor,
                 },
                 input: {
                     job_type: job.job_type,
-                    preparation: job.preparation ?? null,
+                    project: job.project ?? null,
                     build_plan: buildPlanId,
                     source_path: job.source_path ?? null,
                 },

package/dist/packages/runtime/runtime-action-proposals.d.ts

@@ -0,0 +1,7 @@
+import { type ActionProposalResource } from "./schemas/index.js";
+import type { LocalServiceRuntime } from "./runtime.js";
+export declare function listActionProposals(projectDataDir: string): ActionProposalResource[];
+export declare function getActionProposal(projectDataDir: string, proposalId: string): ActionProposalResource | null;
+export declare function createActionProposal(runtime: LocalServiceRuntime, projectDataDir: string, requestValue: unknown): Promise<ActionProposalResource>;
+export declare function decideActionProposal(runtime: LocalServiceRuntime, projectDataDir: string, proposalId: string, requestValue: unknown): Promise<ActionProposalResource | null>;
+export declare function writeActionProposal(projectDataDir: string, proposal: ActionProposalResource): void;