@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/@herbertgao/pi-subagents/src/ui/fleet-list.ts

@@ -19,7 +19,7 @@ import {
   truncateToWidth,
   visibleWidth,
 } from "@earendil-works/pi-tui"
-import { renderAgentName } from "../agent-color.js"
+import { hasAgentBadge, renderAgentName } from "../agent-color.js"
 import type { AgentManager } from "../agent-manager.js"
 import type { AgentRecord } from "../types.js"
 import { getLifetimeTotal } from "../usage.js"
@@ -476,15 +476,24 @@ export class FleetList {
     width: number,
     theme: Theme,
   ): string {
-    const left = `  ${this.bullet(rosterIndex, sel, theme)} ${renderAgentName(record.type, theme, { fallbackColor: "muted" })}  ${record.description}`
+    const selected = rosterIndex === sel
+    const name = renderAgentName(
+      record.type,
+      theme,
+      selected
+        ? { fallbackColor: "text", bold: hasAgentBadge(record.type) }
+        : { fallbackColor: "muted" },
+    )
+    const description = selected
+      ? theme.fg("text", record.description)
+      : record.description
+    const left = `  ${this.bullet(rosterIndex, sel, theme)} ${name}  ${description}`
     const tokens = getLifetimeTotal(
       this.agentActivity.get(record.id)?.lifetimeUsage ?? record.lifetimeUsage,
     )
     const elapsedMs = (record.completedAt ?? Date.now()) - record.startedAt // freezes once finished
-    const right = theme.fg(
-      "dim",
-      `${formatFleetElapsed(elapsedMs)} · ${formatFleetTokens(tokens)}`,
-    )
+    const stats = `${formatFleetElapsed(elapsedMs)} · ${formatFleetTokens(tokens)}`
+    const right = selected ? theme.fg("text", stats) : theme.fg("dim", stats)
     return rightAlign(left, right, width)
   }
 }

package/node_modules/@herbertgao/pi-subagents/src/ui/schedule-menu.ts

@@ -11,6 +11,7 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent"
 import type { SubagentScheduler } from "../schedule.js"
 import type { ScheduledSubagent } from "../types.js"
+import { selectItem } from "./select-item.js"
 
 /** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
 function relTime(iso: string | undefined, now = Date.now()): string {
@@ -88,16 +89,16 @@ export async function showSchedulesMenu(
     return
   }
 
-  const labels = jobs.map((j) => formatJob(j, scheduler))
-  const choice = await ctx.ui.select(
+  // Numbered + item-paired: two jobs whose names agree in the first 18
+  // characters format identically, and matching the returned string back
+  // against a parallel label array cancelled whichever came first.
+  const job = await selectItem(
+    ctx.ui,
     `Scheduled jobs (${jobs.length}) — select to cancel`,
-    labels,
+    jobs,
+    (j) => formatJob(j, scheduler),
   )
-  if (!choice) return
-
-  const idx = labels.indexOf(choice)
-  if (idx < 0) return
-  const job = jobs[idx]
+  if (!job) return
 
   const ok = await ctx.ui.confirm(
     `Cancel "${job.name}"?`,

package/node_modules/@herbertgao/pi-subagents/src/ui/select-item.ts

@@ -0,0 +1,48 @@
+/**
+ * select-item.ts — pick an item from a list via `ctx.ui.select`, safely.
+ *
+ * Pi's dialog API is `select(title, options: string[]) => Promise<string | undefined>`:
+ * strings in, string out, with no index or value form. Callers therefore have to
+ * map the returned string back to the item it came from, and the obvious way —
+ * `labels.indexOf(choice)` over a parallel array — silently resolves to the
+ * FIRST match whenever two rows format identically. Row formatters here truncate
+ * (job names to 18 chars, agent descriptions to whatever fits), and the text they
+ * truncate is LLM-authored, so collisions are ordinary rather than exotic.
+ *
+ * This numbers every row, which makes the labels unique by construction — no
+ * data-dependent branch that only executes in the case nobody exercises — and
+ * keeps each label paired with its item so a later edit that sorts or filters
+ * between building and resolving cannot desync them.
+ */
+
+/** Minimal shape of the `ctx.ui` surface this needs. */
+export interface SelectUI {
+  select(title: string, options: string[]): Promise<string | undefined>
+}
+
+/**
+ * Show a numbered picker and return the chosen item (not its label).
+ *
+ * Returns undefined when the user escapes, or when the returned string is not
+ * one we offered.
+ */
+export async function selectItem<T>(
+  ui: SelectUI,
+  title: string,
+  items: readonly T[],
+  format: (item: T, index: number) => string,
+): Promise<T | undefined> {
+  // Pad the number so a 10+ item list keeps its columns aligned.
+  const width = String(items.length).length
+  const rows = items.map((item, i) => ({
+    item,
+    label: `${String(i + 1).padStart(width)}. ${format(item, i)}`,
+  }))
+
+  const choice = await ui.select(
+    title,
+    rows.map((r) => r.label),
+  )
+  if (!choice) return undefined
+  return rows.find((r) => r.label === choice)?.item
+}

