jeo-code 0.8.43 → 0.9.0

package/src/commands/launch.ts

@@ -19,8 +19,9 @@ 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, type MonitorJobEvent } from "../agent/job-registry";
 import { createMonitorTool, MONITOR_TOOL_PROTOCOL_LINE } from "../agent/monitor-tool";
+import { MonitorRegistry } from "../agent/monitor-registry";
+import { JobRegistry } from "../agent/job-registry";
 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";
@@ -186,7 +187,6 @@ import {
   gatedStdout,
   formatTaskSubEvent,
   logTaskSubEvent,
-  formatMonitorJobEvent,
   createStreamEvents,
   shouldUseOneShotTui,
 } from "./launch/stream";
@@ -910,6 +910,33 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     sessionNotifyEndpoint.sendIdentity({ repo: cwd.split(/[\\/]/).filter(Boolean).pop() ?? cwd, branch, cwd });
   }
 
+  // Session-scoped registries for DETACHED subagents, background jobs, and monitors (gjc parity).
+  // Created ONCE for the whole launch session lifetime (not per-turn) so detached
+  // runs persist across turns and remain controllable/inspectable.
+  const subagentRegistry = new SubagentRegistry();
+  const jobRegistry = new JobRegistry();
+  let activeTui: LaunchTui | null = null;
+  const monitorRegistry = new MonitorRegistry({
+    onLine: (record, line) => {
+      const notice = `[monitor ${record.id}] ${line}`;
+      if (activeTui) activeTui.events().onNotice?.(notice);
+      else console.log(notice);
+    },
+  });
+  sessionNotifyEndpoint?.attachRegistry(subagentRegistry);
+
+  let cleanedUp = false;
+  const cleanupSession = async (): Promise<void> => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    subagentRegistry.cancelAll();
+    jobRegistry.cancelAll();
+    monitorRegistry.cancelAll();
+    sessionNotifyEndpoint?.detachRegistry();
+    await sessionNotifyEndpoint?.stop();
+    await stopSessionNotifyEndpoint(subagentRegistry);
+  };
+
   // Persist the active per-session model into the session header so `/resume` restores
   // it (each session can carry its own model independent of the global default).
   // Best-effort: a header-rewrite failure must never abort the turn.
@@ -1215,6 +1242,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const { provider: activeProvider } = await describeModel(activeModel, turnConfig);
     const turnDirtyCount = branch ? gitDirtyCount(cwd) : undefined;
     const tui = useTui ? new LaunchTui({ model: activeModel, provider: activeProvider, sessionId, maxSteps: initialStepLimit, cwd, branch, dirtyCount: turnDirtyCount, thinking: activeThinking, routedTier: routed?.tier }) : null;
+    activeTui = tui;
     if (routeCredentialNotice) {
       if (tui) tui.events().onNotice?.(routeCredentialNotice);
       else console.log(routeCredentialNotice);
@@ -1272,7 +1300,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         },
         onHardExit: () => {
           if (tui) tui.finish("Cancelled.", { ok: false });
-          process.exit(130);
+          forceExitFromCtrlC();
         },
       });
       let compRes: Awaited<ReturnType<typeof maybeCompact>>;
@@ -1418,40 +1446,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         },
         onHardExit: () => {
           if (tui) tui.finish("Cancelled.", { ok: false });
-          process.exit(130);
+          forceExitFromCtrlC();
         },
       });
       const ac = harness.controller;
-      // #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) {
         const preview = userInput.length > 200 ? `${userInput.slice(0, 200)}…` : userInput;
@@ -1523,18 +1521,22 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             steer: drainSteer,
             registry: subagentRegistry,
             sessionEndpoint: sessionNotifyEndpoint,
-            onEvent: onSubagentEvent,
+            onEvent: useTui
+              ? (e => tui?.onSubagentEvent(e))
+              : (e => logTaskSubEvent(e)),
           }),
           eval: createEvalTool({
             config: { ...turnConfig, defaultModel: activeModel },
             signal: ac.signal,
             steer: drainSteer,
-            onEvent: onSubagentEvent,
+            onEvent: useTui
+              ? (e => tui?.onSubagentEvent(e))
+              : (e => logTaskSubEvent(e)),
           }),
           todo: createTodoTool({ onChange: items => { turnTodos = items; tui?.setTodos(items); } }),
           subagent: createSubagentTool(subagentRegistry),
           job: createJobTool(jobRegistry),
