omnirush 0.9.0 → 0.10.0

package/assets/extensions/omnirush/agents.ts

@@ -4,7 +4,11 @@
 // the SAME workspace:
 //   - role presets: code-searcher (read-only exploration),
 //     researcher-web (web_fetch research), general-worker (full tools)
-//   - parallel execution, every task at once unless max_parallel throttles
+//   - parallel execution, every task at once unless max_parallel throttles;
+//     no count cap, but memory-aware admission (memory-lib.ts): a child
+//     starts while the machine keeps enough RAM free and the agents' process
+//     tree stays under its budget, the rest wait ("queued: waiting for
+//     memory") and start as memory frees up
 //   - no wall-clock limit: a child runs until it is done. Only an explicit
 //     timeout_minutes, the inactivity watchdog (no output at all for
 //     OMNIRUSH_AGENT_INACTIVITY_MINUTES, default 30, longer while one of
@@ -20,7 +24,8 @@
 //     running children
 //
 // Tracing is free: every child writes its own session JSONL under
-// <agentDir>/sessions/<cwd-slug>/ (children run without --no-session)
+// <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
 // turn (session.child events with parent and depth, as the desktop
@@ -29,6 +34,11 @@
 // stopped and recorded as interrupted. Children get
 // OMNIRUSH_PARENT_SESSION, so a child process uploads nothing of its own.
 //
+// Nesting: a sub-agent may start sub-agents of its own, up to
+// MAX_SUBAGENT_DEPTH (3) layers below the main session (the desktop's
+// OMNIRUSH_SUBAGENT_DEPTH). Each child gets OMNIRUSH_AGENT_DEPTH (its layer)
+// and a note saying it; layer 3 has no spawn_agents.
+//
 // `/agents` lists this session's subagents (running + finished);
 // `/agents cancel <id|all>` stops running ones.
 
@@ -46,16 +56,25 @@ import {
   type AgentRunner,
   type AgentsHook,
   type AgentRecord,
+  agentDepth,
+  canDelegate,
   childInactivityMs,
   renderAgentStatus,
+  subagentLayerNote,
   renderChildResults,
   renderDelivery,
   runChildAgent,
   childModelFallback,
+  subagentSessionDir,
   type ChildResult,
   type ChildTask,
 } from "./agents-lib";
 import { SWARM_GUIDELINE } from "./swarm-lib";
+import { omniDir } from "./auth";
+import { MemoryAdmission, readMemorySettings } from "./memory-lib";
+
+/** Blocking spawn_agents: progress updates at most this often (ms). */
+const PROGRESS_UPDATE_MS = 500;
 
 /** A timeout_minutes below this is taken for a placeholder, not a limit. */
 const MIN_TIMEOUT_MINUTES = 1;
@@ -109,7 +128,19 @@ function renderSome(records: AgentRecord[], unknown: string[] = []): string {
   return parts.join("\n\n") || "No matching sub-agents.";
 }
 
