v1.9.1: move Plan Mode to alt+p so shift+tab stays pi's thinking cycle (#47)

v1.9.0 rebound pi's built-in app.thinking.cycle to alt+t so the plan-mode
extension could claim shift+tab. That collided with pi's documented thinking
shortcut and pi (>= 0.79) surfaced an [Extension issues] warning whenever the
rebind hadn't taken yet.

Plan Mode now registers on alt+p (unbound by pi, no shadowing), and the
launcher performs a one-time cleanup of the v1.9.0 rewrite: if the user's
keybindings.json still has app.thinking.cycle: "alt+t" exactly, that entry
is removed; any binding the user set themselves is preserved.

Verified end-to-end against a real little-coder run with a fresh PI_CODING_AGENT_DIR:
extension loads with no [Extension issues] warning, and the upgrade scenario
(seeded v1.9.0 leftover) is cleaned on first launch.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Itay Inbar

.pi/extensions/plan-mode/index.ts

@@ -12,8 +12,8 @@ import { PlanStatus } from "./status.ts";
 
 // Plan Mode — a Claude-Code-style "research, ask, then plan" flow.
 //
-// shift+tab toggles plan mode (an indicator appears below the input). While it
-// is on, submitting a prompt does NOT run a normal coding turn; instead the
+// alt+p toggles plan mode (an indicator appears below the input). While it is
+// on, submitting a prompt does NOT run a normal coding turn; instead the
 // extension orchestrates:
 //   1. decompose the request into 1-4 exploration tasks (a reasoning sub-coder),
 //   2. dispatch those as read-only explorer sub-coders (isolated context; only
@@ -27,9 +27,8 @@ import { PlanStatus } from "./status.ts";
 // child little-coder (spawned via ../subagent/spawn.ts), and the final plan is
 // injected as a normal turn via pi.sendUserMessage so it lands in the chat.
 //
-// shift+tab is normally pi's thinking-level cycle; extension shortcuts take
-// precedence (custom-editor.js checks them first), so we shadow it and move the
-// thinking-level cycle to alt+t to keep it reachable.
+// alt+p is unbound by pi, so the extension can claim it cleanly without
+// shadowing any built-in (shift+tab stays pi's thinking-level cycle — issue #47).
 
 const honey = (s: string) => `\x1b[38;2;225;90;31m${s}\x1b[39m`;
 const gray = (s: string) => `\x1b[90m${s}\x1b[39m`;
