little-coder 1.8.3 → 1.9.0

package/.pi/extensions/prompt-history/prompt-history.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+import { makeHistory } from "./index.ts";
+
+describe("prompt history recall", () => {
+  it("records prompts, skipping blanks and consecutive duplicates", () => {
+    const h = makeHistory();
+    h.add("first");
+    h.add("  "); // blank
+    h.add("second");
+    h.add("second"); // dup
+    expect(h.items).toEqual(["first", "second"]);
+  });
+
+  it("persists on add via the provided callback", () => {
+    const saved: string[][] = [];
+    const h = makeHistory([], (items) => saved.push([...items]));
+    h.add("one");
+    h.add("two");
+    expect(saved).toEqual([["one"], ["one", "two"]]);
+  });
+
+  it("seeds from initial (cross-session) history", () => {
+    const h = makeHistory(["older", "newer"]);
+    expect(h.recall("up", "")).toBe("newer");
+    expect(h.recall("up", "newer")).toBe("older");
+  });
+
+  it("up from an empty prompt recalls most-recent-first and clamps", () => {
+    const h = makeHistory(["a", "b", "c"]);
+    expect(h.recall("up", "")).toBe("c");
+    expect(h.recall("up", "c")).toBe("b");
+    expect(h.recall("up", "b")).toBe("a");
+    expect(h.recall("up", "a")).toBe("a"); // clamps at oldest
+  });
+
+  it("down walks forward and clears past the newest", () => {
+    const h = makeHistory(["a", "b"]);
+    h.recall("up", ""); // → b
+    h.recall("up", "b"); // → a
+    expect(h.recall("down", "a")).toBe("b");
+    expect(h.recall("down", "b")).toBe(""); // past newest → empty
+  });
+
+  it("does NOT hijack up when the prompt is non-empty (editor handles it)", () => {
+    const h = makeHistory(["a"]);
+    expect(h.recall("up", "draft text")).toBeNull();
+  });
+
+  it("does nothing on up when there is no history", () => {
+    const h = makeHistory([]);
+    expect(h.recall("up", "")).toBeNull();
+  });
+
+  it("down with no active navigation is a no-op (editor handles it)", () => {
+    const h = makeHistory(["a"]);
+    expect(h.recall("down", "")).toBeNull();
+  });
+
+  it("reset() ends navigation so the next up starts fresh", () => {
+    const h = makeHistory(["a", "b"]);
+    h.recall("up", ""); // → b (navigating)
+    h.reset();
+    expect(h.recall("up", "b")).toBeNull(); // non-empty + not navigating → editor handles
+  });
+
+  it("caps stored history at the maximum", () => {
+    const many = Array.from({ length: 150 }, (_, i) => `p${i}`);
+    const h = makeHistory(many);
+    expect(h.items.length).toBe(100);
+    expect(h.items[0]).toBe("p50"); // kept the newest 100
+  });
+});

package/.pi/extensions/read-guard-edit/index.ts

