little-coder 1.9.0 → 1.9.2

package/.pi/extensions/_shared/width.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import { stripAnsi, visibleWidth, truncateLineToWidth } from "./width.ts";
+
+describe("stripAnsi / visibleWidth", () => {
+  it("strips SGR color codes", () => {
+    expect(stripAnsi("\x1b[31mred\x1b[39m")).toBe("red");
+    expect(visibleWidth("\x1b[31mred\x1b[39m")).toBe(3);
+  });
+  it("strips OSC hyperlinks", () => {
+    const link = "\x1b]8;;https://example.com\x07click\x1b]8;;\x07";
+    expect(stripAnsi(link)).toBe("click");
+    expect(visibleWidth(link)).toBe(5);
+  });
+  it("counts plain ASCII", () => {
+    expect(visibleWidth("hello world")).toBe(11);
+  });
+});
+
+describe("truncateLineToWidth", () => {
+  it("returns the line unchanged when it fits", () => {
+    expect(truncateLineToWidth("hi", 10)).toBe("hi");
+  });
+  it("truncates and adds an ellipsis when it overflows", () => {
+    const out = truncateLineToWidth("abcdefghij", 5);
+    expect(visibleWidth(out)).toBeLessThanOrEqual(5);
+    expect(out).toContain("…");
+  });
+  it("preserves SGR codes through the visible portion", () => {
+    // 12 visible chars under one color, truncate to 6
+    const input = "\x1b[31m" + "abcdefghijkl" + "\x1b[39m";
+    const out = truncateLineToWidth(input, 6);
+    expect(out).toContain("\x1b[31m");
+    // visible chars in out (after stripping ansi) should be <= 6
+    expect(visibleWidth(out)).toBeLessThanOrEqual(6);
+  });
+  it("appends a reset to prevent color bleed after truncation", () => {
+    const out = truncateLineToWidth("\x1b[31mlong red string here\x1b[39m", 8);
+    expect(out.endsWith("\x1b[0m")).toBe(true);
+  });
+  it("handles a width of 0 defensively", () => {
+    expect(truncateLineToWidth("anything", 0)).toBe("");
+  });
+  it("matches the issue #48 reproduction shape", () => {
+    // Construct a row roughly the shape the sub-coder tracker would build,
+    // with a real-world ~167-char errorMessage. Without truncation this is
+    // 198 visible chars — exactly the user-reported overflow.
+    const honey = (s: string) => `\x1b[38;2;225;90;31m${s}\x1b[39m`;
+    const gray = (s: string) => `\x1b[90m${s}\x1b[39m`;
+    const red = (s: string) => `\x1b[31m${s}\x1b[39m`;
+    const longError =
+      "child process exited with non-zero code 1: " +
+      "Error: provider \"llamacpp\" — failed to reach " +
+      "http://127.0.0.1:8888/v1/chat/completions: ECONNREFUSED (transport error 503, retries=3)";
+    const row = `  ${red("✗")} deep-explorer-research  ${gray("0:47 ")}  ${gray(longError)}`;
+    expect(visibleWidth(row)).toBeGreaterThan(184);
+    const fixed = truncateLineToWidth(row, 184);
+    expect(visibleWidth(fixed)).toBeLessThanOrEqual(184);
+    expect(fixed.startsWith("  \x1b[31m✗\x1b[39m deep-explorer")).toBe(true);
+    void honey; // keep import shape parity with the tracker
+  });
+});

package/.pi/extensions/_shared/width.ts

