jeo-code 0.4.6 → 0.4.8

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" +
@@ -1355,6 +1360,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         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
@@ -1408,9 +1418,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               return;
             }
           }
-          // Keep the SAME query input box visible during a live turn. Printable
-          // keystrokes edit the next prompt draft; there is no separate queue surface.
-          if (captured) tui.setLivePromptInput(queueBusySnapshot?.().text ?? "");
+          // 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);
@@ -1422,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"
@@ -1442,11 +1461,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             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, {
@@ -1488,6 +1509,7 @@ 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);
@@ -1660,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
@@ -1695,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);
@@ -3238,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());
 

package/src/tui/app.ts

@@ -22,7 +22,7 @@ import type { TaskSubEvent } from "../agent/task-tool";
 import { supportsUnicode } from "./components/capability";
 import { centerBlock, padLineTo, boxBlock, BOX_ASCII, BOX_UNICODE } from "./components/layout";
 import { SECTION_GAP, stackSections } from "./components/section";
-import { resolveTheme, themeGradient, accentPaint, accentShadowPaint, diffPaint } from "./components/themes";
+import { resolveTheme, themeGradient, accentPaint, accentShadowPaint, diffPaint, mutedPaint, cardFillPaint } from "./components/themes";
 import { detectColorLevel, animatedGradientText, ColorLevel } from "./components/color";
 import { formatForgeBox, summarizeForgeInvocation, summarizeForgeResult, fitForgeBoxes, webSearchCardLines, type ForgeSummary } from "./components/forge";
 import { renderJeoStatus, renderStatusBar, renderStatusBox } from "./components/status";
@@ -30,7 +30,7 @@ import { costForUsage, formatCost } from "../ai/pricing";
 import { renderMarkdownTables } from "./components/markdown-table";
  
 import { stripMarkdown, renderMarkdownAnsi } from "./components/markdown-text";
-import { visibleWidth, wrapTextWithAnsi } from "./components/width";
+import { visibleWidth, wrapTextWithAnsi, truncateToWidth, sanitizeForFrame } from "./components/width";
 import { categoryBadge } from "./components/category-index";
 import { formatStepTimeline, stepsFromTools, formatStepHeader, formatStepTimelineCompact, type StepState } from "./components/step-timeline";
 import { formatHintBar } from "./components/hints";
@@ -63,9 +63,11 @@ export interface AgentEventsLike {
   onStep?(step: number): void;
   onAssistant?(raw: string, invocation: { tool: string; arguments?: unknown } | null): void;
   onToolResult?(tool: string, success: boolean, output: string): void;
+  onToolProgress?(tool: string, partial: string): void;
   onNotice?(message: string): void;
   onUsage?(usage: { inputTokens: number; outputTokens: number }): void;
   onModelStream?(textSoFar: string): void;
+  onReasoningStream?(textSoFar: string): void;
   onBudget?(limit: number, reason: string): void;
 
 }