-export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {}) {
+export default function (pi: ExtensionAPI, options: { run?: AgentRunner; admission?: MemoryAdmission | null; env?: NodeJS.ProcessEnv } = {}) {
+  // Sub-agents nest up to MAX_SUBAGENT_DEPTH layers below the main session,
+  // as in the desktop app: every sub-agent is told its layer, and the last
+  // layer gets no spawn_agents (nor the tools that manage sub-agents).
+  const depth = agentDepth(options.env ?? process.env);
+  if (depth > 0) {
+    pi.on("before_agent_start", async (event: any) => {
+      const base = typeof event?.systemPrompt === "string" ? event.systemPrompt : "";
+      return { systemPrompt: `${base}\n\n${subagentLayerNote(depth)}` };
+    });
+  }
+  if (!canDelegate(depth)) return;
+
   const watchdogMinutes = Math.round(childInactivityMs() / 60_000);
   const hub = deliveryHub(pi);
   /** The last context seen (the TUI status bar for running agents). */
@@ -130,18 +161,49 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
     statusTimer.unref?.();
   }
 
+  // Memory-aware admission of children; thresholds from the environment or
+  // settings.json "subagentMemory" (memory-lib.ts). Built on first use.
+  let admission: MemoryAdmission | null = null;
+  const admissionOf = (): MemoryAdmission => {
+    admission ??= options.admission ?? new MemoryAdmission({ settings: readMemorySettings(omniDir()) });
+    return admission;
+  };
+  const lazyAdmission = {
+    check: () => admissionOf().check(),
+    started: (key: object, pid?: number | null) => admissionOf().started(key, pid ?? null),
+    spawned: (key: object, pid: number | null | undefined) => admissionOf().spawned(key, pid),
+    finished: (key: object) => admissionOf().finished(key),
+  };
+
+  /** Tell the user when children wait for memory (a warning when it is critically low). */
+  function memoryWait(info: { critical: boolean; detail: string; queued: number } | null): void {
+    scheduleStatus();
+    if (!info) return;
+    const text = info.critical
+      ? `omnirush: ${info.detail}. Not starting more sub-agents until memory frees up (${info.queued} queued); running ones continue.`
+      : `omnirush: ${info.queued} sub-agent${info.queued === 1 ? "" : "s"} queued: waiting for memory (${info.detail}).`;
+    if (lastContext?.hasUI && lastContext?.ui?.notify) lastContext.ui.notify(text, info.critical ? "warning" : "info");
+    // Headless: the top agent says it on stderr (a sub-agent's stderr only reaches its parent).
+    else if (info.critical || !String(process.env.OMNIRUSH_PARENT_SESSION ?? "").trim()) process.stderr.write(`${text}\n`);
+  }
+
   const manager = new AgentManager({
     run: options.run ?? ((task, options) => runChildAgent(task, {
       cwd: options.cwd ?? hub.cwd,
       parentSessionId: options.parentSessionId,
       sessionId: options.sessionId,
+      ...(options.sessionDir ? { sessionDir: options.sessionDir } : {}),
       signal: options.signal,
       onActivity: options.onActivity,
+      ...(options.onSpawn ? { onSpawn: options.onSpawn } : {}),
+      extraEnv: admissionOf().childEnv(),
       ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
     })),
     // After the settle's own bookkeeping (waiters took theirs).
     onDeliverable: () => hub.notify(),
     onChanged: scheduleStatus,
+    admission: options.admission === null ? null : lazyAdmission,
+    onMemoryWait: memoryWait,
   });
 
   hub.addSource({
@@ -231,6 +293,8 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
         ? Math.floor(params.max_parallel)
         : undefined;
       const background = params.wait === false;
+      let progressTimer: ReturnType<typeof setTimeout> | null = null;
+      let finished = false;
 
       const dispatched = manager.dispatch(parentSessionId, resolvedTasks, {
         background,
@@ -245,14 +309,24 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
           });
         },
         onChanged: () => {
-          if (background) return;
-          onUpdate?.({
-            content: [{ type: "text", text: agentStatusSummary(manager.list(parentSessionId)) }],
-            details: { results: manager.list(parentSessionId).filter((candidate) => candidate.result).map(resultOf) },
-          });
+          // Every sign of life of every child lands here: the progress update
+          // (which carries the finished results) goes out at most every
+          // PROGRESS_UPDATE_MS, not once per output chunk.
+          if (background || progressTimer) return;
+          progressTimer = setTimeout(() => {
+            progressTimer = null;
+            if (finished) return;
+            onUpdate?.({
+              content: [{ type: "text", text: agentStatusSummary(manager.list(parentSessionId)) }],
+              details: { results: manager.list(parentSessionId).filter((candidate) => candidate.result).map(resultOf) },
+            });
+          }, PROGRESS_UPDATE_MS);
+          progressTimer.unref?.();
         },
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         cwd: workdir,
+        // Children's sessions stay out of the user's /resume list.
+        sessionDir: subagentSessionDir(ctx?.sessionManager?.getSessionDir?.()),
       });
 
       if (background) {
@@ -295,6 +369,8 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
       }
 
       await dispatched.done;
