@pi9/todo 0.1.0 → 0.3.0

package/src/tool.ts

@@ -1,39 +1,43 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Container, type Component } from "@earendil-works/pi-tui";
-import { formatTodoSummary } from "./format.js";
+import { formatTodoCompactionContext, formatTodoSummary } from "./format.js";
 import { restoreTodoState } from "./persistence.js";
+import {
+  beginReminderAgentRun,
+  consumeDueReminder,
+  createReminderCadenceState,
+  noteReminderTurn,
+  noteTodoInteraction,
+  type ReminderCadenceConfig,
+} from "./reminder-cadence.js";
+import { formatTodoReminder } from "./reminder.js";
 import { renderResult as renderTodoResult } from "./renderer.js";
 import { TodoToolFrame, type TodoToolFrameContent, type TodoToolFrameTheme } from "./tool-frame.js";
 import { TodoParamsSchema } from "./schema.js";
-import { DEFAULT_TODO_UI_SETTINGS, loadTodoUiSettings, type TodoUiSettings } from "./settings.js";
+import { DEFAULT_TODO_SETTINGS, loadTodoSettings, type TodoSettings } from "./settings.js";
 import { createTodoState, todoAddressKey, transitionTodoState } from "./state.js";
-import { TODO_STATUSES, type TodoAction, type TodoAddress, type TodoState, type TodoToolDetails } from "./types.js";
+import type { TodoAddress, TodoState, TodoStatus, TodoToolDetails } from "./types.js";
 import { shouldRenderTodoAction } from "./visibility.js";
 import { updateTodoWidget } from "./widget.js";
 
