@agnishc/edb-todo 0.10.8 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.12.0] - 2026-05-22
+
+## [0.10.9] - 2026-05-18
+
+### Added
+- **Subtask support** — `TaskCreate` gains optional `parentId` param; tasks with a `parentId` render as indented subtasks in the widget
+- **Parallel group support** — `TaskCreate` gains optional `groupId` param; tasks in the same group are treated as parallel; a downstream task can set `blockedByGroup` to wait until all tasks in the group complete
+- **`blocked` status** — new task lifecycle state for in-progress tasks waiting for a supervisor answer; widget renders ⏸ with question preview
+- **`blockQuestion` / `blockMessageId` / `blockedAt` fields** — store the pending question text and bridge message ID when a task is blocked
+- **Attribution display** — tasks where `owner` is set show `[agent-id]` in the widget; orchestrator-created tasks (no owner) show no annotation
+- **Tree widget rendering** — widget now shows tasks followed by their subtasks (indented), replacing the flat list
+- **`blocked` count in widget header** — summary line shows blocked task count in warning colour
+- **edb-bridge integration** — listens for `bridge:task_updated` events and refreshes widget when a sub-agent writes to the shared store; emits `bridge:task_updated` after every task mutation so the parent session widget stays in sync
+- **`todo:store_path` event** — emits the active store file path so edb-subagents can inject it into sub-agent system prompts
+- **System prompt store injection** — reads `<task_store_path>` XML tag from the system prompt (injected by edb-subagents at spawn time) to point sub-agent sessions at the parent's shared task store
+- **`isGroupComplete()` / `getReadyTasks()`** — new store helpers for group-join resolution
+
+### Changed
+- `TaskList` output now includes subtask annotation (`[subtask of #id]`), owner, blocked question preview, and group wait status
+- `TaskGet` output now includes `parentId`, `groupId`, `blockedByGroup`, and blocked question details
+- `TaskUpdate` handles `blocked` status transitions: sets `blockedAt`, clears `blockQuestion`/`blockMessageId` on unblock
+- Widget `MAX_VISIBLE_TASKS` raised from 10 to 12
+- `statusOrder` in `TaskList` updated to include `blocked` (ordered after `in_progress`)
+
 ## [0.10.8] - 2026-05-18
 
 ## [0.10.6] - 2026-05-15

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agnishc/edb-todo",
-	"version": "0.10.8",
+	"version": "0.12.0",
 	"description": "Pi extension: structured task list with live widget and system-prompt injection to prevent goal drift",
 	"keywords": [
 		"pi-package",

package/src/component.ts

@@ -191,6 +191,7 @@ export class TodoViewComponent {
 		}
 
 		const idHint = th.fg("dim", ` [${task.id}]`);
+		const ownerHint = task.owner ? th.fg("dim", ` [${task.owner}]`) : "";
 		const cursor = isFocused ? th.fg("accent", "❯") : " ";
 
 		// Dependency hint
@@ -208,7 +209,7 @@ export class TodoViewComponent {
 			depHint += th.fg("dim", ` → blocks ${task.blocks.map((id) => `#${id}`).join(", ")}`);
 		}
 
-		return [truncateToWidth(`  ${cursor} ${icon} ${pLabel}  ${contentText}${idHint}${depHint}`, width)];
+		return [truncateToWidth(`  ${cursor} ${icon} ${pLabel}  ${contentText}${idHint}${ownerHint}${depHint}`, width)];
 	}
 
 	private rebuildFlatTasks(): void {

package/src/file-store.ts

@@ -63,6 +63,16 @@ export class FileTaskStore {
 	private filePath: string | undefined;
 	private lockPath: string | undefined;
 
+	/** The file path this store persists to. Undefined for in-memory stores. */
+	get path(): string | undefined {
+		return this.filePath;
+	}
+
+	/** Force-reload from disk (useful when another process may have written to the store). */
+	reload(): void {
+		this.load();
+	}
+
 	private nextId = 1;
 	private tasks = new Map<string, Task>();
 
@@ -87,6 +97,7 @@ export class FileTaskStore {
 				if (!t.blocks) t.blocks = [];
 				if (!t.blockedBy) t.blockedBy = [];
 				if (!t.updatedAt) t.updatedAt = t.createdAt;
+				// New fields — default to undefined (no migration needed, optional)
 				this.tasks.set(t.id, t);
 			}
 		} catch {
@@ -94,6 +105,35 @@ export class FileTaskStore {
 		}
 	}
 
+	/**
+	 * Check if a parallel group is fully complete (all tasks with that groupId are completed).
+	 * Used to resolve blockedByGroup dependencies.
+	 */
+	isGroupComplete(groupId: string): boolean {
+		const groupTasks = Array.from(this.tasks.values()).filter((t) => t.groupId === groupId);
+		if (groupTasks.length === 0) return true; // no tasks in group — treat as complete
+		return groupTasks.every((t) => t.status === "completed");
+	}
+
+	/**
+	 * Get all tasks that are ready to start:
+	 * - status === "pending"
+	 * - no open blockedBy tasks
+	 * - blockedByGroup is resolved (if set)
+	 */
+	getReadyTasks(): Task[] {
+		return this.list().filter((t) => {
+			if (t.status !== "pending") return false;
+			const hasOpenBlocker = t.blockedBy.some((bid) => {
+				const b = this.tasks.get(bid);
+				return b && b.status !== "completed";
+			});
+			if (hasOpenBlocker) return false;
+			if (t.blockedByGroup && !this.isGroupComplete(t.blockedByGroup)) return false;
+			return true;
+		});
+	}
+
 	private save(): void {
 		if (!this.filePath) return;
 		const data: TaskStoreData = {
@@ -141,6 +181,9 @@ export class FileTaskStore {
 			description?: string;
 			priority?: TaskPriority;
 			activeForm?: string;
+			owner?: string;
+			parentId?: string;
+			groupId?: string;
 			metadata?: Record<string, any>;
 		},
 	): Task {
@@ -153,7 +196,9 @@ export class FileTaskStore {
 				status: "pending",
 				priority: opts?.priority ?? "medium",
 				activeForm: opts?.activeForm,
-				owner: undefined,
+				owner: opts?.owner,
+				parentId: opts?.parentId,
+				groupId: opts?.groupId,
 				metadata: opts?.metadata ?? {},
 				blocks: [],
 				blockedBy: [],
@@ -198,6 +243,11 @@ export class FileTaskStore {
 			priority?: TaskPriority;
 			activeForm?: string;
 			owner?: string;
+			parentId?: string;
+			groupId?: string;
+			blockedByGroup?: string;
+			blockQuestion?: string;
+			blockMessageId?: string;
 			metadata?: Record<string, any>;
 			addBlocks?: string[];
 			addBlockedBy?: string[];
@@ -223,6 +273,15 @@ export class FileTaskStore {
 			const now = Date.now();
 
 			if (fields.status !== undefined) {
+				// blockedByGroup enforcement: reject in_progress if the group is not yet complete
+				if (fields.status === "in_progress" && task.blockedByGroup && !this.isGroupComplete(task.blockedByGroup)) {
+					warnings.push(
+						`Cannot set status to in_progress: task is waiting for group [${task.blockedByGroup}] which is not yet complete. ` +
+							`Complete all tasks in that group first, or remove blockedByGroup from this task.`,
+					);
+					// Return early — do not apply any changes
+					return { task, changedFields: [], warnings };
+				}
 				// Timestamp transitions
 				if (task.status !== "in_progress" && fields.status === "in_progress") task.startedAt = now;
 				if (task.status !== "completed" && fields.status === "completed") {
@@ -232,6 +291,14 @@ export class FileTaskStore {
 				if (task.status === "completed" && fields.status !== "completed") {
 					task.completedAt = undefined;
 				}
+				if (fields.status === "blocked") {
+					task.blockedAt = now;
+				} else if ((task.status as string) === "blocked") {
+					// Was blocked, now transitioning to a different status — clear block metadata
+					task.blockedAt = undefined;
+					if (!fields.blockQuestion) task.blockQuestion = undefined;
+					if (!fields.blockMessageId) task.blockMessageId = undefined;
+				}
 				task.status = fields.status;
 				changedFields.push("status");
 			}
@@ -255,6 +322,26 @@ export class FileTaskStore {
 				task.owner = fields.owner;
 				changedFields.push("owner");
 			}
+			if (fields.parentId !== undefined) {
+				task.parentId = fields.parentId;
+				changedFields.push("parentId");
+			}
+			if (fields.groupId !== undefined) {
+				task.groupId = fields.groupId;
+				changedFields.push("groupId");
+			}
+			if (fields.blockedByGroup !== undefined) {
+				task.blockedByGroup = fields.blockedByGroup;
+				changedFields.push("blockedByGroup");
+			}
+			if (fields.blockQuestion !== undefined) {
+				task.blockQuestion = fields.blockQuestion;
+				changedFields.push("blockQuestion");
+			}
+			if (fields.blockMessageId !== undefined) {
+				task.blockMessageId = fields.blockMessageId;
+				changedFields.push("blockMessageId");
+			}
 
 			if (fields.metadata !== undefined) {
 				for (const [key, value] of Object.entries(fields.metadata)) {

package/src/index.ts

@@ -36,6 +36,11 @@ const SYSTEM_REMINDER = `<system-reminder>
 The task tools haven't been used recently. If you're working on tasks that would benefit from tracking progress, consider using TaskCreate to add new tasks and TaskUpdate to update task status (set to in_progress when starting, completed when done). Also consider cleaning up the task list if it has become stale. Only use these if relevant to the current work. This is just a gentle reminder - ignore if not applicable. Make sure that you NEVER mention this reminder to the user
 </system-reminder>`;
 
+// Internal pi.events: edb-bridge emits this when a task_updated message arrives (from sub-agent)
+const EV_BRIDGE_TASK_UPDATED = "bridge:task_updated";
+// We emit this so edb-subagents can read the store path
+const EV_TODO_STORE_PATH = "todo:store_path";
+
 // ── Extension ──────────────────────────────────────────────────────────────────
 
 export default function todoExtension(pi: ExtensionAPI): void {
@@ -66,6 +71,112 @@ export default function todoExtension(pi: ExtensionAPI): void {
 		() => cfg.autoClearCompleted ?? "on_list_complete",
 		AUTO_CLEAR_DELAY,
 	);
+	/** The pi session ID of the current (or most recently started) session. */
+	let currentSessionId: string | null = null;
+
+	// Expose store path to other extensions (edb-subagents reads this to inject PI_TODO into sub-agents)
+	function emitStorePath() {
+		const p = store.path;
+		if (p) pi.events.emit(EV_TODO_STORE_PATH, { path: p });
+	}
+
+	// Listen for bridge:task_updated (emitted by edb-bridge when a sub-agent updates a task)
+	// Re-reads the store and refreshes the widget
+	pi.events.on(EV_BRIDGE_TASK_UPDATED, () => {
+		// Force a re-read from disk (sub-agent may have written to the shared file)
+		if (store.path) {
+			try {
+				store.reload();
+			} catch {
+				/* ignore */
+			}
+		}
+		widget.update();
+	});
+
+	// Listen for bridge:notify_parent — sub-agent progress update with optional task_id
+	// When task_id is provided, update the task's activeForm so it shows in the spinner
+	pi.events.on("bridge:notify_parent", (payload: unknown) => {
+		const p = payload as { taskId?: string; message?: string; agentId?: string } | undefined;
+		if (!p?.taskId || !p.message) return;
+		try {
+			// Update activeForm on the task so the widget spinner shows the progress message
+			store.update(p.taskId, { activeForm: p.message.slice(0, 80) });
+			widget.update();
+		} catch {
+			/* ignore */
+		}
+	});
+
+	// Listen for bridge:ask_supervisor — sub-agent called ask_supervisor with a task_id
+	// Auto-block the linked task so the widget shows ⏸ with the question text
+	pi.events.on("bridge:ask_supervisor", (payload: unknown) => {
+		const p = payload as { taskId?: string; question?: string; messageId?: string } | undefined;
+		if (!p?.taskId || !p.question) return;
+		try {
+			store.update(p.taskId, {
+				status: "blocked",
+				blockQuestion: p.question,
+				blockMessageId: p.messageId,
+			});
+			widget.update();
+		} catch {
+			/* ignore */
+		}
+	});
+
+	// Listen for bridge:supervisor_answered — orchestrator answered, unblock the task
+	pi.events.on("bridge:supervisor_answered", (payload: unknown) => {
+		const p = payload as { taskId?: string } | undefined;
+		if (!p?.taskId) return;
+		try {
+			// Transition back to in_progress and clear block metadata
+			store.update(p.taskId, { status: "in_progress" });
+			widget.update();
+		} catch {
+			/* ignore */
+		}
+	});
+
+	// Listen for todo:update_task — edb-subagents requests a task status update
+	// This avoids edb-subagents duplicating FileTaskStore write logic
+	pi.events.on("todo:update_task", (payload: unknown) => {
+		const p = payload as { taskId?: string; fields?: { status?: string; owner?: string } } | undefined;
+		if (!p?.taskId || !p.fields) return;
+		try {
+			store.update(p.taskId, p.fields as any);
+			widget.update();
+			// Notify bridge to propagate refresh to parent if we're in a sub-agent store
+			notifyBridgeOnChange();
+		} catch {
+			/* ignore */
+		}
+	});
+
+	// Parse task store path from system prompt (for sub-agent sessions)
+	let storePathFromPromptParsed = false;
+
+	function maybeOverrideStoreFromPrompt(systemPrompt: string, _sessionId: string) {
+		if (storePathFromPromptParsed) return;
+		storePathFromPromptParsed = true;
+		const match = systemPrompt.match(/<task_store_path>(.*?)<\/task_store_path>/s);
+		if (!match) return;
+		const path = match[1]!.trim();
+		if (path && path !== store.path) {
+			store = new FileTaskStore(path);
+			widget.setStore(store);
+			autoClear.getStore = () => store;
+			storeUpgraded = true; // prevent upgradeStoreIfNeeded from overriding
+			emitStorePath();
+		}
+	}
+
+	// Helper to emit task_updated through bridge (so parent session widget refreshes)
+	function notifyBridgeOnChange() {
+		// Only route to parent when this is a sub-agent session (store was overridden from system prompt)
+		if (!storeUpgraded) return;
+		pi.events.emit(EV_BRIDGE_TASK_UPDATED, { storePath: store.path, sessionId: currentSessionId });
+	}
 
 	let storeUpgraded = false;
 	let persistedTasksShown = false;
@@ -81,6 +192,7 @@ export default function todoExtension(pi: ExtensionAPI): void {
 			}
 		}
 		storeUpgraded = true;
+		emitStorePath();
 	}
 
 	function showPersistedTasks(isResume = false) {
@@ -132,7 +244,10 @@ export default function todoExtension(pi: ExtensionAPI): void {
 	pi.on("before_agent_start", async (event, ctx) => {
 		cwd = ctx.cwd;
 		cfg = loadTodoConfig(cwd);
+		currentSessionId = ctx.sessionManager.getSessionId();
 		widget.setUICtx(ctx.ui);
+		// For sub-agent sessions: read store path from system prompt (injected by edb-subagents)
+		maybeOverrideStoreFromPrompt(event.systemPrompt, ctx.sessionManager.getSessionId());
 		upgradeStoreIfNeeded(ctx.sessionManager.getSessionId());
 		showPersistedTasks();
 		const block = buildSystemPromptBlock(store);
@@ -150,8 +265,10 @@ export default function todoExtension(pi: ExtensionAPI): void {
 		const isResume = event.reason === "resume";
 		cwd = ctx.cwd;
 		cfg = loadTodoConfig(cwd);
+		currentSessionId = ctx.sessionManager.getSessionId();
 		storeUpgraded = false;
 		persistedTasksShown = false;
+		storePathFromPromptParsed = false;
 		currentTurn = 0;
 		lastTaskToolUseTurn = 0;
 		reminderInjectedThisCycle = false;
@@ -224,8 +341,11 @@ All tasks are created with status \`pending\`.
 				description: params.description,
 				priority: params.priority as TaskPriority | undefined,
 				activeForm: params.activeForm,
+				parentId: params.parentId as string | undefined,
+				groupId: params.groupId as string | undefined,
 				metadata: params.metadata,
 			});
+			notifyBridgeOnChange();
 			widget.setUICtx(ctx.ui);
 			widget.update();
 			return {
@@ -286,7 +406,7 @@ Use TaskGet with a specific task ID to view full details including description.`
 					details: { tasks: [] } satisfies TaskDetails,
 				};
 
-			const statusOrder: Record<string, number> = { pending: 0, in_progress: 1, completed: 2 };
+			const statusOrder: Record<string, number> = { pending: 0, in_progress: 1, blocked: 2, completed: 3 };
 			const sorted = [...tasks].sort((a, b) => {
 				const so = (statusOrder[a.status] ?? 0) - (statusOrder[b.status] ?? 0);
 				if (so !== 0) return so;
@@ -295,11 +415,19 @@ Use TaskGet with a specific task ID to view full details including description.`
 
 			const lines = sorted.map((task) => {
 				let line = `[${task.status}] [${task.priority}] #${task.id} ${task.content}`;
+				if (task.parentId) line += ` [subtask of #${task.parentId}]`;
+				if (task.owner) line += ` [owner: ${task.owner}]`;
+				if (task.status === "blocked" && task.blockQuestion) {
+					line += ` [blocked: "${task.blockQuestion.slice(0, 60)}"]`;
+				}
 				const openBlockers = task.blockedBy.filter((bid) => {
 					const b = store.get(bid);
 					return b && b.status !== "completed";
 				});
 				if (openBlockers.length > 0) line += ` [blocked by ${openBlockers.map((id) => `#${id}`).join(", ")}]`;
+				if (task.blockedByGroup && !store.isGroupComplete(task.blockedByGroup)) {
+					line += ` [waiting for group: ${task.blockedByGroup}]`;
+				}
 				return line;
 			});
 
@@ -363,6 +491,15 @@ Returns full task details:
 				`Priority: ${task.priority}`,
 			];
 			if (task.owner) lines.push(`Owner: ${task.owner}`);
+			if (task.parentId) lines.push(`Subtask of: #${task.parentId}`);
+			if (task.groupId) lines.push(`Parallel group: ${task.groupId}`);
+			if (task.blockedByGroup) {
+				const groupDone = store.isGroupComplete(task.blockedByGroup);
+				lines.push(`Blocked by group: ${task.blockedByGroup} (${groupDone ? "resolved" : "waiting"})`);
+			}
+			if (task.status === "blocked" && task.blockQuestion) {
+				lines.push(`Blocked waiting for answer: "${task.blockQuestion}"`);
+			}
 			lines.push(`Description: ${desc}`);
 
 			const openBlockers = task.blockedBy.filter((bid) => {
@@ -471,6 +608,14 @@ Set dependencies:
 				};
 			}
 
+			// Early return from enforcement (e.g. blockedByGroup)
+			if (changedFields.length === 0 && warnings.length > 0) {
+				return {
+					content: [{ type: "text", text: `⚠ Not updated: ${warnings.join("; ")}` }],
+					details: { tasks: [...store.list()] } satisfies TaskDetails,
+				};
+			}
+
 			if (fields.status === "in_progress") {
 				widget.setActiveTask(id);
 				autoClear.resetBatchCountdown();
@@ -481,8 +626,11 @@ Set dependencies:
 				autoClear.trackCompletion(id, currentTurn);
 			} else if (fields.status === "deleted") {
 				widget.setActiveTask(id, false);
+			} else if (fields.status === "blocked") {
+				widget.setActiveTask(id, false); // stop spinner while blocked
 			}
 
+			notifyBridgeOnChange();
 			widget.setUICtx(ctx.ui);
 			widget.update();
 

package/src/schemas.ts

@@ -21,6 +21,18 @@ export const TodoCreateParams = Type.Object({
 				"Present continuous form shown in the spinner when in_progress (e.g., 'Fixing authentication bug').",
 		}),
 	),
+	parentId: Type.Optional(
+		Type.String({
+			description: "Parent task ID. Creates this as a subtask of the specified task.",
+		}),
+	),
+	groupId: Type.Optional(
+		Type.String({
+			description:
+				"Parallel group ID. Tasks with the same groupId run concurrently. " +
+				"A task with blockedByGroup pointing to this groupId starts only when ALL group tasks complete.",
+		}),
+	),
 	metadata: Type.Optional(
 		Type.Record(Type.String(), Type.Any(), { description: "Arbitrary key-value metadata to attach to the task." }),
 	),
@@ -37,10 +49,13 @@ export const TodoGetParams = Type.Object({
 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.Unsafe<"pending" | "in_progress" | "completed" | "blocked" | "failed" | "deleted">({
 			type: "string",
-			enum: ["pending", "in_progress", "completed", "deleted"],
-			description: "New status. Use 'deleted' to permanently remove the task.",
+			enum: ["pending", "in_progress", "completed", "blocked", "failed", "deleted"],
+			description:
+				"New status. Use 'deleted' to permanently remove the task. " +
+				"Use 'blocked' when the task is waiting for an answer from the supervisor (set blockQuestion too). " +
+				"Use 'failed' when the task errored or the assigned sub-agent aborted.",
 		}),
 	),
 	content: Type.Optional(Type.String({ description: "New task title." })),
@@ -48,6 +63,14 @@ export const TodoUpdateParams = Type.Object({
 	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." })),
+	blockQuestion: Type.Optional(
+		Type.String({ description: "Question text when setting status to 'blocked' (waiting for supervisor answer)." }),
+	),
+	blockedByGroup: Type.Optional(
+		Type.String({
+			description: "Group ID to wait for. Task starts only when ALL tasks in this group are completed.",
+		}),
+	),
 	metadata: Type.Optional(
 		Type.Record(Type.String(), Type.Any(), { description: "Metadata to merge. Set a key to null to delete it." }),
 	),

package/src/state.ts

@@ -6,7 +6,7 @@ import type { Task, TaskPriority, TaskStatus } from "./types.js";
 // ── Spinner ───────────────────────────────────────────────────────────────────
 
 const SPINNER = ["✳", "✴", "✵", "✶", "✷", "✸", "✹", "✺", "✻", "✼", "✽"];
-const MAX_VISIBLE_TASKS = 10;
+const MAX_VISIBLE_TASKS = 12;
 
 function formatDuration(ms: number): string {
 	const totalSec = Math.floor(ms / 1000);
@@ -63,71 +63,130 @@ export class TodoWidget {
 		}
 	}
 
+	/** Render a single task row. indent=0 for top-level, indent=1 for subtasks. */
+	private renderTask(
+		task: Task,
+		isActive: boolean,
+		spinnerChar: string,
+		indent: number,
+		theme: any,
+		w: number,
+	): string {
+		const truncate = (line: string) => truncateToWidth(line, w);
+		const pad = `  ${"  ".repeat(indent)}`;
+
+		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 if (task.status === "blocked") {
+			icon = theme.fg("warning", "⏸");
+		} else if (task.status === "failed") {
+			icon = theme.fg("error", "✗");
+		} else {
+			icon = "◻";
+		}
+
+		// Attribution: show [owner] only when set (i.e. updated by a sub-agent)
+		const ownerTag = task.owner ? theme.fg("dim", ` [${task.owner}]`) : "";
+
+		let suffix = "";
+
+		if (task.status === "blocked" && task.blockQuestion) {
+			const preview = task.blockQuestion.slice(0, 50);
+			suffix = theme.fg("warning", ` waiting: "${preview}${task.blockQuestion.length > 50 ? "…" : ""}"`);
+		} else if (task.status === "pending") {
+			// Sequential blockedBy
+			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(", ")}`);
+			}
+			// Group blocker
+			if (!suffix && task.blockedByGroup && !this.store.isGroupComplete(task.blockedByGroup)) {
+				suffix = theme.fg("dim", ` › waiting for group [${task.blockedByGroup}]`);
+			}
+		}
+
+		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 = `${pad}${icon} ${theme.fg("accent", `${form}…`)} ${stats}${ownerTag}`;
+		} else if (task.status === "completed") {
+			text = `${pad}${icon} ${theme.fg("dim", theme.strikethrough(task.content))}${ownerTag}`;
+		} else if (task.status === "blocked") {
+			text = `${pad}${icon} ${theme.fg("muted", task.content)}${ownerTag}`;
+		} else if (task.status === "failed") {
+			text = `${pad}${icon} ${theme.fg("error", task.content)}${ownerTag}`;
+		} else {
+			text = `${pad}${icon} ${task.content}${ownerTag}`;
+		}
+
+		return truncate(text + suffix);
+	}
+
 	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 blocked = tasks.filter((t) => t.status === "blocked");
+		const failed = tasks.filter((t) => t.status === "failed");
 		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 (blocked.length > 0) parts.push(theme.fg("warning", `${blocked.length} blocked`));
+		if (failed.length > 0) parts.push(theme.fg("error", `${failed.length} failed`));
 		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)}`)];
-
-		const visible = tasks.slice(0, MAX_VISIBLE_TASKS);
-		for (const task of visible) {
-			const isActive = this.activeTaskIds.has(task.id) && task.status === "in_progress";
+		const spinnerChar = SPINNER[this.widgetFrame % SPINNER.length]!;
+		const lines: string[] = [truncateToWidth(`${theme.fg("accent", "●")} ${theme.fg("accent", statusText)}`, w)];
 
-			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 = "◻";
+		// Build subtask map for tree rendering
+		const childrenOf = new Map<string, Task[]>();
+		for (const t of tasks) {
+			if (t.parentId) {
+				const arr = childrenOf.get(t.parentId) ?? [];
+				arr.push(t);
+				childrenOf.set(t.parentId, arr);
 			}
+		}
 
-			// 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(", ")}`);
-				}
-			}
+		// Render top-level tasks followed by their subtasks
+		const topLevel = tasks.filter((t) => !t.parentId);
+		let rendered = 0;
 
-			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}`;
+		for (const task of topLevel) {
+			if (rendered >= MAX_VISIBLE_TASKS) break;
+			const isActive = this.activeTaskIds.has(task.id) && task.status === "in_progress";
+			lines.push(this.renderTask(task, isActive, spinnerChar, 0, theme, w));
+			rendered++;
+
+			const children = childrenOf.get(task.id) ?? [];
+			for (const child of children) {
+				if (rendered >= MAX_VISIBLE_TASKS) break;
+				const childActive = this.activeTaskIds.has(child.id) && child.status === "in_progress";
+				lines.push(this.renderTask(child, childActive, spinnerChar, 1, theme, w));
+				rendered++;
 			}
-
-			lines.push(truncate(text + suffix));
 		}
 
 		if (tasks.length > MAX_VISIBLE_TASKS) {
-			lines.push(truncate(theme.fg("dim", `    … and ${tasks.length - MAX_VISIBLE_TASKS} more`)));
+			lines.push(truncateToWidth(theme.fg("dim", `    … and ${tasks.length - MAX_VISIBLE_TASKS} more`), w));
 		}
 
 		return lines;
@@ -218,6 +277,7 @@ export function priorityLabel(p: TaskPriority): string {
 export function statusIcon(status: TaskStatus): string {
 	if (status === "completed") return "✓";
 	if (status === "in_progress") return "●";
+	if (status === "blocked") return "⏸";
 	return "○";
 }
 
@@ -228,10 +288,14 @@ export function renderTaskListResult(tasks: Task[], expanded: boolean, theme: an
 
 	const doneCount = tasks.filter((t) => t.status === "completed").length;
 	const inProgCount = tasks.filter((t) => t.status === "in_progress").length;
+	const blockedCount = tasks.filter((t) => t.status === "blocked").length;
+	const failedCount = tasks.filter((t) => t.status === "failed").length;
 	const total = tasks.length;
 
 	const parts: string[] = [];
 	if (inProgCount > 0) parts.push(theme.fg("accent", `● ${inProgCount} active`));
+	if (blockedCount > 0) parts.push(theme.fg("warning", `⏸ ${blockedCount} blocked`));
+	if (failedCount > 0) parts.push(theme.fg("error", `✗ ${failedCount} failed`));
 	parts.push(theme.fg("success", `✓ ${doneCount}/${total} done`));
 	let output = parts.join("  ");
 
@@ -242,16 +306,26 @@ export function renderTaskListResult(tasks: Task[], expanded: boolean, theme: an
 				? theme.fg("success", "✓")
 				: t.status === "in_progress"
 					? theme.fg("accent", "●")
-					: theme.fg("dim", "○");
+					: t.status === "blocked"
+						? theme.fg("warning", "⏸")
+						: t.status === "failed"
+							? theme.fg("error", "✗")
+							: theme.fg("dim", "○");
 		const pColor = priorityColor(t.priority);
 		const pLabel = theme.fg(pColor, priorityLabel(t.priority));
+		const ownerTag = t.owner ? theme.fg("dim", ` [${t.owner}]`) : "";
+		const subtaskIndent = t.parentId ? "  " : "";
 		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}`;
+					: t.status === "blocked"
+						? theme.fg("muted", t.content)
+						: t.status === "failed"
+							? theme.fg("error", t.content)
+							: theme.fg("muted", t.content);
+		output += `\n${subtaskIndent}${icon} ${pLabel}  ${content}${ownerTag}`;
 	}
 
 	if (!expanded && tasks.length > 5) {

package/src/types.ts

@@ -1,6 +1,6 @@
 // ── Types ──────────────────────────────────────────────────────────────────────
 
-export type TaskStatus = "pending" | "in_progress" | "completed";
+export type TaskStatus = "pending" | "in_progress" | "completed" | "blocked" | "failed";
 export type TaskPriority = "high" | "medium" | "low";
 
 export interface Task {
@@ -10,7 +10,12 @@ export interface Task {
 	status: TaskStatus;
 	priority: TaskPriority;
 	activeForm?: string; // spinner text when in_progress (e.g. "Running tests")
-	owner?: string; // agent name / owner
+	owner?: string; // agent name / owner — shown in widget only when set by a sub-agent
+	parentId?: string; // parent task ID (for subtasks)
+	groupId?: string; // parallel group ID — tasks in the same group run concurrently
+	blockedByGroup?: string; // groupId to wait for — unblocks when all group tasks are completed
+	blockQuestion?: string; // question text when status === "blocked" (waiting for supervisor answer)
+	blockMessageId?: string; // bridge message ID for the pending ask (resolved by answer_subagent)
 	metadata: Record<string, any>;
 	blocks: string[]; // task IDs this task blocks
 	blockedBy: string[]; // task IDs that block this task
@@ -18,6 +23,7 @@ export interface Task {
 	updatedAt: number;
 	startedAt?: number;
 	completedAt?: number;
+	blockedAt?: number; // when status changed to "blocked"
 }
 
 export interface TaskDetails {
@@ -36,6 +42,8 @@ export const STATUS_ICON: Record<TaskStatus, string> = {
 	pending: "○",
 	in_progress: "●",
 	completed: "✓",
+	blocked: "⏸",
+	failed: "✗",
 };
 
 export const PRIORITY_ORDER: Record<TaskPriority, number> = {