jeo-code 0.4.5 → 0.4.6

package/README.ja.md

@@ -150,11 +150,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.4.6]** (2026-06-14) — Width-correct forge cards for CJK/emoji, red borders on failed tool cards, aligned `ooo ralph` monitor HUD, and a per-theme user-card palette.
 - **[0.4.5]** (2026-06-14) — First-class filesystem make/remove tools.
 - **[0.4.4]** (2026-06-13) — Live subagent status mirroring, always-useful Ctrl+O activity tail, read lineRange crash guard.
 - **[0.4.3]** (2026-06-13) — Readability pass for autopilot, subagent activity, and worked-history review.
 - **[0.4.2]** (2026-06-13) — Thinking-loop termination guarantees (cycle guard + turn wall-clock budget), unboxed live status without step counters, self-contained `.jeo` namespace, live next-prompt input card, role-targeted model/thinking picker.
-- **[0.4.1]** (2026-06-12) — TUI card parity polish + done-time todo reconciliation.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -150,11 +150,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.4.6]** (2026-06-14) — Width-correct forge cards for CJK/emoji, red borders on failed tool cards, aligned `ooo ralph` monitor HUD, and a per-theme user-card palette.
 - **[0.4.5]** (2026-06-14) — First-class filesystem make/remove tools.
 - **[0.4.4]** (2026-06-13) — Live subagent status mirroring, always-useful Ctrl+O activity tail, read lineRange crash guard.
 - **[0.4.3]** (2026-06-13) — Readability pass for autopilot, subagent activity, and worked-history review.
 - **[0.4.2]** (2026-06-13) — Thinking-loop termination guarantees (cycle guard + turn wall-clock budget), unboxed live status without step counters, self-contained `.jeo` namespace, live next-prompt input card, role-targeted model/thinking picker.
-- **[0.4.1]** (2026-06-12) — TUI card parity polish + done-time todo reconciliation.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -150,11 +150,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.4.6]** (2026-06-14) — Width-correct forge cards for CJK/emoji, red borders on failed tool cards, aligned `ooo ralph` monitor HUD, and a per-theme user-card palette.
 - **[0.4.5]** (2026-06-14) — First-class filesystem make/remove tools.
 - **[0.4.4]** (2026-06-13) — Live subagent status mirroring, always-useful Ctrl+O activity tail, read lineRange crash guard.
 - **[0.4.3]** (2026-06-13) — Readability pass for autopilot, subagent activity, and worked-history review.
 - **[0.4.2]** (2026-06-13) — Thinking-loop termination guarantees (cycle guard + turn wall-clock budget), unboxed live status without step counters, self-contained `.jeo` namespace, live next-prompt input card, role-targeted model/thinking picker.
-- **[0.4.1]** (2026-06-12) — TUI card parity polish + done-time todo reconciliation.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -150,11 +150,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.4.6]** (2026-06-14) — Width-correct forge cards for CJK/emoji, red borders on failed tool cards, aligned `ooo ralph` monitor HUD, and a per-theme user-card palette.
 - **[0.4.5]** (2026-06-14) — First-class filesystem make/remove tools.
 - **[0.4.4]** (2026-06-13) — Live subagent status mirroring, always-useful Ctrl+O activity tail, read lineRange crash guard.
 - **[0.4.3]** (2026-06-13) — Readability pass for autopilot, subagent activity, and worked-history review.
 - **[0.4.2]** (2026-06-13) — Thinking-loop termination guarantees (cycle guard + turn wall-clock budget), unboxed live status without step counters, self-contained `.jeo` namespace, live next-prompt input card, role-targeted model/thinking picker.
-- **[0.4.1]** (2026-06-12) — TUI card parity polish + done-time todo reconciliation.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/engine.ts

