omnirush 0.10.1 → 0.10.3

package/assets/extensions/omnirush/commands.ts

@@ -5,7 +5,7 @@
  *   /usage   full usage from the manager (grant date, token counters,
  *            devices)
  *   /status  one-screen session summary (identity, model/effort, grant,
- *            collector, origin, version)
+ *            session uploader, origin, version)
  *   /verify  prove the served model is genuine — full implementation
  *            lands with the gateway's model-attestation endpoint (M2)
  * plus the footer status line that keeps grant/model info visible while
@@ -17,10 +17,10 @@
  * which is exactly how /grant and /verify broke the first time.
  */
 
-import { readSessionLedger, SESSION_LEDGER_FILE } from "./capture/workspace-collector";
+import { readSessionLedger, SESSION_LEDGER_FILE } from "./capture/workspace-sync";
 import { deviceMe, omniDir, resolveOrigin, sessionEndedMessage } from "./auth";
 import { sharedRefresher } from "./refresh";
-import { formatCollectorLine, formatStatusLines } from "./status-lib";
+import { formatSyncLine, formatStatusLines } from "./status-lib";
 import { formatModeStatus } from "./yolo-lib";
 import {
   formatDeviceLines,
@@ -129,7 +129,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerCommand("status", {
-    description: "Show the Omnirush session status (identity, model, grant, collector)",
+    description: "Show the Omnirush session status (identity, model, grant, session uploads)",
     handler: async (_args: string, ctx: any) => {
       const { me } = await fetchMe();
       const usage = gatewayUsage();
@@ -140,7 +140,7 @@ export default function (pi: ExtensionAPI) {
         const ledger = await readSessionLedger(`${omniDir()}/${SESSION_LEDGER_FILE}`);
         record = ledger.sessions[sessionId] ?? null;
       } catch {
-        /* collector state is best effort */
+        /* session upload state is best effort */
       }
       const model = ctx?.model;
       const statusLines = formatStatusLines({
@@ -151,7 +151,7 @@ export default function (pi: ExtensionAPI) {
         effort: usage?.["x-omnirush-effort"] ?? null,
         grant: grant?.text ?? null,
         grantDate: grant?.date ?? null,
-        collector: { sessionId, record },
+        sync: { sessionId, record },
         origin: resolveOrigin(process.env),
         version: CLI_VERSION,
         yolo: formatModeStatus(),

package/assets/extensions/omnirush/{pi-engine.ts → engine-messages.ts}

@@ -1,6 +1,6 @@
 // The CLI's session, in the desktop app's engine message format.
 //
-// The desktop collector records the conversation as the engine (opencode)
+// The desktop app records the conversation as the engine (opencode)
 // keeps it: one message per user prompt and per model step,
 //
 //   {info: {id, sessionID, role, time: {created, completed}, modelID,
@@ -72,7 +72,7 @@
 // outcome) comes from stream-timing.ts's `omnirush-timing` entries.
 //
 // Also here, pure and shared with the tests: the helpers the desktop's turn
-// observer (apps/server/src/collector-observer.ts) applies to the engine's
+// observer (apps/server/src) applies to the engine's
 // messages when a turn settles: the turn's model, the message budget of a
 // flush and its split into `turn.messages` parts.
 
@@ -1010,9 +1010,9 @@ export function parseSessionFile(text: string): { header: PiEntry | null; entrie
   return { header, entries };
 }
 
-// --- the turn observer's helpers (collector-observer.ts) -------------------------
+// --- the turn observer's helpers (the desktop turn observer) -------------------------
 
-/** Latest model selection of a turn, as the collector's session.model event records it. */
+/** Latest model selection of a turn, as the session uploader's session.model event records it. */
 export type TurnModel = { provider_id: string | null; model_id: string | null; variant: string | null; agent: string | null };
 
 function optionalText(value: unknown): string | null {
@@ -1023,7 +1023,7 @@ function optionalText(value: unknown): string | null {
  * The model the turn ran on, read from the turn's first assistant message
  * (providerID / modelID / mode or agent); the user message that opened the
  * turn supplies the variant and agent when the assistant record lacks them.
- * (collector-observer.ts `turnModelFromMessages`.)
+ * (the desktop turn observer `turnModelFromMessages`.)
  */
 export function turnModelFromMessages(messages: unknown): TurnModel | null {
   if (!Array.isArray(messages)) return null;
@@ -1071,7 +1071,7 @@ export type TurnHistory = {
  * The part of a session's messages a settled turn records: every message
  * after the checkpoint message (all of them without one, or when the
  * checkpoint is not on the branch), newest first up to `budget` bytes, and
- * once the budget is spent only the user's own prompts. (collector-observer.ts
+ * once the budget is spent only the user's own prompts. (the desktop turn observer
  * `readEngineHistory`, over messages already in memory.)
  */
 export function turnHistory(messages: readonly EngineMessage[], checkpoint: string | undefined, budget = MAX_BACKLOG_MESSAGE_BYTES): TurnHistory {
@@ -1112,7 +1112,7 @@ export type MessagePart = { messages: unknown[]; bytes: number };
  * A settled turn's messages (oldest first) cut into the parts its trace
  * flushes carry, oldest part first: the newest messages up to `maxBytes` make
  * the last part, and each earlier part takes the next older ones. One part,
- * empty, when there are no messages. (collector-observer.ts `messageParts`.)
+ * empty, when there are no messages. (the desktop turn observer `messageParts`.)
  */
 export function messageParts(messages: readonly unknown[], sizes: readonly number[], maxBytes = MAX_TURN_MESSAGE_BYTES): MessagePart[] {
   const parts: MessagePart[] = [];

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
@@ -39,11 +39,11 @@ export default async function (pi: ExtensionAPI) {
   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
-  // collector, so a settled run's idle entry is written before it is read.
+  // 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)) {
@@ -159,13 +159,48 @@ function modelFallbackOf(result: any): ChildModelFallback | null {
   };
 }
 
+/** A task's own model that did not run (spawn_agents' model_override). */
+export type ChildModelOverride = { requested: string; used: string; effort: string | null; reason: string; note: string };
+
+/** The model and effort a sub-agent really ran on, once its result is final. */
+export type ChildRanOn = { model: string | null; effort: string | null; source: string | null; requested: string | null; status: string };
+
+function modelOverrideOf(result: any): ChildModelOverride | null {
+  const override = result && typeof result.model_override === "object" ? result.model_override : null;
+  if (!override || typeof override.requested !== "string" || typeof override.used !== "string") return null;
+  return {
+    requested: override.requested,
+    used: override.used,
+    effort: typeof override.effort === "string" ? override.effort : null,
+    reason: typeof override.reason === "string" ? override.reason : "user_choice",
+    note: typeof override.note === "string" ? override.note : `ran on ${override.used}`,
+  };
+}
+
+/** A finished child's model and effort (the gateway fallback's when the gateway moved it). */
+function ranOnOf(result: any, fallback: ChildModelFallback | null): ChildRanOn | null {
+  const status = result && typeof result.status === "string" ? result.status : "";
+  if (!status || status === "running" || status === "queued") return null;
+  const gateway = fallback?.kind === "gateway" ? fallback : null;
+  return {
+    model: gateway ? gateway.used : typeof result.model === "string" ? result.model : null,
+    effort: gateway ? gateway.effort : typeof result.effort === "string" ? result.effort : null,
+    source: typeof result.model_source === "string" ? result.model_source : null,
+    requested: typeof result.requested_model === "string" ? result.requested_model : null,
+    status,
+  };
+}
+
+type SpawnedChild = { id: string; role: string | null; task: string | null; modelFallback?: ChildModelFallback; modelOverride?: ChildModelOverride; ranOn?: ChildRanOn };
+
 /**
  * Sub-agents a session started: its spawn_agents results (session id, role,
  * task), with the model fallback a later result reported (a background
- * child's delivery, agents_wait / agents_result) when there is one.
+ * child's delivery, agents_wait / agents_result) when there is one, a task
+ * model that did not run, and the model and effort it ran on once finished.
  */
-export function spawnedChildren(entries: readonly PiEntry[]): Array<{ id: string; role: string | null; task: string | null; modelFallback?: ChildModelFallback }> {
-  const children: Array<{ id: string; role: string | null; task: string | null; modelFallback?: ChildModelFallback }> = [];
+export function spawnedChildren(entries: readonly PiEntry[]): SpawnedChild[] {
+  const children: SpawnedChild[] = [];
   for (const entry of entries) {
     const message = entry.type === "message" ? entry.message : null;
     const spawned = Boolean(message && message.role === "toolResult" && message.toolName === "spawn_agents");
@@ -182,16 +217,23 @@ export function spawnedChildren(entries: readonly PiEntry[]): Array<{ id: string
       if (!sanitizeSessionId(id)) continue;
       const known = children.find((child) => child.id === id);
       const modelFallback = modelFallbackOf(result);
+      const modelOverride = modelOverrideOf(result);
       if (known) {
         if (modelFallback) known.modelFallback = modelFallback;
+        if (modelOverride) known.modelOverride = modelOverride;
+        const ran = ranOnOf(result, known.modelFallback ?? null);
+        if (ran) known.ranOn = ran;
         continue;
       }
       if (!spawned) continue;
+      const ran = ranOnOf(result, modelFallback);
       children.push({
         id,
         role: typeof result.role === "string" ? result.role : null,
         task: typeof result.task === "string" ? result.task : null,
         ...(modelFallback ? { modelFallback } : {}),
+        ...(modelOverride ? { modelOverride } : {}),
+        ...(ran ? { ranOn: ran } : {}),
       });
     }
   }
@@ -200,6 +242,15 @@ export function spawnedChildren(entries: readonly PiEntry[]): Array<{ id: string
 
 /** Fallbacks already recorded as trace events (root session : child session). */
 const recordedFallbacks = new Set<string>();
+/** Overrides and ran-on models already recorded (same keys). */
+const recordedOverrides = new Set<string>();
+const recordedRanOn = new Set<string>();
+
+/** A child's trace title: its task, with the model note when its model was not the one asked for. */
+function childTitle(child: SpawnedChild): string | null {
+  const notes = [child.modelOverride?.note, child.modelFallback?.note].filter(Boolean);
+  return child.task && notes.length ? `${child.task} (${notes.join("; ")})` : child.task;
+}
 
 /** The session file of `sessionId`: `<ts>_<id>.jsonl` in one of the session dirs. */
 async function findSessionFile(sessionId: string, dirs: readonly string[]): Promise<string | null> {
@@ -307,20 +358,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 +405,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,
@@ -369,13 +420,38 @@ export async function captureChildSessions(input: {
         kind: child.modelFallback.kind,
       });
     }
+    if (child.modelOverride && !recordedOverrides.has(fallbackKey)) {
+      // The task named a model that did not run: the user's /subagents
+      // choice won, or the gateway does not serve it to this account.
+      recordedOverrides.add(fallbackKey);
+      input.sync.recordTrace(input.rootSessionId, "subagent.model_override", {
+        child_session_id: child.id,
+        requested: child.modelOverride.requested,
+        used: child.modelOverride.used,
+        effort: child.modelOverride.effort,
+        reason: child.modelOverride.reason,
+      });
+    }
+    if (child.ranOn && !recordedRanOn.has(fallbackKey)) {
+      // What the sub-agent really ran on (after any gateway fallback).
+      recordedRanOn.add(fallbackKey);
+      input.sync.recordTrace(input.rootSessionId, "subagent.model", {
+        child_session_id: child.id,
+        role: child.role,
+        model: child.ranOn.model,
+        effort: child.ranOn.effort,
+        source: child.ranOn.source,
+        requested: child.ranOn.requested,
+        status: child.ranOn.status,
+      });
+    }
     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,
-        title: child.task && child.modelFallback ? `${child.task} (${child.modelFallback.note})` : child.task,
+        title: childTitle(child),
         agent: turnModelFromMessages(messages)?.agent ?? agent,
         messages: history.delta,
         lastMessageId: typeof messages.at(-1)?.info.id === "string" ? (messages.at(-1)!.info.id as string) : null,
@@ -391,7 +467,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 +487,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 +507,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 +526,7 @@ export default function (pi: any) {
     return globalThis.fetch(input, init);
   };
 
-  const collector = new WorkspaceCollector({
+  const sync = new WorkspaceSync({
     gatewayUrl,
     accessToken,
     refreshAccessToken,
@@ -484,12 +560,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 +578,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 +657,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 +685,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 +700,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 +729,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 +749,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 +811,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 +831,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 +846,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 +913,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 +937,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 +945,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,