jeo-code 0.4.5 → 0.4.7

package/src/ai/register-providers.ts

@@ -0,0 +1,21 @@
+/**
+ * Built-in provider registration (the registry bootstrap).
+ *
+ * Importing this module for its side effect registers every bundled LLM adapter
+ * into the shared `providerRegistry`. `model-manager` then resolves adapters
+ * through the registry alone — it no longer imports, or even names, concrete
+ * providers. To add a new built-in provider, register it HERE only; nothing in
+ * `model-manager` changes.
+ */
+import { providerRegistry } from "./provider-registry";
+import { anthropicAdapter } from "./providers/anthropic";
+import { openaiAdapter } from "./providers/openai";
+import { geminiAdapter } from "./providers/gemini";
+import { ollamaAdapter } from "./providers/ollama";
+import { antigravityAdapter } from "./providers/antigravity";
+
+providerRegistry.register("anthropic", anthropicAdapter);
+providerRegistry.register("openai", openaiAdapter);
+providerRegistry.register("gemini", geminiAdapter);
+providerRegistry.register("antigravity", antigravityAdapter);
+providerRegistry.register("ollama", ollamaAdapter);

package/src/ai/types.ts

@@ -43,6 +43,10 @@ export interface CallOptions {
   /** Notified before each auto-retry backoff wait (rate limits / transient errors).
    *  NOT forwarded to provider adapters — consumed by the manager's retry layer. */
   onRetry?: (attempt: number, err: unknown, delayMs: number) => void;
+  /** Streaming sink for native model reasoning/thinking text deltas (separate from the
+   *  answer text). Surfaced as a transient dimmed view; absent for models that emit no
+   *  thought text. */
+  onReasoning?: (delta: string) => void;
 }
 
 export interface ProviderAdapter {

package/src/cli/runner.ts

@@ -172,15 +172,6 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runUpdateCommand(args);
     },
   },