-function taskStatuses(state: TodoState): Map<string, string> {
+function taskStatuses(state: TodoState): Map<string, TodoStatus> {
   return new Map(state.phases.flatMap((phase) => phase.tasks.map((task) => [todoAddressKey(phase.name, task.name), task.status])));
 }
 
-function taskAddresses(state: TodoState): Map<string, TodoAddress> {
-  return new Map(state.phases.flatMap((phase) => phase.tasks.map((task) => {
-    const address = { phase: phase.name, task: task.name };
-    return [todoAddressKey(address.phase, address.task), address];
+function taskAddresses(state: TodoState): TodoAddress[] {
+  return state.phases.flatMap((phase) => phase.tasks.map((task) => ({
+    phase: phase.name,
+    task: task.name,
   })));
 }
 
 function changedTasks(previous: TodoState, next: TodoState): TodoAddress[] {
   const before = taskStatuses(previous);
-  const after = taskStatuses(next);
-  const addresses = taskAddresses(next);
-  return [...after.keys()].filter((key) => before.get(key) !== after.get(key)).map((key) => addresses.get(key)!);
-}
-
-function completedTasks(previous: TodoState, next: TodoState): TodoAddress[] {
-  const before = taskStatuses(previous);
-  return next.phases.flatMap((phase) => phase.tasks
-    .filter((task) => task.status === "completed" && before.has(todoAddressKey(phase.name, task.name)) && before.get(todoAddressKey(phase.name, task.name)) !== "completed")
-    .map((task) => ({ phase: phase.name, task: task.name })));
+  return next.phases.flatMap((phase) => phase.tasks.flatMap((task) =>
+    before.get(todoAddressKey(phase.name, task.name)) === task.status
+      ? []
+      : [{ phase: phase.name, task: task.name }],
+  ));
 }
 
 function createTodoFrame(
@@ -58,6 +62,15 @@ type TodoRenderInput = {
 type TodoRenderTheme = Parameters<typeof renderTodoResult>[2];
 type TrackedSetRenderer = { toolCallId: string; invalidate?: () => void };
 
+function reminderConfig(settings: TodoSettings): ReminderCadenceConfig {
+  return {
+    minTurns: settings.reminderMinTurns,
+    maxTurns: settings.reminderMaxTurns,
+    outputTokens: settings.reminderOutputTokens,
+    maxPerRun: settings.reminderMaxPerRun,
+  };
+}
+
 /** Expanded content for the one set result that is allowed to follow in-memory state. */
 class LiveSetResult implements Component {
   constructor(
@@ -81,7 +94,10 @@ class LiveSetResult implements Component {
 
 export function registerTodoTool(pi: ExtensionAPI): void {
   let state = createTodoState();
-  let settings: TodoUiSettings = { ...DEFAULT_TODO_UI_SETTINGS };
+  let settings: TodoSettings = { ...DEFAULT_TODO_SETTINGS };
+  let reminderCadence = createReminderCadenceState();
+  let pendingCompactionContext: string | undefined;
+  let interactedWithTodoThisTurn = false;
   let queue: Promise<void> = Promise.resolve();
   let latestSetRenderer: TrackedSetRenderer | undefined;
 
@@ -95,30 +111,80 @@ export function registerTodoTool(pi: ExtensionAPI): void {
     updateTodoWidget(ctx, state, settings);
   };
 
+  const resetReminderTracking = (): void => {
+    reminderCadence = createReminderCadenceState();
+    interactedWithTodoThisTurn = false;
+  };
+
   pi.on("session_start", async (_event, ctx) => {
-    const loaded = await loadTodoUiSettings(ctx);
+    const loaded = await loadTodoSettings(ctx);
     settings = loaded.settings;
     if (loaded.warning) ctx.ui.notify(loaded.warning, "warning");
     restore(ctx);
+    pendingCompactionContext = undefined;
+    resetReminderTracking();
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    restore(ctx);
+    pendingCompactionContext = undefined;
+    resetReminderTracking();
+  });
+  pi.on("session_compact", () => {
+    pendingCompactionContext = formatTodoCompactionContext(state);
+    if (pendingCompactionContext) reminderCadence = noteTodoInteraction(reminderCadence);
+  });
+  pi.on("before_agent_start", () => {
+    reminderCadence = beginReminderAgentRun(reminderCadence);
+  });
+  pi.on("turn_end", (event) => {
+    reminderCadence = interactedWithTodoThisTurn
+      ? noteTodoInteraction(reminderCadence)
+      : noteReminderTurn(
+          reminderCadence,
+          event.message.role === "assistant" ? event.message.usage?.output ?? 0 : 0,
+        );
+    interactedWithTodoThisTurn = false;
+  });
+  pi.on("context", (event) => {
+    if (pendingCompactionContext) {
+      const content = pendingCompactionContext;
+      pendingCompactionContext = undefined;
+      return {
+        messages: [...event.messages, { role: "user", content, timestamp: Date.now() }],
+      };
+    }
+
+    if (!settings.dynamicReminders) return;
+
+    const reminder = formatTodoReminder(state);
+    if (!reminder) return;
+
+    const consumed = consumeDueReminder(reminderCadence, reminderConfig(settings));
+    if (!consumed.due) return;
+
+    reminderCadence = consumed.state;
+    return {
+      messages: [...event.messages, { role: "user", content: reminder, timestamp: Date.now() }],
+    };
   });
-  pi.on("session_tree", (_event, ctx) => restore(ctx));
 
   pi.registerTool({
     name: "todo",
     label: "Todo",
     description: [
-      "Maintain a concise phased plan that reflects both intended work and current execution progress.",
+      "Maintain a phased task plan for complex work with 3+ distinct steps.",
       "Actions:",
-      "  set: Replace the entire plan. All tasks reset to pending. Use only for a new plan or full re-plan.",
-      "  add: Append tasks or phases without touching existing work.",
-      "  transition: Update task statuses (" + TODO_STATUSES.join(", ") + ") by exact phase and task name.",
-      "  view: Return the plan, optionally filtered to one phase.",
+      "  set(phases): Replace the entire plan; all tasks start `pending`.",
+      "  add(phases): Add described tasks; preserve existing tasks and statuses.",
+      "  transition(transitions, workingOn?): Set statuses and current work by exact phase and task names.",
+      "  view(): Return the full plan with task descriptions.",
     ].join("\n"),
-    promptSnippet: "Track multi-step work with the todo tool; keep statuses current as you go",
+    promptSnippet: "Track multi-step work in a phased task plan",
     promptGuidelines: [
-      "Use todo for non-trivial work with three or more distinct steps; skip todo for simple tasks.",
-      "Transition todo statuses immediately and honestly—mark tasks completed only when fully done, not merely attempted, and cancel abandoned tasks rather than leaving them pending.",
-      "Todo tasks in_progress must all belong to a single phase; finish or cancel a phase's active tasks before starting the next.",
+      "Update the todo plan immediately as work starts, finishes, or is abandoned; never defer status transitions to the end.",
+      "Mark todo tasks `completed` only after verification and `cancelled` when abandoned or obsolete; keep all `in_progress` tasks confined to one phase.",
+      "Include an accurate `workingOn` summary in every todo transition that leaves one or more tasks `in_progress`.",
+      "Use todo `add` for material new work rather than expanding the scope of existing tasks; use the destructive `set` action only for planning or replanning.",
     ],
     parameters: TodoParamsSchema,
     renderShell: "self",
@@ -126,24 +192,24 @@ export function registerTodoTool(pi: ExtensionAPI): void {
     execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const run = queue.then(() => {
         const previous = state;
-        const next = transitionTodoState(previous, params as TodoAction);
+        const next = transitionTodoState(previous, params);
         const details: TodoToolDetails = {
           action: params.action,
           state: next,
           changedTasks: params.action === "view"
             ? []
             : params.action === "set"
-              ? [...taskAddresses(next).values()]
+              ? taskAddresses(next)
               : changedTasks(previous, next),
-          completedTasks: params.action === "transition" ? completedTasks(previous, next) : [],
         };
         if (params.action !== "view") {
           state = next;
           invalidateLatestSetRenderer();
         }
         updateTodoWidget(ctx, state, settings);
+        interactedWithTodoThisTurn = true;
         return {
-          content: [{ type: "text" as const, text: formatTodoSummary(next) }],
+          content: [{ type: "text" as const, text: formatTodoSummary(next, params.action === "view") }],
           details,
         };
       });

package/src/types.ts

@@ -1,63 +1,87 @@
 export const TODO_STATUSES = ["pending", "in_progress", "completed", "cancelled"] as const;
 export type TodoStatus = typeof TODO_STATUSES[number];
 
+export function isTodoStatus(value: unknown): value is TodoStatus {
+  return typeof value === "string" && (TODO_STATUSES as readonly string[]).includes(value);
+}
+
 export const TODO_ACTIONS = ["set", "add", "transition", "view"] as const;
 export type TodoActionName = typeof TODO_ACTIONS[number];
 
+export function isTodoActionName(value: unknown): value is TodoActionName {
+  return typeof value === "string" && (TODO_ACTIONS as readonly string[]).includes(value);
+}
+
 export type Todo = {
-  name: string;
-  status: TodoStatus;
+  readonly name: string;
+  readonly description: string;
+  readonly status: TodoStatus;
 };
 
+export function isTerminalTodo(todo: Pick<Todo, "status">): boolean {
+  return todo.status === "completed" || todo.status === "cancelled";
+}
+
+export function todoTaskPriority(todo: Pick<Todo, "status">): number {
+  if (todo.status === "in_progress") return 0;
+  if (todo.status === "pending") return 1;
+  return 2;
+}
+
 export type TodoPhase = {
-  name: string;
-  tasks: Todo[];
+  readonly name: string;
+  readonly tasks: readonly Todo[];
 };
 
 export type TodoState = {
-  phases: TodoPhase[];
+  readonly phases: readonly TodoPhase[];
+  readonly workingOn?: string;
 };
 
 export type TodoAddress = {
-  phase: string;
-  task: string;
+  readonly phase: string;
+  readonly task: string;
 };
 
 /** Persisted with a successful tool result so session state can be restored. */
 export type TodoToolDetails = {
-  action: TodoActionName;
-  state: TodoState;
-  changedTasks: TodoAddress[];
-  completedTasks: TodoAddress[];
+  readonly action: TodoActionName;
+  readonly state: TodoState;
+  readonly changedTasks: readonly TodoAddress[];
+};
+
+export type TodoTaskInput = {
+  readonly name: string;
+  readonly description: string;
 };
 
 export type TodoPhaseInput = {
-  name: string;
-  tasks: string[];
+  readonly name: string;
+  readonly tasks: readonly TodoTaskInput[];
 };
 
 export type TodoTransitionInput = TodoAddress & {
-  status: TodoStatus;
+  readonly status: TodoStatus;
 };
 
 export type SetTodoAction = {
-  action: "set";
-  phases: TodoPhaseInput[];
+  readonly action: "set";
+  readonly phases: readonly TodoPhaseInput[];
 };
 
 export type AddTodoAction = {
-  action: "add";
-  phases: TodoPhaseInput[];
+  readonly action: "add";
+  readonly phases: readonly TodoPhaseInput[];
 };
 
 export type TransitionTodoAction = {
-  action: "transition";
-  transitions: TodoTransitionInput[];
+  readonly action: "transition";
+  readonly transitions: readonly TodoTransitionInput[];
+  readonly workingOn?: string;
 };
 
 export type ViewTodoAction = {
-  action: "view";
-  phase?: string;
+  readonly action: "view";
 };
 
 export type TodoAction = SetTodoAction | AddTodoAction | TransitionTodoAction | ViewTodoAction;

package/src/visibility.ts

@@ -1,9 +1,5 @@
 import type { TodoToolVisibility } from "./settings.js";
-import { TODO_ACTIONS, type TodoActionName } from "./types.js";
-
-function isTodoActionName(action: unknown): action is TodoActionName {
-  return typeof action === "string" && (TODO_ACTIONS as readonly string[]).includes(action);
-}
+import { isTodoActionName } from "./types.js";
 
 /** Returns whether a successful todo action should be shown in tool output. */
 export function shouldRenderTodoAction(action: unknown, visibility: TodoToolVisibility): boolean {

package/src/widget-component.ts

@@ -1,14 +1,16 @@
-import { wrapTextWithAnsi, type Component, type TUI } from "@earendil-works/pi-tui";
+import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 
 import type { TodoState } from "./types.js";
 import { renderTodoWidgetLines, type TodoWidgetLayoutOptions } from "./widget-layout.js";
 
-const DROPLET_FRAMES = ["", "", "󰺕", "󰻃", ""] as const;
-const DROPLET_DURATIONS_MS = [220, 110, 80, 100, 420] as const;
 const PI_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
 const PI_SPINNER_INTERVAL_MS = 80;
 
+type TodoWidgetComponentOptions = TodoWidgetLayoutOptions & {
+  blankLineBelow?: boolean;
+};
+
 /** A width-aware component for Pi's persistent widget area. */
 export class TodoWidgetComponent implements Component {
   private frameIndex = 0;
@@ -17,22 +19,25 @@ export class TodoWidgetComponent implements Component {
   constructor(
     private readonly state: TodoState,
     private readonly theme: Theme | undefined,
-    private readonly options: TodoWidgetLayoutOptions = {},
+    private readonly options: TodoWidgetComponentOptions = {},
     private readonly tui?: Pick<TUI, "requestRender">,
   ) {
-    if (tui && state.phases.some(phase => phase.tasks.some(task => task.status === "in_progress"))) {
+    if (tui && state.workingOn) {
       this.scheduleNextFrame();
     }
   }
 
-  invalidate(): void { }
+  invalidate(): void {}
 
   render(width: number): string[] {
     const safeWidth = Math.max(1, Math.floor(width) || 1);
-    return renderTodoWidgetLines(this.state, this.theme, safeWidth, {
-      ...this.options,
-      activeMarker: this.frames[this.frameIndex],
-    }).flatMap(line => wrapTextWithAnsi(line, safeWidth));
+    const { blankLineBelow, ...layoutOptions } = this.options;
+    const lines = renderTodoWidgetLines(this.state, this.theme, safeWidth, {
+      ...layoutOptions,
+      workingMarker: PI_SPINNER_FRAMES[this.frameIndex],
+    });
+    if (blankLineBelow && lines.length > 0) lines.push("");
+    return lines;
   }
 
   dispose(): void {
@@ -40,18 +45,11 @@ export class TodoWidgetComponent implements Component {
     this.timer = undefined;
   }
 
-  private get frames(): readonly string[] {
-    return this.options.fallbackGlyphs ? PI_SPINNER_FRAMES : DROPLET_FRAMES;
-  }
-
   private scheduleNextFrame(): void {
-    const delay = this.options.fallbackGlyphs
-      ? PI_SPINNER_INTERVAL_MS
-      : DROPLET_DURATIONS_MS[this.frameIndex];
     this.timer = setTimeout(() => {
-      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      this.frameIndex = (this.frameIndex + 1) % PI_SPINNER_FRAMES.length;
       this.tui?.requestRender();
       this.scheduleNextFrame();
-    }, delay);
+    }, PI_SPINNER_INTERVAL_MS);
   }
 }

package/src/widget-layout.ts

@@ -2,22 +2,20 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 
 import { todoGlyph } from "./glyphs.js";
-import type { Todo, TodoPhase, TodoState } from "./types.js";
+import { currentTodoPhaseIndex } from "./state.js";
+import { isTerminalTodo, todoTaskPriority, type Todo, type TodoPhase, type TodoState } from "./types.js";
 
 export type TodoWidgetLayoutOptions = {
   maxVisible?: number;
   fallbackGlyphs?: boolean;
-  activeMarker?: string;
+  workingMarker?: string;
 };
 
 type ThemeLike = Partial<Pick<Theme, "bold" | "fg" | "strikethrough">>;
 
 type DisplayTask = Todo & { taskIndex: number };
 
-/**
- * Produces compact widget rows. Every returned row is constrained to the supplied display width;
- * the component may subsequently wrap a row when a host chooses a narrower cell.
- */
+/** Produces compact widget rows constrained to the supplied display width. */
 export function renderTodoWidgetLines(
   state: TodoState | undefined,
   theme: ThemeLike | undefined,
@@ -25,15 +23,16 @@ export function renderTodoWidgetLines(
   options: TodoWidgetLayoutOptions = {},
 ): string[] {
   const safeWidth = Math.max(1, Math.floor(width) || 1);
-  const phases = Array.isArray(state?.phases) ? state.phases : [];
-  if (phases.length === 0 || !phases.some(phase => phase.tasks.length > 0)) return [];
-
-  const selectedPhaseIndex = selectPhase(phases);
+  const phases = state?.phases ?? [];
+  const currentPhaseIndex = currentTodoPhaseIndex(phases);
+  const selectedPhaseIndex = currentPhaseIndex >= 0
+    ? currentPhaseIndex
+    : lastNonEmptyPhaseIndex(phases);
   if (selectedPhaseIndex < 0) return [];
   const selectedPhase = phases[selectedPhaseIndex];
   const maxVisible = boundedMaxVisible(options.maxVisible);
   const selectedTasks = visibleTasks(selectedPhase.tasks, maxVisible);
-  const lines: string[] = [fit(toolTitle(summary(phases), theme), safeWidth)];
+  const lines: string[] = [fit(toolTitle("Todos", theme), safeWidth)];
 
   for (let phaseIndex = 0; phaseIndex < phases.length; phaseIndex++) {
     const phase = phases[phaseIndex];
@@ -42,9 +41,9 @@ export function renderTodoWidgetLines(
 
     if (selected) {
       for (const task of selectedTasks) {
-        lines.push(fit(taskLine(task, theme, options.fallbackGlyphs, options.activeMarker), safeWidth));
+        lines.push(fit(taskLine(task, theme, options.fallbackGlyphs), safeWidth));
       }
-      const openTasks = phase.tasks.filter(task => !isTerminal(task));
+      const openTasks = phase.tasks.filter(task => !isTerminalTodo(task));
       const hidden = openTasks.length - selectedTasks.length;
       if (hidden > 0) lines.push(fit(`    +${hidden} more`, safeWidth));
       const terminalSummary = terminalTaskSummary(phase.tasks);
@@ -55,50 +54,37 @@ export function renderTodoWidgetLines(
     }
   }
 
+  if (state?.workingOn) {
+    lines.push("");
+    const text = theme?.fg ? theme.fg("dim", state.workingOn) : state.workingOn;
+    lines.push(fit(`  ${options.workingMarker ?? "⠋"} ${text}`, safeWidth));
+  }
+
   return lines;
 }
 
-/** Alias kept for callers that prefer a builder-style name. */
-export const buildTodoWidgetLines = renderTodoWidgetLines;
-
-function boundedMaxVisible(value: number | undefined): number {
-  if (!Number.isFinite(value)) return 5;
-  return Math.max(1, Math.floor(value!));
+function lastNonEmptyPhaseIndex(phases: readonly TodoPhase[]): number {
+  for (let index = phases.length - 1; index >= 0; index -= 1) {
+    if (phases[index].tasks.length > 0) return index;
+  }
+  return -1;
 }
 
-function summary(phases: TodoPhase[]): string {
-  const tasks = phases.flatMap(phase => phase.tasks);
-  const active = tasks.filter(isActive).length;
-  const pending = tasks.filter(task => task.status === "pending").length;
-  const completed = tasks.filter(task => task.status === "completed").length;
-  const cancelled = tasks.filter(task => task.status === "cancelled").length;
-  return [
-    "Todos",
-    ...(active ? [`${active} active`] : []),
-    ...(pending ? [`${pending} pending`] : []),
-    ...(completed ? [`${completed} completed`] : []),
-    ...(cancelled ? [`${cancelled} cancelled`] : []),
-  ].join(" · ");
+function boundedMaxVisible(value: number | undefined): number {
+  if (value === undefined || !Number.isFinite(value)) return 5;
+  return Math.max(1, Math.floor(value));
 }
 
 function phaseTitle(phase: TodoPhase, phaseIndex: number, selected: boolean, theme: ThemeLike | undefined): string {
-  const title = `${phaseIndex + 1}. ${phaseSummary(phase)}`;
-  if (selected) return toolTitle(`  ${title}`, theme);
-  return theme?.fg ? theme.fg("dim", `  ${title}`) : `  ${title}`;
-}
-
-function phaseSummary(phase: TodoPhase): string {
-  const active = phase.tasks.filter(isActive).length;
-  const pending = phase.tasks.filter(task => task.status === "pending").length;
-  const completed = phase.tasks.filter(task => task.status === "completed").length;
-  const cancelled = phase.tasks.filter(task => task.status === "cancelled").length;
-  return [
-    phase.name,
-    ...(active ? [`${active} active`] : []),
-    ...(pending ? [`${pending} pending`] : []),
-    ...(completed ? [`${completed} completed`] : []),
-    ...(cancelled ? [`${cancelled} cancelled`] : []),
-  ].join(" · ");
+  const title = `  ${phaseIndex + 1}. ${phase.name}`;
+  const terminal = phase.tasks.filter(isTerminalTodo).length;
+  const progress = `· ${terminal}/${phase.tasks.length}`;
+  if (!selected) {
+    const line = `${title} ${progress}`;
+    return theme?.fg ? theme.fg("dim", line) : line;
+  }
+  const dimProgress = theme?.fg ? theme.fg("dim", progress) : progress;
+  return `${toolTitle(title, theme)} ${dimProgress}`;
 }
 
 function toolTitle(text: string, theme: ThemeLike | undefined): string {
@@ -106,39 +92,26 @@ function toolTitle(text: string, theme: ThemeLike | undefined): string {
   return theme?.fg ? theme.fg("toolTitle", bold) : bold;
 }
 
-function visibleTasks(tasks: Todo[], maxVisible: number): DisplayTask[] {
+function visibleTasks(tasks: readonly Todo[], maxVisible: number): DisplayTask[] {
   const ordered = tasks
     .map((task, taskIndex) => ({ ...task, taskIndex }))
-    .filter(task => !isTerminal(task))
-    .sort((left, right) => taskPriority(left) - taskPriority(right) || left.taskIndex - right.taskIndex);
+    .filter(task => !isTerminalTodo(task))
+    .sort((left, right) => todoTaskPriority(left) - todoTaskPriority(right) || left.taskIndex - right.taskIndex);
   const active = ordered.filter(isActive);
   return active.length > maxVisible ? active : ordered.slice(0, maxVisible);
 }
 
-function taskLine(task: Todo, theme: ThemeLike | undefined, fallbackGlyphs = false, activeMarker?: string): string {
-  const marker = isActive(task) && activeMarker ? activeMarker : todoGlyph(task.status, fallbackGlyphs);
+function taskLine(task: Todo, theme: ThemeLike | undefined, fallbackGlyphs = false): string {
+  const marker = todoGlyph(task.status, fallbackGlyphs);
   const color = task.status === "in_progress" ? "text" : task.status === "completed" ? "success" : "dim";
-  const name = (task.status === "completed" || task.status === "cancelled") && theme?.strikethrough
+  const name = isTerminalTodo(task) && theme?.strikethrough
     ? theme.strikethrough(task.name)
     : task.name;
-  let line = `    ${marker} ${name}`;
-  if (isActive(task) && theme?.bold) line = theme.bold(line);
+  const line = `    ${marker} ${name}`;
   return theme?.fg ? theme.fg(color, line) : line;
 }
 
-function taskPriority(task: Todo): number {
-  if (isActive(task)) return 0;
-  if (task.status === "pending") return 1;
-  return 2;
-}
-
-function selectPhase(phases: TodoPhase[]): number {
-  const active = phases.findIndex(phase => phase.tasks.some(isActive));
-  if (active >= 0) return active;
-  return phases.findIndex(phase => phase.tasks.some(task => task.status === "pending"));
-}
-
-function terminalTaskSummary(tasks: Todo[]): string | undefined {
+function terminalTaskSummary(tasks: readonly Todo[]): string | undefined {
   const completed = tasks.filter(task => task.status === "completed").length;
   const cancelled = tasks.filter(task => task.status === "cancelled").length;
   const parts = [
@@ -152,10 +125,6 @@ function isActive(task: Todo): boolean {
   return task.status === "in_progress";
 }
 
-function isTerminal(task: Todo): boolean {
-  return task.status === "completed" || task.status === "cancelled";
-}
-
 function fit(line: string, width: number): string {
   return visibleWidth(line) <= width ? line : truncateToWidth(line, width, "…");
 }