pi-jar 0.1.2 → 0.1.4

package/src/side-model.ts

@@ -28,33 +28,53 @@ export interface SideAnswer { text: string; model: string }
 
 /**
  * Ask the model assigned to `role` (or the current model) a one-shot question outside the
- * conversation. Throws on a missing model, provider error or empty answer.
+ * conversation. Tries configured fallbacks in order on failure; cancellation never retries.
  */
 export async function askRole(ctx: ExtensionContext, roles: ModelRoleManager, usage: SideUsage | undefined, role: string,
   systemPrompt: string, prompt: string, signal?: AbortSignal): Promise<SideAnswer> {
-  const assigned = roles.resolve(role);
-  const model = assigned ? ctx.modelRegistry.find(assigned.provider, assigned.model) : ctx.model;
-  if (!model) throw new Error(assigned ? `model not found for role ${role}: ${assigned.provider}/${assigned.model}` : "no model selected");
-  const thinking: ThinkingLevel | undefined = assigned?.thinking;
-  const reasoning = thinking && thinking !== "off" ? thinking : undefined;
-  const result = await ctx.modelRegistry.streamSimple(model,
-    { systemPrompt, messages: [{ role: "user", content: prompt, timestamp: Date.now() }] },
-    { ...(reasoning ? { reasoning } : {}), ...(signal ? { signal } : {}) }).result();
-  const name = `${model.provider}/${model.id}`;
-  const cost = result.usage?.cost?.total;
-  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 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);
+  const fallbacks = roles.fallbackSpecs?.(role) ?? [];
+  const failures: string[] = [];
+  const tried = new Set<string>();
+  for (const spec of [undefined, ...fallbacks]) {
+    signal?.throwIfAborted();
+    let name = spec ?? role;
+    let aborted = false;
+    try {
+      const assigned = spec === undefined ? roles.resolve(role) : roles.resolveSpec(spec);
+      const model = assigned ? ctx.modelRegistry.find(assigned.provider, assigned.model) : ctx.model;
+      if (!model) throw new Error(assigned ? `model not found for role ${role}: ${assigned.provider}/${assigned.model}` : "no model selected");
+      name = `${model.provider}/${model.id}`;
+      const key = name + ":" + (assigned?.thinking ?? "off");
+      if (tried.has(key)) continue;
+      tried.add(key);
+      const thinking: ThinkingLevel | undefined = assigned?.thinking;
+      const reasoning = thinking && thinking !== "off" ? thinking : undefined;
+      const result = await ctx.modelRegistry.streamSimple(model,
+        { systemPrompt, messages: [{ role: "user", content: prompt, timestamp: Date.now() }] },
+        { ...(reasoning ? { reasoning } : {}), ...(signal ? { signal } : {}) }).result();
+      const cost = result.usage?.cost?.total;
+      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() });
+      signal?.throwIfAborted();
+      aborted = result.stopReason === "aborted";
+      if (result.stopReason === "error" || aborted) throw new Error(result.errorMessage || `${name} ${result.stopReason}`);
+      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 };
+    } catch (error) {
+      signal?.throwIfAborted();
+      if (aborted || (error instanceof Error && error.name === "AbortError") || !fallbacks.length) throw error;
+      failures.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  text = text.trim();
-  if (!text) throw new Error(`${name} returned an empty answer`);
-  return { text, model: name };
+  throw new Error(`All models for role ${role} failed:\n${failures.join("\n")}`);
 }

package/src/split-view.ts

@@ -1,4 +1,5 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { RowCache } from "./row-cache.ts";
 
 export interface SplitTheme { fg(color: string, text: string): string }
 
@@ -15,9 +16,14 @@ export interface SplitLayout {
   footerTop: number;
 }
 