-  {
-    name: "gjc",
-    summary: "Run the gjc workflow skill as an autonomous build loop (plan → implement → verify).",
-    usage: "gjc \"<intent>\"",
-    loader: async () => {
-      const m = await import("../commands/gjc");
-      return args => m.runGjcCommand(args);
-    },
-  },
   {
     name: "ooo-seed",
     summary: "Generate an immutable ooo seed from a specification (spec-first automation).",

package/src/commands/launch.ts

@@ -3,6 +3,8 @@ import { runAgentLoop, executorSystemPrompt, DEFAULT_TOOLS, TOOL_PROTOCOL, WORKI
 import { initialDynamicStepLimit } from "../agent/step-budget";
 import { memoryPromptSection, spawnDetachedDistill } from "../agent/memory";
 import { createTaskTool, taskToolProtocolLine, type TaskSubEvent } from "../agent/task-tool";
+import { createSubagentTool, SUBAGENT_TOOL_PROTOCOL_LINE } from "../agent/subagent-tool";
+import { SubagentRegistry } from "../agent/subagent-registry";
 import { createTodoTool, TODO_TOOL_PROTOCOL_LINE } from "../agent/todo-tool";
 import { LaunchTui } from "../tui/app";
 import { runDeepInterviewEngine } from "./deep-interview";
@@ -19,7 +21,7 @@ import { staticCompletionContext, readlineCompleter, formatCompletionPreview, to
 import { EVOLUTION_STAGES, animateAsciiArt } from "../tui/components/ascii-art";
 import { getEvolutionTip } from "../tui/components/evolution";
 import { renderWelcome, playWelcomeSweep } from "../tui/components/welcome";
-import { checkForUpdate } from "../util/update-check";
+import { checkForUpdate, readUpdateCache, writeUpdateCache } from "../util/update-check";
 import { jeoEnv } from "../util/env";
 import { renderUpdateBox } from "../tui/components/update-box";
 import { supportsUnicode } from "../tui/components/capability";
@@ -379,7 +381,8 @@ function streamResultSuffix(tool: string, ok: boolean, output: string | undefine
 
 export function formatTaskSubEvent(e: TaskSubEvent): string {
   const role = e.role || "subagent";
-  const roleLabel = role.toUpperCase();
+  const roleLabel = e.index && e.total ? `${role.toUpperCase()}[${e.index}/${e.total}]` : role.toUpperCase();
+  const tokTag = e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : "";
   const detail = firstOutputLine(e.detail);
   const summary = e.summary ? ` — ${e.summary}` : "";
   // No ` step N/M` marker — step counters carry no meaning under the dynamic
@@ -390,7 +393,7 @@ export function formatTaskSubEvent(e: TaskSubEvent): string {
   if (e.kind === "step") return `  ${badge} ${chalk.cyan(`├─ ${roleLabel}`)} · ${detail || "working"}`;
   if (e.kind === "tool") return `  ${badge} ${e.success === false ? chalk.red("├─") : chalk.green("├─")} ${roleLabel} ${e.success === false ? chalk.red("✗") : chalk.green("✓")} ${detail || "tool"}${summary}`;
   if (e.kind === "error") return `  ${badge} ${chalk.red("├─")} ${roleLabel} ${chalk.red("✗")} ${detail || "error"}`;
-  return `${badge} ${e.success === false ? chalk.red("└─") : chalk.green("└─")} ${roleLabel} done${e.success === false ? " (incomplete)" : ""}${detail ? `: ${detail}` : ""}`;
+  return `${badge} ${e.success === false ? chalk.red("└─") : chalk.green("└─")} ${roleLabel} done${tokTag}${e.success === false ? " (incomplete)" : ""}${detail ? `: ${detail}` : ""}`;
 }
 
 function logTaskSubEvent(e: TaskSubEvent, log: (line: string) => void = (s: string) => console.log(s)): void {
@@ -1141,7 +1144,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", "todo"]);
+  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "todo", "subagent"]);
   let allowedTools = new Set(KNOWN_TOOLS);
 
   if (flags.noTools) {
@@ -1196,6 +1199,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     (allowedTools.has("task") ? "\n\nDelegation: " + taskToolProtocolLine(cfg) +
     " Call task with {\"role\": <one of the advertised roles>, \"task\": <assignment>, \"context\": <optional>} to hand a focused slice to a subagent." : "") +
     (allowedTools.has("todo") ? "\n\nPlanning: " + TODO_TOOL_PROTOCOL_LINE : "") +
+    (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." : "") +
     (effectiveNoSkills ? "" :
     "\n\nJEO workflow routing:\n" +
     "- Answer the user's request DIRECTLY. Never reply with a catalog, list, or summary of skills unless the user explicitly asks what skills exist.\n" +
@@ -1297,6 +1302,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // box during a running turn so typed text stays in the same query surface
   // instead of a separate queued row.
   let queueBusySnapshot: (() => { text: string }) | undefined;
+  // Clears the live next-prompt draft — used after a mid-turn Enter is lifted into
+  // the steering inbox so the consumed line does not also become the next prompt.
+  let queueBusyClear: (() => void) | undefined;
   let interactiveTurnActive = false;
 
 
@@ -1311,42 +1319,61 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const activeModel = sessionModel || turnConfig.defaultModel;
     const contextTokens = catalogMetadata(activeModel)?.contextTokens;
 
-    const compRes = await maybeCompact(history, {
-      model: sessionModel,
-      contextTokens,
-    });
-    
-    if (compRes.error) {
-      throw new Error(compRes.error);
-    }
-
-    if (compRes.compacted && sessionId && compRes.replacesThrough !== undefined) {
-      const touchedNote = compRes.touchedFiles?.length ? ` Files touched: ${compRes.touchedFiles.join(", ")}.` : "";
-      const summaryText = compRes.summary ?? `[Earlier conversation omitted: ${compRes.removed} messages — summary unavailable.${touchedNote}]`;
-      await appendCompaction(sessionId, ++compactionSeq, summaryText, compRes.replacesThrough, cwd);
-    }
-
-    const beforeLen = history.length;
-    if (images?.length && catalogMetadata(activeModel)?.images === false) {
-      console.log(`! ${activeModel} does not advertise image input — sending the attachment anyway.`);
-    }
-    history.push(images?.length ? { role: "user", content: userInput, images } : { role: "user", content: userInput });
-
-    // `turnConfig` was read before compaction so both the compactor and delegated
-    // task tool see mid-session config changes (e.g. `/agents <role> <model>`).
-    const { provider: activeProvider } = await describeModel(activeModel);
-    // Dirty count is recomputed at each turn start (gjc parity P1.B5: per-turn, not
-    // per-render) so `?N` grows as the agent edits files; one spawn/turn, not per frame.
+    // Resolve provider + dirty count up front — both are cheap and feed the live
+    // frame's footer. `turnConfig` is reused so describeModel does NOT re-read the
+    // config file. (gjc parity P1.B5: dirty count per-turn, not per-render.)
+    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: sessionThinking }) : null;
-    tui?.setContextUsage(historyTokens(history), contextTokens);
     tui?.setTurnTitle(userInput); // gjc-parity turn title → HUD + tmux pane title (no LLM call)
+    // `beforeLen` marks where this turn's appended messages start; it is re-read
+    // AFTER compaction (which mutates history) and consumed by the post-turn
+    // persistence block below.
+    let beforeLen = history.length;
     let result;
     try {
+      // Paint the live frame + spinner the INSTANT the turn is accepted, BEFORE the
+      // potentially slow / LLM-driven compaction below. Otherwise the gap between the
+      // submitted prompt and the first feedback reads as a dead "no response" window
+      // (the reported symptom). All remaining preflight runs UNDER the spinner now.
       if (tui) {
         interactiveTurnActive = true;
         tui.start();
       }
+      const compRes = await maybeCompact(history, {
+        model: sessionModel,
+        contextTokens,
+      });
+      if (compRes.error) {
+        throw new Error(compRes.error);
+      }
+      if (compRes.compacted && sessionId && compRes.replacesThrough !== undefined) {
+        const touchedNote = compRes.touchedFiles?.length ? ` Files touched: ${compRes.touchedFiles.join(", ")}.` : "";
+        const summaryText = compRes.summary ?? `[Earlier conversation omitted: ${compRes.removed} messages — summary unavailable.${touchedNote}]`;
+        await appendCompaction(sessionId, ++compactionSeq, summaryText, compRes.replacesThrough, cwd);
+        tui?.events().onNotice?.(`(compacted ${compRes.removed} older message${compRes.removed === 1 ? "" : "s"})`);
+      }
+      beforeLen = history.length;
+      if (images?.length && catalogMetadata(activeModel)?.images === false) {
+        const warn = `! ${activeModel} does not advertise image input — sending the attachment anyway.`;
+        if (tui) tui.events().onNotice?.(warn);
+        else console.log(warn);
+      }
+      history.push(images?.length ? { role: "user", content: userInput, images } : { role: "user", content: userInput });
+      // Keep the submitted query in scrollback: the prompt that STARTS a turn shows
+      // only as the transient HUD turn-title otherwise, which vanishes when the live
+      // frame clears at turn-end — so the conversation transcript lost every user
+      // prompt. Flush a `user` card (same surface as a mid-turn steer) so it persists.
+      if (tui && userInput.trim()) tui.flushUserCard(userInput);
+      tui?.setContextUsage(historyTokens(history), contextTokens);
+
+      // Per-turn steering inbox (gjc parity): additional queries typed mid-turn land
+      // here and the engine drains them at each step boundary; createTaskTool forwards
+      // the same drain so a single running subagent receives them live. Unconsumed
+      // messages are folded into the next prompt in the finally block (race safety).
+      const steerInbox: string[] = [];
+      const steeringEnabled = !!tui && jeoEnv("NO_STEER") !== "1";
+      const drainSteer = () => steerInbox.splice(0, steerInbox.length);
       const harness = createInFlightAbortHarness({
         captureEsc: !!tui,
         onNoise: () => tui?.repaint(),
@@ -1368,11 +1395,38 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         },
         onBufferedInput: chunk => {
           if (!tui) return;
+          // gjc-style mid-turn steering: a typed Enter (outside a bracketed paste)
+          // lifts the current draft into the steering inbox so the RUNNING turn picks
+          // it up at the next step, instead of only becoming the next prompt.
+          // JEO_NO_STEER=1 restores the legacy draft-only behavior.
+          const typedEnter =
+            steeringEnabled &&
+            !(queueBusyPasteActive?.() ?? false) &&
+            /[\r\n]/.test(chunk) &&
+            !chunk.includes(PASTE_START) &&
+            !chunk.includes(PASTE_END);
           const captured = queueBusyInput?.(chunk) ?? false;
-          // Keep the SAME query input box visible during a live turn. Printable
-          // keystrokes edit the next prompt draft; Enter does not create a hidden
-          // queue entry, so there is no separate "queued input" surface.
-          if (captured) tui.setLivePromptInput(queueBusySnapshot?.().text ?? "");
+          if (typedEnter) {
+            const line = (queueBusySnapshot?.().text ?? "").trim();
+            if (line) {
+              steerInbox.push(line);
+              queueBusyClear?.();
+              tui.setLivePromptInput("");
+              // Surface the steered query as a `user` card in scrollback so it reads
+              // as an accepted input that started work — not just a transient notice.
+              tui.flushSteerCard(line);
+              return;
+            }
+          }
+          // Mid-turn additional input is committed (and shown) ONLY on Enter (above):
+          // the running turn does NOT echo half-typed text per keystroke. Captured
+          // printable input accumulates silently in the draft buffer and surfaces as a
+          // `user` card the moment Enter lifts it into the steering inbox (or folds into
+          // the next prompt if the turn ends first). JEO_LIVE_DRAFT=1 restores the
+          // legacy live per-keystroke echo in the input box.
+          if (captured && jeoEnv("LIVE_DRAFT") === "1") {
+            tui.setLivePromptInput(queueBusySnapshot?.().text ?? "");
+          }
         },
         onAbortNotice: msg => {
           if (tui) tui.events().onNotice?.(msg);
@@ -1384,6 +1438,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         },
       });
       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();
       try {
         // Per-turn todo snapshot: drives the done-time reconciliation gate (the
         // Todos checklist used to end a finished turn stuck at "✓0 ◐1 ·4 / 5"
@@ -1403,11 +1460,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           task: createTaskTool({
             config: { ...turnConfig, defaultModel: activeModel },
             signal: ac.signal,
+            steer: drainSteer,
+            registry: subagentRegistry,
             onEvent: useTui
               ? (e => tui?.onSubagentEvent(e))
               : (e => logTaskSubEvent(e)),
           }),
           todo: createTodoTool({ onChange: items => { turnTodos = items; tui?.setTodos(items); } }),
+          subagent: createSubagentTool(subagentRegistry),
         };
         const tools = filterToolMap(fullTools, Array.from(allowedTools));
         result = await runAgentLoop(history, {
@@ -1417,6 +1477,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           model: sessionModel,
           maxTokens: sessionThinking ? thinkingMaxTokens(sessionThinking) : undefined,
           signal: ac.signal,
+          steer: drainSteer,
           events: { ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone },
         });
         if (result.done && looksLikeSkillEcho(result.doneReason ?? "", resolvedSkills)) {
@@ -1434,6 +1495,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             model: sessionModel,
             maxTokens: sessionThinking ? thinkingMaxTokens(sessionThinking) : undefined,
             signal: ac.signal,
+            steer: drainSteer,
             events: withToolDetailCapture(tui ? tui.events() : streamEvents),
           });
           const usage =
@@ -1447,6 +1509,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
       } finally {
         harness.dispose();
+        subagentRegistry.cancelAll(); // #9: no detached run leaks past the turn
+        // 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.
+        const leftover = steerInbox.splice(0, steerInbox.length).map(s => s.trim()).filter(Boolean);
+        if (leftover.length) {
+          const merged = [queuedPromptInput.partial, ...leftover].filter(Boolean).join(" ");
+          queuedPromptInput.partial = merged;
+        }
       }
     } catch (err) {
       if (tui) {
@@ -1612,6 +1682,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
   // INTERACTIVE mode
   const updatePromise = checkForUpdate({ timeoutMs: 2500 });
+  // Refresh the on-disk update cache for the NEXT launch regardless of whether
+  // this launch's bounded wait below catches the result. Screen-safe: writes
+  // only, never renders (rendering after the prompt is armed would corrupt the
+  // boxed input footer).
+  void updatePromise.then(u => { if (u) void writeUpdateCache(u.latest); }).catch(() => {});
   // Terminal hygiene BEFORE anything renders: a previous program (or stale tmux
   // pane) can leave xterm mouse-tracking ON, so the terminal reports clicks and
   // motion as escape sequences from the very first prompt — the "starts out
@@ -1647,8 +1722,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   if (sweepable) await playWelcomeSweep(welcomeData, { cycles: sweepCycles });
   else console.log(renderWelcome(welcomeData).join("\n"));
 
-  const upd = await Promise.race([updatePromise, new Promise<null>(r => setTimeout(() => r(null), 1200))]);
-  if (upd?.updateAvailable) console.log(renderUpdateBox(upd.current, upd.latest).join("\n"));
+  // Surface the "New version" banner reliably: render ONCE from the on-disk cache
+  // instantly (no network wait, works offline — the common path after the first
+  // successful check), and ALSO from a bounded live check so a first run / version
+  // bump still shows it this launch. Both must run BEFORE the prompt is armed.
+  let updateBannerShown = false;
+  const showUpdateBanner = (u: { current: string; latest: string; updateAvailable: boolean } | null): void => {
+    if (updateBannerShown || !u?.updateAvailable) return;
+    updateBannerShown = true;
+    console.log(renderUpdateBox(u.current, u.latest).join("\n"));
+  };
+  showUpdateBanner(await readUpdateCache(pkg.version));
+  showUpdateBanner(await Promise.race([updatePromise, new Promise<null>(r => setTimeout(() => r(null), 1200))]));
   if (!LaunchTui.usable(flags.noTui)) console.log("(plain output)");
 
   const useTui = LaunchTui.usable(flags.noTui);
@@ -1800,6 +1885,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     };
   };
   let previewArmed = false;
+  // True while a prompt line is being awaited. Folded into the readline output
+  // gate so native echo is suppressed for the WHOLE await window — including the
+  // brief gap between turn-end and armPreview() — so no keystroke can leak into
+  // scrollback before the boxed footer takes over.
+  let promptActive = false;
   let pickerActive = false;
   const rl = createInterface({
     input: process.stdin,
@@ -1810,7 +1900,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // previously OPENED the gate and let readline echo typed filter characters
     // (CJK wide chars especially) straight onto the picker frame — the
     // "stacked input-box borders" corruption.
-    output: gatedStdout(process.stdout, () => previewArmed || pickerActive || interactiveTurnActive),
+    output: gatedStdout(process.stdout, () => previewArmed || promptActive || pickerActive || interactiveTurnActive),
     completer: (line: string) => readlineCompleter(line, completionContext()),
   });
   const promptStdin = process.stdin as typeof process.stdin & { isRaw?: boolean; setRawMode?(raw: boolean): void };
@@ -1839,6 +1929,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   queueBusySnapshot = () => ({
     text: queuedPromptInput.partial,
   });
+  queueBusyClear = () => { queuedPromptInput.partial = ""; };
   // Bracketed-paste line routing at the PROMPT: readline strips the 2004 markers
   // and replays pasted lines as synthetic keypresses, emitting paste-start /
   // paste-end around them. Lines submitted INSIDE that window are intentional
@@ -1897,6 +1988,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       if (hardExitOnLoopEnd || process.stdin.isTTY || process.stdout.isTTY) forceExitFromCtrlC();
       return "/exit";
     }
+    promptActive = true;
     try {
       return await Promise.race([
         rl.question(prompt),
@@ -1908,6 +2000,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }),
       ]);
     } finally {
+      promptActive = false;
       notifyStdinClosed = undefined;
     }
   };
