deepseek-cli-mode 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 1.3.0 — pickers, Shift+Tab permission cycling, permanent mode footer
+
+- `/model`, `/reasoning`, `/permissions`, and `/resume` now open an interactive picker (`↑`/`↓`, `Enter`,
+  `Ctrl+C` to cancel) instead of requiring an argument. `/model` lists the models discovered from the provider.
+- **Shift+Tab** cycles the permission mode (read-only → workspace-write → danger-full-access) without losing the
+  typed line, with a transient hint.
+- A permanent dim footer above the prompt shows the active permission mode, model, and the Shift+Tab hint:
+  `⏵⏵ workspace-write · deepseek-official/deepseek-chat · shift+tab to cycle`.
+- Direct arguments still work (`/model <id>`, `/reasoning high`, `/permissions read-only`, `/resume <id>`).
+- Security: picker labels/descriptions and the footer pass through the sanitizer; permission changes still require a
+  user keystroke (the model cannot trigger them).
+
+## 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.

package/README.md

@@ -134,6 +134,24 @@ 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.
+
+`/model`, `/reasoning`, `/permissions`, and `/resume` open the same kind of picker when called without an argument.
+**Shift+Tab** cycles the permission mode, and a dim footer above the prompt always shows the active one:
+
+```
+  ⏵⏵ workspace-write · deepseek-official/deepseek-chat · shift+tab to cycle
+> 
+```
+
 | Command | What it does |
 |---|---|
 | `/help` | command list, including the live Harness command registry |

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.1.0",
+  "version": "1.3.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,462 @@
+// 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, onShiftTab }) {
+    this.input = input;
+    this.output = output;
+    this.columns = columns ?? (() => this.output.columns || 80);
+    this.onInterrupt = onInterrupt ?? (() => {});
+    this.onEnd = onEnd ?? (() => {});
+    this.onShiftTab = onShiftTab ?? (() => undefined);
+    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.selectMode = false;
+    this.selectOptions = [];
+    this.selectIndex = 0;
+    this.hint = "";
+    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;
+    });
+  }
+
+  /**
+   * Ask the user to pick one option from a list.
+   * @param {string} title prompt line
+   * @param {{label: string, description?: string, value: string}[]} options
+   * @param {number} [initial]
+   * @returns {Promise<string|null>}
+   */
+  askSelect(title, options, initial = 0) {
+    this.selectMode = true;
+    this.selectOptions = Array.isArray(options) ? options : [];
+    this.selectIndex = Math.max(0, Math.min(initial, this.selectOptions.length - 1));
+    this.prompt = title;
+    this.menuEnabled = false;
+    this.hint = "";
+    this.buffer = "";
+    this.cursor = 0;
+    this.active = true;
+    this.renderedRows = 0;
+    this.output.write("\x1b[?25l");
+    this.render();
+    return new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+
+  chooseSelect() {
+    const option = this.selectOptions[this.selectIndex];
+    this.selectMode = false;
+    this.selectOptions = [];
+    this.settle(option === undefined ? null : option.value);
+  }
+
+  cancelSelect() {
+    if (!this.selectMode) return;
+    this.selectMode = false;
+    this.selectOptions = [];
+    this.settle(null);
+  }
+
+  // ---- input --------------------------------------------------------------
+  handleData(chunk) {
+    for (const char of String(chunk)) {
+      if (this.escape !== null) {
+        if (this.escape === "\x1b" && char !== "[" && char !== "O") {
+          // Lone Esc (not a CSI/SS3 sequence).
+          this.escape = null;
+          if (this.selectMode) this.cancelSelect();
+          else if (this.active) {
+            this.hint = "";
+            this.menu = [];
+            this.render();
+          }
+          continue;
+        }
+        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.selectMode) {
+      if (char === "\r" || char === "\n") this.chooseSelect();
+      else if (char === "\x03" || char === "\x04") this.cancelSelect();
+      return;
+    }
+    if (this.paste) {
+      if (char === "\x1b") this.escape = "\x1b";
+      else this.insert(char === "\n" ? " " : char);
+      return;
+    }
+    this.hint = "";
+    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;
+    if (sequence === "\x1b[Z") {
+      // Shift+Tab: cycle a mode (permission preset) while keeping the line.
+      if (this.selectMode) return;
+      this.hint = this.onShiftTab?.() ?? "";
+      return;
+    }
+    if (this.selectMode) {
+      if (sequence === "\x1b[A") {
+        this.selectIndex = (this.selectIndex - 1 + this.selectOptions.length) % Math.max(1, this.selectOptions.length);
+      } else if (sequence === "\x1b[B") {
+        this.selectIndex = (this.selectIndex + 1) % Math.max(1, this.selectOptions.length);
+      }
+      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.selectMode = false;
+    this.selectOptions = [];
+    this.hint = "";
+    this.clearRender();
+    this.menu = [];
+    this.output.write("\x1b[?25h");
+    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;
+    if (this.selectMode) {
+      this.renderSelect();
+      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;
+    let rows = 0;
+    if (this.menu.length > 0) {
+      const nameWidth = Math.min(18, Math.max(...this.menu.map((item) => item.name.length)) + 1);
+      for (let index = 0; index < this.menu.length; 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);
+      }
+      rows = this.menu.length;
+    }
+    if (this.hint !== "") {
+      this.output.write(`\n  \x1b[2m${clean(this.hint)}\x1b[22m`);
+      rows += 1;
+    }
+    if (rows > 0) this.output.write(`\x1b[${rows}A`);
+    this.renderedRows = rows;
+    this.output.write(`\x1b[${column + 1}G`);
+  }
+
+  renderSelect() {
+    this.clearRender();
+    const columns = Math.max(40, this.columns() || 80);
+    this.output.write(this.prompt);
+    const options = this.selectOptions;
+    const rows = options.length;
+    for (let index = 0; index < rows; index += 1) {
+      const option = options[index];
+      const selected = index === this.selectIndex;
+      const marker = selected ? "❯" : " ";
+      const label = clean(option.label ?? option.value ?? "");
+      const description = option.description ? `  \x1b[2m${clean(option.description)}\x1b[22m` : "";
+      const line = `  ${marker} ${selected ? `\x1b[36m${label}\x1b[39m` : label}${description}`;
+      this.output.write("\n" + line.slice(0, columns + 16));
+    }
+    if (rows > 0) this.output.write(`\x1b[${rows}A`);
+    this.renderedRows = rows;
+    this.output.write(`\x1b[${visibleWidth(this.prompt) + 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";
@@ -493,6 +494,41 @@ function printBanner(model) {
   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) {
   write(`deepseek ${VERSION} — DeepSeek Harness in your terminal.
 
@@ -511,9 +547,9 @@ Interactive commands:
   /new               start a fresh session
   /sessions          list recent sessions in this directory
   /resume <id>       switch to another session
-  /model [id]        show or switch the model (e.g. /model deepseek-v4-pro)
-  /reasoning [off|high|max]   show or set the reasoning effort
-  /permissions [p]   show or switch the permission preset (native: /permission)
+  /model [id]        pick a model, or pass an id directly
+  /reasoning [off|high|max]   pick a reasoning effort
+  /permissions [p]   pick a permission mode (native: /permission; Shift+Tab cycles)
   /skills            list the skills discovered in this workspace
   /jobs              list this session's background jobs
   /todos             show the current todo list
@@ -528,6 +564,12 @@ Interactive commands:
 Harness commands (shared with the Web and Desktop apps):
   /compact, /goal, /plan, and any command a plugin registers.
   Type /help inside a session to see the live list.
+
+Keyboard:
+  Shift+Tab          cycle the permission mode (workspace-write, read-only, …)
+  Ctrl+C             interrupt a running turn; twice exits
+  ↑/↓                history (or move in the / command menu)
+  Tab                complete the highlighted / command
 `);
 }
 
@@ -601,6 +643,7 @@ async function run(ctx, options, exit) {
   const permissionPresets = ctx.get("permissionPresets");
   const attachments = ctx.get("attachments");
   const tokenMeter = ctx.get("tokenMeter");
+  const llm = ctx.get("llm");
 
   if (options.list) {
     printSessionList(listSessions());
@@ -616,6 +659,7 @@ async function run(ctx, options, exit) {
   const autoYes = options.yes || process.env.DSH_CLI_YES === "1";
 
   let handle = null;
+  let activeAgent = null;
   let busy = false;
   let quitting = false;
   let cancelSent = false;
@@ -631,17 +675,32 @@ 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(),
+        onShiftTab: () => cyclePermission(),
+        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) {
@@ -650,8 +709,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 {
@@ -672,12 +737,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);
@@ -711,6 +780,7 @@ async function run(ctx, options, exit) {
 
   function closeInput() {
     try {
+      editor?.stop();
       rlInterface?.close();
     } catch {}
   }
@@ -888,6 +958,7 @@ async function run(ctx, options, exit) {
           setup,
         });
     handle = created;
+    activeAgent = created.agent;
     wire(created.agent);
     await created.agent.whenIdle();
     return created.agent;
@@ -935,6 +1006,73 @@ async function run(ctx, options, exit) {
     return `${current.provider}/${current.model}${current.reasoningEffort ? ` · ${current.reasoningEffort}` : ""}`;
   };
 
+  // ---- permission state, pickers, status bar ------------------------------
+  function currentPermission() {
+    try {
+      if (permissionPresets !== undefined && activeAgent !== null) return permissionPresets.current(activeAgent.session);
+    } catch {}
+    return "workspace-write";
+  }
+
+  /** Shift+Tab: cycle the sandbox/approval preset and return a hint label. */
+  function cyclePermission() {
+    try {
+      if (permissionPresets === undefined || activeAgent === null) return "";
+      const options = permissionPresets.catalog().options.map((option) => option.value);
+      if (options.length === 0) return "";
+      const current = currentPermission();
+      const next = options[(Math.max(0, options.indexOf(current)) + 1) % options.length];
+      permissionPresets.set(activeAgent.session, next);
+      return `⏵⏵ ${next} (shift+tab to cycle)`;
+    } catch {
+      return "";
+    }
+  }
+
+  /** Permanent one-line footer above the prompt. */
+  function printStatusBar() {
+    if (!tty || !interactive) return;
+    out(paint(ansi.dim, `  ⏵⏵ ${sanitize(currentPermission())} · ${sanitize(modelDesc())} · shift+tab to cycle`) + "\n");
+  }
+
+  /** One list picker shared by /model, /reasoning, /permissions, /resume. */
+  async function selectOption(title, options, initial = 0) {
+    if (options.length === 0) return null;
+    if (editor) {
+      printStatusBar();
+      return editor.askSelect(paint(ansi.bold, `  ${title}`), options, initial);
+    }
+    out(`\n  ${sanitize(title)}\n`);
+    options.forEach((option, index) => {
+      out(`   ${index + 1}) ${sanitize(option.label)}${option.description ? paint(ansi.dim, ` — ${sanitize(option.description)}`) : ""}\n`);
+    });
+    const answer = await ask(paint(ansi.green, "  choose: "));
+    const index = Number.parseInt(answer ?? "", 10) - 1;
+    return options[index]?.value ?? null;
+  }
+
+  async function applyModelSelection(modelId) {
+    const next = { ...selectionRef.current, model: modelId };
+    try {
+      await defaultModel.saveSelection(next);
+      selectionRef.current = next;
+      out(paint(ansi.green, `  ✓ model set: ${sanitize(next.provider)}/${sanitize(next.model)} (next message)\n`));
+    } catch (error) {
+      out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
+    }
+  }
+
+  async function applyReasoningSelection(effort) {
+    const next = { ...selectionRef.current, reasoningEffort: effort === "default" ? undefined : effort };
+    try {
+      await defaultModel.saveSelection(next);
+      selectionRef.current = next;
+      out(paint(ansi.green, `  ✓ reasoning set: ${sanitize(effort)} (next message)\n`));
+    } catch (error) {
+      out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
+    }
+  }
+
   // ---- parity helpers -----------------------------------------------------
   const transcript = [];
   const pendingImages = [];
@@ -1150,7 +1288,9 @@ async function run(ctx, options, exit) {
   }
 
   while (!quitting) {
-    const line = await ask(paint(ansi.bold, "> "));
+    printStatusBar();
+    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;
@@ -1181,13 +1321,27 @@ async function run(ctx, options, exit) {
           printSessionList(listSessions(), write);
           continue;
         case "/resume": {
-          if (argument === "") {
-            out(paint(ansi.yellow, "  usage: /resume <session-id> (see /sessions)\n"));
-            continue;
+          let target = argument;
+          if (target === "") {
+            const sessions = listSessions();
+            if (sessions.length === 0) {
+              out(paint(ansi.yellow, "  no sessions in this directory yet\n"));
+              continue;
+            }
+            target = await selectOption(
+              "Resume session",
+              sessions.slice(0, 10).map((session) => ({
+                label: session.id,
+                description: timeAgo(session.mtime) + (session.openTurn ? " · running" : ""),
+                value: session.id,
+              })),
+              0
+            );
+            if (target === null) continue;
           }
           try {
-            out(paint(ansi.dim, `  ↻ resuming ${argument}\n`));
-            agent = await startAgent(undefined, argument);
+            out(paint(ansi.dim, `  ↻ resuming ${sanitize(target)}\n`));
+            agent = await startAgent(undefined, target);
           } catch (error) {
             out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
@@ -1211,33 +1365,45 @@ async function run(ctx, options, exit) {
           continue;
         }
         case "/model": {
-          if (argument === "") {
-            out(paint(ansi.dim, `  model: ${modelDesc()}\n`));
+          if (argument !== "") {
+            await applyModelSelection(argument);
             continue;
           }
-          const next = { ...selectionRef.current, model: argument };
+          let models = [];
           try {
-            await defaultModel.saveSelection(next);
-            selectionRef.current = next;
-            out(paint(ansi.green, `  ✓ model set: ${next.provider}/${next.model} (next message)\n`));
-          } catch (error) {
-            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
+            models = llm === undefined ? [] : await llm.listModels(selectionRef.current.provider);
+          } catch {}
+          if (models.length === 0) {
+            out(paint(ansi.dim, `  model: ${sanitize(modelDesc())}`) + "\n");
+            out(paint(ansi.dim, "  no model list is discoverable here — use /model <id>\n"));
+            continue;
           }
+          const currentIndex = Math.max(0, models.findIndex((model) => model.id === selectionRef.current.model));
+          const chosen = await selectOption(
+            "Select model",
+            models.map((model) => ({ label: model.name || model.id, description: model.id, value: model.id })),
+            currentIndex
+          );
+          if (chosen !== null) await applyModelSelection(chosen);
           continue;
         }
         case "/reasoning": {
-          if (argument === "") {
-            out(paint(ansi.dim, `  reasoning: ${selectionRef.current.reasoningEffort ?? "default"}\n`));
+          if (argument !== "") {
+            await applyReasoningSelection(argument);
             continue;
           }
-          const next = { ...selectionRef.current, reasoningEffort: argument === "default" ? undefined : argument };
-          try {
-            await defaultModel.saveSelection(next);
-            selectionRef.current = next;
-            out(paint(ansi.green, `  ✓ reasoning set: ${argument} (next message)\n`));
-          } catch (error) {
-            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
-          }
+          const efforts = ["off", "high", "max", "default"];
+          const current = selectionRef.current.reasoningEffort ?? "default";
+          const chosen = await selectOption(
+            "Select reasoning effort",
+            efforts.map((effort) => ({
+              label: effort,
+              description: effort === "default" ? "provider default" : `effort: ${effort}`,
+              value: effort,
+            })),
+            Math.max(0, efforts.indexOf(current))
+          );
+          if (chosen !== null) await applyReasoningSelection(chosen);
           continue;
         }
         case "/thinking": {
@@ -1319,19 +1485,25 @@ async function run(ctx, options, exit) {
             continue;
           }
           try {
-            const catalog = permissionPresets.catalog();
-            if (argument === "") {
-              out(paint(ansi.bold, "Permission presets:") + "\n");
-              for (const option of catalog.options) {
-                out(`  ${paint(ansi.cyan, option.value.padEnd(18))} ${option.name}${option.description ? paint(ansi.dim, ` — ${option.description}`) : ""}\n`);
-              }
-              out(paint(ansi.dim, `  default: ${catalog.defaultPreset}`) + "\n");
-            } else {
+            if (argument !== "") {
               permissionPresets.set(agent.session, argument);
-              out(paint(ansi.green, `  ✓ permissions: ${argument} (applies to the next tool call)\n`));
+              out(paint(ansi.green, `  ✓ permission mode: ${sanitize(argument)}\n`));
+              continue;
+            }
+            const catalog = permissionPresets.catalog();
+            const options = catalog.options.map((option) => ({
+              label: option.value === catalog.defaultPreset ? `${option.value} (default)` : option.value,
+              description: option.description || option.name,
+              value: option.value,
+            }));
+            const initial = Math.max(0, options.findIndex((option) => option.value === currentPermission()));
+            const chosen = await selectOption("Permission mode", options, initial);
+            if (chosen !== null) {
+              permissionPresets.set(agent.session, chosen);
+              out(paint(ansi.green, `  ✓ permission mode: ${sanitize(chosen)}\n`));
             }
           } catch (error) {
-            out(paint(ansi.red, `  ✘ ${describeError(error)}\n`));
+            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
           continue;
         }