@agnishc/edb-todo 0.8.2 → 0.10.4

package/src/process-tracker.ts

@@ -0,0 +1,146 @@
+/**
+ * process-tracker.ts — Background process management for tasks.
+ *
+ * Tracks spawned child processes, buffers their output, and supports
+ * blocking wait and graceful stop (SIGTERM → 5s → SIGKILL).
+ */
+
+import type { ChildProcess } from "node:child_process";
+
+export interface BackgroundProcess {
+	taskId: string;
+	pid: number;
+	command?: string;
+	output: string[];
+	status: "running" | "completed" | "error" | "stopped";
+	exitCode?: number;
+	startedAt: number;
+	completedAt?: number;
+	proc: ChildProcess;
+	waiters: Array<() => void>;
+}
+
+export interface ProcessOutput {
+	output: string;
+	status: BackgroundProcess["status"];
+	exitCode?: number;
+	startedAt: number;
+	completedAt?: number;
+	command?: string;
+}
+
+export class ProcessTracker {
+	private processes = new Map<string, BackgroundProcess>();
+
+	/** Register a spawned child process for a task. */
+	track(taskId: string, proc: ChildProcess, command?: string): void {
+		const bp: BackgroundProcess = {
+			taskId,
+			pid: proc.pid!,
+			command,
+			output: [],
+			status: "running",
+			startedAt: Date.now(),
+			proc,
+			waiters: [],
+		};
+
+		proc.stdout?.on("data", (data: Buffer) => {
+			bp.output.push(data.toString());
+		});
+		proc.stderr?.on("data", (data: Buffer) => {
+			bp.output.push(data.toString());
+		});
+
+		proc.on("close", (code) => {
+			if (bp.status === "running") bp.status = code === 0 ? "completed" : "error";
+			bp.exitCode = code ?? undefined;
+			bp.completedAt = Date.now();
+			for (const resolve of bp.waiters) resolve();
+			bp.waiters = [];
+		});
+
+		proc.on("error", (err) => {
+			if (bp.status === "running") {
+				bp.status = "error";
+				bp.output.push(`Process error: ${err.message}`);
+				bp.completedAt = Date.now();
+				for (const resolve of bp.waiters) resolve();
+				bp.waiters = [];
+			}
+		});
+
+		this.processes.set(taskId, bp);
+	}
+
+	/** Get current output and status for a task's process. */
+	getOutput(taskId: string): ProcessOutput | undefined {
+		const bp = this.processes.get(taskId);
+		if (!bp) return undefined;
+		return {
+			output: bp.output.join(""),
+			status: bp.status,
+			exitCode: bp.exitCode,
+			startedAt: bp.startedAt,
+			completedAt: bp.completedAt,
+			command: bp.command,
+		};
+	}
+
+	/** Wait for a task's process to complete, with timeout. Returns output or undefined on timeout. */
+	waitForCompletion(taskId: string, timeout: number, signal?: AbortSignal): Promise<ProcessOutput | undefined> {
+		const bp = this.processes.get(taskId);
+		if (!bp) return Promise.resolve(undefined);
+		if (bp.status !== "running") return Promise.resolve(this.getOutput(taskId));
+
+		return new Promise<ProcessOutput | undefined>((resolve) => {
+			let settled = false;
+			const self = this;
+
+			function finish() {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(self.getOutput(taskId));
+			}
+
+			const timer = setTimeout(finish, timeout);
+			bp.waiters.push(finish);
+			signal?.addEventListener("abort", finish, { once: true });
+		});
+	}
+
+	/** Stop a task's background process gracefully. SIGTERM → wait 5s → SIGKILL. */
+	async stop(taskId: string): Promise<boolean> {
+		const bp = this.processes.get(taskId);
+		if (!bp || bp.status !== "running") return false;
+
+		bp.status = "stopped";
+		bp.proc.kill("SIGTERM");
+
+		await new Promise<void>((resolve) => {
+			const timer = setTimeout(() => {
+				try {
+					bp.proc.kill("SIGKILL");
+				} catch {
+					/* already dead */
+				}
+				resolve();
+			}, 5000);
+			bp.proc.on("close", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+
+		bp.completedAt = Date.now();
+		for (const resolve of bp.waiters) resolve();
+		bp.waiters = [];
+		return true;
+	}
+
+	/** Check whether a task has an active tracked process. */
+	has(taskId: string): boolean {
+		return this.processes.has(taskId);
+	}
+}

package/src/prompt.ts

@@ -1,16 +1,17 @@
-import { priorityLabel, store } from "./state";
-import { PRIORITY_ORDER } from "./types";
+import type { FileTaskStore } from "./file-store.js";
+import { priorityLabel } from "./state.js";
+import { PRIORITY_ORDER } from "./types.js";
 
 // ── System prompt injection ────────────────────────────────────────────────────
 
-export function buildSystemPromptBlock(): string {
+export function buildSystemPromptBlock(store: FileTaskStore): string {
 	const active = store.activeTasks();
 	if (active.length === 0) return "";
 
 	const lines: string[] = [
 		"## Current Task List",
 		"",
-		"You have the following tasks. Update them with `todo_write` as you work:",
+		"You have the following tasks. Update them with `TaskCreate` / `TaskUpdate` as you work:",
 		"",
 	];
 
@@ -23,12 +24,13 @@ export function buildSystemPromptBlock(): string {
 		const icon = t.status === "in_progress" ? "●" : "○";
 		const pLabel = `[${priorityLabel(t.priority)}]`;
 		const suffix = t.status === "in_progress" ? "  ← in progress" : "";
-		lines.push(`${icon} ${pLabel} ${t.content}${suffix}`);
+		const depStr = t.blockedBy.length > 0 ? ` [blocked by ${t.blockedBy.map((id) => `#${id}`).join(", ")}]` : "";
+		lines.push(`${icon} [${t.id}] ${pLabel} ${t.content}${suffix}${depStr}`);
 	}
 
-	const doneCount = store.tasks.filter((t) => t.status === "completed").length;
+	const doneCount = store.list().filter((t) => t.status === "completed").length;
 	if (doneCount > 0) {
-		lines.push("", `${doneCount}/${store.tasks.length} tasks completed.`);
+		lines.push("", `${doneCount}/${store.list().length} tasks completed.`);
 	}
 
 	return lines.join("\n");
@@ -36,12 +38,14 @@ export function buildSystemPromptBlock(): string {
 
 // ── LLM text formatter ─────────────────────────────────────────────────────────
 
-export function formatListForLLM(): string {
-	if (store.tasks.length === 0) return "Task list is empty.";
-	return store.tasks
+export function formatListForLLM(store: FileTaskStore): string {
+	const tasks = store.list();
+	if (tasks.length === 0) return "Task list is empty.";
+	return tasks
 		.map((t) => {
 			const icon = t.status === "in_progress" ? "●" : t.status === "completed" ? "✓" : "○";
-			return `${icon} [${priorityLabel(t.priority)}] [${t.id}] ${t.content}`;
+			const dep = t.blockedBy.length > 0 ? ` [blocked by ${t.blockedBy.map((id) => `#${id}`).join(", ")}]` : "";
+			return `${icon} [${priorityLabel(t.priority)}] [${t.id}] ${t.content}${dep}`;
 		})
 		.join("\n");
 }

package/src/schemas.ts

@@ -1,41 +1,66 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 
-// ── Tool schemas ───────────────────────────────────────────────────────────────
+// ── TaskCreate schema ──────────────────────────────────────────────────────────
 
-export const TaskSchema = Type.Object({
-	id: Type.Optional(
+export const TodoCreateParams = Type.Object({
+	content: Type.String({
+		description: "A brief, actionable title in imperative form (e.g., 'Fix authentication bug in login flow').",
+	}),
+	description: Type.Optional(
+		Type.String({
+			description: "Detailed description of what needs to be done, including context and acceptance criteria.",
+		}),
+	),
+	priority: Type.Optional(
+		StringEnum(["high", "medium", "low"] as const, { description: "Task priority. Defaults to 'medium'." }),
+	),
+	activeForm: Type.Optional(
 		Type.String({
 			description:
-				"Unique task ID. Omit to auto-generate. " +
-				"When updating existing tasks use their current ID to preserve identity.",
+				"Present continuous form shown in the spinner when in_progress (e.g., 'Fixing authentication bug').",
 		}),
 	),
-	content: Type.String({
-		description: "Clear, actionable task description.",
-	}),
-	status: StringEnum(["pending", "in_progress", "completed"] as const, {
-		description:
-			"Task status. " +
-			"Set to 'in_progress' for the task you are actively working on right now. " +
-			"Only one task should be 'in_progress' at a time unless tasks are genuinely parallel.",
-	}),
-	priority: StringEnum(["high", "medium", "low"] as const, {
-		description: "Task priority.",
-	}),
+	metadata: Type.Optional(
+		Type.Record(Type.String(), Type.Any(), { description: "Arbitrary key-value metadata to attach to the task." }),
+	),
 });
 
-export const TodoWriteParams = Type.Object({
-	tasks: Type.Array(TaskSchema, {
-		description:
-			"The COMPLETE, updated task list. " +
-			"This REPLACES the current list entirely — always include ALL tasks, " +
-			"both updated ones and unchanged ones.",
-	}),
+// ── TaskGet schema ─────────────────────────────────────────────────────────────
+
+export const TodoGetParams = Type.Object({
+	id: Type.String({ description: "The task ID to retrieve." }),
 });
 
+// ── TaskUpdate schema ──────────────────────────────────────────────────────────
+
+export const TodoUpdateParams = Type.Object({
+	id: Type.String({ description: "The ID of the task to update." }),
+	status: Type.Optional(
+		Type.Unsafe<"pending" | "in_progress" | "completed" | "deleted">({
+			type: "string",
+			enum: ["pending", "in_progress", "completed", "deleted"],
+			description: "New status. Use 'deleted' to permanently remove the task.",
+		}),
+	),
+	content: Type.Optional(Type.String({ description: "New task title." })),
+	description: Type.Optional(Type.String({ description: "New task description." })),
+	priority: Type.Optional(StringEnum(["high", "medium", "low"] as const, { description: "New priority." })),
+	activeForm: Type.Optional(Type.String({ description: "Spinner text shown when in_progress." })),
+	owner: Type.Optional(Type.String({ description: "Owner / agent name." })),
+	metadata: Type.Optional(
+		Type.Record(Type.String(), Type.Any(), { description: "Metadata to merge. Set a key to null to delete it." }),
+	),
+	addBlocks: Type.Optional(
+		Type.Array(Type.String(), { description: "Task IDs that this task blocks (bidirectional)." }),
+	),
+	addBlockedBy: Type.Optional(
+		Type.Array(Type.String(), { description: "Task IDs that block this task (bidirectional)." }),
+	),
+});
+
+// ── Kept for backward compat (unused internally but may be imported by tests) ──
+
 export const TodoRemoveParams = Type.Object({
-	ids: Type.Array(Type.String(), {
-		description: "Task IDs to remove from the list permanently.",
-	}),
+	ids: Type.Array(Type.String(), { description: "Task IDs to remove from the list permanently." }),
 });

package/src/state.ts

@@ -1,123 +1,214 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Task, TaskDetails, TaskPriority, TaskStatus } from "./types";
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { Text, truncateToWidth } from "@earendil-works/pi-tui";
+import type { FileTaskStore } from "./file-store.js";
+import type { Task, TaskPriority, TaskStatus } from "./types.js";
 
-// ── TodoStore ──────────────────────────────────────────────────────────────────
+// ── Spinner ───────────────────────────────────────────────────────────────────
 
-export class TodoStore {
-	tasks: Task[] = [];
-	idCounter: number = 0;
+const SPINNER = ["✳", "✴", "✵", "✶", "✷", "✸", "✹", "✺", "✻", "✼", "✽"];
+const MAX_VISIBLE_TASKS = 10;
 
-	generateId(): string {
-		return `t${++this.idCounter}`;
+function formatDuration(ms: number): string {
+	const totalSec = Math.floor(ms / 1000);
+	if (totalSec < 60) return `${totalSec}s`;
+	const min = Math.floor(totalSec / 60);
+	const sec = totalSec % 60;
+	if (min < 60) return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+	const hr = Math.floor(min / 60);
+	const remMin = min % 60;
+	return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+}
+
+// ── TodoWidget ────────────────────────────────────────────────────────────────
+
+export class TodoWidget {
+	private uiCtx: ExtensionUIContext | undefined;
+	private store: FileTaskStore;
+	private widgetFrame = 0;
+	private widgetInterval: ReturnType<typeof setInterval> | undefined;
+	/** IDs of tasks currently active (show spinner). */
+	private activeTaskIds = new Set<string>();
+	/** Per-task start time for elapsed display. */
+	private taskStartedAt = new Map<string, number>();
+	private tui: any | undefined;
+	private widgetRegistered = false;
+
+	constructor(store: FileTaskStore) {
+		this.store = store;
 	}
 
-	activeTasks(): Task[] {
-		return this.tasks.filter((t) => t.status !== "completed");
+	setStore(store: FileTaskStore) {
+		this.store = store;
 	}
 
-	setTasks(next: Task[]): void {
-		this.tasks = next;
+	setUICtx(ctx: ExtensionUIContext) {
+		this.uiCtx = ctx;
 	}
 
-	syncIdCounter(): void {
-		for (const t of this.tasks) {
-			const m = t.id.match(/^t(\d+)$/);
-			if (m) this.idCounter = Math.max(this.idCounter, parseInt(m[1]!, 10));
+	setActiveTask(taskId: string | undefined, active = true) {
+		if (taskId && active) {
+			this.activeTaskIds.add(taskId);
+			if (!this.taskStartedAt.has(taskId)) this.taskStartedAt.set(taskId, Date.now());
+			this.ensureTimer();
+		} else if (taskId) {
+			this.activeTaskIds.delete(taskId);
+			this.taskStartedAt.delete(taskId);
 		}
+		this.update();
 	}
 
-	removeByIds(ids: string[]): string[] {
-		const removed: string[] = [];
-		this.tasks = this.tasks.filter((t) => {
-			if (ids.includes(t.id)) {
-				removed.push(t.id);
-				return false;
-			}
-			return true;
-		});
-		return removed;
+	private ensureTimer() {
+		if (!this.widgetInterval) {
+			this.widgetInterval = setInterval(() => this.update(), 200);
+		}
 	}
 
-	/** Apply status transitions and stamp timestamps accordingly. */
-	applyStatusTransitions(updated: Task[]): void {
-		const now = Date.now();
-		const existing = new Map(this.tasks.map((t) => [t.id, t]));
-
-		for (const task of updated) {
-			const prev = existing.get(task.id);
-			if (!prev) {
-				// New task — set createdAt
-				task.createdAt = task.createdAt ?? now;
-				if (task.status === "in_progress") task.startedAt = now;
-				if (task.status === "completed") {
-					task.startedAt = task.startedAt ?? now;
-					task.completedAt = now;
-				}
-				continue;
-			}
-			// Existing task — carry forward timestamps, apply transitions
-			task.createdAt = prev.createdAt;
-			task.startedAt = prev.startedAt;
-			task.completedAt = prev.completedAt;
+	private renderWidget(tui: any, theme: any): string[] {
+		const tasks = this.store.list();
+		const w: number = tui.terminal?.columns ?? 80;
+		const truncate = (line: string) => truncateToWidth(line, w);
+
+		if (tasks.length === 0) return [];
+
+		const completed = tasks.filter((t) => t.status === "completed");
+		const inProgress = tasks.filter((t) => t.status === "in_progress");
+		const pending = tasks.filter((t) => t.status === "pending");
+
+		const parts: string[] = [];
+		if (completed.length > 0) parts.push(`${completed.length} done`);
+		if (inProgress.length > 0) parts.push(`${inProgress.length} in progress`);
+		if (pending.length > 0) parts.push(`${pending.length} open`);
+		const statusText = `${tasks.length} task${tasks.length !== 1 ? "s" : ""} (${parts.join(", ")})`;
+
+		const spinnerChar = SPINNER[this.widgetFrame % SPINNER.length];
+		const lines: string[] = [truncate(`${theme.fg("accent", "●")} ${theme.fg("accent", statusText)}`)];
 
-			if (prev.status !== "in_progress" && task.status === "in_progress") {
-				task.startedAt = now;
+		const visible = tasks.slice(0, MAX_VISIBLE_TASKS);
+		for (const task of visible) {
+			const isActive = this.activeTaskIds.has(task.id) && task.status === "in_progress";
+
+			let icon: string;
+			if (isActive) {
+				icon = theme.fg("accent", spinnerChar);
+			} else if (task.status === "completed") {
+				icon = theme.fg("success", "✔");
+			} else if (task.status === "in_progress") {
+				icon = theme.fg("accent", "◼");
+			} else {
+				icon = "◻";
 			}
-			if (prev.status !== "completed" && task.status === "completed") {
-				task.startedAt = task.startedAt ?? now;
-				task.completedAt = now;
+
+			// Blocked-by suffix
+			let suffix = "";
+			if (task.status === "pending" && task.blockedBy.length > 0) {
+				const openBlockers = task.blockedBy.filter((bid) => {
+					const blocker = this.store.get(bid);
+					return blocker && blocker.status !== "completed";
+				});
+				if (openBlockers.length > 0) {
+					suffix = theme.fg("dim", ` › blocked by ${openBlockers.map((id) => `#${id}`).join(", ")}`);
+				}
 			}
-			// If reverted from completed back to in_progress/pending, clear completedAt
-			if (prev.status === "completed" && task.status !== "completed") {
-				task.completedAt = undefined;
+
+			let text: string;
+			if (isActive) {
+				const form = task.activeForm || task.content;
+				const startedAt = this.taskStartedAt.get(task.id) ?? Date.now();
+				const elapsed = formatDuration(Date.now() - startedAt);
+				const stats = theme.fg("dim", `(${elapsed})`);
+				text = `  ${icon} ${theme.fg("accent", `${form}…`)} ${stats}`;
+			} else if (task.status === "completed") {
+				text = `  ${icon} ${theme.fg("dim", theme.strikethrough(task.content))}`;
+			} else {
+				text = `  ${icon} ${task.content}`;
 			}
+
+			lines.push(truncate(text + suffix));
 		}
-	}
-}
 
-// ── Singleton ──────────────────────────────────────────────────────────────────
+		if (tasks.length > MAX_VISIBLE_TASKS) {
+			lines.push(truncate(theme.fg("dim", `    … and ${tasks.length - MAX_VISIBLE_TASKS} more`)));
+		}
 
-export const store = new TodoStore();
+		return lines;
+	}
 
-// ── Session reconstruction ─────────────────────────────────────────────────────
+	update() {
+		if (!this.uiCtx) return;
+		const tasks = this.store.list();
+
+		if (tasks.length === 0) {
+			if (this.widgetRegistered) {
+				this.uiCtx.setWidget("pi-todo", undefined);
+				this.uiCtx.setStatus("pi-todo", undefined);
+				this.widgetRegistered = false;
+			}
+			if (this.widgetInterval) {
+				clearInterval(this.widgetInterval);
+				this.widgetInterval = undefined;
+			}
+			return;
+		}
 
-export function reconstructState(ctx: ExtensionContext): void {
-	store.tasks = [];
-	store.idCounter = 0;
+		// Prune stale active IDs
+		for (const id of this.activeTaskIds) {
+			const t = this.store.get(id);
+			if (!t || t.status !== "in_progress") {
+				this.activeTaskIds.delete(id);
+				this.taskStartedAt.delete(id);
+			}
+		}
 
-	for (const entry of ctx.sessionManager.getBranch()) {
-		if (entry.type !== "message") continue;
-		const msg = entry.message;
-		if (msg.role !== "toolResult" || msg.toolName !== "todo_write") continue;
-		const details = msg.details as TaskDetails | undefined;
-		if (details?.tasks) {
-			store.tasks = details.tasks;
-			store.syncIdCounter();
+		const hasActiveSpinner = tasks.some((t) => this.activeTaskIds.has(t.id) && t.status === "in_progress");
+		if (hasActiveSpinner) {
+			this.ensureTimer();
+		} else if (this.widgetInterval) {
+			clearInterval(this.widgetInterval);
+			this.widgetInterval = undefined;
 		}
-	}
-}
 
-// ── Status bar ─────────────────────────────────────────────────────────────────
+		this.widgetFrame++;
 
-export function updateWidget(ctx: ExtensionContext): void {
-	const active = store.activeTasks();
+		if (!this.widgetRegistered) {
+			this.uiCtx.setWidget(
+				"pi-todo",
+				(tui, theme) => {
+					this.tui = tui;
+					return {
+						render: () => this.renderWidget(tui, theme),
+						invalidate: () => {},
+					};
+				},
+				{ placement: "aboveEditor" },
+			);
+			this.widgetRegistered = true;
 
-	if (active.length === 0) {
-		ctx.ui.setWidget("pi-todo", undefined);
-		ctx.ui.setStatus("pi-todo", undefined);
-		return;
+			// Also set status bar
+			const active = tasks.filter((t) => t.status !== "completed");
+			const inProg = active.filter((t) => t.status === "in_progress");
+			const doneCount = tasks.filter((t) => t.status === "completed").length;
+			const th = this.uiCtx.theme;
+			const parts: string[] = [];
+			if (inProg.length > 0) parts.push(th.fg("accent", `● ${inProg.length} active`));
+			if (doneCount > 0) parts.push(th.fg("success", `✓ ${doneCount} done`));
+			this.uiCtx.setStatus("pi-todo", parts.join("  "));
+		} else if (this.tui) {
+			this.tui.requestRender();
+		}
 	}
 
-	const th = ctx.ui.theme;
-	const inProg = active.filter((t) => t.status === "in_progress");
-	const pending = active.filter((t) => t.status === "pending");
-	const doneCount = store.tasks.filter((t) => t.status === "completed").length;
-
-	const parts: string[] = [];
-	if (inProg.length > 0) parts.push(th.fg("accent", `● ${inProg.length} active`));
-	if (pending.length > 0) parts.push(th.fg("muted", `○ ${pending.length} pending`));
-	if (doneCount > 0) parts.push(th.fg("success", `✓ ${doneCount} done`));
-	ctx.ui.setStatus("pi-todo", parts.join("  "));
+	dispose() {
+		if (this.widgetInterval) {
+			clearInterval(this.widgetInterval);
+			this.widgetInterval = undefined;
+		}
+		if (this.uiCtx) {
+			this.uiCtx.setWidget("pi-todo", undefined);
+			this.uiCtx.setStatus("pi-todo", undefined);
+		}
+		this.widgetRegistered = false;
+		this.tui = undefined;
+	}
 }
 
 // ── Shared rendering helpers ───────────────────────────────────────────────────
@@ -133,15 +224,51 @@ export function priorityColor(p: TaskPriority): "error" | "warning" | "dim" {
 }
 
 export function priorityLabel(p: TaskPriority): string {
-	return p.toUpperCase().slice(0, 1) + p.slice(1);
+	return p.charAt(0).toUpperCase() + p.slice(1);
 }
 
 export function statusIcon(status: TaskStatus): string {
-	return STATUS_ICON[status];
+	if (status === "completed") return "✓";
+	if (status === "in_progress") return "●";
+	return "○";
 }
 
-const STATUS_ICON: Record<TaskStatus, string> = {
-	pending: "○",
-	in_progress: "●",
-	completed: "✓",
-};
+// ── Tool result rendering (inline) ─────────────────────────────────────────────
+
+export function renderTaskListResult(tasks: Task[], expanded: boolean, theme: any): any {
+	if (!tasks?.length) return new Text(theme.fg("dim", "Task list cleared"), 0, 0);
+
+	const doneCount = tasks.filter((t) => t.status === "completed").length;
+	const inProgCount = tasks.filter((t) => t.status === "in_progress").length;
+	const total = tasks.length;
+
+	const parts: string[] = [];
+	if (inProgCount > 0) parts.push(theme.fg("accent", `● ${inProgCount} active`));
+	parts.push(theme.fg("success", `✓ ${doneCount}/${total} done`));
+	let output = parts.join("  ");
+
+	const display = expanded ? tasks : tasks.slice(0, 5);
+	for (const t of display) {
+		const icon =
+			t.status === "completed"
+				? theme.fg("success", "✓")
+				: t.status === "in_progress"
+					? theme.fg("accent", "●")
+					: theme.fg("dim", "○");
+		const pColor = priorityColor(t.priority);
+		const pLabel = theme.fg(pColor, priorityLabel(t.priority));
+		const content =
+			t.status === "completed"
+				? theme.fg("dim", theme.strikethrough(t.content))
+				: t.status === "in_progress"
+					? theme.fg("text", theme.bold(t.content))
+					: theme.fg("muted", t.content);
+		output += `\n${icon} ${pLabel}  ${content}`;
+	}
+
+	if (!expanded && tasks.length > 5) {
+		output += `\n${theme.fg("dim", `... ${tasks.length - 5} more`)}`;
+	}
+
+	return new Text(output, 0, 0);
+}