@@ -0,0 +1,76 @@
+// Width-aware truncation for custom TUI widget content.
+//
+// pi-tui (>= ~0.75) throws "Rendered line N exceeds terminal width" when any
+// rendered line is wider than the terminal — see issue #48. Custom widgets
+// (subagent tracker, plan-mode status/indicator, branding header) MUST cap
+// every line they emit to the active terminal width, or pi crashes the whole
+// session when the widget happens to produce a long line (e.g. a failed
+// sub-coder whose errorMessage runs ~200 chars).
+//
+// pi-tui itself exports visibleWidth + truncateToWidth, but pi 0.79 no longer
+// hoists pi-tui to the top-level node_modules, so extensions can't import it
+// directly. This module is the lightweight inline replacement: it strips
+// SGR / OSC escapes for the width count and walks the string char-by-char to
+// truncate while preserving any in-flight color codes.
+
+const SGR_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+const OSC_RE = /\x1b\][^\x07]*\x07/g;
+
+export function stripAnsi(s: string): string {
+  return s.replace(SGR_RE, "").replace(OSC_RE, "");
+}
+
+// Approximation: ANSI-stripped char count (treats every visible char as width
+// 1). Exact for ASCII / Latin / single-cell glyphs the tracker and status
+// widgets emit. Wide CJK or emoji *under*count here, so callers should leave a
+// small safety margin (see terminalColumns/SAFETY_MARGIN).
+export function visibleWidth(s: string): number {
+  return [...stripAnsi(s)].length;
+}
+
+// Truncate `line` so its visible width fits `maxWidth`. ANSI escapes are
+// preserved verbatim; the visible portion is cut at maxWidth-1 to leave room
+// for an ellipsis, and a final SGR reset is appended so a half-emitted color
+// can't bleed into the next line. If maxWidth ≤ 0, returns "" (defensive).
+export function truncateLineToWidth(line: string, maxWidth: number, ellipsis = "…"): string {
+  if (maxWidth <= 0) return "";
+  if (visibleWidth(line) <= maxWidth) return line;
+  const cutAt = Math.max(0, maxWidth - visibleWidth(ellipsis));
+  let visible = 0;
+  let out = "";
+  let i = 0;
+  while (i < line.length) {
+    const ch = line[i];
+    if (ch === "\x1b" && line[i + 1] === "[") {
+      const m = line.slice(i).match(/^\x1b\[[0-9;]*[a-zA-Z]/);
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (ch === "\x1b" && line[i + 1] === "]") {
+      const end = line.indexOf("\x07", i);
+      if (end >= 0) {
+        out += line.slice(i, end + 1);
+        i = end + 1;
+        continue;
+      }
+    }
+    if (visible >= cutAt) break;
+    out += ch;
+    visible += 1;
+    i += 1;
+  }
+  return out + ellipsis + "\x1b[0m";
+}
+
+// Current terminal width, with a small safety margin to absorb wide Unicode
+// chars that visibleWidth's char-count approximation under-measures. Falls
+// back to `fallback` columns when stdout isn't a TTY (headless runs).
+const SAFETY_MARGIN = 2;
+export function terminalColumns(fallback = 80): number {
+  const c = (process.stdout && (process.stdout as any).columns) | 0;
+  const w = c > 0 ? c : fallback;
+  return Math.max(20, w - SAFETY_MARGIN);
+}

package/.pi/extensions/branding/index.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { truncateLineToWidth } from "../_shared/width.ts";
 
 // Replace pi's built-in startup header + terminal title with little-coder
 // branding. The interactive TUI's "pi vX.Y.Z" logo, the "Pi can explain its
@@ -46,7 +47,7 @@ function readVersion(): string {
 
 const VERSION = readVersion();
 
-function buildHeader(theme: Theme): string[] {
+function buildHeader(theme: Theme, width: number): string[] {
   // Brand-book "prompt lockup" (the variant the brand reserves for terminals
   // and dark surfaces): a honey prompt caret, the wordmark in the foreground,
   // and the honey block cursor — "lc▌"'s ready-to-type punchline, applied to
@@ -67,7 +68,11 @@ function buildHeader(theme: Theme): string[] {
     `${dim("!")} bash`,
     `${dim("ctrl-r")} more`,
   ].join(sep);
-  return ["", logo, tagline, "", hints, ""];
+  // pi-tui throws if any rendered line exceeds the terminal width (issue #48).
+  // Truncate every line we hand it so a narrow terminal can't crash the launch.
+  return ["", logo, tagline, "", hints, ""].map((l) =>
+    l ? truncateLineToWidth(l, width) : l,
+  );
 }
 
 // Derive a short, human session name from the first user prompt. Returns
@@ -111,8 +116,8 @@ export default function (pi: ExtensionAPI) {
     if (!ctx.hasUI) return;
 
     ctx.ui.setHeader((_tui, theme) => ({
-      render(_width: number): string[] {
-        return buildHeader(theme);
+      render(width: number): string[] {
+        return buildHeader(theme, width);
       },
       invalidate() {},
     }));

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

@@ -9,11 +9,12 @@ import {
 import { SubCoderTracker } from "../subagent/tracker.ts";
 import { currentModelId } from "../subagent/index.ts";
 import { PlanStatus } from "./status.ts";
+import { terminalColumns, truncateLineToWidth } from "../_shared/width.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 +28,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 +50,11 @@ let pendingSynthesis: { digest: string; answers: string } | null = null;
 let synthesisActive = false;
 
 function indicatorLines(): string[] {
-  return [`${honey("◆")} ${honey("PLAN MODE")}  ${gray("(shift+tab to exit)")}`];
+  // Cap to terminal width — pi-tui throws on overflow (issue #48). The
+  // indicator is short, but truncate for defense in depth so even a narrow
+  // terminal (≤ 30 cols) doesn't crash on widget render.
+  const raw = `${honey("◆")} ${honey("PLAN MODE")}  ${gray("(alt+p to exit)")}`;
+  return [truncateLineToWidth(raw, terminalColumns())];
 }
 
 function setIndicator(ctx: any, on: boolean): void {
@@ -269,8 +273,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 +286,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 +359,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",
       );
     }

package/.pi/extensions/plan-mode/status.ts

@@ -7,6 +7,8 @@
 // (needed to animate the spinner + tick the clock), colored with raw SGR so it
 // doesn't depend on the active theme.
 
+import { terminalColumns, truncateLineToWidth } from "../_shared/width.ts";
+
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const honey = (s: string) => `\x1b[38;2;225;90;31m${s}\x1b[39m`;
 const gray = (s: string) => `\x1b[90m${s}\x1b[39m`;
@@ -71,7 +73,11 @@ export class PlanStatus {
     if (!this.ctx.hasUI) return;
     const now = Date.now();
     const frame = SPINNER[Math.floor(now / 100) % SPINNER.length];
-    const line = `${honey(frame)} ${this.message}  ${gray(fmtElapsed(now - this.startMs))}`;
+    const raw = `${honey(frame)} ${this.message}  ${gray(fmtElapsed(now - this.startMs))}`;
+    // Cap to terminal width — pi-tui throws on overflow (issue #48). Our own
+    // phase messages are short, but the line is still passed through for
+    // defense-in-depth (a future caller, or a long custom message, won't crash).
+    const line = truncateLineToWidth(raw, terminalColumns());
     if (line === this.lastFrame) return; // diff-guard
     this.lastFrame = line;
     this.ctx.ui.setWidget(this.key, [line], { placement: this.placement });

package/.pi/extensions/subagent/issue-48-repro.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { SubCoderTracker } from "./tracker.ts";
+
+// Live regression for issue #48 — the user's reported crash shape.
+// pi-tui throws when any rendered widget line is wider than the terminal.
+// Before the fix, the sub-coder tracker fed an unbounded errorMessage straight
+// into a widget row; a ~167-char error at terminal width 184 produced a
+// 248-char visible line and crashed the session. This test simulates the
+// exact scenario and asserts every emitted line fits.
+
+describe("issue #48 — tracker doesn't overflow terminal width", () => {
+  it("caps a failed sub-coder's row to the terminal width", () => {
+    const orig = (process.stdout as any).columns;
+    (process.stdout as any).columns = 184;
+    try {
+      const captured: string[] = [];
+      const ctx = {
+        hasUI: true,
+        ui: {
+          setWidget: (_k: string, lines: string[] | undefined) => {
+            if (lines) captured.push(...lines);
+          },
+        },
+      };
+      const tracker = new SubCoderTracker(ctx, { key: "t", totalSince: Date.now() - 47000 });
+      tracker.begin([{ id: "a", label: "deep-explorer-research" }]);
+      const longErr =
+        "child process exited with non-zero code 1: " +
+        "Error: provider \"llamacpp\" — failed to reach " +
+        "http://127.0.0.1:8888/v1/chat/completions: ECONNREFUSED (transport error 503 after 3 retries)";
+      tracker.update([
+        {
+          id: "a",
+          label: "deep-explorer-research",
+          task: "",
+          exitCode: 1,
+          errorMessage: longErr,
+          report: "",
+          messages: [],
+          stderr: "",
+          usage: { input: 0, output: 0, cost: 0, turns: 0, contextTokens: 0 },
+        },
+      ]);
+      tracker.end();
+      expect(captured.length).toBeGreaterThan(0);
+      const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+      const widths = captured.map((l) => stripAnsi(l).length);
+      const max = Math.max(...widths);
+      expect(max).toBeLessThanOrEqual(184);
+    } finally {
+      (process.stdout as any).columns = orig;
+    }
+  });
+
+  it("survives narrower terminals (~80 cols)", () => {
+    const orig = (process.stdout as any).columns;
+    (process.stdout as any).columns = 80;
+    try {
+      const captured: string[] = [];
+      const ctx = {
+        hasUI: true,
+        ui: { setWidget: (_k: string, lines: string[] | undefined) => { if (lines) captured.push(...lines); } },
+      };
+      const tracker = new SubCoderTracker(ctx);
+      tracker.begin([{ id: "a", label: "x" }, { id: "b", label: "y" }]);
+      tracker.update([
+        { id: "a", label: "x", task: "", exitCode: 0, report: "ok", messages: [], stderr: "", usage: { input: 0, output: 0, cost: 0, turns: 0, contextTokens: 0 } },
+        { id: "b", label: "y", task: "", exitCode: 1, errorMessage: "x".repeat(500), report: "", messages: [], stderr: "", usage: { input: 0, output: 0, cost: 0, turns: 0, contextTokens: 0 } },
+      ]);
+      tracker.end();
+      const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+      const max = Math.max(...captured.map((l) => stripAnsi(l).length));
+      expect(max).toBeLessThanOrEqual(80);
+    } finally {
+      (process.stdout as any).columns = orig;
+    }
+  });
+});

package/.pi/extensions/subagent/spawn.test.ts

@@ -64,6 +64,15 @@ describe("summarizeActivity", () => {
   it("falls back to working when running with no tool call", () => {
     expect(summarizeActivity(base)).toBe("working…");
   });
+  it("caps long error messages on failure (issue #48 regression)", () => {
+    const longErr =
+      "child process exited with non-zero code 1: " +
+      "Error: provider \"llamacpp\" — failed to reach " +
+      "http://127.0.0.1:8888/v1/chat/completions: ECONNREFUSED";
+    const out = summarizeActivity({ ...base, exitCode: 1, errorMessage: longErr });
+    expect(out.length).toBeLessThanOrEqual(56);
+    expect(out.endsWith("…")).toBe(true);
+  });
 });
 
 describe("buildChildEnv", () => {

package/.pi/extensions/subagent/spawn.ts

@@ -131,11 +131,20 @@ export function truncateReport(text: string, max = MAX_REPORT_CHARS): string {
 
 /** A one-line "what is this child doing right now" string for the tracker. */
 export function summarizeActivity(r: SubCoderResult): string {
+  const cap = (s: string, n = 56): string => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
   if (r.exitCode === 0) {
     const firstLine = r.report.split(/\r?\n/).find((l) => l.trim()) ?? "(done)";
-    return firstLine.length > 56 ? `${firstLine.slice(0, 55)}…` : firstLine;
+    return cap(firstLine);
+  }
+  if (r.exitCode > 0) {
+    // The error path used to return raw errorMessage / stderr UNCAPPED, which
+    // routinely runs ~200 chars (a child process error with a URL + stack
+    // fragment). The tracker passes that straight into a widget line, and any
+    // line wider than the terminal crashes pi-tui (issue #48). Cap here so the
+    // source string is bounded; the widget also truncates the assembled row
+    // for defense in depth.
+    return cap(r.errorMessage || r.stderr.split(/\r?\n/)[0] || "(failed)");
   }
-  if (r.exitCode > 0) return r.errorMessage || r.stderr.split(/\r?\n/)[0] || "(failed)";
   // running: surface the most recent tool call, else the latest partial text.
   for (let i = r.messages.length - 1; i >= 0; i--) {
     const m = r.messages[i];
@@ -145,7 +154,7 @@ export function summarizeActivity(r: SubCoderResult): string {
         if (part?.type === "toolCall") {
           const a = part.arguments ?? {};
           const hint = a.pattern || a.query || a.url || a.path || a.file_path || a.command || "";
-          return `→ ${part.name}${hint ? ` ${String(hint).slice(0, 40)}` : ""}`;
+          return cap(`→ ${part.name}${hint ? ` ${String(hint).slice(0, 40)}` : ""}`);
         }
       }
     }

package/.pi/extensions/subagent/tracker.ts

@@ -7,6 +7,7 @@
 // active theme and the string[] form of setWidget can be used directly.
 
 import { summarizeActivity, type SubCoderResult } from "./spawn.ts";
+import { terminalColumns, truncateLineToWidth } from "../_shared/width.ts";
 
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
@@ -130,7 +131,13 @@ export class SubCoderTracker {
       return `  ${icon} ${padEnd(r.label, labelWidth)}  ${gray(padEnd(elapsed, 5))}  ${gray(activity)}`;
     });
 
-    const lines = [header, ...rows];
+    // Cap every line to the active terminal width — pi-tui throws if a custom
+    // widget renders a line wider than the terminal (issue #48). The activity
+    // text in rows can be unbounded (failed sub-coders surface raw stderr /
+    // errorMessage, which routinely runs ~200 chars), so without this each
+    // failing dispatch turn would crash the whole session.
+    const width = terminalColumns();
+    const lines = [header, ...rows].map((l) => truncateLineToWidth(l, width));
     const frameKey = lines.join("\n");
     if (frameKey === this.lastFrame) return; // diff-guard: skip identical repaints
     this.lastFrame = frameKey;

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 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.2] — 2026-06-18
+
+### Fixed
+- **Width-overflow crash from custom widgets** ([#48](https://github.com/itayinbarr/little-coder/issues/48)). pi-tui throws `Rendered line N exceeds terminal width` whenever a custom TUI component emits a line wider than the active terminal — the user saw a 198-char line at width 184 take down the whole session. Root cause was the **sub-coder tracker** (`subagent/tracker.ts`): a failed sub-coder's `errorMessage` flowed straight into a widget row without any cap, and real-world child-process errors routinely run 150-250 chars (transport error + URL + retry count is enough). The tracker now caps every emitted row to the active terminal width using a new `_shared/width.ts` utility (`visibleWidth` + `truncateLineToWidth`, ANSI-aware so SGR colour codes are preserved through the cut and a final reset prevents bleed). `summarizeActivity` also gained a 56-char cap on the failure path (was uncapped) and the running path (was uncapped on `part.name`) for defense in depth. The same width-cap is now applied to the **plan-mode status panel**, the **plan-mode indicator**, and the **branding startup header** (which now uses the `width` arg pi passes to `render()` instead of returning hardcoded-length lines), so a narrow terminal can no longer crash launch either. New `width.test.ts` (9 cases) covers ASCII / SGR / OSC hyperlink / colour-bleed / the exact issue-48 reproduction shape, and `issue-48-repro.test.ts` drives the tracker directly with a 167-char failure at width 184 and asserts no emitted row exceeds the terminal.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. If you ever saw `Rendered line N exceeds terminal width (… > …)` crash a session — particularly during a `dispatch` call that errored, or while Plan Mode was orchestrating sub-coders — 1.9.2 fixes it. Third-party pi extensions (e.g. `context-mode`) that emit their own widgets remain subject to pi's check; if you still see the crash with `Loaded pi extensions: <name>` listed, the offending widget is in that extension, not little-coder.
+
+---
+
+## [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

package/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)

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "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": {