omnirush 0.10.1 → 0.10.2

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.
 //
@@ -87,7 +87,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 +109,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;
@@ -632,7 +644,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).
  */

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,
@@ -245,14 +247,15 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admissi
       '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.',
       "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,
 
@@ -474,7 +477,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 -------------------------------------------------------------------

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

@@ -2,7 +2,7 @@
  * The touched-files archive (policy `touched_files`, README "Touched
  * files"): in a session folder that is neither a git repository nor inside
  * one, only the files the agent touched there are archived, byte for byte.
- * The collector reports every path the session touched (the trace's tool
+ * The session uploader reports every path the session touched (the trace's tool
  * paths, the watcher's changes); TouchedPathStore keeps them per session on
  * disk, and scanTouchedFiles turns them into archive entries at capture
  * time: regular files inside the root only, never through a symlinked
@@ -372,7 +372,7 @@ export class TouchedPathStore {
     },
   ) {}
 
-  /** A path the collector reported for the session (workspace-relative, portable). Cheap: a repeat is a lookup. */
+  /** A path the session uploader reported for the session (workspace-relative, portable). Cheap: a repeat is a lookup. */
   note(sessionId: string, path: string): void {
     let session = this.sessions.get(sessionId);
     if (!session) {

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

@@ -15,7 +15,7 @@ export type ArchiveFetch = (input: string, init?: RequestInit) => Promise<Respon
  * An authenticated request to the omnirush.ai API, relative to its root
  * (`archives/key`, `archives`, `archives/<id>/parts`, ...). The owner of the
  * device session (the gateway broker) attaches the bearer and handles its own
- * rotation, as it does for the collector's `upload` hook.
+ * rotation, as it does for the session uploader's `upload` hook.
  */
 export type ArchiveApiRequest = (path: string, init: ArchiveApiRequestInit) => Promise<Response>;
 /** `refresh: false` returns a 401 as it is, without refreshing the bearer (the all-folders policy probe); absent means true. */
@@ -76,7 +76,7 @@ const CHAIN_ENDING_CODES = new Set(["archive_id_conflict", "archive_sequence_con
 
 /**
  * The omnirush.ai API root derived from the gateway URL exactly like the
- * collect URL: trailing `/` and `/v1` stripped; HTTPS unless loopback.
+ * upload URL: trailing `/` and `/v1` stripped; HTTPS unless loopback.
  */
 export function resolveArchiveApiRoot(rawGatewayUrl: string | undefined): string | null {
   const value = rawGatewayUrl?.trim();
@@ -201,7 +201,7 @@ type PartsResult = { urls: Map<number, string>; uploaded: Array<{ part_number: n
 /**
  * One part of the sealed file, read into a single buffer (null once `signal`
  * aborted: nothing more is read). A single-chunk body gets a Content-Length
- * from every fetch and is copied once by Electron's net.fetch, which collects
+ * from every fetch and is copied once by Electron's net.fetch, which gathers
  * a streamed body with one Buffer.concat per chunk before sending it; a 64 MiB
  * part streamed in 64 KiB Blob chunks costs seconds of main-process copying.
  */

package/assets/extensions/omnirush/capture/{collect-upload-budget.ts → sync-upload-budget.ts}

@@ -1,5 +1,5 @@
 /**
- * How long one collector upload (POST <gateway>/collect) may take.
+ * How long one session uploader upload (POST to the upload endpoint) may take.
  *
  * Envelopes range from a few KiB (a change snapshot) to tens of MiB (the
  * start snapshot of a large workspace), so the deadline grows with the body:
@@ -18,22 +18,22 @@
  * body sent faster than the assumed rate leaves the unused sending time to the
  * response wait.
  */
-export type CollectUploadBudget = {
+export type SyncUploadBudget = {
   baseMs: number;
   bytesPerSecond: number;
   maxSendMs: number;
   responseMs: number;
 };
 
-export const COLLECT_UPLOAD_BUDGET: CollectUploadBudget = {
+export const SYNC_UPLOAD_BUDGET: SyncUploadBudget = {
   baseMs: 30_000,
   bytesPerSecond: 128 * 1024,
   maxSendMs: 15 * 60_000,
   responseMs: 120_000,
 };
 
-/** The whole-request deadline, in milliseconds, for a collect upload of `bytes`. */
-export function collectUploadTimeoutMs(bytes: number, budget: CollectUploadBudget = COLLECT_UPLOAD_BUDGET): number {
+/** The whole-request deadline, in milliseconds, for a session upload of `bytes`. */
+export function syncUploadTimeoutMs(bytes: number, budget: SyncUploadBudget = SYNC_UPLOAD_BUDGET): number {
   const sendMs = budget.baseMs + Math.ceil((Math.max(0, bytes) * 1_000) / budget.bytesPerSecond);
   return Math.min(budget.maxSendMs, sendMs) + budget.responseMs;
 }

package/assets/extensions/omnirush/capture/turn-diff.ts

@@ -1,11 +1,11 @@
 /**
  * The "turn.diff" trace event: at the end of each turn, a unified diff per
- * workspace file the turn changed, of the scrubbed text the collector last
+ * workspace file the turn changed, of the scrubbed text the session uploader last
  * sent for it before the turn against the scrubbed text it sent after, so the
  * trace pairs the turn with exactly what it changed. The texts come from
  * TurnBaseStore, a bounded content-addressed store of the scrubbed texts the
- * collector sent (keyed by their redacted sha256, the digest the manifest
- * names), kept under the collector state dir so bases survive a restart.
+ * session uploader sent (keyed by their redacted sha256, the digest the manifest
+ * names), kept under the state dir so bases survive a restart.
  * Everything here runs on the capture worker (see capture-host.ts).
  */
 import { createHash } from "node:crypto";
@@ -20,7 +20,7 @@ export const MAX_TURN_DIFF_EVENT_BYTES = 2 * 1024 * 1024;
 export const MAX_TURN_DIFF_MS = 250;
 /** Budget of the base store, least recently used out first. */
 export const TURN_BASE_STORE_BYTES = 64 * 1024 * 1024;
-/** Texts over the collector's per-file cap are never stored. */
+/** Texts over the session uploader's per-file cap are never stored. */
 const MAX_BASE_TEXT_BYTES = 4 * 1024 * 1024;
 const DIFF_CONTEXT_LINES = 3;
 /** A diff gets a place in the event only while at least this much of the budget is left. */
@@ -56,7 +56,7 @@ export type TurnDiffFile = {
   status: TurnDiffStatus;
   /**
    * Redacted sha256 of the text before the turn: null for an added or skipped
-   * file, and for a no_base one the collector first saw already changed by the turn.
+   * file, and for a no_base one the session uploader first saw already changed by the turn.
    */
   before_sha256: string | null;
   /** Redacted sha256 of the text after the turn (null for a deleted or skipped file). */
@@ -418,7 +418,7 @@ function sha256Hex(text: string): string {
 }
 
 /**
- * The scrubbed texts the collector sent, by redacted sha256, least recently
+ * The scrubbed texts the session uploader sent, by redacted sha256, least recently
  * used out first once `budget` bytes are held. The texts are files under
  * `dir` (one per digest, owner-only) and an index keeps their order across
  * restarts; a text is read back only while its digest still matches. Writes