deepseek-cli-mode 1.0.2 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 1.2.0 — live slash-command menu
+
+- Typing `/` at the prompt now opens a live command menu (like Claude Code): matching commands and descriptions,
+  `↑`/`↓` to move, `Tab` to complete, `Enter` to run the highlighted command.
+- New raw-mode line editor (`runner/line-editor.js`) for TTY sessions: cursor movement, history, bracketed paste,
+  Ctrl+A/E, and a menu that filters as you type.
+- Piped/non-TTY input keeps the existing readline path; one-shot mode is unchanged.
+- Security: the editor strips C0/C1 control characters from inserted text and renders command names/descriptions
+  through the sanitizer; it never executes anything itself.
+- The launcher now copies every runner module into the profile (previously only `runner.js`).
+
+## 1.1.0 — Claude-Code-style terminal UI
+
+- New welcome panel: rounded box with version, model, cwd, and first-run hints.
+- Prompt is now `> `; each turn ends with a dim status line (`model · tokens · seconds`).
+- Tool activity renders as `⏺ Tool(args)` followed by a `⎿ result` summary line.
+- Animated `✻ Thinking… (Ns · ctrl+c to interrupt)` spinner while the model works.
+- Permission prompts use the numbered `Do you want to allow …? 1. Yes / 2. No` dialog.
+- Todo list uses `☒`/`☐` checkboxes and prints only changed items after the first render.
+- New `/status` command (session, model, cwd, mode, token pressure); `/session` kept.
+- Security: all new rendering paths pass model/repository text through the existing
+  control-character sanitizer; no new process, network, or filesystem surfaces were added.
+
 ## 1.0.2 — runtime discovery fixes
 
 - `resolveDshBin()` now also looks for `@deepseek-ai/dsh` next to this package (same `node_modules`) and in the

package/README.md