@@ -1955,10 +2048,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const MAX_PREVIEW_ROWS = 12;
   const MIN_PREVIEW_ROWS = 7; // status bar (1) + spacer (1) + input box (3 rows) + 2 preview rows
   const previewRowsFor = (rows: number): number => Math.max(MIN_PREVIEW_ROWS, Math.min(MAX_PREVIEW_ROWS, rows - 6));
+  // Enable the boxed input footer for ANY interactive TTY. It paints inside a
+  // reserved bottom region (never scrollback) and only commits the line on
+  // Enter, so typed characters never leak into the conversation history while
+  // typing. previewRowsFor() clamps the reservation height for short terminals,
+  // so even small panes get the box instead of the raw `jeo>` echo fallback
+  // (which echoes every keystroke straight into scrollback). The raw fallback is
+  // now reserved for non-TTY/piped input, where live history echo is moot.
   const previewEnabled =
     process.stdin.isTTY &&
-    jeoEnv("NO_SLASH_PREVIEW") !== "1" &&
-    (process.stdout.rows ?? 24) >= MIN_PREVIEW_ROWS + 6; // box + ≥6 scrollable content rows
+    jeoEnv("NO_SLASH_PREVIEW") !== "1";
   // Footer height reserved by the CURRENTLY armed region; disarm/draw must use the
   // same value the arm computed, even if the terminal was resized in between.
   let footerRows = MAX_PREVIEW_ROWS;