@@ -149,6 +149,10 @@ export interface AgentLoopEvents {
    *  first"); return null to let the turn finish. The engine guarantees at most
    *  one bounce per turn, so a stubborn model can never loop here. */
   onBeforeDone?(reason: string): string | null;
+  /** Fired when a mid-turn steering message (an additional user query typed while
+   *  the turn is running) is injected into the live history. `text` is the raw
+   *  user line — drives a TUI notice so the user sees their input was picked up. */
+  onSteer?(text: string): void;
 }
 
 export interface AgentLoopOptions {
@@ -173,6 +177,11 @@ export interface AgentLoopOptions {
   /** Step-budget overrides (gjc-style retry flow). `{ maxExtensions: 0 }` restores the
    *  legacy fixed counter — used by bounded subagent delegation. */
   budget?: Partial<StepBudgetConfig>;
+  /** Mid-turn steering drain (gjc parity): called at each step boundary. Any strings
+   *  returned are appended to `history` as user messages BEFORE the next model call,
+   *  so an additional query typed while the turn runs steers the live turn instead of
+   *  waiting for the next prompt. Return [] when nothing is pending. */
+  steer?: () => string[];
 }
 
 export interface AgentLoopResult {
@@ -400,6 +409,29 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     }
     await ev.onStep?.(step);
 
+    // MID-TURN steering (gjc parity): drain any additional user queries typed while
+    // the turn is running and inject them as user messages BEFORE this step's model
+    // call, so the live turn adapts immediately instead of deferring to the next
+    // prompt. A genuine new instruction resets the stall/failure guards (it is fresh
+    // progress, not a repeat) and earns a budget extension so the loop has room to act.
+    if (opts.steer) {
+      const pending = opts.steer();
+      for (const raw of pending) {
+        const text = (raw ?? "").trim();
+        if (!text) continue;
+        history.push({
+          role: "user",
+          content: `[mid-turn steering — additional instruction from the user; incorporate it now]\n${text}`,
+        });
+        ev.onSteer?.(text);
+        repeatCount = 0;
+        lastSig = "";
+        consecutiveFailures = 0;
+        recentStepSigs.length = 0;
+        budget.noteSteer?.();
+      }
+    }
+
     // MID-TURN context guard: a single long turn (60+ steps) otherwise grows the
     // history without bound — turn-boundary compaction never runs inside a turn,
     // and field evidence shows multi-million-token prompts degrading the model
@@ -623,6 +655,29 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
           continue;
         }
       }
+      // Steering that arrived DURING this final step (after the top-of-loop drain,
+      // while the model was generating its `done`): reopen the turn and handle it now
+      // instead of letting it bounce to the next prompt. Bounded by the step/time budget.
+      if (opts.steer) {
+        const pending = opts.steer().map(s => (s ?? "").trim()).filter(Boolean);
+        if (pending.length) {
+          history.push({ role: "assistant", content: responseText });
+          for (const text of pending) {
+            history.push({
+              role: "user",
+              content: `[mid-turn steering — additional instruction from the user; incorporate it now before finishing]\n${text}`,
+            });
+            ev.onSteer?.(text);
+          }
+          repeatCount = 0;
+          lastSig = "";
+          consecutiveFailures = 0;
+          recentStepSigs.length = 0;
+          budget.noteSteer();
+          step++;
+          continue;
+        }
+      }
       return finish({ done: true, steps: step, doneReason: (toolCalls[0].arguments?.reason as string) ?? "" });
     }
 

package/src/agent/step-budget.ts

@@ -180,6 +180,16 @@ export class StepBudget {
     if (this.window.length > this.cfg.windowSize) this.window.shift();
   }
 