-          monitor: createMonitorTool(jobRegistry),
+          monitor: createMonitorTool(monitorRegistry),
           irc: createIrcTool(subagentRegistry),
           goal: createGoalTool(),
           approve: createApproveTool(),
@@ -1640,7 +1642,6 @@ 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),
@@ -1774,7 +1775,6 @@ 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
@@ -1799,14 +1799,8 @@ 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
+        activeTui = null;
         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.
@@ -2060,7 +2054,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const harness = createInFlightAbortHarness({
           captureEsc: false,
           onAbortNotice: msg => console.log(msg),
-          onHardExit: () => process.exit(130),
+          onHardExit: () => forceExitFromCtrlC(),
         });
         const ac = harness.controller;
 
@@ -2273,7 +2267,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       const harness = createInFlightAbortHarness({
         captureEsc: false,
         onAbortNotice: msg => console.log(msg),
-        onHardExit: () => process.exit(130),
+        onHardExit: () => forceExitFromCtrlC(),
       });
       const ac = harness.controller;
 
@@ -3171,8 +3165,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     } catch {
       // Best-effort terminal restore; process exit is the contract.
     }
-    // Fire-and-forget — see the identical rationale at the main hard-exit path.
+    subagentRegistry.cancelAll();
+    jobRegistry.cancelAll();
+    monitorRegistry.cancelAll();
+    sessionNotifyEndpoint?.detachRegistry();
     void sessionNotifyEndpoint?.stop();
+    void stopSessionNotifyEndpoint(subagentRegistry);
     process.exit(130);
   };
   // Prompt Ctrl+C: a single press clears a non-empty box; on an empty box it exits.
@@ -4994,11 +4992,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       disarmPreview();
       out.write("\x1b[?25h\n");
     } catch { /* best effort */ }
-    // Fire-and-forget: process.exit() below does not wait for this, but the OS
-    // tears down the socket on process death regardless, and a leaked discovery
-    // file is self-healing (the daemon's scanSessions() reaps dead-pid entries
-    // on its next 3s poll — see notify-telegram-daemon.test.ts).
-    void sessionNotifyEndpoint?.stop();
+    await cleanupSession();
     process.removeListener("SIGINT", handleCtrlC);
     process.stdin.off("data", handleCtrlCByte);
     drainPromptListeners();
@@ -5015,7 +5009,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // gjc-parity resume pointer (logs/gjc-tui-study analysis Gap C): leave the exact
   // resume command in scrollback on exit, mirroring the --list handler's convention.
   if (sessionId && !flags.noSession) console.log(formatResumeHint(sessionId));
-  await sessionNotifyEndpoint?.stop();
+  await cleanupSession();
   process.removeListener("SIGINT", handleCtrlC);
   process.stdin.off("data", handleCtrlCByte);
   drainPromptListeners();

package/src/tui/app.ts