@@ -0,0 +1,89 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { normalizeWritePath } from "../write-guard/index.ts";
+import { harnessIntervention } from "../_shared/intervention.ts";
+
+// Read-before-edit guard.
+//
+// Small models routinely fire `edit` with an `oldText` they never actually saw
+// — guessing at the current file contents — which either fails the exact-match
+// requirement (wasting a turn) or, worse, matches the wrong span. Editors the
+// user is used to (Claude Code et al.) enforce a simple invariant: a file must
+// be Read before it can be Edited. We reproduce that here.
+//
+// Mechanism mirrors write-guard: we don't own pi's built-in `read`/`edit`
+// tools, so we enforce at the event layer. We remember every file that was
+// successfully `read` this session (`tool_result`, !isError), and block any
+// `edit` whose target hasn't been read, redirecting the model to Read first.
+//
+// Why a separate extension from `read-guard`: read-guard trims an oversized
+// read so it can't overflow a small context window — a different concern from
+// the read-before-edit invariant. Keeping them apart keeps each single-purpose.
+//
+// A successful `edit` or `write` also marks the path as known: an edit only
+// succeeds when the file was already read (we'd have blocked it otherwise), and
+// a write means the model authored the file's contents, so a follow-up edit to
+// either is legitimate without a re-read.
+
+// Files read (or authored) in the current session. Module-scoped: one pi
+// process drives one session at a time, and we clear on session_start.
+export const readFiles = new Set<string>();
+
+// pi's built-in tools use `path`; some prompts/older builds use `file_path`.
+// Accept both so the guard is independent of which key the model emits.
+export function resolveToolPath(
+  input: Record<string, unknown>,
+  cwd: string,
+): string | undefined {
+  const raw =
+    typeof input.path === "string"
+      ? input.path
+      : typeof input.file_path === "string"
+        ? input.file_path
+        : undefined;
+  if (!raw) return undefined;
+  return normalizeWritePath(raw, cwd).path;
+}
+
+export function editBeforeReadReason(resolved: string): string {
+  return (
+    `File must be read first before edit — ${resolved} has not been read in ` +
+    `this session.\n` +
+    `\n` +
+    `Read ${resolved} first to get the exact current text for oldText ` +
+    `(whitespace and indentation must match exactly), then issue the Edit. ` +
+    `Reading also lets you include enough surrounding context (2-3 lines) to ` +
+    `make oldText unique in the file. Do NOT guess the file's contents.`
+  );
+}
+
+export default function (pi: ExtensionAPI) {
+  // New session (startup, /clear, /resume, reload) is a clean slate — what was
+  // read in a previous session says nothing about the current one.
+  pi.on("session_start", async () => {
+    readFiles.clear();
+  });
+
+  // Record successful reads (and authored files) as "known".
+  pi.on("tool_result", async (event, ctx) => {
+    const name = String((event as any).toolName ?? "").toLowerCase();
+    if (name !== "read" && name !== "edit" && name !== "write") return;
+    if ((event as any).isError) return;
+    const p = resolveToolPath(((event as any).input ?? {}) as Record<string, unknown>, ctx.cwd);
+    if (p) readFiles.add(p);
+  });
+
+  // Block edits to files that were never read.
+  pi.on("tool_call", async (event, ctx) => {
+    if (String((event as any).toolName ?? "").toLowerCase() !== "edit") return;
+    const input = ((event as any).input ?? {}) as Record<string, unknown>;
+    const p = resolveToolPath(input, ctx.cwd);
+    if (!p) return; // no resolvable path — let the edit tool surface its own error
+    if (readFiles.has(p)) return; // already read this session — allow
+
+    harnessIntervention(
+      ctx,
+      "the model tried to edit a file it hadn't read — redirected it to Read first.",
+    );
+    return { block: true, reason: editBeforeReadReason(p) };
+  });
+}

package/.pi/extensions/read-guard-edit/read-guard-edit.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import setupReadGuardEdit, { readFiles, resolveToolPath } from "./index.ts";
+
+describe("resolveToolPath", () => {
+  const cwd = "/home/me/proj";
+  it("resolves relative paths against cwd", () => {
+    expect(resolveToolPath({ path: "src/a.ts" }, cwd)).toBe("/home/me/proj/src/a.ts");
+  });
+  it("honors the file_path key", () => {
+    expect(resolveToolPath({ file_path: "b.ts" }, cwd)).toBe("/home/me/proj/b.ts");
+  });
+  it("returns undefined with no path", () => {
+    expect(resolveToolPath({ content: "x" }, cwd)).toBeUndefined();
+  });
+});
+
+// Wire up the extension against a fake pi, capturing each registered handler.
+function setup() {
+  const handlers: Record<string, (...args: any[]) => any> = {};
+  const pi = {
+    on(name: string, h: (...args: any[]) => any) {
+      handlers[name] = h;
+    },
+  };
+  setupReadGuardEdit(pi as any);
+  return handlers;
+}
+
+function makeCtx(cwd: string) {
+  const notifies: string[] = [];
+  return { cwd, notifies, ui: { notify: (m: string) => notifies.push(m) } };
+}
+
+describe("read-before-edit guard", () => {
+  const cwd = "/home/me/proj";
+  beforeEach(() => readFiles.clear());
+
+  it("blocks an edit to a file that was never read", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts", edits: [] } }, ctx);
+    expect(result?.block).toBe(true);
+    expect(result.reason).toContain("must be read first");
+    expect(result.reason).toContain("/home/me/proj/a.ts");
+    expect(ctx.notifies[0]).toMatch(/harness intervention:.*Read first/i);
+  });
+
+  it("allows an edit after the file was successfully read", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "read", isError: false, input: { path: "a.ts" } }, ctx);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts", edits: [] } }, ctx);
+    expect(result).toBeUndefined();
+    expect(ctx.notifies).toHaveLength(0);
+  });
+
+  it("does not count a failed read as having read the file", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "read", isError: true, input: { path: "a.ts" } }, ctx);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts" } }, ctx);
+    expect(result?.block).toBe(true);
+  });
+
+  it("treats a freshly written file as known (write then edit is allowed)", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "write", isError: false, input: { path: "new.ts" } }, ctx);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "new.ts" } }, ctx);
+    expect(result).toBeUndefined();
+  });
+
+  it("clears known files on session_start", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "read", isError: false, input: { path: "a.ts" } }, ctx);
+    await h.session_start();
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts" } }, ctx);
+    expect(result?.block).toBe(true);
+  });
+
+  it("matches reads and edits that use different path spellings for the same file", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    // read with cwd-relative, edit with the absolute form of the same file
+    await h.tool_result({ toolName: "read", isError: false, input: { path: "src/a.ts" } }, ctx);
+    const result = await h.tool_call(
+      { toolName: "edit", input: { path: "/home/me/proj/src/a.ts" } },
+      ctx,
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("ignores non-edit tool calls", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    const result = await h.tool_call({ toolName: "grep", input: { pattern: "x" } }, ctx);
+    expect(result).toBeUndefined();
+  });
+});

