omnirush 0.10.1 → 0.10.3

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

@@ -10,7 +10,7 @@
 // of the folder /resume and --continue read, so a user only ever sees
 // their own conversations there), under a session id the parent
 // picks (`--session-id`) and returns in the result (`session_id`): the
-// parent session's collector reads the child's session file from it and
+// parent session's session uploader reads the child's session file from it and
 // records the child as a sub-agent of the turn (session.child events,
 // grandchildren included), the way the desktop records task sub-agents.
 //
@@ -35,6 +35,7 @@ import {
   ENV_FALLBACK_MODEL,
   FALLBACK_MARKER,
   fallbackNote,
+  sourceNote,
   piThinking,
   type SubagentFallback,
 } from "./subagents-lib";
@@ -87,7 +88,7 @@ export const RELEASED_OUTPUT = "(output no longer kept in memory: it was deliver
 /**
  * Sub-agent layers below the main session (the desktop app's
  * OMNIRUSH_SUBAGENT_DEPTH): layers 1 and 2 may delegate, layer 3 may not.
- * The session capture records exactly these layers (collector.ts).
+ * The session capture records exactly these layers (session-sync.ts).
  */
 export const MAX_SUBAGENT_DEPTH = 3;
 /** The layer a process runs at, handed down to every child (+1 per layer). */
@@ -109,11 +110,23 @@ export function canDelegate(depth: number): boolean {
   return depth < MAX_SUBAGENT_DEPTH;
 }
 
-/** System text for a sub-agent: its layer, and whether it may delegate. */
+/**
+ * The main session's spawn_agents guideline: delegate on request or on a
+ * clear split, exactly as many as the user names, each task only its own
+ * part (a pasted user message made the sub-agent obey the delegation
+ * instructions again and nest), all in one call.
+ */
+export const SPAWN_GUIDELINE = "Do simple work directly: a question that a few lookups or commands answer needs no sub-agent. Start sub-agents only when the user asks for them or the work clearly splits into independent parts that each take several tool calls; otherwise do the work yourself. When the user names a number of sub-agents, start exactly that many. Each task must be self-contained (the sub-agent cannot see this conversation) and limited to that sub-agent's part: say what to do, with the names, paths or URLs it needs, and what to report. Never paste the user's whole message or any instructions about sub-agents into a task. A sub-agent does its task itself; tell it to start sub-agents of its own only when the user explicitly asked for nested sub-agents. Start them all in one spawn_agents call so they run in parallel.";
+
+/** A sub-agent's spawn_agents guideline (layer >= 1). */
+export const SUBAGENT_SPAWN_GUIDELINE = "You are a sub-agent: do your whole task yourself, even when it is long. Use spawn_agents only if your task explicitly tells you to start sub-agents of your own.";
+
+/** System text for a sub-agent: its layer, and that it does its task itself. */
 export function subagentLayerNote(depth: number): string {
+  const head = `You are a sub-agent: layer ${depth} of at most ${MAX_SUBAGENT_DEPTH} below the main session. Do your whole task yourself, even when it is long: splitting it among sub-agents of your own is slower, not faster. Instructions about sub-agents in your task text (such as "use one subagent to ...") were meant for the main session, which has already carried them out: you are that sub-agent.`;
   return canDelegate(depth)
-    ? `You are a sub-agent: layer ${depth} of at most ${MAX_SUBAGENT_DEPTH} below the main session. You may delegate independent parts of your task with spawn_agents (your sub-agents are layer ${depth + 1}); otherwise do the work yourself.`
-    : `You are a sub-agent: layer ${depth} of at most ${MAX_SUBAGENT_DEPTH} below the main session. You cannot delegate further (there is no spawn_agents at this layer): do the work yourself.`;
+    ? `${head} Start sub-agents (spawn_agents) only if your task explicitly tells you to start sub-agents of your own.`
+    : `${head} You cannot delegate further (there is no spawn_agents at this layer).`;
 }
 
 export const AGENT_ROLES = ["code-searcher", "researcher-web", "general-worker"] as const;