@@ -2112,7 +2211,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   };
   const historyPreviewLines = (detail: string[]): string[] => {
     const cols = Math.max(24, (process.stdout.columns ?? 80) - 1);
-    const title = `${chalk.cyan.bold("history")} ${chalk.gray("· Ctrl+O closes")}`;
+    const title = `${uiAccent("history")} ${chalk.dim("· Ctrl+O closes")}`;
     const budget = Math.max(0, footerRows - 2);
     const physical = detail.flatMap(line => line.split("\n")).map(line => truncateAnsi(line, cols));
     let body = physical;
@@ -2833,29 +2932,34 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           console.log(chalk.dim(`(restored ${folded} queued input line${folded > 1 ? "s" : ""} into the prompt — Enter to run, Esc to discard)`));
         }
       }
-      // Refresh the status bar's dirty flag once per prompt (one git spawn, not per frame).
-      idleDirtyCount = branch ? gitDirtyCount(cwd) : undefined;
       const prefilledLine = queuedPromptInput.partial;
       queuedPromptInput.partial = "";
-      armPreview();
-      // Render the boxed input immediately so the prompt is visible even though
-      // readline's own echo is suppressed. If the user typed while the previous
-      // live turn/subagent was still running, seed that text into readline and the
-      // box instead of dropping it as "noise". A pasted batch's TRAILING partial
-      // (no final newline) survives in readline's own buffer — adopt it as the
-      // visible typed line so the box never hides editable input.
+      // Resolve the visible input text FIRST (cheap, no I/O): the queued prefill, else
+      // any partial the user typed while the previous live turn/subagent was running
+      // (that text survives in readline's own buffer — adopt it so the box never hides
+      // editable input). A pasted batch's TRAILING partial is recovered the same way.
       const rli = rl as unknown as { line?: string; cursor?: number; _refreshLine?: () => void };
       const residualPartial = !prefilledLine && typeof rli.line === "string" && rli.line.length > 0 && !/\x1b/.test(rli.line)
         ? rli.line
         : "";
       typedLine = prefilledLine || residualPartial;
