jeo-code 0.6.18 → 0.6.20

package/CHANGELOG.md

@@ -6,6 +6,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.6.20] - 2026-06-18
+_Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage._
+
+### Changed
+- **`mentionPaths` / `currentAtLabel` extracted to `src/commands/launch/mentions.ts`.** The `@path` filesystem completion and footer label logic are now pure, `cwd`-parametric functions that can be unit-tested in isolation; `launch.ts` delegates to them via thin wrappers.
+- **Slash-command view renderers extracted to `src/commands/launch/slash-views.ts`.** `hotkeysLines` and `contextUsageLines` are now pure functions (no I/O, no hidden state) returning `string[]`; verified with snapshot-style unit tests.
+- **Slash-command handlers extracted to `src/commands/launch/slash-handlers.ts`.** `/usage`, `/tools`, `/hotkeys`, `/context` handlers are isolated behind a `SlashContext` interface, each returning a typed result — testable without spinning up the full REPL.
+
+### Added
+- **Unit tests for all extracted modules** (`test/launch-mentions.test.ts`, `test/launch-slash-views.test.ts`, `test/slash-handlers.test.ts`): 13 new tests, 79 assertions — mentionPaths directory traversal, case-insensitive filtering, unreadable-dir guard, currentAtLabel edge cases, context token tallies, singular/plural spacing, handler outputs.
+
+## [0.6.19] - 2026-06-18
+
+_Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint._
+
+### Changed
+- **Post-turn hooks execute ONCE per multi-call batch instead of once per result.** A project-wide checker hook (`tsc --noEmit`/lint/test) whose `match.tool` matched every edit in a batch previously re-ran N times sequentially — the dominant in-loop latency multiplier on multi-edit turns. `runPostTurnHooksForBatch` now groups the batch's calls, invokes each matching hook a single time, and runs distinct hooks concurrently. A hook matching several calls receives a back-compatible payload (`{event,tool,args,success,output}` plus a `calls[]` array of every matched call) so a payload-aware per-file hook can still iterate the changed files in one invocation; a single match keeps the exact legacy shape. The single-call `runPostTurnHooks` is retained as a thin wrapper for direct callers/tests.
+- **Tool-result bodies are formatted in parallel.** The per-result loop that serialized body formatting (and any oversized-body spill to a disk artifact) is replaced by a `Promise.all` over the batch, so independent formatting/disk writes overlap.
+
+### Performance
+- **Local `.jeo/hooks.json` is mtime/size-cached.** The per-project hook override was re-read and re-parsed (`fs.readFile` + `JSON.parse`) on every `loadHooks` call — once per pre-tool check and once per post-turn batch. It is now cached keyed by absolute path → mtime/size (bounded LRU, cap 32) and only re-read when the file actually changes, so any external write is still picked up immediately without a stale serve.
+
+### Fixed
+- **Wrapped colored text keeps its color on every continuation row.** `wrapTextWithAnsi` is now SGR-stateful: a color opened before a wrap point is re-applied at the start of each continuation line and closed at its end, so a wrapped colored span stays tinted on every row (the reported "color breaks when the line wraps") instead of losing its tint after the first line — and never bleeds into the padding or box border. Plain uncolored text is left byte-for-byte unchanged.
+
+
 ## [0.6.18] - 2026-06-17
 _Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior._
 

package/README.ja.md

