pi-jar 0.1.1 → 0.1.2

package/src/shells.ts

@@ -11,7 +11,10 @@ export const SHELL_MESSAGE = "pi-jar.shell";
 export const MAX_RUNNING_SHELLS = 8;
 const MAX_KEPT_SHELLS = 20;
 const MAX_LINES = 2000;
+const LINE_PRUNE_BATCH = 128;
 const MAX_LINE_CHARS = 2000;
+const MAX_RETAINED_CHARS = 1024 * 1024;
+const MAX_TOOL_OUTPUT_CHARS = 32 * 1024;
 const KILL_GRACE_MS = 3000;
 
 export type ShellStatus = "running" | "exited" | "killed" | "failed";
@@ -44,14 +47,25 @@ const ANSI = /\x1b\][^\x07]*(?:\x07|\x1b\\)?|\x1b\[[0-?]*[ -/]*[@-~]|\x1b./g;
 export class ShellManager {
   private jobs = new Map<string, { job: ShellJob; child?: ChildProcess; pattern?: RegExp; partial: string; timer?: ReturnType<typeof setTimeout> }>();
   private next = 1;
+  private lineChars = new Map<string, number>();
   private readonly onEvent: (event: ShellEvent) => void;
   private readonly spawnShell: typeof spawn;
   onChange?: () => void;
   constructor(onEvent: (event: ShellEvent) => void, spawnShell: typeof spawn = spawn) { this.onEvent = onEvent; this.spawnShell = spawnShell; }
 
   list(): ShellJob[] { return [...this.jobs.values()].map(({ job }) => ({ ...job, lines: [...job.lines] })); }
+  summaries(): Array<Omit<ShellJob, "lines">> {
+    return [...this.jobs.values()].map(({ job }) => {
+      const { lines: _lines, ...summary } = job;
+      return { ...summary };
+    });
+  }
   get(id: string): ShellJob | undefined { const entry = this.jobs.get(id); return entry && { ...entry.job, lines: [...entry.job.lines] }; }
-  running(): number { return [...this.jobs.values()].filter(({ job }) => job.status === "running").length; }
+  running(): number {
+    let count = 0;
+    for (const { job } of this.jobs.values()) if (job.status === "running") count++;
+    return count;
+  }
 
   start(options: StartOptions): ShellJob {
     const command = options.command.trim();
@@ -68,6 +82,7 @@ export class ShellManager {
       notify: options.notify ?? true, lines: [], dropped: 0, ...(options.watch ? { watch: options.watch } : {}) };
     const entry: { job: ShellJob; child?: ChildProcess; pattern?: RegExp; partial: string; timer?: ReturnType<typeof setTimeout> } = { job, partial: "", ...(pattern ? { pattern } : {}) };
     this.jobs.set(id, entry);
+    this.lineChars.set(id, 0);
     // Own process group so kill() stops the whole tree (dev servers spawn children).
     const child = this.spawnShell("/bin/sh", ["-c", command], { cwd: options.cwd, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"], env: process.env });
     entry.child = child;
@@ -105,16 +120,26 @@ export class ShellManager {
     const line = raw.replace(ANSI, "").replace(/\r/g, "").slice(0, MAX_LINE_CHARS);
     const { job } = entry;
     job.lines.push(line);
-    if (job.lines.length > MAX_LINES) { job.lines.splice(0, job.lines.length - MAX_LINES); job.dropped++; }
+    this.lineChars.set(job.id, (this.lineChars.get(job.id) ?? 0) + line.length);
+    // Bound both line count and retained characters. A shell that prints very wide lines should
+    // not quietly reserve several MiB forever just because it has not reached MAX_LINES yet.
+    while (job.lines.length > MAX_LINES + LINE_PRUNE_BATCH || (this.lineChars.get(job.id) ?? 0) > MAX_RETAINED_CHARS) {
+      const removed = job.lines.splice(0, Math.min(LINE_PRUNE_BATCH, job.lines.length));
+      let removedChars = 0;
+      for (const item of removed) removedChars += item.length;
+      this.lineChars.set(job.id, Math.max(0, (this.lineChars.get(job.id) ?? 0) - removedChars));
+      job.dropped += removed.length;
+      if (!removed.length) break;
+    }
     if (entry.pattern && !job.matched && entry.pattern.test(line)) {
       job.matched = line;
-      this.onEvent({ kind: "match", job: { ...job, lines: [...job.lines] } });
+      this.onEvent({ kind: "match", job: { ...job, lines: job.lines.slice(-20) } });
     }
   }
 
   private finish(entry: { job: ShellJob; timer?: ReturnType<typeof setTimeout> }): void {
     if (entry.timer) clearTimeout(entry.timer);
-    this.onEvent({ kind: "exit", job: { ...entry.job, lines: [...entry.job.lines] } });
+    this.onEvent({ kind: "exit", job: { ...entry.job, lines: entry.job.lines.slice(-20) } });
     this.onChange?.();
   }
 
@@ -122,8 +147,10 @@ export class ShellManager {
   output(id: string, count = 40): string[] {
     const entry = this.jobs.get(id);
     if (!entry) throw new Error("no shell " + id);
-    const lines = [...entry.job.lines, ...(entry.partial ? [entry.partial] : [])];
-    return lines.slice(-Math.max(1, Math.min(400, Math.floor(count))));
+    const limit = Math.max(1, Math.min(400, Math.floor(count)));
+    if (!entry.partial) return entry.job.lines.slice(-limit);
+    if (limit === 1) return [entry.partial];
+    return [...entry.job.lines.slice(-(limit - 1)), entry.partial];
   }
 
   kill(id: string): boolean {
@@ -147,22 +174,41 @@ export class ShellManager {
   /** Forget finished jobs beyond the retention limit (oldest first). */
   private prune(): void {
     const finished = [...this.jobs.values()].filter(({ job }) => job.status !== "running");
-    for (const { job } of finished.slice(0, Math.max(0, this.jobs.size - MAX_KEPT_SHELLS + 1))) this.jobs.delete(job.id);
+    for (const { job } of finished.slice(0, Math.max(0, this.jobs.size - MAX_KEPT_SHELLS + 1))) {
+      this.jobs.delete(job.id);
+      this.lineChars.delete(job.id);
+    }
   }
 
   dispose(): void {
     for (const id of this.jobs.keys()) { try { this.kill(id); } catch { /* already gone */ } }
     this.jobs.clear();
+    this.lineChars.clear();
   }
 }
 
-const elapsed = (job: ShellJob, now = Date.now()) => {
+type ShellMeta = Omit<ShellJob, "lines">;
+const elapsed = (job: ShellMeta | ShellJob, now = Date.now()) => {
   const seconds = Math.max(0, Math.round(((job.endedAt ?? now) - job.startedAt) / 1000));
   return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
 };
-export const shellState = (job: ShellJob) => job.status === "running" ? "running"
+export const shellState = (job: ShellMeta | ShellJob) => job.status === "running" ? "running"
   : job.status === "exited" ? `exited ${job.exitCode ?? "?"}` : job.status === "failed" ? `failed: ${cleanText(job.error ?? "", 60)}` : "killed";
-const describe = (job: ShellJob) => `${job.id} · ${job.name} · ${shellState(job)} · ${elapsed(job)}${job.watch ? ` · watch /${job.watch}/${job.matched ? " matched" : ""}` : ""}`;
+const describe = (job: ShellMeta | ShellJob) => `${job.id} · ${job.name} · ${shellState(job)} · ${elapsed(job)}${job.watch ? ` · watch /${job.watch}/${job.matched ? " matched" : ""}` : ""}`;
+const boundedTail = (lines: readonly string[], limit = MAX_TOOL_OUTPUT_CHARS): string => {
+  let size = 0;
+  const kept: string[] = [];
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const line = lines[index]!;
+    const cost = line.length + (kept.length ? 1 : 0);
+    if (size + cost > limit) break;
+    kept.push(line);
+    size += cost;
+  }
+  kept.reverse();
+  const omitted = lines.length - kept.length;
+  return (omitted ? `… ${omitted} earlier line(s) omitted\n` : "") + kept.join("\n");
+};
 
 /** The message that wakes the agent when a watched shell matches or ends. */
 export function shellEventMessage(event: ShellEvent): string {
@@ -198,7 +244,9 @@ export function registerShells(pi: ExtensionAPI, shells: () => ShellManager | un
     parameters: Parameters,
     async execute(_id, params, _signal, _update, ctx) {
       const manager = shells();
-      const reply = (text: string, jobs: ShellJob[] = manager?.list() ?? []) => ({ content: [{ type: "text" as const, text }], details: { jobs } });
+      const reply = (text: string) => ({ content: [{ type: "text" as const, text: text.slice(0, MAX_TOOL_OUTPUT_CHARS) }], details: {
+        jobs: (manager?.summaries() ?? []).map((job) => ({ id: job.id, name: job.name, status: job.status, pid: job.pid, exitCode: job.exitCode }))
+      } });
       if (!manager) return reply("Background shells are unavailable before a Pi session starts.");
       try {
         switch (params.action) {
@@ -210,14 +258,14 @@ export function registerShells(pi: ExtensionAPI, shells: () => ShellManager | un
           case "output": {
             if (!params.id) return reply("output needs an id.");
             const lines = manager.output(params.id, params.lines ?? 40);
-            return reply(`${describe(manager.get(params.id)!)}\n${lines.length ? lines.join("\n") : "(no output yet)"}`);
+            return reply(`${describe(manager.get(params.id)!)}\n${lines.length ? boundedTail(lines) : "(no output yet)"}`);
           }
           case "kill":
             if (!params.id) return reply("kill needs an id.");
             return reply(manager.kill(params.id) ? `Stopping ${params.id}.` : `${params.id} is not running.`);
           default: {
-            const jobs = manager.list();
-            return reply(jobs.length ? jobs.map(describe).join("\n") : "No background shells.", jobs);
+            const jobs = manager.summaries();
+            return reply(jobs.length ? jobs.map(describe).join("\n") : "No background shells.");
           }
         }
       } catch (error) {
@@ -232,11 +280,18 @@ export function registerShells(pi: ExtensionAPI, shells: () => ShellManager | un
       return new Text(text, 0, 0);
     },
     renderResult(result, { expanded }, theme) {
-      const text = result.content.map((part) => part.type === "text" ? part.text : "").join("\n");
-      const lines = text.split("\n");
-      const shown = expanded ? lines : lines.slice(0, 6);
+      const text = result.content.find((part) => part.type === "text")?.text ?? "";
+      if (expanded) {
+        const lines = text.split("\n");
+        return new Text(lines.map((line, index) => theme.fg(index ? "muted" : "accent", safeLine(line))).join("\n"), 0, 0);
+      }
+      // Historical shell cards are rebuilt on resume. Split only enough text to draw the collapsed
+      // card instead of counting every stored output line.
+      const sample = text.split("\n", 7);
+      const more = sample.length > 6;
+      const shown = sample.slice(0, 6);
       return new Text(shown.map((line, index) => theme.fg(index ? "muted" : "accent", safeLine(line))).join("\n")
-        + (shown.length < lines.length ? "\n" + theme.fg("dim", `… +${lines.length - shown.length} lines (expand)`) : ""), 0, 0);
+        + (more ? "\n" + theme.fg("dim", "… more lines (expand)") : ""), 0, 0);
     }
   });
 }
@@ -249,7 +304,7 @@ const SHELL_ACTIONS = [
 /** Overlay: shells on the left, the selected shell's live output on the right; k kills. */
 export async function openShellsView(ctx: ExtensionContext, manager: ShellManager): Promise<void> {
   if (!ctx.hasUI || ctx.mode !== "tui") return;
-  if (!manager.list().length) { ctx.ui.notify("pi-jar: no background shells (the agent starts them with jar_shell)", "info"); return; }
+  if (!manager.summaries().length) { ctx.ui.notify("pi-jar: no background shells (the agent starts them with jar_shell)", "info"); return; }
   await ctx.ui.custom<void>((tui, theme, _keys, done) => {
     let selected = 0;
     let follow = true;
@@ -259,14 +314,14 @@ export async function openShellsView(ctx: ExtensionContext, manager: ShellManage
     let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
     const fg = (color: string, text: string) => theme.fg(color as never, text);
     const previous = manager.onChange;
-    const timer = setInterval(() => tui.requestRender(), 500);
+    const timer = setInterval(() => tui.requestRender(), 1000);
     timer.unref?.();
     manager.onChange = () => { previous?.(); tui.requestRender(); };
     const close = () => { clearInterval(timer); manager.onChange = previous; done(); };
     const component = {
       invalidate() {},
       handleInput(data: string) {
-        const jobs = manager.list();
+        const jobs = manager.summaries();
         if (matchesKey(data, Key.escape) || data === "q") return close();
         if (matchesKey(data, Key.up) || data === "k") selected = Math.max(0, selected - 1);
         else if (matchesKey(data, Key.down) || data === "j") selected = Math.min(jobs.length - 1, selected + 1);
@@ -281,14 +336,14 @@ export async function openShellsView(ctx: ExtensionContext, manager: ShellManage
         if (event.type === "wheel" && event.wheelDelta) { follow = false; scroll = Math.max(0, scroll + Math.sign(event.wheelDelta) * 3); tui.requestRender(); return { handled: true }; }
         if (event.type !== "click" || event.button !== "left") return;
         if (event.y === 0 && event.x >= width - 3) { close(); return { handled: true }; }
-        if (row >= 0 && row < layout.rows && layout.leftWidth && event.x < layout.leftWidth + 3 && row < manager.list().length) { selected = row; follow = true; tui.requestRender(); return { handled: true, focus: true }; }
+        if (row >= 0 && row < layout.rows && layout.leftWidth && event.x < layout.leftWidth + 3 && row < manager.summaries().length) { selected = row; follow = true; tui.requestRender(); return { handled: true, focus: true }; }
         const action = SHELL_ACTIONS[event.y - layout.footerTop];
         if (action) { component.handleInput(action.key); return { handled: true }; }
       },
       render(available: number): string[] {
         width = Math.max(24, available);
         rows = contentRows(6 + SHELL_ACTIONS.length, 6);
-        const jobs = manager.list();
+        const jobs = manager.summaries();
         selected = Math.min(selected, Math.max(0, jobs.length - 1));
         const job = jobs[selected];
         const listWidth = sidebarWidth(width, 20, 34);

package/src/side-model.ts

@@ -16,7 +16,10 @@ export interface SideCall {
 /** Session-scoped record of side calls, so /usage can show what they cost. */
 export class SideUsage {
   private calls: SideCall[] = [];
-  add(call: SideCall): void { this.calls.push(call); if (this.calls.length > 500) this.calls.shift(); }
+  add(call: SideCall): void {
+    this.calls.push(call);
+    if (this.calls.length > 512) this.calls.splice(0, 64);
+  }
   all(): readonly SideCall[] { return this.calls; }
   clear(): void { this.calls = []; }
 }
@@ -42,7 +45,16 @@ export async function askRole(ctx: ExtensionContext, roles: ModelRoleManager, us
   usage?.add({ role, model: name, input: result.usage?.input ?? 0, output: result.usage?.output ?? 0, cacheRead: result.usage?.cacheRead ?? 0,
     cacheWrite: result.usage?.cacheWrite ?? 0, cost: Number.isFinite(cost) ? cost! : 0, at: Date.now() });
   if (result.stopReason === "error" || result.stopReason === "aborted") throw new Error(result.errorMessage || `${name} ${result.stopReason}`);
-  const text = result.content.filter((part) => part.type === "text").map((part) => (part as { text: string }).text).join("").trim();
+  const MAX_ANSWER_CHARS = 32 * 1024;
+  let text = "";
+  for (const part of result.content) {
+    if (part.type !== "text") continue;
+    const value = (part as { text: string }).text;
+    const room = MAX_ANSWER_CHARS - text.length;
+    if (room <= 0) break;
+    text += value.slice(0, room);
+  }
+  text = text.trim();
   if (!text) throw new Error(`${name} returned an empty answer`);
   return { text, model: name };
 }

package/src/status.ts

@@ -24,6 +24,36 @@ export interface JarStatus {
   extras: string[];
 }
 
+const ROLE_CACHE_LIMIT = 64;
+const roleCache = new Map<string, JarRole | null>();
+
+function cachedRole(id: string, rawValue: string): JarRole | undefined {
+  const cacheKey = id + "\0" + rawValue;
+  if (roleCache.has(cacheKey)) return roleCache.get(cacheKey) ?? undefined;
+  let parsed: JarRole | undefined;
+  try {
+    if (rawValue.length > 4096) throw new Error("oversized status");
+    const data: unknown = JSON.parse(rawValue);
+    if (!data || typeof data !== "object") throw new Error("invalid status");
+    const role = data as Record<string, unknown>;
+    if (typeof role.name !== "string" || typeof role.state !== "string" || !STATES.has(role.state as RoleState)) throw new Error("invalid role");
+    const expiresAt = role.expiresAt;
+    if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) throw new Error("invalid expiry");
+    const name = cleanText(role.name, 32) || id;
+    parsed = {
+      id,
+      name,
+      label: cleanText(typeof role.label === "string" ? role.label : name, 12) || id,
+      state: role.state as RoleState,
+      task: typeof role.task === "string" ? cleanText(role.task, 48) : undefined,
+      expiresAt
+    };
+  } catch { parsed = undefined; }
+  roleCache.set(cacheKey, parsed ?? null);
+  if (roleCache.size > ROLE_CACHE_LIMIT) roleCache.delete(roleCache.keys().next().value!);
+  return parsed;
+}
+
 /** Explicit opt-in contract; never guess teammate state from arbitrary status prose. */
 export function collectStatuses(statuses: ReadonlyMap<string, string>, now: number): JarStatus {
   const roles: JarRole[] = [];
@@ -40,32 +70,12 @@ export function collectStatuses(statuses: ReadonlyMap<string, string>, now: numb
     }
     const id = rawKey.slice(ROLE_PREFIX.length);
     if (!/^[a-z0-9][a-z0-9-]{0,31}$/.test(id)) continue;
-    try {
-      if (rawValue.length > 4096) throw new Error("oversized status");
-      const data: unknown = JSON.parse(rawValue);
-      if (!data || typeof data !== "object") throw new Error("invalid status");
-      const role = data as Record<string, unknown>;
-      if (typeof role.name !== "string" || typeof role.state !== "string" || !STATES.has(role.state as RoleState)) {
-        throw new Error("invalid role");
-      }
-      const state = role.state as RoleState;
-      const expiresAt = role.expiresAt;
-      if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || expiresAt <= now || expiresAt > now + ROLE_TTL_MS) {
-        extras.push(`${id}: unavailable`);
-        continue;
-      }
-      const name = cleanText(role.name, 32) || id;
-      roles.push({
-        id,
-        name,
-        label: cleanText(typeof role.label === "string" ? role.label : name, 12) || id,
-        state,
-        task: typeof role.task === "string" ? cleanText(role.task, 48) : undefined,
-        expiresAt: typeof expiresAt === "number" ? expiresAt : undefined
-      });
-    } catch {
+    const role = cachedRole(id, rawValue);
+    if (!role || role.expiresAt == null || role.expiresAt <= now || role.expiresAt > now + ROLE_TTL_MS) {
       extras.push(`${id}: unavailable`);
+      continue;
     }
+    roles.push(role);
   }
   return { roles: roles.slice(0, 16), extras: extras.slice(0, 16) };
 }

package/src/suggest.ts

@@ -4,7 +4,6 @@ import { Type } from "typebox";
 import { cleanText } from "./status.ts";
 
 export const SUGGEST_TOOL = "jar_suggest";
-const REMINDER_TYPE = "pi-jar.suggest-reminder";
 const MAX_SUGGESTION = 160;
 
 /** The next-prompt suggestion shown as ghost text in an empty composer. Session-only, never persisted. */
@@ -25,27 +24,22 @@ export class SuggestionState {
 
 export interface SuggestionOptions {
   enabled: () => boolean;
-  /** Skip enforcement while another workflow owns the next step (plan review, goal loop). */
-  skip: () => boolean;
 }
 
 /** Ask the agent for one next-prompt suggestion per finished request, like an inline autocomplete. */
 export function registerSuggestions(pi: ExtensionAPI, state: SuggestionState, options: SuggestionOptions): { sync(): void } {
-  let suggested = false;
-  let reminded = false;
   pi.registerTool?.({
     name: SUGGEST_TOOL,
     label: "suggest",
-    description: "Offer the user one short next prompt. It appears as dimmed ghost text in their input box; Tab accepts it for editing. Call it once, last, when you finish a request.",
-    promptSnippet: "Finish each completed request by calling jar_suggest with the most useful next prompt for the user.",
+    description: "Optionally offer one useful next prompt as ghost text in the input box; Tab accepts it for editing.",
+    promptSnippet: "Optionally use jar_suggest at the end when one genuinely useful next prompt would help the user continue.",
     promptGuidelines: [
-      "When you finish the user's request, call jar_suggest exactly once as your final action with the single most useful next prompt the user could send (imperative, one line, under 120 characters, written as the user would type it, e.g. \"Run the full test suite\").",
-      "Do not mention jar_suggest or the suggestion in your reply, and do not call it mid-task or while waiting for an answer."
+      "jar_suggest is best-effort, not mandatory. Use it only when there is one clear next action worth surfacing; skip it for routine completions.",
+      "When used, call it once as the final action with one imperative line under 120 characters. Do not mention jar_suggest in your reply."
     ],
     parameters: Type.Object({ suggestion: Type.String({ description: "The user's likely next prompt, one line." }) }),
     execute: async (_id, params) => {
       const ok = state.set(params.suggestion ?? "");
-      suggested ||= ok;
       return { content: [{ type: "text", text: ok ? "Suggestion shown to the user. End your turn now." : "Suggestion was empty; skipped." }], details: { suggestion: state.text }, terminate: true };
     },
     renderCall() { return new Text("", 0, 0); },
@@ -66,24 +60,11 @@ export function registerSuggestions(pi: ExtensionAPI, state: SuggestionState, op
 
   pi.on("input", (event) => {
     if (event.source !== "interactive") return;
-    suggested = false;
-    reminded = false;
     state.clear();
   });
   pi.on("agent_start", () => { state.clear(); });
-  pi.on("session_start", () => { suggested = false; reminded = false; state.clear(); });
+  pi.on("session_start", () => { state.clear(); });
   pi.on("session_tree", () => { state.clear(); });
-  pi.on("context", async (event) => ({ messages: event.messages.filter((raw) => (raw as { customType?: string }).customType !== REMINDER_TYPE) }));
-
-  pi.on("agent_before_settle", (event) => {
-    if (!options.enabled() || options.skip() || event.continue || event.outcome !== "completed" || suggested || reminded) return;
-    if (typeof pi.getActiveTools === "function" && !pi.getActiveTools().includes(SUGGEST_TOOL)) return;
-    reminded = true;
-    return {
-      entries: [{ type: "custom_message", customType: REMINDER_TYPE, display: false,
-        content: "[PI-JAR] Call jar_suggest now with the single most useful next prompt for the user. Do not add any other text." }],
-      continue: true
-    };
-  });
+  // No settle hook: suggestions must not add a provider turn or a hidden session entry.
   return { sync };
 }

package/src/task-tool.ts

@@ -22,14 +22,27 @@ const Parameters = Type.Object({
 
 interface TaskToolDetails {
   action: string;
+  /** Bounded preview only; the canonical list lives in TodoStore. */
   items: Todo[];
+  total: number;
+  done: number;
+  current?: string;
   changed?: string;
+  truncated?: boolean;
 }
 
+const stats = (items: readonly Todo[]) => {
+  let done = 0;
+  let current: Todo | undefined;
+  for (const item of items) {
+    if (item.done) done++;
+    if (!current && item.status === "in_progress") current = item;
+  }
+  return { total: items.length, done, current };
+};
 const summary = (items: readonly Todo[]) => {
-  const done = items.filter((item) => item.done).length;
-  const current = items.find((item) => item.status === "in_progress");
-  return `${done}/${items.length} done` + (current ? ` · now: ${current.title}` : "");
+  const value = stats(items);
+  return `${value.done}/${value.total} done` + (value.current ? ` · now: ${value.current.title}` : "");
 };
 
 const lines = (items: readonly Todo[]) => items.length
@@ -60,7 +73,7 @@ export function registerTaskTool(
       const current = store();
       const action = params.todos ? "write" : params.action ?? "list";
       if (!current) {
-        return { content: [{ type: "text", text: "Task tracking is unavailable before a Pi session starts." }], details: { action, items: [] } satisfies TaskToolDetails };
+        return { content: [{ type: "text", text: "Task tracking is unavailable before a Pi session starts." }], details: { action, items: [], total: 0, done: 0 } satisfies TaskToolDetails };
       }
       let changedId: string | undefined;
       let error: string | undefined;
@@ -94,12 +107,22 @@ export function registerTaskTool(
       }
       if (action !== "list" && !error) changed(ctx);
       const items = current.all();
+      const state = stats(items);
+      const changedItem = changedId ? items.find((item) => item.id === changedId) : undefined;
       const message = error
-        ? `Could not ${action} tasks: ${error}\n${lines(items)}`
-        : `${action === "list" ? "Tasks" : "Task list updated"} (${summary(items)}):\n${lines(items)}${action === "list" ? "" : "\n" + REMINDER}`;
+        ? `Could not ${action} tasks: ${error} (${summary(items)}).`
+        : action === "list"
+          ? `Tasks (${summary(items)}):\n${lines(items)}`
+          : `Task list updated (${summary(items)}).${changedItem ? `\n${todoMark(changedItem)} [${changedItem.status}] ${changedItem.title} (${changedItem.id})` : ""}\n${REMINDER}`;
+      const preview = items.slice(0, 8);
       return {
         content: [{ type: "text", text: message }],
-        details: { action, items, ...(changedId ? { changed: changedId } : {}) } satisfies TaskToolDetails
+        details: {
+          action, items: preview, total: state.total, done: state.done,
+          ...(state.current ? { current: state.current.title } : {}),
+          ...(preview.length < items.length ? { truncated: true } : {}),
+          ...(changedId ? { changed: changedId } : {})
+        } satisfies TaskToolDetails
       };
     },
     renderCall(args, theme) {
@@ -115,12 +138,13 @@ export function registerTaskTool(
       if (isPartial) return new Text(theme.fg("warning", "Updating tasks…"), 0, 0);
       const details = result.details as TaskToolDetails | undefined;
       const items = details?.items ?? [];
-      if (!items.length) return new Text(theme.fg("dim", "No tracked tasks."), 0, 0);
-      // Like Claude: the checklist itself is the result. Collapsed shows up to 8 rows.
+      const total = details?.total ?? items.length;
+      const done = details?.done ?? items.filter((item) => item.done).length;
+      if (!total) return new Text(theme.fg("dim", "No tracked tasks."), 0, 0);
       const shown = expanded ? items : items.slice(0, 8);
-      let text = theme.fg("dim", summary(items));
+      let text = theme.fg("dim", `${done}/${total} done${details?.current ? " · now: " + details.current : ""}`);
       for (const item of shown) text += "\n" + todoRow(item, (color, value) => theme.fg(color, value), (value) => theme.bold(value));
-      if (shown.length < items.length) text += "\n" + theme.fg("dim", `  … +${items.length - shown.length} more (expand)`);
+      if (details?.truncated || shown.length < total) text += "\n" + theme.fg("dim", `  … +${Math.max(0, total - shown.length)} more · /jar tasks`);
       return new Text(text, 0, 0);
     }
   });

package/src/tasks.ts

@@ -22,6 +22,18 @@ export type TodoEvent =
 const validId = (id: unknown): id is string => typeof id === "string" && /^[a-zA-Z0-9-]{1,64}$/.test(id);
 const validTitle = (title: unknown): title is string => typeof title === "string" && title.length <= 256 && !!cleanText(title, 120);
 const validStatus = (status: unknown): status is TodoStatus => TODO_STATUSES.includes(status as TodoStatus);
+const validWrite = (event: Record<string, unknown>): boolean => {
+  if (event.v !== 1 || event.op !== "write" || !Array.isArray(event.items) || event.items.length > MAX_TODOS) return false;
+  const ids = new Set<string>();
+  let running = 0;
+  for (const raw of event.items as unknown[]) {
+    const item = raw as Record<string, unknown> | null;
+    if (!item || !validId(item.id) || !validTitle(item.title) || !validStatus(item.status) || ids.has(item.id)) return false;
+    ids.add(item.id);
+    if (item.status === "in_progress" && ++running > 1) return false;
+  }
+  return true;
+};
 const make = (id: string, title: string, status: TodoStatus, activeForm?: unknown, details?: unknown): Todo => ({
   id, title: cleanText(title, 120), status, done: status === "completed",
   ...(typeof activeForm === "string" && cleanText(activeForm, 80) ? { activeForm: cleanText(activeForm, 80) } : {}),
@@ -50,14 +62,12 @@ export class TodoStore {
     const event = raw as Record<string, unknown>;
     if (event.v !== 1) return false;
     if (event.op === "write") {
-      if (!Array.isArray(event.items) || event.items.length > MAX_TODOS) return false;
+      if (!validWrite(event)) return false;
       const next = new Map<string, Todo>();
       for (const raw of event.items as unknown[]) {
-        const item = raw as Record<string, unknown> | null;
-        if (!item || !validId(item.id) || !validTitle(item.title) || !validStatus(item.status) || next.has(item.id)) return false;
-        next.set(item.id, make(item.id, item.title, item.status, item.activeForm, this.items.get(item.id)?.details));
+        const item = raw as Record<string, unknown>;
+        next.set(item.id as string, make(item.id as string, item.title as string, item.status as TodoStatus, item.activeForm, this.items.get(item.id as string)?.details));
       }
-      if ([...next.values()].filter((item) => item.status === "in_progress").length > 1) return false;
       this.items = next;
       return true;
     }
@@ -86,11 +96,18 @@ export class TodoStore {
   }
   restore(branch: readonly unknown[]): void {
     this.items.clear();
-    for (const raw of branch) {
+    // Walk the transcript once from newest to oldest, collecting only task events. A valid full
+    // write is a checkpoint, so everything before it is irrelevant.
+    const replay: unknown[] = [];
+    for (let index = branch.length - 1; index >= 0; index--) {
+      const raw = branch[index];
       if (!raw || typeof raw !== "object") continue;
       const entry = raw as Record<string, unknown>;
-      if (entry.type === "custom" && entry.customType === TASK_ENTRY) this.apply(entry.data);
+      if (entry.type !== "custom" || entry.customType !== TASK_ENTRY) continue;
+      replay.push(entry.data);
+      if (entry.data && typeof entry.data === "object" && validWrite(entry.data as Record<string, unknown>)) break;
     }
+    for (let index = replay.length - 1; index >= 0; index--) this.apply(replay[index]);
   }
   private commit(event: TodoEvent): boolean {
     const before = new Map([...this.items].map(([id, item]) => [id, { ...item }]));

package/src/usage.ts

@@ -1,9 +1,10 @@
+import { sessionBranch } from "./session-branch.ts";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 /** Sum the active session branch, not all historical branches, using Pi's reported monetary cost. */
 export function sessionCost(ctx: Pick<ExtensionContext, "sessionManager">): number {
   let total = 0;
-  for (const entry of ctx.sessionManager.getBranch()) {
+  for (const entry of sessionBranch(ctx) as ReturnType<typeof ctx.sessionManager.getBranch>) {
     if (entry.type !== "message" || entry.message.role !== "assistant") continue;
     const value = entry.message.usage.cost.total;
     if (Number.isFinite(value) && value >= 0) total += value;