+      navMatches = [];
+      navIdx = -1;
+      // Reserve + paint the boxed input IMMEDIATELY — WITH its real text — so the
+      // prompt is visible the instant the turn ends, BEFORE the git spawn below.
+      // Otherwise the dirty-flag spawn (slow on a large / just-edited repo) runs in a
+      // window where the box is gone and keystrokes echo nowhere (the "no response
+      // after the result" gap). readline's own echo stays gated while armed.
+      armPreview();
       if (prefilledLine) {
         rli.line = prefilledLine;
         rli.cursor = prefilledLine.length;
         rli._refreshLine?.();
       }
-      navMatches = [];
-      navIdx = -1;
+      drawFooter(previewLines(typedLine));
+      // Refresh the status bar's dirty flag once per prompt (one git spawn, not per
+      // frame); the second drawFooter repaints only if the count actually changed.
+      idleDirtyCount = branch ? gitDirtyCount(cwd) : undefined;
       drawFooter(previewLines(typedLine));
       // Box mode: NO raw `jeo>` prompt at all — the boxed footer IS the input UI
       // (gating already suppresses readline echo, the empty prompt guarantees no
@@ -3171,6 +3275,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         for (const line of TOOL_PROTOCOL.split("\n")) console.log(`  ${line}`);
         console.log(`  ${taskToolProtocolLine(await readGlobalConfig())}`);
         console.log(`  ${TODO_TOOL_PROTOCOL_LINE}`);