+      finished = true;
+      if (progressTimer) clearTimeout(progressTimer);
       const records = dispatched.records;
       return {
         content: [{ type: "text", text: renderChildResults(records.map((record) => record.result as ChildResult), records.map((record) => record.id)) }],
@@ -404,7 +480,7 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
   });
 
   pi.registerCommand("agents", {
-    description: "List this session's subagents (running and finished); /agents cancel <id|all> stops running ones",
+    description: "List this session's subagents (running and finished) and the memory they may use; /agents cancel <id|all> stops running ones; /agents memory shows the memory admission",
     handler: async (args: string, ctx: any) => {
       const session = sessionOf(ctx);
       const words = String(args ?? "").trim().split(/\s+/).filter(Boolean);
@@ -416,11 +492,16 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
         return;
       }
       const records = manager.list(session);
+      const memory = options.admission === null ? "" : `\n${admissionOf().describe()}`;
+      if (words[0] === "memory") {
+        ctx?.ui?.notify?.(memory.trim() || "Memory admission is off.");
+        return;
+      }
       if (records.length === 0) {
-        ctx?.ui?.notify?.("No subagents have been spawned in this session yet.");
+        ctx?.ui?.notify?.(`No subagents have been spawned in this session yet.${memory}`);
         return;
       }
-      ctx?.ui?.notify?.(renderAgentStatus(records));
+      ctx?.ui?.notify?.(`${renderAgentStatus(records)}${memory}`);
     },
   });
 }

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

@@ -21,6 +21,12 @@ export const MAX_FOREGROUND_SECONDS = 3_600;
 export const JOB_BUFFER_CHARS = 1_000_000;
 /** Output a delivery or a read shows at most (characters): the newest part. */
 export const SHOW_CHARS = 30_000;
+/**
+ * Finished jobs whose result the model has seen are kept (for bash_output /
+ * status) without their output; beyond this many they are forgotten, oldest
+ * first. Every bash call is a job, so a long session has thousands.
+ */
+export const MAX_SETTLED_JOBS = 200;
 /** Longest wait a bash_wait call may ask for (seconds). */
 export const MAX_WAIT_SECONDS = 3_600;
 
@@ -53,6 +59,11 @@ export class OutputBuffer {
     if (this.text.length > this.max * 1.25) this.text = this.text.slice(this.text.length - this.max);
   }
 
