agent.libx.js 0.87.3 → 0.89.1

package/dist/cli.js

@@ -2482,6 +2482,30 @@ function checkSyntax(path, content) {
   }
 }
 
+// src/reasoning.ts
+var BUDGET = { low: 2048, medium: 8192, high: 24576 };
+function toLabel(effort) {
+  if (typeof effort !== "number") return effort === "off" ? "low" : effort;
+  return effort <= BUDGET.low ? "low" : effort < BUDGET.high ? "medium" : "high";
+}
+function toBudget(effort) {
+  return typeof effort === "number" ? effort : BUDGET[effort];
+}
+function reasoningToChatFragment(model, effort) {
+  if (effort == null || effort === "off") return {};
+  const provider = model.split("/")[0];
+  switch (provider) {
+    case "anthropic": {
+      const budget = toBudget(effort);
+      return { providerOptions: { thinking: { type: "enabled", budget_tokens: budget } }, maxTokens: budget + 8192 };
+    }
+    case "openai":
+      return { providerOptions: { reasoning_effort: toLabel(effort) } };
+    default:
+      return {};
+  }
+}
+
 // src/Agent.ts
 var log3 = forComponent("Agent");
 var AgentOptions = class {
@@ -2559,6 +2583,10 @@ var AgentOptions = class {
   autoTest;
   /** Provider-specific options forwarded to ai.chat() (e.g. cursor mcpServers, cwd). */
   providerOptions;
+  /** Extended-thinking / reasoning effort, normalized across providers (anthropic, openai).
+   *  `'off'`/undefined = none; `'low'|'medium'|'high'` or a raw token budget. Mapped to the
+   *  provider-specific request shape via {@link reasoningToChatFragment}; explicit `providerOptions` wins. */
+  reasoning;
 };
 var Agent = class _Agent {
   options;
@@ -2574,6 +2602,12 @@ var Agent = class _Agent {
   // the assembled system prompt from the last prepare()
   started = false;
   // session-start lifecycle hook fires once per conversation
+  /** Force the next `send()`/`run()` to rebuild the system prompt, tools, plan-mode and permission hooks
+   *  from `options` — apply mid-conversation changes to `planMode`/`permissions`/`model` etc. (prepare()
+   *  is otherwise memoized per conversation). */
+  reprepare() {
+    this.prepared = false;
+  }
   /** Inject tools into a running agent (e.g. dynamically mounted MCP servers). Takes effect on the next turn. */
   addTools(tools) {
     this.activeTools.push(...tools);
@@ -2755,12 +2789,17 @@ var Agent = class _Agent {
       steps++;
       let res;
       const sent = this.trimContext();
+      const frag = reasoningToChatFragment(o.model, o.reasoning);
+      const reasonOpts = {
+        ...frag,
+        ...o.providerOptions ? { providerOptions: { ...frag.providerOptions, ...o.providerOptions } } : {}
+      };
       try {
         if (useStream) {
-          const r = await o.ai.chat({ model: o.model, messages: sent, tools: wireTools, stream: true, signal: o.signal, providerOptions: o.providerOptions });
+          const r = await o.ai.chat({ model: o.model, messages: sent, tools: wireTools, stream: true, signal: o.signal, ...reasonOpts });
           res = await this.consumeStream(r);
         } else {
-          const r = await o.ai.chat({ model: o.model, messages: sent, tools: wireTools, stream: false, signal: o.signal, providerOptions: o.providerOptions });
+          const r = await o.ai.chat({ model: o.model, messages: sent, tools: wireTools, stream: false, signal: o.signal, ...reasonOpts });
           res = r;
         }
       } catch (err2) {
@@ -3881,6 +3920,7 @@ The filesystem root '/' is the real machine root \u2014 you have full filesystem
       return [...filtered, ...realShell, ...o.extraTools ?? []];
     })(),
     maxSteps: o.maxSteps ?? 30,
+    ...o.reasoning != null ? { reasoning: o.reasoning } : {},
     stream: o.stream ?? false,
     host: o.host,
     hooks,
@@ -3947,6 +3987,10 @@ function loadSettings(dir) {
     if (raw.mcpServers && typeof raw.mcpServers === "object") cfg.mcpServers = raw.mcpServers;
     if (raw.permissions && typeof raw.permissions === "object") cfg.permissions = raw.permissions;
     if (raw.model && typeof raw.model === "string") cfg.model = raw.model;
+    if (raw.reasoning != null) cfg.reasoning = raw.reasoning;
+    if (raw.permissionMode === "default" || raw.permissionMode === "acceptEdits" || raw.permissionMode === "plan") cfg.permissionMode = raw.permissionMode;
+    if (raw.editorMode === "normal" || raw.editorMode === "vim") cfg.editorMode = raw.editorMode;
+    if (typeof raw.stream === "boolean") cfg.stream = raw.stream;
     if (raw.env && typeof raw.env === "object") {
       for (const [k, v] of Object.entries(raw.env)) {
         if (typeof v === "string" && !process.env[k]) process.env[k] = v;
@@ -4597,12 +4641,13 @@ function completePath(listDir, ref) {
 import { emitKeypressEvents } from "readline";
 var visibleWidth = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length;
 var EditorState = class _EditorState {
-  // placeholder → full pasted content
-  constructor(suggest, history = [], classifyPaste, onEmptyPaste) {
+  // pending operator awaiting a motion (dd/dw/cc)
+  constructor(suggest, history = [], classifyPaste, onEmptyPaste, vimEnabled = false) {
     this.suggest = suggest;
     this.history = history;
     this.classifyPaste = classifyPaste;
     this.onEmptyPaste = onEmptyPaste;
+    if (vimEnabled) this.vim = "insert";
   }
   suggest;
   history;
@@ -4629,6 +4674,24 @@ var EditorState = class _EditorState {
   pasteBuf = "";
   pasteSeq = 0;
   pastes = /* @__PURE__ */ new Map();
+  // placeholder → full pasted content
+  // Vim modal editing (opt-in): undefined = emacs/readline keymap; else 'insert'|'normal'.
+  vim;
+  vimOp;
+  /** The most-recent history entry that EXTENDS the current buffer — the inline ghost-suggestion suffix.
+   *  Empty unless the buffer is a single non-empty line with the cursor at its end and no menu/search open. */
+  ghost() {
+    if (!this.buf || this.cursor !== this.buf.length || this.menuOpen || this.searching || this.buf.includes("\n")) return "";
+    for (const h of this.history) if (h.length > this.buf.length && h.startsWith(this.buf)) return h.slice(this.buf.length);
+    return "";
+  }
+  /** Accept the ghost suggestion (append its remainder). Returns false when there's nothing to accept. */
+  acceptGhost() {
+    const g = this.ghost();
+    if (!g) return false;
+    this.insert(g);
+    return true;
+  }
   /** Collapse pastes that would break the single-line editor (multi-line) or flood it (≥ this many chars). */
   static PASTE_INLINE_MAX = 800;
   beginPaste() {
@@ -4882,11 +4945,119 @@ var EditorState = class _EditorState {
     this.searchQuery = "";
     this.pastes.clear();
     this.closeMenu();
+    this.vimOp = void 0;
+    if (this.vim) this.vim = "insert";
   }
 };
 var REWIND = "\0REWIND";
+function applyVimNormal(s, key, str) {
+  const k = key?.name;
+  if (key?.ctrl || key?.meta) return "pass";
+  if (k === "return" || k === "enter") return "pass";
+  if (k === "escape") {
+    s.vimOp = void 0;
+    return "pass";
+  }
+  const op = s.vimOp;
+  s.vimOp = void 0;
+  if (op) {
+    if (str === "d" && op === "d") s.killToStart(), s.killToEnd();
+    else if (str === "c" && op === "c") {
+      s.killToStart();
+      s.killToEnd();
+      s.vim = "insert";
+    } else if (str === "w") {
+      s.killWordForward();
+      while (s.buf[s.cursor] === " ") s.del();
+      if (op === "c") s.vim = "insert";
+    }
+    return "none";
+  }
+  switch (str) {
+    case "i":
+      s.vim = "insert";
+      return "none";
+    case "a":
+      s.right();
+      s.vim = "insert";
+      return "none";
+    case "A":
+      s.end();
+      s.vim = "insert";
+      return "none";
+    case "I":
+      s.home();
+      s.vim = "insert";
+      return "none";
+    case "o":
+      s.end();
+      s.insert("\n");
+      s.vim = "insert";
+      return "none";
+    case "h":
+      s.left();
+      return "none";
+    case "l":
+      s.right();
+      return "none";
+    case "0":
+      s.home();
+      return "none";
+    case "$":
+      s.end();
+      return "none";
+    case "w":
+    case "e":
+      s.wordRight();
+      return "none";
+    case "b":
+      s.wordLeft();
+      return "none";
+    case "x":
+      s.del();
+      return "none";
+    case "D":
+      s.killToEnd();
+      return "none";
+    case "C":
+      s.killToEnd();
+      s.vim = "insert";
+      return "none";
+    case "d":
+      s.vimOp = "d";
+      return "none";
+    case "c":
+      s.vimOp = "c";
+      return "none";
+  }
+  if (k === "left") {
+    s.left();
+    return "none";
+  }
+  if (k === "right") {
+    s.right();
+    return "none";
+  }
+  if (k === "up") {
+    s.historyPrev();
+    return "none";
+  }
+  if (k === "down") {
+    s.historyNext();
+    return "none";
+  }
+  if (k === "backspace") {
+    s.left();
+    return "none";
+  }
+  return "none";
+}
 function applyKey(s, key, str) {
   const k = key?.name;
+  if (s.vim === "normal" && !s.pasting && !s.searching) {
+    const r = applyVimNormal(s, key ?? {}, str);
+    if (r !== "pass") return r;
+  }
   if (k === "paste-start") {
     s.beginPaste();
     return "none";
@@ -4965,13 +5136,23 @@ function applyKey(s, key, str) {
       }
       return "submit";
     case "tab":
-      if (s.menuOpen) s.accept();
+      if (s.menuOpen) {
+        s.accept();
+        return "none";
+      }
+      if (s.acceptGhost()) return "none";
       return "none";
+    // menu accept, else accept history ghost
     case "escape":
       if (s.menuOpen) {
         s.closeMenu();
         return "none";
       }
+      if (s.vim === "insert") {
+        s.vim = "normal";
+        return "none";
+      }
+      if (s.vim === "normal" && s.buf.length) return "none";
       if (s.buf.length) return "cancel";
       if (wasEsc) return "rewind";
       s.prevEsc = true;
@@ -4987,8 +5168,10 @@ function applyKey(s, key, str) {
       s.left();
       return "none";
     case "right":
+      if (s.cursor === s.buf.length && s.acceptGhost()) return "none";
       s.right();
       return "none";
+    // at EOL → accept ghost
     case "home":
       s.home();
       return "none";
@@ -5022,13 +5205,16 @@ function createLineEditor(out) {
   function render(s, promptArg, maxVisible, status) {
     const cols = out.columns ?? 80;
     const mode = !s.searching ? inputMode(s.buf) : void 0;
-    const prompt = s.searching ? dim2(`(${s.searchMiss ? "failing " : ""}reverse-i-search)\`${s.searchQuery}': `) : mode ? COLOR[mode.name](`${mode.pfx} ${mode.name} \u203A `) : promptArg;
+    const vimTag = s.vim === "normal" && !s.searching && !mode ? inverse(" N ") + " " : "";
+    const prompt = s.searching ? dim2(`(${s.searchMiss ? "failing " : ""}reverse-i-search)\`${s.searchQuery}': `) : mode ? COLOR[mode.name](`${mode.pfx} ${mode.name} \u203A `) : vimTag + promptArg;
     if (curRow > 0) out.write(`\x1B[${curRow}A`);
     out.write("\r\x1B[J");
     const viewBuf = mode ? s.buf.slice(mode.pfx.length) : s.buf;
     const viewCursor = mode ? Math.max(0, s.cursor - mode.pfx.length) : s.cursor;
     const { rows, cursorRow, cursorCol } = wrapLayout(visibleWidth(prompt), viewBuf, viewCursor, cols);
-    out.write(prompt + (rows[0] ?? ""));
+    const ghost = !mode && !s.searching ? s.ghost() : "";
+    const ghostFits = ghost && rows.length === 1 && visibleWidth(prompt) + viewBuf.length + ghost.length < cols;
+    out.write(prompt + (rows[0] ?? "") + (ghostFits ? dim2(ghost) : ""));
     for (let i = 1; i < rows.length; i++) out.write("\r\n" + rows[i]);
     const inputRows = rows.length - 1;
     let menuRows = 0;
@@ -5059,7 +5245,7 @@ function createLineEditor(out) {
   async function readLine(opts) {
     const maxVisible = opts.maxVisible ?? 8;
     if (!isTTY) return readPlainLine();
-    const s = new EditorState(opts.suggest, opts.history ?? [], opts.classifyPaste, opts.onEmptyPaste);
+    const s = new EditorState(opts.suggest, opts.history ?? [], opts.classifyPaste, opts.onEmptyPaste, opts.vimMode);
     curRow = 0;
     if (opts.initial) s.insert(opts.initial);
     s.refresh();
@@ -5074,11 +5260,31 @@ function createLineEditor(out) {
     };
     process.on("SIGWINCH", onResize);
     return new Promise((resolve4) => {
+      const redraw = () => render(s, opts.prompt, maxVisible, opts.status);
       const onKey = (str, key) => {
         if (key?.ctrl && key.name === "l") {
           out.write("\x1B[2J\x1B[3J\x1B[H");
           curRow = 0;
-          render(s, opts.prompt, maxVisible, opts.status);
+          redraw();
+          return;
+        }
+        if (key?.name === "tab" && key.shift && opts.onCyclePosture) {
+          opts.onCyclePosture();
+          redraw();
+          return;
+        }
+        if (key?.meta && key.name === "t" && opts.onToggleThinking) {
+          opts.onToggleThinking();
+          redraw();
+          return;
+        }
+        if (key?.meta && key.name === "p" && opts.onPickModel) {
+          process.stdin.off("keypress", onKey);
+          void opts.onPickModel().finally(() => {
+            process.stdin.on("keypress", onKey);
+            curRow = 0;
+            redraw();
+          });
           return;
         }
         const action = applyKey(s, key ?? {}, str);
@@ -5452,6 +5658,12 @@ function numFlag(raw, flag) {
   if (!Number.isFinite(n) || n < 0) throw new Error(`invalid ${flag}: ${raw ?? "(missing value)"}`);
   return n;
 }
+function parseReasoning(raw) {
+  if (raw === "off" || raw === "low" || raw === "medium" || raw === "high") return raw;
+  const n = Number(raw);
+  if (Number.isFinite(n) && n > 0) return n;
+  throw new Error(`invalid --reasoning: ${raw} (use off|low|medium|high or a token budget)`);
+}
 function parseArgs(argv) {
   const a = { stream: true, plan: false, ask: false, yes: false, vfs: false, shell: void 0, seed: false, subagents: false, help: false, version: false, cont: false, outputFormat: "text" };
   const rest = [];
@@ -5489,6 +5701,9 @@ function parseArgs(argv) {
     else if (x === "--disallowedTools" || x === "--disallowed-tools") a.disallowedTools = val(++i, x).split(",").map((s) => s.trim()).filter(Boolean);
     else if (x === "--append-system-prompt") a.appendSystemPrompt = val(++i, x);
     else if (x === "--add-dir") (a.addDirs ??= []).push(val(++i, x));
+    else if (x === "--reasoning") a.reasoning = parseReasoning(val(++i, x));
+    else if (x === "--session-id") a.sessionId = val(++i, x);
+    else if (x === "--fork-session") a.fork = true;
     else if (x === "--max-steps") a.maxSteps = numFlag(argv[++i], "--max-steps");
     else if (x === "--max-tokens") a.maxTokens = numFlag(argv[++i], "--max-tokens");
     else if (x === "--timeout") a.timeoutMs = numFlag(argv[++i], "--timeout") * 1e3;
@@ -5532,6 +5747,9 @@ Flags:
   --append-system-prompt <t>  extra instructions appended to the system prompt for this run
   --add-dir <path>     mount another directory into the workspace (repeatable; disk mode only)
   --subagents          allow the Task tool (spawn child agents)
+  --reasoning <e>      extended thinking: off|low|medium|high or a token budget (anthropic/openai)
+  --session-id <id>    use this id for the session (instead of an auto-generated one)
+  --fork-session       with -r/-c: branch the resumed session into a new id (source left untouched)
   --max-steps <n>      step budget (default 30)
   --max-tokens <n>     token budget kill-switch (default 200000)
   --timeout <sec>      wall-clock kill-switch (default 120)
@@ -5543,7 +5761,7 @@ Prompts may reference files with @path (e.g. "explain @src/Agent.ts") \u2014 the
 
 Providers: set any of ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY / GROQ_API_KEY.
 Config: ./.agent/config.{ts,js,json} (project) or ~/.agent/config.* (user).
-  export default { model, maxSteps, tools, apiKeys, baseUrls, hooks, permissions, mcpServers, maxTokens,
+  export default { model, maxSteps, reasoning, permissionMode, editorMode, tools, apiKeys, baseUrls, hooks, permissions, mcpServers, maxTokens,
                    timeoutMs, maxRepeats, maxToolCalls, keepToolOutputs, maxContextTokens,
                    learnFromMistakes, reflectOnFailure, budget: {\u2026} }
   hooks: { preToolUse|postToolUse|onStop: [{ tool?, command, block? }] } \u2014 shell hooks
@@ -5556,10 +5774,11 @@ Project instructions: ./AGENTS.md or ./CLAUDE.md are auto-loaded (scaffold with
 Auto-loaded from ./.agent/: commands/, skills/, memory/, agents/.
 
 REPL shortcuts: !<cmd> runs a shell command inline \xB7 #<note> saves a memory \xB7 @path inlines a file
-REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /exit
+REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /exit
 REPL completion: type / (commands+skills) or @ (files) for a LIVE menu \u2014 \u2191/\u2193 select, \u23CE/Tab accept, Esc dismiss.
 REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to continue. Esc cancels a running turn / clears the input line; double-Esc jumps back to edit a previous message.
-REPL editing (emacs/readline): Ctrl-A/E line start/end \xB7 Ctrl-B/F char \xB7 Alt-B/F or Alt/Ctrl-\u2190/\u2192 word \xB7 Ctrl-W kill word \xB7 Ctrl-U/K kill to start/end \xB7 Ctrl-Y yank \xB7 Alt-D kill word fwd \xB7 Ctrl-L clear screen.
+REPL shortcuts: Shift+Tab cycles permission posture (ask \u2192 accept-edits \u2192 plan) \xB7 Alt+T toggles reasoning \xB7 Alt+P switches model \xB7 \u2192 or Tab accepts the dim history ghost-suggestion.
+REPL editing (emacs/readline): Ctrl-A/E line start/end \xB7 Ctrl-B/F char \xB7 Alt-B/F or Alt/Ctrl-\u2190/\u2192 word \xB7 Ctrl-W kill word \xB7 Ctrl-U/K kill to start/end \xB7 Ctrl-Y yank \xB7 Alt-D kill word fwd \xB7 Ctrl-L clear screen. Set editorMode:'vim' (or /config) for modal vim editing.
 REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; /paste grabs a clipboard image (macOS).`;
 function newestModel() {
   return listModels().slice().sort((a, b) => (getModelInfo(b)?.releaseDate ?? "").localeCompare(getModelInfo(a)?.releaseDate ?? ""))[0] ?? "";
@@ -5875,6 +6094,7 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
     permissions: rules.length ? new PermissionPolicy({ rules, default: "allow", host: makeHost(), ask: makeAskResolver(resolve3(args.cwd ?? process.cwd())) }) : void 0,
     subagents: args.subagents || cfg.subagents || false,
     maxSteps: args.maxSteps ?? cfg.maxSteps,
+    reasoning: args.reasoning ?? cfg.reasoning,
     // kill-switches: CLI flag > config > Agent default
     maxTokens: args.maxTokens ?? cfg.maxTokens,
     timeoutMs: args.timeoutMs ?? cfg.timeoutMs,
@@ -6069,6 +6289,14 @@ function startSession(args, store, agent, cwd) {
     const data = args.resume ? store.load(args.resume) : store.latestData();
     if (data) {
       agent.transcript = data.messages;
+      if (args.fork) {
+        const now2 = Date.now();
+        const forked = { meta: { ...data.meta, id: args.sessionId ?? store.newId(now2), created: now2, updated: now2, turns: data.meta.turns }, messages: data.messages };
+        err(dim(`  forked ${data.meta.id} \u2192 ${forked.meta.id} (${data.meta.turns} turns)
+`));
+        if (!args.task) printHistory(data.messages);
+        return forked;
+      }
       err(dim(`  resumed session ${data.meta.id} (${data.meta.turns} turns) \u2014 ${data.meta.title}
 `));
       if (!args.task) printHistory(data.messages);
@@ -6078,7 +6306,7 @@ function startSession(args, store, agent, cwd) {
 `));
   }
   const now = Date.now();
-  return { meta: { id: store.newId(now), created: now, updated: now, cwd, model: agent.options.model, turns: 0, title: "" }, messages: [] };
+  return { meta: { id: args.sessionId ?? store.newId(now), created: now, updated: now, cwd, model: agent.options.model, turns: 0, title: "" }, messages: [] };
 }
 var AGENTS_MD_TEMPLATE = `# ${"${name}"}
 
@@ -6109,23 +6337,56 @@ function initInstructions(cwd) {
   err(green(`  created ${path}
 `) + dim("  edit it, then it auto-loads into every run.\n"));
 }
-function persistModel(cwd, model) {
+function persistSetting(cwd, key, value) {
   const path = join8(cwd, ".agent", "settings.json");
   try {
     const obj = existsSync7(path) ? JSON.parse(readFileSync5(path, "utf8")) : {};
-    if (obj.model === model) return;
-    obj.model = model;
+    if (obj[key] === value) return;
+    obj[key] = value;
     mkdirSync6(dirname3(path), { recursive: true });
     writeFileSync6(path, JSON.stringify(obj, null, 2) + "\n");
   } catch (e) {
-    err(yellow(`  \u26A0 couldn't persist model to ${path} \u2014 ${e?.message ?? e}
+    err(yellow(`  \u26A0 couldn't persist ${key} to ${path} \u2014 ${e?.message ?? e}
 `));
   }
 }
+var persistModel = (cwd, model) => persistSetting(cwd, "model", model);
 async function repl(args, ai, cfg, cwd) {
   const oauth = new McpOAuth({ storePath: join8(cwd, ".agent", "mcp-auth.json") });
   const mounted = await mountMcp(cfg, oauth);
   const agent = await makeAgent(args, ai, cfg, mounted.flatMap((m) => m.tools));
+  const baseRules = () => [
+    ...parsePermRules({ deny: args.disallowedTools }),
+    ...parsePermRules({ allow: args.allowedTools }),
+    ...parsePermRules(mergePerms(loadPersistedRules(cwd), cfg.permissions))
+  ];
+  const askFor = (tools) => tools.map((t) => ({ tool: t, decision: "ask" }));
+  const POSTURES = ["default", "acceptEdits", "plan"];
+  let posture = args.plan || cfg.permissionMode === "plan" ? "plan" : cfg.permissionMode === "acceptEdits" ? "acceptEdits" : "default";
+  const postureLabel = () => posture === "default" ? "ask (default)" : posture === "acceptEdits" ? "accept edits" : "plan mode";
+  const applyPosture = (p) => {
+    posture = p;
+    const ask = p === "acceptEdits" ? askFor(["bash", "Shell"]) : askFor(ASK_MUTATING);
+    agent.options.permissions = new PermissionPolicy({ rules: [...baseRules(), ...ask], default: "allow", host: makeHost(), ask: makeAskResolver(cwd) });
+    agent.options.planMode = p === "plan";
+    agent.reprepare();
+  };
+  const cyclePosture = () => {
+    applyPosture(POSTURES[(POSTURES.indexOf(posture) + 1) % POSTURES.length]);
+    err(dim(`  \u21E5 ${postureLabel()}
+`));
+    return postureLabel();
+  };
+  if (!args.yes) applyPosture(posture);
+  const REASONING_CYCLE = ["off", "low", "medium", "high"];
+  const toggleReasoning = () => {
+    const cur = String(agent.options.reasoning ?? "off");
+    const next = REASONING_CYCLE[(Math.max(0, REASONING_CYCLE.indexOf(cur)) + 1) % REASONING_CYCLE.length];
+    agent.options.reasoning = next;
+    err(dim(`  ~ reasoning \u2192 ${next}
+`));
+    return next;
+  };
   const pendingImages = [];
   const grabClipboardAttachment = () => {
     const dir = join8(tmpdir(), "agentx-pasted");
@@ -6144,6 +6405,18 @@ async function repl(args, ai, cfg, cwd) {
     void closeMcp(mounted);
     process.exit(130);
   });
+  const isStreamTeardown = (e) => /NGHTTP2_FRAME_SIZE_ERROR|ERR_HTTP2_STREAM_ERROR/.test(`${e?.code ?? ""} ${e?.rawMessage ?? ""} ${e?.message ?? ""}`);
+  const onFatal = (kind) => (e) => {
+    if (isStreamTeardown(e)) {
+      log11.debug(`suppressed ${kind} (connect/HTTP-2 stream teardown on cancel)`, e);
+      return;
+    }
+    console.error(e);
+    void closeMcp(mounted);
+    process.exit(1);
+  };
+  process.on("unhandledRejection", onFatal("unhandledRejection"));
+  process.on("uncaughtException", onFatal("uncaughtException"));
   const store = new SessionStore(cwd);
   let session = startSession(args, store, agent, cwd);
   const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join8(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
@@ -6401,6 +6674,92 @@ ${extra}` : body, checkpoints, cwd);
         } else err(dim("  " + agent.options.model + "\n"));
       }
     },
+    reasoning: {
+      desc: "extended thinking \u2014 /reasoning <off|low|medium|high|tokens>, or alone for an interactive picker",
+      run: async (a) => {
+        const current = String(agent.options.reasoning ?? "off");
+        let next;
+        if (a[0]) {
+          try {
+            next = parseReasoning(a[0]);
+          } catch (e) {
+            err(yellow("  " + (e?.message ?? e) + "\n"));
+            return;
+          }
+        } else {
+          const items = [
+            { label: "off", value: "off", desc: "no extended thinking" },
+            { label: "low", value: "low", desc: "minimal reasoning (~2k tokens)" },
+            { label: "medium", value: "medium", desc: "balanced (~8k tokens)" },
+            { label: "high", value: "high", desc: "maximal reasoning (~24k tokens)" }
+          ];
+          const picked = await selectMenu(process.stderr, { title: `Reasoning effort \xB7 current: ${current}`, items, current });
+          if (!picked) {
+            err(dim("  " + current + "\n"));
+            return;
+          }
+          next = picked;
+        }
+        agent.options.reasoning = next;
+        if (next !== "off" && getModelInfo(agent.options.model)?.reasoning === false)
+          err(yellow(`  note: ${agent.options.model} has no reasoning capability \u2014 setting may be ignored
+`));
+        err(dim("  reasoning \u2192 " + next + "\n"));
+      }
+    },
+    config: {
+      desc: "view/change settings \u2014 model, reasoning, permission posture, streaming, editor mode",
+      run: async () => {
+        for (; ; ) {
+          const items = [
+            { label: "model", value: "model", desc: agent.options.model },
+            { label: "reasoning", value: "reasoning", desc: String(agent.options.reasoning ?? "off") },
+            { label: "permission posture", value: "posture", desc: postureLabel() + "  (Shift+Tab)" },
+            { label: "streaming", value: "stream", desc: agent.options.stream ? "on" : "off" },
+            { label: "editor mode", value: "editor", desc: cfg.editorMode === "vim" ? "vim" : "normal" }
+          ];
+          const pick = await selectMenu(process.stderr, { title: "Settings \xB7 \u21B5 change \xB7 esc close", items });
+          if (!pick) return;
+          if (pick === "model") {
+            const m = await pickModel(agent.options.model);
+            if (m) {
+              agent.options.model = m;
+              persistModel(cwd, m);
+            }
+          } else if (pick === "reasoning") {
+            await builtins.reasoning.run([]);
+            persistSetting(cwd, "reasoning", agent.options.reasoning ?? "off");
+          } else if (pick === "posture") {
+            cyclePosture();
+            persistSetting(cwd, "permissionMode", posture);
+          } else if (pick === "stream") {
+            agent.options.stream = !agent.options.stream;
+            persistSetting(cwd, "stream", agent.options.stream);
+            err(dim("  streaming \u2192 " + (agent.options.stream ? "on" : "off") + "\n"));
+          } else if (pick === "editor") {
+            cfg.editorMode = cfg.editorMode === "vim" ? "normal" : "vim";
+            persistSetting(cwd, "editorMode", cfg.editorMode);
+            err(dim("  editor \u2192 " + cfg.editorMode + "\n"));
+          }
+        }
+      }
+    },
+    rename: {
+      desc: "rename the current session \u2014 /rename <title>",
+      run: (a) => {
+        const t = a.join(" ").trim();
+        if (!t) {
+          err(dim("  title: " + (session.meta.title || "(none)") + "\n"));
+          return;
+        }
+        session.meta.title = t;
+        try {
+          store.save(session);
+        } catch {
+        }
+        err(dim("  renamed \u2192 " + t + "\n"));
+      }
+    },
     compact: {
       desc: "summarize older context to free up the window",
       run: () => {
@@ -6695,11 +7054,20 @@ ${extra}` : body, checkpoints, cwd);
     return { hits, token, describe };
   };
   const editor = createLineEditor(process.stderr);
+  let aborting = false;
+  let pendingRewind = false;
   if (process.stdin.isTTY) {
     process.stdin.on("keypress", (_s, key) => {
-      if (activeTurn && (key?.name === "escape" || key?.ctrl && key?.name === "c")) {
+      if (!activeTurn) return;
+      const cancel = key?.name === "escape" || key?.ctrl && key?.name === "c";
+      if (!cancel) return;
+      if (!aborting) {
+        aborting = true;
         activeTurn.abort();
         err(yellow("\n  \u238B cancelling\u2026\n"));
+      } else if (key?.name === "escape" && !pendingRewind) {
+        pendingRewind = true;
+        err(dim("  \u238B\u238B jumping back to edit\u2026\n"));
       }
     });
   }
@@ -6717,14 +7085,48 @@ ${extra}` : body, checkpoints, cwd);
   };
   let prefill;
   while (true) {
+    if (pendingRewind) {
+      pendingRewind = false;
+      const t = await rewindToMessage();
+      if (t !== void 0) prefill = t;
+    }
+    aborting = false;
     err("\n");
     const initial = prefill;
     prefill = void 0;
     const ctxTok = estimateTranscriptTokens(agent.transcript);
     const ctxCap = agent.options.maxTokens || 2e5;
     const usd = session.meta.costUsd ?? 0;
-    const footer = ctxTok > 400 || usd > 0 ? `${Math.round(ctxTok / ctxCap * 100)}% ctx (~${(ctxTok / 1e3).toFixed(1)}k/${Math.round(ctxCap / 1e3)}k)${usd > 0 ? ` \xB7 ${session.meta.costEstimated ? "~" : ""}${fmtUsd(usd)}` : ""}` : "";
-    const result = await readMultiline((cont) => editor.readLine({ prompt: cont ? contPrompt : promptStr, suggest, history, classifyPaste, onEmptyPaste: grabClipboardAttachment, initial: cont ? void 0 : initial, status: () => footer }));
+    const computeFooter = () => {
+      const parts = [];
+      if (ctxTok > 400) parts.push(`${Math.round(ctxTok / ctxCap * 100)}% ctx (~${(ctxTok / 1e3).toFixed(1)}k/${Math.round(ctxCap / 1e3)}k)`);
+      if (usd > 0) parts.push(`${session.meta.costEstimated ? "~" : ""}${fmtUsd(usd)}`);
+      if (posture !== "default") parts.push(postureLabel());
+      const r = agent.options.reasoning;
+      if (r && r !== "off") parts.push(`reasoning:${r}`);
+      return parts.join(" \xB7 ");
+    };
+    const result = await readMultiline((cont) => editor.readLine({
+      prompt: cont ? contPrompt : promptStr,
+      suggest,
+      history,
+      classifyPaste,
+      onEmptyPaste: grabClipboardAttachment,
+      initial: cont ? void 0 : initial,
+      status: computeFooter,
+      vimMode: cfg.editorMode === "vim",
+      onCyclePosture: cyclePosture,
+      onToggleThinking: toggleReasoning,
+      onPickModel: async () => {
+        const picked = await pickModel(agent.options.model);
+        if (picked) {
+          agent.options.model = picked;
+          persistModel(cwd, picked);
+          err(dim("  model \u2192 " + picked + "\n"));
+        }
+        return picked;
+      }
+    }));
     if (result === null) break;
     if (result === REWIND) {
       prefill = await rewindToMessage();