@llblab/pi-actors 0.43.1 → 0.44.0

package/README.md

@@ -121,13 +121,13 @@ String command-template leaves execute directly without shell interpretation. Us
 }
 ```
 
-Trace fields are exact: `id`, `ts`, `kind`, and optional `summary`, `data`, `level`, `attention`. Address, sender, recipient, reply, and routing fields fail validation. The canonical append authority validates and size-checks under a cross-process mutation lock before one append-only JSONL write; first-party scripts never append this file directly.
+Trace fields are exact: `id`, `ts`, `kind`, and optional `summary`, `data`, `level`, `attention`. Address, sender, recipient, reply, and routing fields fail validation. Trace is a bounded retained suffix, not an audit archive: the canonical authority appends within 2,048 events and 4 MiB or atomically keeps the newest suffix plus one warning-only `runtime.trace_compacted` marker. That marker means older history was discarded; `result.json`, `execution.json`, terminal state, and declared artifacts retain their own authority. `inspect view=trace` reports whether retained history is complete. Reads are newline-safe and deterministic; first-party scripts never write this file directly.
 
-Use `attention: "notify"` for visible status and `attention: "followup"` only when the coordinator needs semantic follow-up context. Store large evidence in artifacts or bounded execution captures.
+Attention is a live wake hint, not a durable queue: persist recovery state or an artifact first. Use `attention: "notify"` for visible status and `attention: "followup"` only when the coordinator needs semantic follow-up context; compaction may discard older hints. Store large evidence in artifacts or bounded execution captures.
 
 ## Control
 
-Controls persist to `controls.jsonl` before transport. Token-owned dead-process-reclaiming locks serialize atomic journal replacements. Every record carries the immutable `run_instance_id`; expected-status fencing advances outcomes monotonically through queued/delivered/claimed/handled/failed evidence, while a fast consumer may claim or handle before the sender adds independent delivery-time evidence.
+Controls persist to `controls.jsonl` before transport. One token-owned lock rejects a 65th pending Control or 1 MiB rewrite before admission, fails closed on malformed or stale-generation evidence, and atomically admits one record. Canonical transitions retain a 128-terminal tail, expected-state fencing, and 4 KiB errors. Admitted nonterminal Controls never expire automatically. Every record carries immutable `run_instance_id`. `inspect view=control` reports pending capacity, saturation, stale work, journal bytes, and bounded diagnostics. If a stuck Run is saturated, use runtime-owned `kill`; it bypasses actor-local capacity and creates no synthetic Control.
 
 Long-lived services publish `control-endpoint.json` only when ready:
 
@@ -159,7 +159,7 @@ Core files:
 - `execution.json` — command/session provenance and complete-capture references;
 - `result.json`, command logs, progress, and declared artifacts.
 
-The runtime preserves owner filtering, process-identity verification, lifecycle locking, shutdown kill, terminal reconciliation, bounded captures, owned Pi sessions, path containment, and redaction.
+The runtime preserves owner filtering, process-identity verification, lifecycle locking, shutdown kill independent of actor-local Control capacity, terminal reconciliation, bounded captures, owned Pi sessions, path containment, and redaction. Trace/Control quotas do not constrain user-declared artifacts, repositories, media sources, complete captures, or actor-owned workload state. Restart clears generation-local Trace, Control, endpoint, execution, and terminal evidence; archive preserves the bounded tree, while prune preserves only requested artifacts.
 
 ## Actor Inspector
 
@@ -197,7 +197,7 @@ npm run validate
 npm run test:preservation
 ```
 
-See the [documentation index](./docs/README.md), [Run lifecycle](./docs/async-runs.md), [Recipe library](./docs/recipe-library.md), and [0.43 baseline](./docs/0.43-baseline.md).
+See the [documentation index](./docs/README.md), [Run lifecycle](./docs/async-runs.md), and [Recipe library](./docs/recipe-library.md).
 
 Project context: [AGENTS.md](./AGENTS.md) · [BACKLOG.md](./BACKLOG.md) · [CHANGELOG.md](./CHANGELOG.md).
 