+  /** Nothing more will be read: drop the text, keep the counters. */
+  release(): void {
+    this.text = "";
+  }
+
   /** Offset of the oldest character still kept. */
   get start(): number {
     return this.total - this.text.length;
@@ -143,6 +154,7 @@ export class ShellJobManager {
     toolCallId?: string | null;
     onData?: (data: Buffer | string) => void;
   }): ShellJob {
+    this.prune();
     const controller = new AbortController();
     const job: ShellJob = {
       id: `sh${this.next++}`,
@@ -209,6 +221,25 @@ export class ShellJobManager {
     if (job.background && !job.delivered) this.onDeliverable();
   }
 
+  /**
+   * Memory: finished jobs whose result reached the model keep no output (up
+   * to 1.25M characters each otherwise, for the life of the process), and
+   * only the newest MAX_SETTLED_JOBS of them are kept at all.
+   */
+  prune(): void {
+    let settled = 0;
+    for (let index = this.jobs.length - 1; index >= 0; index--) {
+      const job = this.jobs[index];
+      if (job.status === "running" || !job.delivered || (this.awaited.get(job) ?? 0) > 0) continue;
+      job.output.release();
+      settled += 1;
+      if (settled > MAX_SETTLED_JOBS) {
+        this.jobs.splice(index, 1);
+        this.reminded.delete(job);
+      }
+    }
+  }
+
   /** Hear the job's (cleaned) output from now on; returns the unsubscribe. */
   listen(job: ShellJob, listener: (text: string) => void): () => void {
     const set = this.listeners.get(job) ?? new Set();
@@ -304,6 +335,7 @@ export class ShellJobManager {
 
   /** Finished background jobs whose result the model has not seen (marked delivered). */
   takeDeliverable(session: string): ShellJob[] {
+    this.prune();
     const ready = this.list(session).filter((job) => job.background && job.status !== "running" && !job.delivered);
     ready.forEach((job) => { job.delivered = true; });
     return ready;

package/assets/extensions/omnirush/bgshell.ts

@@ -42,6 +42,7 @@ import {
 } from "./bgshell-lib";
 import { deliveryHub } from "./deliveries";
 import { BACKGROUND_BASH_TYPE } from "./pi-engine";
+import { sanitizeToolEnvironment } from "./secret-env";
 
 /** customType of the message that brings finished background commands back (the trace maps it to bash tool parts). */
 export const BASH_DELIVERY_TYPE = BACKGROUND_BASH_TYPE;
@@ -221,7 +222,14 @@ export default function (pi: any, options: { exec?: ShellExec; now?: () => numbe
       const operations = {
         exec: (command: string, cwd: string, execOptions: any) =>
           new Promise<{ exitCode: number | null }>((resolve, reject) => {
-            const current = manager.start({ session, command, cwd, env: execOptions?.env, toolCallId, onData: execOptions?.onData });
+            const current = manager.start({
+              session,
+              command,
+              cwd,
+              env: sanitizeToolEnvironment(execOptions?.env ?? process.env),
+              toolCallId,
+              onData: execOptions?.onData,
+            });
             job = current;
             let timer: ReturnType<typeof setTimeout> | null = null;
             const onAbort = () => { void manager.kill([current]); };

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

@@ -79,10 +79,6 @@ const MAX_JOB_AGE_MS = 7 * 24 * 60 * 60_000;
 const JOB_RETRY_BASE_MS = 60_000;
 const JOB_RETRY_MAX_MS = 60 * 60_000;
 const SIGN_OUT_ABORT_TIMEOUT_MS = 5_000;
-/** At app start, sessions active (a base, a prompt, a turn) within this long may get a final archive (startFinalCandidates). */
-const START_FINAL_WINDOW_MS = 7 * 24 * 60 * 60_000;
-/** At most this many sessions are scanned for a final archive at app start. */
-const MAX_START_FINALS = 10;
 /**
  * How long a folder policy answer (4.4: all folders, touched files) is
  * reused for folders without `.git`: sessions started meanwhile send no
@@ -515,12 +511,9 @@ export class SessionArchiver {
    * with a turn captured since its last final archive (the app quit before
    * that final, or crashed), the most recently active session on each
    * other folder (the folder may have changed while the app was closed),
-   * and every touched-files session (its files are its own). Only sessions
-   * active (a base, a prompt, a turn) within the last 7 days, not stopped
-   * and not deleted, with a base or (touched files) a touched path: a final
-   * archive never extends the window, so a chat left alone gets none a week
-   * after its last turn, however often the app starts. The most recently
-   * active first, at most 10.
+   * and every touched-files session (its files are its own). Sessions are
+   * recovered until their final archive is settled; there is no age or count
+   * cutoff that can silently lose the final workspace state.
    */
   async startFinalCandidates(): Promise<string[]> {
     try {
@@ -533,7 +526,7 @@ export class SessionArchiver {
         const parsed = sessionStateSchema.safeParse(await readJsonFile(join(this.dirs.sessions, name)));
         if (!parsed.success || name !== `${stateKey(parsed.data.session_id)}.json`) continue;
         const state = parsed.data;
-        if (state.stopped || state.ended || !(nowMs - Date.parse(state.last_activity_at) <= START_FINAL_WINDOW_MS)) continue;
+        if (state.stopped || state.ended || Date.parse(state.last_activity_at) > nowMs) continue;
         // Without a base, only a touched-files session that touched something may get one.
         if (state.next_sequence === 0 && !(state.marker === TOUCHED_MARKER && (await this.touched.has(state.session_id)))) continue;
         sessions.push(state);
@@ -548,7 +541,7 @@ export class SessionArchiver {
         roots.add(folder);
         if (state.final_due || newestOnRoot) picked.push(state.session_id);
       }
-      return picked.slice(0, MAX_START_FINALS);
+      return picked;
     } catch (error) {
       this.log("warn", "OmniRush archive could not list the sessions to check at start", { error: errorSummary(error) });
       return [];

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

@@ -39,8 +39,8 @@ import {
 import { stateKey } from "./files.js";
 import type { ArchiveLog } from "./upload.js";
 
-/** A session keeps at most this many touched paths; later ones are not archived (one log line). */
-export const MAX_TOUCHED_PATHS = 100_000;
+/** Kept as a compatibility export; touched paths are no longer silently capped. */
+export const MAX_TOUCHED_PATHS = Number.MAX_SAFE_INTEGER;
 const MAX_TOUCHED_PATH_CHARS = 4_096;
 /** A touched symlink is followed to a file inside the root through at most this many links. */
 const MAX_LINK_HOPS = 8;
@@ -387,11 +387,6 @@ export class TouchedPathStore {
       }, () => undefined);
     }
     if (session.mode === "ignored" || session.known?.has(path) || session.pending.has(path) || touchedPathParts(path) === null) return;
-    if ((session.known?.size ?? 0) + session.pending.size + session.writing.length >= MAX_TOUCHED_PATHS) {
-      if (!session.capped) this.options.log("warn", "OmniRush touched-files archive keeps a limited number of paths per session; later ones are not archived", { sessionId, limit: MAX_TOUCHED_PATHS });
-      session.capped = true;
-      return;
-    }
     session.pending.add(path);
     if (session.mode === "tracked") this.schedule();
   }

package/assets/extensions/omnirush/capture/workspace-collector.ts

@@ -92,7 +92,6 @@ const MAX_SESSION_LEDGER_ENTRIES = 512;
 const SESSION_LEDGER_LOCK_TIMEOUT_MS = 5_000;
 const SESSION_LEDGER_LOCK_STALE_MS = 60_000;
 const SESSION_LEDGER_LOCK_RETRY_MS = 25;
-const MAX_TOUCHED_PATHS = 128;
 const MAX_GIT_STATUS_ENTRIES = 500;
 const MAX_GIT_RECENT_COMMITS = 50;
 const MAX_GIT_REMOTES = 10;
@@ -1689,11 +1688,16 @@ export async function readSessionLedger(path: string | null): Promise<SessionLed
   }
 }
 
+/**
+ * The trace document (scrubbed, cut to `maxBytes`) as JSON text, plus the
+ * events it carries (the same values the text encodes): the envelope's
+ * "trace" array is written from them without parsing the text back.
+ */
 function boundedTracePayload(
   state: Pick<SessionState, "id" | "workspaceId" | "segment" | "resumed">,
   events: TraceEvent[],
   maxBytes = MAX_TRACE_BYTES,
-): Buffer {
+): { content: string; events: unknown[] } {
   // The trace is scrubbed as a JSON value, never as serialised text: a text
   // redaction inside an escaped string (`\n@app.function`) once left a
   // dangling backslash that made the whole document unparseable. Header and
@@ -1707,12 +1711,15 @@ function boundedTracePayload(
     session_resumed: state.resumed,
     events,
   }).value as Record<string, unknown> & { events: TraceEvent[] };
-  const encode = (selected: TraceEvent[], truncated: boolean, includedCount = selected.length) => Buffer.from(JSON.stringify({
-    ...header,
-    trace_truncated: truncated,
-    dropped_event_count: Math.max(0, events.length - includedCount),
-    events: selected,
-  }));
+  const encode = (selected: TraceEvent[], truncated: boolean, includedCount = selected.length) => {
+    const content = JSON.stringify({
+      ...header,
+      trace_truncated: truncated,
+      dropped_event_count: Math.max(0, events.length - includedCount),
+      events: selected,
+    });
+    return { content, events: selected as unknown[], byteLength: Buffer.byteLength(content) };
+  };
 
   // One encode settles the common case. Only an oversized trace pays for the
   // search, and that search measures each event once: the payload of a prefix
@@ -1721,7 +1728,7 @@ function boundedTracePayload(
   // probe used to be a full serialisation of the prefix, which made a flush
   // at the MAX_COLLECTOR_TRACE_EVENTS cap peak at many times the payload.
   let payload = encode(scrubbed, false);
-  if (payload.byteLength <= maxBytes) return payload;
+  if (payload.byteLength <= maxBytes) return { content: payload.content, events: payload.events };
   const wrapperBytes = (included: number) => Buffer.byteLength(JSON.stringify({
     ...header,
     trace_truncated: true,
@@ -1749,9 +1756,9 @@ function boundedTracePayload(
       data: { dropped_event_count: events.length },
     };
     const marked = encode([marker], true, 0);
-    if (marked.byteLength <= maxBytes) return marked;
+    if (marked.byteLength <= maxBytes) return { content: marked.content, events: marked.events };
   }
-  return payload;
+  return { content: payload.content, events: payload.events };
 }
 
 /** Eligible files plus the number of non-ignored paths the denylist dropped. */
@@ -2837,6 +2844,45 @@ const utf8Encoder = new TextEncoder();
  * entry exists in memory at a time, and writing allocates no buffer per chunk.
  * The compressed result is read back from disk only for the upload.
  */
+/** Strings longer than this are escaped and written a piece at a time. */
+const JSON_STRING_PIECE_CHARS = 1 << 20;
+
+/**
+ * Writes `value` as JSON, byte for byte what JSON.stringify(value) gives,
+ * without building the whole text: a plain object's long string values (a
+ * file's content, up to MAX_COLLECTOR_FILE_BYTES; the trace document, up to
+ * MAX_TRACE_BYTES) are escaped in pieces, so no escaped copy of them exists
+ * at once. Anything else goes through JSON.stringify.
+ */
+export async function writeJsonStreaming(writer: { write(text: string): Promise<void> }, value: unknown): Promise<void> {
+  if (typeof value === "string" && value.length > JSON_STRING_PIECE_CHARS) {
+    await writer.write('"');
+    for (let at = 0; at < value.length;) {
+      let end = Math.min(value.length, at + JSON_STRING_PIECE_CHARS);
+      // Never split a surrogate pair: each half alone would be escaped.
+      const last = value.charCodeAt(end - 1);
+      if (end < value.length && last >= 0xd800 && last <= 0xdbff) end -= 1;
+      await writer.write(JSON.stringify(value.slice(at, end)).slice(1, -1));
+      at = end;
+    }
+    await writer.write('"');
+    return;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && typeof (value as { toJSON?: unknown }).toJSON !== "function") {
+    await writer.write("{");
+    let first = true;
+    for (const [key, item] of Object.entries(value)) {
+      if (item === undefined || typeof item === "function" || typeof item === "symbol") continue;
+      await writer.write(`${first ? "" : ","}${JSON.stringify(key)}:`);
+      first = false;
+      await writeJsonStreaming(writer, item);
+    }
+    await writer.write("}");
+    return;
+  }
+  await writer.write(JSON.stringify(value) ?? "null");
+}
+
 class EnvelopeWriter {
   /** Uncompressed bytes written so far. */
   bytes = 0;
@@ -4105,6 +4151,17 @@ export class WorkspaceCollector {
     });
   }
 
+  /**
+   * Resolves once the session's queued uploads (traces, snapshots) went out:
+   * a caller recording a lot at once (every sub-agent of a turn) waits here
+   * between flushes, so only one flush's events wait in memory at a time.
+   */
+  async drained(sessionId: string): Promise<void> {
+    const state = this.sessions.get(sessionId);
+    if (!state) return;
+    await state.tail.catch(() => undefined);
+  }
+
   /** Resolves once every queued capture and upload for the session has settled, and its watchers are up. */
   async idle(sessionId: string): Promise<void> {
     const state = this.sessions.get(sessionId);
@@ -4377,7 +4434,7 @@ export class WorkspaceCollector {
   }
 
   private touchedPathsForUpload(state: SessionState): string[] {
-    return [...state.touchedPaths].slice(0, MAX_TOUCHED_PATHS).map(collectorPathForUpload);
+    return [...state.touchedPaths].map(collectorPathForUpload);
   }
 
   /**
@@ -4558,15 +4615,10 @@ export class WorkspaceCollector {
 
   private async uploadTrace(state: SessionState, traceEvents: TraceEvent[]): Promise<void> {
     if (traceEvents.length === 0) return;
-    const bounded = boundedTracePayload(state, traceEvents, MAX_TRACE_BYTES);
-    const content = bounded.toString("utf8");
-    let events: unknown[] = [];
-    try {
-      const parsed = JSON.parse(content) as { events?: unknown };
-      if (Array.isArray(parsed.events)) events = parsed.events;
-    } catch {
-      events = [];
-    }
+    // The text is uploaded as the trace file and its events as the envelope's
+    // trace (written event by event); neither is copied or parsed back.
+    const { content, events } = boundedTracePayload(state, traceEvents, MAX_TRACE_BYTES);
+    traceEvents.length = 0;
     await this.uploadEnvelope(state, "trace", "trace_flush", {
       extras: {
         workspace: { root_name: workspaceRootName(state.root), git: null },
@@ -4600,7 +4652,8 @@ export class WorkspaceCollector {
         "Content-Type": "application/zstd",
         "X-OmniRush-Session-ID": sessionId,
       },
-      body: compressed.buffer.slice(compressed.byteOffset, compressed.byteOffset + compressed.byteLength) as ArrayBuffer,
+      // The bytes as they are (a view, not a copy of up to 64 MiB).
+      body: compressed as Uint8Array<ArrayBuffer>,
       signal,
     });
   }
@@ -4731,7 +4784,8 @@ export class WorkspaceCollector {
       });
       await writer.write(`${head.slice(0, -1)},"files":[`);
       await body.writeFiles(async (file) => {
-        await writer.write(`${fileCount > 0 ? "," : ""}${JSON.stringify(file)}`);
+        if (fileCount > 0) await writer.write(",");
+        await writeJsonStreaming(writer, file);
         fileCount += 1;
       });
       await writer.write('],"manifest":[');
@@ -4741,7 +4795,16 @@ export class WorkspaceCollector {
         first = false;
       }
       await writer.write(`],"privacy":${JSON.stringify(body.privacy())}`);
-      if (body.trace) await writer.write(`,"trace":${JSON.stringify(body.trace)}`);
+      if (Array.isArray(body.trace)) {
+        // Event by event: the same text as one JSON.stringify of the array.
+        await writer.write(',"trace":[');
+        for (let index = 0; index < body.trace.length; index += 1) {
+          await writer.write(`${index > 0 ? "," : ""}${JSON.stringify(body.trace[index]) ?? "null"}`);
+        }
+        await writer.write("]");
+      } else if (body.trace) {
+        await writer.write(`,"trace":${JSON.stringify(body.trace)}`);
+      }
       await writer.write("}");
       compressedBytes = await writer.finish();
     } catch (error) {