omnirush 0.10.1 → 0.10.2

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)) {
@@ -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

@@ -8,7 +8,7 @@
 // `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. pi-engine.ts reads them into the trace's 2.x fields:
+// 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:
@@ -16,10 +16,10 @@
 //   one entry when the run settles
 //     {idle: {at, outcome: "succeeded" | "failed" | "interrupted"}}
 //
-// Loaded before the collector (index.ts): the idle entry is on the branch
-// when the collector reads the settled run.
+// 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 "./pi-engine";
+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 };

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;

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

@@ -34,7 +34,7 @@ export const SWARM_LAYER_ENV = "OMNIRUSH_SWARM_LAYER";
 export const SWARM_SKILL_DESCRIPTION = `Required before starting ${SWARM_MIN_AGENTS} or more sub-agents for one request (a swarm, or the user asks for several agents): the shared-board procedure. Never for 1-2 sub-agents or a small request.`;
 
 /** The always-on line (a spawn_agents guideline). */
-export const SWARM_GUIDELINE = `Before you start ${SWARM_MIN_AGENTS} or more sub-agents for one request (large work that splits into ${SWARM_MIN_AGENTS}+ independent parts, or the user asks for a swarm or for several agents), load the ${SWARM_SKILL_NAME} skill first and follow it. Otherwise answer directly, or use at most 1-2 sub-agents with spawn_agents and no board or coordination file.`;
+export const SWARM_GUIDELINE = `Before you start ${SWARM_MIN_AGENTS} or more sub-agents for one request (large work that splits into ${SWARM_MIN_AGENTS}+ independent parts, or the user asks for a swarm or for several agents), load the ${SWARM_SKILL_NAME} skill first and follow it. Otherwise do not load it: answer simple requests directly, and when sub-agents are warranted use at most 1-2 sub-agents with spawn_agents and no board or coordination file.`;
 
 export const SWARM_SKILL = `# Sub-agent swarm
 
@@ -81,7 +81,7 @@ export function swarmSubagentNote(layer: number): string {
     `You are a sub-agent (layer ${layer}) in a swarm coordinated through \`${SWARM_FILE}\` in the workspace.`,
     `Read \`${SWARM_FILE}\` before you start. Find your task id in your task (or the row that matches your task), set its status to running, and when you finish set it to done with a one-line result and append your findings under your task id. Edit only your own rows and sections, and re-read the file right before each edit because other agents write to it too. Do not move or archive the board: the main agent does that.`,
     layer < 3
-      ? "If your task splits into independent parts that each take real effort, you may delegate them with spawn_agents: add sub-task rows (for example T1.1, T1.2) first and give each sub-agent the same instructions. Otherwise do the work yourself."
+      ? "Do your task yourself. Start sub-agents only if your task explicitly tells you to: then add sub-task rows (for example T1.1, T1.2) first and give each sub-agent the same instructions."
       : "Do not delegate further: do the work yourself.",
   ].join("\n");
 }