@@ -186,11 +188,19 @@ export class LaunchTui {
   // `"reasoning"` field of the forming tool-call JSON). Shown dim under the HUD while
   // the model responds, then flushed once into scrollback as a `jeo · …` ledger line.
   private streamingReasoning = "";
+  /** Native model thinking text (separate reasoning channel), shown DIMMED while it
+   *  streams and cleared on commit — ephemeral, never flushed (the durable record is the
+   *  action/reply the thinking produced). */
+  private streamingThought = "";
   /** Uniform live-activity text for the live status field (reasoning OR derived fallback). */
   private streamingActivity = "";
   /** Last stream-driven draw (ms epoch) — throttles per-delta repaints to ≤10/s. */
   private lastStreamDraw = 0;
   private flushedReasoning = "";
+  // Live streaming output of the currently-running tool (bash stdout via onToolProgress).
+  // Shown as a DIMMED bounded block while the tool runs; cleared when the formatted
+  // result card lands (onToolResult) — the gjc-style "shaded until complete" effect.
+  private liveToolOutput = "";
   // Ctrl+O history/detail panel. When set, the live inline frame shows this
   // block above the heartbeat; pressing Ctrl+O again clears it and restores the
   // normal activity view. Kept as data, not scrollback text, so it can actually close.
@@ -268,7 +278,14 @@ export class LaunchTui {
     // scrollback (☑ + strikethrough as items complete), so the checklist's history
     // is reviewable. The live pinned plan stays in the frame tail as before.
     if (changed && items.length > 0 && !this.finished) {
-      const card = formatTodoWriteCard(items, { unicode: this.unicode, color: this.theme.color });
+      const card = formatTodoWriteCard(items, {
+        unicode: this.unicode,
+        color: this.theme.color,
+        muted: mutedPaint(this.theme),
+        accent: this.theme.color ? accentPaint(this.theme) : undefined,
+        fill: cardFillPaint(this.theme),
+        width: Math.max(24, Math.min(100, size().cols)),
+      });
       this.appendLedger(card.join("\n") + "\n", "card");
     }
     this.todos = items;
@@ -320,8 +337,10 @@ export class LaunchTui {
         this.hudPhase = "thinking";
         this.retryNotice = null; // a new step starts a fresh model call
         this.streamingReasoning = ""; // fresh model response this step
+        this.streamingThought = "";
         this.streamingActivity = "";
         this.flushedReasoning = "";
+        this.liveToolOutput = ""; // fresh step: no tool output yet
         this.currentStepStartedAt = Date.now();
         this.spinner.updateStep(step, this.footer.maxSteps);
         this.spinner.next();
@@ -353,6 +372,18 @@ export class LaunchTui {
           this.draw();
         }
       },
+      onReasoningStream: textSoFar => {
+        if (this.finished) return;
+        // Native thinking deltas → the SAME transient dimmed block as the JSON-reasoning
+        // path (reuses the screen-safe tail renderer; no new frame structure). Ephemeral:
+        // cleared on commit, never flushed into scrollback.
+        if (textSoFar === this.streamingThought) return;
+        this.streamingThought = textSoFar;
+        if (Date.now() - this.lastStreamDraw >= 100) {
+          this.lastStreamDraw = Date.now();
+          this.draw();
+        }
+      },
       onAssistant: (_raw, invocation) => {
         this.thinking = false; // model replied; now dispatching the tool
         this.retryNotice = null; // the call got through — clear any backoff notice
@@ -365,6 +396,7 @@ export class LaunchTui {
           this.appendLedger(`${name}\n${this.streamingReasoning}\n`, "reasoning");
         }
         this.streamingReasoning = "";
+        this.streamingThought = "";
         this.streamingActivity = "";
         if (invocation && invocation.tool !== "done") {
           this.runningTool = true;
@@ -394,8 +426,20 @@ export class LaunchTui {
           this.hudPhase = "reporting";
         }
       },
+      onToolProgress: (_tool, partial) => {
+        if (this.finished) return;
+        // Sanitize raw child stdout (CR / EL / cursor-move escapes) before it enters the
+        // frame — unsanitized control bytes tore the renderer's next \x1b[2K (literal "2K")
+        // and hijacked the cursor, corrupting the live frame.
+        this.liveToolOutput = sanitizeForFrame(partial);
+        if (Date.now() - this.lastStreamDraw >= 100) {
+          this.lastStreamDraw = Date.now();
+          this.draw();
+        }
+      },
       onToolResult: (tool, success, output) => {
         this.runningTool = false;
+        this.liveToolOutput = ""; // formatted result card now replaces the live dim output
         if (this.pendingIndex !== null) {
           this.tools.finish(this.pendingIndex, success);
           this.pendingIndex = null;
@@ -544,10 +588,10 @@ export class LaunchTui {
     return [`  ${accent("user")}`, top, ...mid, bottom];
   }
 
-  /** Flush a `user` card into scrollback for a mid-turn steering query: signals that
-   *  the additional input was accepted and is now driving the running turn (gjc parity),
-   *  instead of only a transient status notice. */
-  flushSteerCard(text: string): void {
+  /** Flush a `user` card into scrollback so a submitted query stays visible there
+   *  (gjc parity), instead of only as the transient HUD turn-title / a status notice.
+   *  Shared by the prompt that STARTS a turn and the mid-turn steering flush. */
+  flushUserCard(text: string): void {
     const t = (text ?? "").trim();
     if (!t || this.finished) return;
     const cols = Math.max(20, size().cols);
@@ -555,6 +599,12 @@ export class LaunchTui {
     if (lines.length) this.appendLedger(lines.join("\n"), "card");
   }
 
+  /** Mid-turn steering query → a `user` card in scrollback (accepted input that is
+   *  now driving the running turn). Alias of {@link flushUserCard}. */
+  flushSteerCard(text: string): void {
+    this.flushUserCard(text);
+  }
+
   /** Append a completed progress-ledger line. In inline mode the line is flushed
    *  straight into normal scrollback ABOVE the live frame, so tmux / terminal
    *  mouse-wheel can review the full progress history mid-turn (gjc-style); the
@@ -704,7 +754,7 @@ export class LaunchTui {
     if (this.finished) return;
     const color = this.theme.color;
     const role = e.role || "subagent";
-    const roleLabel = role.toUpperCase();
+    const roleLabel = 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";
@@ -736,7 +786,7 @@ export class LaunchTui {
       case "done":
         this.subagentActive = false;
         this.subagentLive = null;
-        this.appendLedger(`${badge} ${last} ${roleLabel} done${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();
@@ -960,6 +1010,7 @@ export class LaunchTui {
       paint,
       paintShadow,
       diffPaint: diffPaint(this.theme),
+      fill: cardFillPaint(this.theme),
       color: this.theme.color,
     });
     this.appendLedger(lines.join("\n") + "\n", "card");
@@ -971,6 +1022,7 @@ export class LaunchTui {
     width: number,
     maxEntries: number,
     anim?: { phase: number; colorLevel: ColorLevel; beat: string },
+    dim = false,
   ): string[] {
     const floor = Math.min(24, width);
     // Fill the available width (cap at formatForgeBox's own 120 ceiling) so an
@@ -987,12 +1039,14 @@ export class LaunchTui {
         paint,
         paintShadow: accentShadowPaint(this.theme),
         diffPaint: diffPaint(this.theme),
+        fill: cardFillPaint(this.theme),
         index: i + 1,
         color: this.theme.color,
+        dim,
         // DNA-flow identity on LIVE cards only: the flowing helix gradient rides
         // the card border and the claw beat marks the title. Flushed/final cards
-        // stay static — scrollback never carries animation frames.
-        ...(anim
+        // stay static. Suppressed while `dim` (in-flight shading takes precedence).
+        ...(anim && !dim
           ? { flow: { palette: DNA_FLOW_PALETTE, phase: anim.phase, colorLevel: anim.colorLevel }, titleMark: anim.beat }
           : {}),
       }));
@@ -1057,6 +1111,47 @@ export class LaunchTui {
     // it is the live heartbeat and must always be visible; the in-flight card gets
     // whatever rows remain above it.
     const tail: string[] = [];
+    // Live reasoning (gjc-style muted thinking): stream the model's forming thought
+    // as a DIMMED, bounded block above the status line. It is transient — flushed
+    // UN-dimmed into scrollback once the model commits to a tool/reply (onAssistant),
+    // so the in-progress trace stays shaded while the final record reads in normal text.
+    const liveThink = this.streamingThought.trim() || this.streamingReasoning.trim();
+    if (isThinking && liveThink) {
+      const wrapW = Math.max(8, Math.min(120, cols) - 2);
+      const wrapped = liveThink
+        .split("\n")
+        .flatMap(l => wrapTextWithAnsi(l, wrapW))
+        .filter(l => l.length > 0);
+      // FIXED reserved height (bottom-anchored, blank-padded at top): once present the
+      // block's row count is CONSTANT, so streaming content never changes the frame
+      // height. The per-100ms height thrash that desynced the differential renderer
+      // (duplicate model bar) is gone; height now toggles only at lifecycle boundaries.
+      const ROWS = 6;
+      const shown = wrapped.slice(-ROWS);
+      tail.push(dim(`${this.unicode ? "│" : "|"} thinking`));
+      for (let k = 0; k < ROWS - shown.length; k++) tail.push("");
+      for (const l of shown) tail.push(dim(`  ${l}`));
+      tail.push("");
+    }
+
+    // Live tool output (gjc-style streaming bash stdout): while a tool runs, its
+    // output arrives via onToolProgress and is shown as a DIMMED, bounded tail block.
+    // It is transient — cleared on result, when the formatted forge card takes over.
+    if (this.runningTool && this.liveToolOutput.trim()) {
+      const wrapW = Math.max(8, Math.min(120, cols) - 2);
+      const wrapped = this.liveToolOutput
+        .split("\n")
+        .flatMap(l => wrapTextWithAnsi(l, wrapW))
+        .filter(l => l.length > 0);
+      // FIXED reserved height (see thinking block): constant rows while a tool streams,
+      // so cumulative stdout growth does not thrash the frame height.
+      const ROWS = 8;
+      const shown = wrapped.slice(-ROWS);
+      tail.push(dim(`${this.unicode ? "│" : "|"} output`));
+      for (let k = 0; k < ROWS - shown.length; k++) tail.push("");
+      for (const l of shown) tail.push(dim(`  ${l}`));
+      tail.push("");
+    }
 
     // Live status field: unboxed thinking line + compact metrics row. The model's
     // streamed activity is uniform across providers via streamingActivity and keeps
@@ -1128,7 +1223,7 @@ export class LaunchTui {
       const forgeAnim = isThinking && this.theme.color && colorLevel >= ColorLevel.TrueColor
         ? { phase, colorLevel, beat }
         : undefined;
-      const forgeK = budget > 0 ? fitForgeBoxes(this.renderForge(cols, 2, forgeAnim), budget) : [];
+      const forgeK = budget > 0 ? fitForgeBoxes(this.renderForge(cols, 2, forgeAnim, true), budget) : [];
       if (forgeK.length) {
         frame.push(...forgeK);
         frame.push("");
@@ -1221,7 +1316,18 @@ export class LaunchTui {
     // model bar), no outer border, no mascot art — completed work lives in scrollback.
     if (fit && this.inline) {
       const inlineFrame = this.composeInlineFrame({ cols, rows, stepNow, elapsedMs, idx, isThinking, planLines });
-      this.renderer.render(inlineFrame.slice(0, rows));
+      // Option C (constant live-frame height): pad the composed frame to EXACTLY `rows`
+      // — blank rows at the TOP, the tail (status/hud/input/model bar) pinned to the
+      // bottom. With a constant height the differential renderer reserves rows ONCE and
+      // thereafter only does in-place, within-frame cursor moves; the bottom-margin
+      // reserve-GROW that drifted the anchor by one row (the duplicate model bar during
+      // rapid tool churn) never runs again. Every line is still width-clamped so a long
+      // line cannot soft-wrap into a second physical row and desync the row accounting.
+      const capped = inlineFrame.length > rows ? inlineFrame.slice(inlineFrame.length - rows) : inlineFrame;
+      const fixedHeight = capped.length < rows
+        ? [...new Array(rows - capped.length).fill(""), ...capped]
+        : capped;
+      this.renderer.render(fixedHeight.map(l => truncateToWidth(l, cols)));
       return;
     }
 
@@ -1406,6 +1512,6 @@ export class LaunchTui {
     if (fit) {
       frame = frame.slice(0, rows);
     }
-    this.renderer.render(frame);
+    this.renderer.render(frame.map(l => truncateToWidth(l, cols)));
   }
 }

package/src/tui/components/forge.ts

@@ -33,6 +33,16 @@ export interface ForgeBoxOptions {
    *  the FULL padded row so added/removed lines read as background-tinted
    *  stripes — block-level contrast inside the card. */
   diffPaint?: { add: (s: string) => string; del: (s: string) => string };
+  /** Faint card background tint painter — applied to every WHOLE box row (borders
+   *  + content) so the card reads as a panel. Interior coloring uses targeted close
+   *  codes, so the fill spans each row. Identity/omitted = transparent card. Patch
+   *  `diffPaint` rows set their own background and intentionally override it. */
+  fill?: (s: string) => string;
+  /** In-flight shading: render the card as a flat DIMMED block (gjc-style "not done
+   *  yet" look). Strips inner color and wraps every row in `chalk.dim`, so a live
+   *  card reads as shaded until the result arrives and the normal formatted card
+   *  replaces it. Overrides `fill`/`flow` coloring. */
+  dim?: boolean;
 }
 
 const SECRET_VALUE_RE = /(api[_-]?key|authorization|bearer|password|secret|token)(\s*[:=]\s*)(["']?)[^"'\s,}]+/gi;
@@ -559,5 +569,12 @@ export function formatForgeBox(summary: ForgeSummary, opts: ForgeBoxOptions = {}
     rendered.push(contentRow(`… ${content.length - clipped.length} more lines ${hint}`));
   }
   rendered.push(bottom);
-  return rendered;
+  // In-flight shading takes precedence: strip inner color and dim every row so a
+  // live card reads as a flat shaded block until its formatted result replaces it.
+  if (opts.dim) {
+    return rendered.map(l => chalk.dim(l.replace(/\x1b\[[0-9;]*m/g, "")));
+  }
+  // Faint panel tint: wrap each whole, width-padded row so the card background spans
+  // the full rectangle (borders + content). No-op when no fill painter is supplied.
+  return opts.fill ? rendered.map(opts.fill) : rendered;
 }

package/src/tui/components/markdown-text.ts

@@ -64,7 +64,13 @@ export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {})
       .replace(/`([^`]+)`/g, (_m, code: string) => chalk.cyan(code))
       .replace(/\*\*\*([^\*]+)\*\*\*/g, (_m, t: string) => chalk.bold.italic(t))
       .replace(/\*\*([^\*]+)\*\*/g, (_m, t: string) => chalk.bold(t))
-      .replace(/__([^\_]+)__/g, (_m, t: string) => chalk.bold(t));
+      .replace(/__([^\_]+)__/g, (_m, t: string) => chalk.bold(t))
+      // Single *italic* / _italic_ run AFTER the ***/**/__ passes so the doubles
+      // are already consumed. The `*` form ignores list bullets ("* item" has no
+      // closing `*`); the `_` form is word-boundary guarded so snake_case
+      // identifiers (foo_bar_baz) are never mistaken for emphasis.
+      .replace(/\*([^\s*][^*\n]*?[^\s*]|[^\s*])\*/g, (_m, t: string) => chalk.italic(t))
+      .replace(/(?<![\p{L}\p{N}_])_(?=\S)([^_\n]*?)(?<=\S)_(?![\p{L}\p{N}_])/gu, (_m, t: string) => chalk.italic(t));
 
   const out: string[] = [];
   let inFence = false;
@@ -79,6 +85,9 @@ export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {})
     }
     const heading = line.match(/^(#{1,6})\s+(.+)$/);
     if (heading) {
+      // Vertical rhythm: a heading that follows content gets one blank line of
+      // breathing room above it (final-report readability), never a leading blank.
+      if (out.length > 0 && out[out.length - 1]!.trim() !== "") out.push("");
       out.push(accent(styleInline(heading[2]!)));
       continue;
     }

package/src/tui/components/themes.ts

@@ -34,6 +34,14 @@ export interface EvolutionTheme {
   diff?: { add: string; del: string; addBg: string; delBg: string; hunk: string };
   /** User query card palette: themed colors for the mid-turn steering user card. */
   userCard?: { accent: string; border: string; shadow: string; fill: string };
+  /** Muted foreground for secondary text (done/pending todo items, counts, tree
+   *  connectors). A real readable mid-tone — replaces `chalk.dim`, which washes
+   *  out to near-invisible on dark backgrounds. Falls back to a neutral gray. */
+  muted?: string;
+  /** Faint background tint for tool/todo cards — a subtle panel fill so cards read
+   *  as distinct blocks instead of floating on the terminal background. Falls back
+   *  to `userCard.fill`. No fill when the theme is colorless. */
+  card?: { fill: string };
 }
 
 /** Default diff palette (used when a theme defines none): high-contrast
@@ -277,6 +285,44 @@ export function accentShadowPaint(theme: EvolutionTheme): (s: string) => string
   return (s: string) => chalk.dim(chalk.hex(hex)(s));
 }
 
+/** Default muted foreground when a theme defines no `muted` — a readable mid-gray
+ *  that holds up on dark terminals (unlike ANSI `dim`, which collapses toward the
+ *  background). */
+export const DEFAULT_MUTED = "#9aa0a6";
+
+/** Painter for secondary/muted text. A real mid-tone hue, NOT `chalk.dim` — dim
+ *  renders near-invisible on dark backgrounds (the washed-out done/pending todo
+ *  rows). Identity when the theme is colorless. */
+export function mutedPaint(theme: EvolutionTheme): (s: string) => string {
+  if (!theme.color) return (s: string) => s;
+  const hex = theme.muted ?? DEFAULT_MUTED;
+  return (s: string) => chalk.hex(hex)(s);
+}
+
+/** Lighten a `#rrggbb` hex by a per-channel delta (clamped 0–255). Used to lift a
+ *  near-black `userCard.fill` (tuned for input chrome) into a card tint that reads
+ *  as a distinct panel without becoming loud. */
+export function liftHex(hex: string, delta: number): string {
+  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim());
+  if (!m) return hex;
+  const n = parseInt(m[1], 16);
+  const ch = (shift: number) => Math.max(0, Math.min(255, ((n >> shift) & 0xff) + delta));
+  return "#" + [ch(16), ch(8), ch(0)].map(v => v.toString(16).padStart(2, "0")).join("");
+}
+
+/** Painter that applies the theme's faint card background tint, so tool/todo cards
+ *  read as panels. Uses an explicit `card.fill`, else lifts `userCard.fill` (which is
+ *  near-black, tuned for input chrome) by a small delta so the panel separates from
+ *  the terminal background. Identity when the theme is colorless or has no fill. The
+ *  fill wraps whole, width-padded lines whose interior coloring uses targeted close
+ *  codes (never a full `\x1b[0m` reset), so the background spans the row. */
+export function cardFillPaint(theme: EvolutionTheme): (s: string) => string {
+  if (!theme.color) return (s: string) => s;
+  const fill = theme.card?.fill ?? (theme.userCard?.fill ? liftHex(theme.userCard.fill, 12) : undefined);
+  if (!fill) return (s: string) => s;
+  return (s: string) => chalk.bgHex(fill)(s);
+}
+
 /** Themed diff painters: foreground + full-row background tints for added /
  *  removed lines (block-level separation, not just a colored sign) and a
  *  distinct hunk-header color. Identity painters when the theme is colorless. */