+  /** A mid-turn steering message arrived — fresh, user-driven work. Grant headroom
+   *  (capped at the hard cap, without consuming the extension budget) and clear the
+   *  scoring window so the new instruction is never declined by the previous
+   *  sub-task's stall/failure signals. */
+  noteSteer(): void {
+    this.window.length = 0;
+    this.novelSinceExtension = 0;
+    this.currentLimit = Math.min(this.currentLimit + this.cfg.extensionSteps, this.cfg.hardCap);
+  }
+
   /** Progress over the recent window: ok count, total, distinct signatures. */
   progress(): { ok: number; total: number; distinct: number } {
     const ok = this.window.filter(r => r.success).length;

package/src/agent/task-tool.ts

@@ -51,6 +51,13 @@ export interface TaskToolOptions {
   signal?: AbortSignal;
   /** Optional live sink (e.g. plain-stream rendering of nested progress). */
   onEvent?: (ev: TaskSubEvent) => void;
+  /** Mid-turn steering drain (gjc parity). Forwarded to a SINGLE running subagent so
+   *  an additional user query typed while the subagent works reaches it live. While
+   *  the subagent runs the parent loop is blocked inside this tool call, so the
+   *  subagent is the only active drainer — the message is not double-consumed.
+   *  Fan-out batches do NOT forward it (parallel drains would deliver to one arbitrary
+   *  subagent); pending steering stays for the parent after the batch returns. */
+  steer?: () => string[];
 }
 
 /** Max concurrent read-only subagents in a fan-out batch. */
@@ -134,6 +141,7 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     taskText: string,
     context: string,
     cwd: string,
+    steer?: () => string[],
   ): Promise<ToolResult> => {
     const model = resolveSubagentModel(role.id, opts.config);
     const maxSteps = resolveSubagentMaxSteps(role.id, opts.config);
@@ -162,6 +170,7 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
       // owns any retry/extension decision, so the gjc retry flow is disabled here.
       budget: { maxExtensions: 0 },
       signal: opts.signal,
+      steer,
       tools: subagentToolset(role),
       events: {
         onStep: n => { currentStep = n; },
@@ -184,6 +193,9 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
         // Retry notices (rate-limit backoff etc.) surface as live "step" beats so the
         // parent's monitor shows WHY a subagent is pausing instead of going silent.
         onNotice: msg => opts.onEvent?.({ role: role.id, kind: "step", detail: msg, step: currentStep, maxSteps, model }),
+        // Mid-turn steering reached this subagent: surface it as a live beat so the
+        // parent's monitor shows the redirect instead of an unexplained behavior change.
+        onSteer: text => opts.onEvent?.({ role: role.id, kind: "step", detail: `↳ steer: ${text}`, step: currentStep, maxSteps, model }),
       },
     });
     const reason = result.doneReason?.trim() || `(subagent reached the ${result.steps}-step limit without signaling done)`;
@@ -267,6 +279,6 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     if (!taskText) {
       return { success: false, output: "", error: `task tool requires a non-empty 'task' (or a 'tasks' array). Valid roles: ${subagentRoleIds(opts.config).join(", ")}.` };
     }
-    return runOne(role, taskText, ctx(args.context), cwd);
+    return runOne(role, taskText, ctx(args.context), cwd, opts.steer);
   };
 }

package/src/ai/model-manager.ts

@@ -96,9 +96,13 @@ export function thinkingToReasoningEffort(
   return "medium";
 }
 
-/** Describe a model id: alias expansion + the provider it routes to. For `/model` + diagnostics. */
-export async function describeModel(input: string): Promise<{ input: string; resolved: string; provider: ProviderName }> {
-  const resolved = await resolveModelId(input);
+/** Describe a model id: alias expansion + the provider it routes to. For `/model` + diagnostics.
+ *  Pass an already-read `config` to skip a redundant readGlobalConfig() on the turn hot path. */
+export async function describeModel(
+  input: string,
+  config?: { modelAliases?: Record<string, string> },
+): Promise<{ input: string; resolved: string; provider: ProviderName }> {
+  const resolved = await resolveModelId(input, config);
   return { input, resolved, provider: resolveProvider(resolved) };
 }
 

package/src/ai/model-registry.ts

@@ -25,9 +25,14 @@ export function expandAlias(input: string, aliases: ModelAliases = BUILTIN_ALIAS
 }
 
 // Async: merge BUILTIN_ALIASES with config.modelAliases (config wins) and expand.
-export async function resolveModelId(input: string): Promise<string> {
-  const config = await readGlobalConfig();
-  const modelAliases = (config as any).modelAliases ?? {};
+// Pass an already-read `config` to skip the readGlobalConfig() round-trip (turn
+// hot path: avoids re-reading the config file mid-turn for model resolution).
+export async function resolveModelId(
+  input: string,
+  config?: { modelAliases?: ModelAliases },
+): Promise<string> {
+  const cfg = config ?? (await readGlobalConfig());
+  const modelAliases = (cfg as any).modelAliases ?? {};
   const merged: ModelAliases = { ...BUILTIN_ALIASES, ...modelAliases };
   return expandAlias(input, merged);
 }

package/src/commands/launch.ts

@@ -1297,6 +1297,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 +1314,56 @@ 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 });
+      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,10 +1385,31 @@ 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;
+          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;
+            }
+          }
           // 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.
