@wrongstack/tui 0.273.1 → 0.274.0

package/dist/index.js

@@ -1,9 +1,9 @@
 import { writeErr, resolveProjectDir, wstackGlobalRoot, createHqPublisherFromEnv, GlobalMailbox, resolveWstackPaths, loadGoal, InputBuilder, DefaultSessionRewinder, writeOut, formatTodosList, buildGoalPreamble, expectDefined as expectDefined$1, projectSlug, shouldEnhance, enhanceUserPrompt, recentTextTurns, normalizedEqual, buildChildEnv } from '@wrongstack/core';
 export { buildGoalPreamble } from '@wrongstack/core';
-import { Box as Box$1, useInput, useStdin, useStdout, Text as Text$1, render, useApp, measureElement, Static } from 'ink';
+import { Box as Box$1, useStdout, Static, measureElement, useInput, useStdin, Text as Text$1, render, useApp } from 'ink';
 import { randomUUID } from 'crypto';
 import * as path5 from 'path';
-import React5, { forwardRef, useState, useEffect, useMemo, memo, useRef, useCallback, useReducer, useLayoutEffect, isValidElement, Fragment as Fragment$1 } from 'react';
+import React5, { forwardRef, useState, useEffect, useMemo, memo, useRef, useLayoutEffect, useCallback, useReducer, isValidElement, Fragment as Fragment$1 } from 'react';
 import * as fs3 from 'fs/promises';
 import { expectDefined, toErrorMessage, resolveWstackPaths as resolveWstackPaths$1 } from '@wrongstack/core/utils';
 import { routeImagesForModel } from '@wrongstack/runtime/vision';