+        console.log(`  ${SUBAGENT_TOOL_PROTOCOL_LINE}`);
         continue;
       }
       if (input === "/hotkeys") {

package/src/commands/team.ts

@@ -403,7 +403,8 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     // LLM summary failure does not halt team
   }
 
-  let mutationsOk = 0; // round-8 parent audit: successful write/edit/bash count
+  let fileMutations = 0; // round-8 parent audit: successful write/edit/mkdir/delete
+  let bashRuns = 0;      // bash counted apart so read-only bash isn't edit evidence
   const result = await runAgentLoop(history, {
     cwd: ctx.cwd,
     model,
@@ -429,7 +430,10 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
         }
       },
       onToolResult: (tool, ok) => {
-        if (ok && (tool === "write" || tool === "edit" || tool === "bash")) mutationsOk++;
+        if (ok) {
+          if (tool === "write" || tool === "edit" || tool === "mkdir" || tool === "delete") fileMutations++;
+          else if (tool === "bash") bashRuns++;
+        }
         console.log(formatRalphStreamEvent(ok ? "complete" : "error", `tool ${tool}`, renderOpts));
       },
       onNotice: msg => console.log(formatRalphStreamEvent("step", msg, renderOpts)),
@@ -454,11 +458,14 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     return false;
   }
 
