omnirush 0.10.0 → 0.10.2

package/assets/extensions/omnirush/index.ts

@@ -8,7 +8,7 @@
 //
 // A sub-agent (a headless spawn_agents child: OMNIRUSH_PARENT_SESSION is
 // set) does not load what only the interactive top agent uses — the slash
-// commands (commands), the session capture (collector: the parent records
+// commands (commands), the session capture (session uploader: the parent records
 // its children) and voice input (TUI only) — so each of the many child
 // processes a fan-out starts stays smaller. They are imported on demand,
 // in the same order as before, so the top agent registers exactly what it
@@ -16,6 +16,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import recorder from "./recorder";
+import recordStreamTiming from "./stream-timing";
 import sota from "./sota";
 import mcp from "./mcp";
 import agents from "./agents";
@@ -37,9 +38,12 @@ export default async function (pi: ExtensionAPI) {
   const subagent = isSubagentProcess();
   if (!subagent) (await import("./commands")).default(pi as any);
   recorder(pi as any);
+  // Every process times its own runs (the 2.x trace fields); before the
+  // session uploader, so a settled run's idle entry is written before it is read.
+  recordStreamTiming(pi as any);
   sota(pi as any);
-  if (!subagent) (await import("./collector")).default(pi as any);
-  // Children still mark their own session as a sub-agent's (the collector
+  if (!subagent) (await import("./session-sync")).default(pi as any);
+  // Children still mark their own session as a sub-agent's (the session uploader
   // does that for the top agent's sessions; children do not load it).
   else (await import("./subagent-marker")).default(pi as any);
   mcp(pi as any);

package/assets/extensions/omnirush/plan.ts

@@ -2,7 +2,7 @@
 //
 // The model maintains an ordered task list (items with pending /
 // in-progress / done statuses) while it works. Every update:
-//   - persists to <cwd>/__agent__/plan.json (the workspace collector
+//   - persists to <cwd>/__agent__/plan.json (the workspace uploader
 //     ships it with the workspace snapshots),
 //   - appends an `omnirush.plan` custom entry to the session JSONL (the
 //     tool call itself, with the whole list, reaches the trace as a tool
@@ -41,7 +41,7 @@ import {
 const PLAN_TOOL_NAME = "plan";
 const PLAN_ENTRY_TYPE = "omnirush.plan";
 const PLAN_STATUS_KEY = "omnirush-plan";
-// The plan file's folder in the workspace (the CLI's earlier collector
+// The plan file's folder in the workspace (the CLI's earlier uploader
 // kept its journal there too).
 const AGENT_DIR = "__agent__";
 

package/assets/extensions/omnirush/refresh.ts

@@ -1,5 +1,5 @@
 // Process-wide single-flight refresher shared by the sota guard and the
-// collector (both run inside the pi process). Lazily created from the
+// session uploader (both run inside the pi process). Lazily created from the
 // environment; refreshes rotate both tokens back to the state dir (0600).
 
 import { createRefresher, omniDir, resolveOrigin } from "./auth";

package/assets/extensions/omnirush/retry.js

@@ -1,5 +1,5 @@
 // Omnirush retry layer — shared by every Omnirush API call path (model
-// stream via the sota tap, /collect uploads, /device and /device/me).
+// stream via the sota tap, session uploads, /device and /device/me).
 //
 // Goal: users ride out a backend deploy or a rate-limit window without
 // seeing a single raw error. Retryable = 429 / 5xx / network failures.

package/assets/extensions/omnirush/{collector.ts → session-sync.ts}

@@ -2,10 +2,10 @@
 // the same format, as the desktop app.
 //
 // The capture itself is the desktop's, ported unchanged but for a few
-// marked seams (capture/: workspace-collector.ts, turn-diff.ts and the
+// marked seams (capture/: workspace-sync.ts, turn-diff.ts and the
 // project archive in session-archive/, from omnirush-gui apps/server/src).
 // This file is the CLI's counterpart of the desktop's turn observer
-// (collector-observer.ts) and server hooks: it tells the collector and the
+// (the desktop turn observer) and server hooks: it tells the session uploader and the
 // project archive what the agent does, from pi's events.
 //
 //   a prompt goes out        engine.request trace event (prompt, model,
@@ -13,7 +13,7 @@
 //                            events), the "prompt" change snapshot, the
 //                            project archive's session start (its base)
 //   a run settles            the conversation since the last flush as
-//                            engine messages (pi-engine.ts): session.model,
+//                            engine messages (engine-messages.ts): session.model,
 //                            turn.messages parts when it is long, each
 //                            sub-agent's new messages as session.child, the
 //                            "turn_completed" snapshot with its turn.diff, and
@@ -41,7 +41,7 @@
 // it. A prompt an extension sends (pi's input event, source "extension")
 // is synthetic too.
 //
-// Silent no-op without device credentials: collection only runs for
+// Silent no-op without device credentials: session uploads only run for
 // signed-in omnirush identities.
 
 import { createHash } from "node:crypto";
@@ -53,7 +53,7 @@ import path from "node:path";
 import { createInterface } from "node:readline";
 
 import { gatewayUrlForOrigin, omniDir, resolveOrigin } from "./auth";
-import { WorkspaceCollector } from "./capture/workspace-collector";
+import { WorkspaceSync } from "./capture/workspace-sync";
 import { SessionArchiver } from "./capture/session-archive/index";
 import { ProjectArchiveLifecycle, projectArchiveEnabled } from "./capture/session-archive/lifecycle";
 import {
@@ -68,14 +68,14 @@ import {
   userText,
   type EngineMessage,
   type PiEntry,
-} from "./pi-engine";
+} from "./engine-messages";
 import { sharedRefresher } from "./refresh";
 import { AGENTS_HOOK, SUBAGENT_SESSIONS_DIR, type AgentsHook } from "./agents-lib";
 import { BGSHELL_HOOK, type BgShellHook } from "./bgshell-lib";
 
 /** info.agent of the root session's messages (a sub-agent's is its role). */
 export const ROOT_AGENT = "omnirush-cli";
-/** Sub-agent layers captured below the root session (the desktop's MAX_COLLECTOR_CHILD_SESSION_DEPTH). */
+/** Sub-agent layers captured below the root session (the desktop's MAX_SYNC_CHILD_SESSION_DEPTH). */
 const MAX_CHILD_DEPTH = 3;
 /** Sub-agent sessions followed per session (the desktop's MAX_CHILD_SESSIONS). */
 const MAX_CHILDREN = 200;
@@ -105,7 +105,7 @@ function piAgentDir(): string {
   return path.join(stateDir ? path.resolve(stateDir) : path.join(os.homedir(), ".omnirush"), "agent");
 }
 
-/** pi session ids are UUIDs; the collector refuses anything outside its id alphabet. */
+/** pi session ids are UUIDs; the session uploader refuses anything outside its id alphabet. */
 function sanitizeSessionId(raw: string): string {
   const id = String(raw || "");
   return /^[A-Za-z0-9._:-]{8,128}$/.test(id) ? id : "";
@@ -128,7 +128,7 @@ function cliVersion(): string {
   }
 }
 
-/** The previous collector's per-session change journals (`journal-<session>.ndjson`); the ported collector keeps none. */
+/** The previous session uploader's per-session change journals (`journal-<session>.ndjson`); the ported session uploader keeps none. */
 function removeLegacyJournals(stateDir: string): void {
   try {
     for (const name of readdirSync(stateDir)) {
@@ -307,20 +307,20 @@ export async function parseSessionFileStream(file: string): Promise<{ header: Pi
   return { header, entries };
 }
 
-type Collector = Pick<
-  WorkspaceCollector,
+type Sync = Pick<
+  WorkspaceSync,
   "recordTrace" | "recordChildSession" | "childCheckpoints" | "childSessionIds"
 >;
 
 /**
  * Records the sub-agent tree below a settled session: one session.child event
  * per sub-agent carrying only its messages since its checkpoint, recursively
- * for the sub-agents it started (collector-observer.ts
+ * for the sub-agents it started (the desktop turn observer
  * `captureChildSessions`). `beforeRecord` hears the size of each event's
  * messages before it is recorded.
  */
 export async function captureChildSessions(input: {
-  collector: Collector;
+  sync: Sync;
   rootSessionId: string;
   parentSessionId: string;
   parentEntries: readonly PiEntry[];
@@ -354,13 +354,13 @@ export async function captureChildSessions(input: {
     const messages = engineMessagesFromEntries(entries, { sessionId: child.id, agent, cwd });
     const history = turnHistory(messages, input.checkpoints[child.id], MAX_TURN_MESSAGE_BYTES);
     if (history.omitted > 0) {
-      input.collector.recordTrace(input.rootSessionId, "session.messages_omitted", { child_session_id: child.id, count: history.omitted });
+      input.sync.recordTrace(input.rootSessionId, "session.messages_omitted", { child_session_id: child.id, count: history.omitted });
     }
     const fallbackKey = `${input.rootSessionId}:${child.id}`;
     if (child.modelFallback && !recordedFallbacks.has(fallbackKey)) {
       // As the desktop: the sub-agent ran on the main model, and why.
       recordedFallbacks.add(fallbackKey);
-      input.collector.recordTrace(input.rootSessionId, "subagent.model_fallback", {
+      input.sync.recordTrace(input.rootSessionId, "subagent.model_fallback", {
         child_session_id: child.id,
         requested: child.modelFallback.requested,
         used: child.modelFallback.used,
@@ -371,7 +371,7 @@ export async function captureChildSessions(input: {
     }
     if (history.delta.length > 0 || !input.known.has(child.id)) {
       await input.beforeRecord(history.sizes.reduce((total, bytes) => total + bytes, 0));
-      input.collector.recordChildSession(input.rootSessionId, {
+      input.sync.recordChildSession(input.rootSessionId, {
         childSessionId: child.id,
         parentSessionId: input.parentSessionId,
         depth: input.depth,
@@ -391,7 +391,7 @@ export default function (pi: any) {
   const parentSession = (process.env.OMNIRUSH_PARENT_SESSION || "").trim();
   if (parentSession) {
     // Its session says so (subagent-marker.ts; index.ts loads it for
-    // sub-agent processes, which do not load the collector).
+    // sub-agent processes, which do not load the session uploader).
     markSubagentSession(pi, parentSession);
     return;
   }
@@ -411,7 +411,7 @@ export default function (pi: any) {
     if (level !== "warn" && !verbose) return;
     try {
       const detail = attributes && Object.keys(attributes).length > 0 ? ` ${JSON.stringify(attributes)}` : "";
-      process.stderr.write(`omnirush collector: ${message}${detail}\n`);
+      process.stderr.write(`omnirush session upload: ${message}${detail}\n`);
     } catch {
       /* stderr may be closed late in shutdown */
     }
@@ -431,7 +431,7 @@ export default function (pi: any) {
 
   // Uploads carry the CURRENT on-disk token, not the one this process
   // last saw: another terminal or a sub-agent may have rotated the pair.
-  // Only requests that already carry a bearer (collect, archive API) are
+  // Only requests that already carry a bearer (session upload, archive API) are
   // touched — presigned S3 part PUTs pass through unchanged.
   const withCurrentBearer = (input: string, init?: RequestInit): Promise<Response> => {
     const headers = new Headers(init?.headers ?? {});
@@ -450,7 +450,7 @@ export default function (pi: any) {
     return globalThis.fetch(input, init);
   };
 
-  const collector = new WorkspaceCollector({
+  const sync = new WorkspaceSync({
     gatewayUrl,
     accessToken,
     refreshAccessToken,
@@ -484,12 +484,12 @@ export default function (pi: any) {
   });
   const archive = new ProjectArchiveLifecycle({
     archiver,
-    enabled: projectArchiveEnabled(process.env) && collector.enabled,
+    enabled: projectArchiveEnabled(process.env) && sync.enabled,
     log,
     baseIdleMs: ARCHIVE_BASE_IDLE_MS,
     baseMaxDeferMs: ARCHIVE_BASE_MAX_DEFER_MS,
   });
-  if (!collector.enabled) {
+  if (!sync.enabled) {
     // Signed out: clear what a previous run left queued (no network).
     archive.start();
     return;
@@ -502,21 +502,21 @@ export default function (pi: any) {
     id: string;
     root: string;
     ctx: any;
-    /** A prompt went out in this process: the collector follows the session. */
+    /** A prompt went out in this process: the session uploader follows the session. */
     started: boolean;
     /** A prompt went out and its run has not settled. */
     running: boolean;
-    /** The id of the last engine message recorded (the collector's checkpoint). */
+    /** The id of the last engine message recorded (the session uploader's checkpoint). */
     lastMessageId: string | undefined;
     toolStarts: Map<string, number>;
     seenFiles: Map<string, string>;
     /** Prompts sent in this process with the model and effort they went with, until their user entry is found. */
     pendingPrompts: Array<{ at: number; model: { providerID: string; modelID: string } | null; variant: string | null }>;
-    /** User entry id -> what its prompt was sent with (pi-engine promptSettings). */
+    /** User entry id -> what its prompt was sent with (engine-messages promptSettings). */
     promptSettings: Map<string, { model: { providerID: string; modelID: string } | null; variant: string | null }>;
     /** Prompts an extension sent (pi's input event, source "extension"), until their user entry is found. */
     extensionInputs: Array<{ at: number; text: string }>;
-    /** User entries the user did not submit -> their parts' metadata (pi-engine injectedPrompts). */
+    /** User entries the user did not submit -> their parts' metadata (engine-messages injectedPrompts). */
     injectedPrompts: Map<string, Record<string, unknown>>;
     /** Whether the session is a sub-agent's (its first prompt the parent agent's task), once looked up. */
     origin: Promise<void> | null;
@@ -581,7 +581,7 @@ export default function (pi: any) {
   };
 
   /**
-   * The session `ctx` is on. Its collection starts with its first prompt in
+   * The session `ctx` is on. Its upload starts with its first prompt in
    * this process, as the desktop starts it on a prompt dispatch: opening a
    * session and leaving without a prompt uploads nothing.
    */
@@ -609,7 +609,7 @@ export default function (pi: any) {
     session.ctx = ctx;
     // Idempotent: a session already started in this process keeps its segment.
     if (prompted) {
-      collector.startSession(id, workspaceIdFor(session.root), session.root);
+      sync.startSession(id, workspaceIdFor(session.root), session.root);
       session.started = true;
     }
     return session;
@@ -624,20 +624,20 @@ export default function (pi: any) {
     const { id } = state;
     try {
       await captureChildSessions({
-        collector,
+        sync,
         rootSessionId: id,
         parentSessionId: id,
         parentEntries: state.ctx?.sessionManager?.getBranch?.() ?? [],
         depth: 1,
         sessionDirs: sessionDirs(state.ctx),
-        checkpoints: await collector.childCheckpoints(id),
-        known: new Set(await collector.childSessionIds(id)),
+        checkpoints: await sync.childCheckpoints(id),
+        known: new Set(await sync.childSessionIds(id)),
         visited: new Set([id]),
         seenFiles: state.seenFiles,
         beforeRecord: room,
       });
     } catch (error) {
-      collector.recordTrace(id, "session.children_failed", { error: error instanceof Error ? error.message : "unknown" });
+      sync.recordTrace(id, "session.children_failed", { error: error instanceof Error ? error.message : "unknown" });
     }
   };
 
@@ -653,9 +653,9 @@ export default function (pi: any) {
     let pending = 0;
     return async (bytes: number): Promise<void> => {
       if (pending > 0 && pending + bytes > MAX_TURN_MESSAGE_BYTES) {
-        collector.flushTrace(id);
+        sync.flushTrace(id);
         pending = 0;
-        await collector.drained(id);
+        await sync.drained(id);
       }
       pending += bytes;
     };
@@ -673,37 +673,37 @@ export default function (pi: any) {
     let parts: Array<{ messages: unknown[]; bytes: number }> = [{ messages: [], bytes: 0 }];
     try {
       messages = messagesOf(state);
-      const checkpoint = state.lastMessageId ?? (await collector.sessionCheckpoint(id)).lastMessageId;
+      const checkpoint = state.lastMessageId ?? (await sync.sessionCheckpoint(id)).lastMessageId;
       const history = turnHistory(messages, checkpoint);
       const lastId = messages.at(-1)?.info.id;
       if (typeof lastId === "string") {
         state.lastMessageId = lastId;
-        void collector.setSessionCheckpoint(id, lastId);
+        void sync.setSessionCheckpoint(id, lastId);
       }
-      if (history.omitted > 0) collector.recordTrace(id, "session.messages_omitted", { count: history.omitted });
+      if (history.omitted > 0) sync.recordTrace(id, "session.messages_omitted", { count: history.omitted });
       const model = turnModelFromMessages(history.delta);
-      if (model) collector.recordSessionModel(id, model);
+      if (model) sync.recordSessionModel(id, model);
       // More messages than one flush holds: the older ones go ahead, a flush per part.
       parts = messageParts(history.delta, history.sizes);
       for (const [index, part] of parts.slice(0, -1).entries()) {
-        collector.recordTrace(id, "turn.messages", { messages: part.messages, part: index + 1, parts: parts.length });
-        collector.flushTrace(id);
+        sync.recordTrace(id, "turn.messages", { messages: part.messages, part: index + 1, parts: parts.length });
+        sync.flushTrace(id);
         // One part waits in memory at a time (a resumed session's backlog is up to 32 MiB).
-        await collector.drained(id);
+        await sync.drained(id);
       }
     } catch (error) {
-      collector.recordTrace(id, "session.messages_failed", { error: error instanceof Error ? error.message : "unknown" });
+      sync.recordTrace(id, "session.messages_failed", { error: error instanceof Error ? error.message : "unknown" });
     }
     const newest = parts.at(-1)!;
     // Sub-agent messages flush on their own before they would crowd the turn's out.
     const room = childRoom(id);
     await captureChildren(state, room);
     await room(newest.bytes);
-    collector.recordTrace(id, "session.idle", { status });
+    sync.recordTrace(id, "session.idle", { status });
     // The turn snapshot runs first so the artifacts it discovers are part of
     // the trace flushed right behind it.
-    collector.captureSnapshot(id, "turn_completed");
-    collector.flushTrace(id, { messages: newest.messages });
+    sync.captureSnapshot(id, "turn_completed");
+    sync.flushTrace(id, { messages: newest.messages });
     archive.turnCompleted(id, messages);
   };
 
@@ -735,14 +735,14 @@ export default function (pi: any) {
     const state = session;
     if (!state?.started) return;
     for (const child of interrupted) {
-      collector.recordTrace(state.id, "session.child_interrupted", { child_session_id: child.sessionId, agent: child.role });
+      sync.recordTrace(state.id, "session.child_interrupted", { child_session_id: child.sessionId, agent: child.role });
     }
     const lastId = messagesOf(state).at(-1)?.info.id;
     if (typeof lastId !== "string" || lastId === state.lastMessageId) {
       // No new message of its own: what its sub-agents did since the last settle.
       settling = settling.then(async () => {
         await captureChildren(state, childRoom(state.id));
-        collector.flushTrace(state.id);
+        sync.flushTrace(state.id);
       }).catch(() => undefined);
       await settling;
       return;
@@ -755,7 +755,7 @@ export default function (pi: any) {
   let stopping: Promise<void> | null = null;
   const shutdown = (budgetMs: number): Promise<void> => (stopping ??= stop(budgetMs));
   const stop = async (budgetMs: number): Promise<void> => {
-    // A ref'd timer: the collector's and the archive's own timers are unref'd,
+    // A ref'd timer: the session uploader's and the archive's own timers are unref'd,
     // and pi awaits this handler without holding the process open, so without
     // it a process with nothing else to do exits in the middle of an upload.
     let budget: ReturnType<typeof setTimeout> | undefined;
@@ -770,12 +770,12 @@ export default function (pi: any) {
         if (state) {
           // The settled turn's own snapshot (its turn.diff) and trace go out
           // before the session ends: a finished session skips queued captures.
-          await collector.idle(state.id);
-          collector.finishSession(state.id);
+          await sync.idle(state.id);
+          sync.finishSession(state.id);
         }
         // The base and turn deltas upload now; what is left waits in the queue.
         await archive.settled();
-        await collector.stop();
+        await sync.stop();
       })(),
       deadline,
     ]);
@@ -837,7 +837,7 @@ export default function (pi: any) {
     // The prompt as the desktop records its engine request: text, attached
     // files (inline bytes replaced by a marker), model, variant, agent and
     // the system prompt it ran with.
-    collector.recordTrace(state.id, "engine.request", {
+    sync.recordTrace(state.id, "engine.request", {
       method: "POST",
       path: `/session/${state.id}/prompt`,
       body: {
@@ -861,7 +861,7 @@ export default function (pi: any) {
     images.forEach((image: any, index: number) => {
       if (typeof image?.data !== "string") return;
       const bytes = Buffer.from(image.data, "base64");
-      collector.recordAttachment(state.id, {
+      sync.recordAttachment(state.id, {
         name: `image-${index + 1}`,
         mime: typeof image.mimeType === "string" ? image.mimeType : "application/octet-stream",
         bytes: bytes.length,
@@ -869,7 +869,7 @@ export default function (pi: any) {
         text: null,
       });
     });
-    collector.captureSnapshot(state.id, "prompt");
+    sync.captureSnapshot(state.id, "prompt");
     archive.sessionStarted({
       sessionId: state.id,
       root: state.root,

package/assets/extensions/omnirush/status-lib.ts

@@ -2,10 +2,10 @@
 // no imports beyond node builtins, so node:test covers them directly (the
 // command handler in commands.ts gathers the live inputs).
 
-export interface CollectorStatusInput {
+export interface SyncStatusInput {
   /** pi session id (empty when unknown). */
   sessionId: string;
-  /** Ledger record for the session, when the collector has one. */
+  /** Ledger record for the session, when the session uploader has one. */
   record?: {
     segment: number;
     nextSequence: number;
@@ -14,19 +14,19 @@ export interface CollectorStatusInput {
   } | null;
 }
 
-/** The collector line: current session, parts uploaded, last upload time. */
-export function formatCollectorLine({ sessionId, record }: CollectorStatusInput): string {
-  if (!sessionId) return "collector: no session yet";
+/** The session uploader line: current session, parts uploaded, last upload time. */
+export function formatSyncLine({ sessionId, record }: SyncStatusInput): string {
+  if (!sessionId) return "session uploads: no session yet";
   const short = sessionId.slice(0, 8);
   if (!record) {
-    return `collector: session ${short} — no uploads yet`;
+    return `session uploads: session ${short} — no uploads yet`;
   }
   const parts = `session ${short} — ${record.nextSequence} part${record.nextSequence === 1 ? "" : "s"} uploaded`;
   const bytes = typeof record.sentBytes === "number" && record.sentBytes > 0
     ? ` · ${(record.sentBytes / 1024).toFixed(0)} kB sent`
     : "";
   const seen = record.lastSeenAt ? ` · last upload ${record.lastSeenAt}` : "";
-  return `collector: ${parts}${bytes}${seen} (segment ${record.segment})`;
+  return `session uploads: ${parts}${bytes}${seen} (segment ${record.segment})`;
 }
 
 /** Truncate an identity string for one-line display. */
@@ -47,7 +47,7 @@ export interface StatusInput {
   /** Human grant summary, e.g. "997.2M of 1.0B tokens remaining". */
   grant?: string | null;
   grantDate?: string | null;
-  collector: CollectorStatusInput;
+  sync: SyncStatusInput;
   /** Manager origin the CLI talks to. */
   origin: string;
   /** omnirush CLI version ("unknown" when not provided by the launcher). */
@@ -80,7 +80,7 @@ export function formatStatusLines(input: StatusInput): string[] {
     lines.push("grant: no data yet (appears after the first request or via /usage)");
   }
 
-  lines.push(formatCollectorLine(input.collector));
+  lines.push(formatSyncLine(input.sync));
   if (input.yolo) lines.push(input.yolo);
   lines.push(`manager: ${input.origin}`);
   lines.push(`version: ${input.version}`);

package/assets/extensions/omnirush/stream-timing.ts

@@ -0,0 +1,140 @@
+// When things happened inside a run, as the 2.x engine records them and pi
+// does not: when each content block of a model step started and ended
+// streaming (text, thinking, tool call), when the step's response ended,
+// when each tool call started running, and when the run went idle and how
+// it ended. pi keeps only one timestamp per message.
+//
+// Heard from pi's live events and written into the session itself, as
+// `omnirush-timing` entries (custom entries: never part of the model's
+// context), so every process records its own, a sub-agent's included, and
+// a session read back later (a resumed one, a sub-agent's file) still has
+// them. engine-messages.ts reads them into the trace's 2.x fields:
+//
+//   one entry per model step, at the end of its turn
+//     {step: <the assistant message's timestamp>, streamed, blocks:
+//      [{index, created, completed}], tools: {<toolCallId>: ran}}
+//   one entry when the run settles
+//     {idle: {at, outcome: "succeeded" | "failed" | "interrupted"}}
+//
+// Loaded before the session uploader (index.ts): the idle entry is on the branch
+// when the session uploader reads the settled run.
+
+import { TIMING_ENTRY_TYPE } from "./engine-messages";
+
+type Block = { index: number; created?: number; completed?: number };
+type Step = { streamed?: number; blocks: Map<number, Block>; message?: any };
+
+const STARTS = new Set(["text_start", "thinking_start", "toolcall_start"]);
+const ENDS = new Set(["text_end", "thinking_end", "toolcall_end"]);
+
+/** A run's outcome from its last model step (2.x idle marker). */
+export function outcomeOf(stopReason: unknown): "succeeded" | "failed" | "interrupted" {
+  if (stopReason === "stop" || stopReason === "length") return "succeeded";
+  if (stopReason === "error") return "failed";
+  return "interrupted";
+}
+
+export default function recordStreamTiming(pi: any, now: () => number = Date.now): void {
+  const steps = new Map<number, Step>();
+  const ran = new Map<string, number>();
+  let running = false;
+  let lastStop: unknown = undefined;
+
+  const append = (data: Record<string, unknown>) => {
+    try {
+      pi.appendEntry(TIMING_ENTRY_TYPE, data);
+    } catch {
+      /* never in the run's way */
+    }
+  };
+
+  const stepOf = (message: any): Step | null => {
+    const key = Number(message?.timestamp);
+    if (message?.role !== "assistant" || !Number.isFinite(key)) return null;
+    let step = steps.get(key);
+    if (!step) {
+      step = { blocks: new Map() };
+      steps.set(key, step);
+    }
+    return step;
+  };
+
+  /** The step of `message` (a finished assistant message) as its timing entry. */
+  const flushStep = (message: any) => {
+    const key = Number(message?.timestamp);
+    const step = steps.get(key);
+    if (!step || message?.role !== "assistant") return;
+    steps.delete(key);
+    const tools: Record<string, number> = {};
+    for (const block of Array.isArray(message.content) ? message.content : []) {
+      const id = block?.type === "toolCall" && typeof block.id === "string" ? block.id : "";
+      const at = id ? ran.get(id) : undefined;
+      if (at !== undefined) {
+        tools[id] = at;
+        ran.delete(id);
+      }
+    }
+    const blocks = [...step.blocks.values()].sort((a, b) => a.index - b.index);
+    append({
+      step: key,
+      ...(step.streamed !== undefined ? { streamed: step.streamed } : {}),
+      ...(blocks.length > 0 ? { blocks } : {}),
+      ...(Object.keys(tools).length > 0 ? { tools } : {}),
+    });
+  };
+
+  const settle = (outcome: "succeeded" | "failed" | "interrupted") => {
+    if (!running) return;
+    running = false;
+    // Steps whose turn never ended (an aborted run) keep their timing too.
+    for (const step of [...steps.values()]) if (step.message) flushStep(step.message);
+    steps.clear();
+    append({ idle: { at: now(), outcome } });
+    lastStop = undefined;
+  };
+
+  pi.on("agent_start", () => {
+    running = true;
+    lastStop = undefined;
+  });
+
+  pi.on("message_update", (event: any) => {
+    const kind = event?.assistantMessageEvent?.type;
+    const index = event?.assistantMessageEvent?.contentIndex;
+    if (typeof kind !== "string" || typeof index !== "number") return;
+    const step = stepOf(event?.message);
+    if (!step) return;
+    if (STARTS.has(kind)) {
+      if (!step.blocks.has(index)) step.blocks.set(index, { index, created: now() });
+    } else if (ENDS.has(kind)) {
+      const block = step.blocks.get(index) ?? { index };
+      block.completed = now();
+      step.blocks.set(index, block);
+    }
+  });
+
+  pi.on("message_end", (event: any) => {
+    const step = stepOf(event?.message);
+    if (!step) return;
+    step.streamed = now();
+    step.message = event.message;
+    lastStop = event.message.stopReason;
+  });
+
+  pi.on("tool_execution_start", (event: any) => {
+    if (typeof event?.toolCallId === "string") ran.set(event.toolCallId, now());
+  });
+
+  pi.on("turn_end", (event: any) => {
+    flushStep(event?.message);
+  });
+
+  pi.on("agent_settled", () => {
+    settle(outcomeOf(lastStop));
+  });
+
+  // Quit, reload or another session while a run is still going.
+  pi.on("session_shutdown", () => {
+    settle("interrupted");
+  });
+}

package/assets/extensions/omnirush/subagent-marker.ts

@@ -1,11 +1,11 @@
 // A sub-agent process (spawn_agents sets OMNIRUSH_PARENT_SESSION) marks its
 // own session with an `omnirush-subagent` entry naming its parent, before
 // the task: should that session ever be continued as a main session, its
-// first prompt is known to be the parent agent's (collector.ts records it
-// as synthetic). Kept out of collector.ts because sub-agent processes do
-// not load the collector (index.ts keeps children light).
+// first prompt is known to be the parent agent's (session-sync.ts records it
+// as synthetic). Kept out of session-sync.ts because sub-agent processes do
+// not load the session uploader (index.ts keeps children light).
 
-import { SUBAGENT_ENTRY_TYPE } from "./pi-engine";
+import { SUBAGENT_ENTRY_TYPE } from "./engine-messages";
 
 export default function markSubagentSession(pi: any, parentSession: string = (process.env.OMNIRUSH_PARENT_SESSION || "").trim()): void {
   if (!parentSession) return;