little-coder 1.8.3 → 1.9.0

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

@@ -0,0 +1,373 @@
+// Sub-coder spawn engine.
+//
+// A "sub-coder" is a child little-coder session with an isolated context window,
+// spawned to research a focused question (read the repo + browse online) and
+// report back concisely. Both the `dispatch` tool (index.ts) and Plan Mode
+// (../plan-mode) drive children through this module.
+//
+// Why spawn little-coder's OWN launcher and not bare `pi`: the child must use
+// the same local-model provider, the same extensions, and the same AGENTS.md as
+// the parent. The launcher (bin/little-coder.mjs) is what composes all of that —
+// it registers the provider (llama-cpp-provider), wires every .pi/extension, and
+// passes --system-prompt AGENTS.md. Spawning `pi` directly would yield a blank
+// agent with none of it. We therefore re-invoke the launcher headless
+// (--mode json -p --no-session) and parse pi's JSON event stream from stdout.
+//
+// The child is constrained to read + browse (no edit/write, no recursive
+// dispatch) entirely through environment variables the existing gates already
+// honor — see buildChildEnv().
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Tools a sub-coder may use: read + search + browse online + read-only bash.
+// Enforced by the tool-gating extension in the child. Deliberately omits
+// edit/write (children never mutate the tree) and `dispatch` (no fan-out bombs).
+export const SUBCODER_ALLOWED_TOOLS = [
+  "read",
+  "grep",
+  "glob",
+  "find",
+  "ls",
+  "bash",
+  "webfetch",
+  "websearch",
+  "BrowserNavigate",
+  "BrowserClick",
+  "BrowserType",
+  "BrowserScroll",
+  "BrowserExtract",
+  "BrowserBack",
+  "BrowserHistory",
+].join(",");
+
+// Appended to every task so children answer with a short, parent-friendly
+// report rather than a wall of pasted file contents.
+export const REPORT_SUFFIX =
+  "\n\nWhen done, reply with a CONCISE report (≤ ~200 words): the key findings, " +
+  "file:line citations where relevant, and a direct answer to the task. Do NOT " +
+  "paste large file contents or long logs — summarize them.";
+
+export const MAX_REPORT_CHARS = 2000;
+
+export interface SubCoderUsage {
+  input: number;
+  output: number;
+  cost: number;
+  turns: number;
+  contextTokens: number;
+}
+
+export interface SubCoderResult {
+  id: string;
+  label: string;
+  task: string;
+  /** -1 = still running, 0 = ok, >0 = failed. */
+  exitCode: number;
+  /** The child's final assistant text — the report shown to the parent model. */
+  report: string;
+  /** Full child transcript. UI-only (rendered in tool details); never sent to the parent model. */
+  messages: any[];
+  stderr: string;
+  usage: SubCoderUsage;
+  stopReason?: string;
+  errorMessage?: string;
+}
+
+function emptyUsage(): SubCoderUsage {
+  return { input: 0, output: 0, cost: 0, turns: 0, contextTokens: 0 };
+}
+
+// .pi/extensions/subagent/spawn.ts → up 3 → package root → bin/little-coder.mjs.
+// Same path math as branding/index.ts; works in the local checkout and the
+// installed npm layout.
+export function resolveLauncher(): string {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return resolve(here, "..", "..", "..", "bin", "little-coder.mjs");
+}
+
+export function buildChildEnv(extra?: Record<string, string>): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    // Constrain the child to read + browse, no mutation, no recursion.
+    LITTLE_CODER_ALLOWED_TOOLS: SUBCODER_ALLOWED_TOOLS,
+    // bash limited to permission-gate's read-only BUILTIN_SAFE_PREFIXES.
+    LITTLE_CODER_PERMISSION_MODE: "auto",
+    // Headless fast-path in the launcher (skip update-check + settings write).
+    LITTLE_CODER_SUBAGENT: "1",
+    // Belt and suspenders: never show pi's update banner in a child.
+    PI_SKIP_VERSION_CHECK: "1",
+    ...extra,
+  };
+}
+
+export function defaultConcurrency(): number {
+  const n = Number(process.env.LITTLE_CODER_SUBCODER_CONCURRENCY);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 2;
+}
+
+/** The last assistant text block in a transcript — the child's report. */
+export function getFinalText(messages: any[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role === "assistant" && Array.isArray(m.content)) {
+      for (const part of m.content) {
+        if (part?.type === "text" && typeof part.text === "string" && part.text.trim()) {
+          return part.text;
+        }
+      }
+    }
+  }
+  return "";
+}
+
+export function truncateReport(text: string, max = MAX_REPORT_CHARS): string {
+  const t = (text ?? "").trim();
+  if (t.length <= max) return t;
+  return `${t.slice(0, max).trimEnd()}\n\n… (report truncated at ${max} chars — full transcript in tool details)`;
+}
+
+/** A one-line "what is this child doing right now" string for the tracker. */
+export function summarizeActivity(r: SubCoderResult): string {
+  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;
+  }
+  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];
+    if (m?.role === "assistant" && Array.isArray(m.content)) {
+      for (let j = m.content.length - 1; j >= 0; j--) {
+        const part = m.content[j];
+        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 "working…";
+}
+
+export interface RunSubCoderOptions {
+  id: string;
+  label: string;
+  task: string;
+  cwd: string;
+  /** "provider/id" of the parent's model, so the child uses the same one. */
+  model?: string;
+  signal?: AbortSignal;
+  /** Called whenever the child emits a new message, with the live result. */
+  onUpdate?: (r: SubCoderResult) => void;
+}
+
+/** Run one sub-coder to completion. Never throws — failures land in exitCode/stderr. */
+export async function runSubCoder(opts: RunSubCoderOptions): Promise<SubCoderResult> {
+  const result: SubCoderResult = {
+    id: opts.id,
+    label: opts.label,
+    task: opts.task,
+    exitCode: -1,
+    report: "",
+    messages: [],
+    stderr: "",
+    usage: emptyUsage(),
+  };
+
+  const launcher = resolveLauncher();
+  if (!existsSync(launcher)) {
+    result.exitCode = 1;
+    result.stderr = `sub-coder launcher not found at ${launcher}`;
+    result.errorMessage = result.stderr;
+    opts.onUpdate?.(result);
+    return result;
+  }
+
+  const args = [
+    launcher,
+    "--no-update-check",
+    "--mode",
+    "json",
+    "-p",
+    "--no-session",
+    // Match the parent's model so children run on the same backend. Without
+    // this the child would fall back to pi's default model.
+    ...(opts.model ? ["--model", opts.model] : []),
+    opts.task + REPORT_SUFFIX,
+  ];
+
+  const emit = () => {
+    result.report = getFinalText(result.messages);
+    opts.onUpdate?.(result);
+  };
+
+  const exitCode = await new Promise<number>((resolveP) => {
+    let proc;
+    try {
+      proc = spawn(process.execPath, args, {
+        cwd: opts.cwd,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: buildChildEnv(),
+      });
+    } catch (e) {
+      result.stderr += String((e as Error)?.message ?? e);
+      resolveP(1);
+      return;
+    }
+
+    let buffer = "";
+    const processLine = (line: string) => {
+      if (!line.trim()) return;
+      let ev: any;
+      try {
+        ev = JSON.parse(line);
+      } catch {
+        return; // non-JSON noise (shouldn't happen in --mode json, but be safe)
+      }
+      if (ev.type === "message_end" && ev.message) {
+        const msg = ev.message;
+        result.messages.push(msg);
+        if (msg.role === "assistant") {
+          result.usage.turns++;
+          const u = msg.usage;
+          if (u) {
+            result.usage.input += u.input || 0;
+            result.usage.output += u.output || 0;
+            result.usage.cost += u.cost?.total || 0;
+            result.usage.contextTokens = u.totalTokens || 0;
+          }
+          if (msg.stopReason) result.stopReason = msg.stopReason;
+          if (msg.errorMessage) result.errorMessage = msg.errorMessage;
+        }
+        emit();
+      } else if (ev.type === "tool_result_end" && ev.message) {
+        result.messages.push(ev.message);
+        emit();
+      }
+    };
+
+    proc.stdout.on("data", (d) => {
+      buffer += d.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const l of lines) processLine(l);
+    });
+    proc.stderr.on("data", (d) => {
+      result.stderr += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (buffer.trim()) processLine(buffer);
+      resolveP(code ?? 0);
+    });
+    proc.on("error", (e) => {
+      result.stderr += String(e?.message ?? e);
+      resolveP(1);
+    });
+
+    if (opts.signal) {
+      const kill = () => {
+        try {
+          proc.kill("SIGTERM");
+        } catch {
+          /* already gone */
+        }
+        setTimeout(() => {
+          try {
+            if (!proc.killed) proc.kill("SIGKILL");
+          } catch {
+            /* ignore */
+          }
+        }, 4000);
+      };
+      if (opts.signal.aborted) kill();
+      else opts.signal.addEventListener("abort", kill, { once: true });
+    }
+  });
+
+  result.exitCode = exitCode;
+  result.report = getFinalText(result.messages);
+  if (exitCode !== 0 && !result.errorMessage) {
+    result.errorMessage = result.stderr.split(/\r?\n/).filter(Boolean).slice(-1)[0] || `exited ${exitCode}`;
+  }
+  return result;
+}
+
+export interface SubCoderItem {
+  id: string;
+  label: string;
+  task: string;
+  cwd: string;
+}
+
+async function mapWithConcurrencyLimit<TIn, TOut>(
+  items: TIn[],
+  concurrency: number,
+  fn: (item: TIn, index: number) => Promise<TOut>,
+): Promise<TOut[]> {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  const results: TOut[] = new Array(items.length);
+  let next = 0;
+  const workers = new Array(limit).fill(null).map(async () => {
+    while (true) {
+      const cur = next++;
+      if (cur >= items.length) return;
+      results[cur] = await fn(items[cur], cur);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+/**
+ * Run several sub-coders with a concurrency cap (default 2 — a single local
+ * backend is easily starved). `onUpdate` receives a fresh snapshot of all
+ * results whenever any child changes, which drives the live tracker.
+ */
+export async function runSubCodersConcurrent(
+  items: SubCoderItem[],
+  opts: {
+    signal?: AbortSignal;
+    concurrency?: number;
+    model?: string;
+    onUpdate?: (all: SubCoderResult[]) => void;
+  } = {},
+): Promise<SubCoderResult[]> {
+  const all: SubCoderResult[] = items.map((it) => ({
+    id: it.id,
+    label: it.label,
+    task: it.task,
+    exitCode: -1,
+    report: "",
+    messages: [],
+    stderr: "",
+    usage: emptyUsage(),
+  }));
+  const snapshot = () => opts.onUpdate?.(all.map((r) => ({ ...r })));
+  snapshot();
+
+  await mapWithConcurrencyLimit(items, opts.concurrency ?? defaultConcurrency(), async (it, i) => {
+    const r = await runSubCoder({
+      id: it.id,
+      label: it.label,
+      task: it.task,
+      cwd: it.cwd,
+      model: opts.model,
+      signal: opts.signal,
+      onUpdate: (live) => {
+        all[i] = live;
+        snapshot();
+      },
+    });
+    all[i] = r;
+    snapshot();
+    return r;
+  });
+
+  return all;
+}

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

@@ -0,0 +1,139 @@
+// Live sub-coder tracker — a small animated panel above the input showing each
+// running/finished sub-coder, its status, elapsed time and current activity.
+//
+// Driven by string[] content re-set on a timer (the spinner + clock need to
+// tick, which event updates alone can't do). Colors are raw 24-bit/SGR escapes
+// (same approach as branding's honey accent) so the panel doesn't depend on the
+// active theme and the string[] form of setWidget can be used directly.
+
+import { summarizeActivity, type SubCoderResult } from "./spawn.ts";
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+// Brand honey (matches branding/index.ts) + plain SGR status colors.
+const honey = (s: string) => `\x1b[38;2;225;90;31m${s}\x1b[39m`;
+const green = (s: string) => `\x1b[32m${s}\x1b[39m`;
+const red = (s: string) => `\x1b[31m${s}\x1b[39m`;
+const gray = (s: string) => `\x1b[90m${s}\x1b[39m`;
+
+function fmtElapsed(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+
+function padEnd(s: string, n: number): string {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+
+export interface TrackerUI {
+  hasUI: boolean;
+  ui: {
+    setWidget: (
+      key: string,
+      content: string[] | undefined,
+      options?: { placement?: "aboveEditor" | "belowEditor" },
+    ) => void;
+  };
+}
+
+export class SubCoderTracker {
+  private readonly key: string;
+  private readonly placement: "aboveEditor" | "belowEditor";
+  private results = new Map<string, SubCoderResult>();
+  private order: string[] = [];
+  private startedAt = new Map<string, number>();
+  private finishedAt = new Map<string, number>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastFrame = "";
+
+  constructor(
+    private ctx: TrackerUI,
+    opts: { key?: string; placement?: "aboveEditor" | "belowEditor"; totalSince?: number } = {},
+  ) {
+    this.key = opts.key ?? "subcoders";
+    this.placement = opts.placement ?? "aboveEditor";
+    this.totalSince = opts.totalSince;
+  }
+
+  // When set, the header shows a running total-elapsed timer (the overall
+  // process time, not just per-sub-coder).
+  private totalSince?: number;
+
+  /** Register the items and start the animation timer. */
+  begin(items: { id: string; label: string }[]): void {
+    if (!this.ctx.hasUI || items.length === 0) return;
+    const now = Date.now();
+    for (const it of items) {
+      if (!this.startedAt.has(it.id)) {
+        this.order.push(it.id);
+        this.startedAt.set(it.id, now);
+        this.results.set(it.id, {
+          id: it.id,
+          label: it.label,
+          task: "",
+          exitCode: -1,
+          report: "",
+          messages: [],
+          stderr: "",
+          usage: { input: 0, output: 0, cost: 0, turns: 0, contextTokens: 0 },
+        });
+      }
+    }
+    this.render();
+    if (!this.timer) this.timer = setInterval(() => this.render(), 120);
+  }
+
+  /** Feed a fresh snapshot of all results (from runSubCodersConcurrent). */
+  update(results: SubCoderResult[]): void {
+    if (!this.ctx.hasUI) return;
+    const now = Date.now();
+    for (const r of results) {
+      if (!this.startedAt.has(r.id)) {
+        this.order.push(r.id);
+        this.startedAt.set(r.id, now);
+      }
+      this.results.set(r.id, r);
+      if (r.exitCode !== -1 && !this.finishedAt.has(r.id)) this.finishedAt.set(r.id, now);
+    }
+  }
+
+  /** Stop the timer, paint a final static frame, then clear the panel. */
+  end(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (!this.ctx.hasUI) return;
+    this.render();
+    this.ctx.ui.setWidget(this.key, undefined, { placement: this.placement });
+  }
+
+  private render(): void {
+    if (!this.ctx.hasUI || this.order.length === 0) return;
+    const now = Date.now();
+    const frame = SPINNER[Math.floor(now / 100) % SPINNER.length];
+
+    const items = this.order.map((id) => this.results.get(id)!).filter(Boolean);
+    const done = items.filter((r) => r.exitCode !== -1).length;
+    const labelWidth = Math.min(18, Math.max(...items.map((r) => r.label.length), 4));
+
+    const total = this.totalSince !== undefined ? ` · ${fmtElapsed(now - this.totalSince)}` : "";
+    const header = `${honey("sub-coders")} ${gray(`· ${done}/${items.length} done${total}`)}`;
+    const rows = items.map((r) => {
+      const running = r.exitCode === -1;
+      const icon = running ? honey(frame) : r.exitCode === 0 ? green("✓") : red("✗");
+      const end = this.finishedAt.get(r.id) ?? now;
+      const elapsed = fmtElapsed(end - (this.startedAt.get(r.id) ?? now));
+      const activity = summarizeActivity(r);
+      return `  ${icon} ${padEnd(r.label, labelWidth)}  ${gray(padEnd(elapsed, 5))}  ${gray(activity)}`;
+    });
+
+    const lines = [header, ...rows];
+    const frameKey = lines.join("\n");
+    if (frameKey === this.lastFrame) return; // diff-guard: skip identical repaints
+    this.lastFrame = frameKey;
+    this.ctx.ui.setWidget(this.key, lines, { placement: this.placement });
+  }
+}

package/AGENTS.md

@@ -11,6 +11,7 @@ Instead, proactively write the necessary background scripts (Python, Bash, etc.)
 # Runtime invariants
 
 - **Write refuses on existing files.** Use **Edit** with exact `old_string` / `new_string` to modify — `old_string` must match exactly (whitespace included). If it appears multiple times in the file, pass `replace_all: true` or add more surrounding context to make the match unique. Read with line numbers first when precision is in doubt. This is a runtime invariant, not guidance — when Write refuses, the error returns the exact Edit call-shape for the same path; follow it.
+- **Edit refuses on unread files.** A file must be **Read** in the current session before you can Edit it — this is a runtime invariant. If an edit is blocked, Read the file first to get the exact current text (so `old_string` matches), then Edit. Files you just wrote count as read.
 - **Bash / ShellSession default timeout is 30 s.** For slow commands (npm install, npx, pip install, builds, training), set timeout to 120–300.
 - Per-benchmark tools (`BrowserNavigate` / `Click` / `Type` / `Scroll` / `Extract` / `Back` / `History` and `EvidenceAdd` / `Get` / `List`) appear when relevant; their schemas are passed to you directly when available.
 
@@ -27,6 +28,10 @@ Instead, proactively write the necessary background scripts (Python, Bash, etc.)
 - **WebFetch**: Fetch and extract content from a URL
 - **WebSearch**: Search the web via DuckDuckGo
 
+## Delegation
+
+- **Dispatch**: Spawn isolated sub-coders to research a focused question. Each child reads the repo and browses online (read-only — no edit/write) and returns a concise report; the full transcript stays out of your context. Single mode `{ task }`, or parallel `{ tasks: [{ label, task }] }` (up to 4). Use it to gather facts before implementing, then do the edits yourself.
+
 Additional tools appear per benchmark: `BrowserNavigate`/`Click`/`Type`/`Scroll`/`Extract`/`Back`/`History` and `EvidenceAdd`/`Get`/`List` (GAIA). Their schemas are passed to you directly when available.
 
 # Approaching complex tasks

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 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.0] — 2026-06-15
+
+### Added
+- **Plan Mode (shift+tab).** A Claude-Code-style "research → ask → plan" flow, built as the new `plan-mode` extension. Press **shift+tab** to toggle it (an honey `◆ PLAN MODE` indicator appears below the input). When it's on, submitting a request does *not* run a normal coding turn — instead little-coder: (1) decomposes the request into 1-4 exploration tasks, (2) dispatches read-only explorer sub-coders to gather information (their transcripts never enter the main context — only their concise reports survive), (3) generates 1-3 clarifying questions, each with suggested answers plus a free-text "Other" option, asked via the UI, and (4) synthesizes the findings + your answers into a written plan in the chat. Each reasoning phase ("deciding what to explore…", "preparing clarifying questions…") shows an animated spinner with a running m:ss timer. The planning instructions + research are injected into the synthesis turn's system prompt, so the chat shows only your original request and the plan — never the internal scaffolding. A single continuous m:ss timer runs for the whole process (not just the per-sub-coder timers). When the plan is presented, an **Approve & implement / Keep planning** prompt (arrow keys + enter) gates implementation — only on approval does little-coder start making the changes. **Esc** (or Ctrl+C) cancels a plan in progress.
+- **Up-arrow prompt history** (`prompt-history` extension), **persisted across sessions**. pi's default editor has no prompt recall; from an empty prompt, **↑** now walks back through your recent prompts (most-recent first) and **↓** walks forward. History is saved to `<agentDir>/little-coder-prompt-history.json`, so even a brand-new session can recall prompts from earlier runs. Implemented as a `CustomEditor` subclass (pi copies its keybindings/autocomplete/submit wiring onto it) using `keybindings.matches` for ↑/↓ detection — robust to pi's Kitty keyboard protocol and key-release events — and scoped to recall-from-empty so it never interferes with multi-line cursor movement or the autocomplete dropdown. Edits/writes are blocked during the synthesis turn so plan mode produces a plan, not changes. shift+tab previously cycled the thinking level; pi (≥ 0.79) reserves built-in shortcuts and won't let an extension claim a colliding one, so the launcher rebinds the thinking-level cycle to **alt+t** in `~/.pi/agent/keybindings.json` (non-destructively — only when you haven't set your own binding for it), freeing shift+tab for Plan Mode.
+- **Sub-coders (`dispatch` tool).** little-coder can now spawn isolated child little-coder sessions to research a focused question — single (`{ task }`) or parallel (`{ tasks: [{ label, task }] }`, up to 4, concurrency 2 by default, override with `LITTLE_CODER_SUBCODER_CONCURRENCY`). Children run with the **same local-model provider and extensions** as the parent (spawned through the launcher headless, not bare `pi`) but are constrained to **read + browse-online** tools (read, grep, glob, webfetch, websearch, browser, read-only bash) — no edit/write and no recursive dispatch, enforced via the existing `tool-gating` + `permission-gate` env gates. Each child returns a **concise report**; its full transcript lives in the tool's UI-only `details` and never enters the parent model's context, keeping the main window clean. New `subagent` extension (`spawn.ts` engine, importable by plan mode).
+- **Live sub-coder tracker.** A small animated panel above the input shows each running/finished sub-coder with a spinner, status (✓/✗), elapsed time, and current activity (the latest tool call or report snippet), with a diff-guarded ~120 ms repaint. Hidden on non-interactive (benchmark/RPC) runs.
+- **Session naming + terminal title sync.** The session is auto-named from your first prompt (overridable any time with pi's `/name`), and the terminal tab title now shows the session name (`little-coder · <name>`), updating when you switch sessions with `/resume`. pi's built-in `/resume` already lists past sessions for the current directory.
+- **Read-before-edit guard.** New `read-guard-edit` extension: a file must be **Read** in the current session before it can be **Edited** — an edit to an unread file is blocked with "File must be read first before edit" and a nudge to Read it (so `old_string` matches exactly). Files you just wrote count as read. Mirrors the `write-guard` enforcement pattern.
+
+### Changed
+- **`glob` match cap lowered 500 → 100** (`extra-tools/glob.ts`) to keep results focused for small models. (`grep` was already capped at 100.)
+- **Default thinking level is now `medium`** for interactive sessions (pi's default is `minimal`) — the launcher passes `--thinking medium` unless you set a level yourself (`--thinking`, or a `--model …:<level>` shorthand) or run headless (`--mode`/`-p`).
+- **Auto-named session titles are capped at 4 words**, cut on word boundaries (no more mid-word truncation) with a trailing `…` when the prompt was longer.
+
+### Dependencies
+- **Bumped bundled pi `@earendil-works/pi-coding-agent` 0.75.3 → 0.79.4.** The "Operation aborted" marker patch (`scripts/patch-pi.mjs`) still applies cleanly to the new source (verified by `patch-pi.test.mjs`). pi 0.79 no longer hoists `@earendil-works/pi-tui` to the top level, so the `dispatch` tool's result renderers now build their lines as duck-typed components via the theme (the same pattern `branding` already uses) instead of importing pi-tui primitives — no behavior change.
+
+### Notes for upgraders
+- No breaking CLI-flag or public-API changes. **shift+tab now toggles Plan Mode** instead of cycling the thinking level — use **alt+t** for the thinking-level cycle (the launcher writes this rebinding into `~/.pi/agent/keybindings.json`, preserving any binding you've already set). New env var `LITTLE_CODER_SUBCODER_CONCURRENCY` (default 2) tunes how many sub-coders run at once against your local backend.
+
+---
+
+## [v1.8.4] — 2026-06-08
+
+### Added
+- **`output-parser` now recognizes LFM2 / Liquid "Pythonic" tool calls** ([#42](https://github.com/itayinbarr/little-coder/issues/42)). LiquidAI LFM2 models emit tool calls as a Python list wrapped in special tokens — `<|tool_call_start|>[Read(path='/a.c'), Bash(command='ls -la')]<|tool_call_end|>` — a format neither pi's native path nor the existing fenced/`<tool_call>`/bare-JSON parsers understood. New `parseLiquidToolCalls()` recovers them best-effort: single **and** double quotes, dict args (`{"k":"v"}`), list args (`['a','b']`), `True`/`False`/`None`, ints/floats, commas/parens **inside** string values, truncated tails (missing `)`/`]`/quote), the issue's exact leak shape (start token + `[` stripped, `]<|tool_call_end|><|im_end|>` trailing), and the real-world `<think>…</think>[calls]` shape — all with a precision guard so ordinary prose never trips it. Each recovered call is tagged `format: "liquid"`; the extension surfaces a single, accurate diagnostic for that format instead of the futile "use native tool calls" nudge (Pythonic *is* LFM2's native channel, so nudging would just loop). 20 new parser tests, including one built from verbatim LFM2.5-8B-A1B output.
+
+### Fixed / Documentation
+- **Diagnosed and documented the actual `Failed to parse input at pos N: …<|tool_call_end|>` failure** ([#42](https://github.com/itayinbarr/little-coder/issues/42)). The error is *server-side*: llama.cpp's `chat.cpp` tool-call parser chokes when the chat template doesn't match it — typically the GGUF's **embedded** template, which renders tools as a plain `List of tools: […]` blob without the `<|tool_list_start|>` / `<|tool_call_start|>` special tokens the parser expects. Verified end-to-end with `LiquidAI/LFM2.5-8B-A1B-Q4_K_M`: the embedded template reproduces the error and the tool never runs, while serving with `--jinja --chat-template-file LFM2-8B-A1B.jinja` (the matching template, with the special tokens) parses calls into native `tool_calls` and tools execute normally. New Troubleshooting entry with the exact fix.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. If you run an LFM2/Liquid model, serve llama.cpp with `--jinja` and the model's matching chat template (see Troubleshooting). The parser change only adds recovery + a clearer diagnostic for builds that leak the calls as text.
+
+---
+
 ## [v1.8.3] — 2026-06-08
 
 ### Fixed

package/README.md

@@ -60,6 +60,14 @@ little-coder --list-models                      # see everything pi knows about
 
 The agent uses the directory you launched it from as its working directory — `Read` / `Write` / `Edit` / `Bash` operate on your project, not on little-coder's install path.
 
+### 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**.)
+- **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.
+- **Read-before-edit** — editing a file requires reading it first, so edits match the file's exact current text.
+
 For local providers (llama.cpp, Ollama, LM Studio) pi expects *some* value in the API-key env even though local servers ignore it:
 
 ```bash
@@ -99,12 +107,14 @@ build/bin/llama-server -m ~/models/Qwen3.6-35B-A3B-UD-Q4_K_M.gguf \
 
 If you only need text and want to skip the projector download, drop the second `hf download` line and the `--mmproj` flag — little-coder still works text-only, but the TUI's image attachment will be rejected by the server with a 4xx.
 
+**Context window.** `-c` sets the server's context (`-c 16384` = 16K above — a conservative default for 8 GB VRAM). little-coder **auto-detects the live `n_ctx`** from llama.cpp's `/props` at startup and registers the model with it, so whatever you pass to `-c` is what the TUI shows and budgets against — no `models.json` edit needed. To run larger, relaunch the server with e.g. `-c 131072` (128K) or `-c 262144` (256K); the KV cache grows with it, so size it to your RAM/VRAM. (`--list-models` reflects the detected window.)
+
 **Option B — Ollama** (simpler, but slower on MoE):
 
 ```bash
 curl -fsSL https://ollama.com/install.sh | sh
 ollama pull qwen3.5        # 9.7B — the paper's model
-# or: ollama pull qwen3.6-35b-a3b
+# or: ollama pull qwen3.6:35b-a3b
 ```
 
 **Option C — LM Studio** (GUI; OpenAI-compatible server on port 1234):
@@ -294,6 +304,8 @@ This is where the scaffolding work now compounds: knowledge injection/selection,
 
 **Image attachment is accepted but the request returns 4xx** — your llama-server is running without a vision projector. Re-launch it with `--mmproj ~/models/mmproj-F16.gguf` (or another mmproj variant from the same GGUF repo). The `--list-models` `images` column reflects what the client *will attempt to send*, not what the server can answer; the projector is what gives the model eyes.
 
+**`Failed to parse input at pos N: SomeTool(arg='…')]<|tool_call_end|>` (LFM2 / Liquid models)** — the model is emitting its native *Pythonic* tool calls (`<|tool_call_start|>[Read(path='…')]<|tool_call_end|>`), but llama.cpp's tool-call parser is choking on them — usually because the **chat template doesn't match the parser**. The GGUF's *embedded* template often renders tools as a plain `List of tools: […]` blob without the `<|tool_list_start|>` / `<|tool_call_start|>` special tokens the parser expects. Fix: serve with `--jinja` and the model's **proper** chat template, e.g. `llama-server -m LFM2.5-8B-A1B-Q4_K_M.gguf --jinja --chat-template-file LFM2-8B-A1B.jinja` (templates ship under `llama.cpp/models/templates/`). With the matching template, llama.cpp parses the calls into native `tool_calls` and tools execute normally — verified end-to-end with LFM2.5-8B-A1B. If your build still leaks the calls as plain text, little-coder's `output-parser` recognizes the format and surfaces this same diagnostic instead of a cryptic error (issue [#42](https://github.com/itayinbarr/little-coder/issues/42)).
+
 **No API key env var warning** — pi expects *some* key even for local providers. Export `LLAMACPP_API_KEY=noop` (or `OLLAMA_API_KEY=noop`) before launching.
 
 **No pi "Update Available" banner** — that's intentional. little-coder defaults `PI_SKIP_VERSION_CHECK=1` so the bundled pi runtime doesn't nag about updating itself; little-coder pins pi to a known-good version per release. If you actually want the banner back, `export PI_SKIP_VERSION_CHECK=0` before launching.
@@ -328,11 +340,15 @@ The benchmarks harness (`benchmarks/`) is dev-only and not shipped with the npm
 little-coder/
 ├── .pi/
 │   ├── settings.json               # per-model profiles + benchmark_overrides (terminal_bench, gaia)
-│   └── extensions/                 # 23 TypeScript extensions, auto-discovered by pi
-│       ├── branding/               # little-coder startup header + terminal title (replaces pi's built-in)
+│   └── 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)
+│       ├── 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)
 │       ├── write-guard/            # Write refuses on existing files; rewrites root-bare /foo.md paths to cwd
 │       ├── read-guard/             # trims a Read that would overflow the context window to its first 30 lines + a search-instead directive
+│       ├── read-guard-edit/        # Edit refuses until the file has been Read this session
 │       ├── extra-tools/            # glob, webfetch, websearch (pi ships grep/find)
 │       ├── skill-inject/           # per-turn tool-skill selection (error > recency > intent)
 │       ├── knowledge-inject/       # algorithm cheat-sheet scoring (word=1.0, bigram=2.0, threshold=2.0)