-  if (!role.readOnly && mutationsOk === 0) {
-    // Round-8: a mutating role finished without ONE successful mutation — the
+  if (!role.readOnly && fileMutations === 0) {
+    // Round-8: a mutating role finished without a successful file mutation — the
     // task may be legitimately read-only, but its "Changed Files:" claim is
-    // unverified; warn instead of silently trusting the report.
-    console.log(formatRalphStreamEvent("error", `${role.title} completed WITHOUT any successful write/edit/bash — treat its changed-files claim as unverified.`, renderOpts));
+    // unverified. bash is tracked apart: an only-bash run MIGHT have mutated.
+    const msg = bashRuns === 0
+      ? `${role.title} completed WITHOUT any successful write/edit/bash — treat its changed-files claim as unverified.`
+      : `${role.title} completed with only bash (no write/edit) — verify its changed-files claim independently.`;
+    console.log(formatRalphStreamEvent("error", msg, renderOpts));
   }
   console.log(formatRalphStreamEvent("complete", `${role.title} finished task`, renderOpts));
   return true;

package/src/skills/catalog.ts

@@ -3,7 +3,6 @@ import deepDiveSkillRaw from "../prompts/skills/deep-dive/SKILL.md" with { type:
 import ralplanSkillRaw from "../prompts/skills/ralplan/SKILL.md" with { type: "text" };
 import teamSkillRaw from "../prompts/skills/team/SKILL.md" with { type: "text" };
 import ultragoalSkillRaw from "../prompts/skills/ultragoal/SKILL.md" with { type: "text" };
-import gjcSkillRaw from "../prompts/skills/gjc/SKILL.md" with { type: "text" };
 
 const MAX_SKILL_SUMMARY_CHARS = 180;
 const MAX_SKILL_DETAILS_CHARS = 8_000;
@@ -29,7 +28,6 @@ export const SKILLS: SkillDoc[] = [
   parseSkillMarkdown("ralplan", ralplanSkillRaw),
   parseSkillMarkdown("team", teamSkillRaw),
   parseSkillMarkdown("ultragoal", ultragoalSkillRaw),
-  parseSkillMarkdown("gjc", gjcSkillRaw),
 ];
 export const BUILTIN_SKILL_NAMES = SKILLS.map(s => s.name.toLowerCase());