@llblab/pi-actors 0.43.1 → 0.44.0

package/lib/inspector-overlay.ts

@@ -4,7 +4,7 @@
  * Owns manual kernel navigation; evidence parsing and lifecycle mutation stay in ports.
  */
 
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import * as path from "node:path";
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
@@ -19,6 +19,10 @@ import * as ActorInspector from "./inspector.ts";
 import * as ControlProjection from "./control-projection.ts";
 import * as RunsControls from "./runs-controls.ts";
 import * as RunControlDelivery from "./runs-control-delivery.ts";
+import * as RunsTrace from "./runs-trace.ts";
+import * as Limits from "./limits.ts";
+import { computeRunControlCapacity } from "./run-evidence-policy.ts";
+import * as RuntimeTriage from "./runtime-triage.ts";
 import * as TraceProjection from "./trace-projection.ts";
 
 export type ActorInspectorTab = "recipe" | "trace" | "control";
@@ -59,12 +63,6 @@ const TRACE_SOURCES: TraceProjection.TraceSourceFilter[] = [
   "runtime",
 ];
 
-function newestTraceItems(items: readonly TraceProjection.TraceItem[]): TraceProjection.TraceItem[] {
-  return [...items].sort((left, right) =>
-    right.ts.localeCompare(left.ts) || right.id.localeCompare(left.id),
-  );
-}
-
 export class ActorInspectorOverlay {
   private readonly done: () => void;
   private readonly killRun?: (run: string, runInstanceId: string) => ActorInspectorActionResult;
@@ -442,7 +440,7 @@ export class ActorInspectorOverlay {
       `${this.theme.fg("muted", "Run:")} ${this.theme.fg("accent", `run:${confirmation.run}`)}`,
       `${this.theme.fg("muted", "Current status:")} ${this.theme.fg("warning", confirmation.status)}`,
       "",
-      this.theme.fg("text", "This sends canonical kill Control."),
+      this.theme.fg("text", "This invokes generation-fenced runtime kill."),
       "",
       `${cancel}    ${kill}`,
       "",
@@ -544,7 +542,11 @@ export class ActorInspectorOverlay {
 
   private renderTraceList(run: ActorInspector.ActorInspectorRunItem): string[] {
     const items = this.traceItems(run);
-    if (items.length === 0) return [this.theme.fg("muted", " No Trace evidence")];
+    const summary = RunsTrace.summarizeRunTraceJournal(
+      RunsTrace.readRunTraceJournal(path.join(this.stateRoot, run.run)));
+    const banner = summary.history_complete ? [] : [this.theme.fg("warning",
+      ` ! Trace history incomplete: ${summary.compacted ? `${summary.compactions_total} compaction(s), ` : ""}${summary.dropped_event_count_exact ? summary.dropped_events : "unknown"} dropped event(s), ${summary.dropped_bytes} bytes`)];
+    if (items.length === 0) return [...banner, this.theme.fg("muted", " No Trace evidence")];
     if (this.selectedTraceId) {
       const selectedIndex = items.findIndex((item) => item.id === this.selectedTraceId);
       if (selectedIndex >= 0) this.rowIndex = selectedIndex;
@@ -560,7 +562,7 @@ export class ActorInspectorOverlay {
     this.contentStripeIndices = items
       .slice(start, start + viewportRows)
       .map((_item, offset) => start + offset);
-    return items.slice(start, start + viewportRows).map((item, offset) => {
+    return [...banner, ...items.slice(start, start + viewportRows - banner.length).map((item, offset) => {
       const index = start + offset;
       const detail = item.detail && typeof item.detail === "object"
         ? item.detail as Record<string, unknown>
@@ -577,7 +579,7 @@ export class ActorInspectorOverlay {
       return this.focus === "list" && index === this.rowIndex
         ? this.theme.fg("accent", row)
         : row;
-    });
+    })];
   }
 
   private renderTraceDetail(width: number): string[] {
@@ -603,16 +605,26 @@ export class ActorInspectorOverlay {
       ? RunControlDelivery.readRunControlEndpoint(stateDir, run.runInstanceId)
       : undefined;
     const meta = this.readRunMeta(stateDir);
+    const journal = RunsControls.readRunControlJournalFromStateDir(stateDir);
+    const capacity = computeRunControlCapacity(journal.records);
+    const stalePending = journal.records.reduce<number>((count, control) => count + Number(Boolean(
+      RuntimeTriage.classifyRuntimeControl({ run: run.run,
+        runInstanceId: run.runInstanceId, status: run.status }, control, Date.now()).stale)), 0);
     return {
       status: run.status,
       run_instance_id: run.runInstanceId,
+      pending: capacity.pending, pending_limit: capacity.limit,
+      available: capacity.available, backpressured: capacity.backpressured,
+      journal_bytes: (() => { try { return statSync(RunsControls.runControlsFile(stateDir)).size; } catch { return 0; } })(),
+      journal_limit: Limits.RUN_CONTROL_JOURNAL_MAX_BYTES,
+      stale_pending: stalePending,
+      diagnostics: journal.diagnostics.map((item) => item.line === undefined
+        ? { reason: "unreadable_control_journal" } : { line: item.line, reason: "invalid_control_json" }),
       actor_actions: Array.isArray(meta.control) ? meta.control : [],
       runtime_actions: run.status === "running" ? ["kill"] : ["archive", "prune"],
       endpoint,
-      recent_controls: RunsControls.readRunControlsFromStateDir(stateDir)
-        .slice(-20)
-        .reverse()
-        .map(ControlProjection.projectRunControl),
+      recent_controls: journal.records.slice(-20).reverse().map((control) =>
+        ControlProjection.projectRunControl(control as RunsControls.RunControlRecord)),
     };
   }
 
@@ -624,10 +636,10 @@ export class ActorInspectorOverlay {
     ) {
       return this.traceCache.items;
     }
-    const items = newestTraceItems(this.readTrace(path.join(this.stateRoot, run.run), {
+    const items = this.readTrace(path.join(this.stateRoot, run.run), {
       limit: 100,
       source: "all",
-    }));
+    });
     this.traceCache = { run: run.run, runInstanceId: run.runInstanceId, items };
     return items;
   }

package/lib/limits.ts

@@ -17,3 +17,13 @@ export const SESSION_EVIDENCE_TEXT_CHARS = 4_000;
 export const SESSION_EVIDENCE_MAX_TOOL_CALLS = 100;
 export const TRACE_EVENT_MAX_BYTES = 64 * 1024;
 export const TRACE_EVENT_MAX_READ = 200;
+export const TRACE_JOURNAL_MAX_EVENTS = 2_048;
+export const TRACE_JOURNAL_TARGET_EVENTS = 1_536;
+export const TRACE_JOURNAL_MAX_BYTES = 4 * 1024 * 1024;
+export const TRACE_JOURNAL_TARGET_BYTES = 3 * 1024 * 1024;
+export const RUN_CONTROL_PENDING_LIMIT = 64;
+export const RUN_CONTROL_TERMINAL_LIMIT = 128;
+export const RUN_CONTROL_ERROR_MAX_BYTES = 4 * 1024;
+export const RUN_CONTROL_JOURNAL_MAX_BYTES = 1024 * 1024;
+export const RUN_RETENTION_MAX_RECORDS = 256;
+export const RUN_RETENTION_MAX_BYTES = 1024 * 1024;

package/lib/observability.ts

@@ -25,6 +25,7 @@ import {
 
 import * as AsyncRuns from "./async-runs.ts";
 import * as Paths from "./paths.ts";
+import * as RunsTrace from "./runs-trace.ts";
 import { readJsonlFileResilient } from "./state-readers.ts";
 
 export type RunObservedStatus =
@@ -73,7 +74,7 @@ export interface RunSummary {
 
 export interface RunUiObservationState {
   attentionEventIds: Map<string, Set<string>>;
-  eventLines: Map<string, number>;
+  legacyEventLines: Map<string, number>;
   frame: number;
   observed: Map<string, RunObservedStatus>;
 }
@@ -98,12 +99,19 @@ export interface RunUiNotificationSink {
 export function createRunUiObservationState(): RunUiObservationState {
   return {
     attentionEventIds: new Map<string, Set<string>>(),
-    eventLines: new Map<string, number>(),
+    legacyEventLines: new Map<string, number>(),
     frame: 0,
     observed: new Map<string, RunObservedStatus>(),
   };
 }
 
+export function primeRunAttentionState(
+  state: RunUiObservationState, ownerId: string, stateRoot?: string,
+): void {
+  detectRunAttentionEvents(state.legacyEventLines, summarizeRuns(stateRoot, ownerId),
+    state.attentionEventIds, true);
+}
+
 export function readRunUiSnapshot(
   state: RunUiObservationState,
   ownerId: string,
@@ -116,7 +124,7 @@ export function readRunUiSnapshot(
       options.includeAttention === false
         ? []
         : detectRunAttentionEvents(
-            state.eventLines,
+            state.legacyEventLines,
             summary,
             state.attentionEventIds,
           ),
@@ -132,7 +140,7 @@ export function pruneRunUiObservationState(
 ): void {
   pruneRunObservationState(
     state.observed,
-    state.eventLines,
+    state.legacyEventLines,
     snapshot.summary,
     snapshot.transitions.map(
       (transition) => transition.stateDir ?? transition.run,
@@ -192,16 +200,15 @@ export function reconcileRunTerminalNotifications(input: {
   sink: RunUiNotificationSink;
   state: RunUiObservationState;
   stateRoot?: string;
+  includeAttention?: boolean;
 }): RunUiSnapshot {
   const snapshot = readRunUiSnapshot(input.state, input.ownerId, {
-    includeAttention: false,
+    includeAttention: input.includeAttention,
     stateRoot: input.stateRoot,
   });
-  deliverRunTransitionNotifications(
-    snapshot.transitions,
-    input.sink,
-    input.inFlight,
-  );
+  if (input.includeAttention)
+    deliverRunAttentionNotifications(snapshot.attentionEvents, input.sink);
+  deliverRunTransitionNotifications(snapshot.transitions, input.sink, input.inFlight);
   pruneRunUiObservationState(input.state, snapshot);
   return snapshot;
 }
@@ -1114,15 +1121,17 @@ function parseAttentionRecord(
   };
 }
 
-function readTraceAttentionRecords(run: RunObservation): Record<string, unknown>[] {
-  if (!run.stateDir) return [];
-  const tracePath = join(run.stateDir, "trace.jsonl");
-  if (existsSync(tracePath)) {
-    return readJsonlFileResilient<Record<string, unknown>>(tracePath).records;
-  }
-  return readJsonlFileResilient<Record<string, unknown>>(
-    join(run.stateDir, "outbox.jsonl"),
-  ).records;
+function readTraceAttentionRecords(run: RunObservation): {
+  canonical: boolean; records: Record<string, unknown>[];
+} {
+  if (!run.stateDir) return { canonical: true, records: [] };
+  if (existsSync(join(run.stateDir, "trace.jsonl"))) return {
+    canonical: true,
+    records: RunsTrace.readRunTraceJournal(run.stateDir).events.map(
+      ({ event }) => event as unknown as Record<string, unknown>),
+  };
+  return { canonical: false, records: readJsonlFileResilient<Record<string, unknown>>(
+    join(run.stateDir, "outbox.jsonl")).records };
 }
 
 export function pruneRunObservationState(
@@ -1134,55 +1143,44 @@ export function pruneRunObservationState(
 ): void {
   const activeRuns = new Set(summary.runs.map((run) => runObservationKey(run)));
   const terminalRunSet = new Set(terminalRuns);
-  const terminalLineKeys = new Set(
-    summary.runs
-      .filter((run) => terminalRunSet.has(runObservationKey(run)))
-      .map((run) => runObservationKey(run)),
-  );
-  const activeLineKeys = new Set(
-    summary.runs.map((run) => run.stateDir ?? run.run),
-  );
+  const terminalLineKeys = new Set(summary.runs
+    .filter((run) => terminalRunSet.has(runObservationKey(run)))
+    .map((run) => runObservationKey(run)));
+  const activeLineKeys = new Set(summary.runs.map((run) => run.stateDir ?? run.run));
   for (const run of terminalRunSet) previousStatuses.delete(run);
-  for (const run of previousStatuses.keys()) {
+  for (const run of previousStatuses.keys())
     if (!activeRuns.has(run)) previousStatuses.delete(run);
-  }
-  for (const key of previousLineCounts.keys()) {
-    if (terminalLineKeys.has(key) || !activeLineKeys.has(key)) {
-      previousLineCounts.delete(key);
-    }
-  }
-  for (const key of seenEventIds.keys()) {
-    if (terminalLineKeys.has(key) || !activeLineKeys.has(key)) {
-      seenEventIds.delete(key);
-    }
-  }
+  for (const key of previousLineCounts.keys())
+    if (terminalLineKeys.has(key) || !activeLineKeys.has(key)) previousLineCounts.delete(key);
+  for (const key of seenEventIds.keys())
+    if (terminalLineKeys.has(key) || !activeLineKeys.has(key)) seenEventIds.delete(key);
 }
 
 export function detectRunAttentionEvents(
-  previousLineCounts: Map<string, number>,
-  summary: RunSummary,
-  seenEventIds: Map<string, Set<string>> = new Map(),
+  legacyLineCounts: Map<string, number>, summary: RunSummary,
+  seenEventIds: Map<string, Set<string>> = new Map(), prime = false,
 ): RunAttentionEvent[] {
   const events: RunAttentionEvent[] = [];
   for (const run of summary.runs) {
     const key = run.stateDir ?? run.run;
-    const records = readTraceAttentionRecords(run);
-    const previousCount = previousLineCounts.get(key) ?? 0;
-    if (run.notificationPolicy === "silent") {
-      previousLineCounts.set(key, records.length);
-      seenEventIds.set(key, seenEventIds.get(key) ?? new Set<string>());
-      continue;
-    }
-    const start = Math.min(previousCount, records.length);
+    const read = readTraceAttentionRecords(run);
+    const retained = new Set<string>();
     const seen = seenEventIds.get(key) ?? new Set<string>();
-    for (let index = start; index < records.length; index += 1) {
-      const event = parseAttentionRecord(records[index], run, index);
-      if (!event || seen.has(event.id)) continue;
-      events.push(event);
-      seen.add(event.id);
+    const start = read.canonical ? 0
+      : Math.min(legacyLineCounts.get(key) ?? 0, read.records.length);
+    for (const [index, record] of read.records.entries()) {
+      const event = parseAttentionRecord(record, run, index);
+      if (!event || !shouldNotifyRunAttentionEvent(event) ||
+          event.kind === "runtime.trace_compacted") continue;
+      retained.add(event.id);
+      if (prime || run.notificationPolicy === "silent") seen.add(event.id);
+      else if (index >= start && !seen.has(event.id)) {
+        events.push(event); seen.add(event.id);
+      }
     }
-    previousLineCounts.set(key, records.length);
-    seenEventIds.set(key, seen);
+    seenEventIds.set(key, new Set([...retained].filter((id) => seen.has(id))));
+    if (read.canonical) legacyLineCounts.delete(key);
+    else legacyLineCounts.set(key, read.records.length);
   }
   return events;
 }

package/lib/run-evidence-policy.ts

@@ -0,0 +1,242 @@
+/**
+ * Pure bounded Run-evidence policy.
+ * Zones: Trace retention, compaction accounting, Control capacity and admission
+ * Owns deterministic limits policy; journal I/O, locks, lifecycle authorization, and projection stay in adapters.
+ * Trace keeps the newest physical suffix because semantic priority would silently
+ * redefine causal history. Admitted Controls never expire: only a real terminal
+ * transition or generation replacement proves that durable work is finished.
+ */
+
+import * as Limits from "./limits.ts";
+
+export const TRACE_COMPACTION_KIND = "runtime.trace_compacted";
+export const TRACE_COMPACTION_VERSION = 1;
+export type TraceJournalUsage = { bytes: number; events: number };
+export type TraceRetentionCandidate<T> = { encodedBytes: number; value: T };
+export type TraceRetentionSelection<T> = {
+  droppedEvents: number; retained: TraceRetentionCandidate<T>[];
+  retainedBytes: number; retainedEvents: number;
+};
+export interface TraceCompactionData {
+  version: typeof TRACE_COMPACTION_VERSION;
+  compactions_total: number;
+  dropped_valid_events_total: number;
+  dropped_malformed_lines_total: number;
+  dropped_bytes_total: number;
+  dropped_event_count_exact: boolean;
+  retained_events: number;
+  retained_bytes: number;
+  history_complete: false;
+}
+export interface TraceCompactionDelta {
+  dropped_valid_events: number;
+  dropped_malformed_lines: number;
+  dropped_bytes: number;
+  dropped_event_count_exact: boolean;
+  retained_events: number;
+  retained_bytes: number;
+}
+export type RunControlStatus = "queued" | "delivered" | "claimed" | "handled" | "failed";
+export type RunControlCapacity = {
+  available: number; backpressured: boolean; limit: number;
+  oldest_pending_at?: string; pending: number;
+};
+export type RunControlAdmissionIntegrity =
+  | "valid" | "unreadable" | "malformed" | "noncanonical"
+  | "invalid_record" | "invalid_status_timestamp" | "generation_mismatch"
+  | "journal_bytes";
+export interface RunControlAdmissionErrorDetails {
+  reason: "control_backpressure" | "control_journal_integrity";
+  pending: number;
+  limit: number;
+  journal_bytes: number;
+  journal_limit: number;
+  oldest_pending_at?: string;
+  run_instance_id: string;
+  next_actions: string[];
+  integrity_reason?: string;
+}
+export type RunControlAdmissionDecision =
+  { admitted: true; capacity: RunControlCapacity } |
+  { admitted: false; capacity: RunControlCapacity; error: RunControlAdmissionErrorDetails };
+export type RunControlAdmissionInput = {
+  integrity: RunControlAdmissionIntegrity; journalBytes: number;
+  newRecordBytes: number; records: readonly unknown[];
+  retainedJournalBytes: number; runInstanceId: string;
+  capacity?: RunControlCapacity;
+};
+
+const PENDING_CONTROL_STATUSES = new Set<RunControlStatus>(["queued", "delivered", "claimed"]);
+const TERMINAL_CONTROL_STATUSES = new Set<RunControlStatus>(["handled", "failed"]);
+const CONTROL_ADMISSION_NEXT_ACTIONS = [
+  "inspect target=run:<id> view=control",
+  "inspect target=runtime view=triage",
+];
+
+function isCount(value: number): boolean {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function assertCount(value: number, name: string): void {
+  if (!isCount(value)) throw new RangeError(`${name} must be a non-negative safe integer`);
+}
+function boundedAdd(left: number, right: number): number {
+  return Math.min(Number.MAX_SAFE_INTEGER, left + right);
+}
+export function traceAppendFits(usage: TraceJournalUsage, encodedEventBytes: number): boolean {
+  if (!isCount(usage.events) || !isCount(usage.bytes) || !isCount(encodedEventBytes)) return false;
+  return usage.events + 1 <= Limits.TRACE_JOURNAL_MAX_EVENTS &&
+    usage.bytes + encodedEventBytes <= Limits.TRACE_JOURNAL_MAX_BYTES;
+}
+
+export function selectNewestTraceSuffix<T>(
+  candidates: readonly TraceRetentionCandidate<T>[],
+  reserve: { bytes?: number; events?: number } = {},
+): TraceRetentionSelection<T> {
+  const reservedBytes = reserve.bytes ?? 0;
+  const reservedEvents = reserve.events ?? 0;
+  assertCount(reservedBytes, "reserved Trace bytes");
+  assertCount(reservedEvents, "reserved Trace events");
+  const byteBudget = Math.max(0, Limits.TRACE_JOURNAL_TARGET_BYTES - reservedBytes);
+  const eventBudget = Math.max(0, Limits.TRACE_JOURNAL_TARGET_EVENTS - reservedEvents);
+  let retainedBytes = 0;
+  let start = candidates.length;
+  while (start > 0 && candidates.length - start < eventBudget) {
+    const candidate = candidates[start - 1]!;
+    assertCount(candidate.encodedBytes, "encoded Trace bytes");
+    if (retainedBytes + candidate.encodedBytes > byteBudget) break;
+    retainedBytes += candidate.encodedBytes;
+    start -= 1;
+  }
+  const retained = candidates.slice(start);
+  return {
+    droppedEvents: candidates.length - retained.length,
+    retained,
+    retainedBytes,
+    retainedEvents: retained.length,
+  };
+}
+
+export function accumulateTraceCompactionStatistics(
+  previous: TraceCompactionData | undefined,
+  delta: TraceCompactionDelta,
+): TraceCompactionData {
+  for (const [name, value] of Object.entries(delta)) {
+    if (name !== "dropped_event_count_exact") assertCount(value as number, name);
+  }
+  const prior = previous ?? {
+    compactions_total: 0,
+    dropped_bytes_total: 0,
+    dropped_event_count_exact: true,
+    dropped_malformed_lines_total: 0,
+    dropped_valid_events_total: 0,
+  };
+  const eventCountOverflow = prior.dropped_valid_events_total +
+    delta.dropped_valid_events > Number.MAX_SAFE_INTEGER;
+  return {
+    version: TRACE_COMPACTION_VERSION,
+    compactions_total: boundedAdd(prior.compactions_total, 1),
+    dropped_valid_events_total: boundedAdd(prior.dropped_valid_events_total, delta.dropped_valid_events),
+    dropped_malformed_lines_total: boundedAdd(prior.dropped_malformed_lines_total, delta.dropped_malformed_lines),
+    dropped_bytes_total: boundedAdd(prior.dropped_bytes_total, delta.dropped_bytes),
+    dropped_event_count_exact: prior.dropped_event_count_exact &&
+      delta.dropped_event_count_exact && !eventCountOverflow,
+    retained_events: delta.retained_events,
+    retained_bytes: delta.retained_bytes,
+    history_complete: false,
+  };
+}
+
+export function traceCompactionMarkerInput(data: TraceCompactionData): {
+  data: TraceCompactionData; kind: typeof TRACE_COMPACTION_KIND; level: "warning";
+} {
+  return { data, kind: TRACE_COMPACTION_KIND, level: "warning" };
+}
+
+export function classifyRunControlRecord(value: unknown): "pending" | "terminal" | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const status = (value as { status?: unknown }).status as RunControlStatus;
+  if (PENDING_CONTROL_STATUSES.has(status)) return "pending";
+  if (TERMINAL_CONTROL_STATUSES.has(status)) return "terminal";
+  return undefined;
+}
+
+export function runControlStatusTimestamp(
+  record: Record<string, unknown>, status: RunControlStatus,
+): unknown {
+  if (status === "failed") return record.failed_at;
+  if (status === "handled") return record.handled_at;
+  if (status === "claimed") return record.claimed_at;
+  if (status === "delivered") return record.delivered_at;
+  return record.queued_at;
+}
+
+export function computeRunControlCapacity(records: readonly unknown[]): RunControlCapacity {
+  let oldest: { timestamp: string; timestampMs: number } | undefined;
+  let pending = 0;
+  for (const value of records) {
+    if (classifyRunControlRecord(value) !== "pending") continue;
+    pending += 1;
+    const record = value as Record<string, unknown>;
+    const timestamp = runControlStatusTimestamp(record, record.status as RunControlStatus);
+    const timestampMs = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+    if (typeof timestamp === "string" && Number.isFinite(timestampMs) &&
+        (!oldest || timestampMs < oldest.timestampMs)) {
+      oldest = { timestamp, timestampMs };
+    }
+  }
+  return {
+    available: Math.max(0, Limits.RUN_CONTROL_PENDING_LIMIT - pending),
+    backpressured: pending >= Limits.RUN_CONTROL_PENDING_LIMIT,
+    limit: Limits.RUN_CONTROL_PENDING_LIMIT,
+    ...(oldest ? { oldest_pending_at: oldest.timestamp } : {}),
+    pending,
+  };
+}
+
+export function decideRunControlAdmission(
+  input: RunControlAdmissionInput,
+): RunControlAdmissionDecision {
+  const capacity = input.capacity ?? computeRunControlCapacity(input.records);
+  const reject = (
+    reason: RunControlAdmissionErrorDetails["reason"],
+    integrityReason?: string,
+  ): RunControlAdmissionDecision => ({
+    admitted: false,
+    capacity,
+    error: {
+      reason,
+      pending: capacity.pending,
+      limit: capacity.limit,
+      journal_bytes: input.journalBytes,
+      journal_limit: Limits.RUN_CONTROL_JOURNAL_MAX_BYTES,
+      ...(capacity.oldest_pending_at ? { oldest_pending_at: capacity.oldest_pending_at } : {}),
+      run_instance_id: input.runInstanceId,
+      next_actions: [...CONTROL_ADMISSION_NEXT_ACTIONS],
+      ...(integrityReason ? { integrity_reason: integrityReason } : {}),
+    },
+  });
+  if (input.integrity !== "valid") return reject("control_journal_integrity", input.integrity);
+  if (!isCount(input.journalBytes) || !isCount(input.retainedJournalBytes) ||
+      !isCount(input.newRecordBytes) ||
+      input.journalBytes > Limits.RUN_CONTROL_JOURNAL_MAX_BYTES) {
+    return reject("control_journal_integrity", "journal_bytes");
+  }
+  for (const value of input.records) {
+    const classification = classifyRunControlRecord(value);
+    if (!classification) return reject("control_journal_integrity", "invalid_record");
+    if (classification !== "pending") continue;
+    const record = value as Record<string, unknown>;
+    const timestamp = runControlStatusTimestamp(record, record.status as RunControlStatus);
+    if (typeof timestamp !== "string" || !Number.isFinite(Date.parse(timestamp))) {
+      return reject("control_journal_integrity", "invalid_status_timestamp");
+    }
+    if (record.run_instance_id !== input.runInstanceId) {
+      return reject("control_journal_integrity", "generation_mismatch");
+    }
+  }
+  if (capacity.backpressured ||
+      input.retainedJournalBytes + input.newRecordBytes > Limits.RUN_CONTROL_JOURNAL_MAX_BYTES) {
+    return reject("control_backpressure");
+  }
+  return { admitted: true, capacity };
+}

package/lib/run-ui-runtime.ts

@@ -106,6 +106,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
         ownerId: deps.getRunOwnerId(ctx),
         sink: Pi.createNotificationSink(deps.pi, ctx),
         state: observation,
+        includeAttention: true,
       });
       reportDiagnostics(ctx);
     },
@@ -141,6 +142,7 @@ export function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime {
     },
     start(ctx) {
       close();
+      Observability.primeRunAttentionState(observation, deps.getRunOwnerId(ctx));
       update(ctx, true, true);
       watcher.refresh();
       reconciliation.start();