+          // keystrokes edit the next prompt draft; there is no separate queue surface.
           if (captured) tui.setLivePromptInput(queueBusySnapshot?.().text ?? "");
         },
         onAbortNotice: msg => {
@@ -1403,6 +1441,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           task: createTaskTool({
             config: { ...turnConfig, defaultModel: activeModel },
             signal: ac.signal,
+            steer: drainSteer,
             onEvent: useTui
               ? (e => tui?.onSubagentEvent(e))
               : (e => logTaskSubEvent(e)),
@@ -1417,6 +1456,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 +1474,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 +1488,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
       } finally {
         harness.dispose();
+        // 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) {
@@ -1800,6 +1848,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 +1863,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 +1892,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 +1951,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 +1963,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }),
       ]);
     } finally {
+      promptActive = false;
       notifyStdinClosed = undefined;
     }
   };
@@ -1955,10 +2011,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 +2174,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 +2895,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

package/src/tui/app.ts

@@ -417,7 +417,7 @@ export class LaunchTui {
           // the non-TTY summary both show the merged card.
           card.title = `${paintedMark} Bash`;
           card.lines.push(...result.lines);
-          this.flushForgeCard(card);
+          this.flushForgeCard(card, success);
         } else if (card && t === "web_search" && success && webSearchCardLines(output, { unicode: this.unicode })) {
           // gjc-style Web Search card: `✓ Web Search: <provider> · N sources` header
           // over Query / Answer / Sources / Metadata divider sections rebuilt from
@@ -426,12 +426,12 @@ export class LaunchTui {
           const ws = webSearchCardLines(output, { unicode: this.unicode })!;
           card.title = `${paintedMark} Web Search: ${ws.titleMeta}`;
           card.lines = ws.lines;
-          this.flushForgeCard(card);
+          this.flushForgeCard(card, success);
         } else if (card) {
           card.title = `${paintedMark} ${card.title}`;
           if (!success) this.rememberForge(result);
-          this.flushForgeCard(card);
-          if (!success) this.flushForgeCard(result);
+          this.flushForgeCard(card, success);
+          if (!success) this.flushForgeCard(result, false);
         } else {
           // Light tool: one ✓/✗ line, plus a dim result tree for list-shaped output
           // (find/search/ls) and an error card when the tool failed.
@@ -439,7 +439,7 @@ export class LaunchTui {
           this.appendLedger(`${paintedMark} ${target}${suffix}\n${children.map(c => `${c}\n`).join("")}`, "tool");
           if (!success) {
             this.rememberForge(result);
-            this.flushForgeCard(result);
+            this.flushForgeCard(result, false);
           }
         }
         this.draw();
@@ -511,15 +511,22 @@ export class LaunchTui {
   }
 
   private renderLiveUserQueryCard(cols: number): string[] {
-    const text = this.livePromptInput.trim();
+    return this.renderUserCard(this.livePromptInput, cols);
+  }
+
+  /** Render a `user`-labeled query card (orange "user" header over a filled box).
+   *  Shared by the live next-prompt draft and the mid-turn steering flush. */
+  private renderUserCard(rawText: string, cols: number): string[] {
+    const text = (rawText ?? "").trim();
     if (!text) return [];
     const boxWidth = Math.max(24, Math.min(120, cols));
     const inner = Math.max(10, boxWidth - 2);
     const g = this.unicode ? BOX_UNICODE : BOX_ASCII;
-    const accent = this.theme.color ? chalk.hex("#ff6b4a").bold : (s: string) => s;
-    const border = this.theme.color ? chalk.hex("#7f1d1d") : (s: string) => s;
-    const shadow = this.theme.color ? chalk.hex("#451a1a").dim : border;
-    const fill = this.theme.color ? (s: string) => chalk.bgHex("#210b10")(s) : (s: string) => s;
+    const uc = this.theme.userCard;
+    const accent = this.theme.color && uc ? chalk.hex(uc.accent).bold : (s: string) => s;
+    const border = this.theme.color && uc ? chalk.hex(uc.border) : (s: string) => s;
+    const shadow = this.theme.color && uc ? chalk.hex(uc.shadow) : border;
+    const fill = this.theme.color && uc ? (s: string) => chalk.bgHex(uc.fill)(s) : (s: string) => s;
     const body = text
       .split("\n")
       .flatMap(line => wrapTextWithAnsi(line, Math.max(8, inner - 2)))
@@ -537,6 +544,17 @@ 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 {
+    const t = (text ?? "").trim();
+    if (!t || this.finished) return;
+    const cols = Math.max(20, size().cols);
+    const lines = this.renderUserCard(t, cols);
+    if (lines.length) this.appendLedger(lines.join("\n"), "card");
+  }
+
   /** 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
@@ -925,15 +943,22 @@ export class LaunchTui {
   /** Flush a completed forge card into scrollback (inline mode) and retire it from the
    *  live array so the in-frame card region and the final summary never repeat it.
    *  Non-inline modes keep the card in `forgeSummaries` for the final static summary. */
-  private flushForgeCard(summary: ForgeSummary): void {
+  private flushForgeCard(summary: ForgeSummary, success?: boolean): void {
     if (!this.inline || this.finished) return;
     const width = Math.max(24, Math.min(120, size().cols));
+    // gjc D2 (state-encoded border): a FAILED card gets a red border so it pops
+    // out of scrollback at a glance; OK/neutral cards keep the theme accent
+    // identity. The ✓/✗ title mark already encodes state, but the border tone
+    // is what the eye catches first when scanning back through history.
+    const errored = success === false && this.theme.color;
+    const paint = errored ? (s: string) => chalk.red(s) : accentPaint(this.theme);
+    const paintShadow = errored ? (s: string) => chalk.dim(chalk.red(s)) : accentShadowPaint(this.theme);
     const lines = formatForgeBox(summary, {
       width,
       maxLines: 12,
       unicode: this.unicode,
-      paint: accentPaint(this.theme),
-      paintShadow: accentShadowPaint(this.theme),
+      paint,
+      paintShadow,
       diffPaint: diffPaint(this.theme),
       color: this.theme.color,
     });

package/src/tui/components/forge.ts

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { BOX_ASCII, BOX_UNICODE, padLineTo, type BoxGlyphs } from "./layout";
-import { stripAnsi, visibleWidth, animatedGradientText } from "./color";
-import { truncateToWidth } from "./width";
+import { visibleWidth, animatedGradientText } from "./color";
+import { truncateToWidth, wrapTextWithAnsi } from "./width";
 import { lightHighlightLine } from "./code-view";
 import { type UiCategory } from "./category-index";
 
@@ -421,12 +421,13 @@ export function summarizeForgeResult(tool: string, success: boolean, output: str
 }
 
 function wrapPlainLine(line: string, width: number): string[] {
-  const plain = stripAnsi(line);
   if (width <= 0) return [""];
+  // Wrap by DISPLAY width (SGR-aware, wide-glyph-aware) so CJK/emoji content
+  // breaks on column boundaries and never overflows the card border. The old
+  // `slice(i, i+width)` counted code points, so a Hangul/CJK line (2 cols each)
+  // rendered ~2× the intended width and tore the right edge.
   if (visibleWidth(line) <= width) return [line];
-  const out: string[] = [];
-  for (let i = 0; i < plain.length; i += width) out.push(plain.slice(i, i + width));
-  return out;
+  return wrapTextWithAnsi(line, width);
 }
 
 function borderGlyphs(unicode: boolean | undefined): BoxGlyphs {

package/src/tui/components/input-box.ts

@@ -115,7 +115,7 @@ export function renderInputFrame(line: string, opts: InputBoxOptions = {}): Inpu
   if (crow - hidden < 0) { visRow = 0; ccol = 0; }
 
   const promptMark = "> ";
-  const paintPrompt = useColor ? (opts.accent ?? chalk.red) : (s: string) => s;
+  const paintPrompt = useColor ? (opts.accent ?? chalk.blueBright) : (s: string) => s;
   const paintGhost = useColor ? chalk.dim : (s: string) => s;
   const body = rows.map((r, i) => {
     const content = placeholderRow ? paintGhost(r) : r;
@@ -123,11 +123,16 @@ export function renderInputFrame(line: string, opts: InputBoxOptions = {}): Inpu
   });
 
   const content = [...body];
+  // Label rows follow the active theme: the attachment hint uses the accent and
+  // the cwd label a dimmed accent (shadow), so the whole box reads in one tone
+  // instead of off-theme cyan/gray.
+  const labelAccent = useColor ? (opts.accent ?? chalk.cyan) : (s: string) => s;
+  const labelMuted = useColor ? (opts.accentShadow ?? chalk.gray) : (s: string) => s;
   if (opts.attachmentLabel) {
-    content.push(useColor ? chalk.cyan(opts.attachmentLabel) : opts.attachmentLabel);
+    content.push(labelAccent(opts.attachmentLabel));
   }
   if (opts.cwdLabel) {
-    content.push(useColor ? chalk.gray(opts.cwdLabel) : opts.cwdLabel);
+    content.push(labelMuted(opts.cwdLabel));
   }
   const glyphs = opts.unicode === false ? BOX_ASCII : BOX_UNICODE;
   // Depth cue: lit top/left edge (bright accent) vs shaded bottom/right edge (dim).

package/src/tui/components/themes.ts

@@ -32,6 +32,8 @@ export interface EvolutionTheme {
    *  `addBg`/`delBg` are full-row background tints that give added/removed
    *  lines block-level separation, not just a colored sign. */
   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 };
 }
 
 /** Default diff palette (used when a theme defines none): high-contrast
@@ -44,13 +46,14 @@ export const DEFAULT_DIFF_PALETTE = {
   hunk: "#7dcfff",
 } as const;
 
-const COSMIC: EvolutionTheme = {
+const COSMIC: EvolutionTheme = { 
   name: "cosmic",
   description: "Default — deep-space arc from cyan tide to white-hot singularity.",
   gradients: EVOLUTION_STAGE_GRADIENTS,
   color: true,
   accent: "#48dbfb",
   accentShadow: "#1b6f8c",
+  userCard: { accent: "#48dbfb", border: "#1b6f8c", shadow: "#0e3c4c", fill: "#081b24" },
 };
 
 const MATRIX: EvolutionTheme = {
@@ -67,6 +70,7 @@ const MATRIX: EvolutionTheme = {
   accent: "#39ff14",
   accentShadow: "#0b6623",
   diff: { add: "#7fff00", del: "#ff5f5f", addBg: "#0c2410", delBg: "#2a1212", hunk: "#00e5a0" },
+  userCard: { accent: "#39ff14", border: "#0b6623", shadow: "#053311", fill: "#031a08" },
 };
 
 const SOLAR: EvolutionTheme = {
@@ -82,6 +86,7 @@ const SOLAR: EvolutionTheme = {
   color: true,
   accent: "#ff8c00",
   accentShadow: "#8a4500",
+  userCard: { accent: "#ff8c00", border: "#8a4500", shadow: "#452200", fill: "#241100" },
 };
 
 const RED_CLAW: EvolutionTheme = {
@@ -97,6 +102,7 @@ const RED_CLAW: EvolutionTheme = {
   color: true,
   accent: "#e25656",
   accentShadow: "#5c0f0f",
+  userCard: { accent: "#e25656", border: "#5c0f0f", shadow: "#2e0707", fill: "#170303" },
 };
 
 const BLUE_CRAB: EvolutionTheme = {
@@ -113,6 +119,7 @@ const BLUE_CRAB: EvolutionTheme = {
   accent: "#0096c7",
   accentShadow: "#023e8a",
   diff: { add: "#06d6a0", del: "#ef476f", addBg: "#0a2922", delBg: "#2b1320", hunk: "#48cae4" },
+  userCard: { accent: "#0096c7", border: "#023e8a", shadow: "#011f45", fill: "#000f24" },
 };
 
 const AURORA: EvolutionTheme = {
@@ -129,6 +136,7 @@ const AURORA: EvolutionTheme = {
   accent: "#3ddad7",
   accentShadow: "#1d5c8f",
   diff: { add: "#16c79a", del: "#fd7c9b", addBg: "#0c2620", delBg: "#2a1626", hunk: "#7c83fd" },
+  userCard: { accent: "#3ddad7", border: "#1d5c8f", shadow: "#0e2e47", fill: "#071724" },
 };
 
 const SYNTHWAVE: EvolutionTheme = {
@@ -145,6 +153,7 @@ const SYNTHWAVE: EvolutionTheme = {
   accent: "#ec38bc",
   accentShadow: "#5b1a8a",
   diff: { add: "#03e9f4", del: "#ff5e99", addBg: "#0a2330", delBg: "#33122a", hunk: "#b388eb" },
+  userCard: { accent: "#ec38bc", border: "#5b1a8a", shadow: "#2d0d45", fill: "#160624" },
 };
 
 const SAKURA: EvolutionTheme = {
@@ -161,6 +170,7 @@ const SAKURA: EvolutionTheme = {
   accent: "#d6336c",
   accentShadow: "#862e59",
   diff: { add: "#37b24d", del: "#e03131", addBg: "#13260f", delBg: "#2b1212", hunk: "#cc5de8" },
+  userCard: { accent: "#d6336c", border: "#862e59", shadow: "#43172c", fill: "#210b16" },
 };
 
 const MONO: EvolutionTheme = {

package/src/tui/monitoring/hud-view.ts

@@ -1,12 +1,12 @@
 import chalk from "chalk";
 import { renderHud, type JeoPhase } from "../components/hud";
-import { 
-  evolutionTrack, 
-  stageIndexForStep, 
+import { padLineTo } from "../components/layout";
+import { visibleWidth, truncateToWidth } from "../components/width";
+import {
+  evolutionTrack,
+  stageIndexForStep,
   getEvolutionStatusMessage,
-  stageProgressRatio,
   meterGlyphsFor,
-  EVOLUTION_STAGE_COLORS
 } from "../components/evolution";
 
 export interface MonitorState {
@@ -17,39 +17,62 @@ export interface MonitorState {
   analysisReport?: string;
 }
 
+/**
+ * The `ooo ralph` sovereign monitoring HUD. Every row is padded by DISPLAY width
+ * (ANSI escapes count 0, wide glyphs count 2) and the box auto-sizes to its widest
+ * row, so the heavy border stays flush regardless of color/unicode content. The
+ * old version padded ANSI-colored strings with `String.padEnd`, which counted the
+ * SGR escape bytes and tore the right edge whenever color was on.
+ */
 export function renderMonitorView(state: MonitorState): string {
   const unicode = true;
   const stage = stageIndexForStep(state.step, state.maxSteps);
+  const ratio = Math.max(0, Math.min(1, state.maxSteps > 0 ? state.step / state.maxSteps : 0));
+
   const hud = renderHud(state.phase, { unicode, color: true });
-  const evo = evolutionTrack(stage, { color: true, unicode, ratio: state.step / state.maxSteps });
+  const evo = evolutionTrack(stage, { color: true, unicode, ratio });
   const statusMsg = getEvolutionStatusMessage(state.step, state.maxSteps, state.tickCount);
-  
-  // Progress Bar / Meter
-  const ratio = Math.max(0, Math.min(1, state.step / state.maxSteps));
+
+  // Progress meter.
   const barWidth = 30;
   const filledWidth = Math.round(ratio * barWidth);
   const glyphs = meterGlyphsFor(stage, unicode);
   const bar = glyphs.color(glyphs.fill.repeat(filledWidth)) + chalk.dim(glyphs.empty.repeat(barWidth - filledWidth));
-  const percentage = (ratio * 100).toFixed(1) + "%";
-
-  let output = "";
-  output += chalk.bold.cyan("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓") + "\n";
-  output += chalk.bold.cyan("┃") + " " + chalk.bold.yellow("ooo ralph") + chalk.bold(" Sovereign Monitoring HUD") + " ".repeat(25) + chalk.bold.cyan("┃") + "\n";
-  output += chalk.bold.cyan("┠──────────────────────────────────────────────────────────────┨") + "\n";
-  output += chalk.bold.cyan("┃") + " " + chalk.bold("PHASE:") + " " + hud.padEnd(50) + " ".repeat(4) + chalk.bold.cyan("┃") + "\n";
-  output += chalk.bold.cyan("┃") + " " + chalk.bold("EVO  :") + " " + evo.padEnd(50) + " ".repeat(4) + chalk.bold.cyan("┃") + "\n";
-  output += chalk.bold.cyan("┃") + " " + chalk.bold("PROG :") + " " + bar.padEnd(50) + " " + chalk.bold(percentage).padStart(6) + chalk.bold.cyan("┃") + "\n";
-  output += chalk.bold.cyan("┠──────────────────────────────────────────────────────────────┨") + "\n";
-  output += chalk.bold.cyan("┃") + " " + chalk.italic.dim("> " + statusMsg).padEnd(60) + " " + chalk.bold.cyan("┃") + "\n";
-  
-  if (state.analysisReport) {
-    output += chalk.bold.cyan("┠──────────────────────────────────────────────────────────────┨") + "\n";
-    const lines = state.analysisReport.split("\n").slice(0, 5);
-    for (const line of lines) {
-      output += chalk.bold.cyan("┃") + " " + chalk.yellow(line.substring(0, 58).padEnd(58)) + " " + chalk.bold.cyan("┃") + "\n";
-    }
+  const percentage = chalk.bold((ratio * 100).toFixed(1) + "%");
+
+  const label = (s: string) => chalk.bold(s);
+  const title = `${chalk.bold.yellow("ooo ralph")}${chalk.bold(" Sovereign Monitoring HUD")}`;
+  const phaseRow = `${label("PHASE:")} ${hud}`;
+  const evoRow = `${label("EVO  :")} ${evo}`;
+  const progLeft = `${label("PROG :")} ${bar}`;
+  const statusRow = chalk.italic.dim(`> ${statusMsg}`);
+  const analysisRows = state.analysisReport
+    ? state.analysisReport.split("\n").slice(0, 5).map(l => chalk.yellow(l))
+    : [];
+
+  // Size the inner content area to the widest row (clamped), then right-align the
+  // progress percentage within that width.
+  const MIN_INNER = 40;
+  const MAX_INNER = 88;
+  const measured = [title, phaseRow, evoRow, progLeft, statusRow, ...analysisRows].map(visibleWidth);
+  const progMin = visibleWidth(progLeft) + 1 + visibleWidth(percentage);
+  const inner = Math.min(MAX_INNER, Math.max(MIN_INNER, progMin, ...measured));
+
+  const progGap = Math.max(1, inner - visibleWidth(progLeft) - visibleWidth(percentage));
+  const progRow = `${progLeft}${" ".repeat(progGap)}${percentage}`;
+
+  const paint = chalk.bold.cyan;
+  const top = paint("┏" + "━".repeat(inner + 2) + "┓");
+  const sep = paint("┠" + "─".repeat(inner + 2) + "┨");
+  const bottom = paint("┗" + "━".repeat(inner + 2) + "┛");
+  const v = paint("┃");
+  const row = (content: string) => `${v} ${padLineTo(truncateToWidth(content, inner), inner, "left")} ${v}`;
+
+  const out: string[] = [top, row(title), sep, row(phaseRow), row(evoRow), row(progRow), sep, row(statusRow)];
+  if (analysisRows.length > 0) {
+    out.push(sep);
+    for (const line of analysisRows) out.push(row(line));
   }
-  output += chalk.bold.cyan("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛") + "\n";
-  
-  return output;
+  out.push(bottom);
+  return out.join("\n") + "\n";
 }