package/node_modules/@herbertgao/pi-subagents/src/worktree.ts

@@ -134,11 +134,15 @@ export function cleanupWorktree(
       // Truncate description for commit message (no shell sanitization needed — execFileSync uses argv)
       const safeDesc = agentDescription.slice(0, 200)
       const commitMsg = `pi-agent: ${safeDesc}`
-      execFileSync("git", ["commit", "--no-verify", "-m", commitMsg], {
-        cwd: worktree.path,
-        stdio: "pipe",
-        timeout: 10000,
-      })
+      execFileSync(
+        "git",
+        ["commit", "--no-verify", "--no-gpg-sign", "-m", commitMsg],
+        {
+          cwd: worktree.path,
+          stdio: "pipe",
+          timeout: 10000,
+        },
+      )
     } else {
       const currentSha = execFileSync("git", ["rev-parse", "HEAD"], {
         cwd: worktree.path,

package/node_modules/@juicesharp/rpiv-ask-user-question/README.md

@@ -27,6 +27,8 @@ Nothing to set up — the tool is live as soon as Pi restarts. Hand the model a
 
 Rather than picking a strategy on your behalf, the model calls `ask_user_question` and a dialog takes over the bottom of your terminal. Move with `↑`/`↓`, choose with `Enter`, press `n` to attach a note, or land on the `Type something.` row to answer in your own words. While typing, `Shift+Enter` adds a line, `Ctrl+G` opens Pi's configured external editor, and `Ctrl+U` clears the draft; browsing another option and returning keeps what you wrote. `Esc` abandons the questionnaire entirely.
 
+When the questionnaire begins waiting in an interactive TTY, it emits one standard terminal BEL (`\x07`). Your terminal configuration determines whether that appears as an audible alert, a visual alert, or nothing; redirected and non-TTY output is untouched.
+
 ![Single question in the dialog: the tab strip reads Feature Type, Design Tab, Testing, Release, Submit; the question Which real development task are we planning right now? sits above four numbered options — Bug fix (Recommended), New feature, Refactor, Perf tuning — each with a one-line description, followed by the appended Type something. row](https://raw.githubusercontent.com/juicesharp/rpiv-mono/main/packages/rpiv-ask-user-question/docs/single-question.jpg)
 
 When the model asks several things at once, `Tab` moves between them and a Submit tab reviews everything before it goes back:

package/node_modules/@juicesharp/rpiv-ask-user-question/ask-user-question.ts

@@ -61,6 +61,24 @@ const ERROR_SESSION_LOAD_FAILED =
 const ERROR_STALE_MODULE_CACHE =
 	"Error: the questionnaire UI cannot load — the host's module cache went stale after an earlier failed load (typically dependencies replaced on disk mid-session). This is unrecoverable within the current Pi process. The user never saw the questions — do NOT treat this as a decline. Ask the questions as plain chat text instead, and tell the user to restart Pi to restore this tool.";
 
+/** Standard terminal bell — same byte rpiv-warp exports as OSC_TERMINATOR. */
+export const BEL = "\x07";
+
+/**
+ * Emit one portable terminal attention signal without touching redirected output.
+ * Writes to stdout rather than rpiv-warp's `/dev/tty` transport: the `isTTY` gate
+ * both proves an interactive terminal owns the coming wait and keeps the byte out
+ * of piped RPC transports (VS Code pendant, Zed) — a `/dev/tty` write would ring
+ * even when the questionnaire renders in a remote host's own UI.
+ */
+function emitTerminalAttention(): void {
+	try {
+		if (process.stdout.isTTY) process.stdout.write(BEL);
+	} catch {
+		// Terminal attention is best effort; the questionnaire must still proceed.
+	}
+}
+
 /** Delay before the background session-graph pre-warm; mirrors rpiv-workflow's /wf prewarm. */
 export const PREWARM_DELAY_MS = 2000;
 
@@ -173,6 +191,7 @@ Preview content is rendered as markdown in a monospace box. Multi-line text with
 			if ((ctx as { mode?: string }).mode === "rpc" && hasDialogUI(ctx.ui)) {
 				emitAskUserBlockedEvent(pi, true);
 				try {
+					emitTerminalAttention();
 					return buildQuestionnaireResponse(await runRpcQuestionnaire(ctx.ui, typed), typed);
 				} finally {
 					emitAskUserBlockedEvent(pi, false);
@@ -232,6 +251,7 @@ Preview content is rendered as markdown in a monospace box. Multi-line text with
 
 			emitAskUserBlockedEvent(pi, true);
 			try {
+				emitTerminalAttention();
 				const result = await ctx.ui.custom<QuestionnaireResult>(
 					(tui, theme, keybindings, done) => {
 						const session = new QuestionnaireSession({

package/node_modules/@juicesharp/rpiv-ask-user-question/docs/hosts.md

@@ -11,6 +11,12 @@ render at all.
 | RPC / ACP host (VS Code pendant, Zed, Paseo) | `ask_user_question` in its tool list | A sequence of the host's own native select and input dialogs |
 | Non-interactive run (no UI) | Nothing — the tool is removed | Nothing |
 
+### Terminal attention
+
+After UI availability and questionnaire validation succeed, the package emits exactly one standard terminal BEL (`\x07`) immediately before the interactive wait begins. The signal is sent to `stdout` only when `process.stdout.isTTY` is true, so redirected output and non-TTY RPC streams stay untouched. A TTY-backed RPC dialog walker receives the same signal as the TUI path.
+
+The BEL is best effort: if the synchronous terminal write fails, the questionnaire continues and its existing prompt/blocked lifecycle and result envelope are unchanged. The terminal configuration decides whether the BEL is audible, visual, or ignored. No BEL is emitted for missing UI, invalid questionnaires, or a failed TUI session load.
+
 ### Non-interactive runs
 
 A `before_agent_start` hook reconciles the active tool set against `ctx.hasUI` before every

package/node_modules/@juicesharp/rpiv-ask-user-question/docs/keyboard.md

@@ -18,6 +18,13 @@ adapts to the size of your terminal.
 | `Ctrl+U` | Clear the current custom-answer draft. | `Type something.` input |
 | `Ctrl+]` | Collapse or expand the dialog. Configurable via `collapseKey`. | Everywhere, including while collapsed |
 
+The table names the default keys; the dialog actually follows your Pi keybindings.
+Confirm listens to both `tui.select.confirm` and `tui.input.submit`, and a key bound to
+`tui.input.newLine` always inserts a newline even if it also matches confirm. So a
+Slack-style configuration — `enter` folded into `tui.input.newLine`, submit moved to
+`ctrl+enter` — keeps working: `enter` breaks lines, and your submit key confirms
+everywhere `Enter` does.
+
 In a multi-select question, `Enter` on a regular row toggles its checkbox exactly like
 `Space` — it does not submit. Committing the question means focusing the `Next` row and
 pressing `Enter`. That is deliberate: it makes `Enter` a zero-cost way to flip boxes

package/node_modules/@juicesharp/rpiv-ask-user-question/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@juicesharp/rpiv-ask-user-question",
-	"version": "2.4.0",
+	"version": "2.6.0",
 	"description": "Pi extension. A structured questionnaire the model can put to you when it would otherwise guess, with typed options instead of free-form replies.",
 	"keywords": [
 		"pi-package",
@@ -93,7 +93,7 @@
 		}
 	},
 	"dependencies": {
-		"@juicesharp/rpiv-config": "^2.4.0",
+		"@juicesharp/rpiv-config": "^2.6.0",
 		"typebox": "^1.1.24"
 	}
 }

package/node_modules/@juicesharp/rpiv-ask-user-question/state/build-questionnaire.ts

@@ -130,6 +130,13 @@ class QuestionnaireBuilder {
 		const textEditorTheme = editorTheme(this.theme);
 		this.notesInput = new Editor(this.tui, textEditorTheme);
 		this.inlineInput = new Editor(this.tui, textEditorTheme);
+		// The key router owns confirm/submit semantics; keys reaching these headless
+		// editors are text-editing only. Without this, a `tui.input.submit` match inside
+		// Editor.handleInput would run submitValue(), which resets the buffer and
+		// silently destroys the draft — no onSubmit is wired here, so the text is
+		// unrecoverable (#156).
+		this.notesInput.disableSubmit = true;
+		this.inlineInput.disableSubmit = true;
 	}
 
 	build(): QuestionnaireBuilt {

package/node_modules/@juicesharp/rpiv-ask-user-question/state/key-router.ts

@@ -6,6 +6,7 @@ import type { QuestionnaireRuntime, QuestionnaireState } from "./state.js";
 const KEYBIND_UP = "tui.select.up";
 const KEYBIND_DOWN = "tui.select.down";
 const KEYBIND_CONFIRM = "tui.select.confirm";
+const KEYBIND_SUBMIT = "tui.input.submit";
 const KEYBIND_CANCEL = "tui.select.cancel";
 const KEYBIND_NEW_LINE = "tui.input.newLine";
 const KEYBIND_EDITOR_UP = "tui.editor.cursorUp";
@@ -39,6 +40,16 @@ export interface QuestionnaireKeybindings {
 	matches(data: string, name: string): boolean;
 }
 
+// Confirm has two semantic sources: `tui.select.confirm` (the select-list default)
+// and `tui.input.submit` (the user's "send" key). A Slack-style configuration folds
+// `enter` into `tui.input.newLine` and moves submit elsewhere (e.g. `ctrl+enter`);
+// the newline checks below stay first, so without the submit source every confirm
+// branch would be shadowed by the collision and no key could confirm (#156). With
+// pi defaults both names resolve to `enter`, so matching either is equivalent.
+function isConfirm(kb: QuestionnaireKeybindings, data: string): boolean {
+	return kb.matches(data, KEYBIND_CONFIRM) || kb.matches(data, KEYBIND_SUBMIT);
+}
+
 export function wrapTab(index: number, total: number): number {
 	if (total <= 0) return 0;
 	return ((index % total) + total) % total;
@@ -183,7 +194,7 @@ export function routeKey(data: string, state: QuestionnaireState, runtime: Quest
 	if (state.notesVisible) {
 		if (kb.matches(data, KEYBIND_CANCEL)) return { kind: "notes_exit" };
 		if (kb.matches(data, KEYBIND_NEW_LINE)) return { kind: "notes_forward", data };
-		if (kb.matches(data, KEYBIND_CONFIRM)) return { kind: "notes_exit" };
+		if (isConfirm(kb, data)) return { kind: "notes_exit" };
 		return { kind: "notes_forward", data };
 	}
 
@@ -191,7 +202,7 @@ export function routeKey(data: string, state: QuestionnaireState, runtime: Quest
 		// Newline takes precedence over confirmation if a user configuration binds
 		// the same physical key to both semantic actions.
 		if (kb.matches(data, KEYBIND_NEW_LINE)) return { kind: "ignore" };
-		if (kb.matches(data, KEYBIND_CONFIRM)) {
+		if (isConfirm(kb, data)) {
 			const answer = buildSingleSelectAnswer(state, runtime);
 			if (!answer) return { kind: "ignore" };
 			return { kind: "confirm", answer, autoAdvanceTab: computeAutoAdvanceTab(state, runtime) };
@@ -219,7 +230,7 @@ export function routeKey(data: string, state: QuestionnaireState, runtime: Quest
 			const next = wrapTab(state.submitChoiceIndex + delta, 2);
 			return { kind: "submit_nav", nextIndex: (next === 1 ? 1 : 0) as 0 | 1 };
 		}
-		if (kb.matches(data, KEYBIND_CONFIRM)) {
+		if (isConfirm(kb, data)) {
 			// D1 (revised): Submit always submits; Cancel always cancels. The warning header
 			// is informational only — `allAnswered(state)` no longer gates submission. Partial
 			// answers flow through `orderedAnswers()` in the host.
@@ -265,7 +276,7 @@ export function routeKey(data: string, state: QuestionnaireState, runtime: Quest
 			if (focusedMeta?.activatesInputMode) return { kind: "ignore" };
 			return { kind: "toggle", index: state.optionIndex };
 		}
-		if (kb.matches(data, KEYBIND_CONFIRM)) {
+		if (isConfirm(kb, data)) {
 			// Enter on the "Type something." row is handled by the inputMode block above
 			// (→ confirm kind:"custom"). Defensive: never enter the toggle/multi_confirm
 			// path for an inputMode-activating row.
@@ -289,7 +300,7 @@ export function routeKey(data: string, state: QuestionnaireState, runtime: Quest
 		return { kind: "ignore" };
 	}
 
-	if (kb.matches(data, KEYBIND_CONFIRM)) {
+	if (isConfirm(kb, data)) {
 		const answer = buildSingleSelectAnswer(state, runtime);
 		if (!answer) return { kind: "ignore" };
 		return { kind: "confirm", answer, autoAdvanceTab: computeAutoAdvanceTab(state, runtime) };

package/node_modules/@juicesharp/rpiv-ask-user-question/state/questionnaire-session.ts

@@ -139,7 +139,9 @@ export class QuestionnaireSession {
 	}
 
 	private mirrorNotesDraft(s: QuestionnaireState): QuestionnaireState {
-		const draft = this.notesInput.getText();
+		// Drafts restore through Editor.setText, which clears the backing paste map —
+		// read expanded so stored drafts never orphan a paste marker.
+		const draft = this.notesInput.getExpandedText?.() ?? this.notesInput.getText();
 		return s.notesDraft === draft ? s : { ...s, notesDraft: draft };
 	}
 
@@ -202,7 +204,7 @@ export class QuestionnaireSession {
 		const lastLine = this.inlineInput.getLines().length - 1;
 		return {
 			keybindings: this.keybindings,
-			inputBuffer: this.inlineInput.getText(),
+			inputBuffer: this.inlineInput.getExpandedText?.() ?? this.inlineInput.getText(),
 			canMoveInputUp: cursor.line > 0,
 			canMoveInputDown: cursor.line < lastLine,
 			questions: this.questions,

package/node_modules/@narumitw/pi-btw/README.md

@@ -18,7 +18,7 @@ Use it when you want to ask a temporary question, inspect context, or get a shor
 - Optionally brings the latest answer, a question-to-end suffix, an exact line range, or the entire side thread into the main editor.
 - Uses the current session branch as context.
 - Uses Pi's current model or an independent model selected in `pi-btw.json`.
-- Uses a pi-btw thinking level that can be changed with Pi's configured thinking shortcut and remembered for next time.
+- Uses a pi-btw thinking level that can either start from the main thread or use a fixed remembered value.
 - Does not append the side question or answer to the main conversation.
 - Works as an independently installable npm Pi extension package.
 
@@ -58,14 +58,15 @@ Examples:
 /btw is this API name idiomatic?
 ```
 
-Running `/btw` alone opens a menu with **Start side thread** selected first. When the current Pi
-session has non-empty side threads in memory, **Resume side thread** opens a bounded choice list;
-**Settings** changes the starting thinking level and whether shortcut changes are remembered.
-Each Resume row keeps the first question as its fixed title, shows its question count, and the list
-is ordered by the newest recorded answer or visible error. Opening and closing a thread without a
-new result does not reorder it. `/btw <question>` bypasses this menu and always starts a fresh side
-thread. Its answer opens above the side-thread editor. The side thread uses a dedicated full-screen
-terminal view.
+Running `/btw` alone opens a menu with **Start side thread** selected first.
+When the current Pi session has non-empty side threads in memory, **Resume side thread** opens a bounded searchable choice list.
+Search matches the displayed first question and question count while returning the thread's raw in-memory ID.
+**Settings** changes the starting thinking level and whether shortcut changes for fixed levels are remembered.
+Each Resume row keeps the first question as its fixed title, shows its question count, and the list is ordered by the newest recorded answer or visible error.
+Opening and closing a thread without a new result does not reorder it.
+`/btw <question>` bypasses this menu and always starts a fresh side thread.
+Its answer opens above the side-thread editor.
+The side thread uses a dedicated full-screen terminal view.
 The main agent continues running in the background, but its screen rendering stays suspended until
 `/btw` closes, so new main-thread output cannot move a mouse selection inside the side thread.
 Drag the primary mouse button across side-thread text to select and copy it through Pi's terminal
@@ -78,9 +79,11 @@ Previous side questions and answers remain available to the model and visible fo
 invocation. The side-thread header shows its current thinking level. Press Pi's configured
 `app.thinking.cycle` shortcut (`Shift+Tab` by default) in the composer to cycle the levels
 supported by the side-thread model; every later question uses the displayed level until it is
-changed again. By default, each shortcut change is also written to `pi-btw.json` for the next
-invocation. Turn **Remember thinking level changes** off in Settings to keep changes local to the
-current side thread. Neither path changes the main session's thinking level.
+changed again. When a fixed thinking level is selected, each shortcut change is also written to
+`pi-btw.json` for the next invocation by default. Turn **Remember thinking level changes** off in
+Settings to keep fixed-level changes local to the current side thread. When **Same as main thread** is
+selected, shortcut changes are always local to the current side thread. Neither path changes the main
+session's thinking level.
 While a response is running, the transcript and composer remain visible above an `Answering…`
 status.
 Type another question and press `Enter` to queue it as `Steering`; queued questions are shown in
@@ -147,18 +150,23 @@ cannot be found or authenticated, pi-btw warns and falls back to the current ses
 If neither model is available, `/btw` reports an error and stops. This selection affects only
 `/btw`; it does not change the main session model.
 
-Pi calls its reasoning setting the **thinking level**. `thinkingLevel` sets pi-btw's starting
-level; accepted values are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. When the
-field is absent for backward compatibility, the next invocation starts from the current session
-level. The initial value and shortcut cycle are clamped to the selected side model's capabilities
-using Pi's model rules. Pi-btw does not read, write, or change the main session's
-`defaultThinkingLevel`.
-
-`rememberThinkingLevelChanges` controls only persistence and defaults to `true` when omitted. A
-side-thread shortcut always changes that side thread immediately. When remembering is on, the
-concrete level is written for the next invocation; when off, `pi-btw.json` stays unchanged. If a
-shortcut write fails, the local change remains active and pi-btw warns that it was not remembered.
-A failed Settings-screen save instead restores the previous displayed value.
+Pi calls its reasoning setting the **thinking level**. In Settings, choose **Same as main thread**
+to start each new side thread from the main thread's current thinking level. This is stored by
+omitting `thinkingLevel` from `pi-btw.json`.
+
+Set `thinkingLevel` only when you want a fixed pi-btw starting level. Accepted fixed values are
+`off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. The initial value and shortcut cycle
+are clamped to the selected side model's capabilities using Pi's model rules. Resumed side threads
+keep their own local thinking level instead of re-syncing with the main thread. Pi-btw does not read,
+write, or change the main session's `defaultThinkingLevel`.
+
+`rememberThinkingLevelChanges` controls only persistence for fixed thinking levels and defaults to
+`true` when omitted. A side-thread shortcut always changes that side thread immediately. When a fixed
+thinking level is selected and remembering is on, the concrete level is written for the next
+invocation; when off, `pi-btw.json` stays unchanged. When **Same as main thread** is selected,
+shortcut changes stay local even when remembering is on. If a shortcut write fails, the local change
+remains active and pi-btw warns that it was not remembered. A failed Settings-screen save instead
+restores the previous displayed value.
 
 A missing settings file is a side-effect-free read: pi-btw creates it only after a Settings change
 or a remembered shortcut change. Saves are ordered within the Pi process and published atomically

package/node_modules/@narumitw/pi-btw/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-btw",
-	"version": "0.50.0",
+	"version": "0.52.0",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",
@@ -31,10 +31,10 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.7",
-		"@earendil-works/pi-ai": "0.84.1",
-		"@earendil-works/pi-coding-agent": "0.84.1",
-		"@earendil-works/pi-tui": "0.84.1",
+		"@biomejs/biome": "2.5.8",
+		"@earendil-works/pi-ai": "0.84.2",
+		"@earendil-works/pi-coding-agent": "0.84.2",
+		"@earendil-works/pi-tui": "0.84.2",
 		"typescript": "7.0.2"
 	},
 	"repository": {
@@ -43,7 +43,7 @@
 		"directory": "packages/pi-btw"
 	},
 	"dependencies": {
-		"@narumitw/pi-tui-kit": "^0.49.1"
+		"@narumitw/pi-tui-kit": "^0.54.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",

package/node_modules/@narumitw/pi-btw/src/btw.ts

@@ -194,7 +194,7 @@ export async function loadBtwThinkingLevel(
 
 	options.warn?.(
 		sanitizeSingleLine(
-			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", and boolean rememberThinkingLevelChanges. Using current Pi thinking level.`,
+			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", and boolean rememberThinkingLevelChanges. Using current Pi thinking level.`,
 		),
 	);
 	return currentThinkingLevel;
@@ -265,6 +265,7 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 			}
 
 			const settings = await loadSettings(ctx);
+			const sameAsMainThinkingLevel = settings.thinkingLevel === undefined;
 			const resolution = await resolveModel(settings, ctx);
 			if (resolution.kind === "cancelled") {
 				notifySafely(ctx, "Cancelled", "info");
@@ -302,7 +303,8 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 						initialQuestion: question || undefined,
 						selected: resolution.selected,
 						thinkingLevel: state.thinkingLevel,
-						rememberThinkingLevelChanges: effectiveRememberThinkingLevelChanges(settings),
+						rememberThinkingLevelChanges:
+							!sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
 						state,
 						ctx: fullscreenCtx,
 					});

package/node_modules/@narumitw/pi-btw/src/menu.ts

@@ -7,6 +7,7 @@ import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { MenuContext, RunMenuResult } from "@narumitw/pi-tui-kit";
 import {
 	type BtwSettings,
+	type BtwSettingsPatch,
 	btwSettingsPath,
 	effectiveRememberThinkingLevelChanges,
 	readBtwSettings,
@@ -35,7 +36,7 @@ export interface ShowBtwCommandMenuOptions {
 	settingsPath?: string;
 	readSettings?: typeof readBtwSettings;
 	updateSettings?: (
-		patch: Partial<Pick<BtwSettings, "thinkingLevel" | "rememberThinkingLevelChanges">>,
+		patch: BtwSettingsPatch,
 		options: UpdateBtwSettingsOptions,
 	) => Promise<BtwSettings>;
 }
@@ -44,6 +45,7 @@ export type BtwCommandMenuResult = "start" | "closed" | { kind: "resume"; thread
 
 type BtwMenuScreen = "main" | "resume" | "settings" | "invalid";
 type BtwMenuAction = "start" | "resume" | "set-thinking" | "set-remember";
+const SAME_AS_MAIN_THREAD = "Same as main thread";
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 
 type BtwCustomFactory<T> = (
@@ -79,8 +81,22 @@ export async function showBtwCommandMenu(
 		}
 		return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
 	};
-	const displayThinkingLevel = (settings: BtwSettings): BtwThinkingLevel =>
-		clampToAvailableThinkingLevel(settings.thinkingLevel ?? options.currentThinkingLevel, levels);
+	const currentMainThinkingLevel = clampToAvailableThinkingLevel(
+		options.currentThinkingLevel,
+		levels,
+	);
+	const displayThinkingLevel = (settings: BtwSettings): string =>
+		settings.thinkingLevel === undefined
+			? SAME_AS_MAIN_THREAD
+			: clampToAvailableThinkingLevel(settings.thinkingLevel, levels);
+	const displayThinkingSummary = (settings: BtwSettings): string =>
+		settings.thinkingLevel === undefined
+			? `${SAME_AS_MAIN_THREAD} (currently ${currentMainThinkingLevel})`
+			: displayThinkingLevel(settings);
+	const displayRememberSummary = (settings: BtwSettings): string => {
+		const value = effectiveRememberThinkingLevelChanges(settings) ? "On" : "Off";
+		return settings.thinkingLevel === undefined ? `${value} (fixed levels only)` : value;
+	};
 
 	const menu = defineMenu<BtwMenuState, BtwMenuScreen, BtwMenuAction, MenuContext>({
 		start: "main",
@@ -89,7 +105,7 @@ export async function showBtwCommandMenu(
 				kind: "actions",
 				title: "Pi BTW",
 				lines: [
-					`Thinking: ${displayThinkingLevel(state.settings)} · Remember changes: ${effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off"}`,
+					`Thinking: ${displayThinkingSummary(state.settings)} · Remember changes: ${displayRememberSummary(state.settings)}`,
 				],
 				items: [
 					{
@@ -111,7 +127,7 @@ export async function showBtwCommandMenu(
 					{
 						id: "settings",
 						label: "Settings",
-						description: "Choose pi-btw thinking and whether shortcut changes are remembered",
+						description: "Choose pi-btw thinking level and fixed-level shortcut memory",
 						to: state.kind === "invalid" ? "invalid" : "settings",
 					},
 				],
@@ -120,6 +136,7 @@ export async function showBtwCommandMenu(
 			resume: () => ({
 				kind: "choice",
 				title: "Resume BTW side thread",
+				enableSearch: true,
 				items: resumeThreads.map((thread) => ({
 					id: thread.id,
 					label: thread.title,
@@ -137,15 +154,15 @@ export async function showBtwCommandMenu(
 					{
 						id: "thinkingLevel",
 						label: "Thinking level",
-						description: "Set the starting level for future pi-btw side threads.",
+						description: `Set the starting level for future pi-btw side threads. Currently ${currentMainThinkingLevel}.`,
 						currentValue: displayThinkingLevel(state.settings),
-						values: levels,
+						values: [SAME_AS_MAIN_THREAD, ...levels],
 						action: "set-thinking",
 					},
 					{
 						id: "rememberThinkingLevelChanges",
 						label: "Remember thinking level changes",
-						description: "Save side-thread shortcut changes to pi-btw.json for next time.",
+						description: "Save shortcut changes for fixed thinking levels to pi-btw.json.",
 						currentValue: effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off",
 						values: ["On", "Off"],
 						action: "set-remember",
@@ -175,12 +192,16 @@ export async function showBtwCommandMenu(
 				return { kind: "close" } as const;
 			},
 			"set-thinking": async ({ value, signal }) => {
-				if (!value || !levels.includes(value as BtwThinkingLevel)) return { kind: "rejected" };
+				if (!value) return { kind: "rejected" };
+				const patch =
+					value === SAME_AS_MAIN_THREAD
+						? ({ thinkingLevel: undefined } satisfies BtwSettingsPatch)
+						: levels.includes(value as BtwThinkingLevel)
+							? ({ thinkingLevel: value as BtwThinkingLevel } satisfies BtwSettingsPatch)
+							: undefined;
+				if (!patch) return { kind: "rejected" };
 				try {
-					await updateSettings(
-						{ thinkingLevel: value as BtwThinkingLevel },
-						{ settingsPath, signal },
-					);
+					await updateSettings(patch, { settingsPath, signal });
 					if (signal.aborted) return { kind: "rejected" };
 					notifySafely(ctx, `Pi BTW thinking level: ${value}.`, "info");
 					return { kind: "stay" };