@@ -119,6 +119,32 @@ function useTokenCounterRefresh(tokenCounter, events) {
 // src/thinking-word.ts
 var DEFAULT_TUI_THINKING_WORD = "thinking";
 var MAX_TUI_THINKING_WORD_LENGTH = 16;
+var TUI_THINKING_WORD_POOL = [
+  "pondering",
+  "cogitating",
+  "ruminating",
+  "noodling",
+  "brewing",
+  "conjuring",
+  "percolating",
+  "scheming",
+  "tinkering",
+  "vibing",
+  "crafting",
+  "wrangling",
+  "summoning",
+  "finagling",
+  "marinating",
+  "hatching",
+  "juggling",
+  "spelunking",
+  "contemplating",
+  "bamboozling",
+  "alchemizing",
+  "incubating",
+  "doodling",
+  "mulling"
+];
 function normalizeTuiThinkingWord(value) {
   if (typeof value !== "string") return DEFAULT_TUI_THINKING_WORD;
   const word = value.trim();
@@ -128,6 +154,18 @@ function normalizeTuiThinkingWord(value) {
   if (!/^[\p{L}\p{N}_-]+$/u.test(word)) return DEFAULT_TUI_THINKING_WORD;
   return word;
 }
+function isRandomTuiThinkingWord(value) {
+  if (typeof value !== "string") return true;
+  const word = value.trim().toLowerCase();
+  return word.length === 0 || word === DEFAULT_TUI_THINKING_WORD || word === "random";
+}
+function pickRandomTuiThinkingWord(previous) {
+  const pool = TUI_THINKING_WORD_POOL;
+  const candidates = previous ? pool.filter((w) => w !== previous) : pool;
+  const list = candidates.length > 0 ? candidates : pool;
+  const idx = Math.floor(Math.random() * list.length);
+  return list[idx] ?? list[0] ?? DEFAULT_TUI_THINKING_WORD;
+}
 function chipExpired(meta, now = Date.now()) {
   if (meta.expiresIn == null) return false;
   return now >= meta.shownAt + meta.expiresIn * 6e4;
@@ -2477,10 +2515,84 @@ function helpSections() {
         { keys: "/fleet", desc: "multi-agent fleet controls" },
         { keys: "/goal", desc: "set an autonomous goal" },
         { keys: "/autonomy", desc: "autonomy mode (eternal / off)" },
-        { keys: "/settings", desc: "autonomy defaults (also Ctrl+S)" },
+        { keys: "/settings", desc: "settings picker (also: /settings <chord> <value> \xB7 /settings reset <chord>)" },
+        { keys: "/settings-get", desc: "show setting value(s) without opening picker" },
         { keys: "/clear", desc: "clear the conversation" }
       ]
     },
+    {
+      // Surface user-facing knobs that don't have a key chord or slash
+      // command of their own — the only way to change them is through the
+      // settings picker. Keeping the descriptions terse so the overlay
+      // fits in narrow terminals.
+      title: "Settings",
+      entries: [
+        {
+          keys: "Multi-diff summary",
+          desc: "min files before per-tool aggregate footer (Ctrl+M in picker, settings \u2192 tools, 0 = off, default 5)"
+        },
+        {
+          keys: "Index on session start",
+          desc: "run incremental index at startup (Ctrl+I in picker)"
+        },
+        {
+          keys: "Thinking word",
+          desc: "status-bar working word (Ctrl+W in picker; Enter to type your own)"
+        },
+        {
+          keys: "Refine countdown / Refine",
+          desc: "prompt refinement delay / on-off (Ctrl+R / Ctrl+E in picker)"
+        },
+        {
+          keys: "Reasoning mode",
+          desc: "auto / on / off (Ctrl+N in picker)"
+        },
+        {
+          keys: "Max concurrent",
+          desc: "parallel subagent cap (Ctrl+L in picker, settings \u2192 fleet)"
+        },
+        {
+          keys: "Statusline",
+          desc: "detailed / minimum density (Ctrl+D in picker)"
+        },
+        {
+          keys: "Default autonomy mode",
+          desc: "off / suggest / auto (Alt+A in picker, settings \u2192 autonomy)"
+        },
+        {
+          keys: "YOLO mode",
+          desc: "skip all confirmation prompts (Alt+Y in picker, settings \u2192 UX)"
+        },
+        {
+          keys: "Token-saving mode",
+          desc: "off / minimal / light / medium / aggressive (Alt+T in picker)"
+        },
+        {
+          keys: "Context mode",
+          desc: "balanced / frugal / deep / archival (Alt+X in picker, settings \u2192 context)"
+        },
+        {
+          keys: "Confirm before exit",
+          desc: "confirmation on Esc interrupt & Ctrl+C exit (Alt+S in picker, settings \u2192 UX)"
+        },
+        {
+          keys: "Completion chime",
+          desc: "play a sound when agent finishes (Alt+C in picker, settings \u2192 UX)"
+        },
+        {
+          keys: "Log level / Audit level",
+          desc: "console log verbosity / audit depth (Alt+Shift+L / Alt+Shift+A in picker, settings \u2192 logging)"
+        },
+        {
+          keys: "Stream debug logging",
+          desc: "hex-dump raw SSE bytes to stderr (Alt+Shift+B in picker, settings \u2192 debug)"
+        },
+        {
+          keys: "Config scope",
+          desc: "global / project (Alt+Shift+G in picker, settings \u2192 debug)"
+        }
+      ]
+    },
     {
       title: "Tool Colors",
       entries: toolColorLegend()
@@ -5017,6 +5129,61 @@ function CodeBlock({
     }
   );
 }
+var MULTI_DIFF_SUMMARY_THRESHOLD = 5;
+function summarizeMultiFileDiffs(items) {
+  let added = 0;
+  let removed = 0;
+  let hiddenAdded = 0;
+  let hiddenRemoved = 0;
+  let truncatedFiles = 0;
+  for (const item of items) {
+    added += item.preview.added;
+    removed += item.preview.removed;
+    hiddenAdded += item.preview.hiddenAdded;
+    hiddenRemoved += item.preview.hiddenRemoved;
+    if (item.preview.hidden > 0) truncatedFiles += 1;
+  }
+  return {
+    fileCount: items.length,
+    added,
+    removed,
+    hiddenAdded,
+    hiddenRemoved,
+    truncatedFiles
+  };
+}
+function formatMultiDiffSummary(summary, threshold = MULTI_DIFF_SUMMARY_THRESHOLD) {
+  if (threshold === 0) return null;
+  const effectiveThreshold = threshold < 0 ? MULTI_DIFF_SUMMARY_THRESHOLD : threshold;
+  if (summary.fileCount < effectiveThreshold) return null;
+  const parts = [`${summary.fileCount} files`];
+  if (summary.added > 0) parts.push(`+${summary.added}`);
+  if (summary.removed > 0) parts.push(`-${summary.removed}`);
+  if (summary.hiddenAdded > 0 || summary.hiddenRemoved > 0) {
+    const hiddenParts = [];
+    if (summary.hiddenAdded > 0) hiddenParts.push(`+${summary.hiddenAdded}`);
+    if (summary.hiddenRemoved > 0) hiddenParts.push(`-${summary.hiddenRemoved}`);
+    parts.push(`\u2026 ${hiddenParts.join(" ")} hidden across ${summary.truncatedFiles} file${summary.truncatedFiles === 1 ? "" : "s"}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function DiffFileBlock({
+  path: path7,
+  preview
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: path7 }),
+    /* @__PURE__ */ jsx(
+      DiffBlock,
+      {
+        rows: preview.rows,
+        hidden: preview.hidden,
+        hiddenAdded: preview.hiddenAdded,
+        hiddenRemoved: preview.hiddenRemoved
+      }
+    )
+  ] });
+}
 function DiffBlock({
   rows,
   hidden,
@@ -5154,20 +5321,167 @@ function extractDiffPreview(toolName, output, input) {
   } else if (toolName === "replace") {
     const parsed = tryParseJson(text);
     if (parsed && typeof parsed === "object") {
-      diff = collectReplaceDiffs(parsed);
+      diff = joinReplaceDiffs(parsed);
     }
   }
   if (!diff?.trim() || diff.startsWith("(no-op")) return void 0;
   const preview = parseUnifiedDiff(diff, DIFF_MAX_LINES);
   return preview.rows.length > 0 ? preview : void 0;
 }
-function collectReplaceDiffs(obj) {
-  const results = Array.isArray(obj["results"]) ? obj["results"] : [];
-  const diffs = results.map(
-    (result) => result && typeof result === "object" ? stringOf(result["diff"]) : void 0
-  ).filter((diff) => Boolean(diff?.trim()));
+function joinReplaceDiffs(obj) {
+  const items = splitReplaceDiffs(obj);
+  const diffs = items.map((item) => item.diff);
   return diffs.length > 0 ? diffs.join("\n") : void 0;
 }
+function splitReplaceDiffs(obj) {
+  const results = Array.isArray(obj["results"]) ? obj["results"] : [];
+  const items = [];
+  for (const result of results) {
+    if (!result || typeof result !== "object") continue;
+    const record = result;
+    const diff = stringOf(record["diff"]);
+    if (!diff?.trim()) continue;
+    const path7 = stringOf(record["path"]);
+    items.push(path7 ? { path: path7, diff } : { diff });
+  }
+  return items;
+}
+function extractMultiFileDiffs(toolName, output, input) {
+  if (!output) return void 0;
+  const items = collectMultiFileDiffItems(toolName, output, input);
+  if (items === void 0) return void 0;
+  if (items.length === 0) return void 0;
+  const previews = [];
+  for (const item of items) {
+    const preview = parseUnifiedDiff(item.diff, DIFF_MAX_LINES);
+    if (preview.rows.length === 0) continue;
+    previews.push({ path: item.path ?? "unknown file", preview });
+  }
+  return previews.length > 0 ? previews : void 0;
+}
+function collectMultiFileDiffItems(toolName, output, _input) {
+  const trimmed = output.trim();
+  if (!trimmed) return void 0;
+  if (toolName === "replace") {
+    const parsed = tryParseJson(trimmed);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const items = splitReplaceDiffs(parsed);
+    if (items.length === 0) return items;
+    const allMissing = items.every((item) => !item.path);
+    const fallback = allMissing && _input && typeof _input === "object" && typeof _input["path"] === "string" ? stringOf(_input["path"]) : void 0;
+    if (fallback) {
+      return items.map((item) => ({ path: item.path ?? fallback, diff: item.diff }));
+    }
+    return items;
+  }
+  if (toolName === "diff") {
+    const parsed = tryParseJson(trimmed);
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      const files = Array.isArray(obj["files"]) ? obj["files"].map(stringOf).filter((p) => Boolean(p)) : [];
+      const diff = stringOf(obj["diff"]) ?? stringOf(obj["stdout"]);
+      if (!diff?.trim()) return void 0;
+      const blocks = splitGitStyleDiff(diff);
+      return blocks.map((block, idx) => ({
+        path: files[idx] ?? block.path,
+        diff: block.diff
+      }));
+    }
+    if (trimmed.includes("@@")) return [{ diff: trimmed }];
+    return void 0;
+  }
+  if (toolName === "patch") {
+    const parsed = tryParseJson(trimmed);
+    let diffText;
+    let explicitFiles = [];
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      diffText = stringOf(obj["diff"]) ?? stringOf(obj["stdout"]);
+      if (Array.isArray(obj["files"])) {
+        explicitFiles = obj["files"].map(stringOf).filter((p) => Boolean(p));
+      }
+    } else if (trimmed.includes("@@") || trimmed.startsWith("---")) {
+      diffText = trimmed;
+    }
+    if (!diffText?.trim()) return void 0;
+    const blocks = splitGitStyleDiff(diffText);
+    if (blocks.length === 0) {
+      const path7 = explicitFiles[0] ?? extractPatchHeaderPath(diffText);
+      return [{ path: path7, diff: diffText }];
+    }
+    return blocks.map((block, idx) => ({
+      path: explicitFiles[idx] ?? block.path,
+      diff: block.diff
+    }));
+  }
+  return void 0;
+}
+function splitGitStyleDiff(diff) {
+  const lines = diff.split("\n");
+  const blocks = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const text = current.body.join("\n").trim();
+    if (text) blocks.push({ path: current.path, diff: text });
+    current = null;
+  };
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      current = { path: parseDiffGitPath(line), body: [line], hasGitHeader: true };
+      continue;
+    }
+    if (current) {
+      current.body.push(line);
+      if (!current.hasGitHeader && line.startsWith("--- a/") && current.body.length > 2) {
+        const carriedBody = current.body.slice(0, -1);
+        const carriedPath = current.path;
+        const text = carriedBody.join("\n").trim();
+        if (text) blocks.push({ path: carriedPath, diff: text });
+        current = {
+          path: line.slice("--- a/".length).trim(),
+          body: [line],
+          hasGitHeader: false
+        };
+      }
+    } else if (line.startsWith("--- a/")) {
+      current = { path: line.slice("--- a/".length).trim(), body: [line], hasGitHeader: false };
+    } else if (line.startsWith("+++ b/")) {
+      current = { body: [line], hasGitHeader: false };
+    }
+  }
+  flush();
+  if (blocks.length === 1 && !blocks[0].path) {
+    const path7 = extractPatchHeaderPath(blocks[0].diff);
+    if (path7) blocks[0] = { path: path7, diff: blocks[0].diff };
+  }
+  return blocks;
+}
+function parseDiffGitPath(line) {
+  const rest = line.slice("diff --git ".length).trim();
+  if (!rest) return void 0;
+  const sep2 = rest.lastIndexOf(" b/");
+  if (sep2 > 0 && sep2 > rest.length - sep2 - 3) {
+    return rest.slice(sep2 + 3);
+  }
+  const spaceIdx = rest.lastIndexOf(" ");
+  if (spaceIdx > 0) {
+    const rhs = rest.slice(spaceIdx + 1);
+    return rhs.startsWith("b/") ? rhs.slice(2) : rhs;
+  }
+  return void 0;
+}
+function extractPatchHeaderPath(diffText) {
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const path7 = line.slice(4).trim();
+      const cleaned = path7.replace(/^b\//, "").split("	")[0].trim();
+      return cleaned || void 0;
+    }
+  }
+  return void 0;
+}
 function newFileDiffFromWriteInput(output, input) {
   if (!input || typeof input !== "object") return void 0;
   const obj = input;
@@ -5466,7 +5780,7 @@ var Entry = React5.memo(function Entry2({
   termWidth,
   setSuggestions,
   autonomyMode,
-  autoSubmitCountdown
+  multiDiffSummaryThreshold
 }) {
   const nextSteps = useMemo(() => {
     if (entry.kind !== "assistant") return { steps: [], stripped: "" };
@@ -5549,7 +5863,7 @@ var Entry = React5.memo(function Entry2({
                 /* @__PURE__ */ jsx(Text, { bold: true, color: theme.accent, children: `  ${s2.index}. ` }),
                 /* @__PURE__ */ jsx(Text, { children: s2.text }),
                 s2.auto ? /* @__PURE__ */ jsx(Text, { color: "cyan", dimColor: true, children: "  auto" }) : null,
-                autonomyMode === "auto" && i === 0 ? autoSubmitCountdown != null && autoSubmitCountdown > 0 ? /* @__PURE__ */ jsx(Text, { color: autoSubmitCountdown > 20 ? "green" : autoSubmitCountdown > 10 ? "yellow" : "red", children: `  auto in ${autoSubmitCountdown}s` }) : /* @__PURE__ */ jsx(Text, { color: "cyan", children: "  \u23E9" }) : null
+                autonomyMode === "auto" && i === 0 ? /* @__PURE__ */ jsx(Text, { color: "cyan", children: "  \u23E9" }) : null
               ] }) }, s2.index))
             ]
           }
@@ -5558,30 +5872,49 @@ var Entry = React5.memo(function Entry2({
     }
     case "tool": {
       const { glyph, color } = getToolVisual(entry.name);
-      const argSummary = formatToolArgs(entry.name, entry.input);
-      const outLines = formatToolOutput(
+      const {
+        argSummary,
+        outLines,
+        visualLines,
+        diff,
+        multiDiffs,
+        sizeChip
+      } = useMemo(() => {
+        const argSummary2 = formatToolArgs(entry.name, entry.input);
+        const outLines2 = formatToolOutput(
+          entry.name,
+          entry.output,
+          entry.ok,
+          entry.outputBytes,
+          entry.outputLines
+        );
+        const visualLines2 = formatToolVisualOutput(entry.name, entry.output, entry.ok, entry.input);
+        const diff2 = entry.ok ? extractDiffPreview(entry.name, entry.output, entry.input) : void 0;
+        const multiDiffs2 = entry.ok && !diff2 && (entry.name === "replace" || entry.name === "diff" || entry.name === "patch") ? extractMultiFileDiffs(entry.name, entry.output, entry.input) : void 0;
+        const sizeChip2 = (() => {
+          if (!entry.ok) return "";
+          const parts = [];
+          if (entry.outputLines !== void 0 && entry.outputLines > 0) {
+            parts.push(`${entry.outputLines} L`);
+          }
+          if (entry.outputBytes && entry.outputBytes > 0) {
+            parts.push(fmtBytes(entry.outputBytes));
+          }
+          if (entry.outputTokens && entry.outputTokens > 0) {
+            parts.push(`\u2248${fmtTok2(entry.outputTokens)} tok`);
+          }
+          return parts.join(" \xB7 ");
+        })();
+        return { argSummary: argSummary2, outLines: outLines2, visualLines: visualLines2, diff: diff2, multiDiffs: multiDiffs2, sizeChip: sizeChip2 };
+      }, [
         entry.name,
         entry.output,
+        entry.input,
         entry.ok,
         entry.outputBytes,
-        entry.outputLines
-      );
-      const visualLines = formatToolVisualOutput(entry.name, entry.output, entry.ok, entry.input);
-      const diff = entry.ok ? extractDiffPreview(entry.name, entry.output, entry.input) : void 0;
-      const sizeChip = (() => {
-        if (!entry.ok) return "";
-        const parts = [];
-        if (entry.outputLines !== void 0 && entry.outputLines > 0) {
-          parts.push(`${entry.outputLines} L`);
-        }
-        if (entry.outputBytes && entry.outputBytes > 0) {
-          parts.push(fmtBytes(entry.outputBytes));
-        }
-        if (entry.outputTokens && entry.outputTokens > 0) {
-          parts.push(`\u2248${fmtTok2(entry.outputTokens)} tok`);
-        }
-        return parts.join(" \xB7 ");
-      })();
+        entry.outputLines,
+        entry.outputTokens
+      ]);
       return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
         /* @__PURE__ */ jsxs(Text, { children: [
           /* @__PURE__ */ jsx(Text, { color, children: glyph }),
@@ -5594,8 +5927,8 @@ var Entry = React5.memo(function Entry2({
           /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \xB7  ${fmtDuration(entry.durationMs)}` }),
           sizeChip ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \xB7  ${sizeChip}` }) : null
         ] }),
-        visualLines ? /* @__PURE__ */ jsx(ToolOutputLines, { lines: visualLines, hasFollowingBlock: Boolean(diff) }) : outLines.map((line, i) => /* @__PURE__ */ jsxs(Text, { children: [
-          /* @__PURE__ */ jsx(Text, { dimColor: true, children: i === outLines.length - 1 && !diff ? "  \u2514\u2500 " : "  \u251C\u2500 " }),
+        visualLines ? /* @__PURE__ */ jsx(ToolOutputLines, { lines: visualLines, hasFollowingBlock: Boolean(diff || multiDiffs) }) : outLines.map((line, i) => /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: i === outLines.length - 1 && !diff && !multiDiffs ? "  \u2514\u2500 " : "  \u251C\u2500 " }),
           /* @__PURE__ */ jsx(
             Text,
             {
@@ -5605,7 +5938,16 @@ var Entry = React5.memo(function Entry2({
             }
           )
         ] }, i)),
-        diff ? /* @__PURE__ */ jsx(
+        multiDiffs ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          (() => {
+            const summaryLine = formatMultiDiffSummary(
+              summarizeMultiFileDiffs(multiDiffs),
+              multiDiffSummaryThreshold ?? -1
+            );
+            return summaryLine ? /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: summaryLine }) : null;
+          })(),
+          multiDiffs.map((item) => /* @__PURE__ */ jsx(DiffFileBlock, { path: item.path, preview: item.preview }, item.path))
+        ] }) : diff ? /* @__PURE__ */ jsx(
           DiffBlock,
           {
             rows: diff.rows,
@@ -5725,7 +6067,7 @@ var Entry = React5.memo(function Entry2({
     }
   }
 });
-function History({ entries, generation, streamingText, toolStream, setSuggestions, autonomyMode, autoSubmitCountdown }) {
+var History = memo(function History2({ entries, generation, streamingText, toolStream, setSuggestions, autonomyMode, multiDiffSummaryThreshold }) {
   const { stdout } = useStdout();
   const [termSize, setTermSize] = useState({
     columns: stdout?.columns ?? 80,
@@ -5743,10 +6085,10 @@ function History({ entries, generation, streamingText, toolStream, setSuggestion
   const termWidth = termSize.columns;
   const tail = streamingText ? tailForDisplay(streamingText, MAX_STREAM_DISPLAY_CHARS) : "";
   return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Static, { items: entries, children: (entry) => /* @__PURE__ */ jsx(Box, { marginBottom: entry.kind === "turn-summary" ? 1 : 0, children: /* @__PURE__ */ jsx(Entry, { entry, termWidth, setSuggestions, autonomyMode, autoSubmitCountdown }) }, entry.id) }, generation ?? 0),
+    /* @__PURE__ */ jsx(Static, { items: entries, children: (entry) => /* @__PURE__ */ jsx(Box, { marginBottom: entry.kind === "turn-summary" ? 1 : 0, children: /* @__PURE__ */ jsx(Entry, { entry, termWidth, setSuggestions, autonomyMode, multiDiffSummaryThreshold }) }, entry.id) }, generation ?? 0),
     /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: tail ? /* @__PURE__ */ jsx(AssistantTail, { text: tail, termWidth }) : null })
   ] });
-}
+});
 var MAX_MOUNTED = 500;
 function scrollbarThumb(rows, offset, total) {
   const scrollable = total > rows;
@@ -5784,7 +6126,7 @@ function Scrollbar({
     i
   )) });
 }
-function ScrollableHistory({
+var ScrollableHistory = memo(function ScrollableHistory2({
   entries,
   streamingText,
   toolStream,
@@ -5794,8 +6136,7 @@ function ScrollableHistory({
   onMeasure,
   maxWidth,
   setSuggestions,
-  autonomyMode,
-  autoSubmitCountdown
+  autonomyMode
 }) {
   const { stdout } = useStdout();
   const rawWidth = stdout?.columns ?? 80;
@@ -5834,7 +6175,7 @@ function ScrollableHistory({
             flexShrink: 0,
             children: [
               hiddenCount > 0 ? /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: `  \u2191 ${hiddenCount} earlier ${hiddenCount === 1 ? "entry" : "entries"} (scroll lives in this session; full log on disk)` }) }) : null,
-              shown.map((entry) => /* @__PURE__ */ jsx(Box, { marginBottom: entry.kind === "turn-summary" ? 1 : 0, flexShrink: 0, children: /* @__PURE__ */ jsx(Entry, { entry, termWidth, setSuggestions, autonomyMode, autoSubmitCountdown }) }, entry.id)),
+              shown.map((entry) => /* @__PURE__ */ jsx(Box, { marginBottom: entry.kind === "turn-summary" ? 1 : 0, flexShrink: 0, children: /* @__PURE__ */ jsx(Entry, { entry, termWidth, setSuggestions, autonomyMode }) }, entry.id)),
               tail ? /* @__PURE__ */ jsx(AssistantTail, { text: tail, termWidth }) : null,
               toolTail && toolStream ? /* @__PURE__ */ jsx(
                 ToolStreamBox,
@@ -5852,7 +6193,7 @@ function ScrollableHistory({
     ),
     /* @__PURE__ */ jsx(Scrollbar, { rows: vp, offset: Math.max(0, scrollOffset), total: totalLines })
   ] });
-}
+});
 var MB = 1024 * 1024;
 function defaultHeapLogPath() {
   return path5.join(wstackGlobalRoot(), "logs", "heap.jsonl");
@@ -7606,6 +7947,7 @@ var MAX_ITERATIONS_PRESETS = [100, 200, 500, 1e3, 0];
 var MAX_CONCURRENT_PRESETS = [1, 3, 4, 5, 10, 25, 50, 0];
 var AUTO_PROCEED_MAX_PRESETS = [10, 25, 50, 100, 250, 0];
 var ENHANCE_DELAY_PRESETS = [15e3, 3e4, 45e3, 6e4, 9e4, 12e4];
+var MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS = [3, 5, 8, 10, 15, 0];
 var ENHANCE_LANGUAGES = ["original", "english"];
 var TOKEN_SAVING_TIERS = ["off", "minimal", "light", "medium", "aggressive"];
 var TOKEN_SAVING_TIER_DESCS = {
@@ -7624,6 +7966,10 @@ function formatMaxIterations(n) {
   if (n === 0) return "unlimited";
   return String(n);
 }
+function formatMultiDiffSummaryThreshold(n) {
+  if (n === 0) return "off";
+  return String(n);
+}
 function formatEnhanceDelay(ms) {
   return `${Math.round(ms / 1e3)}s`;
 }
@@ -7632,10 +7978,473 @@ var MODE_DESC = {
   suggest: "Shows next-step suggestions after each turn",
   auto: "Self-driving \u2014 agent continues automatically"
 };
-var SETTINGS_FIELD_COUNT = 35;
+var SETTINGS_FIELD_COUNT = 36;
+var THINKING_WORD_FIELD = 22;
+var SETTINGS_PICKER_JUMP_CHORDS = Object.freeze([
+  // ── Ctrl chords (Tools / Reasoning / Fleet / Debug sections) ──
+  // Most-tweaked rows first — these are the knobs users reach for daily.
+  { mod: "ctrl", letter: "i", field: 20, label: "Index on session start" },
+  { mod: "ctrl", letter: "m", field: 21, label: "Multi-diff summary" },
+  { mod: "ctrl", letter: "w", field: 22, label: "Thinking word" },
+  { mod: "ctrl", letter: "r", field: 17, label: "Refine preview countdown" },
+  { mod: "ctrl", letter: "e", field: 18, label: "Refine" },
+  { mod: "ctrl", letter: "n", field: 23, label: "Reasoning mode" },
+  { mod: "ctrl", letter: "l", field: 30, label: "Max concurrent" },
+  { mod: "ctrl", letter: "d", field: 34, label: "Statusline" },
+  // ── Alt chords (Autonomy / UX / Features / Context sections) ──
+  // The Ctrl set above is dominated by Tools + Reasoning rows; Alt picks up
+  // the spread-out sections to give every region of the picker a fast path.
+  { mod: "alt", letter: "a", field: 0, label: "Default autonomy mode" },
+  { mod: "alt", letter: "y", field: 3, label: "YOLO mode" },
+  { mod: "alt", letter: "c", field: 5, label: "Completion chime" },
+  { mod: "alt", letter: "s", field: 6, label: "Confirm before exit" },
+  { mod: "alt", letter: "t", field: 13, label: "Token-saving mode" },
+  { mod: "alt", letter: "x", field: 29, label: "Context mode" },
+  // ── Alt+Shift chords (Logging / Debug sections) ──
+  // 'L' is taken by Ctrl+L (Max concurrent), so the Logging rows get the
+  // composed Alt+Shift version. A standalone Alt+L would shadow the same
+  // letter as Max concurrent's Ctrl chord, so the composition is the
+  // disambiguator. 'A' and 'B' are both currently free as Alt+Shift
+  // letters (B is unmapped at any mod), so the Debug row's "Stream debug
+  // logging" takes B (de**B**ug, raw-**B**yte stream) rather than churn
+  // the existing Ctrl+D → Statusline binding to make room. The Config
+  // scope row uses G (**G**lobal / project) — G is free as Alt+Shift even
+  // though Ctrl+G is the agents-monitor chord, because the mod+letter
+  // composition makes them distinct at the keyboard-handler level.
+  { mod: "alt-shift", letter: "l", field: 31, label: "Log level" },
+  { mod: "alt-shift", letter: "a", field: 32, label: "Audit level" },
+  { mod: "alt-shift", letter: "b", field: 33, label: "Stream debug logging" },
+  { mod: "alt-shift", letter: "g", field: 35, label: "Config scope" }
+]);
+function settingsPickerJumpField(mod, letter) {
+  const lower = letter.toLowerCase();
+  const chord = SETTINGS_PICKER_JUMP_CHORDS.find((c) => c.mod === mod && c.letter === lower);
+  return chord?.field;
+}
+function settingsPickerSlug(label) {
+  return label.toLowerCase().replace(/\s+/g, "-");
+}
+function settingsPickerJumpByName(name) {
+  const query = settingsPickerSlug(name);
+  if (!query) return void 0;
+  const exact = SETTINGS_PICKER_JUMP_CHORDS.find(
+    (c) => settingsPickerSlug(c.label) === query
+  );
+  if (exact) return exact.field;
+  const queryTokens = query.split("-");
+  for (const c of SETTINGS_PICKER_JUMP_CHORDS) {
+    const labelTokens = settingsPickerSlug(c.label).split("-");
+    if (queryTokens.every((t, i) => labelTokens[i] === t)) {
+      return c.field;
+    }
+  }
+  for (const c of SETTINGS_PICKER_JUMP_CHORDS) {
+    const labelTokens = settingsPickerSlug(c.label).split("-");
+    if (labelTokens.some((t) => t === query || t.startsWith(`${query}-`))) {
+      return c.field;
+    }
+  }
+  return void 0;
+}
+function settingsPickerJumpNames() {
+  return SETTINGS_PICKER_JUMP_CHORDS.map((c) => settingsPickerSlug(c.label));
+}
+var THINKING_WORD_PRESETS = [
+  "thinking",
+  "random",
+  "working",
+  "cooking",
+  "vibing",
+  "pondering",
+  "brewing",
+  "crunching",
+  "computing",
+  "grinding",
+  "noodling",
+  "churning",
+  "hacking"
+];
 var CONFIG_SCOPES = ["global", "project"];
+var SETTINGS_FIELD_LABELS = [
+  "Default autonomy mode",
+  // 0
+  "Auto-proceed delay",
+  // 1
+  "Terminal title animation",
+  // 2
+  "YOLO mode",
+  // 3
+  "Stream fleet",
+  // 4
+  "Completion chime",
+  // 5
+  "Confirm before exit",
+  // 6
+  "Next prediction",
+  // 7
+  "MCP features",
+  // 8
+  "Plugin features",
+  // 9
+  "Memory features",
+  // 10
+  "Skills features",
+  // 11
+  "Models registry",
+  // 12
+  "Token-saving mode",
+  // 13
+  "Allow outside project root",
+  // 14
+  "Max iterations",
+  // 15
+  "Auto-proceed max iterations",
+  // 16
+  "Refine preview countdown",
+  // 17
+  "Refine",
+  // 18
+  "Refine language",
+  // 19
+  "Index on session start",
+  // 20
+  "Multi-diff summary",
+  // 21
+  "Thinking word",
+  // 22
+  "Reasoning mode",
+  // 23
+  "Reasoning effort",
+  // 24
+  "Reasoning preserve",
+  // 25
+  "Cache TTL",
+  // 26
+  "Context auto-compact",
+  // 27
+  "Compactor strategy",
+  // 28
+  "Context mode",
+  // 29
+  "Max concurrent",
+  // 30
+  "Log level",
+  // 31
+  "Audit level",
+  // 32
+  "Stream debug logging",
+  // 33
+  "Statusline",
+  // 34
+  "Config scope"
+  // 35
+];
+function resolveSettingsFieldValue(field, input) {
+  const raw = input.trim().toLowerCase();
+  const label = SETTINGS_FIELD_LABELS[field] ?? `Field ${field}`;
+  const BOOL_FIELDS = /* @__PURE__ */ new Map([
+    [2, "titleAnimation"],
+    [3, "yolo"],
+    [4, "streamFleet"],
+    [5, "chime"],
+    [6, "confirmExit"],
+    [7, "nextPrediction"],
+    [8, "featureMcp"],
+    [9, "featurePlugins"],
+    [10, "featureMemory"],
+    [11, "featureSkills"],
+    [12, "featureModelsRegistry"],
+    [14, "allowOutsideProjectRoot"],
+    [18, "enhanceEnabled"],
+    [20, "indexOnStart"],
+    [25, "reasoningPreserve"],
+    [27, "contextAutoCompact"],
+    [33, "debugStream"]
+  ]);
+  const boolKey = BOOL_FIELDS.get(field);
+  if (boolKey) {
+    if (["on", "true", "yes", "1"].includes(raw)) {
+      return { ok: true, patch: { [boolKey]: true }, label, displayValue: "on" };
+    }
+    if (["off", "false", "no", "0"].includes(raw)) {
+      return { ok: true, patch: { [boolKey]: false }, label, displayValue: "off" };
+    }
+    return { ok: false, error: `Invalid value "${input}" for ${label}. Use on or off.` };
+  }
+  const ENUM_FIELDS = [
+    [0, "mode", SETTINGS_MODES],
+    [13, "tokenSavingTier", TOKEN_SAVING_TIERS],
+    [19, "enhanceLanguage", ENHANCE_LANGUAGES],
+    [23, "reasoningMode", REASONING_MODES],
+    [24, "reasoningEffort", REASONING_EFFORTS],
+    [26, "cacheTtl", CACHE_TTLS],
+    [28, "contextStrategy", COMPACTOR_STRATEGIES],
+    [29, "contextMode", CONTEXT_MODES],
+    [31, "logLevel", LOG_LEVELS],
+    [32, "auditLevel", AUDIT_LEVELS],
+    [34, "statuslineMode", STATUSLINE_MODES],
+    [35, "configScope", CONFIG_SCOPES]
+  ];
+  for (const [f, key, values] of ENUM_FIELDS) {
+    if (field !== f) continue;
+    const match = values.find((v) => v.toLowerCase() === raw);
+    if (match) {
+      return { ok: true, patch: { [key]: match }, label, displayValue: match };
+    }
+    return {
+      ok: false,
+      error: `Invalid value "${input}" for ${label}. Valid: ${values.join(", ")}.`
+    };
+  }
+  const presetLabel = (n, zeroLabel) => n === 0 ? zeroLabel : String(n);
+  const PRESET_FIELDS = [
+    [1, "delayMs", DELAY_PRESETS_MS, (n) => formatSettingsDelay(n)],
+    [15, "maxIterations", MAX_ITERATIONS_PRESETS, (n) => formatMaxIterations(n)],
+    [16, "autoProceedMaxIterations", AUTO_PROCEED_MAX_PRESETS, (n) => formatMaxIterations(n)],
+    [17, "enhanceDelayMs", ENHANCE_DELAY_PRESETS, (n) => formatEnhanceDelay(n)],
+    [21, "multiDiffSummaryThreshold", MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS, (n) => formatMultiDiffSummaryThreshold(n)],
+    [30, "maxConcurrent", MAX_CONCURRENT_PRESETS, (n) => presetLabel(n, "runtime default")]
+  ];
+  for (const [f, key, presets, fmt2] of PRESET_FIELDS) {
+    if (field !== f) continue;
+    const asNum = Number.parseInt(raw, 10);
+    if (!Number.isNaN(asNum) && presets.includes(asNum)) {
+      return { ok: true, patch: { [key]: asNum }, label, displayValue: fmt2(asNum) };
+    }
+    const byName = presets.find((p) => fmt2(p).toLowerCase() === raw);
+    if (byName !== void 0) {
+      return { ok: true, patch: { [key]: byName }, label, displayValue: fmt2(byName) };
+    }
+    const options = presets.map((p) => fmt2(p)).join(", ");
+    return {
+      ok: false,
+      error: `Invalid value "${input}" for ${label}. Available: ${options}.`
+    };
+  }
+  if (field === 22) {
+    const word = input.trim();
+    if (word.length === 0 || word.length > MAX_TUI_THINKING_WORD_LENGTH) {
+      return {
+        ok: false,
+        error: `"${input}" is not a valid thinking word. Use a single short word (1\u2013${MAX_TUI_THINKING_WORD_LENGTH} chars, letters/numbers only).`
+      };
+    }
+    if (!/^[\p{L}\p{N}_-]+$/u.test(word)) {
+      return {
+        ok: false,
+        error: `"${input}" is not a valid thinking word. Use a single short word (1\u2013${MAX_TUI_THINKING_WORD_LENGTH} chars, letters/numbers only).`
+      };
+    }
+    return { ok: true, patch: { thinkingWord: word }, label, displayValue: word };
+  }
+  return { ok: false, error: `Unknown settings field ${field}.` };
+}
+function getSettingsFieldValue(values, field) {
+  const label = SETTINGS_FIELD_LABELS[field] ?? `Field ${field}`;
+  const BOOL_KEYS = [
+    [2, "titleAnimation"],
+    [3, "yolo"],
+    [4, "streamFleet"],
+    [5, "chime"],
+    [6, "confirmExit"],
+    [7, "nextPrediction"],
+    [8, "featureMcp"],
+    [9, "featurePlugins"],
+    [10, "featureMemory"],
+    [11, "featureSkills"],
+    [12, "featureModelsRegistry"],
+    [14, "allowOutsideProjectRoot"],
+    [18, "enhanceEnabled"],
+    [20, "indexOnStart"],
+    [25, "reasoningPreserve"],
+    [27, "contextAutoCompact"],
+    [33, "debugStream"]
+  ];
+  for (const [f, key] of BOOL_KEYS) {
+    if (field !== f) continue;
+    return { ok: true, label, displayValue: values[key] ? "on" : "off" };
+  }
+  const ENUM_KEYS = [
+    [0, "mode"],
+    [13, "tokenSavingTier"],
+    [19, "enhanceLanguage"],
+    [23, "reasoningMode"],
+    [24, "reasoningEffort"],
+    [26, "cacheTtl"],
+    [28, "contextStrategy"],
+    [29, "contextMode"],
+    [31, "logLevel"],
+    [32, "auditLevel"],
+    [34, "statuslineMode"],
+    [35, "configScope"]
+  ];
+  for (const [f, key] of ENUM_KEYS) {
+    if (field !== f) continue;
+    return { ok: true, label, displayValue: String(values[key]) };
+  }
+  const presetLabel = (n, zeroLabel) => n === 0 ? zeroLabel : String(n);
+  const PRESET_KEYS = [
+    [1, "delayMs", formatSettingsDelay],
+    [15, "maxIterations", formatMaxIterations],
+    [16, "autoProceedMaxIterations", formatMaxIterations],
+    [17, "enhanceDelayMs", formatEnhanceDelay],
+    [21, "multiDiffSummaryThreshold", formatMultiDiffSummaryThreshold],
+    [30, "maxConcurrent", (n) => presetLabel(n, "runtime default")]
+  ];
+  for (const [f, key, fmt2] of PRESET_KEYS) {
+    if (field !== f) continue;
+    return { ok: true, label, displayValue: fmt2(values[key]) };
+  }
+  if (field === 22) {
+    return { ok: true, label, displayValue: values.thinkingWord };
+  }
+  return { ok: false, error: `Unknown settings field ${field}.` };
+}
+var SETTINGS_SECTIONS = [
+  {
+    name: "Autonomy",
+    fields: [0, 1]
+  },
+  {
+    name: "UX",
+    fields: [2, 3, 4, 5, 6, 7]
+  },
+  {
+    name: "Features",
+    fields: [8, 9, 10, 11, 12, 13, 14]
+  },
+  {
+    name: "Tools",
+    fields: [15, 16, 17, 18, 19, 20, 21, 22]
+  },
+  {
+    name: "Reasoning",
+    fields: [23, 24, 25, 26]
+  },
+  {
+    name: "Context",
+    fields: [27, 28, 29]
+  },
+  {
+    name: "Fleet",
+    fields: [30]
+  },
+  {
+    name: "Logging",
+    fields: [31, 32]
+  },
+  {
+    name: "Debug",
+    fields: [33, 34, 35]
+  }
+];
+function formatAllSettingsSummary(values) {
+  const lines = [];
+  for (const section of SETTINGS_SECTIONS) {
+    lines.push(`\u2500\u2500 ${section.name} \u2500\u2500`);
+    for (const field of section.fields) {
+      const result = getSettingsFieldValue(values, field);
+      if (result.ok) {
+        lines.push(`  ${result.label.padEnd(28)} ${result.displayValue}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+var SETTINGS_DEFAULTS = Object.freeze({
+  mode: "off",
+  delayMs: 0,
+  titleAnimation: true,
+  yolo: false,
+  streamFleet: true,
+  chime: false,
+  confirmExit: true,
+  nextPrediction: false,
+  featureMcp: true,
+  featurePlugins: true,
+  featureMemory: true,
+  featureSkills: true,
+  featureModelsRegistry: true,
+  tokenSavingTier: "off",
+  allowOutsideProjectRoot: true,
+  contextAutoCompact: true,
+  contextStrategy: "hybrid",
+  contextMode: "balanced",
+  maxConcurrent: 10,
+  logLevel: "info",
+  auditLevel: "standard",
+  indexOnStart: true,
+  multiDiffSummaryThreshold: 5,
+  maxIterations: 500,
+  autoProceedMaxIterations: 50,
+  enhanceDelayMs: 6e4,
+  enhanceEnabled: true,
+  enhanceLanguage: "original",
+  debugStream: false,
+  statuslineMode: "detailed",
+  reasoningMode: "auto",
+  reasoningEffort: "high",
+  reasoningPreserve: false,
+  thinkingWord: "thinking",
+  cacheTtl: "default",
+  configScope: "global"
+});
+function resetSettingsFieldValue(field) {
+  const result = getSettingsFieldValue(SETTINGS_DEFAULTS, field);
+  if (!result.ok) return result;
+  const patch = buildResetPatch(field);
+  if (!patch) return { ok: false, error: `Unknown settings field ${field}.` };
+  return { ok: true, patch, label: result.label, displayValue: result.displayValue };
+}
+function buildResetPatch(field) {
+  const KEY_MAP = [
+    [0, "mode"],
+    [1, "delayMs"],
+    [2, "titleAnimation"],
+    [3, "yolo"],
+    [4, "streamFleet"],
+    [5, "chime"],
+    [6, "confirmExit"],
+    [7, "nextPrediction"],
+    [8, "featureMcp"],
+    [9, "featurePlugins"],
+    [10, "featureMemory"],
+    [11, "featureSkills"],
+    [12, "featureModelsRegistry"],
+    [13, "tokenSavingTier"],
+    [14, "allowOutsideProjectRoot"],
+    [15, "maxIterations"],
+    [16, "autoProceedMaxIterations"],
+    [17, "enhanceDelayMs"],
+    [18, "enhanceEnabled"],
+    [19, "enhanceLanguage"],
+    [20, "indexOnStart"],
+    [21, "multiDiffSummaryThreshold"],
+    [22, "thinkingWord"],
+    [23, "reasoningMode"],
+    [24, "reasoningEffort"],
+    [25, "reasoningPreserve"],
+    [26, "cacheTtl"],
+    [27, "contextAutoCompact"],
+    [28, "contextStrategy"],
+    [29, "contextMode"],
+    [30, "maxConcurrent"],
+    [31, "logLevel"],
+    [32, "auditLevel"],
+    [33, "debugStream"],
+    [34, "statuslineMode"],
+    [35, "configScope"]
+  ];
+  for (const [f, key] of KEY_MAP) {
+    if (f === field) {
+      return { [key]: SETTINGS_DEFAULTS[key] };
+    }
+  }
+  return null;
+}
 function SettingsPicker({
   field,
+  filter,
   mode,
   delayMs,
   titleAnimation,
@@ -7657,7 +8466,10 @@ function SettingsPicker({
   enhanceEnabled,
   enhanceLanguage,
   indexOnStart,
+  multiDiffSummaryThreshold,
   thinkingWord,
+  thinkingWordEditing,
+  thinkingWordDraft,
   reasoningMode,
   reasoningEffort,
   reasoningPreserve,
@@ -7784,12 +8596,17 @@ function SettingsPicker({
       value: boolVal(indexOnStart),
       detail: "Run incremental index at session start"
     },
+    {
+      label: "Multi-diff summary",
+      value: formatMultiDiffSummaryThreshold(multiDiffSummaryThreshold),
+      detail: "Min files before aggregate header (0 = off, default 5, 10 for big diffs)"
+    },
     // ── Reasoning ──
     { section: "Reasoning" },
     {
       label: "Thinking word",
-      value: thinkingWord,
-      detail: "Word shown in status bar while agent works"
+      value: thinkingWordEditing ? `${thinkingWordDraft ?? ""}\u258F` : thinkingWord,
+      detail: thinkingWordEditing ? "type a word \xB7 Enter \u2713 \xB7 Esc \u2717 (\u226416, letters/digits/_/-)" : "Status-bar working word \xB7 thinking/random = surprise me \xB7 \u2190/\u2192 presets \xB7 Enter to type"
     },
     {
       label: "Reasoning mode",
@@ -7869,6 +8686,94 @@ function SettingsPicker({
   for (let i = 0; i < rows.length; i++) {
     if (!rows[i]?.section) fieldRowIndex.push(i);
   }
+  const filterActive = Boolean(filter && filter.length > 1);
+  const filterQuery = filter && filter.length > 1 ? filter.slice(1).toLowerCase() : "";
+  const fuzzyMatch = (haystack, needle) => {
+    const lower = haystack.toLowerCase();
+    const indices = [];
+    let ni = 0;
+    for (let hi = 0; hi < lower.length && ni < needle.length; hi++) {
+      if (lower[hi] === needle[ni]) {
+        indices.push(hi);
+        ni++;
+      }
+    }
+    return ni === needle.length ? indices : void 0;
+  };
+  const scoreMatch = (contiguous, matchIndices, labelLength) => {
+    const tier = contiguous ? 0 : 1e3;
+    if (!matchIndices || matchIndices.length === 0) {
+      return tier;
+    }
+    const firstPos = matchIndices[0] ?? 0;
+    const span = (matchIndices.at(-1) ?? 0) - firstPos;
+    const gap = span - (matchIndices.length - 1);
+    const lengthPenalty = Math.max(0, labelLength - 8);
+    return tier + firstPos + gap * 2 + lengthPenalty;
+  };
+  const fuzzyResults = filterActive ? SETTINGS_PICKER_JUMP_CHORDS.map((c) => {
+    const label = c.label;
+    const contiguous = label.toLowerCase().includes(filterQuery);
+    if (contiguous) {
+      const firstIdx = label.toLowerCase().indexOf(filterQuery);
+      const indices = Array.from({ length: filterQuery.length }, (_, i) => firstIdx + i);
+      return { chord: c, contiguous, fuzzyIdx: void 0, score: scoreMatch(true, indices, label.length) };
+    }
+    const fuzzyIdx = fuzzyMatch(label, filterQuery);
+    return {
+      chord: c,
+      contiguous: false,
+      fuzzyIdx,
+      score: fuzzyIdx !== void 0 ? scoreMatch(false, fuzzyIdx, label.length) : Infinity
+    };
+  }) : [];
+  const rankedResults = fuzzyResults.filter((r) => r.contiguous || r.fuzzyIdx !== void 0).sort((a, b) => a.score - b.score);
+  const filteredFieldIndices = rankedResults.map((r) => r.chord.field);
+  const highlightSegments = (label) => {
+    if (!filterActive || !filterQuery) return [{ text: label, match: false }];
+    const result = fuzzyResults.find((r) => r.chord.label === label);
+    if (!result) return [{ text: label, match: false }];
+    if (result.contiguous) {
+      const lower = label.toLowerCase();
+      const segments = [];
+      let cursor = 0;
+      while (cursor < label.length) {
+        const idx = lower.indexOf(filterQuery, cursor);
+        if (idx === -1) {
+          segments.push({ text: label.slice(cursor), match: false });
+          break;
+        }
+        if (idx > cursor) {
+          segments.push({ text: label.slice(cursor, idx), match: false });
+        }
+        segments.push({ text: label.slice(idx, idx + filterQuery.length), match: true });
+        cursor = idx + filterQuery.length;
+      }
+      return segments;
+    }
+    if (result.fuzzyIdx) {
+      const matchSet = new Set(result.fuzzyIdx);
+      const segments = [];
+      let current = "";
+      let currentMatch = false;
+      for (let i = 0; i < label.length; i++) {
+        const isMatch = matchSet.has(i);
+        if (i === 0) {
+          current = label[i] ?? "";
+          currentMatch = isMatch;
+        } else if (isMatch === currentMatch) {
+          current += label[i] ?? "";
+        } else {
+          segments.push({ text: current, match: currentMatch });
+          current = label[i] ?? "";
+          currentMatch = isMatch;
+        }
+      }
+      if (current) segments.push({ text: current, match: currentMatch });
+      return segments;
+    }
+    return [{ text: label, match: false }];
+  };
   const VISIBLE_FIELDS = 8;
   const totalFields = fieldRowIndex.length;
   const windowStart = totalFields <= VISIBLE_FIELDS ? 0 : Math.max(0, Math.min(field - Math.floor(VISIBLE_FIELDS / 2), totalFields - VISIBLE_FIELDS));
@@ -7897,30 +8802,80 @@ function SettingsPicker({
   };
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
     /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u2501\u2501 Settings \u2501\u2501" }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 field \xB7 \u2190/\u2192 change + autosave \xB7 F5 to close" }),
-    hasAbove ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2191 ${windowStart} field${windowStart === 1 ? "" : "s"} above` }) : null,
-    rows.map((row, i) => {
-      const fieldAtRow = fieldRowIndex.indexOf(i);
-      if (fieldAtRow === -1) {
-        if (shouldShowSection(i)) {
-          return /* @__PURE__ */ jsxs(Text, { bold: true, color: "green", children: [
-            "\u2500\u2500 ",
-            row.section,
-            " \u2500\u2500"
-          ] }, `section-${row.section ?? i}`);
+    filterActive ? /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: `Filter: ${filter} (${filteredFieldIndices.length} match${filteredFieldIndices.length === 1 ? "" : "es"})` }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 field \xB7 \u2190/\u2192 change + autosave \xB7 `/` to search \xB7 F5 to close" }),
+    hasAbove && !filterActive ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2191 ${windowStart} field${windowStart === 1 ? "" : "s"} above` }) : null,
+    filterActive && filteredFieldIndices.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: "No matching settings rows." }) : null,
+    filterActive ? (
+      // Filter mode: render ranked rows in score order (not picker
+      // order). Each row is looked up by its field index from the
+      // `rows` array via `fieldRowIndex`.
+      rankedResults.map((result) => {
+        const fieldIdx = result.chord.field;
+        const rowIdx = fieldRowIndex[fieldIdx] ?? -1;
+        const row = rows[rowIdx];
+        if (!row || !row.label) return null;
+        const selected = fieldIdx === field;
+        const labelStr = row.label;
+        const segments = highlightSegments(labelStr);
+        const padNeeded = Math.max(0, 26 - labelStr.length);
+        return /* @__PURE__ */ jsxs(Text, { inverse: selected, ...selected ? { color: "yellow" } : {}, children: [
+          selected ? "\u203A " : "  ",
+          segments.map((seg, j) => /* @__PURE__ */ jsx(
+            Text,
+            {
+              bold: true,
+              ...seg.match ? { color: "yellow" } : { dimColor: true },
+              children: seg.text
+            },
+            j
+          )),
+          /* @__PURE__ */ jsx(Text, { bold: true, dimColor: true, children: " ".repeat(padNeeded) }),
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: String(row.value ?? "").padEnd(12) }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: row.detail ?? "" })
+        ] }, `frow-${labelStr}`);
+      })
+    ) : (
+      // Normal mode: render rows in picker order with windowing.
+      rows.map((row, i) => {
+        const fieldAtRow = fieldRowIndex.indexOf(i);
+        if (fieldAtRow === -1) {
+          if (filterActive) return null;
+          if (shouldShowSection(i)) {
+            return /* @__PURE__ */ jsxs(Text, { bold: true, color: "green", children: [
+              "\u2500\u2500 ",
+              row.section,
+              " \u2500\u2500"
+            ] }, `section-${row.section ?? i}`);
+          }
+          return null;
         }
-        return null;
-      }
-      if (fieldAtRow < windowStart || fieldAtRow >= windowEnd) return null;
-      const selected = fieldAtRow === field;
-      return /* @__PURE__ */ jsxs(Text, { inverse: selected, ...selected ? { color: "yellow" } : {}, children: [
-        selected ? "\u203A " : "  ",
-        /* @__PURE__ */ jsx(Text, { bold: true, children: (row.label ?? "").padEnd(26) }),
-        /* @__PURE__ */ jsx(Text, { color: "cyan", children: String(row.value ?? "").padEnd(12) }),
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: row.detail ?? "" })
-      ] }, `row-${row.label ?? fieldAtRow}`);
-    }),
-    hasBelow ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2193 ${totalFields - windowEnd} field${totalFields - windowEnd === 1 ? "" : "s"} below` }) : null,
+        if (filterActive) {
+          if (!filteredFieldIndices.includes(fieldAtRow)) return null;
+        } else if (fieldAtRow < windowStart || fieldAtRow >= windowEnd) return null;
+        const selected = fieldAtRow === field;
+        const labelStr = row.label ?? "";
+        const segments = highlightSegments(labelStr);
+        const padNeeded = Math.max(0, 26 - labelStr.length);
+        return /* @__PURE__ */ jsxs(Text, { inverse: selected, ...selected ? { color: "yellow" } : {}, children: [
+          selected ? "\u203A " : "  ",
+          filterActive ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            segments.map((seg, j) => /* @__PURE__ */ jsx(
+              Text,
+              {
+                bold: true,
+                ...seg.match ? { color: "yellow" } : { dimColor: true },
+                children: seg.text
+              },
+              j
+            )),
+            /* @__PURE__ */ jsx(Text, { bold: true, dimColor: true, children: " ".repeat(padNeeded) })
+          ] }) : /* @__PURE__ */ jsx(Text, { bold: true, children: labelStr.padEnd(26) }),
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: String(row.value ?? "").padEnd(12) }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: row.detail ?? "" })
+        ] }, `row-${row.label ?? fieldAtRow}`);
+      })
+    ),
+    hasBelow && !filterActive ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2193 ${totalFields - windowEnd} field${totalFields - windowEnd === 1 ? "" : "s"} below` }) : null,
     /* @__PURE__ */ jsx(Text, { dimColor: true, children: configScope === "project" ? "Persisted to <project>/.wrongstack/config.json" : "Persisted to ~/.wrongstack/config.json" }),
     hint ? /* @__PURE__ */ jsx(Text, { color: "yellow", children: hint }) : null
   ] });