package/dist/lib/async-runs.js

@@ -23,7 +23,6 @@ import * as RunsStart from "./runs-start.js";
 import { appendRunTraceEvent } from "./runs-trace.js";
 import * as RunsIndex from "./runs-index.js";
 import * as RunsParentTeardown from "./runs-parent-teardown.js";
-import { appendRunControlInStateDir, updateRunControlStatusInStateDir, } from "./runs-controls.js";
 import { deliverRunControl, } from "./runs-control-delivery.js";
 import { buildRunStatus, tailFile, } from "./runs-status.js";
 import { readJsonFileResilient } from "./state-readers.js";
@@ -576,57 +575,36 @@ function stopRun(runOrDir, signal, event, expected = {}) {
             status.run_instance_id !== expected.runInstanceId) {
             return { stopped: false, reason: "run generation changed", status };
         }
-        const control = event === "run.kill" && typeof status.run_instance_id === "string"
-            ? appendRunControlInStateDir(stateDir, {
-                action: "kill",
-                run_instance_id: status.run_instance_id,
-            })
-            : undefined;
-        if (control) {
-            updateRunControlStatusInStateDir(stateDir, control.id, "claimed", {}, ["queued"]);
-        }
-        const finish = (result) => {
-            if (!control)
-                return result;
-            const handled = result.stopped === true;
-            updateRunControlStatusInStateDir(stateDir, control.id, handled ? "handled" : "failed", handled ? {} : { error: String(result.reason ?? "kill rejected") }, ["claimed"]);
-            return { ...result, control_id: control.id };
-        };
         const pid = Number(status.pid || 0);
         if (status.status !== "running" && status.status !== "exited") {
-            return finish({ stopped: false, reason: "not running", status });
+            return { stopped: false, reason: "not running", status };
         }
         const identity = verifyRunProcessIdentity(pid, status.process_identity);
         if (status.status === "exited") {
             if (identity.status === "owner_mismatch" ||
                 identity.status === "unsupported_proof") {
-                return finish({
+                return {
                     stopped: false,
                     reason: identity.status.replaceAll("_", " "),
                     process_identity_status: identity.status,
                     status,
-                });
+                };
             }
-            return finish({ stopped: false, reason: "not running", status });
+            return { stopped: false, reason: "not running", status };
         }
         if (!identity.valid) {
-            return finish({
+            return {
                 stopped: false,
                 reason: identity.status.replaceAll("_", " "),
                 process_identity_status: identity.status,
                 status,
-            });
+            };
         }
         let signalResult;
         try {
             signalResult = signalOwnedRunProcess(pid, signal, status.process_identity);
         }
         catch (error) {
-            if (control) {
-                updateRunControlStatusInStateDir(stateDir, control.id, "failed", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
             throw error;
         }
         appendRunTraceEvent(stateDir, {
@@ -643,13 +621,13 @@ function stopRun(runOrDir, signal, event, expected = {}) {
             finalizeInterruptedExecution(stateDir, "cancelled", signal);
             markTerminalProgress(stateDir, "cancelled");
         }
-        return finish({
+        return {
             stopped: true,
             pid,
             signal,
             ...signalResult,
             state_dir: stateDir,
-        });
+        };
     }
     finally {
         releaseControlLock();

package/dist/lib/file-state.d.ts

@@ -12,5 +12,7 @@ export interface FileMutationLockOptions {
 }
 export declare function acquireFileMutationLock(path: string, options?: FileMutationLockOptions): () => void;
 export declare function withFileMutationLock<T>(path: string, mutate: () => T, options?: FileMutationLockOptions): T;
-export declare function writeTextAtomic(path: string, content: string): void;
+export declare function writeTextAtomic(path: string, content: string, options?: {
+    onBeforeReplace?(): void;
+}): void;
 export declare function writeJsonAtomic(path: string, value: unknown): void;

package/dist/lib/file-state.js

@@ -8,8 +8,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, parse, resolve } from "node:path";
-const FILE_MUTATION_LOCK_TIMEOUT_MS = process.platform === "win32" ? 15000 : 5000;
+const FILE_MUTATION_LOCK_TIMEOUT_MS = process.platform === "win32" ? 30000 : 15000;
 const FILE_MUTATION_LOCK_STALE_MS = 30000;
+const FILE_MUTATION_LOCK_RECLAIM_POLL_MS = 100;
+const FILE_MUTATION_LOCK_REMOVAL_GRACE_MS = 250;
+const FILE_MUTATION_LOCK_MAX_WAIT_MS = 50;
 const FILE_MUTATION_LOCK_ROOT = join(tmpdir(), "pi-actors-file-locks");
 function canonicalMutationPath(path) {
     const absolute = resolve(path);
@@ -65,7 +68,8 @@ function lockOwnerStatus(lockPath) {
             return "unknown";
         try {
             process.kill(pid, 0);
-            if (Date.now() - statSync(lockPath).mtimeMs > 50 && isZombieProcess(pid))
+            if (Date.now() - statSync(lockPath).mtimeMs > FILE_MUTATION_LOCK_REMOVAL_GRACE_MS &&
+                isZombieProcess(pid))
                 return "dead";
             return "alive";
         }
@@ -132,8 +136,10 @@ function tryReclaimRemovalBoundary(reclaimPath) {
     if (!existsSync(reclaimPath))
         return;
     try {
-        const inspectedToken = readLockToken(reclaimPath);
         const age = Date.now() - statSync(reclaimPath).mtimeMs;
+        if (age <= FILE_MUTATION_LOCK_REMOVAL_GRACE_MS)
+            return;
+        const inspectedToken = readLockToken(reclaimPath);
         const ownerStatus = lockOwnerStatus(reclaimPath);
         if ((ownerStatus === "dead" ||
             (ownerStatus === "unknown" && age > FILE_MUTATION_LOCK_STALE_MS)) &&
@@ -200,6 +206,8 @@ export function acquireFileMutationLock(path, options = {}) {
     const token = randomUUID();
     const pendingPath = prepareLockBoundary(lockPath, token, options.onBeforeLockPublish);
     let contentionReported = false;
+    let nextReclaimAt = 0;
+    let waitMs = 10;
     try {
         for (;;) {
             try {
@@ -211,13 +219,22 @@ export function acquireFileMutationLock(path, options = {}) {
                     contentionReported = true;
                     options.onContention?.();
                 }
-                tryReclaimMutationLock(lockPath, options);
-                if (Date.now() >= deadline) {
+                const now = Date.now();
+                if (now >= nextReclaimAt) {
+                    nextReclaimAt = now + FILE_MUTATION_LOCK_RECLAIM_POLL_MS;
+                    if (tryReclaimMutationLock(lockPath, options)) {
+                        waitMs = 10;
+                        continue;
+                    }
+                }
+                if (now >= deadline) {
                     throw new Error(`Timed out waiting for file mutation lock: ${canonicalMutationPath(path)}`, {
                         cause: error,
                     });
                 }
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+                const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(waitMs / 2)));
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs + jitter);
+                waitMs = Math.min(FILE_MUTATION_LOCK_MAX_WAIT_MS, waitMs + 5);
             }
         }
     }
@@ -256,11 +273,12 @@ export function withFileMutationLock(path, mutate, options = {}) {
         release();
     }
 }
-export function writeTextAtomic(path, content) {
+export function writeTextAtomic(path, content, options = {}) {
     mkdirSync(dirname(path), { recursive: true });
     const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
     try {
         writeFileSync(tempPath, content, "utf8");
+        options.onBeforeReplace?.();
         renameSync(tempPath, path);
     }
     catch (error) {

package/dist/lib/inspector-overlay.js

@@ -3,13 +3,17 @@
  * Zones: owned actor selection, Recipe/Trace/Control tabs, safe Run Kill confirmation
  * 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 { matchesKey, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
 import * as ActorInspector from "./inspector.js";
 import * as ControlProjection from "./control-projection.js";
 import * as RunsControls from "./runs-controls.js";
 import * as RunControlDelivery from "./runs-control-delivery.js";
+import * as RunsTrace from "./runs-trace.js";
+import * as Limits from "./limits.js";
+import { computeRunControlCapacity } from "./run-evidence-policy.js";
+import * as RuntimeTriage from "./runtime-triage.js";
 import * as TraceProjection from "./trace-projection.js";
 const TABS = ["recipe", "trace", "control"];
 const TRACE_SOURCES = [
@@ -21,9 +25,6 @@ const TRACE_SOURCES = [
     "artifact",
     "runtime",
 ];
-function newestTraceItems(items) {
-    return [...items].sort((left, right) => right.ts.localeCompare(left.ts) || right.id.localeCompare(left.id));
-}
 export class ActorInspectorOverlay {
     done;
     killRun;
@@ -410,7 +411,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}`,
             "",
@@ -501,8 +502,10 @@ export class ActorInspectorOverlay {
     }
     renderTraceList(run) {
         const items = this.traceItems(run);
+        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 [this.theme.fg("muted", " No Trace evidence")];
+            return [...banner, this.theme.fg("muted", " No Trace evidence")];
         if (this.selectedTraceId) {
             const selectedIndex = items.findIndex((item) => item.id === this.selectedTraceId);
             if (selectedIndex >= 0)
@@ -520,24 +523,24 @@ export class ActorInspectorOverlay {
         this.contentStripeIndices = items
             .slice(start, start + viewportRows)
             .map((_item, offset) => start + offset);
-        return items.slice(start, start + viewportRows).map((item, offset) => {
-            const index = start + offset;
-            const detail = item.detail && typeof item.detail === "object"
-                ? item.detail
-                : {};
-            const marker = item.level === "error"
-                ? this.theme.fg("error", "!")
-                : detail.attention
-                    ? this.theme.fg("warning", "A")
-                    : " ";
-            const prefix = this.focus === "list" && index === this.rowIndex
-                ? this.theme.fg("accent", " ▶ ")
-                : "   ";
-            const row = `${prefix}${this.theme.fg("text", `#${items.length - index}`)} ${marker} ${this.theme.fg("muted", item.source)}/${this.theme.fg(item.level === "error" ? "error" : "accent", item.kind)}  ${this.theme.fg("text", item.summary)}`;
-            return this.focus === "list" && index === this.rowIndex
-                ? this.theme.fg("accent", row)
-                : row;
-        });
+        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
+                    : {};
+                const marker = item.level === "error"
+                    ? this.theme.fg("error", "!")
+                    : detail.attention
+                        ? this.theme.fg("warning", "A")
+                        : " ";
+                const prefix = this.focus === "list" && index === this.rowIndex
+                    ? this.theme.fg("accent", " ▶ ")
+                    : "   ";
+                const row = `${prefix}${this.theme.fg("text", `#${items.length - index}`)} ${marker} ${this.theme.fg("muted", item.source)}/${this.theme.fg(item.level === "error" ? "error" : "accent", item.kind)}  ${this.theme.fg("text", item.summary)}`;
+                return this.focus === "list" && index === this.rowIndex
+                    ? this.theme.fg("accent", row)
+                    : row;
+            })];
     }
     renderTraceDetail(width) {
         if (!this.traceDetail)
@@ -553,16 +556,29 @@ 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((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)),
         };
     }
     allTraceItems(run) {
@@ -572,10 +588,10 @@ export class ActorInspectorOverlay {
             this.traceCache.runInstanceId === run.runInstanceId) {
             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/dist/lib/limits.d.ts

@@ -16,3 +16,13 @@ export declare const SESSION_EVIDENCE_TEXT_CHARS = 4000;
 export declare const SESSION_EVIDENCE_MAX_TOOL_CALLS = 100;
 export declare const TRACE_EVENT_MAX_BYTES: number;
 export declare const TRACE_EVENT_MAX_READ = 200;
+export declare const TRACE_JOURNAL_MAX_EVENTS = 2048;
+export declare const TRACE_JOURNAL_TARGET_EVENTS = 1536;
+export declare const TRACE_JOURNAL_MAX_BYTES: number;
+export declare const TRACE_JOURNAL_TARGET_BYTES: number;
+export declare const RUN_CONTROL_PENDING_LIMIT = 64;
+export declare const RUN_CONTROL_TERMINAL_LIMIT = 128;
+export declare const RUN_CONTROL_ERROR_MAX_BYTES: number;
+export declare const RUN_CONTROL_JOURNAL_MAX_BYTES: number;
+export declare const RUN_RETENTION_MAX_RECORDS = 256;
+export declare const RUN_RETENTION_MAX_BYTES: number;

package/dist/lib/limits.js

@@ -16,3 +16,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/dist/lib/observability.d.ts

@@ -42,7 +42,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>;
 }
@@ -62,6 +62,7 @@ export interface RunUiNotificationSink {
     }): void;
 }
 export declare function createRunUiObservationState(): RunUiObservationState;
+export declare function primeRunAttentionState(state: RunUiObservationState, ownerId: string, stateRoot?: string): void;
 export declare function readRunUiSnapshot(state: RunUiObservationState, ownerId: string, options?: {
     includeAttention?: boolean;
     stateRoot?: string;
@@ -74,6 +75,7 @@ export declare function reconcileRunTerminalNotifications(input: {
     sink: RunUiNotificationSink;
     state: RunUiObservationState;
     stateRoot?: string;
+    includeAttention?: boolean;
 }): RunUiSnapshot;
 export declare function deliverRunAttentionNotifications(events: RunAttentionEvent[], sink: RunUiNotificationSink): void;
 export interface RunRetirementCandidate {
@@ -173,7 +175,7 @@ export declare function findRunRetirementCandidates(summary: RunSummary): RunRet
 export declare function executeRunRetirements(summary: RunSummary, options: RunRetirementExecutorOptions): Promise<RunRetirementExecution[]>;
 export declare function detectRunTransitions(previous: Map<string, RunObservedStatus>, summary: RunSummary): RunTransition[];
 export declare function pruneRunObservationState(previousStatuses: Map<string, RunObservedStatus>, previousLineCounts: Map<string, number>, summary: RunSummary, terminalRuns?: Iterable<string>, seenEventIds?: Map<string, Set<string>>): void;
-export declare function detectRunAttentionEvents(previousLineCounts: Map<string, number>, summary: RunSummary, seenEventIds?: Map<string, Set<string>>): RunAttentionEvent[];
+export declare function detectRunAttentionEvents(legacyLineCounts: Map<string, number>, summary: RunSummary, seenEventIds?: Map<string, Set<string>>, prime?: boolean): RunAttentionEvent[];
 export declare function getRunAttentionNotificationType(event: RunAttentionEvent): RunTransitionNotificationType;
 export declare function shouldNotifyRunAttentionEvent(event: RunAttentionEvent): boolean;
 export declare function shouldSendRunAttentionFollowUp(event: RunAttentionEvent): boolean;

package/dist/lib/observability.js

@@ -7,29 +7,33 @@ import { closeSync, existsSync, fstatSync, openSync, readdirSync, readFileSync,
 import { basename, dirname, isAbsolute, join, relative, } from "node:path";
 import * as AsyncRuns from "./async-runs.js";
 import * as Paths from "./paths.js";
+import * as RunsTrace from "./runs-trace.js";
 import { readJsonlFileResilient } from "./state-readers.js";
 export function createRunUiObservationState() {
     return {
         attentionEventIds: new Map(),
-        eventLines: new Map(),
+        legacyEventLines: new Map(),
         frame: 0,
         observed: new Map(),
     };
 }
+export function primeRunAttentionState(state, ownerId, stateRoot) {
+    detectRunAttentionEvents(state.legacyEventLines, summarizeRuns(stateRoot, ownerId), state.attentionEventIds, true);
+}
 export function readRunUiSnapshot(state, ownerId, options = {}) {
     const summary = summarizeRuns(options.stateRoot, ownerId);
     const status = renderRunStatus(summary, state.frame++);
     return {
         attentionEvents: options.includeAttention === false
             ? []
-            : detectRunAttentionEvents(state.eventLines, summary, state.attentionEventIds),
+            : detectRunAttentionEvents(state.legacyEventLines, summary, state.attentionEventIds),
         status,
         summary,
         transitions: detectRunTransitions(state.observed, summary),
     };
 }
 export function pruneRunUiObservationState(state, snapshot) {
-    pruneRunObservationState(state.observed, state.eventLines, snapshot.summary, snapshot.transitions.map((transition) => transition.stateDir ?? transition.run), state.attentionEventIds);
+    pruneRunObservationState(state.observed, state.legacyEventLines, snapshot.summary, snapshot.transitions.map((transition) => transition.stateDir ?? transition.run), state.attentionEventIds);
 }
 export function deliverRunTransitionNotifications(transitions, sink, inFlight = new Set()) {
     for (const transition of transitions) {
@@ -68,9 +72,11 @@ export function deliverRunTransitionNotifications(transitions, sink, inFlight =
 }
 export function reconcileRunTerminalNotifications(input) {
     const snapshot = readRunUiSnapshot(input.state, input.ownerId, {
-        includeAttention: false,
+        includeAttention: input.includeAttention,
         stateRoot: input.stateRoot,
     });
+    if (input.includeAttention)
+        deliverRunAttentionNotifications(snapshot.attentionEvents, input.sink);
     deliverRunTransitionNotifications(snapshot.transitions, input.sink, input.inFlight);
     pruneRunUiObservationState(input.state, snapshot);
     return snapshot;
@@ -769,12 +775,13 @@ function parseAttentionRecord(raw, run, index) {
 }
 function readTraceAttentionRecords(run) {
     if (!run.stateDir)
-        return [];
-    const tracePath = join(run.stateDir, "trace.jsonl");
-    if (existsSync(tracePath)) {
-        return readJsonlFileResilient(tracePath).records;
-    }
-    return readJsonlFileResilient(join(run.stateDir, "outbox.jsonl")).records;
+        return { canonical: true, records: [] };
+    if (existsSync(join(run.stateDir, "trace.jsonl")))
+        return {
+            canonical: true,
+            records: RunsTrace.readRunTraceJournal(run.stateDir).events.map(({ event }) => event),
+        };
+    return { canonical: false, records: readJsonlFileResilient(join(run.stateDir, "outbox.jsonl")).records };
 }
 export function pruneRunObservationState(previousStatuses, previousLineCounts, summary, terminalRuns = [], seenEventIds = new Map()) {
     const activeRuns = new Set(summary.runs.map((run) => runObservationKey(run)));
@@ -785,43 +792,43 @@ export function pruneRunObservationState(previousStatuses, previousLineCounts, s
     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)) {
+    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)) {
+    for (const key of seenEventIds.keys())
+        if (terminalLineKeys.has(key) || !activeLineKeys.has(key))
             seenEventIds.delete(key);
-        }
-    }
 }
-export function detectRunAttentionEvents(previousLineCounts, summary, seenEventIds = new Map()) {
+export function detectRunAttentionEvents(legacyLineCounts, summary, seenEventIds = new Map(), prime = false) {
     const events = [];
     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());
-            continue;
-        }
-        const start = Math.min(previousCount, records.length);
+        const read = readTraceAttentionRecords(run);
+        const retained = new Set();
         const seen = seenEventIds.get(key) ?? new Set();
-        for (let index = start; index < records.length; index += 1) {
-            const event = parseAttentionRecord(records[index], run, index);
-            if (!event || seen.has(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;
-            events.push(event);
-            seen.add(event.id);
+            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;
 }