@@ -20,7 +20,6 @@ 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";
@@ -275,15 +274,19 @@ 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` rather than a plain boolean
-  // so one completed concurrent run cannot clear still-running siblings.
+  // 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.
   private subagentActive = false;
-  // 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<string, string>();
-  private readonly subagentLiveOrder: string[] = [];
+  // 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 stable `detachedId` when present, else fan-out `index` (1-based),
+  // else fixed key 0 for single foreground runs. `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, string>();
+  private readonly subagentLiveOrder: (number | 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.
@@ -1001,9 +1004,10 @@ 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
-    // multiple concurrent slots live, append a "+N more running" count so parallel
-    // work does not look like one subagent whose label keeps randomly changing.
+    // 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.
     if (this.subagentActive && this.subagentLiveSlots.size > 0) {
       const mostRecent = this.subagentLiveOrder[this.subagentLiveOrder.length - 1];
       const line = (mostRecent !== undefined ? this.subagentLiveSlots.get(mostRecent) : undefined)
@@ -1058,8 +1062,11 @@ export class LaunchTui {
     if (this.finished) return;
     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 roleLabel = e.detachedId
+      ? `${role.toUpperCase()}[${e.detachedId}]`
+      : e.index && e.total
+      ? `${role.toUpperCase()}[${e.index}/${e.total}]`
+      : role.toUpperCase();
     const badge = categoryBadge("subagent", { color });
     const ok = this.unicode ? "✓" : "v";
     const bad = this.unicode ? "✗" : "x";
@@ -1067,14 +1074,10 @@ 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}` : "";
-    // 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";
+    // Slot key: stable `detachedId` when present (detached background task),
+    // else fan-out 1-based `index` (concurrent batch worker),
+    // else fixed key 0 (single foreground run).
+    const slot: number | string = e.detachedId ?? e.index ?? 0;
     const touchSlot = (line: string) => {
       this.subagentLiveSlots.set(slot, line);
       const at = this.subagentLiveOrder.indexOf(slot);
@@ -1087,58 +1090,41 @@ export class LaunchTui {
     // activity readable in scrollback and visually separate from parent tools.
     switch (e.kind) {
       case "start":
-        touchSlot(`${roleLabel}${detachedLabel} ${this.unicode ? "▸" : ">"} ${detail || "starting"}`);
-        this.appendLedger(`${badge} ${this.unicode ? "▸" : ">"} ${roleLabel}${detachedLabel} · ${detail}\n`, "subagent");
+        touchSlot(`${roleLabel} ${this.unicode ? "▸" : ">"} ${detail || "starting"}`);
+        this.appendLedger(`${badge} ${this.unicode ? "▸" : ">"} ${roleLabel} · ${detail}\n`, "subagent");
         break;
       case "step":
-        touchSlot(`${roleLabel}${detachedLabel} ${this.unicode ? "·" : "-"} ${detail || "working"}`);
-        this.appendLedger(`  ${badge} ${branch} ${roleLabel}${detachedLabel} · ${detail || "working"}\n`, "subagent");
+        touchSlot(`${roleLabel} ${this.unicode ? "·" : "-"} ${detail || "working"}`);
+        this.appendLedger(`  ${badge} ${branch} ${roleLabel} · ${detail || "working"}\n`, "subagent");
         break;
       case "tool":
-        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");
+        touchSlot(`${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}`);
+        this.appendLedger(`  ${badge} ${branch} ${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}${summary}\n`, "subagent");
         break;
       case "error":
-        touchSlot(`${roleLabel}${detachedLabel} ${bad} ${detail || "error"}`);
-        this.appendLedger(`  ${badge} ${branch} ${roleLabel}${detachedLabel} ${bad} ${detail || "error"}\n`, "subagent");
+        touchSlot(`${roleLabel} ${bad} ${detail || "error"}`);
+        this.appendLedger(`  ${badge} ${branch} ${roleLabel} ${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}${detachedLabel} ${this.unicode ? "…" : "..."} ${detail || "thinking"}`);
+        touchSlot(`${roleLabel} ${this.unicode ? "…" : "..."} ${detail || "thinking"}`);
         break;
       case "done":
-        // Clear ONLY this slot — completing one concurrent run must leave its
-        // still-running siblings visible and keep the `(sub)` marker active.
+        // 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).
         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}${detachedLabel} done${e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : ""}${e.success === false ? " (incomplete)" : ""}: ${detail}\n`, "subagent");
+        this.appendLedger(`${badge} ${last} ${roleLabel} 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();
@@ -1502,12 +1488,13 @@ 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 MORE THAN ONE concurrent
-   *  fan-out or detached slot is live, render one status line PER active slot
+  /** 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
    *  (most-recently-touched first) instead of collapsing everything into a single
-   *  "+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. */
+   *  "+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. */
   private static readonly SUBAGENT_PANEL_MAX_ROWS = 6;
   private renderSubagentPanel(cols: number): string[] {
     if (this.subagentLiveSlots.size <= 1) return [];
@@ -1706,8 +1693,9 @@ export class LaunchTui {
     if (this.runningTool && this.liveToolOutput.trim()) {
       tail.push(...this.renderLiveBlock("Output", this.liveToolOutput, cols, rows, 8));
     }
-    // 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.
+    // 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.
     if (this.subagentActive) {
       tail.push(...this.renderSubagentPanel(cols));
     }