jeo-code 0.8.41 → 0.8.43

package/src/commands/launch.ts

@@ -19,7 +19,8 @@ import { parseInThreadConfigCommand } from "../agent/notify/config-commands";
 
 import { createTodoTool, TODO_TOOL_PROTOCOL_LINE } from "../agent/todo-tool";
 import { createJobTool, JOB_TOOL_PROTOCOL_LINE } from "../agent/job-tool";
-import { JobRegistry } from "../agent/job-registry";
+import { JobRegistry, type MonitorJobEvent } from "../agent/job-registry";
+import { createMonitorTool, MONITOR_TOOL_PROTOCOL_LINE } from "../agent/monitor-tool";
 import { createIrcTool, IRC_TOOL_PROTOCOL_LINE } from "../agent/irc-tool";
 import { createGoalTool, GOAL_TOOL_PROTOCOL_LINE } from "../agent/goal-tool";
 import { createApproveTool, APPROVE_TOOL_PROTOCOL_LINE } from "../agent/approve-tool";
@@ -185,6 +186,7 @@ import {
   gatedStdout,
   formatTaskSubEvent,
   logTaskSubEvent,
+  formatMonitorJobEvent,
   createStreamEvents,
   shouldUseOneShotTui,
 } from "./launch/stream";
@@ -560,7 +562,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // pi-style: load project context (JEO.md / AGENTS.md / .jeo/context.md / CLAUDE.md) into the prompt.
   const contextFiles = await loadProjectContext(cwd);
 
-  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "eval", "todo", "subagent", "job", "irc", "goal", "approve", "ast_grep", "ast_edit", "computer", "lsp", "lsp_rename", "debug", "browser"]);
+  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "eval", "todo", "subagent", "job", "monitor", "irc", "goal", "approve", "ast_grep", "ast_edit", "computer", "lsp", "lsp_rename", "debug", "browser"]);
   let allowedTools = new Set(KNOWN_TOOLS);
 
   if (flags.noTools) {
@@ -633,6 +635,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     (allowedTools.has("subagent") ? "\n\nDetached subagents: " + SUBAGENT_TOOL_PROTOCOL_LINE +
     " Launch background work with task {\"detached\": true, \"role\": <role>, \"task\": <assignment>}; it returns a subagent id immediately so you can keep working and collect the result later." : "") +
     (allowedTools.has("job") ? "\n\nBackground jobs: " + JOB_TOOL_PROTOCOL_LINE : "") +
+    (allowedTools.has("monitor") ? "\n\nBackground monitors: " + MONITOR_TOOL_PROTOCOL_LINE : "") +
     (allowedTools.has("irc") ? "\n\nPeer messaging: " + IRC_TOOL_PROTOCOL_LINE : "") +
     (allowedTools.has("goal") ? "\n\nGoal tracking: " + GOAL_TOOL_PROTOCOL_LINE : "") +
     (allowedTools.has("approve") ? "\n\nPlan approval: " + APPROVE_TOOL_PROTOCOL_LINE : "") +
@@ -1422,7 +1425,32 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // #9: per-turn registry for DETACHED subagents (task{detached:true}); the
       // `subagent` tool controls them and cancelAll() in finally prevents orphans.
       const subagentRegistry = new SubagentRegistry();
+      // TUI callbacks are scoped to this registry. cancelAll() may trigger a detached
+      // run's final event after the turn is complete; do not let it paint a freshly
+      // reset later TUI. Non-TUI streams retain direct event logging.
+      let acceptingTuiSubagentEvents = true;
+      const onSubagentEvent = useTui
+        ? (e: TaskSubEvent) => {
+            if (acceptingTuiSubagentEvents) tui?.onSubagentEvent(e);
+          }
+        : (e: TaskSubEvent) => logTaskSubEvent(e);
       const jobRegistry = new JobRegistry();
+      // Monitor output stays bounded and turn-scoped. It deliberately feeds the
+      // engine's observational inbox rather than the steering inbox.
+      const monitorInbox: string[] = [];
+      const MONITOR_INBOX_CAP = 32;
+      let acceptingMonitorEvents = true;
+      const onMonitorEvent = (e: MonitorJobEvent) => {
+        if (!acceptingMonitorEvents) return;
+        if (useTui) tui?.onMonitorEvent(e);
+        else console.log(formatMonitorJobEvent(e));
+        if (e.type !== "line" || monitorInbox.length >= MONITOR_INBOX_CAP) return;
+        const description = e.record.description.replace(/\s+/g, " ").trim().slice(0, 240);
+        const line = e.line.slice(0, 2_000);
+        monitorInbox.push(`[monitor ${e.record.id} · ${e.record.category} · ${description}]\n${line}`);
+      };
+      const unsubscribeMonitor = jobRegistry.subscribeMonitor(onMonitorEvent);
+      const drainMonitor = () => monitorInbox.splice(0, monitorInbox.length);
       sessionNotifyEndpoint?.attachRegistry(subagentRegistry);
       currentTurnSteer = { push: line => steerInbox.push(line), flushCard: line => tui?.flushSteerCard(line) };
       if (sessionNotifyEndpoint && !notifyRedact) {
@@ -1495,21 +1523,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             steer: drainSteer,
             registry: subagentRegistry,
             sessionEndpoint: sessionNotifyEndpoint,
-            onEvent: useTui
-              ? (e => tui?.onSubagentEvent(e))
-              : (e => logTaskSubEvent(e)),
+            onEvent: onSubagentEvent,
           }),
           eval: createEvalTool({
             config: { ...turnConfig, defaultModel: activeModel },
             signal: ac.signal,
             steer: drainSteer,
-            onEvent: useTui
-              ? (e => tui?.onSubagentEvent(e))
-              : (e => logTaskSubEvent(e)),
+            onEvent: onSubagentEvent,
           }),
           todo: createTodoTool({ onChange: items => { turnTodos = items; tui?.setTodos(items); } }),
           subagent: createSubagentTool(subagentRegistry),
           job: createJobTool(jobRegistry),
