@astralyn/pi 0.84.3 → 0.84.4

package/dist/extensions/todo/view.js

@@ -1,209 +1,283 @@
-import { truncateToWidth } from "@earendil-works/pi-tui";
-import { LIST_DISPLAY_MAX_ITEMS, TODO_MAX_BATCH_ITEMS, TODO_MAX_BLOCKED_BY } from "./constants.js";
+/**
+ * todo/view.ts — v2 presentation: the one-line above-editor widget renderer,
+ * tool call/group renderers, the /todos list formatter, and model-facing
+ * result text. Wire input (args, details, snapshots) is read defensively and
+ * bounded so partial or hostile input cannot grow output without limit.
+ */
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { TODO_MAX_BATCH_ITEMS, TODO_MAX_DESCRIPTION_LENGTH, TODO_MAX_ITEMS, TODO_MAX_SUBJECT_LENGTH, } from "./constants.js";
 import { TODO_DETAILS_SCHEMA_VERSION, } from "./schema.js";
-import { unresolvedDependencyIds } from "./state.js";
 export const STATUS_MARK = {
     pending: "[ ]",
     in_progress: "[>]",
     completed: "[x]",
-    deleted: "[-]",
 };
-export const STATUS_COLOR = {
+const STATUS_COLOR = {
     pending: "dim",
     in_progress: "warning",
     completed: "success",
-    deleted: "muted",
 };
-const OVERLAY_BODY_MAX_ITEMS = 10;
-function visibleTodos(state) {
-    return state.items.filter((item) => item.status !== "deleted");
-}
-export function hasVisibleOverlayItems(state, hiddenCompleted) {
-    return visibleTodos(state).some((item) => item.status !== "completed" || !hiddenCompleted.has(item.id));
-}
-function todoCounts(items) {
-    const counts = { total: items.length, pending: 0, inProgress: 0, completed: 0 };
-    for (const item of items) {
-        if (item.status === "pending")
+const STATUS_RANK = {
+    in_progress: 0,
+    pending: 1,
+    completed: 2,
+};
+// --- One-line widget --------------------------------------------------------
+const WIDGET_HEADER_SEPARATOR = " · ";
+const WIDGET_ITEM_SEPARATOR = "  ";
+/** True while any open task exists; the widget is registered only in that case. */
+export function hasOpenTodos(state) {
+    return state.items.some((item) => item.status === "pending" || item.status === "in_progress");
+}
+/** Status counts across the whole list. */
+function widgetCounts(state) {
+    const counts = { active: 0, pending: 0, completed: 0 };
+    for (const item of state.items) {
+        if (item.status === "in_progress")
+            counts.active++;
+        else if (item.status === "pending")
             counts.pending++;
-        else if (item.status === "in_progress")
-            counts.inProgress++;
-        else if (item.status === "completed")
+        else
             counts.completed++;
     }
     return counts;
 }
-export function renderOverlayLines(state, theme, width, hiddenCompleted) {
-    const allVisible = visibleTodos(state);
-    const visible = allVisible.filter((item) => item.status !== "completed" || !hiddenCompleted.has(item.id));
-    if (!visible.length)
+function widgetSegment(item, subject, theme) {
+    return `${theme.fg(STATUS_COLOR[item.status], STATUS_MARK[item.status])} ${theme.fg("accent", `#${item.id}`)} ${theme.fg("text", subject)}`;
+}
+function widgetLine(header, segments, overflow) {
+    const body = [...segments, ...(overflow ? [overflow] : [])].join(WIDGET_ITEM_SEPARATOR);
+    return body ? `${header}${WIDGET_HEADER_SEPARATOR}${body}` : header;
+}
+/** Long overflow with counts (zero parts omitted), e.g. `+4 more (4 completed)`. */
+function widgetOverflowLong(remaining, counts) {
+    const parts = [
+        counts.active > 0 ? `${counts.active} active` : "",
+        counts.pending > 0 ? `${counts.pending} pending` : "",
+        counts.completed > 0 ? `${counts.completed} completed` : "",
+    ].filter(Boolean);
+    return `+${remaining} more${parts.length ? ` (${parts.join(", ")})` : ""}`;
+}
+/** One-line widget: `Todos 2/6 · [>] #4 s  [ ] #5 s  +N more (…)`; completed tasks are hidden but counted in the overflow. */
+export function renderWidgetLine(state, theme, width) {
+    const safeWidth = Math.max(1, width);
+    const items = state.items;
+    const candidates = items
+        .filter((item) => item.status !== "completed")
+        .sort((first, second) => STATUS_RANK[first.status] - STATUS_RANK[second.status] || first.id - second.id);
+    if (candidates.length === 0)
         return [];
-    const counts = todoCounts(allVisible);
-    const hasActive = visible.some((item) => item.status === "pending" || item.status === "in_progress");
-    const heading = `${theme.fg(hasActive ? "accent" : "dim", "Todos")} ${theme.fg("dim", `(${counts.completed}/${counts.total})`)}`;
-    const lines = [truncateToWidth(heading, width, "...")];
-    const showIds = visible.some((item) => item.blockedBy?.length);
-    const body = chooseOverlayItems(visible, state, OVERLAY_BODY_MAX_ITEMS);
-    for (const item of body.items) {
-        lines.push(truncateToWidth(`  ${formatOverlayItem(item, state, theme, showIds)}`, width, "..."));
-    }
-    if (body.hidden.length > 0) {
-        lines.push(truncateToWidth(theme.fg("dim", `  ${formatHiddenSummary(body.hidden)}`), width, "..."));
+    const total = items.length;
+    const completed = items.filter((item) => item.status === "completed").length;
+    const header = `${theme.fg("accent", "Todos")} ${theme.fg("dim", `${completed}/${total}`)}`;
+    const counts = widgetCounts(state);
+    const shown = [];
+    let overflow = "";
+    // Best overflow for a trial segment set: the long counts form when it fits,
+    // the short `+N more` form otherwise, undefined when even that overflows.
+    const bestOverflow = (trial) => {
+        const remaining = total - trial.length;
+        const segments = trial.map((entry) => widgetSegment(entry.item, entry.subject, theme));
+        const activeShown = trial.some((entry) => entry.item.status === "in_progress") ? 1 : 0;
+        const hidden = {
+            active: counts.active - activeShown,
+            pending: counts.pending - (trial.length - activeShown),
+            completed: counts.completed,
+        };
+        if (remaining <= 0)
+            return visibleWidth(widgetLine(header, segments, "")) <= safeWidth ? "" : undefined;
+        const long = theme.fg("dim", widgetOverflowLong(remaining, hidden));
+        if (visibleWidth(widgetLine(header, segments, long)) <= safeWidth)
+            return long;
+        const short = theme.fg("dim", `+${remaining} more`);
+        return visibleWidth(widgetLine(header, segments, short)) <= safeWidth ? short : undefined;
+    };
+    // Extreme narrow widths: the best summary that fits, then the bare header.
+    const fallback = () => {
+        const best = bestOverflow([]);
+        if (best !== undefined)
+            return [widgetLine(header, [], best)];
+        if (visibleWidth(header) <= safeWidth)
+            return [header];
+        return [truncateToWidth(header, safeWidth, "…")];
+    };
+    // Segments are added whole, active first then pending by id, while the
+    // line keeps fitting; only the active subject may be truncated.
+    for (const candidate of candidates) {
+        const best = bestOverflow([...shown, { item: candidate, subject: candidate.subject }]);
+        if (best !== undefined) {
+            shown.push({ item: candidate, subject: candidate.subject });
+            overflow = best;
+            continue;
+        }
+        if (candidate.status !== "in_progress")
+            break;
+        const remaining = total - shown.length - 1;
+        const suffix = remaining > 0 ? `${WIDGET_ITEM_SEPARATOR}+${remaining} more` : "";
+        const prefix = `${header}${WIDGET_HEADER_SEPARATOR}${widgetSegment(candidate, "", theme)}${suffix}`;
+        const available = safeWidth - visibleWidth(prefix);
+        if (available < 1)
+            return fallback();
+        shown.push({ item: candidate, subject: truncateToWidth(candidate.subject, available, "…") });
+        overflow = bestOverflow(shown) ?? "";
+    }
+    if (shown.length === 0)
+        return fallback();
+    const segments = shown.map((entry) => widgetSegment(entry.item, entry.subject, theme));
+    const line = widgetLine(header, segments, overflow);
+    // Safety net: the visible width always stays within the terminal width.
+    return [visibleWidth(line) <= safeWidth ? line : truncateToWidth(line, safeWidth, "…")];
+}
+// --- Full list (used by /todos and the model-facing list result) ------------
+/** `Todos: X in progress, Y pending, Z completed` header plus two-line tasks. */
+function formatTodoList(state) {
+    if (state.items.length === 0)
+        return "No todos.";
+    const counts = widgetCounts(state);
+    const lines = [`Todos: ${counts.active} in progress, ${counts.pending} pending, ${counts.completed} completed`];
+    const items = [...state.items].sort((first, second) => STATUS_RANK[first.status] - STATUS_RANK[second.status] || first.id - second.id);
+    for (const item of items) {
+        lines.push(`${STATUS_MARK[item.status]} #${item.id} ${item.subject}`);
+        lines.push(`    ${item.description}`);
     }
-    lines.push("");
-    return lines;
-}
-function byIdAsc(first, second) {
-    return first.id - second.id;
-}
-function overlayPriority(state, item) {
-    if (item.status === "in_progress")
-        return 0;
-    if (item.status === "pending" && unresolvedDependencyIds(state, item).length === 0)
-        return 1;
-    if (item.status === "pending")
-        return 2;
-    return 3; // Completed items here are recent; older ones are hidden by TodoOverlay.
-}
-function chooseOverlayItems(items, state, maxBody) {
-    const prioritized = [...items].sort((first, second) => {
-        const priorityDelta = overlayPriority(state, first) - overlayPriority(state, second);
-        return priorityDelta || byIdAsc(first, second);
-    });
-    if (prioritized.length <= maxBody)
-        return { items: prioritized, hidden: [] };
-    const shown = prioritized.slice(0, Math.max(1, maxBody - 1));
-    return { items: shown, hidden: prioritized.slice(shown.length) };
-}
-function formatHiddenSummary(items) {
-    const counts = todoCounts(items);
-    const parts = [];
-    if (counts.inProgress)
-        parts.push(`${counts.inProgress} in progress`);
-    if (counts.pending)
-        parts.push(`${counts.pending} pending`);
-    if (counts.completed)
-        parts.push(`${counts.completed} completed`);
-    return `+${items.length} more${parts.length ? ` (${parts.join(", ")})` : ""}`;
+    return lines.join("\n");
 }
-function formatOverlayItem(item, state, theme, showId) {
-    let text = theme.fg(STATUS_COLOR[item.status], STATUS_MARK[item.status]);
-    if (showId)
-        text += ` ${theme.fg("accent", `#${item.id}`)}`;
-    const subject = item.status === "completed" ? theme.strikethrough(theme.fg("dim", item.subject)) : theme.fg("text", item.subject);
-    text += ` ${subject}`;
-    if (item.status === "in_progress" && item.activeForm)
-        text += ` ${theme.fg("dim", `(${item.activeForm})`)}`;
-    const unresolved = unresolvedDependencyIds(state, item);
-    if (unresolved.length) {
-        text += ` ${theme.fg("dim", `blocked by ${unresolved.map((id) => `#${id}`).join(",")}`)}`;
-        if (item.status === "pending" || item.status === "in_progress")
-            text += ` ${theme.fg("warning", "(deps incomplete)")}`;
+/** /todos command output: full list, subject line plus indented description per task. */
+export const formatCommandList = formatTodoList;
+/** Model-facing text for one completed todo call; bounded by list and input limits. */
+export function formatTodoContent(change, state) {
+    switch (change.kind) {
+        case "create": {
+            const parts = change.ids.map((id) => {
+                const item = state.items.find((entry) => entry.id === id);
+                return item ? `#${item.id}: ${item.subject}` : `#${id}`;
+            });
+            const noun = change.ids.length === 1 ? "task" : "tasks";
+            return `Created ${change.ids.length} ${noun}${parts.length ? `: ${parts.join("; ")}` : ""}`;
+        }
+        case "update": {
+            const item = state.items.find((entry) => entry.id === change.id);
+            const subject = item ? `: ${item.subject}` : "";
+            const transition = change.from === change.to ? "" : ` (${change.from} -> ${change.to})`;
+            const demoted = change.demotedId !== undefined ? `; demoted #${change.demotedId} to pending` : "";
+            return `Updated #${change.id}${transition}${subject}${demoted}`;
+        }
+        case "list":
+            return formatTodoList(state);
+        case "delete": {
+            const noun = change.removed.length === 1 ? "task" : "tasks";
+            const parts = change.removed.map((entry) => `#${entry.id}: ${entry.subject}`);
+            return `Deleted ${change.removed.length} ${noun}${parts.length ? `: ${parts.join("; ")}` : ""}`;
+        }
     }
-    return text;
-}
-const EDGE_PARAMS = ["blockedBy", "addBlockedBy", "removeBlockedBy", "addBlocks", "removeBlocks"];
-function callText(value) {
-    return typeof value === "string" ? value.trim() : "";
 }
-function callSubject(value) {
-    return callText(value).replace(/\s+/g, " ");
-}
-function callId(value) {
-    return typeof value === "number" && Number.isInteger(value) ? value : undefined;
-}
-function callIds(value) {
-    if (!Array.isArray(value))
-        return [];
-    const ids = [];
-    let count;
+const CALL_ITEMS_MAX = TODO_MAX_BATCH_ITEMS;
+const CALL_SUBJECT_PREVIEW_COUNT = 2;
+const CALL_SUBJECT_PREVIEW_WIDTH = 72;
+const CALL_DESCRIPTION_PREVIEW_LENGTH = 120;
+const GROUP_FAILURE_MAX_LENGTH = 120;
+const TODO_ACTIONS = new Set(["create", "update", "list", "delete"]);
+/** Record-like read; proxies that throw on inspection are treated as absent. */
+function safeRecord(value) {
     try {
-        count = Math.min(value.length, TODO_MAX_BLOCKED_BY);
+        return value !== null && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
     }
     catch {
-        return ids;
-    }
-    for (let index = 0; index < count; index++) {
-        let entry;
-        try {
-            entry = value[index];
-        }
-        catch {
-            continue;
-        }
-        if (typeof entry === "number" && Number.isSafeInteger(entry) && entry >= 1)
-            ids.push(entry);
+        return undefined;
     }
-    return ids;
 }
-function callArrayLength(value) {
+/** Field read that never throws, even for exotic objects with throwing getters. */
+function safeValue(record, key) {
     try {
-        return Array.isArray(value) ? value.length : undefined;
+        return record?.[key];
     }
     catch {
         return undefined;
     }
 }
-const CALL_BATCH_SUBJECT_PREVIEW_COUNT = 2;
-const CALL_SUBJECT_PREVIEW_WIDTH = 72;
-const CALL_DESCRIPTION_PREVIEW_LENGTH = 120;
-function callStrings(value) {
-    if (!Array.isArray(value))
-        return [];
-    const strings = [];
-    let count;
+function safeString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Trimmed, whitespace-collapsed, length-clipped text (empty when absent). */
+function clipText(value, max) {
+    return safeString(value)?.trim().replace(/\s+/g, " ").slice(0, max) ?? "";
+}
+const safeSubject = (value) => clipText(value, TODO_MAX_SUBJECT_LENGTH);
+const safeDescription = (value) => clipText(value, TODO_MAX_DESCRIPTION_LENGTH);
+function safeId(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+function safeStatus(value) {
+    const status = safeString(value);
+    if (status === "pending" || status === "in_progress" || status === "completed")
+        return status;
+    return undefined;
+}
+function readArray(value, limit = CALL_ITEMS_MAX) {
     try {
-        count = Math.min(value.length, TODO_MAX_BLOCKED_BY);
+        if (!Array.isArray(value))
+            return undefined;
+        const length = value.length;
+        const values = [];
+        for (let index = 0; index < Math.min(length, limit); index++) {
+            try {
+                values.push(value[index]);
+            }
+            catch {
+                values.push(undefined);
+            }
+        }
+        return { values, length };
     }
     catch {
-        return strings;
+        return undefined;
     }
-    for (let index = 0; index < count; index++) {
-        let entry;
-        try {
-            entry = value[index];
-        }
-        catch {
+}
+/** Id lists: lenient for delete args (invalid entries drop), strict for result changes (any invalid entry rejects). */
+function readIds(value, strict) {
+    const array = readArray(value);
+    if (strict && (!array || array.length === 0 || array.length > CALL_ITEMS_MAX))
+        return undefined;
+    if (!array)
+        return strict ? undefined : [];
+    const ids = [];
+    for (const entry of array.values) {
+        const id = safeId(entry);
+        if (id === undefined) {
+            if (strict)
+                return undefined;
             continue;
         }
-        const text = callText(entry);
-        if (text)
-            strings.push(text);
+        ids.push(id);
     }
-    return strings;
+    return ids;
 }
-function callBatchItems(value) {
-    if (!Array.isArray(value))
-        return [];
-    let count;
-    try {
-        count = Math.min(value.length, TODO_MAX_BATCH_ITEMS);
-    }
-    catch {
-        return [];
-    }
-    const items = [];
-    for (let index = 0; index < count; index++) {
-        let valueAtIndex;
-        try {
-            valueAtIndex = value[index];
-        }
-        catch {
-            valueAtIndex = undefined;
-        }
-        const item = safeRecord(valueAtIndex);
-        items.push({
-            subject: item ? callSubject(safeValue(item, "subject")) : "",
-            description: item ? callText(safeValue(item, "description")) : "",
-            blockedBy: item ? callIds(safeValue(item, "blockedBy")) : [],
-            blockedByKeys: item ? callStrings(safeValue(item, "blockedByKeys")) : [],
+/** Create args: sparse or invalid entries drop; the batch caps at the maximum. */
+function batchItems(value) {
+    const result = [];
+    for (const raw of readArray(value)?.values ?? []) {
+        const item = safeRecord(raw);
+        if (!item)
+            continue;
+        result.push({
+            subject: safeSubject(safeValue(item, "subject")),
+            description: safeDescription(safeValue(item, "description")),
         });
     }
-    return items;
+    return result;
+}
+function descriptionPreview(value) {
+    const text = value.replace(/\s+/g, " ");
+    return text.length > CALL_DESCRIPTION_PREVIEW_LENGTH
+        ? `${text.slice(0, CALL_DESCRIPTION_PREVIEW_LENGTH - 1)}…`
+        : text;
 }
+/** At most two subjects, each truncated to the preview width, plus `+N more`. */
 function formatSubjectPreview(subjects, total) {
     const shown = subjects
-        .slice(0, CALL_BATCH_SUBJECT_PREVIEW_COUNT)
+        .slice(0, CALL_SUBJECT_PREVIEW_COUNT)
         .filter(Boolean)
         .map((subject) => truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…"));
     if (!shown.length)
@@ -211,340 +285,214 @@ function formatSubjectPreview(subjects, total) {
     const hidden = Math.max(0, total - shown.length);
     return `${shown.join(", ")}${hidden ? `, +${hidden} more` : ""}`;
 }
-function callBatchSubjectPreview(items, total) {
-    return formatSubjectPreview(items.map((item) => item.subject), total);
-}
-function callDescriptionPreview(value) {
-    const text = value.replace(/\s+/g, " ");
-    return text.length > CALL_DESCRIPTION_PREVIEW_LENGTH
-        ? `${text.slice(0, CALL_DESCRIPTION_PREVIEW_LENGTH - 1)}…`
-        : text;
-}
-function callNonNegativeInteger(value) {
-    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
-}
-function isTodoStatus(value) {
-    return Object.hasOwn(STATUS_MARK, value);
-}
-function formatCallHeadline(args, theme) {
-    const action = callText(args?.action);
-    const displayAction = action === "create_many" ? "create" : action;
-    const parts = [theme.fg("toolTitle", theme.bold(displayAction ? `todo ${displayAction}` : "todo"))];
-    if (action === "create_many") {
-        const items = callBatchItems(args?.items);
-        const count = callArrayLength(args?.items);
-        if (count !== undefined) {
-            parts.push(theme.fg("dim", `${count} ${count === 1 ? "task" : "tasks"}`));
-            const preview = callBatchSubjectPreview(items, count);
-            if (preview) {
-                parts.push(theme.fg("dim", "·"));
-                parts.push(theme.fg("text", preview));
-            }
-        }
-    }
-    const id = callId(args?.id);
-    if (id !== undefined)
-        parts.push(theme.fg("accent", `#${id}`));
-    const status = callText(args?.status);
-    if (status && isTodoStatus(status))
-        parts.push(theme.fg(STATUS_COLOR[status], status));
-    const subject = callSubject(args?.subject);
-    if (subject)
-        parts.push(theme.fg("text", subject));
-    // Dependency-only updates would otherwise render as a bare `todo update #3`.
-    const hasEdgeChange = EDGE_PARAMS.some((key) => callIds(args?.[key]).length > 0);
-    if (!status && !subject && hasEdgeChange)
-        parts.push(theme.fg("dim", "dependencies"));
-    return parts.join(" ");
+/** v2 details guard shared by the call and group renderers. */
+function todoDetails(value) {
+    const details = safeRecord(value);
+    if (!details || safeValue(details, "schemaVersion") !== TODO_DETAILS_SCHEMA_VERSION)
+        return undefined;
+    const change = safeRecord(safeValue(details, "change"));
+    const state = safeRecord(safeValue(details, "state"));
+    if (!change || !state)
+        return undefined;
+    const kind = safeString(safeValue(change, "kind"));
+    if (!kind || !TODO_ACTIONS.has(kind))
+        return undefined;
+    return { change, state };
 }
-function batchResultIds(result, count) {
-    const details = groupDetails(result?.details);
-    if (!details || details.action !== "create_many")
+/** Result ids for an expanded create, only when they match the shown items. */
+function createResultIds(result, count) {
+    const details = todoDetails(result?.details);
+    if (!details || safeString(safeValue(details.change, "kind")) !== "create")
         return undefined;
-    const ids = groupIds(safeValue(details.operation, "ids"));
+    const ids = readIds(safeValue(details.change, "ids"), true);
     return ids?.length === count ? ids : undefined;
 }
-function formatCallDetails(args, theme, result) {
-    const lines = [];
-    const push = (label, value) => {
-        if (value)
-            lines.push(theme.fg("dim", `${label}: ${value}`));
-    };
-    const action = callText(args?.action);
-    if (action === "create_many") {
-        const items = callBatchItems(args?.items);
-        const ids = batchResultIds(result, items.length);
+/** Headline plus the parameters the result never echoes as detail lines. */
+function formatCallParts(args, theme, result) {
+    const action = clipText(args?.action, TODO_MAX_SUBJECT_LENGTH);
+    const verb = TODO_ACTIONS.has(action) ? action : undefined;
+    const headline = [theme.fg("toolTitle", theme.bold(verb ? `todo ${verb}` : "todo"))];
+    const details = [];
+    if (verb === "create") {
+        const items = batchItems(args?.items);
+        const rawCount = readArray(args?.items)?.length;
+        if (rawCount !== undefined) {
+            const count = Math.min(rawCount, CALL_ITEMS_MAX);
+            headline.push(theme.fg("dim", `${count} ${count === 1 ? "task" : "tasks"}`));
+            const subjects = items.map((item) => item.subject);
+            const preview = formatSubjectPreview(subjects, count);
+            if (preview)
+                headline.push(theme.fg("dim", "·"), theme.fg("text", preview));
+        }
+        const ids = createResultIds(result, items.length);
         for (const [index, item] of items.entries()) {
-            const dependencies = [...item.blockedBy.map((id) => `#${id}`), ...item.blockedByKeys];
-            let line = theme.fg("accent", ids ? `#${ids[index]}` : `${index + 1}.`);
-            if (item.subject)
-                line += ` ${theme.fg("text", item.subject)}`;
-            if (dependencies.length)
-                line += ` ${theme.fg("dim", `· blocked by ${dependencies.join(", ")}`)}`;
-            lines.push(line);
+            const marker = ids ? theme.fg("accent", `#${ids[index]}`) : theme.fg("accent", `${index + 1}.`);
+            details.push(item.subject ? `${marker} ${theme.fg("text", item.subject)}` : marker);
             if (item.description)
-                lines.push(`  ${theme.fg("dim", callDescriptionPreview(item.description))}`);
+                details.push(`    ${theme.fg("dim", descriptionPreview(item.description))}`);
         }
     }
-    push("description", callText(args?.description));
-    push("activeForm", callText(args?.activeForm));
-    push("owner", callText(args?.owner));
-    for (const key of EDGE_PARAMS) {
-        const ids = callIds(args?.[key]);
-        if (ids.length)
-            push(key, ids.map((id) => `#${id}`).join(","));
+    else if (verb === "update") {
+        const id = safeId(args?.id);
+        if (id !== undefined)
+            headline.push(theme.fg("accent", `#${id}`));
+        const status = safeStatus(args?.status);
+        if (status)
+            headline.push(theme.fg(STATUS_COLOR[status], status));
+        const subject = safeSubject(args?.subject);
+        if (subject)
+            headline.push(theme.fg("text", truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…")));
+        const description = safeDescription(args?.description);
+        if (description)
+            details.push(`    ${theme.fg("dim", descriptionPreview(description))}`);
+    }
+    else if (verb === "delete") {
+        const ids = readIds(args?.ids, false) ?? [];
+        if (ids.length) {
+            const rendered = theme.fg("accent", ids.map((id) => `#${id}`).join(", "));
+            headline.push(rendered);
+            details.push(rendered);
+        }
     }
-    if (args?.includeDeleted === true)
-        push("includeDeleted", "true");
-    const limit = callId(args?.limit);
-    if (limit !== undefined)
-        push("limit", String(limit));
-    const afterId = callId(args?.afterId);
-    if (afterId !== undefined)
-        push("afterId", String(afterId));
-    push("query", callText(args?.query));
-    if (args?.unblockedOnly === true)
-        push("unblockedOnly", "true");
-    if (args?.confirm === true)
-        push("confirm", "true");
-    const expectedCount = callNonNegativeInteger(args?.expectedCount);
-    if (expectedCount !== undefined)
-        push("expectedCount", String(expectedCount));
-    const metadata = args?.metadata;
-    if (metadata && typeof metadata === "object")
-        push("metadata", Object.keys(metadata).join(","));
-    return lines;
+    return { headline: headline.join(" "), details };
 }
-/**
- * One-line call summary when collapsed; the same headline plus the parameters
- * the result never echoes (description, activeForm, dependencies) when expanded.
- */
+/** One-line call summary when collapsed; headline plus details when expanded. */
 export function formatTodoCall(args, theme, expanded, result) {
-    const headline = formatCallHeadline(args, theme);
-    if (!expanded)
-        return headline;
-    return [headline, ...formatCallDetails(args, theme, result)].join("\n");
-}
-const GROUP_FAILURE_MAX_LENGTH = 120;
-const GROUP_MAX_IDS = 20;
-const GROUP_MAX_SNAPSHOT_ITEMS = 10_000;
-const TODO_ACTIONS = new Set(["create", "create_many", "update", "list", "get", "delete", "clear"]);
-function safeRecord(value) {
-    try {
-        return value !== null && typeof value === "object" && !Array.isArray(value)
-            ? value
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    const { headline, details } = formatCallParts(args, theme, result);
+    return !expanded || details.length === 0 ? headline : [headline, ...details].join("\n");
 }
-function safeValue(record, key) {
-    try {
-        return record[key];
-    }
-    catch {
+/** Id -> item index plus status counts over the v2 snapshot (one defensive walk). */
+function stateIndex(state) {
+    const array = readArray(safeValue(state, "items"), TODO_MAX_ITEMS);
+    if (!array || array.length > TODO_MAX_ITEMS)
         return undefined;
+    const byId = new Map();
+    const counts = { inProgress: 0, pending: 0, completed: 0 };
+    for (const raw of array.values) {
+        const item = safeRecord(raw);
+        if (!item)
+            continue;
+        const id = safeId(safeValue(item, "id"));
+        if (id !== undefined && !byId.has(id))
+            byId.set(id, item);
+        const status = safeStatus(safeValue(item, "status"));
+        if (status === "in_progress")
+            counts.inProgress++;
+        else if (status === "pending")
+            counts.pending++;
+        else if (status === "completed")
+            counts.completed++;
     }
+    return { byId, counts };
 }
-function safeString(value) {
-    return typeof value === "string" ? value : undefined;
+function stateSubject(map, id) {
+    const item = map.get(id);
+    return item ? safeSubject(safeValue(item, "subject")) : "";
 }
-function groupDetails(value) {
-    const details = safeRecord(value);
-    if (!details || safeValue(details, "schemaVersion") !== TODO_DETAILS_SCHEMA_VERSION)
-        return undefined;
-    const action = safeString(safeValue(details, "action"));
-    if (!action || !TODO_ACTIONS.has(action))
+/** Deleted entries: one invalid or empty entry rejects the whole list. */
+function removedEntries(value) {
+    const array = readArray(value);
+    if (!array || array.length === 0 || array.length > CALL_ITEMS_MAX)
         return undefined;
-    const operation = safeRecord(safeValue(details, "operation"));
-    if (!operation || safeValue(operation, "kind") !== action)
-        return undefined;
-    return { action, operation, items: safeValue(details, "items") };
-}
-function groupPositiveInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
-}
-function groupIds(value) {
-    try {
-        if (!Array.isArray(value) || value.length === 0 || value.length > GROUP_MAX_IDS)
+    const removed = [];
+    for (const raw of array.values) {
+        const id = safeId(safeValue(safeRecord(raw), "id"));
+        const subject = safeSubject(safeValue(safeRecord(raw), "subject"));
+        if (id === undefined || !subject)
             return undefined;
-        const ids = [];
-        for (const valueAtIndex of value) {
-            const id = groupPositiveInteger(valueAtIndex);
-            if (id === undefined)
-                return undefined;
-            ids.push(id);
-        }
-        return ids;
-    }
-    catch {
-        return undefined;
+        removed.push({ id, subject });
     }
+    return removed;
 }
-function groupNonNegativeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
-}
-function formatGroupStatusCounts(value, resultCount) {
-    const count = groupNonNegativeInteger(resultCount);
-    if (count === undefined)
-        return undefined;
-    if (count === 0)
-        return "no tasks";
-    const rawCounts = safeRecord(value);
-    if (!rawCounts)
+function formatTodoGroupSuccess(args, theme, result) {
+    const parsed = todoDetails(result.details);
+    if (!parsed)
         return undefined;
-    const parts = [];
-    let total = 0;
-    for (const status of ["pending", "in_progress", "completed", "deleted"]) {
-        const statusCount = groupNonNegativeInteger(safeValue(rawCounts, status));
-        if (statusCount === undefined)
-            continue;
-        total += statusCount;
-        if (statusCount > 0)
-            parts.push(`${statusCount} ${status}`);
-    }
-    return total === count && parts.length ? parts.join(", ") : undefined;
-}
-function groupItem(value, id) {
-    try {
-        if (!Array.isArray(value) || value.length > GROUP_MAX_SNAPSHOT_ITEMS)
+    const { change, state } = parsed;
+    const verb = (word) => theme.fg("toolTitle", `todo ${word}`);
+    const withPreview = (word, ids, subjects) => {
+        const text = formatSubjectPreview(subjects, subjects.length);
+        const consecutive = ids.length > 1 && ids.every((id, index) => id === ids[0] + index);
+        const rendered = consecutive ? `#${ids[0]}–#${ids.at(-1)}` : ids.map((id) => `#${id}`).join(", ");
+        const base = `${verb(word)} ${theme.fg("accent", rendered)}`;
+        return text ? `${base}${theme.fg("dim", " · ")}${theme.fg("text", text)}` : base;
+    };
+    const kind = safeString(safeValue(change, "kind"));
+    if (kind === "create") {
+        const ids = readIds(safeValue(change, "ids"), true);
+        const index = stateIndex(state);
+        if (!ids || !index)
             return undefined;
-        for (const rawItem of value) {
-            const item = safeRecord(rawItem);
-            if (item && safeValue(item, "id") === id)
-                return item;
-        }
+        const subjects = ids.map((id) => stateSubject(index.byId, id));
+        return withPreview("created", ids, subjects);
     }
-    catch {
-        return undefined;
+    if (kind === "update") {
+        const id = safeId(safeValue(change, "id"));
+        const index = stateIndex(state);
+        if (id === undefined || !index)
+            return undefined;
+        const to = safeStatus(safeValue(change, "to"));
+        const demotedId = safeId(safeValue(change, "demotedId"));
+        const parts = [verb("updated"), theme.fg("accent", `#${id}`)];
+        if (to)
+            parts.push(theme.fg(STATUS_COLOR[to], to));
+        const subject = stateSubject(index.byId, id) || safeSubject(args?.subject) || "";
+        if (subject)
+            parts.push(theme.fg("text", truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…")));
+        if (demotedId !== undefined)
+            parts.push(theme.fg("dim", `· demoted #${demotedId}`));
+        return parts.join(" ");
+    }
+    if (kind === "list") {
+        const counts = stateIndex(state)?.counts;
+        if (!counts)
+            return undefined;
+        const parts = [];
+        if (counts.inProgress > 0)
+            parts.push(`${counts.inProgress} in progress`);
+        if (counts.pending > 0)
+            parts.push(`${counts.pending} pending`);
+        if (counts.completed > 0)
+            parts.push(`${counts.completed} completed`);
+        return `${verb("list")}: ${theme.fg("dim", parts.length ? parts.join(", ") : "no tasks")}`;
+    }
+    if (kind === "delete") {
+        const removed = removedEntries(safeValue(change, "removed"));
+        if (!removed)
+            return undefined;
+        const subjects = removed.map((entry) => entry.subject);
+        return withPreview("deleted", removed.map((entry) => entry.id), subjects);
     }
     return undefined;
 }
-function groupItemStatus(value, id) {
-    const item = groupItem(value, id);
-    if (!item)
-        return undefined;
-    const status = safeString(safeValue(item, "status"));
-    return status && isTodoStatus(status) ? status : undefined;
-}
-function groupItemSubject(value, id) {
-    const item = groupItem(value, id);
-    if (!item)
-        return undefined;
-    const subject = callSubject(safeValue(item, "subject"));
-    return subject || undefined;
-}
-function formatGroupIds(ids) {
-    const consecutive = ids.length > 1 && ids.every((id, index) => id === ids[0] + index);
-    return consecutive ? `#${ids[0]}–#${ids.at(-1)}` : ids.map((id) => `#${id}`).join(", ");
-}
-function formatGroupFailure(result) {
-    try {
-        for (const block of result?.content.slice(0, 8) ?? []) {
-            if (block.type !== "text" || typeof block.text !== "string")
-                continue;
-            const reason = block.text
-                .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
-                .replace(/\s+/g, " ")
-                .trim();
-            if (!reason)
-                continue;
-            return reason.length > GROUP_FAILURE_MAX_LENGTH ? `${reason.slice(0, GROUP_FAILURE_MAX_LENGTH - 1)}…` : reason;
-        }
-    }
-    catch {
-        // Tool results can come from historical or third-party sources.
-    }
-    return "tool failed";
-}
-function formatTodoGroupSuccess(args, result) {
-    const details = groupDetails(result.details);
-    if (!details)
-        return undefined;
-    switch (details.action) {
-        case "create": {
-            const ids = groupIds(safeValue(details.operation, "ids"));
-            if (!ids || ids.length !== 1)
-                return undefined;
-            const subject = groupItemSubject(details.items, ids[0]) ?? callSubject(args?.subject);
-            const preview = subject ? truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…") : "";
-            return `todo created #${ids[0]}${preview ? ` ${preview}` : ""}`;
-        }
-        case "create_many": {
-            const ids = groupIds(safeValue(details.operation, "ids"));
-            if (!ids)
-                return undefined;
-            const callItems = callBatchItems(args?.items);
-            const subjects = ids.map((id, index) => groupItemSubject(details.items, id) ?? callItems[index]?.subject ?? "");
-            const preview = formatSubjectPreview(subjects, ids.length);
-            return `todo created ${formatGroupIds(ids)}${preview ? ` · ${preview}` : ""}`;
-        }
-        case "update": {
-            const id = groupPositiveInteger(safeValue(details.operation, "id"));
-            const status = safeString(safeValue(details.operation, "status"));
-            return id !== undefined && status && isTodoStatus(status) ? `todo updated #${id} ${status}` : undefined;
-        }
-        case "list": {
-            const counts = formatGroupStatusCounts(safeValue(details.operation, "statusCounts"), safeValue(details.operation, "resultCount"));
-            return counts === undefined ? undefined : `todo list: ${counts}`;
-        }
-        case "get": {
-            const id = groupPositiveInteger(safeValue(details.operation, "id"));
-            const status = id === undefined ? undefined : groupItemStatus(details.items, id);
-            return status ? `todo get #${id} ${status}` : undefined;
-        }
-        case "delete": {
-            const id = groupPositiveInteger(safeValue(details.operation, "id"));
-            if (id === undefined)
-                return undefined;
-            const subject = groupItemSubject(details.items, id);
-            const preview = subject ? truncateToWidth(subject, CALL_SUBJECT_PREVIEW_WIDTH, "…") : "";
-            return `todo deleted #${id}${preview ? ` ${preview}` : ""}`;
-        }
-        case "clear": {
-            const count = callNonNegativeInteger(safeValue(details.operation, "count"));
-            return count === undefined ? undefined : `todo cleared ${count} ${count === 1 ? "task" : "tasks"}`;
-        }
-    }
-}
 /** Compact result-aware summary used only by collapsed todo tool groups. */
 export function formatTodoGroupCall(args, theme, context) {
     if (context.isError) {
-        return `${formatTodoCall(args, theme, false)} ${theme.fg("error", `failed: ${formatGroupFailure(context.result)}`)}`;
+        let reason = "tool failed";
+        try {
+            for (const block of context.result?.content.slice(0, 8) ?? []) {
+                if (block.type !== "text" || typeof block.text !== "string")
+                    continue;
+                const text = block.text
+                    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+                    .replace(/\s+/g, " ")
+                    .trim();
+                if (!text)
+                    continue;
+                reason = text.length > GROUP_FAILURE_MAX_LENGTH ? `${text.slice(0, GROUP_FAILURE_MAX_LENGTH - 1)}…` : text;
+                break;
+            }
+        }
+        catch {
+            // Tool results can come from historical or third-party sources.
+        }
+        return `${formatTodoCall(args, theme, false)} ${theme.fg("error", `failed: ${reason}`)}`;
     }
     if (!context.isPartial && context.result) {
-        const summary = formatTodoGroupSuccess(args, context.result);
+        const summary = formatTodoGroupSuccess(args, theme, context.result);
         if (summary)
-            return theme.fg("toolTitle", summary);
+            return summary;
     }
     return formatTodoCall(args, theme, false);
 }
-export function formatCommandList(state) {
-    const visible = visibleTodos(state);
-    if (!visible.length)
-        return "No todos yet.";
-    const lines = [];
-    let shown = 0;
-    for (const status of ["in_progress", "pending", "completed"]) {
-        const group = visible.filter((item) => item.status === status).sort(byIdAsc);
-        if (!group.length || shown >= LIST_DISPLAY_MAX_ITEMS)
-            continue;
-        lines.push(status);
-        for (const item of group) {
-            if (shown >= LIST_DISPLAY_MAX_ITEMS)
-                break;
-            const active = item.status === "in_progress" && item.activeForm ? ` (${item.activeForm})` : "";
-            const owner = item.owner ? ` @${item.owner}` : "";
-            const unresolved = unresolvedDependencyIds(state, item);
-            const deps = unresolved.length ? ` blocked by ${unresolved.map((id) => `#${id}`).join(",")}` : "";
-            lines.push(`  ${STATUS_MARK[item.status]} #${item.id} ${item.subject}${active}${owner}${deps}`);
-            shown++;
-        }
-    }
-    if (visible.length > shown) {
-        lines.push(`… and ${visible.length - shown} more; use todo list with limit and afterId to page.`);
-    }
-    return lines.join("\n");
-}
 //# sourceMappingURL=view.js.map