omnirush 0.9.0 → 0.9.1

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/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) {