omnirush 0.9.0 → 0.9.1

package/assets/extensions/omnirush/plan.ts

@@ -7,9 +7,16 @@
 //   - appends an `omnirush.plan` custom entry to the session JSONL (the
 //     tool call itself, with the whole list, reaches the trace as a tool
 //     part of the session's engine messages),
-//   - renders one line in the footer via ctx.ui.setStatus,
+//   - renders one line in the footer via ctx.ui.setStatus ("tasks 1/3 ·
+//     ▸ …": a checklist, never a mode), marked idle between requests and
+//     stale when the agent keeps working without updating it; a finished
+//     list clears,
 //   - returns the full list as the tool result.
 //
+// A sub-agent (OMNIRUSH_PARENT_SESSION set) runs in its parent's folder:
+// it keeps its list in its own session only, so it never overwrites the
+// parent's plan.json.
+//
 // Full-replace semantics (like codex update_plan): every call sends
 // the WHOLE list with current statuses.
 
@@ -27,6 +34,7 @@ import {
   planProgress,
   renderPlanFooter,
   renderPlanItems,
+  type PlanFooterPhase,
   type PlanItem,
 } from "./plan-lib";
 
@@ -42,7 +50,7 @@ const PlanParams = Type.Object({
     Type.Object({
       title: Type.String({ description: "Short task title (imperative, e.g. 'add failing test first')" }),
       status: Type.Optional(StringEnum(["pending", "in-progress", "done"] as const, {
-        description: "Task status; defaults to pending. Exactly one item should be in-progress while working.",
+        description: "Task status; defaults to pending. Exactly one item should be in-progress while working; mark it done as soon as it is finished.",
       })),
     }),
     { description: "The FULL ordered task list with current statuses (replaces the previous plan)" },
@@ -50,10 +58,21 @@ const PlanParams = Type.Object({
 });
 
 export default function (pi: ExtensionAPI) {
-  /** Show the footer for a plan (or clear it when the plan is gone). */
-  const showFooter = (items: PlanItem[] | null, ctx: any) => {
+  // Footer state: the latest list, whether it was updated during the
+  // running request ("active") or is left over ("idle"), and how many
+  // other tool calls ran since its last update.
+  let items: PlanItem[] | null = null;
+  let phase: PlanFooterPhase = "idle";
+  let toolCallsSinceUpdate = 0;
+  let lastLine: string | null | undefined;
+  let lastCtx: any = null;
+
+  const showFooter = (ctx: any = lastCtx) => {
+    if (ctx) lastCtx = ctx;
+    const line = renderPlanFooter(items, { phase, toolCallsSinceUpdate });
+    if (line === lastLine) return;
+    lastLine = line;
     try {
-      const line = items ? renderPlanFooter(items) : null;
       ctx?.ui?.setStatus?.(PLAN_STATUS_KEY, line ?? undefined);
     } catch {
       /* non-TUI host */
@@ -62,55 +81,84 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool({
     name: PLAN_TOOL_NAME,
-    label: "Plan",
+    label: "Tasks",
     description: [
-      "Maintain the ordered task list for the current work (todo list).",
-      "Send the FULL list with current statuses every time; keep exactly one item in-progress while working and mark items done as you complete them.",
-      "The list persists for the session and is visible to the user in the footer.",
+      "Maintain the ordered task list (todo list) for the current request.",
+      "Send the FULL list with current statuses every time.",
+      "Keep it current while you work: mark an item in-progress when you start it and done as soon as it is finished (not all at the end), and send the final list when the work is complete.",
+      "The user sees the list's progress in the footer.",
     ].join(" "),
     promptSnippet: "plan: maintain an ordered task list (todo) with statuses",
     promptGuidelines: [
-      "Use plan for multi-step work (3+ steps or user-requested tracking): send the full task list before starting, mark items done as you finish them, and keep exactly one item in-progress.",
+      "Use plan for multi-step work (3+ steps or user-requested tracking): send the full task list before starting, then update it as you go — mark each item done when you finish it and the next one in-progress, keeping exactly one item in-progress.",
+      "Before you end your reply, send the final list (every finished item done); drop items you decided not to do.",
       "Do not use plan for single trivial actions.",
     ],
     parameters: PlanParams,
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const items = normalizePlanItems(params.items);
-      if (!items) {
+      const next = normalizePlanItems(params.items);
+      if (!next) {
         throw new Error(
           "invalid plan items: provide a non-empty array of {title, status} objects (status pending | in-progress | done)",
         );
       }
       const updatedAt = new Date().toISOString();
       const cwd = ctx?.cwd ? resolve(ctx.cwd) : process.cwd();
-      try {
-        const planPath = join(cwd, AGENT_DIR, "plan.json");
-        await mkdir(dirname(planPath), { recursive: true });
-        await writeFile(planPath, JSON.stringify(buildPlanFile(items, updatedAt), null, 2) + "\n", "utf8");
-      } catch {
-        // Persistence is best effort: the session entry + footer still
-        // carry the plan (and the tool result returns it).
+      if (!isSubagent()) {
+        try {
+          const planPath = join(cwd, AGENT_DIR, "plan.json");
+          const sessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "") || undefined;
+          await mkdir(dirname(planPath), { recursive: true });
+          await writeFile(planPath, JSON.stringify(buildPlanFile(next, updatedAt, sessionId), null, 2) + "\n", "utf8");
+        } catch {
+          // Persistence is best effort: the session entry + footer still
+          // carry the plan (and the tool result returns it).
+        }
       }
       try {
-        pi.appendEntry(PLAN_ENTRY_TYPE, { items, updated_at: updatedAt });
+        pi.appendEntry(PLAN_ENTRY_TYPE, { items: next, updated_at: updatedAt });
       } catch {
         /* sessions may be unavailable in some hosts */
       }
-      showFooter(items, ctx);
-      const { done, total } = planProgress(items);
+      items = next;
+      phase = "active";
+      toolCallsSinceUpdate = 0;
+      showFooter(ctx);
+      const { done, total } = planProgress(next);
+      const reminder = done < total
+        ? "\nKeep this list current: mark each item done as soon as it is finished and the next one in-progress."
+        : "";
       return {
-        content: [{ type: "text", text: renderPlanItems(items) }],
-        details: { done, total, items },
+        content: [{ type: "text", text: renderPlanItems(next) + reminder }],
+        details: { done, total, items: next },
       };
     },
   });
 
-  // Restore the footer after reload/resume: the session's latest plan
-  // entry wins, falling back to the persisted plan.json.
+  // Other tool calls age the list: after enough of them without an
+  // update the footer stops pointing at a task as if it were current.
+  pi.on("tool_execution_end", (event: any, ctx: any) => {
+    if (!items || event?.toolName === PLAN_TOOL_NAME) return;
+    toolCallsSinceUpdate += 1;
+    showFooter(ctx);
+  });
+
+  // The request is over: an unfinished list is shown as idle (a finished
+  // one is already cleared) until the model updates it again.
+  pi.on("agent_end", (_event: any, ctx: any) => {
+    phase = "idle";
+    showFooter(ctx);
+  });
+
+  // Restore after reload/resume from THIS session's latest plan entry
+  // (a new session starts with no list, even when the folder still holds
+  // another session's plan.json). Restored lists are idle.
   pi.on("session_start", async (_event: any, ctx: any) => {
+    items = null;
+    phase = "idle";
+    toolCallsSinceUpdate = 0;
     try {
-      let items: PlanItem[] | null = null;
       const entries = ctx?.sessionManager?.getEntries?.() ?? [];
       for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];
@@ -119,17 +167,24 @@ export default function (pi: ExtensionAPI) {
           if (items) break;
         }
       }
-      if (!items && ctx?.cwd) {
+      const sessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "");
+      if (!items && sessionId && ctx?.cwd) {
         try {
           const text = await readFile(join(resolve(ctx.cwd), AGENT_DIR, "plan.json"), "utf8");
-          items = parsePlanFile(text)?.items ?? null;
+          const file = parsePlanFile(text);
+          if (file?.session_id === sessionId) items = file.items;
         } catch {
           /* no persisted plan */
         }
       }
-      showFooter(items, ctx);
     } catch {
       /* footer is cosmetic */
     }
+    lastLine = undefined;
+    showFooter(ctx);
   });
 }
+
+function isSubagent(): boolean {
+  return Boolean((process.env.OMNIRUSH_PARENT_SESSION || "").trim());
+}

package/assets/extensions/omnirush/subagent-marker.ts

@@ -0,0 +1,21 @@
+// A sub-agent process (spawn_agents sets OMNIRUSH_PARENT_SESSION) marks its
+// own session with an `omnirush-subagent` entry naming its parent, before
+// the task: should that session ever be continued as a main session, its
+// first prompt is known to be the parent agent's (collector.ts records it
+// as synthetic). Kept out of collector.ts because sub-agent processes do
+// not load the collector (index.ts keeps children light).
+
+import { SUBAGENT_ENTRY_TYPE } from "./pi-engine";
+
+export default function markSubagentSession(pi: any, parentSession: string = (process.env.OMNIRUSH_PARENT_SESSION || "").trim()): void {
+  if (!parentSession) return;
+  pi.on("session_start", (_event: any, ctx: any) => {
+    try {
+      const entries = ctx?.sessionManager?.getEntries?.() ?? [];
+      if (entries.some((entry: any) => entry?.type === "custom" && entry.customType === SUBAGENT_ENTRY_TYPE)) return;
+      pi.appendEntry(SUBAGENT_ENTRY_TYPE, { parent_session_id: parentSession });
+    } catch {
+      /* never in the child's way */
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",

package/scripts/smoke-packages.py

@@ -28,6 +28,7 @@ REQUIRED_PATHS = [
     "src/bin.js",
     "src/lib.js",
     "src/compat.js",
+    "src/sessions.js",
     "scripts/postinstall.js",
     "scripts/brand-engine.js",
     "assets/extensions/omnirush/index.ts",

package/src/bin.js

@@ -55,6 +55,7 @@ import {
 } from "./lib.js";
 import { installManagedTools } from "./tools.js";
 import { engineEnvAliases, migrateAgentDir, projectConfigDirName, resolveAgentDir } from "./compat.js";
+import { customSessionDir, moveLegacySubagentSessions } from "./sessions.js";
 import { ensureRuntime, managedBunPath } from "../scripts/postinstall.js";
 import {
   clearAuth,
@@ -162,6 +163,23 @@ function ensureDirs() {
   installDefaultThinkingLevel();
 }
 
+/**
+ * Sub-agent sessions older releases wrote next to the user's are moved to
+ * their session dir's subagents/ folder before the core picks a session,
+ * so /resume lists only the user's sessions and --continue resumes the
+ * user's last one (src/sessions.js). Not on a run that fell back to the
+ * pre-0.9 folder, which is left as it was.
+ */
+function tidySubagentSessions(args) {
+  if (AGENT.legacyDir && PI_AGENT_DIR === AGENT.legacyDir) return;
+  try {
+    const custom = customSessionDir(args, process.env, PI_SETTINGS_JSON, os.homedir());
+    moveLegacySubagentSessions({ agentDir: PI_AGENT_DIR, extraDirs: custom ? [custom] : [] });
+  } catch {
+    /* best effort */
+  }
+}
+
 // Product default effort (P2): xhigh. Fills an ABSENT
 // defaultThinkingLevel in the agent settings only — an explicit user
 // choice always wins; the models' thinkingLevelMap is untouched.
@@ -886,6 +904,7 @@ async function cmdRun() {
   // flags win when present.
   // `omnirush run` takes no other arguments; only yolo's --approve passes.
   const yolo = launchYolo(process.argv.slice(3).filter((a) => a === "--yolo" || a === "--no-yolo"));
+  tidySubagentSessions([]);
   const piArgs = withModelDefaults(yolo.args, resolveModelDefaults(process.env));
   spawnAgent(cmd, [...args, ...piArgs], {
     stdio: "inherit",
@@ -950,7 +969,8 @@ Session commands (inside the agent):
   /mcp     MCP server state (/mcp reconnect [server])
   /subagents  model and effort of the sub-agents (/subagents model <id|same>,
               /subagents effort <level|same>; saved for the next runs)
-  /agents  sub-agents of this session (/agents cancel <id|all>)
+  /agents  sub-agents of this session (/agents cancel <id|all>,
+           /agents memory: the memory they may use)
   /jobs    background shell commands (/jobs kill <id|all>)
   /voice   dictate prompts: hold Space to talk (/voice hold|tap|off|status)
   /mode    approval mode: guarded (asks before git writes and destructive
@@ -972,6 +992,12 @@ Environment:
   OMNIRUSH_BASH_FOREGROUND_SECONDS
                          how long a shell command runs in the foreground before
                          it continues in the background (default 300)
+  OMNIRUSH_AGENT_MIN_FREE / OMNIRUSH_AGENT_MEMORY_BUDGET / OMNIRUSH_AGENT_CRITICAL_FREE
+                         sub-agents start while this much RAM stays free
+                         (default 20%), all agents stay under this budget
+                         (default 50% of RAM), and none start below this
+                         (default 10%); e.g. 25% or 6G. OMNIRUSH_AGENT_MEMORY=off
+                         starts them without checking memory
   OMNIRUSH_<SETTING>     the agent core's own settings (e.g. OMNIRUSH_CACHE_RETENTION;
                          the older PI_<SETTING> names still work)
 
@@ -1058,6 +1084,7 @@ async function runCore(args) {
   const { cmd: bin, args: runtimeArgs } = await runtimeFor(entry);
   const yolo = launchYolo(args);
   const piArgs = withModelDefaults(yolo.args, resolveModelDefaults(process.env));
+  tidySubagentSessions(piArgs);
   spawnAgent(bin, [...runtimeArgs, ...piArgs], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth), ...yolo.env },

package/src/sessions.js

@@ -0,0 +1,222 @@
+// Sub-agent sessions out of the user's resume list.
+//
+// spawn_agents children are headless agent runs with session files of
+// their own. Up to 0.9.0 they were written next to the user's sessions
+// (<agentDir>/sessions/<cwd-slug>/), so the core's session picker
+// (/resume) listed every sub-agent run and --continue picked whichever
+// session file changed last — often a background sub-agent's rather than
+// the user's conversation. Children now go to <session dir>/subagents/
+// (agents-lib.ts subagentSessionDir), which the core never lists.
+//
+// moveLegacySubagentSessions puts the children older releases left in a
+// session dir into that folder too (moved, never deleted: the collector
+// still finds them there when a resumed session records its sub-agents).
+// It runs at every agent launch before the core picks a session, and
+// stays cheap on large folders: a marker per session dir records when it
+// was last sorted, and only files changed since then are opened (their
+// first lines only). Files changed in the last minute are left for the
+// next launch, in case an older release is still writing them.
+//
+// A child is recognised from the top of its session file, by the same
+// signals the collector uses (pi-engine.ts subagentTask): the marker entry
+// a sub-agent writes into its own session before its task
+// (SUBAGENT_ENTRY_TYPE), or — sessions of releases that wrote no marker —
+// a first user message "Task: <task>" (SUBAGENT_TASK_PREFIX), confirmed by
+// the role prompt every sub-agent has run with since 0.5.4 (appended to
+// the system prompt: "You are a <role> subagent ..."), which the file
+// itself carries, so no other session has to be read.
+
+import fs from "node:fs";
+import path from "node:path";
+
+/** Same name as agents-lib.ts SUBAGENT_SESSIONS_DIR. */
+export const SUBAGENT_SESSIONS_DIR = "subagents";
+/** Same values as pi-engine.ts SUBAGENT_ENTRY_TYPE / SUBAGENT_TASK_PREFIX. */
+export const SUBAGENT_ENTRY_TYPE = "omnirush-subagent";
+export const SUBAGENT_TASK_PREFIX = "Task: ";
+/** Per session dir: when it was last sorted (a .json file: the core only lists *.jsonl). */
+export const SORT_MARKER = ".subagents-sorted.json";
+/** Files changed more recently than this are left for the next launch. */
+export const SETTLE_MS = 60_000;
+/** How much of a session file is read looking for its first user message. */
+const HEAD_LIMIT = 1024 * 1024;
+const CHUNK = 64 * 1024;
+
+const ROLE_PROMPT = /\bYou are an? [\w-]+ subagent\b/;
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => (part && typeof part.text === "string" ? part.text : "")).join("");
+}
+
+/**
+ * Whether a session file is a sub-agent run: a sub-agent marker entry
+ * before its first user message, or a first user message "Task: ..."
+ * after a system prompt with a sub-agent role. Reads the file only up to
+ * that first user message.
+ */
+export function isSubagentSession(file, fsImpl = fs) {
+  let fd;
+  try {
+    fd = fsImpl.openSync(file, "r");
+  } catch {
+    return false;
+  }
+  try {
+    const buffer = Buffer.alloc(CHUNK);
+    let pending = "";
+    let read = 0;
+    let header = null;
+    let rolePrompt = false;
+    while (read < HEAD_LIMIT) {
+      const bytes = fsImpl.readSync(fd, buffer, 0, CHUNK, read);
+      if (bytes <= 0) break;
+      read += bytes;
+      pending += buffer.toString("utf8", 0, bytes);
+      let newline;
+      while ((newline = pending.indexOf("\n")) !== -1) {
+        const line = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        if (!line.trim()) continue;
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          return false;
+        }
+        if (!header) {
+          // A fork (parentSession) is the user's own branch of a session.
+          if (entry?.type !== "session" || entry.parentSession) return false;
+          header = entry;
+          continue;
+        }
+        if (entry?.type === "custom" && entry.customType === SUBAGENT_ENTRY_TYPE) return true;
+        if (entry?.type !== "message") continue;
+        const message = entry.message;
+        if (message?.role === "system") {
+          const addendum = message.sections?.addendum;
+          if (typeof addendum === "string" && ROLE_PROMPT.test(addendum)) rolePrompt = true;
+          continue;
+        }
+        if (message?.role === "user") return rolePrompt && textOf(message.content).startsWith(SUBAGENT_TASK_PREFIX);
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    try {
+      fsImpl.closeSync(fd);
+    } catch {
+      /* closed */
+    }
+  }
+}
+
+function readMarker(dir, fsImpl) {
+  try {
+    const value = JSON.parse(fsImpl.readFileSync(path.join(dir, SORT_MARKER), "utf8"));
+    return Number.isFinite(value?.sortedUpTo) ? value.sortedUpTo : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Move the sub-agent sessions older releases left in `dir` into
+ * dir/subagents/. Returns how many were moved. Never throws.
+ */
+export function sortSessionDir(dir, { fsImpl = fs, now = Date.now } = {}) {
+  let moved = 0;
+  try {
+    const since = readMarker(dir, fsImpl);
+    const cutoff = now() - SETTLE_MS;
+    let names;
+    try {
+      names = fsImpl.readdirSync(dir);
+    } catch {
+      return 0;
+    }
+    let sawFiles = false;
+    for (const name of names) {
+      if (!name.endsWith(".jsonl")) continue;
+      sawFiles = true;
+      const file = path.join(dir, name);
+      let stats;
+      try {
+        stats = fsImpl.statSync(file);
+      } catch {
+        continue;
+      }
+      if (!stats.isFile()) continue;
+      // Sorted already (a user session): only changes since are looked at.
+      if (stats.mtimeMs < since) continue;
+      // Maybe still being written by an older release: next launch.
+      if (stats.mtimeMs >= cutoff) continue;
+      if (!isSubagentSession(file, fsImpl)) continue;
+      const target = path.join(dir, SUBAGENT_SESSIONS_DIR);
+      try {
+        fsImpl.mkdirSync(target, { recursive: true });
+        const dest = path.join(target, name);
+        if (fsImpl.existsSync(dest)) continue;
+        fsImpl.renameSync(file, dest);
+        moved++;
+      } catch {
+        /* left where it is; tried again next launch */
+      }
+    }
+    if (sawFiles) {
+      const tmp = path.join(dir, `${SORT_MARKER}.${process.pid}.tmp`);
+      fsImpl.writeFileSync(tmp, JSON.stringify({ version: 1, sortedUpTo: cutoff }) + "\n");
+      fsImpl.renameSync(tmp, path.join(dir, SORT_MARKER));
+    }
+  } catch {
+    /* best effort: never in the way of a launch */
+  }
+  return moved;
+}
+
+/**
+ * Sort every project's session dir under <agentDir>/sessions (the picker's
+ * "all" scope lists them all) plus any custom session dir in use.
+ */
+export function moveLegacySubagentSessions({ agentDir, extraDirs = [], fsImpl = fs, now = Date.now } = {}) {
+  const dirs = [];
+  const root = path.join(agentDir, "sessions");
+  try {
+    for (const entry of fsImpl.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory()) dirs.push(path.join(root, entry.name));
+    }
+  } catch {
+    /* no sessions yet */
+  }
+  for (const dir of extraDirs) {
+    if (typeof dir === "string" && dir && !dirs.includes(path.resolve(dir))) dirs.push(path.resolve(dir));
+  }
+  let moved = 0;
+  for (const dir of dirs) moved += sortSessionDir(dir, { fsImpl, now });
+  return moved;
+}
+
+/**
+ * The custom session dir an agent launch uses, if any: --session-dir,
+ * else OMNIRUSH_/PI_CODING_AGENT_SESSION_DIR, else the "sessionDir"
+ * setting (as the core resolves it).
+ */
+export function customSessionDir(args, env, settingsFile, home, fsImpl = fs) {
+  const expand = (value) => (value === "~" ? home : value.startsWith("~/") ? path.join(home, value.slice(2)) : value);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--session-dir" && args[i + 1]) return expand(args[i + 1]);
+    if (args[i].startsWith("--session-dir=")) return expand(args[i].slice("--session-dir=".length));
+  }
+  const fromEnv = env.OMNIRUSH_CODING_AGENT_SESSION_DIR || env.PI_CODING_AGENT_SESSION_DIR;
+  if (fromEnv) return expand(fromEnv);
+  try {
+    const value = JSON.parse(fsImpl.readFileSync(settingsFile, "utf8"))?.sessionDir;
+    if (typeof value === "string" && value.trim()) return expand(value.trim());
+  } catch {
+    /* no settings */
+  }
+  return null;
+}