@@ -200,11 +200,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
-- **[0.6.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
-- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -200,11 +200,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
-- **[0.6.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
-- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -200,11 +200,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
-- **[0.6.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
-- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -200,11 +200,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
+- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 - **[0.6.18]** (2026-06-17) — Memory data-flow diagram and a README "Memory flow" section documenting the actual runtime behavior.
 - **[0.6.17]** (2026-06-17) — Legacy MEMORY.md migrates losslessly into the OKF concept bundle, with a one-shot command and a rollback toggle.
 - **[0.6.16]** (2026-06-17) — OKF memory grows a concept cross-link graph: 1-hop search expansion, bundle lint, graphify-optional.
-- **[0.6.15]** (2026-06-17) — Query-aware OKF memory injection with budget-priority selection, and a truthful end-of-turn Todos receipt.
-- **[0.6.14]** (2026-06-16) — Memory distillation survives malformed model output, and stream-idle stalls retry instead of failing the turn.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/engine.ts

@@ -16,7 +16,7 @@ import { readTool, writeTool, editTool, bashTool, findTool, searchTool, lsTool,
 import { webSearchTool, setWebSearchActiveModel } from "./web-search";
 import { friendlyProviderError, isContextOverflowError, isRefusalError } from "../util/provider-error";
 import { isRateLimitError } from "../util/retry";
-import { runPreToolHooks, runPostTurnHooks } from "./hooks";
+import { runPreToolHooks, runPostTurnHooksForBatch } from "./hooks";
 import { truncateToolOutput, formatToolResultBody } from "./tool-output";
 export { TOOL_OUTPUT_MAX, READ_OUTPUT_MAX, TOOL_SPILL_THRESHOLD, MAX_TOOL_ARTIFACTS, truncateToolOutput, spillToolResult } from "./tool-output";
 import { StepBudget, dynamicStepBudgetConfig, resolveStepBudgetConfig, hashSignature, type StepBudgetConfig } from "./step-budget";
@@ -903,46 +903,53 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     }
 
     const processAndPushResults = async (indices: number[]) => {
-      const resultBlocks: string[] = [];
-      // Per-batch dedup of post-turn hook diagnostics: a whole-project `tsc` hook
-      // matching every edit in a batch yields identical output N times — show it
-      // once, cross-reference the rest (cycle 13).
-      const seenHookFeedback = new Set<string>();
+      // Surface completion to the TUI ledger in call order.
       for (const idx of indices) {
-        const call = toolCalls[idx];
-        const res = results[idx];
-
-        ev.onToolResult?.(call.tool, res.success, res.output);
-
-        const resultBody = await formatToolResultBody(call.tool, res.output, cwd);
-
-        const { diags: hookDiags, ran: hooksRan } = await runPostTurnHooks(
-          cwd,
-          call.tool,
-          call.arguments ?? {},
-          res.success,
-          res.output,
-          opts.signal,
-          ev.onNotice
-        );
-        // F1: a red hook becomes a pending failure the done guard enforces; a
-        // later hook run that completes CLEAN (ran > 0, zero diags) clears it.
-        if (hookDiags.length > 0) pendingHookFailure = hookDiags[hookDiags.length - 1].run;
-        else if (hooksRan > 0) pendingHookFailure = null;
+        ev.onToolResult?.(toolCalls[idx].tool, results[idx].success, results[idx].output);
+      }
+      // Format every result body in PARALLEL — independent work, and an oversized
+      // body may spill to a disk artifact; the previous per-result loop serialized
+      // both the formatting and the disk writes.
+      const bodies = await Promise.all(
+        indices.map(idx => formatToolResultBody(toolCalls[idx].tool, results[idx].output, cwd)),
+      );
+      // Run post-turn hooks ONCE for the whole batch instead of once per result: a
+      // project-wide `tsc`/lint/test hook matching every edit in the batch no longer
+      // re-executes N times sequentially (the dominant in-loop latency multiplier).
+      const { diags: hookDiags, ran: hooksRan } = await runPostTurnHooksForBatch(
+        cwd,
+        indices.map(idx => ({
+          tool: toolCalls[idx].tool,
+          args: toolCalls[idx].arguments ?? {},
+          success: results[idx].success,
+          output: results[idx].output,
+        })),
+        opts.signal,
+        ev.onNotice,
+      );
+      // F1: a red hook becomes a pending failure the done guard enforces; a later
+      // batch whose hooks complete CLEAN (ran > 0, zero diags) clears it.
+      if (hookDiags.length > 0) pendingHookFailure = hookDiags[hookDiags.length - 1].run;
+      else if (hooksRan > 0) pendingHookFailure = null;
 
-        // Append non-zero-exit hook diagnostics to THIS tool's result block so the
-        // model can self-correct. The tool's own ok/fail is unchanged (guard).
-        let resultBlock = `Tool [${call.tool}] result (${res.success ? "ok" : "fail"}):\n${resultBody}`;
+      const resultBlocks: string[] = indices.map((idx, i) =>
+        `Tool [${toolCalls[idx].tool}] result (${results[idx].success ? "ok" : "fail"}):\n${bodies[i]}`,
+      );
+      // Append the batch's hook diagnostics once so the model can self-correct. Two
+      // DISTINCT hooks with identical output collapse to one full block + a cross-ref.
+      if (hookDiags.length > 0) {
+        const seenHookFeedback = new Set<string>();
+        const diagLines: string[] = [];
         for (const d of hookDiags) {
           const key = `${d.run}\u0000${d.output}`;
           if (seenHookFeedback.has(key)) {
-            resultBlock += `\n[post-turn hook "${d.run}" — exit ${d.exitCode}: same diagnostics as above]`;
+            diagLines.push(`[post-turn hook "${d.run}" — exit ${d.exitCode}: same diagnostics as above]`);
           } else {
             seenHookFeedback.add(key);
-            resultBlock += `\n[post-turn hook "${d.run}" — exit ${d.exitCode}]:\n${truncateToolOutput(d.output)}`;
+            diagLines.push(`[post-turn hook "${d.run}" — exit ${d.exitCode}]:\n${truncateToolOutput(d.output)}`);
           }
         }
-        resultBlocks.push(resultBlock);
+        resultBlocks.push(diagLines.join("\n"));
       }
 
       history.push({ role: "assistant", content: responseText });

package/src/agent/hooks.ts

@@ -22,27 +22,56 @@ export interface PostTurnHookDiag {
   output: string;
 }
 
+// Local `.jeo/hooks.json` read cache, keyed by absolute path → mtime/size. The
+// global config is already mtime-cached in state.ts, but the per-project local
+// override was re-read (fs.readFile + JSON.parse) on every loadHooks call — once
+// per pre-tool hook check and once per post-turn batch. Cache the parsed outcome
+// and re-read only when the file's mtime/size changes (any external write bumps
+// both, so a stale entry is never served).
+type LocalHooks =
+  | { kind: "disabled" }
+  | { kind: "hooks"; hooks: NonNullable<HookConfig["hooks"]> }
+  | { kind: "fallback" };
+const localHooksCache = new Map<string, { mtimeMs: number; size: number; result: LocalHooks }>();
+const LOCAL_HOOKS_CACHE_CAP = 32;
+
+async function readLocalHooks(localPath: string): Promise<LocalHooks> {
+  let st: { mtimeMs: number; size: number };
+  try {
+    st = await fs.stat(localPath);
+  } catch {
+    localHooksCache.delete(localPath);
+    return { kind: "fallback" };
+  }
+  const hit = localHooksCache.get(localPath);
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.result;
+  let result: LocalHooks = { kind: "fallback" };
+  try {
+    const parsed = JSON.parse(await fs.readFile(localPath, "utf-8"));
+    if (parsed && typeof parsed === "object") {
+      if (parsed.enabled === false) result = { kind: "disabled" };
+      else if (Array.isArray(parsed.hooks)) result = { kind: "hooks", hooks: parsed.hooks };
+    }
+  } catch {
+    // Missing/invalid local file → fall back to the global config hooks.
+  }
+  if (localHooksCache.size >= LOCAL_HOOKS_CACHE_CAP && !localHooksCache.has(localPath)) {
+    const oldest = localHooksCache.keys().next().value;
+    if (oldest !== undefined) localHooksCache.delete(oldest);
+  }
+  localHooksCache.set(localPath, { mtimeMs: st.mtimeMs, size: st.size, result });
+  return result;
+}
+
 export async function loadHooks(cwd: string): Promise<NonNullable<HookConfig["hooks"]>> {
   const config = await readGlobalConfig();
   if (!config.hooks?.enabled) {
     return [];
   }
 
-  const localPath = path.join(cwd, ".jeo", "hooks.json");
-  try {
-    const content = await fs.readFile(localPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed && typeof parsed === "object") {
-      if (parsed.enabled === false) {
-        return [];
-      }
-      if (Array.isArray(parsed.hooks)) {
-        return parsed.hooks;
-      }
-    }
-  } catch (e) {
-    // If local file is missing or invalid, fall back to global
-  }
+  const local = await readLocalHooks(path.join(cwd, ".jeo", "hooks.json"));
+  if (local.kind === "disabled") return [];
+  if (local.kind === "hooks") return local.hooks;
 
   return config.hooks?.hooks || [];
 }
@@ -180,12 +209,32 @@ export async function runPreToolHooks(
   return { vetoed: false };
 }
 
-export async function runPostTurnHooks(
+/** One executed tool call fed to the post-turn hooks of a batch. */
+export interface PostTurnCall {
+  tool: string;
+  args: Record<string, any>;
+  success: boolean;
+  output: string;
+}
+
+function outputPreviewOf(output: string): string {
+  return output.length > 10000 ? output.slice(0, 10000) + "\n... (truncated)" : output;
+}
+
+/**
+ * Run post-turn hooks for a whole batch of executed tool calls, invoking each
+ * matching hook EXACTLY ONCE — not once per result. A project-wide checker
+ * (`tsc --noEmit`/lint/test) that matches every edit in a batch previously ran N
+ * times sequentially; now it runs a single time. Distinct hooks run concurrently.
+ *
+ * Payload back-compat: a hook that matches a single call gets the legacy
+ * `{event,tool,args,success,output}` shape; a hook matching several gets the same
+ * fields plus a `calls[]` array (every matched call) so a payload-aware per-file
+ * hook can still iterate the changed files in one invocation.
+ */
+export async function runPostTurnHooksForBatch(
   cwd: string,
-  tool: string,
-  args: Record<string, any>,
-  success: boolean,
-  output: string,
+  calls: readonly PostTurnCall[],
   signal?: AbortSignal,
   onNotice?: (msg: string) => void
 ): Promise<{ diags: PostTurnHookDiag[]; ran: number }> {
@@ -195,23 +244,29 @@ export async function runPostTurnHooks(
   let ran = 0;
   try {
     const hooks = await loadHooks(cwd);
-    const postTurnHooks = hooks.filter(
-      h => h.event === "post-turn" && hookMatchesTool(h.match?.tool, tool)
-    );
-
-    const outputPreview = output.length > 10000 ? output.slice(0, 10000) + "\n... (truncated)" : output;
-
-    for (const hook of postTurnHooks) {
-      const payload = {
-        event: "post-turn",
-        tool,
-        args,
-        success,
-        output: outputPreview,
-      };
+    const jobs = hooks
+      .filter(h => h.event === "post-turn")
+      .map(hook => ({ hook, matched: calls.filter(c => hookMatchesTool(hook.match?.tool, c.tool)) }))
+      .filter(j => j.matched.length > 0);
 
+    // Distinct hooks are independent commands → run them concurrently. Each hook
+    // itself runs once for the whole batch (the redundancy this fix removes).
+    const settled = await Promise.all(jobs.map(async ({ hook, matched }) => {
+      const payload = matched.length === 1
+        ? { event: "post-turn", tool: matched[0].tool, args: matched[0].args, success: matched[0].success, output: outputPreviewOf(matched[0].output) }
+        : {
+            event: "post-turn",
+            tool: matched.map(c => c.tool).join(","),
+            calls: matched.map(c => ({ tool: c.tool, args: c.args, success: c.success })),
+            success: matched.every(c => c.success),
+            output: outputPreviewOf(matched.map(c => c.output).join("\n")),
+          };
       const timeoutMs = hook.timeoutMs || 30000;
       const result = await runHookCommand(hook.run, payload, cwd, timeoutMs, signal);
+      return { hook, result };
+    }));
+
+    for (const { hook, result } of settled) {
       if (result.timedOut) {
         onNotice?.(`Post-turn hook "${hook.run}" timed out (advisory).`);
       } else if (result.aborted) {
@@ -235,6 +290,20 @@ export async function runPostTurnHooks(
   return { diags, ran };
 }
 
+/** Single-call convenience wrapper (kept for direct callers/tests). Delegates to
+ *  the batch runner with one call, preserving the legacy payload shape. */
+export async function runPostTurnHooks(
+  cwd: string,
+  tool: string,
+  args: Record<string, any>,
+  success: boolean,
+  output: string,
+  signal?: AbortSignal,
+  onNotice?: (msg: string) => void
+): Promise<{ diags: PostTurnHookDiag[]; ran: number }> {
+  return runPostTurnHooksForBatch(cwd, [{ tool, args, success, output }], signal, onNotice);
+}
+
 export async function runPostImplementationHooks(
   cwd: string,
   request: string,

package/src/commands/launch/mentions.ts

@@ -0,0 +1,48 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { tokenize } from "../../tui/components/autocomplete";
+
+/** Filesystem completion for an `@path` mention prefix, relative to `cwd`.
+ *  Lists the directory the prefix points at, filtering by the basename fragment,
+ *  directories first, hidden entries dropped, capped at 50 — directories keep a
+ *  trailing `/` so the next Tab descends. Pure given `cwd`: never throws (an
+ *  unreadable directory yields no matches). Extracted verbatim from the launch
+ *  REPL so it can be unit-tested in isolation. */
+export function mentionPaths(cwd: string, prefix: string): string[] {
+  const norm = prefix.replace(/\\/g, "/");
+  const wantsDirChildren = norm.endsWith("/");
+  const dirPart = wantsDirChildren ? norm.slice(0, -1) : path.posix.dirname(norm) === "." ? "" : path.posix.dirname(norm);
+  const namePart = wantsDirChildren ? "" : path.posix.basename(norm);
+  const absDir = path.resolve(cwd, dirPart || ".");
+  let entries: fs.Dirent[] = [];
+  try {
+    entries = fs.readdirSync(absDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter(entry => !entry.name.startsWith("."))
+    .filter(entry => !namePart || entry.name.toLowerCase().startsWith(namePart.toLowerCase()))
+    .sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    })
+    .slice(0, 50)
+    .map(entry => {
+      const rel = dirPart ? `${dirPart}/${entry.name}` : entry.name;
+      return entry.isDirectory() ? `${rel}/` : rel;
+    });
+}
+
+/** The `@ <dir>` label shown in the boxed-input footer for the last `@mention`
+ *  token on the current line, or undefined when the line has no mention. Pure. */
+export function currentAtLabel(line: string): string | undefined {
+  const { tokens } = tokenize(line);
+  const token = [...tokens].reverse().find(t => t.startsWith("@"));
+  if (!token) return undefined;
+  const norm = token.slice(1).replace(/\\/g, "/");
+  if (!norm) return "@ .";
+  if (norm.endsWith("/")) return `@ ${norm.slice(0, -1) || "."}`;
+  const dir = path.posix.dirname(norm);
+  return `@ ${dir === "." ? norm : dir}`;
+}

package/src/commands/launch/slash-handlers.ts

@@ -0,0 +1,62 @@
+/**
+ * Slash command handlers extracted from launch.ts.
+ * Each handler is a pure function taking context and returning a result.
+ */
+
+import type { Message } from "../../agent/loop";
+import type { Config } from "../../agent/state";
+import { TOOL_PROTOCOL } from "../../agent/engine";
+import { taskToolProtocolLine } from "../../agent/task-tool";
+import { TODO_TOOL_PROTOCOL_LINE } from "../../agent/todo-tool";
+import { SUBAGENT_TOOL_PROTOCOL_LINE } from "../../agent/subagent-tool";
+import { hotkeysLines, contextUsageLines } from "./slash-views";
+import { describeModel, catalogMetadata } from "../../ai";
+import { readGlobalConfig } from "../../agent/state";
+
+/** Shared context passed to all slash handlers. */
+export interface SlashContext {
+  history: Message[];
+  sessionModel?: string;
+  sessionId?: string;
+  cwd: string;
+  config: Config;
+}
+
+/** Handler result: lines to print, or undefined if handler didn't match. */
+export type SlashResult = { lines: string[] } | { action: "exit" | "continue" } | undefined;
+
+/** Handles /usage command. */
+export function handleUsage(ctx: SlashContext, sessionUsage: { turns: number; inputTokens: number; outputTokens: number }): SlashResult {
+  const total = sessionUsage.inputTokens + sessionUsage.outputTokens;
+  return {
+    lines: [
+      "Provider token usage (this REPL):",
+      `  turns   ${sessionUsage.turns}`,
+      `  input   ${sessionUsage.inputTokens}`,
+      `  output  ${sessionUsage.outputTokens}`,
+      `  total   ${total}${total === 0 ? "  (providers report usage per turn; run a request first)" : ""}`,
+    ],
+  };
+}
+
+/** Handles /tools command. */
+export async function handleTools(ctx: SlashContext): Promise<SlashResult> {
+  const lines = ["Tools visible to the agent:"];
+  for (const line of TOOL_PROTOCOL.split("\n")) lines.push(`  ${line}`);
+  lines.push(`  ${taskToolProtocolLine(await readGlobalConfig())}`);
+  lines.push(`  ${TODO_TOOL_PROTOCOL_LINE}`);
+  lines.push(`  ${SUBAGENT_TOOL_PROTOCOL_LINE}`);
+  return { lines };
+}
+
+/** Handles /hotkeys command. */
+export function handleHotkeys(_ctx: SlashContext): SlashResult {
+  return { lines: hotkeysLines() };
+}
+
+/** Handles /context command. */
+export async function handleContext(ctx: SlashContext): Promise<SlashResult> {
+  const { resolved } = await describeModel(ctx.sessionModel || ctx.config.defaultModel);
+  const window = catalogMetadata(resolved)?.contextTokens;
+  return { lines: contextUsageLines(ctx.history, resolved, window) };
+}

package/src/commands/launch/slash-views.ts

@@ -0,0 +1,48 @@
+// Pure presenters for read-only REPL slash commands. These build the exact
+// line arrays the inline handlers used to `console.log` directly, extracted so
+// they can be unit-tested without driving the whole launch REPL. They hold NO
+// mutable session state — every input is passed in explicitly.
+import type { Message } from "../../agent/loop";
+
+/** Static keyboard-shortcut reference for `/hotkeys` (no inputs, no state). */
+export function hotkeysLines(): string[] {
+  return [
+    "Keyboard shortcuts:",
+    "  Tab        complete slash commands, models, roles, @paths",
+    "  ↑ / ↓      navigate the slash-command preview (Enter runs the highlighted one)",
+    "  Enter      submit input / confirm picker selection",
+    "  Esc        cancel an open picker",
+    "  Ctrl-C     cancel the in-flight turn (press again at the prompt to exit)",
+    "  Ctrl-D     exit the REPL",
+    "  Ctrl-O     dump the full last response (untruncated, tables rendered) into scrollback",
+    "  Ctrl-K / Ctrl-U / Ctrl-W   kill to end / start of line / previous word (emacs kill-ring)",
+    "  Ctrl-Y / Alt-Y             yank / yank-pop the killed text",
+    "  Ctrl-A / Ctrl-E            move to start / end of line",
+    "  /          open the slash-command palette",
+    "  @path      mention a file (Tab completes relative paths)",
+  ];
+}
+
+/** Per-role token tallies for `/context`, estimated at ~4 chars/token. Pure over
+ *  the in-memory history so the math is verifiable in isolation. */
+export function contextUsageLines(
+  history: Message[],
+  resolved: string,
+  window: number | undefined,
+): string[] {
+  const est = (s: string) => Math.ceil(s.length / 4);
+  const byRole: Record<string, { msgs: number; tokens: number }> = {};
+  for (const m of history) {
+    const slot = (byRole[m.role] ??= { msgs: 0, tokens: 0 });
+    slot.msgs++;
+    slot.tokens += est(m.content);
+  }
+  const total = Object.values(byRole).reduce((sum, r) => sum + r.tokens, 0);
+  const lines = ["Context usage (estimated, ~4 chars/token):"];
+  for (const [role, r] of Object.entries(byRole)) {
+    lines.push(`  ${role.padEnd(9)} ${String(r.msgs).padStart(3)} msg${r.msgs === 1 ? " " : "s"}  ~${r.tokens} tokens`);
+  }
+  lines.push(`  ${"total".padEnd(9)} ${String(history.length).padStart(3)} msgs  ~${total} tokens${window ? `  (${Math.round((total / window) * 100)}% of ${resolved}'s ${window}-token window)` : ""}`);
+  lines.push("  Free context with /compact or /clear.");
+  return lines;
+}

package/src/commands/launch.ts

@@ -147,6 +147,21 @@ import {
   isWorkflowSkill,
   runWorkflowEngine,
 } from "./launch/workflow";
+import {
+  mentionPaths as mentionPathsIn,
+  currentAtLabel as currentAtLabelFn,
+} from "./launch/mentions";
+import {
+  hotkeysLines,
+  contextUsageLines,
+} from "./launch/slash-views";
+import {
+  handleUsage,
+  handleTools,
+  handleHotkeys,
+  handleContext,
+  type SlashContext,
+} from "./launch/slash-handlers";
 
 export {
   type LaunchFlags,
@@ -192,6 +207,8 @@ export {
   WORKFLOW_NAMES,
   isWorkflowSkill,
   runWorkflowEngine,
+  mentionPathsIn as mentionPaths,
+  currentAtLabelFn as currentAtLabel,
 };
 export function normalizeSlashAlias(input: string): string {
   if (input === "/login" || input.startsWith("/login ")) return `/provider login${input.slice("/login".length)}`;
@@ -1158,31 +1175,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       liveModelsCache ??= r;
     })
     .catch(() => {});
-  const mentionPaths = (prefix: string): string[] => {
-    const norm = prefix.replace(/\\/g, "/");
-    const wantsDirChildren = norm.endsWith("/");
-    const dirPart = wantsDirChildren ? norm.slice(0, -1) : path.posix.dirname(norm) === "." ? "" : path.posix.dirname(norm);
-    const namePart = wantsDirChildren ? "" : path.posix.basename(norm);
-    const absDir = path.resolve(cwd, dirPart || ".");
-    let entries: fs.Dirent[] = [];
-    try {
-      entries = fs.readdirSync(absDir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    return entries
-      .filter(entry => !entry.name.startsWith("."))
-      .filter(entry => !namePart || entry.name.toLowerCase().startsWith(namePart.toLowerCase()))
-      .sort((a, b) => {
-        if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
-        return a.name.localeCompare(b.name);
-      })
-      .slice(0, 50)
-      .map(entry => {
-        const rel = dirPart ? `${dirPart}/${entry.name}` : entry.name;
-        return entry.isDirectory() ? `${rel}/` : rel;
-      });
-  };
+  const mentionPaths = (prefix: string): string[] => mentionPathsIn(cwd, prefix);
   const completionContext = (): CompletionContext => {
     const base = staticCompletionContext();
     return {
@@ -1512,16 +1505,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // turns/command output so the full-screen turn TUI renders normally. The footer
   // is drawn at absolute rows (per-row clear → no scroll, no duplication).
   // Opt out with JEO_NO_SLASH_PREVIEW=1; auto-off on short terminals.
-  const currentAtLabel = (line: string): string | undefined => {
-    const { tokens } = tokenize(line);
-    const token = [...tokens].reverse().find(t => t.startsWith("@"));
-    if (!token) return undefined;
-    const norm = token.slice(1).replace(/\\/g, "/");
-    if (!norm) return "@ .";
-    if (norm.endsWith("/")) return `@ ${norm.slice(0, -1) || "."}`;
-    const dir = path.posix.dirname(norm);
-    return `@ ${dir === "." ? norm : dir}`;
-  };
+  const currentAtLabel = (line: string): string | undefined => currentAtLabelFn(line);
   // Boxed-input footer height — ADAPTIVE so short terminals/panes still get the single
   // boxed input instead of silently falling back to the raw `jeo>` prompt (previously
   // any terminal under 17 rows lost the box entirely and showed bare CLI input).
@@ -2893,56 +2877,31 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
       // ---- gjc-parity inspection commands ------------------------------------
       if (input === "/usage") {
-        const total = sessionUsage.inputTokens + sessionUsage.outputTokens;
-        console.log("Provider token usage (this REPL):");
-        console.log(`  turns   ${sessionUsage.turns}`);
-        console.log(`  input   ${sessionUsage.inputTokens}`);
-        console.log(`  output  ${sessionUsage.outputTokens}`);
-        console.log(`  total   ${total}${total === 0 ? "  (providers report usage per turn; run a request first)" : ""}`);
+        const cfg = await readGlobalConfig();
+        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+        const result = handleUsage(ctx, sessionUsage);
+        if (result && "lines" in result) for (const line of result.lines) console.log(line);
         continue;
       }
       if (input === "/context") {
-        // Token estimate (~4 chars/token) over the in-memory history, by role.
-        const est = (s: string) => Math.ceil(s.length / 4);
-        const byRole: Record<string, { msgs: number; tokens: number }> = {};
-        for (const m of history) {
-          const slot = (byRole[m.role] ??= { msgs: 0, tokens: 0 });
-          slot.msgs++;
-          slot.tokens += est(m.content);
-        }
-        const total = Object.values(byRole).reduce((sum, r) => sum + r.tokens, 0);
-        const { resolved } = await describeModel(sessionModel || (await readGlobalConfig()).defaultModel);
-        const window = catalogMetadata(resolved)?.contextTokens;
-        console.log("Context usage (estimated, ~4 chars/token):");
-        for (const [role, r] of Object.entries(byRole)) {
-          console.log(`  ${role.padEnd(9)} ${String(r.msgs).padStart(3)} msg${r.msgs === 1 ? " " : "s"}  ~${r.tokens} tokens`);
-        }
-        console.log(`  ${"total".padEnd(9)} ${String(history.length).padStart(3)} msgs  ~${total} tokens${window ? `  (${Math.round((total / window) * 100)}% of ${resolved}'s ${window}-token window)` : ""}`);
-        console.log("  Free context with /compact or /clear.");
+        const cfg = await readGlobalConfig();
+        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+        const result = await handleContext(ctx);
+        if (result && "lines" in result) for (const line of result.lines) console.log(line);
         continue;
       }
       if (input === "/tools") {
-        console.log("Tools visible to the agent:");
-        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}`);
+        const cfg = await readGlobalConfig();
+        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+        const result = await handleTools(ctx);
+        if (result && "lines" in result) for (const line of result.lines) console.log(line);
         continue;
       }
       if (input === "/hotkeys") {
-        console.log("Keyboard shortcuts:");
-        console.log("  Tab        complete slash commands, models, roles, @paths");
-        console.log("  ↑ / ↓      navigate the slash-command preview (Enter runs the highlighted one)");
-        console.log("  Enter      submit input / confirm picker selection");
-        console.log("  Esc        cancel an open picker");
-        console.log("  Ctrl-C     cancel the in-flight turn (press again at the prompt to exit)");
-        console.log("  Ctrl-D     exit the REPL");
-        console.log("  Ctrl-O     dump the full last response (untruncated, tables rendered) into scrollback");
-        console.log("  Ctrl-K / Ctrl-U / Ctrl-W   kill to end / start of line / previous word (emacs kill-ring)");
-        console.log("  Ctrl-Y / Alt-Y             yank / yank-pop the killed text");
-        console.log("  Ctrl-A / Ctrl-E            move to start / end of line");
-        console.log("  /          open the slash-command palette");
-        console.log("  @path      mention a file (Tab completes relative paths)");
+        const cfg = await readGlobalConfig();
+        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+        const result = handleHotkeys(ctx);
+        if (result && "lines" in result) for (const line of result.lines) console.log(line);
         continue;
       }
       if (input === "/theme" || input.startsWith("/theme ")) {

package/src/tui/components/width.ts

@@ -185,13 +185,32 @@ export function sanitizeForFrame(s: string): string {
   return out;
 }
 
+/** Active SGR state after applying every SGR escape in `segment` to `prior`.
+ *  Pragmatic model (matches wrap-ansi): a full reset (`\x1b[0m` / `\x1b[m`) clears
+ *  the open set; any other SGR is appended. Good enough for the fg/bg/bold coloring
+ *  a TUI box actually uses; it does not model selective resets (e.g. `\x1b[22m`). */
+function sgrStateAfter(prior: string, segment: string): string {
+  if (!segment.includes("\x1b")) return prior;
+  let state = prior;
+  const re = /\x1b\[[0-9;]*m/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(segment))) {
+    state = m[0] === "\x1b[0m" || m[0] === "\x1b[m" ? "" : state + m[0];
+  }
+  return state;
+}
+
 /**
  * Hard-wrap text to `cols` display columns, breaking long words and preserving
- * existing newlines. SGR-aware (escapes don't consume width). Returns the wrapped
- * lines. Used by markdown/table rendering where alignment must be column-correct.
+ * existing newlines. SGR-aware (escapes don't consume width) AND SGR-stateful:
+ * a color opened before a wrap point is RE-APPLIED at the start of each continuation
+ * line and CLOSED at its end, so a wrapped colored span stays colored on every row
+ * instead of losing its tint after the first line (and never bleeds into the padding
+ * or box border). Returns the wrapped lines.
  */
 export function wrapTextWithAnsi(text: string, cols: number): string[] {
   const width = Math.max(1, cols);
+  const RESET = "\x1b[0m";
   const out: string[] = [];
   for (const rawLine of text.split("\n")) {
     if (visibleWidth(rawLine) <= width) {
@@ -199,16 +218,31 @@ export function wrapTextWithAnsi(text: string, cols: number): string[] {
       continue;
     }
     let rest = rawLine;
+    let active = ""; // SGR open at the wrap boundary, carried to the next line
     while (visibleWidth(rest) > width) {
       const head = truncateToWidth(rest, width);
-      // Advance past exactly the consumed substring (head may carry a trailing reset).
-      const consumed = head.endsWith("\x1b[0m") && !rest.endsWith("\x1b[0m")
-        ? head.slice(0, -"\x1b[0m".length)
-        : head;
-      out.push(head);
+      // Advance past exactly the consumed substring. truncateToWidth may append a
+      // SYNTHETIC trailing reset (frame safety) that is NOT in `rest` — including it
+      // would over-advance and drop real chars. `rest.startsWith(head)` means the
+      // reset is genuinely part of the source; otherwise strip the synthetic one.
+      const consumed = rest.startsWith(head)
+        ? head
+        : head.endsWith(RESET) && rest.startsWith(head.slice(0, -RESET.length))
+          ? head.slice(0, -RESET.length)
+          : head;
+      let line = active + head;
+      const next = sgrStateAfter(active, consumed);
+      // Close any color still open at the line end so it cannot tint the padding/border.
+      if (next && !line.endsWith(RESET)) line += RESET;
+      out.push(line);
+      active = next;
       rest = rest.slice(consumed.length);
     }
-    if (rest.length > 0) out.push(rest);
+    if (rest.length > 0) {
+      let line = active + rest;
+      if (active && !line.endsWith(RESET)) line += RESET;
+      out.push(line);
+    }
   }
   return out;
 }