-const pad = (text: string, width: number) => {
-  const value = truncateToWidth(text, Math.max(0, width));
-  return value + " ".repeat(Math.max(0, width - visibleWidth(value)));
+/** Padded pane rows: scrolling or one live row re-pads only what changed. */
+const padded = { left: new RowCache(), right: new RowCache(), footer: new RowCache() };
+
+/** The last frame: overlays repaint on every Pi render (including each streamed token) with unchanged rows. */
+let previous: { key: string; left: string[]; right: string[]; footer: string[]; lines: string[]; layout: SplitLayout } | undefined;
+const sameRows = (a: readonly string[], b: readonly string[], rows: number) => {
+  for (let row = 0; row < rows; row++) if ((a[row] ?? "") !== (b[row] ?? "")) return false;
+  return true;
 };
 
 /** Sidebar width for a split view, or 0 when the terminal is too narrow for two panes. */
@@ -34,25 +40,36 @@ export function splitFrame(theme: SplitTheme, width: number, title: string, left
   footer: readonly string[], rows: number, leftWidth = sidebarWidth(width)): { lines: string[]; layout: SplitLayout } {
   const w = Math.max(12, width);
   const dim = (text: string) => theme.fg("dim", text);
-  const heading = " " + title + " ";
-  const top = theme.fg("accent", "╭─" + truncateToWidth(heading, Math.max(0, w - 6)) + "─".repeat(Math.max(0, w - 4 - visibleWidth(truncateToWidth(heading, Math.max(0, w - 6))))) + "×╮");
+  const key = `${w}\0${title}\0${rows}\0${leftWidth}\0${dim("│")}${theme.fg("accent", "╭")}`;
+  if (previous?.key === key && footer.length === previous.footer.length && sameRows(footer, previous.footer, footer.length)
+    && sameRows(left, previous.left, rows) && sameRows(right, previous.right, rows)) {
+    return { lines: previous.lines.slice(), layout: { ...previous.layout } };
+  }
+  const heading = truncateToWidth(" " + title + " ", Math.max(0, w - 6));
+  const top = theme.fg("accent", "╭─" + heading + "─".repeat(Math.max(0, w - 4 - visibleWidth(heading))) + "×╮");
   const lines = [top];
   const split = leftWidth > 0;
   const bodyWidth = split ? w - leftWidth - 6 : w - 4;
+  padded.left.begin(String(leftWidth));
+  padded.right.begin(String(bodyWidth));
+  padded.footer.begin(String(w - 4));
+  // truncateToWidth pads in the pass that measures, so each new row is scanned once.
+  const pad = (cache: RowCache, text: string, cells: number) => cache.get(text, (value) => truncateToWidth(value, Math.max(0, cells), "...", true));
   for (let row = 0; row < rows; row++) {
-    const body = pad(right[row] ?? "", bodyWidth);
+    const body = pad(padded.right, right[row] ?? "", bodyWidth);
     lines.push(split
-      ? dim("│ ") + pad(left[row] ?? "", leftWidth) + dim("│ ") + body + dim(" │")
+      ? dim("│ ") + pad(padded.left, left[row] ?? "", leftWidth) + dim("│ ") + body + dim(" │")
       : dim("│ ") + body + dim(" │"));
   }
   lines.push(dim("├" + (split ? "─".repeat(leftWidth + 1) + "┴" + "─".repeat(Math.max(0, w - leftWidth - 4)) : "─".repeat(w - 2)) + "┤"));
   const footerTop = lines.length;
-  for (const line of footer) lines.push(dim("│ ") + pad(line, w - 4) + dim(" │"));
+  for (const line of footer) lines.push(dim("│ ") + pad(padded.footer, line, w - 4) + dim(" │"));
   lines.push(dim("╰" + "─".repeat(w - 2) + "╯"));
-  return {
-    lines: lines.map((line) => truncateToWidth(line, w)),
-    layout: { top: 1, rows, leftWidth: split ? leftWidth : 0, bodyX: split ? leftWidth + 4 : 2, footerTop }
-  };
+  // Every row is assembled from exact-width parts; only a sidebar too wide for the frame can overflow.
+  const fitted = bodyWidth < 0 ? lines.map((line) => truncateToWidth(line, w)) : lines;
+  const layout = { top: 1, rows, leftWidth: split ? leftWidth : 0, bodyX: split ? leftWidth + 4 : 2, footerTop };
+  previous = { key, left: left.slice(0, rows), right: right.slice(0, rows), footer: footer.slice(), lines: fitted, layout };
+  return { lines: fitted.slice(), layout: { ...layout } };
 }
 
 /** Available content rows for a full-height overlay with `chrome` fixed rows. */

package/src/status.ts

@@ -62,6 +62,8 @@ export function collectStatuses(statuses: ReadonlyMap<string, string>, now: numb
     const key = cleanText(rawKey, 48);
     if (!key || typeof rawValue !== "string") continue;
     if (rawKey.startsWith("pi-jar.quota.")) continue;
+    // SoL-Pi already announces each saving in its own notification; reprinting it here duplicates it.
+    if (rawKey.startsWith("sol-pi")) continue;
     if (!rawKey.startsWith(ROLE_PREFIX)) {
       const value = cleanText(rawValue);
       // pi-jar's own indicators (such as `role:default`) are already self-describing.

package/src/task-tool.ts

@@ -1,53 +1,78 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import type { Todo } from "./tasks.ts";
-import { TODO_STATUSES, TodoStore, todoMark } from "./tasks.ts";
+import type { Todo, TodoInput, TodoStatus } from "./tasks.ts";
+import { TODO_STATUSES, TodoStore, todoMark, todoProgress, todoTotals } from "./tasks.ts";
 
-const ACTIONS = ["write", "list", "add", "start", "done", "open", "edit", "delete"] as const;
-const Action = Type.Unsafe<(typeof ACTIONS)[number]>({ type: "string", enum: ACTIONS as any });
-const Status = Type.Unsafe<(typeof TODO_STATUSES)[number]>({ type: "string", enum: TODO_STATUSES as any });
+const ACTIONS = ["write", "list", "append", "remove", "replace", "add", "start", "done", "open", "edit", "delete"] as const;
+const Action = Type.Unsafe<(typeof ACTIONS)[number]>({ type: "string", enum: [...ACTIONS] });
+const Status = Type.Unsafe<(typeof TODO_STATUSES)[number]>({ type: "string", enum: [...TODO_STATUSES] });
+const Content = Type.String({ description: "Imperative task title, e.g. \"Run the tests\"." });
+const ActiveForm = Type.Optional(Type.String({ description: "Present-continuous form shown while it runs, e.g. \"Running the tests\"." }));
 
 const Parameters = Type.Object({
   todos: Type.Optional(Type.Array(Type.Object({
-    content: Type.String({ description: "Imperative task title, e.g. \"Run the tests\"." }),
+    id: Type.Optional(Type.String({ description: "Existing stable task id for legacy write; omitted ids match by title." })),
+    content: Content,
     status: Status,
-    activeForm: Type.Optional(Type.String({ description: "Present-continuous form shown while it runs, e.g. \"Running the tests\"." }))
-  }), { description: "The complete, updated task list. Replaces the current list." })),
+    activeForm: ActiveForm,
+    subtasks: Type.Optional(Type.Array(Type.Object({ id: Type.Optional(Type.String()), content: Content, status: Status, activeForm: ActiveForm }), {
+      description: "Optional steps of this task (one level deep). The task's status then follows its subtasks."
+    }))
+  }), { description: "For append: new tasks only. For replace: exactly one replacement task. With write (or no action): the complete list, replacing it." })),
   action: Type.Optional(Action),
-  id: Type.Optional(Type.String({ description: "Task id for start/done/open/edit/delete." })),
-  title: Type.Optional(Type.String({ description: "Concise actionable task title for add/edit." })),
+  id: Type.Optional(Type.String({ description: "Stable task id for replace/remove/start/done/open/edit/delete. On a parent, start runs its first open subtask; done/open apply to all its subtasks." })),
+  title: Type.Optional(Type.String({ description: "Task title for append/add/edit/replace." })),
+  status: Type.Optional(Status),
+  activeForm: ActiveForm,
+  parent: Type.Optional(Type.String({ description: "For append/add: id of a top-level task to add the new task under as a subtask." })),
   details: Type.Optional(Type.String({ description: "Optional short task context for a new task." }))
 });
 
 interface TaskToolDetails {
   action: string;
-  /** Bounded preview only; the canonical list lives in TodoStore. */
+  /** Bounded preview (the full list in a subagent); the canonical list lives in TodoStore. */
   items: Todo[];
+  /** Leaf tasks: subtasks plus top-level tasks without subtasks. */
   total: number;
   done: number;
+  /** Every item, parents included. */
+  count?: number;
   current?: string;
   changed?: string;
+  /** Full stable id index, including items outside the bounded preview. */
+  ids?: { id: string; title: string; parentId?: string }[];
   truncated?: boolean;
+  /** Subtask counts of previewed parents when the preview cuts the list. */
+  progress?: { id: string; done: number; total: number }[];
 }
 