@@ -50,7 +49,7 @@ let pendingSynthesis: { digest: string; answers: string } | null = null;
 let synthesisActive = false;
 
 function indicatorLines(): string[] {
-  return [`${honey("◆")} ${honey("PLAN MODE")}  ${gray("(shift+tab to exit)")}`];
+  return [`${honey("◆")} ${honey("PLAN MODE")}  ${gray("(alt+p to exit)")}`];
 }
 
 function setIndicator(ctx: any, on: boolean): void {
@@ -269,8 +268,10 @@ async function orchestrate(pi: ExtensionAPI, ctx: any, prompt: string): Promise<
 }
 
 export default function (pi: ExtensionAPI) {
-  // shift+tab toggles plan mode (shadows pi's thinking-level cycle).
-  pi.registerShortcut("shift+tab", {
+  // alt+p toggles plan mode. pi leaves alt+p unbound, so this doesn't collide
+  // with any built-in and shift+tab stays bound to pi's thinking-level cycle
+  // (issue #47).
+  pi.registerShortcut("alt+p", {
     description: "Toggle plan mode",
     handler: (ctx: any) => {
       if (orchestrating) return; // mid-plan: ignore toggles
@@ -280,10 +281,6 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  // The thinking-level cycle keeps working on alt+t: the launcher rebinds pi's
-  // built-in `app.thinking.cycle` from shift+tab to alt+t so shift+tab is free
-  // for plan mode (see bin/little-coder.mjs §8b). No extension shortcut needed.
-
   // Intercept a submitted prompt while plan mode is on and run the orchestration
   // instead of a normal coding turn.
   pi.on("input", async (event, ctx) => {
@@ -357,7 +354,7 @@ export default function (pi: ExtensionAPI) {
       });
     } else {
       (ctx as any).ui?.notify?.(
-        "plan not implemented — refine your request, or shift+tab to leave plan mode",
+        "plan not implemented — refine your request, or alt+p to leave plan mode",
         "info",
       );
     }

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to little-coder are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and little-coder's public interface (CLI, providers, tools, skills) follows semver starting at `v0.0.1` post-rename.
 
+## [v1.9.1] — 2026-06-08
+
+### Fixed
+- **Plan Mode shortcut moved to `alt+p` so `shift+tab` stays pi's thinking-level cycle** ([#47](https://github.com/itayinbarr/little-coder/issues/47)). v1.9.0 claimed `shift+tab` for Plan Mode by rebinding pi's built-in `app.thinking.cycle` to `alt+t` in `~/.pi/agent/keybindings.json`. That collided with the muscle memory of every existing pi user — `shift+tab` is the documented thinking cycle — and pi (≥ 0.79) also surfaced an `[Extension issues]` warning whenever the rebind hadn't taken yet. Plan Mode now registers on **`alt+p`** instead (unbound by pi, so the extension claims it cleanly with no shadowing), and `shift+tab` returns to pi's default behavior. The launcher also performs a **one-time cleanup**: on first run after upgrade, if `~/.pi/agent/keybindings.json` still has the v1.9.0 rewrite (`app.thinking.cycle: "alt+t"` exactly), it is removed; any binding you set yourself is preserved untouched. README and the Plan-Mode indicator (`(alt+p to exit)`) updated to match.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. **Plan Mode is now `alt+p`** (was `shift+tab` in v1.9.0). `shift+tab` is again pi's thinking-level cycle. If you customized `app.thinking.cycle` yourself in `~/.pi/agent/keybindings.json`, your binding is left alone.
+
+---
+
 ## [v1.9.0] — 2026-06-15
 
 ### Added

README.md

@@ -62,7 +62,7 @@ The agent uses the directory you launched it from as its working directory — `
 
 ### Interactive features
 
-- **Plan Mode** — press **shift+tab** to toggle (a `◆ PLAN MODE` indicator shows below the input). Submit a request and little-coder researches it with sub-coders, asks you 1-3 clarifying questions (each with suggested answers and a free-text option), then writes a plan in the chat instead of editing anything. **Esc** cancels a plan mid-run. (shift+tab used to cycle the thinking level — that's now **alt+t**.)
+- **Plan Mode** — press **alt+p** to toggle (a `◆ PLAN MODE` indicator shows below the input). Submit a request and little-coder researches it with sub-coders, asks you 1-3 clarifying questions (each with suggested answers and a free-text option), then writes a plan in the chat instead of editing anything. **Esc** cancels a plan mid-run. (**shift+tab** stays pi's thinking-level cycle.)
 - **Prompt history** — from an empty input, **↑** recalls your recent prompts (most-recent first), **↓** walks forward. History persists across sessions, so a fresh session can recall prompts from earlier runs.
 - **Sub-coders (`dispatch`)** — little-coder can spawn isolated child sessions to research a question (read the repo + browse online, read-only) and report back concisely, without cluttering the main conversation. A live panel above the input tracks them. Tune parallelism with `LITTLE_CODER_SUBCODER_CONCURRENCY` (default 2).
 - **Sessions** — each session is auto-named from your first prompt (rename with `/name`) and shown in the terminal tab title. Use `/resume` to list and reopen past sessions for the current directory.
@@ -342,7 +342,7 @@ little-coder/
 │   ├── settings.json               # per-model profiles + benchmark_overrides (terminal_bench, gaia)
 │   └── extensions/                 # 27 TypeScript extensions, auto-discovered by pi
 │       ├── branding/               # little-coder startup header + terminal title + session auto-naming
-│       ├── plan-mode/              # shift+tab "research → ask → plan" flow (sub-coders + clarifying questions → written plan)
+│       ├── plan-mode/              # alt+p "research → ask → plan" flow (sub-coders + clarifying questions → written plan)
 │       ├── subagent/              # `dispatch` tool: isolated read/browse-only sub-coders + live tracker (spawn.ts engine)
 │       ├── prompt-history/         # up-arrow recall of recent prompts (from an empty input)
 │       ├── llama-cpp-provider/     # data-driven provider registration from models.json — ships llamacpp, ollama, lmstudio (+ user override file)

bin/little-coder.mjs

@@ -9,6 +9,7 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
@@ -244,32 +245,31 @@ if (!isSubagent) try {
     writeFileSync(globalSettingsPath, JSON.stringify(globalSettings, null, 2));
   }
 
-  // ---- 8b. Free shift+tab for Plan Mode ----
-  // little-coder binds shift+tab to its plan-mode toggle (the plan-mode
-  // extension registers it). But shift+tab is pi's built-in "cycle thinking
-  // level", and pi (>= 0.79) refuses an extension shortcut that collides with a
-  // RESERVED built-in — it skips it with an "[Extension issues]" warning. pi
-  // builds its conflict map from the *resolved* keybindings, so moving the
-  // thinking-cycle action to another key in the user keybindings file removes
-  // shift+tab from that map and lets the extension claim it. We rebind the
-  // cycle to alt+t (the key plan-mode used to register itself) — only when the
-  // user hasn't already chosen their own binding for it, so a real user
-  // customization always wins. Non-destructive: every other binding is left
-  // untouched.
+  // ---- 8b. One-time cleanup of the v1.9.0 keybinding rewrite ----
+  // v1.9.0 wrote `app.thinking.cycle: "alt+t"` into ~/.pi/agent/keybindings.json
+  // so the plan-mode extension could claim shift+tab (issue #47). Plan mode now
+  // lives on alt+p, so shift+tab should go back to pi's default thinking-cycle
+  // binding — but only if the value is *exactly* the one we wrote. A user who
+  // chose their own binding (anything ≠ "alt+t") wins.
   const keybindingsPath = join(agentDir, "keybindings.json");
-  let keybindings = {};
   if (existsSync(keybindingsPath)) {
     try {
       const parsed = JSON.parse(readFileSync(keybindingsPath, "utf-8"));
-      if (parsed && typeof parsed === "object") keybindings = parsed;
+      if (parsed && typeof parsed === "object" && parsed["app.thinking.cycle"] === "alt+t") {
+        delete parsed["app.thinking.cycle"];
+        if (Object.keys(parsed).length === 0) {
+          // Don't leave an empty {} sitting around — remove the file so pi
+          // reads its defaults cleanly.
+          rmSync(keybindingsPath);
+        } else {
+          writeFileSync(keybindingsPath, JSON.stringify(parsed, null, 2));
+        }
+      }
     } catch {
-      keybindings = {};
+      // Corrupted JSON or unreadable — leave it alone; pi will surface its own error.
     }
   }
-  if (keybindings["app.thinking.cycle"] === undefined) {
-    keybindings["app.thinking.cycle"] = "alt+t";
-    writeFileSync(keybindingsPath, JSON.stringify(keybindings, null, 2));
-  }
+
 } catch {
   // Best-effort. If we can't write the settings (read-only HOME, etc.) pi
   // falls back to its built-in defaults — the [Extensions] block will show

package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "A pi-based coding agent optimized for small local language models. Reproduces the whitepaper's scaffold-model-fit adaptations as pi extensions.",
   "homepage": "https://github.com/itayinbarr/little-coder",
   "repository": {