@@ -12,6 +12,31 @@ interactive **CLI** that boots the *same* Harness runtime (`dsh-base` + `dsh-hea
 session persistence, approvals) and keeps **one live Agent for the whole session**, so multi-turn context, tool state,
 and the model's request prefix stay warm between messages.
 
+The terminal UI follows the Claude Code layout:
+
+```
+╭──────────────────────────────────────────────────────╮
+│ ✻ DeepSeek CLI 1.1.0                                 │
+│                                                      │
+│   /help for help · /status for your current setup    │
+│   model: deepseek-official/deepseek-chat             │
+│   cwd:   C:\work\my-project                          │
+╰──────────────────────────────────────────────────────╯
+
+> explain what changed and run the tests
+
+⏺ glob(**/*.ts)
+  ⎿  src/app.ts src/auth.ts tests/auth.spec.ts
+✻ Thinking… (2s · ctrl+c to interrupt)
+
+⏺ pwsh(npm test)
+  ⎿  Tests: 42 passed, 42 total
+
+The auth change is safe; all tests pass.
+
+  ✻ deepseek-official/deepseek-chat · 8.4k tokens · 12.1s
+```
+
 ```
 ❯ explain what changed in this repo and run the tests
 
@@ -109,6 +134,16 @@ deepseek "review @src/app.ts and tell me what is risky"
 
 ### Inside a session
 
+Typing `/` opens a live command menu, like Claude Code:
+
+```
+> /se
+  ❯ /session    Print the current session id
+    /sessions   List recent sessions in this directory
+```
+
+`↑`/`↓` moves the selection, `Tab` completes it, `Enter` runs it. The menu filters as you type.
+
 | Command | What it does |
 |---|---|
 | `/help` | command list, including the live Harness command registry |
@@ -125,6 +160,7 @@ deepseek "review @src/app.ts and tell me what is risky"
 | `/export [file]` | write this run's transcript as markdown |
 | `/thinking` | print the last turn's reasoning (collapsed by default) |
 | `/session` | print the current session id (for `--resume`) |
+| `/status` | session, model, cwd, mode, and token pressure |
 | `/clear` | clear the screen |
 | `/quit`, `/exit` | leave (Ctrl+C at an empty prompt also exits) |
 

package/bin/deepseek.js

@@ -9,7 +9,7 @@
 // The profile keeps ONE live Agent for the whole session, so tools, approvals,
 // session persistence, and the model's request prefix stay warm between turns.
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, delimiter, join, resolve } from "node:path";
@@ -198,11 +198,14 @@ function ensureProfile() {
     if (!existsSync(target) || stampVersion !== VERSION) writeFileSync(target, content);
   }
 
-  // Keep the runner exactly in sync with this package.
-  const runnerSrc = join(root, "runner", "runner.js");
-  const runnerDst = join(profileDir, "runner.js");
-  const src = readFileSync(runnerSrc, "utf8");
-  if (!existsSync(runnerDst) || readFileSync(runnerDst, "utf8") !== src) writeFileSync(runnerDst, src);
+  // Keep every runner file exactly in sync with this package.
+  const runnerSrcDir = join(root, "runner");
+  for (const entry of readdirSync(runnerSrcDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !/\.(?:js|mjs|cjs)$/.test(entry.name)) continue;
+    const src = readFileSync(join(runnerSrcDir, entry.name), "utf8");
+    const dst = join(profileDir, entry.name);
+    if (!existsSync(dst) || readFileSync(dst, "utf8") !== src) writeFileSync(dst, src);
+  }
 
   writeFileSync(stamp, VERSION + "\n");
   return profileDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-cli-mode",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Terminal (CLI) mode for DeepSeek Harness — an interactive, Claude Code-style coding agent for your shell.",
   "type": "module",
   "main": "index.js",

package/runner/line-editor.js

@@ -0,0 +1,354 @@
+// Minimal terminal line editor with a live slash-command menu, in the style of
+// Claude Code. No dependencies. Attaches to a TTY in raw mode and renders one
+// input line plus an optional suggestion list below it.
+//
+// Security: every string this module prints as user content is stripped of
+// C0/C1 control characters (except newline/tab handled by the caller). The
+// editor never executes anything; it only returns the submitted line.
+
+const CONTROL_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
+const ANSI = /\x1b\[[0-9;?]*[A-Za-z]/g;
+
+/** Visible width of a prompt that may contain ANSI escapes. */
+function visibleWidth(text) {
+  return String(text).replace(ANSI, "").length;
+}
+
+/** Strip terminal control characters from untrusted text. */
+function clean(text) {
+  return String(text).replace(CONTROL_CHARS, "");
+}
+
+export class LineEditor {
+  /**
+   * @param {object} options
+   * @param {NodeJS.ReadStream} options.input
+   * @param {NodeJS.WriteStream} options.output
+   * @param {() => number} [options.columns]
+   * @param {() => void} [options.onInterrupt] called for Ctrl+C while no question is pending
+   * @param {() => void} [options.onEnd] called when stdin ends
+   */
+  constructor({ input, output, columns, onInterrupt, onEnd }) {
+    this.input = input;
+    this.output = output;
+    this.columns = columns ?? (() => this.output.columns || 80);
+    this.onInterrupt = onInterrupt ?? (() => {});
+    this.onEnd = onEnd ?? (() => {});
+    this.commands = [];
+    this.buffer = "";
+    this.cursor = 0;
+    this.history = [];
+    this.historyIndex = -1;
+    this.draft = "";
+    this.menu = [];
+    this.menuIndex = 0;
+    this.active = false;
+    this.menuEnabled = false;
+    this.prompt = "";
+    this.resolve = null;
+    this.renderedRows = 0;
+    this.paste = false;
+    this.escape = null;
+    this.started = false;
+    this._onData = (chunk) => this.handleData(chunk);
+    this._onEnd = () => {
+      this.onEnd();
+      this.settle(null, false);
+    };
+  }
+
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.input.setRawMode?.(true);
+    this.input.setEncoding?.("utf8");
+    this.input.resume?.();
+    this.input.on("data", this._onData);
+    this.input.on("end", this._onEnd);
+    this.output.write("\x1b[?2004h");
+  }
+
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.input.off?.("data", this._onData);
+    this.input.off?.("end", this._onEnd);
+    this.output.write("\x1b[?2004l");
+    this.input.setRawMode?.(false);
+    this.input.pause?.();
+  }
+
+  /** Replace the suggestion list (name + description objects). */
+  setCommands(commands) {
+    this.commands = Array.isArray(commands) ? commands : [];
+  }
+
+  /** Enable/disable input while a turn runs (Ctrl+C still interrupts). */
+  setActive(active) {
+    if (this.active === active) return;
+    this.active = active;
+    if (!active) this.clearRender();
+  }
+
+  /**
+   * Ask one line.
+   * @param {string} prompt prompt string (may contain ANSI)
+   * @param {boolean} menuEnabled show slash-command suggestions
+   * @returns {Promise<string|null>} line, or null on Ctrl+C / EOF
+   */
+  ask(prompt, menuEnabled = false) {
+    this.prompt = prompt;
+    this.menuEnabled = menuEnabled;
+    this.buffer = "";
+    this.cursor = 0;
+    this.menu = [];
+    this.menuIndex = 0;
+    this.historyIndex = -1;
+    this.draft = "";
+    this.active = true;
+    this.renderedRows = 0;
+    this.render();
+    return new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+
+  // ---- input --------------------------------------------------------------
+  handleData(chunk) {
+    for (const char of String(chunk)) {
+      if (this.escape !== null) {
+        this.escape += char;
+        if (/[A-Za-z~]$/.test(char)) {
+          const sequence = this.escape;
+          this.escape = null;
+          this.handleEscape(sequence);
+        }
+        continue;
+      }
+      if (char === "\x1b") {
+        this.escape = "\x1b";
+        continue;
+      }
+      if (!this.active) {
+        if (char === "\x03") this.onInterrupt();
+        continue;
+      }
+      this.handleChar(char);
+    }
+    if (this.active) this.render();
+  }
+
+  handleChar(char) {
+    if (this.paste) {
+      if (char === "\x1b") this.escape = "\x1b";
+      else this.insert(char === "\n" ? " " : char);
+      return;
+    }
+    switch (char) {
+      case "\r":
+      case "\n":
+        this.submit();
+        return;
+      case "\x03": // Ctrl+C
+        this.settle(null);
+        return;
+      case "\x04": // Ctrl+D
+        this.settle(null);
+        return;
+      case "\x7f":
+      case "\b":
+        this.backspace();
+        return;
+      case "\t":
+        this.complete();
+        return;
+      case "\x01": // Ctrl+A
+        this.cursor = 0;
+        return;
+      case "\x05": // Ctrl+E
+        this.cursor = this.buffer.length;
+        return;
+      default:
+        if (char >= " ") this.insert(char);
+    }
+  }
+
+  handleEscape(sequence) {
+    if (sequence === "\x1b[200~") {
+      this.paste = true;
+      return;
+    }
+    if (sequence === "\x1b[201~") {
+      this.paste = false;
+      return;
+    }
+    if (this.paste) return;
+    switch (sequence) {
+      case "\x1b[A":
+        this.up();
+        break;
+      case "\x1b[B":
+        this.down();
+        break;
+      case "\x1b[C":
+        this.cursor = Math.min(this.cursor + 1, this.buffer.length);
+        break;
+      case "\x1b[D":
+        this.cursor = Math.max(this.cursor - 1, 0);
+        break;
+      case "\x1b[H":
+      case "\x1b[1~":
+        this.cursor = 0;
+        break;
+      case "\x1b[F":
+      case "\x1b[4~":
+        this.cursor = this.buffer.length;
+        break;
+      case "\x1b[3~":
+        this.deleteForward();
+        break;
+      default:
+        break;
+    }
+  }
+
+  insert(text) {
+    const safe = clean(text);
+    this.buffer = this.buffer.slice(0, this.cursor) + safe + this.buffer.slice(this.cursor);
+    this.cursor += safe.length;
+    this.historyIndex = -1;
+    this.menuIndex = 0;
+  }
+
+  backspace() {
+    if (this.cursor === 0) return;
+    this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+    this.cursor -= 1;
+    this.historyIndex = -1;
+  }
+
+  deleteForward() {
+    if (this.cursor >= this.buffer.length) return;
+    this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+    this.historyIndex = -1;
+  }
+
+  up() {
+    if (this.menu.length > 0) {
+      this.menuIndex = (this.menuIndex - 1 + this.menu.length) % this.menu.length;
+      return;
+    }
+    if (this.history.length === 0) return;
+    if (this.historyIndex === -1) {
+      this.draft = this.buffer;
+      this.historyIndex = this.history.length - 1;
+    } else if (this.historyIndex > 0) {
+      this.historyIndex -= 1;
+    }
+    this.buffer = this.history[this.historyIndex];
+    this.cursor = this.buffer.length;
+  }
+
+  down() {
+    if (this.menu.length > 0) {
+      this.menuIndex = (this.menuIndex + 1) % this.menu.length;
+      return;
+    }
+    if (this.historyIndex === -1) return;
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex += 1;
+      this.buffer = this.history[this.historyIndex];
+    } else {
+      this.historyIndex = -1;
+      this.buffer = this.draft;
+    }
+    this.cursor = this.buffer.length;
+  }
+
+  complete() {
+    const item = this.menu[this.menuIndex];
+    if (item === undefined) return;
+    this.buffer = "/" + item.name;
+    this.cursor = this.buffer.length;
+    this.menu = [];
+    this.menuIndex = 0;
+  }
+
+  submit() {
+    const item = this.menu[this.menuIndex];
+    if (item !== undefined && this.buffer.trim() !== "/" + item.name) {
+      this.buffer = "/" + item.name;
+      this.cursor = this.buffer.length;
+    }
+    const line = this.buffer;
+    if (line.trim() !== "" && this.history[this.history.length - 1] !== line) {
+      this.history.push(line);
+      if (this.history.length > 200) this.history.shift();
+    }
+    this.settle(line);
+  }
+
+  settle(value, echo = true) {
+    if (this.resolve === null) return;
+    const resolve = this.resolve;
+    this.resolve = null;
+    this.active = false;
+    this.clearRender();
+    this.menu = [];
+    if (echo) this.output.write("\n");
+    resolve(value);
+  }
+
+  // ---- rendering ----------------------------------------------------------
+  computeMenu() {
+    if (!this.menuEnabled) return [];
+    if (!this.buffer.startsWith("/")) return [];
+    if (/\s/.test(this.buffer)) return [];
+    const query = this.buffer.slice(1).toLowerCase();
+    const items = this.commands.filter((command) => command.name.toLowerCase().startsWith(query));
+    return items.slice(0, 8);
+  }
+
+  clearRender() {
+    if (this.renderedRows > 0) {
+      this.output.write(`\x1b[${this.renderedRows}B`);
+      this.output.write("\r\x1b[0J");
+      this.output.write(`\x1b[${this.renderedRows}A`);
+    }
+    this.output.write("\r\x1b[2K");
+    this.renderedRows = 0;
+  }
+
+  render() {
+    if (!this.active) return;
+    this.clearRender();
+    const columns = Math.max(40, this.columns() || 80);
+    const prompt = this.prompt;
+    const promptWidth = visibleWidth(prompt);
+    const available = Math.max(8, columns - promptWidth - 1);
+    let offset = 0;
+    if (this.buffer.length > available) offset = Math.max(0, this.cursor - available + 1);
+    const visible = this.buffer.slice(offset, offset + available);
+    const column = promptWidth + (this.cursor - offset);
+    this.output.write(prompt + visible);
+
+    this.menu = this.computeMenu();
+    if (this.menuIndex >= this.menu.length) this.menuIndex = 0;
+    const rows = this.menu.length;
+    if (rows > 0) {
+      const nameWidth = Math.min(18, Math.max(...this.menu.map((item) => item.name.length)) + 1);
+      for (let index = 0; index < rows; index += 1) {
+        const item = this.menu[index];
+        const selected = index === this.menuIndex;
+        const marker = selected ? "❯" : " ";
+        const name = ("/" + clean(item.name)).padEnd(nameWidth + 1);
+        const description = clean(item.description ?? "").slice(0, Math.max(10, columns - nameWidth - 8));
+        const line = `  ${marker} ${selected ? `\x1b[36m${name}\x1b[39m` : name} ${description}`;
+        this.output.write("\n" + line);
+      }
+      this.output.write(`\x1b[${rows}A`);
+    }
+    this.renderedRows = rows;
+    this.output.write(`\x1b[${column + 1}G`);
+  }
+}

package/runner/runner.js

@@ -23,6 +23,7 @@ import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { LineEditor } from "./line-editor.js";
 
 /** Stable Cordis plugin name. */
 export const name = "cli-runner";
@@ -210,6 +211,9 @@ function createRenderer({ write, capture }) {
     get lastTodos() {
       return lastTodos;
     },
+    get turnUsage() {
+      return { ...turnUsage };
+    },
     resetTurn() {
       streamedThisTurn = false;
       reasoning = "";
@@ -246,15 +250,24 @@ function createRenderer({ write, capture }) {
         case "tool/call": {
           if (data.name === "todo_write") break; // the checklist below is the presentation
           endLine();
-          const icon = TOOL_ICONS[data.name] ?? "⏺";
           const preview = previewToolCall(data.name, data.arguments);
-          write(paint(ansi.dim, paint(ansi.italic, `  ${icon} ${data.name}${preview ? " " + preview : ""}`)) + "\n");
+          write(
+            paint(ansi.cyan, "⏺ ") +
+              paint(ansi.bold, sanitize(data.name)) +
+              paint(ansi.dim, `(${preview})`) +
+              "\n"
+          );
           break;
         }
         case "tool/result": {
-          if (data.error) {
-            write(paint(ansi.dim, paint(ansi.italic, `  ✗ ${sanitize(data.error.name)}: ${sanitize(data.error.code)}`)) + "\n");
+          let summary;
+          if (data.error) summary = `Error: ${sanitize(data.error.name)}${data.error.code ? ` (${sanitize(data.error.code)})` : ""}`;
+          else {
+            const content = data.message?.content ?? [];
+            const text = content.filter((b) => b.type === "text").map((b) => b.text).join(" ").replace(/\s+/g, " ").trim();
+            summary = text === "" ? "Done" : truncate(text, 76);
           }
+          write(paint(ansi.dim, `  ⎿  ${sanitize(summary)}`) + "\n");
           break;
         }
         case "assistant/message": {
@@ -280,15 +293,15 @@ function createRenderer({ write, capture }) {
           endLine();
           flushText();
           const done = todos.filter((todo) => todo.status === "completed").length;
-          write(paint(ansi.dim, `  ☑ todos ${done}/${todos.length}`) + "\n");
+          write(paint(ansi.dim, `  ☒ todos ${done}/${todos.length}`) + "\n");
           // Print the whole list once; later writes show only the items that moved.
           const shown = firstRender ? todos : todos.filter((todo) => previous.get(todo.content) !== todo.status);
           for (const todo of shown) {
             const mark =
               todo.status === "completed"
-                ? paint(ansi.green, "✓")
+                ? paint(ansi.green, "☒")
                 : todo.status === "in_progress"
-                  ? paint(ansi.yellow, "▸")
+                  ? paint(ansi.yellow, "☐")
                   : paint(ansi.dim, "☐");
             const content = todo.status === "completed" ? paint(ansi.dim, sanitize(todo.content)) : sanitize(todo.content);
             write(`    ${mark} ${content}\n`);
@@ -442,32 +455,78 @@ function printSessionList(sessions, write = out) {
     write(paint(ansi.dim, "  no sessions in this directory yet\n"));
     return;
   }
-  write(`  Recent sessions in ${process.cwd()}:\n`);
+  write(`  Recent sessions in ${sanitize(process.cwd())}:\n`);
   sessions.slice(0, 10).forEach((session, index) => {
     const running = session.openTurn ? paint(ansi.yellow, "  ▶ running") : "";
-    write(`   ${paint(ansi.cyan, String(index + 1))}) ${paint(ansi.dim, session.id)}  (${paint(ansi.dim, timeAgo(session.mtime))})${running}\n`);
+    write(`   ${paint(ansi.cyan, String(index + 1))}) ${paint(ansi.dim, sanitize(session.id))}  (${paint(ansi.dim, timeAgo(session.mtime))})${running}\n`);
   });
 }
 
 // ---------------------------------------------------------------------------
-// Help / banner
+// Help / welcome
 // ---------------------------------------------------------------------------
+/** Draw a rounded box, truncating content to the terminal width. */
+function box(lines, minWidth = 56) {
+  const cols = Math.max(40, Math.min(process.stdout.columns || 88, 100));
+  const width = Math.min(cols - 2, Math.max(minWidth, ...lines.map((line) => line.length + 4)));
+  const inner = width - 4;
+  const outLines = [];
+  outLines.push(paint(ansi.dim, "╭" + "─".repeat(width - 2) + "╮"));
+  for (const line of lines) {
+    let text = line;
+    if (text.length > inner) text = text.slice(0, inner - 1) + "…";
+    outLines.push(paint(ansi.dim, "│ ") + text.padEnd(inner) + paint(ansi.dim, " │"));
+  }
+  outLines.push(paint(ansi.dim, "╰" + "─".repeat(width - 2) + "╯"));
+  for (const line of outLines) out(line + "\n");
+}
+
 function printBanner(model) {
-  const art = [
-    "        ooo",
-    '       " """',
-    '      "   "',
-    '   ___:____      "  "|',
-    " ,'        \\.     \\//",
-    " |  O        \\___/  |",
-    "~^~^~^~^~^~^~^~^~^~^~^~^~^~^~^~^~",
-  ];
+  const modelLine = sanitize(`${model.provider}/${model.model}${model.reasoningEffort ? ` · ${model.reasoningEffort}` : ""}`);
   out("\n");
-  for (const line of art) out(paint(ansi.blue, line) + "\n");
-  out(`${paint(ansi.bold, "deepseek")} ${paint(ansi.dim, VERSION)} — DeepSeek Harness in your terminal\n`);
-  out(paint(ansi.dim, `model: ${model.provider}/${model.model}${model.reasoningEffort ? ` · ${model.reasoningEffort}` : ""}`) + "\n");
-  out(paint(ansi.dim, `cwd: ${process.cwd()}`) + "\n");
-  out(paint(ansi.dim, "type /help for commands, Ctrl+C to interrupt or exit") + "\n\n");
+  box([
+    `${paint(ansi.cyan, "✻")} ${paint(ansi.bold, "DeepSeek CLI")} ${paint(ansi.dim, VERSION)}`,
+    "",
+    paint(ansi.dim, "  /help for help · /status for your current setup"),
+    paint(ansi.dim, `  model: ${modelLine}`),
+    paint(ansi.dim, `  cwd:   ${sanitize(process.cwd())}`),
+  ]);
+  out(paint(ansi.dim, "  Type a task, or /help. Ctrl+C interrupts; twice exits.") + "\n\n");
+}
+
+// Slash-command suggestions for the live menu (native Harness commands are
+// merged in at runtime).
+const BUILTIN_COMMANDS = [
+  { name: "clear", description: "Clear the screen" },
+  { name: "exit", description: "Leave the session" },
+  { name: "export", description: "Write this run's transcript as markdown" },
+  { name: "help", description: "Show commands" },
+  { name: "image", description: "Attach an image to the next message" },
+  { name: "jobs", description: "List this session's background jobs" },
+  { name: "model", description: "Show or switch the model" },
+  { name: "new", description: "Start a fresh session" },
+  { name: "permissions", description: "Show or switch the permission preset" },
+  { name: "quit", description: "Leave the session" },
+  { name: "reasoning", description: "Show or set the reasoning effort" },
+  { name: "resume", description: "Switch to another session" },
+  { name: "session", description: "Print the current session id" },
+  { name: "sessions", description: "List recent sessions in this directory" },
+  { name: "skills", description: "List discovered skills" },
+  { name: "status", description: "Session, model, cwd, token pressure" },
+  { name: "thinking", description: "Show the last turn's reasoning" },
+  { name: "todos", description: "Show the current todo list" },
+];
+
+/** Built-ins plus whatever commands the Harness profile registers. */
+function commandMenu(agent, commands) {
+  const merged = new Map();
+  for (const command of BUILTIN_COMMANDS) merged.set(command.name, command);
+  try {
+    for (const native of commands?.list(agent) ?? []) {
+      if (!merged.has(native.name)) merged.set(native.name, { name: native.name, description: native.description });
+    }
+  } catch {}
+  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 
 function printHelp(write = out) {
@@ -498,6 +557,7 @@ Interactive commands:
   /export [file]     write this run's transcript as markdown
   /thinking          show the last turn's reasoning
   /session           print the current session id (for --resume)
+  /status            session, model, cwd, token pressure
   /clear             clear the screen
   /quit, /exit       leave (also Ctrl+C at an empty prompt)
 
@@ -576,6 +636,7 @@ async function run(ctx, options, exit) {
   const planMode = ctx.get("planMode");
   const permissionPresets = ctx.get("permissionPresets");
   const attachments = ctx.get("attachments");
+  const tokenMeter = ctx.get("tokenMeter");
 
   if (options.list) {
     printSessionList(listSessions());
@@ -606,17 +667,31 @@ async function run(ctx, options, exit) {
   const write = (text) => process.stdout.write(text);
 
   // ---- line input ---------------------------------------------------------
-  // One-shot mode must not own stdin: a piped/closed stdin would deliver EOF
-  // and tear the runtime down before the task runs.
-  const rlInterface = interactive
-    ? createInterface({
+  // TTY: a raw-mode line editor with a live slash-command menu (Claude style).
+  // Non-TTY: readline over the piped stream. One-shot: no input owner at all.
+  const useEditor = interactive && process.stdin.isTTY === true;
+  const editor = useEditor
+    ? new LineEditor({
         input: process.stdin,
         output: process.stdout,
-        terminal: process.stdin.isTTY,
-        historySize: 200,
-        removeHistoryDuplicates: true,
+        columns: () => process.stdout.columns || 80,
+        onInterrupt: () => handleInterrupt(),
+        onEnd: () => {
+          stdinClosed = true;
+          if (ready && !busy) shutdown(0);
+        },
       })
     : null;
+  const rlInterface =
+    interactive && !useEditor
+      ? createInterface({
+          input: process.stdin,
+          output: process.stdout,
+          terminal: false,
+          historySize: 200,
+          removeHistoryDuplicates: true,
+        })
+      : null;
   // Hold the input until the first agent is ready: buffered piped lines must
   // not be consumed (and dropped) while the profile is still starting.
   if (rlInterface) {
@@ -625,8 +700,14 @@ async function run(ctx, options, exit) {
       paused = true;
     } catch {}
   }
+  editor?.start();
+  editor?.setActive(false);
 
   function setPaused(value) {
+    if (editor) {
+      editor.setActive(!value);
+      return;
+    }
     if (!rlInterface || paused === value) return;
     paused = value;
     try {
@@ -647,12 +728,16 @@ async function run(ctx, options, exit) {
 
   /**
    * Ask one line. Resolves null when the question is interrupted (Ctrl+C) or
-   * stdin closes. A permanent listener queues ahead-of-time lines (piped input,
-   * or typing while the model works), so no line is ever dropped.
+   * stdin closes. On a TTY the editor renders a live command menu.
    * @param {string} prompt
+   * @param {boolean} [menu]
    * @returns {Promise<string | null>}
    */
-  function ask(prompt) {
+  function ask(prompt, menu = false) {
+    if (editor) {
+      setPaused(false);
+      return editor.ask(prompt, menu);
+    }
     return new Promise((resolve) => {
       if (!rlInterface) {
         resolve(null);
@@ -686,6 +771,7 @@ async function run(ctx, options, exit) {
 
   function closeInput() {
     try {
+      editor?.stop();
       rlInterface?.close();
     } catch {}
   }
@@ -783,24 +869,63 @@ async function run(ctx, options, exit) {
   // ---- agent lifecycle ----------------------------------------------------
   const makeAgentOptions = () => ({ ...selectionRef.current });
 
+  // ---- Claude-style activity indicator ------------------------------------
+  let spinnerTimer = null;
+  let spinnerIndex = 0;
+  let spinnerActive = false;
+  const SPINNER = ["✻", "✳", "✶", "✳"];
+
+  function startSpinner(label = "Thinking") {
+    if (!tty || options.mode === "oneshot" || spinnerActive) return;
+    spinnerActive = true;
+    spinnerIndex = 0;
+    const started = Date.now();
+    out("\x1b[?25l");
+    const tick = () => {
+      const glyph = SPINNER[spinnerIndex++ % SPINNER.length];
+      const seconds = Math.floor((Date.now() - started) / 1000);
+      out(`\r\x1b[2K${paint(ansi.dim, `${glyph} ${label}… (${seconds}s · ctrl+c to interrupt)`)}`);
+    };
+    tick();
+    spinnerTimer = setInterval(tick, 120);
+  }
+
+  function stopSpinner() {
+    if (!spinnerActive) return;
+    spinnerActive = false;
+    if (spinnerTimer !== null) {
+      clearInterval(spinnerTimer);
+      spinnerTimer = null;
+    }
+    out("\r\x1b[2K\x1b[?25h");
+  }
+
   const wire = (agent) => {
     agent.ctx.on("session/event", (session, event) => {
-      if (session === agent.session) renderer.event(event);
+      if (session === agent.session) {
+        stopSpinner();
+        renderer.event(event);
+      }
     });
     agent.ctx.on("agent/assistant-stream", (payload) => {
-      if (payload.agent === agent) renderer.frame(payload.frame);
+      if (payload.agent === agent) {
+        stopSpinner();
+        renderer.frame(payload.frame);
+      }
     });
     agent.ctx.on("user-questions/request", async (request) => answerQuestions(request));
     agent.ctx.on("approval/request", async (request) => {
-      const toolName = request.toolName ?? "tool";
+      const toolName = sanitize(request.toolName ?? "tool");
       if (autoYes) return "allowed-once";
-      if (request.reason) {
-        out(paint(ansi.dim, paint(ansi.italic, `  ⚠ ${toolName} needs approval: ${request.reason}`)) + "\n");
-      }
+      stopSpinner();
       if (!interactive || !process.stdin.isTTY) return "rejected";
-      const answer = await ask(paint(ansi.yellow, `  ⚠ Allow ${paint(ansi.cyan, toolName)}? `) + paint(ansi.dim, "[y/N] "));
-      if (answer === null) return "rejected";
-      return /^y(es)?$/i.test(answer.trim()) ? "allowed-once" : "rejected";
+      out("\n");
+      if (request.reason) out(paint(ansi.dim, `  ${sanitize(request.reason)}`) + "\n");
+      out(`  ${paint(ansi.bold, "Do you want to allow")} ${paint(ansi.cyan, toolName)}${paint(ansi.bold, "?")}\n`);
+      out(`    ${paint(ansi.cyan, "1")}. Yes\n    ${paint(ansi.cyan, "2")}. No\n`);
+      const answer = (await ask(paint(ansi.green, "  ❯ "))) ?? "";
+      const choice = answer.trim().toLowerCase();
+      return choice === "1" || choice === "y" || choice === "yes" ? "allowed-once" : "rejected";
     });
   };
 
@@ -836,17 +961,26 @@ async function run(ctx, options, exit) {
     busy = true;
     cancelSent = false;
     renderer.resetTurn();
+    const startedAt = Date.now();
     setPaused(true);
+    startSpinner("Thinking");
     try {
       agent.followup(createUserMessage({ content, source: { kind: "user" } }));
       await agent.whenIdle();
       await persistence.flush();
     } finally {
+      stopSpinner();
       busy = false;
       setPaused(false);
       if (renderer.lastAssistantText && renderer.lastAssistantText !== previousAnswer) {
         transcript.push({ role: "assistant", text: renderer.lastAssistantText });
       }
+      if (interactive && tty) {
+        const usage = renderer.turnUsage;
+        const seconds = ((Date.now() - startedAt) / 1000).toFixed(1);
+        const tokens = usage.input + usage.output;
+        out(paint(ansi.dim, `  ✻ ${sanitize(modelDesc())}${tokens > 0 ? ` · ${formatTokens(tokens)} tokens` : ""} · ${seconds}s`) + "\n\n");
+      }
     }
   };
 
@@ -1057,7 +1191,7 @@ async function run(ctx, options, exit) {
   try {
     agent = resumeTarget ? await startAgent(undefined, resumeTarget) : await startAgent(SessionId(`session-${randomUUID()}`), undefined);
   } catch (error) {
-    err(`deepseek: cannot start a session: ${error instanceof Error ? error.message : String(error)}\n`);
+    err(`deepseek: cannot start a session: ${sanitize(describeError(error))}\n`);
     await shutdown(1);
     return;
   }
@@ -1070,14 +1204,15 @@ async function run(ctx, options, exit) {
 
   printBanner(selectionRef.current);
   if (resumeTarget) {
-    out(paint(ansi.green, `▶ resumed `) + paint(ansi.dim, resumeTarget) + "\n");
+    out(paint(ansi.green, `▶ resumed `) + paint(ansi.dim, sanitize(resumeTarget)) + "\n");
     out(paint(ansi.dim, "  (history is in the session log; continue the conversation below)") + "\n\n");
   } else {
-    out(paint(ansi.dim, `session: ${agent.session.id}  (resume with: deepseek --resume ${agent.session.id})`) + "\n\n");
+    out(paint(ansi.dim, `session: ${sanitize(agent.session.id)}  (resume with: deepseek --resume ${sanitize(agent.session.id)})`) + "\n\n");
   }
 
   while (!quitting) {
-    const line = await ask(paint(ansi.green, "❯ "));
+    if (editor) editor.setCommands(commandMenu(agent, commands));
+    const line = await ask(paint(ansi.bold, "> "), true);
     if (line === null) break;
     const text = line.trim();
     if (text === "") continue;
@@ -1098,9 +1233,9 @@ async function run(ctx, options, exit) {
           out(paint(ansi.dim, "  ↻ new session\n"));
           try {
             agent = await startAgent(SessionId(`session-${randomUUID()}`), undefined);
-            out(paint(ansi.dim, `  session: ${agent.session.id}\n`));
+            out(paint(ansi.dim, `  session: ${sanitize(agent.session.id)}\n`));
           } catch (error) {
-            out(paint(ansi.red, `  ✘ ${error instanceof Error ? error.message : String(error)}\n`));
+            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
           continue;
         }
@@ -1116,13 +1251,27 @@ async function run(ctx, options, exit) {
             out(paint(ansi.dim, `  ↻ resuming ${argument}\n`));
             agent = await startAgent(undefined, argument);
           } catch (error) {
-            out(paint(ansi.red, `  ✘ ${error instanceof Error ? error.message : String(error)}\n`));
+            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
           continue;
         }
         case "/session":
-          out(paint(ansi.dim, `  ${agent.session.id}\n`));
+          out(paint(ansi.dim, `  ${sanitize(agent.session.id)}\n`));
           continue;
+        case "/status": {
+          out(paint(ansi.bold, "  Status") + "\n");
+          out(`  session: ${sanitize(agent.session.id)}\n`);
+          out(`  model:   ${sanitize(modelDesc())}\n`);
+          out(`  cwd:     ${sanitize(process.cwd())}\n`);
+          out(`  mode:    ${interactive ? "interactive" : "one-shot"}${autoYes ? " · auto-approve" : ""}\n`);
+          try {
+            if (tokenMeter !== undefined) {
+              const measurement = tokenMeter.measure(agent.session);
+              out(`  tokens:  ${measurement.totalTokens} (surface ${measurement.surfaceTokens})\n`);
+            }
+          } catch {}
+          continue;
+        }
         case "/model": {
           if (argument === "") {
             out(paint(ansi.dim, `  model: ${modelDesc()}\n`));
@@ -1134,7 +1283,7 @@ async function run(ctx, options, exit) {
             selectionRef.current = next;
             out(paint(ansi.green, `  ✓ model set: ${next.provider}/${next.model} (next message)\n`));
           } catch (error) {
-            out(paint(ansi.red, `  ✘ ${error instanceof Error ? error.message : String(error)}\n`));
+            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
           continue;
         }
@@ -1149,7 +1298,7 @@ async function run(ctx, options, exit) {
             selectionRef.current = next;
             out(paint(ansi.green, `  ✓ reasoning set: ${argument} (next message)\n`));
           } catch (error) {
-            out(paint(ansi.red, `  ✘ ${error instanceof Error ? error.message : String(error)}\n`));
+            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
           continue;
         }
@@ -1281,7 +1430,7 @@ async function run(ctx, options, exit) {
       }
     }
 
-    out("\n" + paint(ansi.green, "❯ ") + sanitize(text) + "\n\n");
+    out("\n" + paint(ansi.bold, "> ") + sanitize(text) + "\n\n");
     await runTurn(agent, text);
   }
 
@@ -1310,7 +1459,7 @@ export function apply(ctx) {
   }
   run(ctx, options, exit).catch((error) => {
     const detail = process.env.DSH_CLI_DEBUG === "1" && error instanceof Error ? `\n${error.stack}` : "";
-    process.stderr.write(`deepseek: ${error instanceof Error ? error.message : String(error)}${detail}\n`);
+    process.stderr.write(`deepseek: ${sanitize(describeError(error))}${detail}\n`);
     try {
       exit(1);
     } catch {}