+type TodoParam = { id?: string; content: string; status: TodoStatus; activeForm?: string; subtasks?: readonly TodoParam[] };
+/** Deeper nesting is passed through so the store rejects it with a clear message. */
+const toInput = (item: TodoParam): TodoInput => ({
+  ...(item.id !== undefined ? { id: item.id } : {}),
+  title: item.content, status: item.status,
+  ...(item.activeForm !== undefined ? { activeForm: item.activeForm } : {}),
+  ...(item.subtasks !== undefined ? { subtasks: item.subtasks.map(toInput) } : {})
+});
+
 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 parents = new Set<string>();
+  for (const item of items) if (item.parentId) parents.add(item.parentId);
+  const current = items.find((item) => item.status === "in_progress" && !parents.has(item.id));
+  const parent = current?.parentId ? items.find((item) => item.id === current.parentId) : undefined;
+  return { ...todoTotals(items), current: current && (parent ? parent.title + " › " : "") + current.title };
 };
 const summary = (items: readonly Todo[]) => {
   const value = stats(items);
-  return `${value.done}/${value.total} done` + (value.current ? ` · now: ${value.current.title}` : "");
+  return `${value.done}/${value.total} done` + (value.current ? ` · now: ${value.current}` : "");
 };
 
-const lines = (items: readonly Todo[]) => items.length
-  ? items.map((item) => `${todoMark(item)} [${item.status}] ${item.title} (${item.id})`).join("\n")
-  : "No tracked tasks.";
+const line = (items: readonly Todo[], item: Todo) => {
+  const progress = todoProgress(items, item.id);
+  return `${item.parentId ? "  " : ""}${todoMark(item)} [${item.status}] ${item.title}${progress.total ? ` (${progress.done}/${progress.total} done)` : ""} (${item.id})`;
+};
+const lines = (items: readonly Todo[]) => items.length ? items.map((item) => line(items, item)).join("\n") : "No tracked tasks.";
 
 const REMINDER = "Keep using jar_todo to track progress: mark the next task in_progress before starting it and completed as soon as it is verified.";
 
