omnirush 0.10.1 → 0.10.3

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/subagents-lib.ts

@@ -12,7 +12,12 @@
 //     agent's model and the main agent's effort.
 //   - spawn_agents (agents.ts) resolves every task against it
 //     (resolveSubagentModel) and starts the child with that --model and
-//     --thinking; a task's own `model` wins over the picked one.
+//     --thinking. The user's choice wins over a task's own `model` (the
+//     agent's), which runs only when the user's message names it; with no
+//     choice set, a task model runs only when the account's catalog lists
+//     it (served), else the delegating agent's model and effort. Every
+//     override is on the result and in the trace (subagent.model_override),
+//     and every finished child's real model and effort (subagent.model).
 //   - A picked model that is not in the account's catalog (the list the
 //     launcher fetched from GET /v1/models), or that the gateway refused in
 //     the last five minutes, resolves to the main model instead (a
@@ -134,7 +139,9 @@ export function catalogFromPayload(payload: unknown): CatalogModel[] | null {
     const ownership = [entry.provider, entry.owned_by, entry.owner, entry.source, entry.namespace, entry.managed_by]
       .filter((value): value is string => typeof value === "string")
       .map((value) => value.trim().toLowerCase());
-    const shipped = ["gpt-6-astra", "gpt-6-sol", "gpt-5.6-sol", "meta-muse-spark", "muse-spark-1.1", "muse-spark-1.3", "muse-spark-1.2-contributor"];
+    // Ids the gateway serves under their bare names; an id counts as served
+    // only when this payload lists it (never because the CLI ships it).
+    const shipped = ["gpt-6-astra", "gpt-6-sol", "gpt-5.6-sol", "meta-muse-spark", "muse-spark-1.1"];
     if (!shipped.includes(id) && entry.omnirush !== true && !ownership.includes("omnirush")) continue;
     const levels = Array.isArray(entry.reasoning_levels)
       ? EFFORTS.filter((effort) => entry.reasoning_levels.some((level: unknown) => parseEffort(level) === effort))
@@ -323,6 +330,26 @@ export interface SubagentFallback {
   reason: FallbackReason | string;
 }
 
+/** Why a task's own `model` did not run: the user's /subagents choice, or the gateway does not serve it. */
+export type OverrideReason = "user_choice" | "not_served" | "catalog_unavailable" | "refused";
+
+/** A task's own `model[:effort]` that was not used, and what ran instead. */
+export interface SubagentOverride {
+  /** The task's model[:effort] as the agent wrote it. */
+  requested: string;
+  used: string;
+  effort: string | null;
+  reason: OverrideReason;
+}
+
+/**
+ * Where a sub-agent's model comes from: "subagents" (the user's /subagents
+ * choice), "user_prompt" (a task model the user's own message named),
+ * "task" (a task model the gateway serves, /subagents unset) or "parent"
+ * (the delegating agent's model and effort).
+ */
+export type ModelSource = "subagents" | "user_prompt" | "task" | "parent";
+
 export interface SubagentResolution {
   /** The model the child runs on; null = leave the child to pi's own default (no omnirush model known). */
   model: string | null;
@@ -332,6 +359,10 @@ export interface SubagentResolution {
   fallback?: SubagentFallback;
   /** The main model (and effort) the child's gateway guard moves to when the gateway refuses `model`. */
   gatewayFallback?: { model: string; effort: string | null };
+  /** The task named a model that did not run (the user's choice won, or it is not served). */
+  override?: SubagentOverride;
+  /** Where the model comes from (absent when no omnirush model is known). */
+  source?: ModelSource;
 }
 
 export interface AgentModel {
@@ -342,14 +373,33 @@ export interface AgentModel {
   effort: string | null;
 }
 
+/** Whether `text` names the model id `id` (case-insensitive, as a whole id: "gpt-6-sol" is not named by "gpt-6-sol-mini" or "gpt-5.6-sol"). */
+export function textNamesModel(text: string | null | undefined, id: string): boolean {
+  if (typeof text !== "string" || !text || !id) return false;
+  const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?<![A-Za-z0-9._-])${escaped}(?![A-Za-z0-9_-]|\\.[A-Za-z0-9])`, "i").test(text);
+}
+
+/** Whether the gateway serves `model` to this account: the live catalog lists it. */
+export function isServed(catalog: readonly CatalogModel[] | null, model: string): boolean {
+  return Boolean(catalog?.some((entry) => entry.id === model));
+}
+
 /**
  * What one sub-agent runs on.
  *
  * `delegating` is the agent calling spawn_agents (its model is what "same as
  * main" keeps); `main` is the main session's model and effort (handed down
  * to nested layers through the environment), the one a picked model falls
- * back to. `explicit` is the task's own `model`, which wins over the picked
- * one and is not checked against the catalog (the gateway decides).
+ * back to. `explicit` is the task's own `model[:effort]` (the agent's
+ * choice) and `userPrompt` the user's latest message:
+ *   - the user set /subagents (model and/or effort): that choice wins; a
+ *     task model runs only when the user's own message names it (and the
+ *     gateway serves it), otherwise it is overridden ("user_choice");
+ *   - /subagents unset: a task model runs only when the account's live
+ *     catalog lists it (and the gateway did not refuse it a moment ago);
+ *     otherwise the delegating agent's model and the main effort run
+ *     ("not_served", "catalog_unavailable" or "refused").
  */
 export function resolveSubagentModel(input: {
   setting: SubagentSetting;
@@ -357,6 +407,7 @@ export function resolveSubagentModel(input: {
   delegating: AgentModel;
   main?: AgentModel | null;
   explicit?: string | null;
+  userPrompt?: string | null;
   refused?: (model: string) => boolean;
 }): SubagentResolution {
   const { setting, catalog, delegating } = input;
@@ -364,6 +415,7 @@ export function resolveSubagentModel(input: {
   const mainIsGateway = main.provider === PROVIDER_ID && Boolean(main.model);
   const wantedEffort = setting.effort ?? parseEffort(main.effort) ?? null;
   const effortOn = (model: string): string | null => nearestEffort(wantedEffort, levelsFor(catalog, model));
+  const userChose = Boolean(setting.model || setting.effort);
 
   const withGatewayFallback = (resolution: SubagentResolution): SubagentResolution => {
     if (
@@ -377,21 +429,39 @@ export function resolveSubagentModel(input: {
     return resolution;
   };
 
-  // The task's own model[:effort]: an effort it names wins over the picked
-  // and the parent's (mapped to the nearest level the model offers).
-  const explicit = input.explicit && isModelId(input.explicit) ? splitModelEffort(input.explicit) : null;
+  // The task's own model[:effort].
+  const requested = typeof input.explicit === "string" ? input.explicit.trim() : "";
+  const explicit = requested && isModelId(requested) ? splitModelEffort(requested) : null;
+  let overrideReason: OverrideReason | null = null;
   if (explicit && isModelId(explicit.model)) {
-    const effort = explicit.effort ? nearestEffort(explicit.effort, levelsFor(catalog, explicit.model)) ?? explicit.effort : effortOn(explicit.model);
-    return withGatewayFallback({ model: explicit.model, effort });
+    const served = isServed(catalog, explicit.model);
+    const refusedNow = served && Boolean(input.refused?.(explicit.model));
+    const named = served && textNamesModel(input.userPrompt, explicit.model);
+    const allowed = served && !refusedNow && (userChose ? named : true);
+    if (allowed) {
+      // An effort the task names applies unless the user picked one with /subagents.
+      const taskEffort = explicit.effort && !setting.effort ? explicit.effort : null;
+      const effort = taskEffort ? nearestEffort(taskEffort, levelsFor(catalog, explicit.model)) ?? taskEffort : effortOn(explicit.model);
+      return withGatewayFallback({ model: explicit.model, effort, source: named ? "user_prompt" : "task" });
+    }
+    overrideReason = userChose ? "user_choice" : !catalog ? "catalog_unavailable" : !served ? "not_served" : "refused";
   }
+  const withOverride = (resolution: SubagentResolution): SubagentResolution => {
+    if (!overrideReason || !explicit || !resolution.model) return resolution;
+    // The same model at the same effort is no override.
+    if (explicit.model === resolution.model && (!explicit.effort || explicit.effort === resolution.effort)) return resolution;
+    resolution.override = { requested, used: resolution.model, effort: resolution.effort, reason: overrideReason };
+    return resolution;
+  };
 
   if (setting.model) {
     const inCatalog = !catalog || catalog.some((entry) => entry.id === setting.model);
     const reason: FallbackReason | null = !inCatalog ? "not_in_catalog" : input.refused?.(setting.model) ? "refused" : null;
     if (reason && mainIsGateway && main.model !== setting.model) {
-      return {
+      return withOverride({
         model: main.model!,
         effort: effortOn(main.model!),
+        source: "subagents",
         fallback: {
           requested: setting.model,
           requestedName: displayName(catalog, setting.model),
@@ -399,16 +469,46 @@ export function resolveSubagentModel(input: {
           usedName: displayName(catalog, main.model!),
           reason,
         },
-      };
+      });
     }
-    return withGatewayFallback({ model: setting.model, effort: effortOn(setting.model) });
+    return withOverride(withGatewayFallback({ model: setting.model, effort: effortOn(setting.model), source: "subagents" }));
   }
 
   // "Same as main": the delegating agent's own model.
   if (delegating.provider !== PROVIDER_ID || !delegating.model) {
     return { model: null, effort: null };
   }
-  return withGatewayFallback({ model: delegating.model, effort: effortOn(delegating.model) });
+  return withOverride(withGatewayFallback({
+    model: delegating.model,
+    effort: effortOn(delegating.model),
+    source: userChose ? "subagents" : "parent",
+  }));
+}
+
+/** A readable note for a task model that did not run (for the parent's result and the trace title). */
+export function overrideNote(override: SubagentOverride, catalog: readonly CatalogModel[] | null = null): string {
+  const ran = `${displayName(catalog, override.used)}${override.effort ? ` · ${override.effort}` : ""}`;
+  switch (override.reason) {
+    case "user_choice":
+      return `ran on ${ran}, your /subagents choice (${override.requested} was asked for)`;
+    case "not_served":
+      return `ran on ${ran}, the parent's model: ${override.requested} is not served to this account`;
+    case "catalog_unavailable":
+      return `ran on ${ran}, the parent's model: the account's model list is not available to check ${override.requested}`;
+    default:
+      return `ran on ${ran}, the parent's model: ${override.requested} was refused by omnirush.ai recently`;
+  }
+}
+
+/** How a sub-agent's model was chosen, in words (the result the parent reads). */
+export function sourceNote(source: ModelSource | string | undefined): string {
+  switch (source) {
+    case "subagents": return "your /subagents choice";
+    case "user_prompt": return "named in your message";
+    case "task": return "the task's model";
+    case "parent": return "same as the parent";
+    default: return "";
+  }
 }
 
 /** A readable note for a sub-agent that ran on the main model instead of the picked one. */

package/assets/extensions/omnirush/subagents.ts

@@ -31,6 +31,7 @@ import {
   loadCatalog,
   nearestEffort,
   nextSetting,
+  overrideNote,
   parseEffort,
   PROVIDER_ID,
   readSetting,
@@ -115,7 +116,12 @@ export function mainModel(pi: any, ctx: any, env: NodeJS.ProcessEnv = process.en
  * model when the picked one is not available, and the environment that hands
  * the setting and the main model down to nested layers.
  */
-export function subagentTasks(pi: any, ctx: any, tasks: ChildTask[], options: { dir?: string; env?: NodeJS.ProcessEnv; now?: number } = {}): ChildTask[] {
+export function subagentTasks(
+  pi: any,
+  ctx: any,
+  tasks: ChildTask[],
+  options: { dir?: string; env?: NodeJS.ProcessEnv; now?: number; userPrompt?: string | null } = {},
+): ChildTask[] {
   const dir = options.dir ?? omniDir();
   const env = options.env ?? process.env;
   const { setting } = currentSetting(pi, dir);
@@ -137,12 +143,17 @@ export function subagentTasks(pi: any, ctx: any, tasks: ChildTask[], options: {
       delegating,
       main,
       explicit: task.model ?? null,
+      userPrompt: options.userPrompt ?? null,
       refused: (model) => Boolean(isRefused(dir, model, options.now)),
     });
     const next: ChildTask = { ...task, env: { ...(task.env ?? {}), ...handDown } };
+    if (task.model) next.requestedModel = task.model;
     if (resolution.model) next.model = resolution.model;
     else delete next.model;
     if (resolution.model && resolution.effort) next.effort = resolution.effort;
+    else delete next.effort;
+    if (resolution.source) next.modelSource = resolution.source;
+    if (resolution.override) next.override = { ...resolution.override, note: overrideNote(resolution.override, catalog) };
     if (resolution.fallback) next.fallback = resolution.fallback;
     if (resolution.gatewayFallback) next.gatewayFallback = resolution.gatewayFallback;
     return next;
@@ -292,7 +303,7 @@ export default function (pi: any) {
       if (patch.model !== undefined) override.model = next.model;
       if (patch.effort !== undefined || next.effort !== current.effort) override.effort = next.effort;
       sessionOverrides.set(pi, override);
-      if (patch.model !== undefined && current.effort && next.effort === null) {
+      if (command !== "reset" && patch.model !== undefined && current.effort && next.effort === null) {
         notify(`Sub-agent effort ${current.effort} is not offered by ${next.model ? displayName(catalog, next.model) : "the main model"}: back to same as main.`, "warning");
       }
       if (next.effort && next.model === null && main.model) {

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

package/assets/extensions/omnirush/voice.ts

@@ -19,7 +19,7 @@
  * shared voice core (./voice/core, vendored from the desktop app).
  * Recordings are disposable: audio exists only in memory until its
  * segment's text is back, is never written to disk or logged, and never
- * reaches the session or the trace collector — only the text you send
+ * reaches the session or the session uploader — only the text you send
  * becomes the prompt.
  */
 

package/assets/{collect-once.ts → sync-once.ts}

@@ -1,23 +1,24 @@
-// omnirush collect — one-shot workspace snapshot upload (the manual
-// trigger; the same snapshots also flow automatically during agent
-// sessions via the omnirush pi extension).
+// omnirush upload — one-shot upload of a workspace snapshot to omnirush.ai
+// (the manual trigger; the same snapshots are also uploaded automatically
+// during agent sessions by the omnirush extension).
 //
-// Runs the session collector (the desktop app's, see
+// Runs the session uploader (the desktop app's, see
 // extensions/omnirush/capture/) for one manual session: the start
 // snapshot of the folder (files[] within the snapshot cap, the full
 // manifest, the git block; gitignored and denied paths left out, content
 // scrubbed) and the session's end snapshot, each one zstd envelope POSTed
-// to {origin}/collect with the device access token. A retryable failure
-// stays in the collector's spool and is sent by the next CLI run.
+// to the upload endpoint (UPLOAD_ENDPOINT_PATH in
+// capture/workspace-sync.ts) with the device access token. A retryable
+// failure stays in the spool and is sent by the next CLI run.
 //
-// Usage: omnirush collect [--dir PATH] [--dry-run]
+// Usage: omnirush upload [--dir PATH] [--dry-run]
 
 import { createHash, randomBytes } from "node:crypto";
 import path from "node:path";
 import { zstdDecompressSync } from "node:zlib";
 
 import { gatewayUrlForOrigin, omniDir, resolveOrigin } from "./extensions/omnirush/auth";
-import { WorkspaceCollector } from "./extensions/omnirush/capture/workspace-collector";
+import { WorkspaceSync } from "./extensions/omnirush/capture/workspace-sync";
 import { sharedRefresher } from "./extensions/omnirush/refresh";
 
 function parseArgs(argv: string[]): { dir: string; dryRun: boolean } {
@@ -32,7 +33,7 @@ function parseArgs(argv: string[]): { dir: string; dryRun: boolean } {
     } else if (arg === "--yes") {
       // Accepted for compatibility: the upload never asks.
     } else if (arg === "-h" || arg === "--help") {
-      console.log("usage: omnirush collect [--dir PATH] [--dry-run]");
+      console.log("usage: omnirush upload [--dir PATH] [--dry-run]");
       process.exit(0);
     }
   }
@@ -47,13 +48,13 @@ async function main() {
     sharedRefresher().accessToken() || process.env.OMNIRUSH_ACCESS_TOKEN || process.env.OMNIRUSH_TOKEN || ""
   ).trim();
   if (!accessToken && !dryRun) {
-    console.error("omnirush collect: no access token (run `omnirush login`)");
+    console.error("omnirush upload: no access token (run `omnirush login`)");
     process.exit(1);
   }
   const version = (process.env.OMNIRUSH_VERSION || "").trim();
   let uploads = 0;
   let current = accessToken;
-  const collector = new WorkspaceCollector({
+  const sync = new WorkspaceSync({
     gatewayUrl: process.env.OMNIRUSH_GATEWAY_URL || gatewayUrlForOrigin(resolveOrigin(process.env)),
     accessToken,
     // A dry run keeps no state (nothing is spooled for a later run).
@@ -86,25 +87,25 @@ async function main() {
       : {}),
     log: (level, message, attributes) => {
       // A dry run reports its envelopes itself (the upload hook above).
-      const uploaded = message === "OmniRush collection artifact uploaded" && !dryRun;
+      const uploaded = message === "OmniRush session upload: artifact uploaded" && !dryRun;
       if (uploaded) uploads += 1;
       if (level === "warn" || uploaded) {
-        console.error(`omnirush collect: ${message}${attributes ? ` ${JSON.stringify(attributes)}` : ""}`);
+        console.error(`omnirush upload: ${message.replace(/^OmniRush session upload: /, "")}${attributes ? ` ${JSON.stringify(attributes)}` : ""}`);
       }
     },
   });
-  console.log(`collect: ${dir} as session ${sessionId}`);
-  collector.startSession(sessionId, workspaceId, dir);
-  collector.finishSession(sessionId);
-  await collector.stop();
+  console.log(`upload: ${dir} as session ${sessionId}`);
+  sync.startSession(sessionId, workspaceId, dir);
+  sync.finishSession(sessionId);
+  await sync.stop();
   if (uploads === 0) {
-    console.error("omnirush collect: nothing uploaded");
+    console.error("omnirush upload: nothing uploaded");
     process.exit(1);
   }
   console.log(dryRun ? "dry run — no upload performed" : `uploaded ${uploads} envelope(s)`);
 }
 
 main().catch((error) => {
-  console.error(`omnirush collect failed: ${error?.message ?? error}`);
+  console.error(`omnirush upload failed: ${error?.message ?? error}`);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Omnirush — free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",

package/src/bin.js

@@ -9,7 +9,7 @@
 //   omnirush logout   forget the stored tokens
 //   omnirush whoami   show the signed-in device identity
 //   omnirush doctor   check auth (or pending login), manager, agent config
-//   omnirush collect  one-shot workspace snapshot upload
+//   omnirush upload   one-shot upload of a workspace snapshot to omnirush.ai
 //   omnirush update   update omnirush from npm
 //   omnirush          run the agent (default; forwards to the agent core)
 //
@@ -347,7 +347,7 @@ function installExtensions() {
   const src = path.join(__dirname, "..", "assets", "extensions", "omnirush");
   // pi loads extensions/<dir>/index.ts only; that aggregator imports the
   // sibling .ts modules, the shared auth.js and the capture/ modules (the
-  // desktop's collector and project archive, in subfolders) — copy every
+  // desktop's session uploader and project archive, in subfolders) — copy every
   // loadable file, keeping the folder layout.
   const copy = (from, to) => {
     fs.mkdirSync(to, { recursive: true });
@@ -373,6 +373,18 @@ function installExtensions() {
       // module open. Keep the running installation usable as a fallback.
       fs.rmSync(staging, { recursive: true, force: true });
       copy(src, PI_EXT_DIR);
+      // Modules earlier releases installed under names nothing imports any
+      // more (the swap above leaves none behind; this in-place copy would).
+      for (const stale of [
+        "collector-lib.ts",
+        "trace-format.ts",
+        "collector.ts",
+        "pi-engine.ts",
+        path.join("capture", "workspace-collector.ts"),
+        path.join("capture", "collect-upload-budget.ts"),
+      ]) {
+        fs.rmSync(path.join(PI_EXT_DIR, stale), { force: true });
+      }
     } finally {
       fs.rmSync(previous, { recursive: true, force: true });
     }
@@ -876,7 +888,7 @@ function childEnv(auth) {
     // /status shows the CLI version; extensions have no package.json of
     // their own in the agent dir, so the launcher hands it over.
     OMNIRUSH_VERSION: ownVersion(),
-    // The collector reports it as the environment's engine_version.
+    // The session uploader reports it as the environment's engine_version.
     OMNIRUSH_ENGINE_VERSION: engineVersion(),
     // Where this package lives: extensions (copied to the agent dir) load optional
     // native dependencies from here (voice: @picovoice/pvrecorder-node).
@@ -993,11 +1005,11 @@ async function cmdRun() {
   });
 }
 
-async function cmdCollect(argv) {
+async function cmdUpload(argv) {
   ensureDirs();
   const auth = requireAuth();
   installExtensions();
-  const entry = path.join(__dirname, "..", "assets", "collect-once.ts");
+  const entry = path.join(__dirname, "..", "assets", "sync-once.ts");
   const { cmd, args } = await runtimeFor(entry);
   spawnAgent(cmd, [...args, ...argv], {
     stdio: "inherit",
@@ -1017,7 +1029,7 @@ Usage:
   omnirush logout                   forget the stored device tokens
   omnirush whoami                   show the signed-in identity
   omnirush doctor                   check auth, manager, runtime, agent config
-  omnirush collect [--dir PATH]     one-shot workspace snapshot upload
+  omnirush upload [--dir PATH]      upload a one-shot workspace snapshot to omnirush.ai
   omnirush update                   update omnirush (npm install -g omnirush@latest)
   omnirush --version                show the omnirush version
 
@@ -1045,7 +1057,7 @@ Options:
 Session commands (inside the agent):
   /grant   today's token grant and usage
   /usage   detailed usage from the manager (counters + devices)
-  /status  session status (identity, model, grant, collector)
+  /status  session status (identity, model, grant, session uploads)
   /mcp     MCP server state (/mcp reconnect [server])
   /subagents  model and effort of the sub-agents (/subagents model <id|same>,
               /subagents effort <level|same>; saved for the next runs)
@@ -1179,7 +1191,7 @@ else if (cmd === "logout") await cmdLogout();
 else if (cmd === "whoami") await cmdWhoami();
 else if (cmd === "doctor") await cmdDoctor();
 else if (cmd === "--version" || cmd === "-v") console.log(`omnirush ${ownVersion()}`);
-else if (cmd === "collect") await cmdCollect(argv.slice(1));
+else if (cmd === "upload" || cmd === "collect") await cmdUpload(argv.slice(1));
 else if (cmd === undefined || cmd === "run") await cmdRun();
 else if (cmd === "update") await cmdUpdate(argv.slice(1));
 else await runCore(argv);

package/src/sessions.js

@@ -9,7 +9,7 @@
 // (agents-lib.ts subagentSessionDir), which the core never lists.
 //
 // moveLegacySubagentSessions puts the children older releases left in a
-// session dir into that folder too (moved, never deleted: the collector
+// session dir into that folder too (moved, never deleted: the session uploader
 // still finds them there when a resumed session records its sub-agents).
 // It runs at every agent launch before the core picks a session, and
 // stays cheap on large folders: a marker per session dir records when it
@@ -18,7 +18,7 @@
 // next launch, in case an older release is still writing them.
 //
 // A child is recognised from the top of its session file, by the same
-// signals the collector uses (pi-engine.ts subagentTask): the marker entry
+// signals the session uploader uses (engine-messages.ts subagentTask): the marker entry
 // a sub-agent writes into its own session before its task
 // (SUBAGENT_ENTRY_TYPE), or — sessions of releases that wrote no marker —
 // a first user message "Task: <task>" (SUBAGENT_TASK_PREFIX), confirmed by
@@ -31,7 +31,7 @@ import path from "node:path";
 
 /** Same name as agents-lib.ts SUBAGENT_SESSIONS_DIR. */
 export const SUBAGENT_SESSIONS_DIR = "subagents";
-/** Same values as pi-engine.ts SUBAGENT_ENTRY_TYPE / SUBAGENT_TASK_PREFIX. */
+/** Same values as engine-messages.ts SUBAGENT_ENTRY_TYPE / SUBAGENT_TASK_PREFIX. */
 export const SUBAGENT_ENTRY_TYPE = "omnirush-subagent";
 export const SUBAGENT_TASK_PREFIX = "Task: ";
 /** Per session dir: when it was last sorted (a .json file: the core only lists *.jsonl). */