@@ -293,8 +306,8 @@ export interface ChildTask {
   role: AgentRole;
   task: string;
   /** Cross-model children: gateway model id the child runs on
-   *  (e.g. "muse-spark-1.3" for cheap swarm workers under an astra
-   *  parent). Undefined = inherit the parent's model. */
+   *  (e.g. "muse-spark-1.1" workers under an astra parent). Undefined =
+   *  inherit the parent's model. */
   model?: string;
   /** The effort the child runs on (gateway spelling); undefined = pi's default. */
   effort?: string;
@@ -304,6 +317,21 @@ export interface ChildTask {
   gatewayFallback?: { model: string; effort: string | null };
   /** Extra environment for the child (the sub-agent setting and main model, for nested layers). */
   env?: Record<string, string>;
+  /** The model[:effort] the delegating agent asked for (the task's own `model`), when it named one. */
+  requestedModel?: string;
+  /** That model did not run: the user's /subagents choice won, or the gateway does not serve it. */
+  override?: ChildModelOverride;
+  /** Where `model` comes from ("subagents", "user_prompt", "task", "parent"). */
+  modelSource?: string;
+}
+
+/** A task model that did not run, and what ran instead (the result's model_override). */
+export interface ChildModelOverride {
+  requested: string;
+  used: string;
+  effort: string | null;
+  reason: string;
+  note: string;
 }
 
 /** A sub-agent that ran on the main model instead of the picked one. */
@@ -330,6 +358,12 @@ export interface ChildResult {
   effort?: string;
   /** It ran on the main model instead of the picked one (why, and since when). */
   model_fallback?: ChildModelFallback;
+  /** The task's own model did not run (the user's /subagents choice, or not served). */
+  model_override?: ChildModelOverride;
+  /** Where the model comes from: "subagents", "user_prompt", "task" or "parent". */
+  model_source?: string;
+  /** The model[:effort] the task asked for, when it named one. */
+  requested_model?: string;
   status: ChildStatus;
   /** Process exit code (null when killed by a signal or still unknown). */
   exitCode: number | null;
@@ -400,6 +434,9 @@ export function buildChildResult(
     ...(task.model ? { model: task.model } : {}),
     ...(task.effort ? { effort: task.effort } : {}),
     ...(modelFallback ? { model_fallback: modelFallback } : {}),
+    ...(task.override ? { model_override: { ...task.override } } : {}),
+    ...(task.modelSource ? { model_source: task.modelSource } : {}),
+    ...(task.requestedModel ? { requested_model: task.requestedModel } : {}),
     status: input.status ?? (input.exitCode === 0 ? "completed" : "failed"),
     exitCode: input.exitCode,
     output: capped,
@@ -632,7 +669,7 @@ export interface ChildActivity {
 }
 
 /**
- * The collector reaches the running sub-agents through this global (it must
+ * The session uploader reaches the running sub-agents through this global (it must
  * stop them before its last capture; pi runs its session_shutdown handler
  * before the agents extension's).
  */
@@ -909,16 +946,34 @@ export async function mapWithConcurrency<TIn, TOut>(
   return results;
 }
 
+/** The model and effort a child really ran on (after a gateway fallback), and why that one. */
+export function ranOn(result: Pick<ChildResult, "model" | "effort" | "model_fallback">): { model: string | null; effort: string | null } {
+  if (result.model_fallback?.kind === "gateway") return { model: result.model_fallback.used, effort: result.model_fallback.effort ?? null };
+  return { model: result.model ?? null, effort: result.effort ?? null };
+}
+
+function ranOnText(result: ChildResult): string {
+  const { model, effort } = ranOn(result);
+  if (!model) return "the parent's model (not an omnirush.ai model)";
+  const why = result.model_fallback?.kind === "gateway"
+    ? "the gateway refused the chosen model"
+    : result.model_fallback
+      ? "the main model"
+      : sourceNote(result.model_source);
+  return `${model}${effort ? ` · ${effort}` : ""}${why ? ` (${why})` : ""}`;
+}
+
 /** Structured result text for the parent model (one section per child). */
 export function renderChildResults(results: ChildResult[], ids?: readonly string[]): string {
   const succeeded = results.filter((result) => result.status === "completed").length;
   const sections = results.map((result, index) => {
     const minutes = Math.round((result.durationMs / 60_000) * 10) / 10;
-    const ranOn = result.model_fallback?.kind === "gateway" ? result.model_fallback.used : result.model;
-    const effort = result.model_fallback?.kind === "gateway" ? result.model_fallback.effort ?? undefined : result.effort;
-    const label = ranOn ? ` [${ranOn}${effort ? ` · ${effort}` : ""}]` : "";
+    const ran = ranOn(result);
+    const label = ran.model ? ` [${ran.model}${ran.effort ? ` · ${ran.effort}` : ""}]` : "";
     const header = `### ${ids?.[index] ? `${ids[index]} ` : ""}${result.role}${label} — ${result.status} (${minutes} min${result.outputTruncated ? ", output capped" : ""})`;
     const meta: string[] = [`task: ${result.task}`];
+    meta.push(`ran on: ${ranOnText(result)}`);
+    if (result.model_override) meta.push(`note: ${result.model_override.note}`);
     if (result.model_fallback) meta.push(`note: ${result.model_fallback.note}`);
     if (result.error) meta.push(`error: ${result.error}`);
     return `${header}\n${meta.join("\n")}\n\n${result.output || "(no output)"}`;

package/assets/extensions/omnirush/agents.ts

@@ -27,7 +27,7 @@
 // <session dir>/subagents/ (children run without --no-session; that
 // folder keeps them out of /resume and --continue)
 // under a session id the parent picks, and the parent session's
-// collector records each child's conversation as a sub-agent of the
+// session uploader records each child's conversation as a sub-agent of the
 // turn (session.child events with parent and depth, as the desktop
 // records task sub-agents) — a background child that finishes in a later
 // turn is recorded as it progresses, and one the session ends under is
@@ -61,6 +61,8 @@ import {
   childInactivityMs,
   renderAgentStatus,
   subagentLayerNote,
+  SPAWN_GUIDELINE,
+  SUBAGENT_SPAWN_GUIDELINE,
   renderChildResults,
   renderDelivery,
   runChildAgent,
@@ -71,6 +73,7 @@ import {
 } from "./agents-lib";
 import { SWARM_GUIDELINE } from "./swarm-lib";
 import { omniDir } from "./auth";
+import { loadCatalog, type CatalogModel } from "./subagents-lib";
 import { MemoryAdmission, readMemorySettings } from "./memory-lib";
 
 /** Blocking spawn_agents: progress updates at most this often (ms). */
@@ -82,16 +85,32 @@ const MIN_TIMEOUT_MINUTES = 1;
 /** customType of the message that brings background results back. */
 export const DELIVERY_TYPE = "omnirush-agents-result";
 
-const SpawnAgentsParams = Type.Object({
+/** Served ids used as examples when the account's catalog is not cached (the live list at 0.10.3). */
+export const SERVED_MODEL_EXAMPLES = ["gpt-6-astra", "gpt-6-sol", "gpt-5.6-sol", "meta-muse-spark", "muse-spark-1.1"];
+
+/** Examples for the per-task model: the ids the account's live catalog lists (served models only). */
+export function modelExamples(catalog: readonly CatalogModel[] | null): string[] {
+  if (!catalog || catalog.length === 0) return SERVED_MODEL_EXAMPLES;
+  return catalog.map((model) => model.id);
+}
+
+export function modelParamDescription(examples: readonly string[]): string {
+  return [
+    "Optional model[:effort] for THIS task. Usually omit it: set it only when the user asked for a model for the sub-agents.",
+    `Served models: ${examples.map((id) => `"${id}"`).join(", ")}, optionally with an effort (e.g. "${examples[0] ?? "gpt-6-astra"}:high"); a model the account is not served is never used (the child runs on your model and effort).`,
+    "The user's /subagents choice always wins: while it is set, a model named here runs only if the user's own message names it.",
+    "Omitted, the child runs on the /subagents choice, else this session's current model and effort.",
+  ].join(" ");
+}
+
+const spawnAgentsParams = (examples: readonly string[]) => Type.Object({
   tasks: Type.Array(
     Type.Object({
       role: StringEnum(AGENT_ROLES, {
         description: "code-searcher: read-only codebase exploration; researcher-web: web research via web_search/web_fetch; general-worker: full-tool implementation work",
       }),
       task: Type.String({ description: "Self-contained task description for the child agent (it sees ONLY this, not your conversation)" }),
-      model: Type.Optional(Type.String({
-        description: 'Optional model[:effort] for THIS task (e.g. "muse-spark-1.3", "muse-spark-1.2-contributor" for cheap swarm workers, "meta-muse-spark", "muse-spark-1.1:low", "gpt-6-astra", "gpt-6-sol:high", "gpt-5.6-sol"). Omit (or leave empty) for the sub-agent model the user picked with /subagents, else the parent session\'s current model and effort',
-      })),
+      model: Type.Optional(Type.String({ description: modelParamDescription(examples) })),
     }),
     { description: "Tasks to delegate; they all run in parallel", minItems: 1 },
   ),
@@ -113,6 +132,26 @@ const IdsParam = Type.Optional(Type.Array(Type.String(), {
   description: 'Agent ids from spawn_agents (e.g. "a3"); omit (or "all") for every agent of this session',
 }));
 
+/** The text of the latest user message on the session's branch (null when there is none). */
+export function lastUserMessageText(ctx: any): string | null {
+  let entries: any[] = [];
+  try {
+    entries = ctx?.sessionManager?.getBranch?.() ?? ctx?.sessionManager?.getEntries?.() ?? [];
+  } catch {
+    return null;
+  }
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const message = entries[index]?.type === "message" ? entries[index].message : null;
+    if (!message || message.role !== "user") continue;
+    if (typeof message.content === "string") return message.content;
+    if (Array.isArray(message.content)) {
+      return message.content.filter((part: any) => part?.type === "text" && typeof part.text === "string").map((part: any) => part.text).join("\n");
+    }
+    return null;
+  }
+  return null;
+}
+
 function resultOf(record: AgentRecord): ChildResult & { agent_id: string } {
   return { ...(record.result as ChildResult), agent_id: record.id };
 }
@@ -225,6 +264,30 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
   };
   (globalThis as any)[AGENTS_HOOK] = hook;
 
+  // The user's latest message (the text they typed, not an extension's):
+  // a task's own model runs over the /subagents choice only when it names
+  // that model. Sub-agents have no user: their task text never counts.
+  let lastUserInput: { session: string; text: string } | null = null;
+  const sessionIdOf = (ctx: any): string => {
+    try {
+      return String(ctx?.sessionManager?.getSessionId?.() ?? "");
+    } catch {
+      return "";
+    }
+  };
+  if (depth === 0) {
+    pi.on("input", (event: any, ctx: any) => {
+      if (event?.source === "extension" || typeof event?.text !== "string") return;
+      lastUserInput = { session: sessionIdOf(ctx), text: event.text };
+    });
+  }
+  const latestUserPrompt = (ctx: any): string | null => {
+    if (depth > 0) return null;
+    const session = sessionIdOf(ctx);
+    if (lastUserInput && lastUserInput.session === session) return lastUserInput.text;
+    return lastUserMessageText(ctx);
+  };
+
   const sessionOf = (ctx: any): string => {
     lastContext = ctx ?? lastContext;
     return hub.sessionOf(ctx);
@@ -242,19 +305,20 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
       "Default (wait true) blocks until all children finish and returns their results.",
       "wait:false dispatches them in the BACKGROUND: the call returns at once with agent ids, you keep working, and their results arrive automatically as a message in this conversation when they finish.",
       "Manage background agents with agents_status, agents_wait, agents_result and agents_cancel.",
-      'Each task can run on a DIFFERENT model via its "model" field — e.g. cheap muse workers for wide swarm sweeps under an astra parent.',
+      'Each task can run on a different model via its "model" field when the user asks for one; the user\'s /subagents choice wins over it, and a model the account is not served is not used. Every result says the model and effort the child ran on.',
       "Every task description must be SELF-CONTAINED: the child cannot see this conversation.",
       "Use for parallelizable work: broad code surveys, independent research questions, independent implementation chunks.",
+      "Give each task only its own part of the work: never the user's whole message or instructions about sub-agents (the child would follow them and delegate again).",
     ].join(" "),
     promptSnippet: "spawn_agents: delegate parallel tasks to role-preset subagents (blocking, or wait:false for background work)",
     promptGuidelines: [
-      "Use spawn_agents when 2+ independent sub-tasks would each take several tool calls (surveys, research, independent fixes); write each task brief as a self-contained mini-prompt with the goal, relevant paths and the expected report format.",
+      depth > 0 ? SUBAGENT_SPAWN_GUIDELINE : SPAWN_GUIDELINE,
       "Short fan-outs whose results you need right away (quick searches, lookups): the default blocking call.",
       "Long work (implementation chunks, builds, test suites, long research — anything that may take many minutes) while you have other things to do: spawn_agents with wait:false, then keep working; the results arrive on their own as a message, so do not poll agents_status in a loop. Call agents_wait only when you have nothing else to do and need the results before going on.",
       "Do not use spawn_agents for a single quick action — doing it yourself is cheaper.",
-      SWARM_GUIDELINE,
+      ...(depth > 0 ? [] : [SWARM_GUIDELINE]),
     ],
-    parameters: SpawnAgentsParams,
+    parameters: spawnAgentsParams(modelExamples(loadCatalog(omniDir()))),
 
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const parentSessionId = sessionOf(ctx);
@@ -263,9 +327,9 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
         if (!raw || typeof raw.task !== "string" || !raw.task.trim()) {
           throw new Error("invalid tasks: every entry needs a non-empty task string");
         }
-        // A task's own model[:effort] wins; an omitted (or empty) one takes
-        // the /subagents pick, else the parent session's current model and
-        // effort (resolved below by subagentTasks).
+        // A task's own model[:effort] (resolved below by subagentTasks):
+        // the user's /subagents choice wins over it unless the user's message
+        // names that model; unset, it runs only when the gateway serves it.
         const requestedModel = typeof raw.model === "string" ? raw.model.trim() : "";
         tasks.push({
           role: raw.role,
@@ -274,11 +338,11 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
         });
       }
       if (tasks.length === 0) throw new Error("no tasks given");
-      // The model and effort each child runs on (subagents.ts): the task's
-      // own model[:effort], else the /subagents pick, else the parent
+      // The model and effort each child runs on (subagents.ts): the
+      // /subagents choice, else a served task model, else the parent
       // session's current model and effort; the main model when a pick is
-      // unavailable.
-      const resolvedTasks = subagentTasks(pi, ctx, tasks);
+      // unavailable. Overrides are noted on the result and the trace.
+      const resolvedTasks = subagentTasks(pi, ctx, tasks, { userPrompt: latestUserPrompt(ctx) });
       if (!parentSessionId) throw new Error("no parent session id — subagents cannot be traced");
       const workdir = ctx?.cwd ? String(ctx.cwd) : process.cwd();
       // Only a deliberate limit counts: models fill optional numbers with
@@ -331,7 +395,7 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
 
       if (background) {
         const lines = dispatched.records.map((record, index) => {
-          const note = childModelFallback(resolvedTasks[index])?.note;
+          const note = [resolvedTasks[index].override?.note, childModelFallback(resolvedTasks[index])?.note].filter(Boolean).join("; ");
           return `- ${record.id}: ${record.role}${record.model ? ` [${record.model}${record.effort ? ` · ${record.effort}` : ""}]` : ""} — ${record.task.length > 100 ? `${record.task.slice(0, 99)}…` : record.task}${note ? ` (${note})` : ""}`;
         });
         return {
@@ -360,6 +424,9 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
                 ...(record.model ? { model: record.model } : {}),
                 ...(record.effort ? { effort: record.effort } : {}),
                 ...(modelFallback ? { model_fallback: modelFallback } : {}),
+                ...(resolvedTasks[index].override ? { model_override: { ...resolvedTasks[index].override } } : {}),
+                ...(resolvedTasks[index].modelSource ? { model_source: resolvedTasks[index].modelSource } : {}),
+                ...(resolvedTasks[index].requestedModel ? { requested_model: resolvedTasks[index].requestedModel } : {}),
                 parallel_limit: record.parallelLimit,
                 status: "running",
               };
@@ -474,7 +541,7 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
   });
 
   pi.on("session_shutdown", async () => {
-    // Children the session ends under are stopped (the collector, when it
+    // Children the session ends under are stopped (the session uploader, when it
     // runs, already did this before its last capture).
     await manager.interruptAll().catch(() => undefined);
   });

package/assets/extensions/omnirush/auth.js

@@ -1,5 +1,5 @@
 // Omnirush device-flow auth core — shared by the CLI (src/bin.js), the
-// extensions (sota guard 401-refresh, collector), and node:test.
+// extensions (sota guard 401-refresh, session uploader), and node:test.
 //
 // Plain ESM JavaScript on node builtins only: pi extensions are loaded
 // through jiti with a fixed virtual-module set (pi packages + typebox),
@@ -23,7 +23,8 @@
 //        -> 409 {"detail":"refresh_token_already_used"}       (race)
 //        -> 403 {"detail":"account_inactive|account_pending|account_rejected"}
 //   GET  /device/me        -> 200 device identity | 401 device_token_invalid
-//   POST /collect          -> zstd body, X-Omnirush-Session-ID header
+//   POST <upload endpoint> -> zstd body, X-Omnirush-Session-ID header
+//                             (UPLOAD_ENDPOINT_PATH, capture/workspace-sync.ts)
 //
 // SECURITY: nothing in this module ever returns or logs a token; error
 // messages carry only server `detail` strings and HTTP statuses.

package/assets/extensions/omnirush/bgshell.ts

@@ -41,7 +41,7 @@ import {
   tailText,
 } from "./bgshell-lib";
 import { deliveryHub } from "./deliveries";
-import { BACKGROUND_BASH_TYPE } from "./pi-engine";
+import { BACKGROUND_BASH_TYPE } from "./engine-messages";
 import { sanitizeToolEnvironment } from "./secret-env";
 
 /** customType of the message that brings finished background commands back (the trace maps it to bash tool parts). */
@@ -78,14 +78,14 @@ export default function (pi: any, options: { exec?: ShellExec; now?: () => numbe
   const fgDefault = defaultForegroundSeconds();
 
   /** New output of each job, marked read. */
-  const collect = (jobs: ShellJob[]) => jobs.map((job) => ({ job, ...manager.read(job) }));
+  const readAll = (jobs: ShellJob[]) => jobs.map((job) => ({ job, ...manager.read(job) }));
 
   hub.addSource({
     hasPending: (session) => manager.hasPending(session),
     take: (session) => {
       const jobs = manager.takeDeliverable(session);
       if (jobs.length === 0) return [];
-      const parts = collect(jobs);
+      const parts = readAll(jobs);
       return [{
         customType: BASH_DELIVERY_TYPE,
         content: renderJobDelivery(parts),
@@ -115,7 +115,7 @@ export default function (pi: any, options: { exec?: ShellExec; now?: () => numbe
 
   // --- stopping at the end of the session -------------------------------------
 
-  /** What the session's end stopped (the collector's hook may do it before our own handler runs). */
+  /** What the session's end stopped (the session uploader's hook may do it before our own handler runs). */
   let stoppedAtEnd: ShellJob[] = [];
   const stopAll = async (session?: string): Promise<ShellJob[]> => {
     const live = manager.running(session);
@@ -127,7 +127,7 @@ export default function (pi: any, options: { exec?: ShellExec; now?: () => numbe
     const background = stopped.filter((job) => job.background);
     if (background.length > 0) {
       try {
-        const parts = collect(background);
+        const parts = readAll(background);
         pi.sendMessage(
           {
             customType: BASH_DELIVERY_TYPE,
@@ -296,7 +296,7 @@ export default function (pi: any, options: { exec?: ShellExec; now?: () => numbe
   }));
 
   const readResult = (jobs: ShellJob[], unknown: string[]) => {
-    const parts = collect(jobs);
+    const parts = readAll(jobs);
     const sections = parts.map(({ job, text, dropped }) => renderJobResult(job, text, { dropped }).text);
     if (unknown.length) sections.push(`Unknown ids: ${unknown.join(", ")}`);
     return {

package/assets/extensions/omnirush/capture/UPSTREAM

@@ -1,11 +1,11 @@
 Ported from omnirush-ai/omnirush-gui @ 2e166a9f9843dccbedc8277addcd94b752e66adb
 (apps/server/src), unchanged except for the CLI seams marked "CLI:" in the code:
 
-  workspace-collector.ts      vendored minimatch import; exported ledger reader and
+  workspace-sync.ts           vendored minimatch import; exported ledger reader and
                               .gitignore helpers; `watch: false` (poll on snapshots)
                               and `envelopeMetadata` options
   turn-diff.ts                unchanged
-  collect-upload-budget.ts    unchanged
+  sync-upload-budget.ts       unchanged
   session-archive/detect.ts, files.ts, lifecycle.ts, pack.ts, seal.ts   unchanged
   session-archive/index.ts, policy.ts, upload.ts    vendored zod import
   session-archive/manifest.ts, touched.ts           gitignored content left out
@@ -14,8 +14,11 @@ Ported from omnirush-ai/omnirush-gui @ 2e166a9f9843dccbedc8277addcd94b752e66adb
 CLI files beside them:
   session-archive/ignored.ts  git's ignore rules for the archive scans
   server-fetch.ts             external egress = the global fetch
-  omnirush-swarm.ts           the one constant the collector reads
+  omnirush-swarm.ts           the one constant workspace-sync.ts reads
   vendor/                     zod and minimatch (npm run build:capture-vendor)
 
-Resync: copy the files again, re-apply the seams, then run
+The CLI names some modules and exports differently from upstream
+(dev/gui-parity-tests.sh maps them back for the desktop's test suites).
+
+Resync: copy the files again, re-apply the seams and the CLI names, then run
 dev/gui-parity-tests.sh <omnirush-gui checkout>.

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

@@ -1,6 +1,6 @@
-// The one constant the ported workspace collector reads from the desktop's
+// The one constant the ported workspace uploader reads from the desktop's
 // swarm module (apps/server/src/omnirush-swarm.ts): the trace event that
 // records a sub-agent answered on the main model instead of the picked one.
 // The CLI never emits it (its sub-agents run in their own process on the
-// model they were given), but the collector keeps the same handling.
+// model they were given), but the session uploader keeps the same handling.
 export const SUBAGENT_MODEL_FALLBACK_TRACE = "subagent.model_fallback";

package/assets/extensions/omnirush/capture/server-fetch.ts

@@ -1,7 +1,7 @@
 // Egress seam of the ported capture modules (desktop: apps/server/src/
 // server-fetch.ts). The desktop routes external egress through the embedding
 // runtime's network stack; the CLI has one runtime and one fetch, so every
-// upload (collect envelopes, archive API calls, presigned S3 part PUTs) goes
+// upload (session upload envelopes, archive API calls, presigned S3 part PUTs) goes
 // through the global fetch.
 export function externalFetch(input: string, init?: RequestInit): Promise<Response> {
   return globalThis.fetch(input, init);

package/assets/extensions/omnirush/capture/session-archive/detect.ts

@@ -12,7 +12,7 @@ import { lstat, open, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import path, { isAbsolute, join, parse, posix, relative, resolve, sep, win32 } from "node:path";
 
-import { isCollectorDirectoryDenied } from "../workspace-collector.js";
+import { isSyncDirectoryDenied } from "../workspace-sync.js";
 import type { ArchivePolicy } from "./policy.js";
 
 export type ArchivableProject = {
@@ -291,7 +291,7 @@ export function foldGatePath(path: string, platform: NodeJS.Platform): string {
  * - the Electron userData directory, and anything above it;
  * - a credential store wherever it is (`.ssh`, `.aws`, `.gnupg`, `.kube`,
  *   `.docker`, `.azure`, `.password-store`, `Keychains`, `.config/gcloud`),
- *   and any folder the collector's denylist denies as a whole (`keys`,
+ *   and any folder the session uploader's denylist denies as a whole (`keys`,
  *   `secrets`, `credentials*`, `.env*`, `node_modules`, `.git`, ...);
  * - app data wherever it is (`AppData`, `Library/Application Support`);
  * - in the home directory, and in the other folders beside it (other
@@ -317,7 +317,7 @@ export function refusedFolderRoot(root: string, context: FolderGateContext): Fol
 
   const names = target.slice(paths.parse(target).root.length).split(paths.sep).filter(Boolean).map((name) => name.toLowerCase());
   const hasPair = (pairs: ReadonlyArray<readonly [string, string]>) => names.some((name, index) => pairs.some(([first, second]) => name === first && names[index + 1] === second));
-  if (names.some((name) => CREDENTIAL_DIRS.has(name)) || hasPair(CREDENTIAL_DIR_PAIRS) || isCollectorDirectoryDenied(names.join("/"))) return "root_credentials";
+  if (names.some((name) => CREDENTIAL_DIRS.has(name)) || hasPair(CREDENTIAL_DIR_PAIRS) || isSyncDirectoryDenied(names.join("/"))) return "root_credentials";
   if (names.some((name) => APP_DATA_DIRS.has(name)) || hasPair(APP_DATA_DIR_PAIRS)) return "root_app_data";
 
   for (const home of homes) {

package/assets/extensions/omnirush/capture/session-archive/files.ts

@@ -72,7 +72,7 @@ export async function readJsonFile(path: string): Promise<unknown> {
 /**
  * Runs a full garbage collection when the runtime offers one (Bun.gc); a
  * no-op elsewhere. Streaming an archive churns through hundreds of MiB of
- * short-lived buffers (zstd output, AES-GCM output) that the collector would
+ * short-lived buffers (zstd output, AES-GCM output) that the session uploader would
  * otherwise let pile up well past the stream's bounded working set. Callers
  * hint once per 64 MiB of data; a collection takes a few milliseconds at the
  * heap sizes involved.

package/assets/extensions/omnirush/capture/session-archive/ignored.ts

@@ -14,7 +14,7 @@
  * ignored folder listed once as `dir/` so the scan prunes it without
  * walking it. Where git cannot answer (git missing, not a work tree, a
  * timeout or an output past the cap) the folder's `.gitignore` files are
- * applied level by level, with the same matcher the workspace collector's
+ * applied level by level, with the same matcher the workspace uploader's
  * fallback listing uses (`ignoredByRules`).
  *
  * This file is a CLI addition to the ported desktop modules; the desktop's
@@ -22,7 +22,7 @@
  */
 import { join } from "node:path";
 
-import { ignoredByRules, readGitignoreFile, scopedIgnoreRules } from "../workspace-collector.js";
+import { ignoredByRules, readGitignoreFile, scopedIgnoreRules } from "../workspace-sync.js";
 import { runGit } from "./manifest.js";
 
 /** The ignored-paths listing is read up to this size; past it the .gitignore fallback applies. */

package/assets/extensions/omnirush/capture/session-archive/index.ts

@@ -8,7 +8,7 @@
  * with the touched-files policy on, the same chain holding only the files
  * the agent touched there (touched.ts), its base at the first capture that
  * has one. Each archive is sealed to the omnirush.ai archive key, queued
- * durably under the collector state dir and uploaded to S3 through
+ * durably under the state dir and uploaded to S3 through
  * presigned multipart URLs. The embedded server drives it through
  * lifecycle.ts; see README.md.
  */
@@ -68,7 +68,7 @@ export { gitMarkerDetector, gitParentDetector, isArchivableProject, type Archiva
 export { isArchiveCredentialPath, type ArchiveTrigger, type FinalReason } from "./manifest.js";
 export type { ArchiveApiRequest } from "./upload.js";
 
-/** Subdirectory of the collector state dir that holds everything the archiver keeps. */
+/** Subdirectory of the state dir that holds everything the archiver keeps. */
 export const ARCHIVE_STATE_DIRECTORY = "omnirush-archive";
 const SESSION_ID_PATTERN = /^[A-Za-z0-9._:-]{8,128}$/;
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
@@ -88,16 +88,16 @@ const SIGN_OUT_ABORT_TIMEOUT_MS = 5_000;
 export const POLICY_TTL_MS = 5 * 60_000;
 
 export type SessionArchiverOptions = {
-  /** As the collector: the archive routes are derived from it like the collect URL. */
+  /** As the session uploader: the archive routes are derived from it like the upload URL. */
   gatewayUrl?: string;
   accessToken?: string;
-  /** The collector's hook: a fresh bearer after a 401, or null. */
+  /** The session uploader's hook: a fresh bearer after a 401, or null. */
   refreshAccessToken?: () => Promise<string | null>;
   /** External egress for S3 part PUTs (and API calls without `request`); externalFetch by default. */
   fetch?: ArchiveFetch;
   /** Authenticated API calls through the device-session owner (the gateway broker); replaces gatewayUrl + accessToken. */
   request?: ArchiveApiRequest;
-  /** The collector state dir; the archiver keeps its files in `<stateDir>/omnirush-archive/`. */
+  /** The state dir; the archiver keeps its files in `<stateDir>/omnirush-archive/`. */
   stateDir: string;
   /** App state/temp/data dirs pruned when under a root (the state dir itself is always pruned). */
   excludedDirs?: string[];
@@ -358,7 +358,7 @@ export class SessionArchiver {
     return this.started;
   }
 
-  /** The device bearer changed (collector token rotation). */
+  /** The device bearer changed (uploader token rotation). */
   setAccessToken(token: string | null): void {
     this.uploader.setAccessToken(token);
   }
@@ -491,7 +491,7 @@ export class SessionArchiver {
 
   /**
    * A path the session touched, workspace-relative (portable `/`), as the
-   * collector reports it: a tool's path in the trace, or a change the
+   * session uploader reports it: a tool's path in the trace, or a change the
    * watcher saw. Kept (on disk, a moment later) for a touched-files session;
    * dropped for any other once the gate has run. Cheap: called for every
    * file event.
@@ -827,7 +827,7 @@ export class SessionArchiver {
   }
 
   /**
-   * One capture under the session's lock. The collection hints around it keep
+   * One capture under the session's lock. The garbage collection hints around it keep
    * a capture's per-entry garbage from stacking on top of the previous one's.
    */
   private async captureArchive(state: SessionState, kind: ArchiveKind, turn: number, key: ArchiveKey, generation: number, options: CaptureOptions = {}): Promise<CaptureResult> {

package/assets/extensions/omnirush/capture/session-archive/lifecycle.ts

@@ -272,7 +272,7 @@ export class ProjectArchiveLifecycle {
   }
 
   /**
-   * The collector saw the session touch a path (workspace-relative): a
+   * The session uploader saw the session touch a path (workspace-relative): a
    * tool's path in the trace, or a change on disk. Kept for a touched-files
    * session (the archiver drops it for any other); nothing for a session
    * this app run has not started or knows is not archived.

package/assets/extensions/omnirush/capture/session-archive/manifest.ts

@@ -12,7 +12,7 @@ import { lstat, open, readdir, readlink, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, delimiter, isAbsolute, join, relative, resolve, sep } from "node:path";
 
-import { clampCollectorBytes, isCollectorPathDenied, stripRemoteUserinfo } from "../workspace-collector.js";
+import { clampSyncBytes, isSyncPathDenied, stripRemoteUserinfo } from "../workspace-sync.js";
 import { hintGarbageCollection } from "./files.js";
 
 export const ARCHIVE_SCHEMA = "omnirush.archive.v1";
@@ -143,19 +143,19 @@ export function compareArchivePaths(left: string, right: string): number {
 
 /**
  * True when a file or symlink must be left out of the archive (section 5.3):
- * the collector's credential denylist, with git internals exempt and
+ * the session uploader's credential denylist, with git internals exempt and
  * `node_modules` not counted as a denial.
  */
 export function isArchiveCredentialPath(relPath: string): boolean {
   const parts = relPath.split("/");
   if (parts.some((part) => part.toLowerCase() === ".git")) return false;
   const rest = parts.filter((part) => part.toLowerCase() !== "node_modules");
-  return rest.length > 0 && isCollectorPathDenied(rest.join("/"));
+  return rest.length > 0 && isSyncPathDenied(rest.join("/"));
 }
 
 /** workspace.label: the root's basename, at most 255 UTF-8 bytes. */
 export function archiveLabel(root: string): string {
-  return clampCollectorBytes(basename(resolve(root)), MAX_LABEL_BYTES).text;
+  return clampSyncBytes(basename(resolve(root)), MAX_LABEL_BYTES).text;
 }
 
 // --- hash cache -------------------------------------------------------------------