@@ -60,74 +85,129 @@ export function registerTaskTool(
   pi.registerTool({
     name: "jar_todo",
     label: "tasks",
-    description: "Maintain pi-jar's session task list, shown live to the user. Send `todos` with the complete updated list (each with content, status pending|in_progress|completed, and activeForm). Single-task actions (start, done, open, add, edit, delete, list) are also available.",
-    promptSnippet: "Track multi-step work with jar_todo: write the full list, keep exactly one task in_progress, complete tasks as they finish.",
+    description: "Maintain session tasks incrementally: append adds todos (or title), remove deletes id and its subtasks, replace updates only id using title/status/activeForm or exactly one todos item. Omitted replacement fields/subtasks are preserved. append with parent adds subtasks. Stable IDs are returned for every task. Legacy write (or todos without action) replaces the entire list. add/delete and start/done/open/edit/list remain supported.",
+    promptSnippet: "Track multi-step work with jar_todo: append new tasks, replace/remove by stable id, keep one leaf in_progress, complete tasks as they finish.",
     promptGuidelines: [
       "Use jar_todo proactively, without waiting for the user, for any task with three or more distinct steps, when the user gives several tasks, or right after receiving new instructions. Skip it for single trivial requests and pure questions.",
-      "Prefer jar_todo with `todos` (the full updated list). Each item has `content` (imperative, e.g. \"Run tests\"), `status`, and `activeForm` (present continuous, e.g. \"Running tests\"), which the user sees while it runs.",
-      "Keep exactly one task in_progress at a time. Mark a task in_progress before you start it and completed immediately after it is verified; do not batch completions.",
+      "Prefer incremental actions: append with todos adds only new tasks; replace with id updates only that task; remove with id deletes only that task tree. Use the returned stable IDs. write with todos is legacy full-list replacement and removes omitted tasks. Each todos item has content, status, and optional activeForm/subtasks.",
+      "Break a large task into `subtasks` (same shape, one level deep). A parent's status follows its subtasks: it is completed when all of them are. Progress counts leaf tasks (subtasks and tasks without subtasks).",
+      "Keep exactly one leaf task in_progress at a time. Mark a task in_progress before you start it and completed immediately after it is verified; do not batch completions.",
       "Only mark a task completed when it is fully done. If tests fail, work is partial or you are blocked, keep it in_progress and add a task for what must be resolved. Remove tasks that are no longer relevant."
     ],
     parameters: Parameters,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const current = store();
-      const action = params.todos ? "write" : params.action ?? "list";
+      const action = params.action ?? (params.todos !== undefined ? "write" : "list");
       if (!current) {
         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;
-      switch (action) {
+      let inputs: TodoInput[] | undefined;
+      if (params.todos !== undefined) {
+        try {
+          if (!Array.isArray(params.todos)) throw new Error();
+          inputs = params.todos.map(toInput);
+        } catch { error = "todos must be an array of task objects with array subtasks."; }
+        if (!["write", "append", "replace"].includes(action)) error = "todos may only be used with write, append, or replace; no tasks were changed.";
+      }
+      if (!error) switch (action) {
         case "list":
           break;
         case "write":
-          if (!params.todos) { error = "write needs `todos`: the complete updated list."; break; }
-          error = current.write(params.todos.map((item) => ({ title: item.content, status: item.status, ...(item.activeForm ? { activeForm: item.activeForm } : {}) })));
+          if (!inputs) { error = "write needs `todos`: the complete updated list."; break; }
+          error = current.write(inputs);
+          break;
+        case "append": {
+          const before = new Set(current.all().map((item) => item.id));
+          if (inputs && params.title !== undefined) { error = "append accepts either todos or title, not both."; break; }
+          error = current.appendTodos(inputs ?? [{ title: params.title ?? "", status: params.status ?? "pending", activeForm: params.activeForm, details: params.details }], params.parent);
+          if (!error) changedId = current.all().find((item) => !before.has(item.id))?.id;
           break;
+        }
+        case "replace": {
+          if (!params.id) { error = "replace needs a valid existing task id."; break; }
+          if (inputs && (inputs.length !== 1 || params.title !== undefined || params.status !== undefined || params.activeForm !== undefined)) { error = "replace accepts exactly one todos item OR title/status/activeForm fields."; break; }
+          const replacement = inputs?.[0] ?? {
+            ...(params.title !== undefined ? { title: params.title } : {}),
+            ...(params.status !== undefined ? { status: params.status } : {}),
+            ...(params.activeForm !== undefined ? { activeForm: params.activeForm } : {})
+          };
+          error = current.replace(params.id, replacement);
+          if (!error) changedId = params.id;
+          break;
+        }
         case "add": {
-          const item = params.title?.trim() ? current.add(params.title, params.details) : undefined;
-          if (!item) error = "add needs a short title.";
+          const parent = params.parent?.trim() || undefined;
+          const title = params.title ?? "";
+          error = current.addError(title, parent);
+          const item = error ? undefined : current.add(title, params.details, parent);
+          if (!error && !item) error = "Could not save the task.";
           changedId = item?.id;
           break;
         }
         case "start":
         case "done":
-        case "open":
-          if (!params.id || !current.setStatus(params.id, action === "start" ? "in_progress" : action === "done" ? "completed" : "pending")) error = `${action} needs a valid id from jar_todo list.`;
-          else changedId = params.id;
+        case "open": {
+          const item = params.id ? current.get(params.id) : undefined;
+          const progress = item ? todoProgress(current.all(), item.id) : { done: 0, total: 0 };
+          if (!item) error = `${action} needs a valid id from jar_todo list.`;
+          else if (action === "start" && progress.total && progress.done === progress.total) error = `every subtask of ${item.id} is completed; open it or add a subtask first.`;
+          else if (!current.setStatus(item.id, action === "start" ? "in_progress" : action === "done" ? "completed" : "pending")) error = "Could not save the task.";
+          else changedId = item.id;
           break;
+        }
         case "edit":
           if (!params.id || !params.title?.trim() || !current.edit(params.id, params.title)) error = "edit needs a valid id and a title.";
           else changedId = params.id;
           break;
+        case "remove":
         case "delete":
-          if (!params.id || !current.delete(params.id)) error = "delete needs a valid id from jar_todo list.";
+          if (!params.id || !current.delete(params.id)) error = `${action} needs a valid id from jar_todo list.`;
           else changedId = params.id;
           break;
+        default: error = "Unknown task action; no tasks were changed.";
       }
       if (action !== "list" && !error) changed(ctx);
       const items = current.all();
       const state = stats(items);
+      // The changed task in context: its whole parent group, subtasks indented.
       const changedItem = changedId ? items.find((item) => item.id === changedId) : undefined;
+      const root = changedItem?.parentId ?? changedItem?.id;
+      const group = root ? items.filter((item) => item.id === root || item.parentId === root) : [];
+      const mutationItems = action === "write" || action === "append" ? items : group;
+      const mutationPreview = mutationItems.slice(0, 8);
+      // Keep task prose bounded while still returning every addressable id in canonical order.
+      const idIndex = mutationItems.length > 8
+        ? "\nTask IDs (list order): " + items.map((item, index) => `${index + 1}=${item.id}`).join(", ") + "\nUse list for all task titles."
+        : "";
       const message = error
         ? `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);
+          : `Task list updated (${summary(items)}).${mutationPreview.length ? "\n" + mutationPreview.map((item) => line(items, item)).join("\n") : ""}${idIndex}\n${REMINDER}`;
+      // A subagent's parent mirrors the checklist from these details, so children send it whole.
+      const preview = process.env.PI_JAR_CHILD ? items : items.slice(0, 8);
+      const truncated = preview.length < items.length;
+      const progress = truncated ? preview.flatMap((item) => {
+        const value = todoProgress(items, item.id);
+        return value.total ? [{ id: item.id, ...value }] : [];
+      }) : [];
       return {
         content: [{ type: "text", text: message }],
         details: {
-          action, items: preview, total: state.total, done: state.done,
-          ...(state.current ? { current: state.current.title } : {}),
-          ...(preview.length < items.length ? { truncated: true } : {}),
+          action, items: preview, total: state.total, done: state.done, count: items.length,
+          ids: items.map(({ id, title, parentId }) => ({ id, title, ...(parentId ? { parentId } : {}) })),
+          ...(state.current ? { current: state.current } : {}),
+          ...(truncated ? { truncated: true } : {}),
+          ...(progress.length ? { progress } : {}),
           ...(changedId ? { changed: changedId } : {})
         } satisfies TaskToolDetails
       };
     },
     renderCall(args, theme) {
       let text = theme.fg("toolTitle", theme.bold("tasks"));
-      if (args.todos) text += " " + theme.fg("accent", `update · ${args.todos.length} item${args.todos.length === 1 ? "" : "s"}`);
+      if (args.todos) text += " " + theme.fg("accent", `${args.action ?? "write"} · ${args.todos.length} item${args.todos.length === 1 ? "" : "s"}`);
       else {
         text += " " + theme.fg("accent", args.action ?? "list");
         if (args.title) text += " " + theme.fg("muted", args.title);
@@ -138,22 +218,29 @@ 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 ?? [];
-      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);
+      // Older results predate `count`, when `total` counted every item.
+      const count = details?.count ?? details?.total ?? items.length;
+      const totals = details?.total === undefined ? todoTotals(items) : { done: details.done, total: details.total };
+      if (!count) return new Text(theme.fg("dim", "No tracked tasks."), 0, 0);
+      const known = new Map((details?.progress ?? []).map((value) => [value.id, value]));
       const shown = expanded ? items : items.slice(0, 8);
-      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 (details?.truncated || shown.length < total) text += "\n" + theme.fg("dim", `  … +${Math.max(0, total - shown.length)} more · /jar tasks`);
+      let text = theme.fg("dim", `${totals.done}/${totals.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), known.get(item.id) ?? todoProgress(items, item.id));
+      if (details?.truncated || shown.length < count) text += "\n" + theme.fg("dim", `  … +${Math.max(0, count - shown.length)} more · /jar tasks`);
       return new Text(text, 0, 0);
     }
   });
 }
 
 type TodoColor = "accent" | "muted" | "dim" | "success";
