@iowarp/clio-coder 0.4.3 → 0.4.5

package/src/domains/observability/contract.ts

@@ -1,4 +1,10 @@
 import type { ResponseModelIdObservationCounts } from "../../core/response-model-id.js";
+import type { AgentAudience } from "../agents/spec.js";
+import type { RunToolBudgetEnvelope } from "../dispatch/budget-envelope.js";
+import type { DispatchSnapshot } from "../dispatch/contract.js";
+import type { DispatchRequestOrigin, RunKind } from "../dispatch/types.js";
+import type { TrustSummaryProjection } from "../evidence/trust-projection.js";
+import type { CanonicalTrustStatus } from "../evidence/trust-status.js";
 import type { TargetStatus } from "../providers/contract.js";
 import type { CostProvenance } from "../providers/index.js";
 import type { AccountabilitySummary } from "./accountability.js";
@@ -6,6 +12,7 @@ import type { CostAggregate, CostEntry, CostEntryLabel, UsageBreakdown } from ".
 import type { MetricsView } from "./metrics.js";
 import type { TelemetrySnapshot } from "./telemetry.js";
 import type { SessionTurnTrace } from "./trace-store.js";
+import type { WorkerProgressSnapshot } from "./worker-progress.js";
 
 export interface TokenThroughputSnapshot {
 	tokensPerSecond: number;
@@ -40,10 +47,10 @@ export interface ObservabilityNotice {
 }
 
 /**
- * Compact lifecycle summary for a recent dispatch run. Projected from the
- * dispatch bus channels; the raw transcript, tool arguments, and worker output
- * are intentionally absent. `evidence` is populated asynchronously once the
- * forensic bundle for the run finalizes.
+ * Compact lifecycle summary for an active or recently settled dispatch run. Projected from the
+ * dispatch bus channels; raw tool arguments and reasoning are absent. Worker
+ * progress is a bounded, redacted presentation of the live stream. `evidence`
+ * is populated asynchronously once the forensic bundle for the run finalizes.
  */
 export interface ObservabilityRunSummary {
 	runId: string;
@@ -51,8 +58,29 @@ export interface ObservabilityRunSummary {
 	targetId?: string;
 	modelId?: string;
 	runtimeId?: string;
-	runtimeKind?: string;
-	status: "enqueued" | "running" | "completed" | "failed" | "aborted" | "dead" | "stale";
+	runtimeKind?: RunKind;
+	status: "enqueued" | "running" | "completed" | "failed" | "aborted" | "dead" | "stale" | "cancelling" | "retrying";
+	agentAudience?: AgentAudience;
+	requestOrigin?: DispatchRequestOrigin;
+	endpoint?: { key: string; label: string; limit: number };
+	taskSummary?: string;
+	budget?: RunToolBudgetEnvelope;
+	ttftMs?: number | null;
+	node?: string;
+	gate?: { role: string; cycle: number };
+	council?: { group: string; label: string; color?: string; round: number };
+	hostVerification?: "verified" | "rejected" | "skipped" | "not_implicated";
+	trust?: TrustSummaryProjection;
+	rerouteCount?: number;
+	failoverHops?: number;
+	contextWindow?: number;
+	lastContextTokens?: number;
+	progress?: WorkerProgressSnapshot;
+	receiptId?: string;
+	retry?: { attempt: number; dueAtMs: number; reason: string };
+	steerAcknowledgement?: { receivedAtMs: number; chars: number };
+	writeRecordDowngrade?: { reason: "opaque_tool_succeeded"; tool: string; toolCallId: string };
+	phase?: { wave: number; stepId: string };
 	startedAtMs: number;
 	updatedAtMs: number;
 	finishedAtMs: number | null;
@@ -101,7 +129,23 @@ export interface ObservabilitySnapshot {
 	pendingEvidenceBuildRunIds: readonly string[];
 }
 
-export interface ObservabilityContract {
+/** Runtime readers supplied after dispatch is composed, avoiding a domain dependency cycle. */
+export interface ObservabilityRunReaders {
+	dispatchSnapshot?: () => DispatchSnapshot;
+	readReceipt?: (runId: string) => { text?: string; trust?: CanonicalTrustStatus } | null;
+}
+
+/** Run projection controls shared by the contract and the in-memory projection. */
+export interface ObservabilityRunProjection {
+	/** Bind live dispatch and receipt readers; disposal detaches this binding only. */
+	bindRunReaders(readers: ObservabilityRunReaders): () => void;
+	/** Fold retry timers and live counters from the dispatch reader. */
+	reconcileRuns(): void;
+	/** Record an explicit fleet position, including before a run's first event. */
+	setFleetPhase(runId: string, phase: NonNullable<ObservabilityRunSummary["phase"]>): void;
+}
+
+export interface ObservabilityContract extends ObservabilityRunProjection {
 	/** Raw counter + histogram view. */
 	telemetry(): TelemetrySnapshot;
 	/** Aggregated view the TUI consumes. */
@@ -114,7 +158,8 @@ export interface ObservabilityContract {
 	/** Running session cost log entries. */
 	costEntries(): ReadonlyArray<CostEntry>;
 	/**
-	 * Rolling first-pass-success rate and failure-cause histogram, aggregated
+	 * Rolling first-pass-success rate, unverified successes, ungrounded claims,
+	 * and failure-cause histogram, aggregated
 	 * from the sidecar evidence index on call. Read-only: it folds rows Slice 2
 	 * already wrote and recomputes no evidence.
 	 */
@@ -160,7 +205,7 @@ export interface ObservabilityContract {
 	recordSessionTurn(trace: SessionTurnTrace): void;
 	/**
 	 * Current product-facing projection. Cheap to call: it folds in-memory state
-	 * (bounded run/notice rings, session cost/tokens, aggregated metrics, and the
+	 * (active runs, bounded terminal history/notices, session cost/tokens, aggregated metrics, and the
 	 * cached accountability summary) into a fresh immutable snapshot.
 	 */
 	snapshot(): ObservabilitySnapshot;

package/src/domains/observability/evidence-index.ts

@@ -42,6 +42,10 @@ export interface EvidenceIndexRow {
 	tags: EvidenceTag[];
 	firstPassSuccess: boolean;
 	findingCount: number;
+	/** Absent on historical rows; never infer success from firstPassSuccess. */
+	succeeded?: boolean;
+	completionEvidenceWarning?: boolean;
+	ungroundedClaims?: number;
 	/** ISO-8601 timestamp the row was written. */
 	generatedAt: string;
 }
@@ -60,6 +64,12 @@ function isEvidenceIndexRow(value: unknown): value is EvidenceIndexRow {
 		row.tags.every((tag) => typeof tag === "string") &&
 		typeof row.firstPassSuccess === "boolean" &&
 		typeof row.findingCount === "number" &&
+		(row.succeeded === undefined || typeof row.succeeded === "boolean") &&
+		(row.completionEvidenceWarning === undefined || typeof row.completionEvidenceWarning === "boolean") &&
+		(row.ungroundedClaims === undefined ||
+			(typeof row.ungroundedClaims === "number" &&
+				Number.isSafeInteger(row.ungroundedClaims) &&
+				row.ungroundedClaims >= 0)) &&
 		typeof row.generatedAt === "string"
 	);
 }

package/src/domains/observability/extension.ts

@@ -130,6 +130,11 @@ function evidenceIndexRow(
 		tags: [...tags],
 		firstPassSuccess,
 		findingCount: result.findings.length,
+		succeeded,
+		completionEvidenceWarning: result.findings.some(
+			(finding) => finding.tag === "completion-evidence" && finding.severity === "warn",
+		),
+		ungroundedClaims: result.ungroundedClaims,
 		generatedAt: new Date().toISOString(),
 	};
 }
@@ -178,11 +183,7 @@ export function createObservabilityBundle(
 		projection.evidenceBuildStarted(runId);
 		const build = buildAndIndexEvidence(runId, succeeded, attempt, {
 			onReady: (id, evidence) => {
-				projection.evidenceBuildSucceeded(id, evidence);
-				// The same fact, once, for listeners outside this closure (the ACP
-				// server forwards it as the opt-in `accountability.evidenceReady`
-				// kind). The payload spreads the evidence object the projection just
-				// received rather than rebuilding it, so the two cannot drift.
+				// The projection and ACP consume the same evidence-ready event.
 				context.bus.emit(BusChannels.AccountabilityEvidenceReady, { runId: id, ...evidence });
 			},
 			onFailed: (id, message) => projection.evidenceBuildFailed(id, message),
@@ -286,6 +287,9 @@ export function createObservabilityBundle(
 			telemetry.record("histogram", "tokens.ttft_ms", snapshot.ttftMs ?? 0);
 			projection.refresh();
 		},
+		bindRunReaders: (readers) => projection.bindRunReaders(readers),
+		reconcileRuns: () => projection.reconcileRuns(),
+		setFleetPhase: (runId, phase) => projection.setFleetPhase(runId, phase),
 		snapshot: () => projection.snapshot(),
 		subscribe: (listener) => projection.subscribe(listener),
 	};