@llblab/pi-actors 0.43.1 → 0.45.0

package/lib/async-runs.ts

@@ -33,6 +33,7 @@ import {
 import * as Paths from "./paths.ts";
 import * as RecipesReferences from "./recipes-references.ts";
 import * as RecipesUsage from "./recipes-usage.ts";
+import * as Schema from "./schema.ts";
 import {
   resolveArtifactManifest,
   resolveArtifactPaths,
@@ -64,10 +65,6 @@ import * as RunsStart from "./runs-start.ts";
 import { appendRunTraceEvent } from "./runs-trace.ts";
 import * as RunsIndex from "./runs-index.ts";
 import * as RunsParentTeardown from "./runs-parent-teardown.ts";
-import {
-  appendRunControlInStateDir,
-  updateRunControlStatusInStateDir,
-} from "./runs-controls.ts";
 import {
   deliverRunControl,
   type DeliverRunControlOptions,
@@ -132,6 +129,8 @@ export interface AsyncRunStartParams {
   template?: CommandTemplateValue;
   args?: string[];
   defaults?: Record<string, unknown>;
+  recipe_dir?: string;
+  skill_dir?: string;
   parallel?: boolean;
   concurrency?: number | string;
   min_successful?: number | string;
@@ -313,7 +312,14 @@ function resolveStartParams(params: AsyncRunStartParams): AsyncRunStartParams {
       fileParams.run_id ||
       fileParams.name ||
       getRunIdFromFile(fileParams.file),
-    values: { ...(fileParams.values ?? {}), ...(params.values ?? {}) },
+    values: {
+      ...(fileParams.values ?? {}),
+      ...(params.values ?? {}),
+      ...(fileParams.recipe_dir
+        ? { recipe_dir: fileParams.recipe_dir }
+        : {}),
+      ...(fileParams.skill_dir ? { skill_dir: fileParams.skill_dir } : {}),
+    },
   };
 }
 
@@ -481,13 +487,37 @@ export function startRun(
     !isAbsolute(recipeRelation)
       ? dirname(packagedRecipeRoot)
       : undefined;
-  const values = {
-    ...(packagedRepo ? { repo: packagedRepo } : {}),
-    ...(startParams.values || {}),
-    run_id: run,
-    state_dir: stateDir,
-    trace_file: join(stateDir, "trace.jsonl"),
-  };
+  const argSpec = Schema.parseToolArgDeclarationList(startParams.args ?? []);
+  if (argSpec.error) throw new Error(argSpec.error);
+  const declaredArgs = new Set(argSpec.args);
+  for (const key of Object.keys(startParams.defaults ?? {})) {
+    if (declaredArgs.size > 0 && !declaredArgs.has(key))
+      throw new Error(`Unknown Recipe default argument: ${key}`);
+  }
+  const values = Schema.normalizeRuntimeValues(
+    {
+      ...argSpec.defaults,
+      ...(startParams.defaults || {}),
+      ...(packagedRepo ? { repo: packagedRepo } : {}),
+      ...(startParams.values || {}),
+      run_id: run,
+      state_dir: stateDir,
+      trace_file: join(stateDir, "trace.jsonl"),
+    },
+    argSpec.argTypes,
+  );
+  const runtimeTemplate =
+    resolved.template &&
+    typeof resolved.template === "object" &&
+    !Array.isArray(resolved.template)
+      ? {
+          ...resolved.template,
+          defaults: {
+            ...(resolved.template.defaults ?? {}),
+            ...values,
+          },
+        }
+      : resolved.template;
   const modelPolicy = describeCurrentPolicyProvenance({
     defaults: startParams.defaults,
     template: resolved.template,
@@ -561,7 +591,7 @@ export function startRun(
       state_schema: RuntimeIdentity.RUN_STATE_SCHEMA,
       status: "running",
       ...(startParams.tool ? { tool: startParams.tool } : {}),
-      template: resolved.template,
+      template: runtimeTemplate,
       values,
       model_policy: modelPolicy,
       ...(artifacts ? { artifacts } : {}),
@@ -933,37 +963,9 @@ function stopRun(
     ) {
       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: Record<string, unknown>): Record<string, unknown> => {
-      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,
@@ -974,22 +976,22 @@ function stopRun(
         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: RunProcessSignalPlan;
     try {
@@ -999,11 +1001,6 @@ function stopRun(
         status.process_identity as RunProcessIdentity,
       );
     } catch (error) {
-      if (control) {
-        updateRunControlStatusInStateDir(stateDir, control.id, "failed", {
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
       throw error;
     }
     appendRunTraceEvent(stateDir, {
@@ -1020,13 +1017,13 @@ function stopRun(
       finalizeInterruptedExecution(stateDir, "cancelled", signal);
       markTerminalProgress(stateDir, "cancelled");
     }
-    return finish({
+    return {
       stopped: true,
       pid,
       signal,
       ...signalResult,
       state_dir: stateDir,
-    });
+    };
   } finally {
     releaseControlLock();
   }

package/lib/config.ts

@@ -188,6 +188,10 @@ export function normalizeStoredTool(
           template: argTemplate,
         };
   const inferredArgTypes = Schema.getTemplateArgTypes(argTemplateConfig);
+  Schema.assertCompatibleToolArgTypes(
+    inferredArgTypes,
+    declarations.argTypes,
+  );
   const argTypes = { ...inferredArgTypes, ...declarations.argTypes };
   const cfg = {
     name,

package/lib/file-state.ts

@@ -10,8 +10,11 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSyn
 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: string): string {
@@ -65,7 +68,8 @@ function lockOwnerStatus(lockPath: string): "alive" | "dead" | "unknown" {
     if (!Number.isInteger(pid) || pid <= 0) return "unknown";
     try {
       process.kill(pid, 0);
-      if (Date.now() - statSync(lockPath).mtimeMs > 50 && isZombieProcess(pid)) return "dead";
+      if (Date.now() - statSync(lockPath).mtimeMs > FILE_MUTATION_LOCK_REMOVAL_GRACE_MS &&
+          isZombieProcess(pid)) return "dead";
       return "alive";
     } catch (error) {
       return (error as NodeJS.ErrnoException).code === "ESRCH"
@@ -120,8 +124,9 @@ function removeLockBoundary(lockPath: string, token: string | undefined): boolea
 function tryReclaimRemovalBoundary(reclaimPath: string): void {
   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" ||
@@ -195,6 +200,8 @@ export function acquireFileMutationLock(
   const token = randomUUID();
   const pendingPath = prepareLockBoundary(lockPath, token, options.onBeforeLockPublish);
   let contentionReported = false;
+  let nextReclaimAt = 0;
+  let waitMs = 10;
   try {
     for (;;) {
       try {
@@ -205,13 +212,22 @@ export function acquireFileMutationLock(
           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);
       }
     }
   } finally {
@@ -251,11 +267,16 @@ export function withFileMutationLock<T>(
   }
 }
 
-export function writeTextAtomic(path: string, content: string): void {
+export function writeTextAtomic(
+  path: string,
+  content: string,
+  options: { onBeforeReplace?(): void } = {},
+): void {
   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) {
     try {

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/inspector.ts

@@ -105,9 +105,22 @@ export function readActorInspectorRecipe(
   const redactedRecord = (value: Record<string, unknown>): Record<string, unknown> =>
     SessionEvidence.redactSessionEvidenceValue(
       Object.fromEntries(
-        Object.entries(value).filter(([, entry]) => entry !== undefined),
+        Object.entries(value).filter(
+          ([key, entry]) =>
+            entry !== undefined &&
+            key !== "recipe_dir" &&
+            key !== "skill_dir",
+        ),
       ),
     ) as Record<string, unknown>;
+  const launchValues =
+    meta.values && typeof meta.values === "object" && !Array.isArray(meta.values)
+      ? Object.fromEntries(
+          Object.entries(meta.values as Record<string, unknown>).filter(
+            ([key]) => key !== "recipe_dir" && key !== "skill_dir",
+          ),
+        )
+      : meta.values;
   return {
     composition: contexts.map((entry) =>
       redactedRecord({
@@ -116,6 +129,7 @@ export function readActorInspectorRecipe(
         file: entry.file,
         import_path: entry.import_path,
         name: entry.name,
+        qualified_name: entry.qualified_name,
       }),
     ),
     ...(definition ? { definition: redactedRecord(definition) } : {}),
@@ -129,7 +143,7 @@ export function readActorInspectorRecipe(
     launch: redactedRecord({
       cwd: meta.cwd,
       template: meta.template,
-      values: meta.values,
+      values: launchValues,
       model_policy: meta.model_policy,
       control: meta.control,
       artifacts: meta.artifacts,

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;
 }