-/** One checklist row: completed rows are struck through, the running one is bold. */
-export function todoRow(item: Todo, fg: (color: TodoColor, text: string) => string, bold: (text: string) => string = (text) => text): string {
-  if (item.status === "completed") return fg("success", "  ✔ ") + fg("dim", "\x1b[9m" + item.title + "\x1b[29m");
-  if (item.status === "in_progress") return fg("accent", "  ◼ ") + fg("accent", bold(item.title));
-  return fg("muted", "  ☐ " + item.title);
+/**
+ * One checklist row: completed rows are struck through, the running one is bold. Subtasks are
+ * indented; pass a parent's subtask `progress` to show its `(done/total)`.
+ */
+export function todoRow(item: Todo, fg: (color: TodoColor, text: string) => string, bold: (text: string) => string = (text) => text, progress?: { done: number; total: number }): string {
+  const indent = item.parentId ? "    " : "  ";
+  const suffix = progress?.total ? fg("dim", ` (${progress.done}/${progress.total})`) : "";
+  if (item.status === "completed") return fg("success", indent + "✔ ") + fg("dim", "\x1b[9m" + item.title + "\x1b[29m") + suffix;
+  if (item.status === "in_progress") return fg("accent", indent + "◼ ") + fg("accent", bold(item.title)) + suffix;
+  return fg("muted", indent + "☐ " + item.title) + suffix;
 }

package/src/tasks-ui.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { promptChoice, promptText, todoView, type TodoFilter } from "./dialogs.ts";
-import { TodoStore } from "./tasks.ts";
+import { TodoStore, todoProgress } from "./tasks.ts";
 
 const help = "Usage: /jar tasks [list|add TITLE|done ID|open ID|edit ID TITLE|delete ID]";
 
@@ -11,7 +11,15 @@ export async function manageTasks(args: string, ctx: ExtensionContext, store: To
   };
   const list = () => {
     const items = store.all();
-    notify(items.length ? items.map((item) => `${item.done ? "[x]" : "[ ]"} ${item.title} (${item.id})`).join("\n") : "pi-jar to-do: empty (separate from other task managers)");
+    notify(items.length ? items.map((item) => {
+      const progress = todoProgress(items, item.id);
+      return `${item.parentId ? "  " : ""}${item.done ? "[x]" : "[ ]"} ${item.title}${progress.total ? ` (${progress.done}/${progress.total})` : ""} (${item.id})`;
+    }).join("\n") : "pi-jar to-do: empty (separate from other task managers)");
+  };
+  /** Deleting a parent also deletes its subtasks, so say so before confirming. */
+  const deleteLabel = (id: string, title: string) => {
+    const count = todoProgress(store.all(), id).total;
+    return count ? `${title} (and ${count} subtask${count === 1 ? "" : "s"})` : title;
   };
   if (!args && ctx.hasUI && ctx.mode === "tui") {
     const filter: { value: TodoFilter } = { value: "all" };
@@ -29,7 +37,7 @@ export async function manageTasks(args: string, ctx: ExtensionContext, store: To
         if (title) success = store.edit(action.id, title);
       } else if (action.id && action.kind === "delete") {
         const item = store.get(action.id);
-        const choice = item && await promptChoice(ctx, "Delete to-do?", item.title, ["Delete item", "Keep item"], 1);
+        const choice = item && await promptChoice(ctx, "Delete to-do?", deleteLabel(item.id, item.title), ["Delete item", "Keep item"], 1);
         if (choice === 0) success = store.delete(action.id);
       }
       if (success) changed();
@@ -47,8 +55,10 @@ export async function manageTasks(args: string, ctx: ExtensionContext, store: To
     }
     case "done":
     case "open": {
+      // On a parent, done completes and open reopens every subtask.
       const item = id && store.get(id);
-      if (item && item.done !== (verb === "done") && store.toggle(id)) { changed(); notify("Updated pi-jar to-do"); }
+      const already = item && (verb === "done" ? item.done : item.status === "pending");
+      if (item && !already && store.setStatus(id, verb === "done" ? "completed" : "pending")) { changed(); notify("Updated pi-jar to-do"); }
       else notify("To-do not found or already in that state", "error");
       return;
     }
@@ -61,7 +71,7 @@ export async function manageTasks(args: string, ctx: ExtensionContext, store: To
     case "delete": {
       if (!id || !store.get(id)) { notify("To-do not found", "error"); return; }
       if (ctx.hasUI && ctx.mode === "tui") {
-        const choice = await promptChoice(ctx, "Delete pi-jar to-do?", store.get(id)!.title, ["Delete item", "Keep item"], 1);
+        const choice = await promptChoice(ctx, "Delete pi-jar to-do?", deleteLabel(id, store.get(id)!.title), ["Delete item", "Keep item"], 1);
         if (choice !== 0) return;
       }
       // Headless deletion is explicit and requires the full ID; TUI deletion asks for confirmation.