omnirush 0.8.6 → 0.9.1

package/assets/extensions/omnirush/bgshell.ts

@@ -0,0 +1,392 @@
+// omnirush-bgshell — long shell commands move to the background instead of
+// being killed.
+//
+// Overrides the built-in bash tool (same execution, output handling and
+// rendering: pi's own bash tool definition runs each call, with an
+// execution backend that keeps the process in a job — bgshell-lib.ts):
+//   - a command that finishes within its foreground window (the call's
+//     `timeout` in seconds, default 300, OMNIRUSH_BASH_FOREGROUND_SECONDS)
+//     answers the call as before;
+//   - one still running then is NOT killed: it moves to the background and
+//     the call returns its id and the output so far; `run_in_background:
+//     true` does that at once (servers, watchers, long builds);
+//   - bash_output (new output and status), bash_wait and bash_kill manage
+//     background commands; when one finishes, its result comes back to the
+//     main agent as a message, the way background sub-agents' results do
+//     (deliveries.ts): steered into a running turn, starting a turn when the
+//     agent is idle, and holding a one-shot run open until it arrives;
+//   - background commands still running when the session ends (exit, /new,
+//     /resume) are stopped with a message saying so; their output is kept
+//     in the session (and so in the trace) as a bash tool part.
+
+import { createBashToolDefinition, createLocalBashOperations } from "@earendil-works/pi-coding-agent";
+import { writeSync } from "node:fs";
+import { Type } from "typebox";
+
+import {
+  BGSHELL_HOOK,
+  type BgShellHook,
+  DEFAULT_FOREGROUND_SECONDS,
+  jobDetails,
+  jobOutcome,
+  MAX_FOREGROUND_SECONDS,
+  MAX_WAIT_SECONDS,
+  renderJobDelivery,
+  renderJobResult,
+  renderJobStatus,
+  shortCommand,
+  type ShellExec,
+  type ShellJob,
+  ShellJobManager,
+  tailText,
+} from "./bgshell-lib";
+import { deliveryHub } from "./deliveries";
+import { BACKGROUND_BASH_TYPE } from "./pi-engine";
+
+/** 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;
+/** customType of the one-shot reminder about background commands still running. */
+export const BASH_REMINDER_TYPE = "omnirush-bash-reminder";
+
+class MovedToBackground extends Error {
+  constructor() {
+    super("moved to the background");
+  }
+}
+
+/** The default foreground window (seconds), OMNIRUSH_BASH_FOREGROUND_SECONDS overriding it. */
+export function defaultForegroundSeconds(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = Number(String(env.OMNIRUSH_BASH_FOREGROUND_SECONDS ?? "").trim());
+  return Number.isFinite(raw) && raw > 0 ? Math.min(raw, MAX_FOREGROUND_SECONDS) : DEFAULT_FOREGROUND_SECONDS;
+}
+
+/** The foreground window of one call: its `timeout` (seconds), bounded; placeholders (<= 0) take the default. */
+export function foregroundSeconds(timeout: unknown, fallback: number = defaultForegroundSeconds()): number {
+  if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0) return fallback;
+  return Math.min(Math.max(timeout, 1), MAX_FOREGROUND_SECONDS);
+}
+
+function plural(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+
+export default function (pi: any, options: { exec?: ShellExec; now?: () => number } = {}) {
+  const hub = deliveryHub(pi);
+  const exec: ShellExec = options.exec ?? (createLocalBashOperations().exec as ShellExec);
+  const manager = new ShellJobManager({ exec, ...(options.now ? { now: options.now } : {}), onDeliverable: () => hub.notify() });
+  const fgDefault = defaultForegroundSeconds();
+
+  /** New output of each job, marked read. */
+  const collect = (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);
+      return [{
+        customType: BASH_DELIVERY_TYPE,
+        content: renderJobDelivery(parts),
+        details: {
+          jobs: parts.map(({ job, text, dropped }) => {
+            const shown = tailText(text);
+            return jobDetails(job, shown.text, shown.truncated || dropped > 0);
+          }),
+        },
+      }];
+    },
+    changed: () => manager.changed(),
+    beforeEnd: (session) => {
+      const jobs = manager.remindable(session);
+      if (jobs.length === 0) return null;
+      return {
+        customType: BASH_REMINDER_TYPE,
+        content: [
+          `This run is about to end while ${plural(jobs.length, "background command")} you started still run${jobs.length === 1 ? "s" : ""}:`,
+          renderJobStatus(jobs),
+          "If you need their results, wait for them with bash_wait; stop the ones you no longer need (servers, watchers) with bash_kill. Background commands still running when you finish are stopped.",
+        ].join("\n"),
+        details: { jobs: jobs.map((job) => job.id) },
+      };
+    },
+  });
+
+  // --- 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). */
+  let stoppedAtEnd: ShellJob[] = [];
+  const stopAll = async (session?: string): Promise<ShellJob[]> => {
+    const live = manager.running(session);
+    if (live.length === 0) return [];
+    const stopped = await manager.kill(live, { interrupted: true });
+    stoppedAtEnd.push(...stopped);
+    // Kept in the session (and so in the trace) like any tool output; the
+    // model never sees it — nothing runs after this.
+    const background = stopped.filter((job) => job.background);
+    if (background.length > 0) {
+      try {
+        const parts = collect(background);
+        pi.sendMessage(
+          {
+            customType: BASH_DELIVERY_TYPE,
+            content: [
+              `The session ended: ${plural(background.length, "background command")} stopped. Output since it was last read:`,
+              "",
+              parts.map(({ job, text, dropped }) => renderJobResult(job, text, { dropped }).text).join("\n\n---\n\n"),
+            ].join("\n"),
+            display: false,
+            details: {
+              jobs: parts.map(({ job, text, dropped }) => {
+                const shown = tailText(text);
+                return jobDetails(job, shown.text, shown.truncated || dropped > 0);
+              }),
+            },
+          },
+          { triggerTurn: false },
+        );
+      } catch {
+        /* the session may already be gone */
+      }
+    }
+    return stopped;
+  };
+  const hook: BgShellHook = {
+    async stopAll(sessionId?: string) {
+      const stopped = await stopAll(sessionId);
+      return stopped.map((job) => ({ id: job.id, command: job.command }));
+    },
+  };
+  (globalThis as any)[BGSHELL_HOOK] = hook;
+
+  pi.on("session_shutdown", async (event: any, ctx: any) => {
+    await stopAll();
+    const stopped = stoppedAtEnd.filter((job) => job.background || job.status === "killed");
+    stoppedAtEnd = [];
+    if (stopped.length === 0) return;
+    const text = `omnirush: stopped ${plural(stopped.length, "background command")} as the session ended: ${stopped
+      .map((job) => `${job.id} (${shortCommand(job.command, 60)})`)
+      .join(", ")}`;
+    if (!event?.reason || event.reason === "quit") {
+      // After the terminal is restored, so the line stays readable.
+      process.once("exit", () => {
+        try {
+          writeSync(2, `${text}\n`);
+        } catch {
+          /* stderr may be closed */
+        }
+      });
+    } else if (ctx?.ui?.notify) {
+      ctx.ui.notify(text, "warning");
+    }
+  });
+
+  // --- the bash tool ---------------------------------------------------------------
+
+  const base = createBashToolDefinition(process.cwd());
+  const BashParams = Type.Object({
+    command: Type.String({ description: "Shell command to execute" }),
+    timeout: Type.Optional(Type.Number({
+      description: `Seconds to wait for the command in the foreground (default ${fgDefault}, at most ${MAX_FOREGROUND_SECONDS}). A command still running then is NOT killed: it moves to the background, you get its id and the output so far, and its result is delivered to you when it finishes`,
+    })),
+    run_in_background: Type.Optional(Type.Boolean({
+      description: "true: start the command in the background and return at once with its id (dev servers, watchers, long builds or test suites while you do other work). Its result is delivered to you as a message when it finishes",
+    })),
+  });
+
+  pi.registerTool({
+    ...base,
+    name: "bash",
+    label: "bash",
+    description: [
+      "Execute a bash command in the current working directory. Returns stdout and stderr (output is truncated to the last lines; full output is saved to a temp file).",
+      `A command that runs longer than its foreground window (timeout, default ${fgDefault} s) is not killed: it continues in the background and its result arrives later as a message.`,
+      "run_in_background: true starts it in the background right away.",
+      "bash_output reads a background command's new output and status, bash_wait waits for it, bash_kill stops it.",
+    ].join(" "),
+    promptSnippet: "Execute bash commands (ls, grep, find, etc.); long-running commands continue in the background",
+    promptGuidelines: [
+      ...(Array.isArray(base.promptGuidelines) ? base.promptGuidelines : []),
+      "Long-running commands (dev servers, watchers, long builds or test suites) you do not need to wait for: bash with run_in_background: true, then keep working; their result arrives as a message when they finish, so do not poll bash_output in a loop.",
+      "Stop background commands you no longer need (servers, watchers) with bash_kill before you finish.",
+    ],
+    parameters: BashParams,
+
+    async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any, ctx: any) {
+      const session = hub.sessionOf(ctx) || "session";
+      const explicit = params?.run_in_background === true;
+      const windowMs = explicit ? 0 : foregroundSeconds(params?.timeout, fgDefault) * 1000;
+      let job: ShellJob | null = null;
+
+      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 });
+            job = current;
+            let timer: ReturnType<typeof setTimeout> | null = null;
+            const onAbort = () => { void manager.kill([current]); };
+            const cleanup = () => {
+              if (timer) clearTimeout(timer);
+              execOptions?.signal?.removeEventListener?.("abort", onAbort);
+            };
+            const moveToBackground = () => {
+              if (current.status !== "running") return;
+              cleanup();
+              manager.toBackground(current, explicit);
+              reject(new MovedToBackground());
+            };
+            if (execOptions?.signal) {
+              if (execOptions.signal.aborted) onAbort();
+              else execOptions.signal.addEventListener("abort", onAbort, { once: true });
+            }
+            if (windowMs <= 0) moveToBackground();
+            else timer = setTimeout(moveToBackground, windowMs);
+            void current.done.then(() => {
+              if (current.background) return;
+              cleanup();
+              // Its output reaches the model through this tool result.
+              current.delivered = true;
+              if (current.status === "killed") reject(new Error("aborted"));
+              else if (current.status === "failed") reject(new Error(current.error ?? "command failed"));
+              else resolve({ exitCode: current.exitCode });
+            });
+          }),
+      };
+
+      const definition = createBashToolDefinition(ctx?.cwd ? String(ctx.cwd) : process.cwd(), { operations: operations as any });
+      try {
+        return await definition.execute(toolCallId, { command: params?.command }, signal, onUpdate, ctx);
+      } catch (error) {
+        const moved = job as ShellJob | null;
+        if (!(error instanceof MovedToBackground) || !moved) throw error;
+        const hint = "Its result arrives as a message in this conversation when it finishes (no need to poll). bash_output reads its new output, bash_wait waits for it, bash_kill stops it.";
+        let text: string;
+        if (explicit) {
+          text = `Started in the background as ${moved.id}: ${shortCommand(moved.command, 200)}\n${hint}`;
+        } else {
+          const soFar = tailText(moved.output.since(0).text);
+          text = [
+            `Still running after ${Math.round(windowMs / 1000)} s — moved to the background as ${moved.id} (not killed).`,
+            hint,
+            "",
+            "Output so far:",
+            `${soFar.truncated ? "[earlier output omitted]\n" : ""}${soFar.text.trim() ? soFar.text.replace(/\s+$/, "") : "(no output yet)"}`,
+          ].join("\n");
+        }
+        return {
+          content: [{ type: "text", text }],
+          details: { background: { id: moved.id, command: moved.command, explicit, started_at: moved.startedAt } },
+        };
+      }
+    },
+  });
+
+  // --- companion tools -----------------------------------------------------------
+
+  const IdsParam = Type.Optional(Type.Array(Type.String(), {
+    description: 'Background command ids (e.g. "sh2"); omit (or "all") for every background command of this session',
+  }));
+
+  const readResult = (jobs: ShellJob[], unknown: string[]) => {
+    const parts = collect(jobs);
+    const sections = parts.map(({ job, text, dropped }) => renderJobResult(job, text, { dropped }).text);
+    if (unknown.length) sections.push(`Unknown ids: ${unknown.join(", ")}`);
+    return {
+      content: [{ type: "text", text: sections.join("\n\n---\n\n") || "No background commands in this session." }],
+      details: {
+        jobs: parts.map(({ job, text, dropped }) => {
+          const shown = tailText(text);
+          return jobDetails(job, shown.text, shown.truncated || dropped > 0);
+        }),
+      },
+    };
+  };
+
+  pi.registerTool({
+    name: "bash_output",
+    label: "bash output",
+    description: "A background command's output since you last read it, and its status (running, or its exit code). Without an id: the status of every background command of this session. Results are delivered automatically when a command finishes — use this to check progress, not to poll in a loop.",
+    promptSnippet: "bash_output: new output and status of a background command",
+    parameters: Type.Object({
+      id: Type.Optional(Type.String({ description: 'Background command id (e.g. "sh2"); omit for the status of all' })),
+    }),
+    async execute(_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: any, ctx: any) {
+      const session = hub.sessionOf(ctx) || "session";
+      const id = typeof params?.id === "string" ? params.id.trim() : "";
+      if (!id || id === "all") {
+        const jobs = manager.resolve(session, []).jobs;
+        return {
+          content: [{ type: "text", text: renderJobStatus(jobs) }],
+          details: { jobs: jobs.map((job) => ({ id: job.id, command: job.command, status: job.status, exit_code: job.exitCode })) },
+        };
+      }
+      const { jobs, unknown } = manager.resolve(session, [id]);
+      return readResult(jobs, unknown);
+    },
+  });
+
+  pi.registerTool({
+    name: "bash_wait",
+    label: "bash wait",
+    description: "Wait until background commands finish (default: every running one) and return their new output and exit codes. timeout_seconds bounds the WAIT only — the commands keep running past it.",
+    promptSnippet: "bash_wait: wait for background commands to finish",
+    parameters: Type.Object({
+      ids: IdsParam,
+      timeout_seconds: Type.Optional(Type.Number({ description: `Leave out (or 0) to wait until they finish (at most ${MAX_WAIT_SECONDS} s per call); otherwise stop WAITING after this many seconds` })),
+    }),
+    async execute(_toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any, ctx: any) {
+      const session = hub.sessionOf(ctx) || "session";
+      const explicit = Array.isArray(params?.ids) && params.ids.length > 0 && !params.ids.includes("all");
+      const resolved = manager.resolve(session, params?.ids);
+      const jobs = explicit ? resolved.jobs : resolved.jobs.filter((job) => job.status === "running" || !job.delivered);
+      if (jobs.length === 0 && resolved.unknown.length === 0) {
+        return { content: [{ type: "text", text: "No background commands to wait for." }], details: { jobs: [] } };
+      }
+      const seconds = typeof params?.timeout_seconds === "number" && params.timeout_seconds > 0
+        ? Math.min(params.timeout_seconds, MAX_WAIT_SECONDS)
+        : MAX_WAIT_SECONDS;
+      onUpdate?.({ content: [{ type: "text", text: `bash_wait: waiting for ${jobs.filter((job) => job.status === "running").map((job) => job.id).join(", ") || "nothing"}` }], details: {} });
+      await manager.wait(jobs, { timeoutMs: seconds * 1000, ...(signal ? { signal } : {}) });
+      return readResult(jobs, resolved.unknown);
+    },
+  });
+
+  pi.registerTool({
+    name: "bash_kill",
+    label: "bash kill",
+    description: 'Stop background commands (the whole process tree) by id, or ["all"]; returns their last output.',
+    promptSnippet: "bash_kill: stop background commands",
+    parameters: Type.Object({
+      ids: Type.Array(Type.String(), { description: 'Background command ids, or ["all"]', minItems: 1 }),
+    }),
+    async execute(_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: any, ctx: any) {
+      const session = hub.sessionOf(ctx) || "session";
+      const { jobs, unknown } = manager.resolve(session, params?.ids);
+      const live = jobs.filter((job) => job.status === "running");
+      await manager.kill(live);
+      if (live.length === 0) {
+        const done = jobs.map((job) => `${job.id} already ${jobOutcome(job)}`);
+        return {
+          content: [{ type: "text", text: `Nothing to stop${done.length ? ` (${done.join(", ")})` : ""}${unknown.length ? `; unknown ids: ${unknown.join(", ")}` : ""}.` }],
+          details: { jobs: [] },
+        };
+      }
+      return readResult(live, unknown);
+    },
+  });
+
+  pi.registerCommand("jobs", {
+    description: "Background shell commands of this session; /jobs kill <id|all> stops them",
+    handler: async (args: string, ctx: any) => {
+      const session = hub.sessionOf(ctx) || "session";
+      const words = String(args ?? "").trim().split(/\s+/).filter(Boolean);
+      if (words[0] === "kill") {
+        const { jobs } = manager.resolve(session, words.slice(1).length ? words.slice(1) : ["all"]);
+        const stopped = await manager.kill(jobs.filter((job) => job.status === "running"), { deliver: true });
+        ctx?.ui?.notify?.(stopped.length ? `Stopped ${stopped.map((job) => job.id).join(", ")}.` : "No running background commands.");
+        return;
+      }
+      ctx?.ui?.notify?.(renderJobStatus(manager.resolve(session, []).jobs));
+    },
+  });
+}

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

@@ -1689,11 +1689,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 +1712,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 +1729,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 +1757,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 +2845,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 +4152,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);
@@ -4558,15 +4616,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 +4653,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 +4785,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 +4796,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) {