@@ -8066,19 +9021,23 @@ function StatuslinePicker({
   const visibleChipsMap = new Map(visibleChips.map((c) => [c.key, c]));
   const totalFields = STATUSLINE_ITEMS.length;
   const byLine = groupByLine(STATUSLINE_ITEMS);
+  const VISIBLE_FIELDS = 8;
+  const windowStart = Math.max(0, Math.min(field - Math.floor(VISIBLE_FIELDS / 2), totalFields - VISIBLE_FIELDS));
+  const windowEnd = Math.min(windowStart + VISIBLE_FIELDS, totalFields);
+  const hasAbove = windowStart > 0;
+  const hasBelow = windowEnd < totalFields;
   const rows = [];
   for (const [line, items] of [...byLine.entries()].sort((a, b) => a[0] - b[0])) {
+    const windowedItems = items.filter((item) => {
+      const idx = STATUSLINE_ITEMS.indexOf(item);
+      return idx >= windowStart && idx < windowEnd;
+    });
+    if (windowedItems.length === 0) continue;
     rows.push({ section: `Line ${line}` });
-    for (const item of items) {
-      const fieldIdx = STATUSLINE_ITEMS.indexOf(item);
-      rows.push({ item, fieldIdx });
+    for (const item of windowedItems) {
+      rows.push({ item, fieldIdx: STATUSLINE_ITEMS.indexOf(item) });
     }
   }
-  const VISIBLE_FIELDS = 7;
-  const windowStart = Math.max(0, Math.min(field - Math.floor(VISIBLE_FIELDS / 2), totalFields - VISIBLE_FIELDS));
-  const windowEnd = Math.min(windowStart + VISIBLE_FIELDS, totalFields);
-  const hasAbove = windowStart > 0;
-  const hasBelow = windowEnd < totalFields;
   const boolVal = (item) => {
     if (hiddenSet.has(item)) return "off";
     if (STREAM_CHIP_KEYS.includes(item)) {
@@ -10402,7 +11361,21 @@ function reducer(state, action) {
         ...closePanels(state),
         settingsPicker: {
           open: true,
-          field: 0,
+          // The persisted `lastSettingsField` (from the canonical Settings
+          // shape) drives where the picker lands on open. The slice's
+          // `field` is a working copy that mirrors it until the user
+          // navigates again. `state.settingsPicker.lastSettingsField` is
+          // the fallback for the (rare) case where the action omits it
+          // — e.g., a tests/dispatch path that hasn't been updated yet.
+          // `||` (not `??`): a payload `lastSettingsField` of 0 means
+          // "no saved value" (the default in the canonical Settings),
+          // so we fall through to the runtime state's tracked value.
+          // This lets the in-session `settingsFieldSet`/`settingsFieldMove`
+          // preserve the field across close/reopen within the same session,
+          // while a non-zero persisted value (loaded from disk) takes
+          // priority on a fresh open.
+          field: action.lastSettingsField || state.settingsPicker.lastSettingsField || 0,
+          lastSettingsField: action.lastSettingsField || state.settingsPicker.lastSettingsField || 0,
           mode: action.mode,
           delayMs: action.delayMs,
           titleAnimation: action.titleAnimation,
@@ -10425,6 +11398,7 @@ function reducer(state, action) {
           logLevel: action.logLevel,
           auditLevel: action.auditLevel,
           indexOnStart: action.indexOnStart,
+          multiDiffSummaryThreshold: action.multiDiffSummaryThreshold,
           maxIterations: action.maxIterations,
           autoProceedMaxIterations: action.autoProceedMaxIterations,
           enhanceDelayMs: action.enhanceDelayMs,
@@ -10436,6 +11410,11 @@ function reducer(state, action) {
           reasoningEffort: action.reasoningEffort,
           reasoningPreserve: action.reasoningPreserve,
           thinkingWord: action.thinkingWord,
+          thinkingWordEditing: false,
+          thinkingWordDraft: "",
+          // Filter is always cleared on open — the user starts fresh.
+          // Persisted `lastSettingsField` is restored separately above.
+          filter: "",
           cacheTtl: action.cacheTtl,
           configScope: action.configScope,
           hint: void 0
@@ -10450,13 +11429,28 @@ function reducer(state, action) {
       const next = (state.settingsPicker.field + action.delta + SETTINGS_FIELD_COUNT) % SETTINGS_FIELD_COUNT;
       return {
         ...state,
-        settingsPicker: { ...state.settingsPicker, field: next, hint: void 0 }
+        settingsPicker: {
+          ...state.settingsPicker,
+          field: next,
+          lastSettingsField: next,
+          thinkingWordEditing: false,
+          thinkingWordDraft: "",
+          hint: void 0
+        }
       };
     }
     case "settingsFieldSet": {
       const field = action.field >= 0 && action.field < SETTINGS_FIELD_COUNT ? action.field : 0;
-      return { ...state, settingsPicker: { ...state.settingsPicker, field, hint: void 0 } };
+      return {
+        ...state,
+        settingsPicker: { ...state.settingsPicker, field, lastSettingsField: field, hint: void 0 }
+      };
     }
+    case "settingsFilterSet":
+      return {
+        ...state,
+        settingsPicker: { ...state.settingsPicker, filter: action.filter }
+      };
     case "settingsValueChange": {
       const sp = state.settingsPicker;
       const f = sp.field;
@@ -10618,8 +11612,28 @@ function reducer(state, action) {
           ...state,
           settingsPicker: { ...sp, indexOnStart: !sp.indexOnStart, hint: bootHint }
         };
-      if (f === 21) return state;
-      if (f === 22) {
+      if (f === 21) {
+        const j = MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS.indexOf(sp.multiDiffSummaryThreshold);
+        const base = j < 0 ? 0 : j;
+        const next = (base + action.delta + MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS.length) % MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS.length;
+        const multiDiffSummaryThreshold = expectDefined$1(MULTI_DIFF_SUMMARY_THRESHOLD_PRESETS[next]);
+        return {
+          ...state,
+          settingsPicker: { ...sp, multiDiffSummaryThreshold, hint: void 0 }
+        };
+      }
+      if (f === THINKING_WORD_FIELD) {
+        const cur = sp.thinkingWord;
+        const list = THINKING_WORD_PRESETS.includes(cur) ? [...THINKING_WORD_PRESETS] : [cur, ...THINKING_WORD_PRESETS];
+        const i = list.indexOf(cur);
+        const base = i < 0 ? 0 : i;
+        const next = (base + action.delta + list.length) % list.length;
+        return {
+          ...state,
+          settingsPicker: { ...sp, thinkingWord: expectDefined$1(list[next]), hint: void 0 }
+        };
+      }
+      if (f === 23) {
         const i = REASONING_MODES.indexOf(sp.reasoningMode);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + REASONING_MODES.length) % REASONING_MODES.length;
@@ -10632,7 +11646,7 @@ function reducer(state, action) {
           }
         };
       }
-      if (f === 23) {
+      if (f === 24) {
         const i = REASONING_EFFORTS.indexOf(
           sp.reasoningEffort
         );
@@ -10647,12 +11661,12 @@ function reducer(state, action) {
           }
         };
       }
-      if (f === 24)
+      if (f === 25)
         return {
           ...state,
           settingsPicker: { ...sp, reasoningPreserve: !sp.reasoningPreserve, hint: void 0 }
         };
-      if (f === 25) {
+      if (f === 26) {
         const i = CACHE_TTLS.indexOf(sp.cacheTtl);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + CACHE_TTLS.length) % CACHE_TTLS.length;
@@ -10661,12 +11675,12 @@ function reducer(state, action) {
           settingsPicker: { ...sp, cacheTtl: expectDefined$1(CACHE_TTLS[next]), hint: void 0 }
         };
       }
-      if (f === 26)
+      if (f === 27)
         return {
           ...state,
           settingsPicker: { ...sp, contextAutoCompact: !sp.contextAutoCompact, hint: void 0 }
         };
-      if (f === 27) {
+      if (f === 28) {
         const i = COMPACTOR_STRATEGIES.indexOf(sp.contextStrategy);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + COMPACTOR_STRATEGIES.length) % COMPACTOR_STRATEGIES.length;
@@ -10679,7 +11693,7 @@ function reducer(state, action) {
           }
         };
       }
-      if (f === 28) {
+      if (f === 29) {
         const i = CONTEXT_MODES.indexOf(sp.contextMode);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + CONTEXT_MODES.length) % CONTEXT_MODES.length;
@@ -10692,7 +11706,7 @@ function reducer(state, action) {
           }
         };
       }
-      if (f === 29) {
+      if (f === 30) {
         const j = MAX_CONCURRENT_PRESETS.indexOf(sp.maxConcurrent);
         const base = j < 0 ? 0 : j;
         const next = (base + action.delta + MAX_CONCURRENT_PRESETS.length) % MAX_CONCURRENT_PRESETS.length;
@@ -10706,7 +11720,7 @@ function reducer(state, action) {
           }
         };
       }
-      if (f === 30) {
+      if (f === 31) {
         const i = LOG_LEVELS.indexOf(sp.logLevel);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + LOG_LEVELS.length) % LOG_LEVELS.length;
@@ -10715,7 +11729,7 @@ function reducer(state, action) {
           settingsPicker: { ...sp, logLevel: expectDefined$1(LOG_LEVELS[next]), hint: void 0 }
         };
       }
-      if (f === 31) {
+      if (f === 32) {
         const i = AUDIT_LEVELS.indexOf(sp.auditLevel);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + AUDIT_LEVELS.length) % AUDIT_LEVELS.length;
@@ -10724,12 +11738,12 @@ function reducer(state, action) {
           settingsPicker: { ...sp, auditLevel: expectDefined$1(AUDIT_LEVELS[next]), hint: void 0 }
         };
       }
-      if (f === 32)
+      if (f === 33)
         return {
           ...state,
           settingsPicker: { ...sp, debugStream: !sp.debugStream, hint: void 0 }
         };
-      if (f === 33) {
+      if (f === 34) {
         const i = STATUSLINE_MODES.indexOf(sp.statuslineMode);
         const base = i < 0 ? STATUSLINE_MODES.indexOf("detailed") : i;
         const next = (base + action.delta + STATUSLINE_MODES.length) % STATUSLINE_MODES.length;
@@ -10742,7 +11756,7 @@ function reducer(state, action) {
           }
         };
       }
-      if (f === 34) {
+      if (f === 35) {
         const i = CONFIG_SCOPES.indexOf(sp.configScope);
         const base = i < 0 ? 0 : i;
         const next = (base + action.delta + CONFIG_SCOPES.length) % CONFIG_SCOPES.length;
@@ -10757,8 +11771,67 @@ function reducer(state, action) {
       }
       return state;
     }
+    case "settingsValueSet": {
+      return {
+        ...state,
+        settingsPicker: { ...state.settingsPicker, ...action.patch, hint: void 0 }
+      };
+    }
     case "settingsHint":
       return { ...state, settingsPicker: { ...state.settingsPicker, hint: action.text } };
+    case "settingsThinkingEditStart":
+      return {
+        ...state,
+        settingsPicker: {
+          ...state.settingsPicker,
+          thinkingWordEditing: true,
+          // Seed the draft with the current word so the user edits from it.
+          thinkingWordDraft: state.settingsPicker.thinkingWord,
+          hint: void 0
+        }
+      };
+    case "settingsThinkingEditChange":
+      return {
+        ...state,
+        settingsPicker: {
+          ...state.settingsPicker,
+          // Hard-cap the draft so it can't grow past the persisted limit.
+          thinkingWordDraft: action.draft.slice(0, MAX_TUI_THINKING_WORD_LENGTH),
+          hint: void 0
+        }
+      };
+    case "settingsThinkingEditCommit": {
+      const sp = state.settingsPicker;
+      const raw = sp.thinkingWordDraft.trim();
+      if (raw.length === 0) {
+        return {
+          ...state,
+          settingsPicker: { ...sp, thinkingWordEditing: false, thinkingWordDraft: "", hint: void 0 }
+        };
+      }
+      const normalized = normalizeTuiThinkingWord(raw);
+      const valid = normalized === raw;
+      return {
+        ...state,
+        settingsPicker: {
+          ...sp,
+          thinkingWord: valid ? normalized : sp.thinkingWord,
+          thinkingWordEditing: false,
+          thinkingWordDraft: "",
+          hint: valid ? void 0 : `Invalid word \u2014 keep it \u2264${MAX_TUI_THINKING_WORD_LENGTH} chars (letters/digits/_/-)`
+        }
+      };
+    }
+    case "settingsThinkingEditCancel":
+      return {
+        ...state,
+        settingsPicker: {
+          ...state.settingsPicker,
+          thinkingWordEditing: false,
+          thinkingWordDraft: "",
+          hint: void 0
+        }
+      };
     // ── Statusline picker ───────────────────────────────────────────────
     case "statuslineOpen":
       return {
@@ -12085,7 +13158,7 @@ function App({
     },
     autonomyPicker: { open: false, options: [], selected: 0 },
     resumePicker: { open: false, sessions: [], selected: 0, busy: false, hint: void 0, error: void 0 },
-    settingsPicker: { open: false, field: 0, mode: "off", delayMs: 0, titleAnimation: true, yolo: false, streamFleet: true, chime: false, confirmExit: true, nextPrediction: false, featureMcp: true, featurePlugins: true, featureMemory: true, featureSkills: true, featureModelsRegistry: true, tokenSavingTier: "off", allowOutsideProjectRoot: true, contextAutoCompact: true, contextStrategy: "hybrid", contextMode: "balanced", maxConcurrent: 10, logLevel: "info", auditLevel: "standard", indexOnStart: true, maxIterations: 500, autoProceedMaxIterations: 50, enhanceDelayMs: 6e4, enhanceEnabled: true, enhanceLanguage: "original", debugStream: false, statuslineMode: "detailed", reasoningMode: "auto", reasoningEffort: "high", reasoningPreserve: false, thinkingWord: "thinking", cacheTtl: "default", configScope: "global" },
+    settingsPicker: { open: false, field: 0, lastSettingsField: 0, filter: "", mode: "off", delayMs: 0, titleAnimation: true, yolo: false, streamFleet: true, chime: false, confirmExit: true, nextPrediction: false, featureMcp: true, featurePlugins: true, featureMemory: true, featureSkills: true, featureModelsRegistry: true, tokenSavingTier: "off", allowOutsideProjectRoot: true, contextAutoCompact: true, contextStrategy: "hybrid", contextMode: "balanced", maxConcurrent: 10, logLevel: "info", auditLevel: "standard", indexOnStart: true, multiDiffSummaryThreshold: 5, maxIterations: 500, autoProceedMaxIterations: 50, enhanceDelayMs: 6e4, enhanceEnabled: true, enhanceLanguage: "original", debugStream: false, statuslineMode: "detailed", reasoningMode: "auto", reasoningEffort: "high", reasoningPreserve: false, thinkingWord: "thinking", thinkingWordEditing: false, thinkingWordDraft: "", cacheTtl: "default", configScope: "global" },
     statuslinePicker: { open: false, field: 0, hiddenItems: [], visibleChips: [], hint: void 0 },
     projectPicker: { open: false, allItems: [], items: [], selected: 0, filter: "", hint: void 0 },
     fKeyPicker: { open: false, selected: 0 },
@@ -12222,6 +13295,20 @@ function App({
   const liveSettings = getSettings?.();
   const liveStatuslineMode = liveSettings?.statuslineMode ?? "detailed";
   const liveThinkingWord = liveSettings?.thinkingWord ?? "thinking";
+  const [rolledThinkingWord, setRolledThinkingWord] = useState(
+    () => pickRandomTuiThinkingWord()
+  );
+  const thinkingWorking = state.status === "running" || state.status === "streaming";
+  const prevThinkingWorkingRef = useRef(false);
+  useEffect(() => {
+    if (thinkingWorking && !prevThinkingWorkingRef.current) {
+      setRolledThinkingWord((prev) => pickRandomTuiThinkingWord(prev));
+    }
+    prevThinkingWorkingRef.current = thinkingWorking;
+  }, [thinkingWorking]);
+  const displayThinkingWord = isRandomTuiThinkingWord(liveThinkingWord) ? rolledThinkingWord : liveThinkingWord;
+  const displayThinkingWordRef = useRef(displayThinkingWord);
+  displayThinkingWordRef.current = displayThinkingWord;
   const chimeRef = useRef(chime);
   chimeRef.current = liveSettings?.chime ?? chime;
   const confirmExitRef = useRef(confirmExit);
@@ -12809,6 +13896,8 @@ function App({
             logLevel: sp.logLevel,
             auditLevel: sp.auditLevel,
             indexOnStart: sp.indexOnStart,
+            multiDiffSummaryThreshold: sp.multiDiffSummaryThreshold,
+            lastSettingsField: sp.lastSettingsField,
             maxIterations: sp.maxIterations,
             autoProceedMaxIterations: sp.autoProceedMaxIterations,
             enhanceDelayMs: sp.enhanceDelayMs,
@@ -13208,6 +14297,8 @@ function App({
       logLevel: s2.logLevel ?? "info",
       auditLevel: s2.auditLevel ?? "standard",
       indexOnStart: s2.indexOnStart ?? true,
+      multiDiffSummaryThreshold: s2.multiDiffSummaryThreshold ?? 5,
+      lastSettingsField: s2.lastSettingsField ?? 0,
       maxIterations: s2.maxIterations ?? 500,
       autoProceedMaxIterations: s2.autoProceedMaxIterations ?? 50,
       enhanceDelayMs: s2.enhanceDelayMs ?? 6e4,
@@ -13352,6 +14443,8 @@ function App({
       logLevel: sp.logLevel,
       auditLevel: sp.auditLevel,
       indexOnStart: sp.indexOnStart,
+      multiDiffSummaryThreshold: sp.multiDiffSummaryThreshold,
+      lastSettingsField: sp.lastSettingsField,
       maxIterations: sp.maxIterations,
       autoProceedMaxIterations: sp.autoProceedMaxIterations,
       enhanceDelayMs: sp.enhanceDelayMs,
@@ -13442,8 +14535,95 @@ function App({
     const cmd = {
       name: "settings",
       aliases: ["config", "prefs"],
-      description: "Open the interactive settings editor (19 config fields across 8 sections).",
-      async run() {
+      description: "Open the settings editor, or set a value inline: /settings [<chord> [<value>]].",
+      argsHint: "[<chord> [<value>]]",
+      help: "Open the settings editor.\n\n  /settings              Open on the last-visited row\n  /settings <chord>      Open on that row\n  /settings <chord> <v>  Set <chord> to <v> without opening the picker\n  /settings reset <chord> Reset <chord> to its factory default\n\nExamples:\n  /settings yolo on      Enable YOLO mode\n  /settings multi-diff 8  Set multi-diff threshold to 8\n  /settings thinking-word pondering  Set the working-state word\n\nAvailable chords:\n  " + settingsPickerJumpNames().join("\n  "),
+      async run(args) {
+        const query = args.trim();
+        if (query === "") {
+          openSettings();
+          return { message: void 0 };
+        }
+        if (query === "reset" || query.startsWith("reset ")) {
+          const subArg = query.slice("reset".length).trim();
+          if (subArg === "") {
+            return {
+              message: "Usage: /settings reset <chord>\nAvailable: " + settingsPickerJumpNames().join(", ")
+            };
+          }
+          const field2 = settingsPickerJumpByName(subArg);
+          if (field2 === void 0) {
+            return {
+              message: `Unknown settings row "${subArg}".
+Available chords:
+  ${settingsPickerJumpNames().join("\n  ")}`
+            };
+          }
+          const result = resetSettingsFieldValue(field2);
+          if (!result.ok) {
+            return { message: result.error };
+          }
+          dispatch({ type: "settingsValueSet", patch: result.patch });
+          const cur = getSettings ? getSettings() : void 0;
+          if (cur && saveSettings) {
+            const { tokenSavingTier, ...rest } = result.patch;
+            Promise.resolve(
+              saveSettings({
+                ...cur,
+                ...rest,
+                ...tokenSavingTier !== void 0 ? { featureTokenSaving: tokenSavingTier } : {}
+              })
+            ).then((err) => {
+              if (err) dispatch({ type: "settingsHint", text: err });
+            });
+          }
+          return { message: `\u21BA ${result.label} reset to ${result.displayValue}` };
+        }
+        const spaceIdx = query.indexOf(" ");
+        if (spaceIdx > 0) {
+          const rowName = query.slice(0, spaceIdx);
+          const valueStr = query.slice(spaceIdx + 1).trim();
+          const field2 = settingsPickerJumpByName(rowName);
+          if (field2 === void 0) {
+            return {
+              message: `Unknown settings row "${rowName}".
+Available chords:
+  ${settingsPickerJumpNames().join("\n  ")}`
+            };
+          }
+          if (valueStr === "") {
+            dispatch({ type: "settingsFieldSet", field: field2 });
+            openSettings();
+            return { message: void 0 };
+          }
+          const result = resolveSettingsFieldValue(field2, valueStr);
+          if (!result.ok) {
+            return { message: result.error };
+          }
+          dispatch({ type: "settingsValueSet", patch: result.patch });
+          const cur = getSettings ? getSettings() : void 0;
+          if (cur && saveSettings) {
+            const { tokenSavingTier, ...rest } = result.patch;
+            const updated = {
+              ...cur,
+              ...rest,
+              ...tokenSavingTier !== void 0 ? { featureTokenSaving: tokenSavingTier } : {}
+            };
+            Promise.resolve(saveSettings(updated)).then((err) => {
+              if (err) dispatch({ type: "settingsHint", text: err });
+            });
+          }
+          return { message: `\u2713 ${result.label} \u2192 ${result.displayValue}` };
+        }
+        const field = settingsPickerJumpByName(query);
+        if (field === void 0) {
+          return {
+            message: `Unknown settings row "${query}".
+Available chords:
+  ${settingsPickerJumpNames().join("\n  ")}`
+          };
+        }
+        dispatch({ type: "settingsFieldSet", field });
         openSettings();
         return { message: void 0 };
       }
@@ -13452,7 +14632,39 @@ function App({
     return () => {
       slashRegistry.unregister("settings");
     };
-  }, [slashRegistry, getSettings, saveSettings, openSettings]);
+  }, [slashRegistry, getSettings, saveSettings, openSettings, dispatch]);
+  useEffect(() => {
+    const cmd = {
+      name: "settings-get",
+      aliases: ["config-get", "get"],
+      description: "Read a setting value without opening the picker.",
+      argsHint: "<chord>",
+      help: 'Show the current value of a setting.\n\nExamples:\n  /settings-get yolo         \u2192 "YOLO mode: off"\n  /settings-get multi-diff   \u2192 "Multi-diff summary: 5"\n  /settings-get log-level    \u2192 "Log level: info"\n\nAvailable chords:\n  ' + settingsPickerJumpNames().join("\n  "),
+      async run(args) {
+        const query = args.trim();
+        if (query === "") {
+          return { message: formatAllSettingsSummary(state.settingsPicker) };
+        }
+        const field = settingsPickerJumpByName(query);
+        if (field === void 0) {
+          return {
+            message: `Unknown settings row "${query}".
+Available chords:
+  ${settingsPickerJumpNames().join("\n  ")}`
+          };
+        }
+        const result = getSettingsFieldValue(state.settingsPicker, field);
+        if (!result.ok) {
+          return { message: result.error };
+        }
+        return { message: `${result.label}: ${result.displayValue}` };
+      }
+    };
+    slashRegistry.register(cmd, "tui", { official: true });
+    return () => {
+      slashRegistry.unregister("settings-get");
+    };
+  }, [slashRegistry, state.settingsPicker]);
   useEffect(() => {
     const cmd = {
       name: "statusline",
@@ -14207,6 +15419,29 @@ function App({
       return;
     }
     if (state.settingsPicker.open) {
+      const sp = state.settingsPicker;
+      if (sp.thinkingWordEditing) {
+        if (key.escape) {
+          dispatch({ type: "settingsThinkingEditCancel" });
+          return;
+        }
+        if (isEnter) {
+          const now = Date.now();
+          if (now - lastEnterAtRef.current < 50) return;
+          lastEnterAtRef.current = now;
+          dispatch({ type: "settingsThinkingEditCommit" });
+          return;
+        }
+        if (key.backspace) {
+          dispatch({ type: "settingsThinkingEditChange", draft: sp.thinkingWordDraft.slice(0, -1) });
+          return;
+        }
+        if (input && input.length === 1 && input.charCodeAt(0) >= 32 && input.charCodeAt(0) < 127) {
+          dispatch({ type: "settingsThinkingEditChange", draft: sp.thinkingWordDraft + input });
+          return;
+        }
+        return;
+      }
       if (key.escape || key.ctrl && input === "s") {
         dispatch({ type: "settingsClose" });
         return;
@@ -14215,6 +15450,33 @@ function App({
         dispatch({ type: "settingsFieldMove", delta: key.mouse.wheel > 0 ? -1 : 1 });
         return;
       }
+      if (input && input.length === 1 && (key.ctrl || key.meta)) {
+        const mod = key.ctrl ? "ctrl" : key.shift ? "alt-shift" : "alt";
+        const field = settingsPickerJumpField(mod, input);
+        if (field !== void 0) {
+          dispatch({ type: "settingsFieldSet", field });
+          return;
+        }
+      }
+      if (input === "/" && sp.filter === "") {
+        dispatch({ type: "settingsFilterSet", filter: "/" });
+        return;
+      }
+      if (sp.filter !== "") {
+        if (key.escape) {
+          dispatch({ type: "settingsFilterSet", filter: "" });
+          return;
+        }
+        if (key.backspace) {
+          const next2 = sp.filter.length > 1 ? sp.filter.slice(0, -1) : "";
+          dispatch({ type: "settingsFilterSet", filter: next2 });
+          return;
+        }
+        if (input && input.length === 1 && input.charCodeAt(0) >= 32 && input.charCodeAt(0) < 127) {
+          dispatch({ type: "settingsFilterSet", filter: sp.filter + input });
+          return;
+        }
+      }
       if (key.upArrow) {
         dispatch({ type: "settingsFieldMove", delta: -1 });
         return;
@@ -14235,7 +15497,15 @@ function App({
         const now = Date.now();
         if (now - lastEnterAtRef.current < 50) return;
         lastEnterAtRef.current = now;
-        dispatch({ type: "settingsValueChange", delta: 1 });
+        if (sp.filter !== "") {
+          dispatch({ type: "settingsFilterSet", filter: "" });
+          return;
+        }
+        if (sp.field === THINKING_WORD_FIELD) {
+          dispatch({ type: "settingsThinkingEditStart" });
+        } else {
+          dispatch({ type: "settingsValueChange", delta: 1 });
+        }
         return;
       }
       return;
@@ -14853,6 +16123,8 @@ function App({
           logLevel: cfg.logLevel ?? "info",
           auditLevel: cfg.auditLevel ?? "standard",
           indexOnStart: cfg.indexOnStart ?? true,
+          multiDiffSummaryThreshold: cfg.multiDiffSummaryThreshold ?? 5,
+          lastSettingsField: cfg.lastSettingsField ?? 0,
           maxIterations: cfg.maxIterations ?? 500,
           autoProceedMaxIterations: cfg.autoProceedMaxIterations ?? 50,
           enhanceDelayMs: cfg.enhanceDelayMs ?? 6e4,
@@ -15124,7 +16396,7 @@ function App({
             // Must match the rendered state label width — while streaming the bar
             // shows the configured thinking word, so the span shifts with it.
             // Omitting this made the model chip un-clickable mid-stream.
-            thinkingWord: liveThinkingWord,
+            thinkingWord: displayThinkingWordRef.current,
             model: `${liveProvider}/${liveModel}`
           });
           if (inSpan(span)) {
@@ -15732,10 +17004,12 @@ User message:
       if (autonomyLive === "auto" && nextStepsAutoSubmitTimerRef.current != null) {
         switchAutonomy?.("off");
       }
-      dispatch({
-        type: "addEntry",
-        entry: { kind: "user", text: displayText, queued: true, pasteContent }
-      });
+      if (!steering) {
+        dispatch({
+          type: "addEntry",
+          entry: { kind: "user", text: displayText, queued: true, pasteContent }
+        });
+      }
       dispatch({ type: "enqueue", item: { displayText, blocks } });
       return;
     }
@@ -15808,7 +17082,7 @@ User message:
         onMeasure: (totalLines) => dispatch({ type: "setMeasuredLines", totalLines }),
         setSuggestions,
         autonomyMode: autonomyLive,
-        autoSubmitCountdown: nextStepsAutoSubmitCountdown
+        multiDiffSummaryThreshold: state.settingsPicker.multiDiffSummaryThreshold
       }
     ) : /* @__PURE__ */ jsx(
       History,
@@ -15819,7 +17093,7 @@ User message:
         toolStream: state.toolStream,
         setSuggestions,
         autonomyMode: autonomyLive,
-        autoSubmitCountdown: nextStepsAutoSubmitCountdown
+        multiDiffSummaryThreshold: state.settingsPicker.multiDiffSummaryThreshold
       }
     ),
     /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexShrink: 0, ref: bottomRegionRef, children: [
@@ -15909,7 +17183,10 @@ User message:
           logLevel: state.settingsPicker.logLevel,
           auditLevel: state.settingsPicker.auditLevel,
           indexOnStart: state.settingsPicker.indexOnStart,
+          multiDiffSummaryThreshold: state.settingsPicker.multiDiffSummaryThreshold,
           thinkingWord: state.settingsPicker.thinkingWord,
+          thinkingWordEditing: state.settingsPicker.thinkingWordEditing,
+          thinkingWordDraft: state.settingsPicker.thinkingWordDraft,
           maxIterations: state.settingsPicker.maxIterations,
           autoProceedMaxIterations: state.settingsPicker.autoProceedMaxIterations,
           enhanceDelayMs: state.settingsPicker.enhanceDelayMs,
@@ -15922,6 +17199,7 @@ User message:
           reasoningPreserve: state.settingsPicker.reasoningPreserve,
           cacheTtl: state.settingsPicker.cacheTtl,
           configScope: state.settingsPicker.configScope,
+          filter: state.settingsPicker.filter,
           hint: state.settingsPicker.hint
         }
       ) : null,
@@ -16080,7 +17358,7 @@ User message:
           model: `${liveProvider}/${liveModel}`,
           version: appVersion,
           state: state.status,
-          thinkingWord: liveThinkingWord,
+          thinkingWord: displayThinkingWord,
           tokenCounter,
           hint: renderRunningTools(state.runningTools) || state.hint,
           queueCount: state.queue.length,