+          monitor: createMonitorTool(jobRegistry),
           irc: createIrcTool(subagentRegistry),
           goal: createGoalTool(),
           approve: createApproveTool(),
@@ -1615,6 +1640,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           signal: ac.signal,
           sessionKey: cacheKey,
           steer: drainSteer,
+          monitor: drainMonitor,
           rateLimitFallbackAvailable,
           safetyFallbackAvailable,
           events: wrapEvents(withStepPersistence({ ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone }, persistTurnTail), opik),
@@ -1748,6 +1774,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             signal: ac.signal,
             sessionKey: turnSessionKey,
             steer: drainSteer,
+            monitor: drainMonitor,
             // Deliberately NOT wiring rateLimitFallbackAvailable here: this repair
             // retry has no reroute loop around it (unlike runLoopWithModel's
             // routeFallbackAttempt loop) — bailing the retry ladder early on a 429
@@ -1772,11 +1799,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         await opik.endTurn({ done: result.done, steps: result.steps, output: result.doneReason });
       } finally {
         harness.dispose();
+        acceptingTuiSubagentEvents = false;
+        acceptingMonitorEvents = false;
         subagentRegistry.cancelAll(); // #9: no detached run leaks past the turn
         sessionNotifyEndpoint?.detachRegistry(); // this turn's registry is gone — subagent frames stop applying to it
         currentTurnSteer = undefined; // a remote message after this point queues instead of steering a dead turn
         await stopSessionNotifyEndpoint(subagentRegistry); // tear down the FALLBACK lazy endpoint, if one was started (no-op when sessionNotifyEndpoint owns the registry)
         jobRegistry.cancelAll(); // background jobs are turn-scoped too — no orphaned processes
+        unsubscribeMonitor();
 
         // Steering typed but never drained (e.g. entered just after the final step)
         // must not be lost — fold it into the next prompt draft so it runs next.

package/src/tui/app.ts

@@ -20,6 +20,7 @@ import { renderFooter, type FooterData } from "./components/footer";
 import { renderForgeMark, forgeMarkHeight, forgeMarkFrameCount, forgeBeat } from "./components/ascii-art";
 import { evolutionTrack, createStageProgress, type StageProgress, transitionMessage } from "./components/evolution";
 import type { TaskSubEvent } from "../agent/task-tool";
+import type { MonitorJobEvent } from "../agent/job-registry";
 import { supportsUnicode } from "./components/capability";
 import { centerBlock, padLineTo, boxBlock, BOX_ASCII, BOX_UNICODE } from "./components/layout";
 import { SECTION_GAP, sectionLabel, stackSections } from "./components/section";
@@ -274,19 +275,15 @@ export class LaunchTui {
   // Cumulative token usage for the live turn (engine onUsage event).
   private turnUsage: { inputTokens: number; outputTokens: number } | null = null;
   // True while at least one delegated subagent SLOT is in flight — drives the `(sub)`
-  // status marker. Derived from `subagentLiveSlots.size` (see below) rather than a
-  // plain boolean so a fan-out batch where ONE worker finishes early no longer
-  // clears the marker while its siblings are still visibly running.
+  // status marker. Derived from `subagentLiveSlots.size` rather than a plain boolean
+  // so one completed concurrent run cannot clear still-running siblings.
   private subagentActive = false;
-  // Latest nested subagent activity, PER CONCURRENT SLOT (fan-out `task` batches — both
-  // the executor and read-only roles — now run several workers at once; a single
-  // shared string clobbered on every event made concurrent subagents look sequential
-  // and, worse, cleared the whole `(sub)` marker the instant ANY one worker finished).
-  // Keyed by the event's fan-out `index` (1-based); a single/detached run with no
-  // index shares the fixed key 0. `subagentLiveOrder` tracks touch order so the
+  // Latest nested subagent activity, PER CONCURRENT SLOT. Detached runs use their
+  // stable registry id, fan-out workers use their 1-based index, and legacy
+  // synchronous runs share one slot. `subagentLiveOrder` tracks touch order so the
   // status row can show the MOST RECENTLY active slot plus a "+N more" count.
-  private readonly subagentLiveSlots = new Map<number, string>();
-  private readonly subagentLiveOrder: number[] = [];
+  private readonly subagentLiveSlots = new Map<string, string>();
+  private readonly subagentLiveOrder: string[] = [];
   // Bounded activity-history ring: one plain-text entry per ledger append, with a
   // turn-relative timestamp. Powers Ctrl+O's "recent activity" tail so the detail
   // view ALWAYS answers "what has been happening", even before the first reply.
@@ -1004,10 +1001,9 @@ export class LaunchTui {
     }
     // A delegated subagent's LATEST nested event beats the parent's static
     // "Task: <role> …" card title — a long task otherwise reads as a stall even
-    // though the subagent is actively reading/editing/running underneath. When a
-    // fan-out batch has MULTIPLE concurrent slots live, append a "+N more running"
-    // count so a parallel batch visibly reads as parallel instead of looking like
-    // one subagent whose label keeps randomly changing.
+    // though the subagent is actively reading/editing/running underneath. When
+    // multiple concurrent slots live, append a "+N more running" count so parallel
+    // work does not look like one subagent whose label keeps randomly changing.
     if (this.subagentActive && this.subagentLiveSlots.size > 0) {
       const mostRecent = this.subagentLiveOrder[this.subagentLiveOrder.length - 1];
       const line = (mostRecent !== undefined ? this.subagentLiveSlots.get(mostRecent) : undefined)
@@ -1063,6 +1059,7 @@ export class LaunchTui {
     const color = this.theme.color;
     const role = e.role || "subagent";
     const roleLabel = e.index && e.total ? `${role.toUpperCase()}[${e.index}/${e.total}]` : role.toUpperCase();
+    const detachedLabel = e.detached && e.id ? ` [${e.id}]` : "";
     const badge = categoryBadge("subagent", { color });
     const ok = this.unicode ? "✓" : "v";
     const bad = this.unicode ? "✗" : "x";
@@ -1070,10 +1067,14 @@ export class LaunchTui {
     const last = this.unicode ? "└─" : "`-";
     const detail = (e.detail ?? "").split("\n").find(l => l.trim().length > 0)?.trim().slice(0, 140) ?? "";
     const summary = e.summary ? ` — ${e.summary}` : "";
-    // Fan-out slot key: the event's 1-based `index` when present (concurrent batch
-    // worker), else the fixed key 0 (single-task/detached run — matches the prior
-    // single-string behavior for the non-batch case).
-    const slot = e.index ?? 0;
+    // Detached runs must retain their registry identity so concurrent detached events
+    // cannot collide. Fan-out indices remain separate, while legacy synchronous/eval
+    // events preserve their single shared slot.
+    const slot = e.detached && e.id
+      ? `detached:${e.id}`
+      : e.index !== undefined
+        ? `fanout:${e.index}`
+        : "single";
     const touchSlot = (line: string) => {
       this.subagentLiveSlots.set(slot, line);
       const at = this.subagentLiveOrder.indexOf(slot);
@@ -1086,41 +1087,58 @@ export class LaunchTui {
     // activity readable in scrollback and visually separate from parent tools.
     switch (e.kind) {
       case "start":
-        touchSlot(`${roleLabel} ${this.unicode ? "▸" : ">"} ${detail || "starting"}`);
-        this.appendLedger(`${badge} ${this.unicode ? "▸" : ">"} ${roleLabel} · ${detail}\n`, "subagent");
+        touchSlot(`${roleLabel}${detachedLabel} ${this.unicode ? "▸" : ">"} ${detail || "starting"}`);
+        this.appendLedger(`${badge} ${this.unicode ? "▸" : ">"} ${roleLabel}${detachedLabel} · ${detail}\n`, "subagent");
         break;
       case "step":
-        touchSlot(`${roleLabel} ${this.unicode ? "·" : "-"} ${detail || "working"}`);
-        this.appendLedger(`  ${badge} ${branch} ${roleLabel} · ${detail || "working"}\n`, "subagent");
+        touchSlot(`${roleLabel}${detachedLabel} ${this.unicode ? "·" : "-"} ${detail || "working"}`);
+        this.appendLedger(`  ${badge} ${branch} ${roleLabel}${detachedLabel} · ${detail || "working"}\n`, "subagent");
         break;
       case "tool":
-        touchSlot(`${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}`);
-        this.appendLedger(`  ${badge} ${branch} ${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}${summary}\n`, "subagent");
+        touchSlot(`${roleLabel}${detachedLabel} ${e.success === false ? bad : ok} ${detail || "tool"}`);
+        this.appendLedger(`  ${badge} ${branch} ${roleLabel}${detachedLabel} ${e.success === false ? bad : ok} ${detail || "tool"}${summary}\n`, "subagent");
         break;
       case "error":
-        touchSlot(`${roleLabel} ${bad} ${detail || "error"}`);
-        this.appendLedger(`  ${badge} ${branch} ${roleLabel} ${bad} ${detail || "error"}\n`, "subagent");
+        touchSlot(`${roleLabel}${detachedLabel} ${bad} ${detail || "error"}`);
+        this.appendLedger(`  ${badge} ${branch} ${roleLabel}${detachedLabel} ${bad} ${detail || "error"}\n`, "subagent");
         break;
       case "thinking":
         // Live-only preview (mirrors the main turn's dimmed "Thinking" block) — never
         // persisted to the ledger; see TaskSubEvent.kind's doc comment for why.
-        touchSlot(`${roleLabel} ${this.unicode ? "…" : "..."} ${detail || "thinking"}`);
+        touchSlot(`${roleLabel}${detachedLabel} ${this.unicode ? "…" : "..."} ${detail || "thinking"}`);
         break;
       case "done":
-        // Clear ONLY this slot — a fan-out batch where one worker finishes early
-        // must keep showing its still-running siblings, not drop the `(sub)`
-        // marker for the whole batch (the bug this per-slot map fixes).
+        // Clear ONLY this slot — completing one concurrent run must leave its
+        // still-running siblings visible and keep the `(sub)` marker active.
         this.subagentLiveSlots.delete(slot);
         {
           const at = this.subagentLiveOrder.indexOf(slot);
           if (at !== -1) this.subagentLiveOrder.splice(at, 1);
         }
         this.subagentActive = this.subagentLiveSlots.size > 0;
-        this.appendLedger(`${badge} ${last} ${roleLabel} done${e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : ""}${e.success === false ? " (incomplete)" : ""}: ${detail}\n`, "subagent");
+        this.appendLedger(`${badge} ${last} ${roleLabel}${detachedLabel} done${e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : ""}${e.success === false ? " (incomplete)" : ""}: ${detail}\n`, "subagent");
         break;
     }
     this.draw();
   }
+  /** Render turn-scoped monitor lifecycle/output separately from subagent activity. */
+  onMonitorEvent(e: MonitorJobEvent): void {
+    if (this.finished) return;
+    const badge = categoryBadge("progress", { color: this.theme.color });
+    const label = sanitizeForFrame(
+      `${e.record.id} · ${e.record.category} · ${e.record.description}`,
+    ).replace(/\s+/g, " ").trim().slice(0, 180);
+    const branch = this.unicode ? "│" : "|";
+    if (e.type === "start") {
+      this.appendLedger(`${badge} ${this.unicode ? "◉" : "o"} Monitor ${label} started\n`, "monitor");
+    } else if (e.type === "line") {
+      const line = sanitizeForFrame(e.line).split("\n").find(row => row.trim())?.trim().slice(0, 180) ?? "";
+      this.appendLedger(`${badge} ${branch} Monitor ${label}${line ? ` — ${line}` : ""}\n`, "monitor");
+    } else {
+      this.appendLedger(`${badge} ${this.unicode ? "└" : "`"} Monitor ${label} done\n`, "monitor");
+    }
+    this.draw();
+  }
 
   start(): void {
     this.startedAt = Date.now();
@@ -1484,13 +1502,12 @@ export class LaunchTui {
    *  block shows only the most-recent lines, capped at ~30% of the screen height (a
    *  ceiling guards a tall terminal), so it grows with the stream and shrinks with the
    *  viewport. Returns [] when there is nothing to show. */
-  /** gjc-parity multi-line parallel-subagent panel: when a fan-out `task` batch has
-   *  MORE THAN ONE concurrent slot live, render one status line PER active slot
+  /** gjc-parity multi-line parallel-subagent panel: when MORE THAN ONE concurrent
+   *  fan-out or detached slot is live, render one status line PER active slot
    *  (most-recently-touched first) instead of collapsing everything into a single
-   *  "+N more running" summary line (see `currentActivity()`). A single/detached
-   *  subagent still uses the plain status-line path — this panel exists specifically
-   *  to make a truly PARALLEL batch visibly read as parallel: every worker's latest
-   *  activity is on screen at once, capped so a large fan-out can't blow the frame. */
+   *  "+N more running" summary line (see `currentActivity()`). A single subagent
+   *  still uses the plain status-line path; this panel makes concurrent work visibly
+   *  parallel while capping rows so a large batch cannot blow the frame. */
   private static readonly SUBAGENT_PANEL_MAX_ROWS = 6;
   private renderSubagentPanel(cols: number): string[] {
     if (this.subagentLiveSlots.size <= 1) return [];
@@ -1689,9 +1706,8 @@ export class LaunchTui {
     if (this.runningTool && this.liveToolOutput.trim()) {
       tail.push(...this.renderLiveBlock("Output", this.liveToolOutput, cols, rows, 8));
     }
-    // Parallel subagent panel (gjc parity): a fan-out `task` batch with more than one
-    // concurrent slot live gets its OWN multi-line block — one row per active worker —
-    // so a genuinely parallel batch reads as parallel instead of a single rotating line.
+    // Parallel subagent panel: more than one fan-out or detached slot gets its own
+    // multi-line block so genuinely parallel work does not read as one rotating line.
     if (this.subagentActive) {
       tail.push(...this.renderSubagentPanel(cols));
     }

package/src/tui/components/forge.ts

@@ -293,6 +293,37 @@ export function summarizeForgeInvocation(tool: string, rawArgs: unknown, opts: {
 
   if (normalized === "task") {
     const role = stringArg(args, "role") ?? "executor";
+    // Fan-out/batch form (`tasks: [...]`, task-tool.ts's concurrent MAX_FANOUT path) previously
+    // fell through to the single-task branch below, which only reads `task`/`prompt`/`assignment`
+    // — every batch call rendered as a bare "<missing task>" placeholder with zero visibility into
+    // what was actually about to run concurrently, even on a well-formed call (live-reproduced: a
+    // real 3-item fan-out showed nothing but "<missing task>" in the tool-call preview box).
+    // A JSON-STRINGIFIED `tasks` (live-reproduced model mistake task-tool.ts's handler itself now
+    // tolerates — see createTaskTool's `tasksArg` coercion) is accepted here too, for the same
+    // reason: the preview must reflect what will actually run, not just the well-formed case.
+    const tasksValue = typeof args.tasks === "string"
+      ? (() => { try { const p = JSON.parse(args.tasks as string); return Array.isArray(p) ? p : args.tasks; } catch { return args.tasks; } })()
+      : args.tasks;
+    if (Array.isArray(tasksValue)) {
+      const items = (tasksValue as unknown[])
+        .map(entry => {
+          if (typeof entry === "string") return entry.trim();
+          if (entry && typeof entry === "object") {
+            const e = entry as Record<string, unknown>;
+            return String(e.task ?? e.assignment ?? e.prompt ?? "").trim();
+          }
+          return "";
+        })
+        .filter(Boolean);
+      const lines = items.length > 0
+        ? items.map((t, i) => {
+            const firstLine = t.split("\n")[0]!;
+            const truncated = firstLine.length > 120 || t.includes("\n");
+            return `${i + 1}. ${firstLine.slice(0, 120)}${truncated ? "…" : ""}`;
+          })
+        : ["<missing tasks>"];
+      return { title: `Task: ${role} ×${items.length}`, language: "text", lines };
+    }
     const task = stringArg(args, "task", "prompt", "assignment") ?? "<missing task>";
     const context = stringArg(args, "context");
     return {

package/src/types/playwriter.d.ts

@@ -0,0 +1,15 @@
+// src/types/playwriter.d.ts
+// Declaration file to allow TypeScript to recognize the optional Playwriter CLI module.
+// This is only needed for the example automation script in scripts/playwriter-apply.ts.
+// The actual Playwriter package is expected to be installed globally or run via npx.
+
+declare module "playwriter" {
+  export class Playwriter {
+    /** Connect to the running Chrome extension bridge */
+    connect(): Promise<void>;
+    /** Open a new page (tab) in the connected browser */
+    newPage(): Promise<any>;
+    /** Disconnect from the bridge */
+    disconnect(): Promise<void>;
+  }
+}