package/.pi/extensions/skill-inject/index.ts

@@ -56,6 +56,9 @@ const INTENT_MAP: Record<string, string[]> = {
   browse: ["BrowserNavigate", "BrowserExtract"],
   page: ["BrowserExtract"],
   click: ["BrowserClick"],
+  // Sub-coder delegation
+  delegate: ["dispatch"], dispatch: ["dispatch"], subagent: ["dispatch"],
+  investigate: ["dispatch"], parallel: ["dispatch"],
 };
 
 function skillsDir(): string {

package/.pi/extensions/skill-inject/selector.test.ts

@@ -60,10 +60,10 @@ describe("skills directory loads from repo", () => {
   const here = dirname(fileURLToPath(import.meta.url));
   const toolsDir = join(here, "..", "..", "..", "skills", "tools");
 
-  it("exists and has 13 markdown files", () => {
+  it("exists and has 14 markdown files", () => {
     expect(existsSync(toolsDir)).toBe(true);
     const files = readdirSync(toolsDir).filter((f) => f.endsWith(".md"));
-    expect(files.length).toBe(13);
+    expect(files.length).toBe(14);
   });
 
   it("every tool skill has target_tool in frontmatter", () => {

package/.pi/extensions/subagent/index.ts

@@ -0,0 +1,201 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import {
+  runSubCoder,
+  runSubCodersConcurrent,
+  truncateReport,
+  type SubCoderItem,
+  type SubCoderResult,
+} from "./spawn.ts";
+import { SubCoderTracker } from "./tracker.ts";
+
+// The `dispatch` tool: the main little-coder spawns isolated child little-coder
+// sessions ("sub-coders") to research a focused question — they read the repo
+// and browse online, then return a CONCISE report. The full child transcript
+// lives in the tool's `details` (UI-only); only the short report enters the
+// parent model's context. A live panel above the input tracks them while they
+// run. See spawn.ts for the engine and the read-only constraints.
+
+const MAX_PARALLEL = 4;
+
+/** "provider/id" of the current model, so children run on the same backend. */
+export function currentModelId(ctx: any): string | undefined {
+  const m = ctx?.model;
+  if (!m || typeof m.id !== "string") return undefined;
+  return m.provider ? `${m.provider}/${m.id}` : m.id;
+}
+
+/** A short label for a single-mode task (first few words). */
+function shortLabel(task: string): string {
+  const words = task.trim().split(/\s+/).filter(Boolean).slice(0, 4).join(" ");
+  return words.length > 28 ? `${words.slice(0, 27)}…` : words || "sub-coder";
+}
+
+function buildContent(results: SubCoderResult[]): string {
+  if (results.length === 1) {
+    const r = results[0];
+    if (r.exitCode !== 0) return `Sub-coder "${r.label}" ${r.stopReason || "failed"}: ${r.errorMessage || "(no output)"}`;
+    return truncateReport(r.report) || "(no report)";
+  }
+  const ok = results.filter((r) => r.exitCode === 0).length;
+  const blocks = results.map((r) => {
+    const status = r.exitCode === 0 ? "" : ` [${r.stopReason || "failed"}]`;
+    const body = r.exitCode === 0 ? truncateReport(r.report) : r.errorMessage || "(no output)";
+    return `### ${r.label}${status}\n${body || "(no report)"}`;
+  });
+  return `${ok}/${results.length} sub-coders succeeded.\n\n${blocks.join("\n\n")}`;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "dispatch",
+    label: "Dispatch sub-coder",
+    description: [
+      "Dispatch one or more isolated sub-coders to research a focused question.",
+      "Each runs in its own context window, can read the repo and browse online",
+      "(read, grep, glob, webfetch, websearch, browser, read-only bash) but CANNOT",
+      "edit or write files. Each returns a concise report. Use this to gather",
+      "information without cluttering your own context.",
+      "Single: { task }. Parallel: { tasks: [{ label, task }] } (max 4).",
+    ].join(" "),
+    parameters: Type.Object({
+      task: Type.Optional(Type.String({ description: "A single research task (single mode)" })),
+      tasks: Type.Optional(
+        Type.Array(
+          Type.Object({
+            label: Type.String({ description: "Short name for this sub-coder (shown in the tracker)" }),
+            task: Type.String({ description: "The research task delegated to this sub-coder" }),
+          }),
+          { description: `Up to ${MAX_PARALLEL} tasks to run in parallel` },
+        ),
+      ),
+      cwd: Type.Optional(Type.String({ description: "Working directory for the sub-coders (default: current)" })),
+    }),
+
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const hasSingle = typeof params.task === "string" && params.task.trim().length > 0;
+      const hasTasks = Array.isArray(params.tasks) && params.tasks.length > 0;
+      if (hasSingle === hasTasks) {
+        return {
+          content: [{ type: "text", text: "Provide exactly one of `task` (single) or `tasks` (parallel)." }],
+          details: { results: [] },
+          isError: true,
+        };
+      }
+      if (hasTasks && params.tasks!.length > MAX_PARALLEL) {
+        return {
+          content: [{ type: "text", text: `Too many parallel tasks (${params.tasks!.length}). Max is ${MAX_PARALLEL}.` }],
+          details: { results: [] },
+          isError: true,
+        };
+      }
+
+      const cwd = params.cwd || ctx.cwd;
+      const items: SubCoderItem[] = hasSingle
+        ? [{ id: "1", label: shortLabel(params.task!), task: params.task!, cwd }]
+        : params.tasks!.map((t, i) => ({ id: String(i + 1), label: t.label, task: t.task, cwd }));
+
+      const model = currentModelId(ctx);
+      const tracker = new SubCoderTracker(ctx as any);
+      tracker.begin(items.map((it) => ({ id: it.id, label: it.label })));
+
+      const streamToToolCard = (results: SubCoderResult[]) => {
+        if (!onUpdate) return;
+        const done = results.filter((r) => r.exitCode !== -1).length;
+        onUpdate({
+          content: [{ type: "text", text: `${done}/${results.length} sub-coders done…` }],
+          details: { results },
+        });
+      };
+
+      let results: SubCoderResult[];
+      try {
+        if (hasSingle) {
+          const r = await runSubCoder({
+            ...items[0],
+            model,
+            signal,
+            onUpdate: (live) => {
+              tracker.update([live]);
+              streamToToolCard([live]);
+            },
+          });
+          results = [r];
+        } else {
+          results = await runSubCodersConcurrent(items, {
+            model,
+            signal,
+            onUpdate: (all) => {
+              tracker.update(all);
+              streamToToolCard(all);
+            },
+          });
+        }
+      } finally {
+        tracker.end();
+      }
+
+      const anyError = results.some((r) => r.exitCode !== 0);
+      const allError = results.every((r) => r.exitCode !== 0);
+      return {
+        content: [{ type: "text", text: buildContent(results) }],
+        details: { results },
+        isError: allError && anyError,
+      };
+    },
+
+    // Renderers return a duck-typed Component ({ render→lines, invalidate }).
+    // pi 0.79 stopped hoisting pi-tui, so we build colored lines via `theme`
+    // rather than importing pi-tui primitives (same approach as branding).
+    renderCall(args: any, theme: any) {
+      const lines: string[] = [];
+      const title = theme.fg("toolTitle", theme.bold("dispatch "));
+      if (Array.isArray(args.tasks) && args.tasks.length > 0) {
+        lines.push(title + theme.fg("accent", `${args.tasks.length} sub-coders`));
+        for (const t of args.tasks.slice(0, MAX_PARALLEL)) {
+          const preview = t.task.length > 48 ? `${t.task.slice(0, 48)}…` : t.task;
+          lines.push(`  ${theme.fg("accent", t.label)}${theme.fg("dim", ` — ${preview}`)}`);
+        }
+      } else {
+        const task = String(args.task ?? "…");
+        lines.push(title + theme.fg("dim", task.length > 64 ? `${task.slice(0, 64)}…` : task));
+      }
+      return makeComponent(lines);
+    },
+
+    renderResult(result: any, options: any, theme: any) {
+      const expanded = !!options?.expanded;
+      const results: SubCoderResult[] = result?.details?.results ?? [];
+      if (results.length === 0) {
+        const t = result?.content?.[0];
+        return makeComponent([t?.type === "text" ? t.text : "(no output)"]);
+      }
+      const ok = results.filter((r) => r.exitCode === 0).length;
+      const lines: string[] = [
+        theme.fg("toolTitle", theme.bold("dispatch ")) + theme.fg("accent", `${ok}/${results.length} sub-coders`),
+      ];
+      for (const r of results) {
+        const icon = r.exitCode === 0 ? theme.fg("success", "✓") : theme.fg("error", "✗");
+        lines.push("");
+        lines.push(`${icon} ${theme.fg("accent", r.label)}`);
+        const body = r.exitCode === 0 ? r.report : r.errorMessage || r.stderr || "(no output)";
+        const bodyLines = body.trim() ? body.trim().split("\n") : ["(no output)"];
+        const shown = expanded ? bodyLines : bodyLines.slice(0, 4);
+        for (const bl of shown) lines.push(theme.fg("toolOutput", bl));
+        if (!expanded && bodyLines.length > shown.length) lines.push(theme.fg("muted", "  …"));
+      }
+      if (!expanded) lines.push(theme.fg("muted", "(Ctrl+O to expand)"));
+      return makeComponent(lines);
+    },
+  });
+}
+
+/** A minimal pi-tui Component backed by precomputed lines. */
+function makeComponent(lines: string[]) {
+  return {
+    render(_width: number): string[] {
+      return lines;
+    },
+    invalidate() {},
+  };
+}

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

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { resolve } from "node:path";
+import { runSubCoder, runSubCodersConcurrent } from "./spawn.ts";
+
+// Live end-to-end: spawns real child little-coder sessions against the local
+// model. Skipped unless LC_LIVE=1 (needs a running model server). Run with:
+//   LC_LIVE=1 LLAMACPP_API_KEY=noop npx vitest run .pi/extensions/subagent/live-spawn.test.ts
+const LIVE = process.env.LC_LIVE === "1";
+const MODEL = process.env.LC_LIVE_MODEL || "llamacpp/qwen3.6-35b-a3b";
+const repoRoot = resolve(__dirname, "..", "..", "..");
+
+describe.skipIf(!LIVE)("sub-coder live spawn", () => {
+  it(
+    "spawns a child that runs on the parent's model and returns a report",
+    async () => {
+      const r = await runSubCoder({
+        id: "1",
+        label: "ping",
+        task: "Respond with exactly the single word ALIVE. Do not use any tools.",
+        cwd: repoRoot,
+        model: MODEL,
+      });
+      expect(r.exitCode).toBe(0);
+      expect(r.report.toUpperCase()).toContain("ALIVE");
+      expect(r.usage.turns).toBeGreaterThan(0);
+    },
+    240_000,
+  );
+
+  it(
+    "runs two sub-coders in parallel and reports per-item",
+    async () => {
+      const results = await runSubCodersConcurrent(
+        [
+          { id: "1", label: "two", task: "What is 2+2? Reply with just the number.", cwd: repoRoot },
+          { id: "2", label: "cap", task: "What is the capital of France? One word.", cwd: repoRoot },
+        ],
+        { model: MODEL },
+      );
+      expect(results).toHaveLength(2);
+      expect(results.every((r) => r.exitCode === 0)).toBe(true);
+      expect(results[0].report).toContain("4");
+      expect(results[1].report.toLowerCase()).toContain("paris");
+    },
+    300_000,
+  );
+});

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

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import {
+  buildChildEnv,
+  defaultConcurrency,
+  getFinalText,
+  resolveLauncher,
+  summarizeActivity,
+  truncateReport,
+  SUBCODER_ALLOWED_TOOLS,
+  type SubCoderResult,
+} from "./spawn.ts";
+
+const base: SubCoderResult = {
+  id: "1",
+  label: "x",
+  task: "t",
+  exitCode: -1,
+  report: "",
+  messages: [],
+  stderr: "",
+  usage: { input: 0, output: 0, cost: 0, turns: 0, contextTokens: 0 },
+};
+
+describe("getFinalText", () => {
+  it("returns the last assistant text block", () => {
+    const messages = [
+      { role: "assistant", content: [{ type: "text", text: "first" }] },
+      { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: {} }] },
+      { role: "assistant", content: [{ type: "text", text: "final answer" }] },
+    ];
+    expect(getFinalText(messages)).toBe("final answer");
+  });
+  it("returns empty string when there is no assistant text", () => {
+    expect(getFinalText([{ role: "user", content: [{ type: "text", text: "hi" }] }])).toBe("");
+    expect(getFinalText([])).toBe("");
+  });
+});
+
+describe("truncateReport", () => {
+  it("leaves short reports intact", () => {
+    expect(truncateReport("short")).toBe("short");
+  });
+  it("truncates long reports with a notice", () => {
+    const out = truncateReport("a".repeat(5000), 100);
+    expect(out.length).toBeLessThan(300);
+    expect(out).toContain("truncated at 100 chars");
+  });
+});
+
+describe("summarizeActivity", () => {
+  it("shows the report's first line when done", () => {
+    expect(summarizeActivity({ ...base, exitCode: 0, report: "Found 3 routes\nmore" })).toBe("Found 3 routes");
+  });
+  it("surfaces the latest tool call while running", () => {
+    const r = {
+      ...base,
+      messages: [{ role: "assistant", content: [{ type: "toolCall", name: "grep", arguments: { pattern: "login(" } }] }],
+    };
+    expect(summarizeActivity(r)).toBe("→ grep login(");
+  });
+  it("shows the error message on failure", () => {
+    expect(summarizeActivity({ ...base, exitCode: 1, errorMessage: "boom" })).toBe("boom");
+  });
+  it("falls back to working when running with no tool call", () => {
+    expect(summarizeActivity(base)).toBe("working…");
+  });
+});
+
+describe("buildChildEnv", () => {
+  it("constrains the child to read-only tools and the headless fast-path", () => {
+    const env = buildChildEnv();
+    expect(env.LITTLE_CODER_ALLOWED_TOOLS).toBe(SUBCODER_ALLOWED_TOOLS);
+    expect(env.LITTLE_CODER_ALLOWED_TOOLS).not.toContain("edit");
+    expect(env.LITTLE_CODER_ALLOWED_TOOLS).not.toContain("write");
+    expect(env.LITTLE_CODER_ALLOWED_TOOLS).not.toContain("dispatch");
+    expect(env.LITTLE_CODER_PERMISSION_MODE).toBe("auto");
+    expect(env.LITTLE_CODER_SUBAGENT).toBe("1");
+  });
+  it("merges extra overrides", () => {
+    expect(buildChildEnv({ FOO: "bar" }).FOO).toBe("bar");
+  });
+});
+
+describe("resolveLauncher / defaultConcurrency", () => {
+  it("points at bin/little-coder.mjs", () => {
+    expect(resolveLauncher().replace(/\\/g, "/")).toMatch(/\/bin\/little-coder\.mjs$/);
+  });
+  it("defaults concurrency to 2", () => {
+    const prev = process.env.LITTLE_CODER_SUBCODER_CONCURRENCY;
+    delete process.env.LITTLE_CODER_SUBCODER_CONCURRENCY;
+    expect(defaultConcurrency()).toBe(2);
+    process.env.LITTLE_CODER_SUBCODER_CONCURRENCY = "3";
+    expect(defaultConcurrency()).toBe(3);
+    if (prev === undefined) delete process.env.LITTLE_CODER_SUBCODER_CONCURRENCY;
+    else process.env.LITTLE_CODER_SUBCODER_CONCURRENCY = prev;
+  });
+});