@agnishc/edb-todo 0.8.2 → 0.10.4

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.10.4] - 2026-05-15
+
+## [0.10.3] - 2026-05-15
+
+## [0.9.0] - 2026-05-15
+
+### Added
+- `todo_create` tool — create individual tasks with `content`, `description`, `priority`, `activeForm`, and `metadata`
+- `todo_get` tool — retrieve full task details: description, dependencies (`blocks`/`blockedBy`), metadata
+- `todo_update` tool — update individual tasks (status, content, description, priority, owner); add dependency edges (`addBlocks`/`addBlockedBy`); `status: "deleted"` permanently removes the task
+- **File-backed storage** — tasks now persist to disk with file locking and atomic writes
+  - `memory`: in-memory only (lost on session end)
+  - `session` *(default)*: per-session file at `<cwd>/.pi/tasks/tasks-<sessionId>.json`
+  - `project`: shared across all sessions at `<cwd>/.pi/tasks/tasks.json`
+- **Dependency management** — bidirectional `blocks`/`blockedBy` edges with cycle detection and warnings
+- **Auto-clear completed tasks** — configurable via settings: `never` / `on_list_complete` *(default)* / `on_task_complete`; turn-based delay so completions linger briefly before disappearing
+- **Settings panel** — `/todos → ⚙ Settings` opens a native TUI settings panel (taskScope + autoClearCompleted); saved to `<cwd>/.pi/tasks-config.json`
+- **System-reminder injection** — periodic `<system-reminder>` nudges appended to non-task tool results after `REMINDER_INTERVAL` turns of inactivity, encouraging the model to keep tasks up to date
+- **Enhanced widget** — animated star spinner (✳✴✵…) for in-progress tasks, elapsed time display (e.g. `42s`, `2m 5s`), blocked-by hints inline
+- `PI_TODO` environment variable override: `off` (memory only), named list (`~/.pi/tasks/<name>.json`), or absolute/relative path
+- `/todos` command now shows a select-based menu with View / Clear completed / Clear all / Settings
+
+### Changed
+- Widget placement changed from status bar to **above editor** (persistent, always visible)
+- Session state no longer reconstructed from tool-result branch entries — file-backed store is the source of truth
+- `todo_write` now merges `blocks`, `blockedBy`, and `metadata` from existing tasks when a task ID is reused (non-destructive for dependency edges)
+- System prompt injection now includes task IDs and blocked-by info
+- `priorityLabel` now correctly outputs `High`/`Medium`/`Low`
+
 ## [0.8.2] - 2026-05-11
 
 ### Added

package/README.md

@@ -2,54 +2,166 @@
 
 A Pi CLI extension that gives the agent a structured task list to prevent **goal drift** — the tendency for agents to lose track of the original plan as context grows and tool calls accumulate.
 
+## Features
+
+- **6 LLM tools** — `TaskCreate`, `TaskList`, `TaskGet`, `TaskUpdate`, `TaskOutput`, `TaskStop` — matching pi-tasks behavior
+- **Persistent widget** — live task list above the editor with animated spinner (✳✽), elapsed time, and blocked-by hints
+- **File-backed storage** — memory / session / project scope with file locking and atomic writes
+- **Dependency management** — bidirectional `blocks` / `blockedBy` edges with cycle detection
+- **Auto-clear completed tasks** — configurable: never / on_list_complete / on_task_complete
+- **System-reminder injection** — periodic nudges when task tools haven't been used recently
+- **Settings panel** — `/todos → ⚙ Settings` (task storage + auto-clear, saved to `tasks-config.json`)
+- **Priority system** — high / medium / low with color coding (Red / Yellow / Dim)
+
 ## How it works
 
-1. The agent calls `todo_write` to plan multi-step work as an explicit task list
-2. Before every agent turn, active tasks are injected into the system prompt so the model always knows what remains and what it's currently doing
-3. A live widget above the editor shows the current task list at all times
-4. State is reconstructed from the session branch, so `/tree` navigation and forking work correctly
-5. Completed tasks remain visible in the list — they are never auto-deleted, providing a full audit trail
+1. The agent uses `TaskCreate` to plan multi-step work as a structured task list
+2. Before every agent turn, active tasks are injected into the system prompt
+3. A live widget above the editor shows tasks with status icons and elapsed time for active tasks
+4. Tasks persist to disk per-session (or project-wide) and survive session resume
+5. Completed tasks remain visible until auto-cleared or manually removed
 
 ## Tools
 
-| Tool | Description |
-|------|-------------|
-| `todo_write` | Replace the entire task list (atomic update) — always pass all tasks |
-| `todo_read` | Read the current task list and statuses |
-| `todo_remove` | Permanently remove tasks by ID — use for cleanup, not for completed tasks |
+### `TaskCreate`
+
+Create a structured task. Used proactively for complex multi-step work.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `content` | string | ✓ | Brief actionable title in imperative form |
+| `description` | string | | Detailed context and acceptance criteria |
+| `priority` | `high` \| `medium` \| `low` | | Default: `medium` |
+| `activeForm` | string | | Spinner text when in_progress (e.g., "Running tests") |
+| `metadata` | object | | Arbitrary key-value pairs |
+
+### `TaskList`
+
+List all tasks sorted by status (pending first, then in_progress, then completed) and ID.
+
+Returns each task's id, content, status, priority, and open blockedBy entries.
+
+### `TaskGet`
+
+Get full details for a specific task by ID — including description, dependencies, and metadata.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The task ID |
 
-## Task statuses
+### `TaskUpdate`
 
-| Status | Icon | Meaning |
-|--------|------|---------|
-| `pending` | `○` | Not started |
-| `in_progress` | `●` | Actively working — only one at a time |
-| `completed` | `✓` | Done — remains in the list |
+Update task fields, status, and dependencies.
 
-## Task priorities
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | Task ID (required) |
+| `status` | `pending` \| `in_progress` \| `completed` \| `deleted` | New status (`deleted` permanently removes) |
+| `content` | string | New title |
+| `description` | string | New description |
+| `priority` | `high` \| `medium` \| `low` | New priority |
+| `activeForm` | string | Spinner text |
+| `owner` | string | Agent/owner name |
+| `metadata` | object | Shallow merge (set key to `null` to delete) |
+| `addBlocks` | string[] | Task IDs this task blocks |
+| `addBlockedBy` | string[] | Task IDs that block this task |
 
-| Priority | Label | Color |
-|----------|-------|-------|
-| `high` | High | Red |
-| `medium` | Medium | Yellow |
-| `low` | Low | Dim |
+Setting `status: "deleted"` permanently removes the task and cleans up all dependency edges.
 
-## Interactive viewer
+Dependencies are bidirectional — `addBlocks: ["t2"]` on task `t1` also adds `blockedBy: ["t1"]` to task `t2`.
+
+### `TaskOutput`
+
+Retrieve output from a running or completed background task process.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `task_id` | string | — | Task ID (required) |
+| `block` | boolean | `true` | Wait for completion |
+| `timeout` | number | `30000` | Max wait time in ms (max 600000) |
+
+### `TaskStop`
+
+Stop a running background task process. Sends SIGTERM, waits 5 seconds, then SIGKILL. Marks the task as completed.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `task_id` | string | Task ID to stop |
+
+## Task lifecycle
 
 ```
-/todos       — open the full-screen task viewer
+pending → in_progress → completed
+                      → deleted  (permanently removed)
 ```
 
-Keyboard controls in the viewer:
+## Dependency management
+
+```bash
+# Task t2 cannot start until t1 is completed
+TaskUpdate { id: "t2", addBlockedBy: ["t1"] }
+```
+
+Edges are bidirectional. The widget and `TaskList` show open blockers inline (`› blocked by #t1`). Cycles and self-dependencies produce warnings but are stored.
+
+## Task storage
+
+Configured via `/todos → ⚙ Settings` or the `PI_TODO` environment variable:
+
+| Mode | File | Behaviour |
+|------|------|-----------|
+| `memory` | *(none)* | In-memory only — tasks lost when session ends |
+| `session` *(default)* | `<cwd>/.pi/tasks/tasks-<sessionId>.json` | Per-session, survives resume |
+| `project` | `<cwd>/.pi/tasks/tasks.json` | Shared across all sessions in the project |
+
+Settings are saved to `<cwd>/.pi/tasks-config.json`.
+
+### Environment variable override
+
+| Variable | Value | Behaviour |
+|----------|-------|-----------|
+| `PI_TODO` | `off` | In-memory only (CI/automation) |
+| `PI_TODO` | `sprint-1` | Named shared list at `~/.pi/tasks/sprint-1.json` |
+| `PI_TODO` | `/abs/path.json` | Explicit absolute file path |
+
+## Auto-clear completed tasks
+
+| Mode | Behaviour |
+|------|-----------|
+| `never` | Completed tasks stay visible until manually cleared |
+| `on_list_complete` *(default)* | Cleared after all tasks complete and a few idle turns pass |
+| `on_task_complete` | Each task cleared individually a few turns after completion |
+
+## Widget
+
+Persistent task list rendered above the editor:
+
+```
+● 4 tasks (1 done, 1 in progress, 2 open)
+  ✔ Design the API
+  ✳ Implementing auth…  (42s)
+  ◻ Write tests  › blocked by #t2
+  ◻ Update docs
+```
+
+| Icon | Meaning |
+|------|---------|
+| `✔` | Completed (strikethrough + dim) |
+| `◼` | In-progress |
+| `✳`/`✽` | Animated spinner — actively executing (shows elapsed time) |
+| `◻` | Pending |
+
+## `/todos` command
+
+```
+/todos  — open the interactive task manager
+```
 
-| Key | Action |
-|-----|--------|
-| `↑` / `k` | Move cursor up |
-| `↓` / `j` | Move cursor down |
-| `g` / `Home` | Jump to first task |
-| `G` / `End` | Jump to last task |
-| `c` | Toggle completed tasks visibility |
-| `Esc` / `Ctrl+C` | Close viewer |
+Menu options:
+- **View all tasks** — select a task to start / complete / delete it
+- **Clear completed** — remove all completed tasks
+- **Clear all** — remove all tasks
+- **⚙ Settings** — configure task storage and auto-clear
 
 ## Install
 

package/package.json

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

package/src/auto-clear.ts

@@ -0,0 +1,87 @@
+/**
+ * auto-clear.ts — Turn-based auto-clearing of completed tasks.
+ *
+ * Two modes:
+ * - "on_task_complete": each completed task gets its own countdown, deleted individually
+ * - "on_list_complete": countdown starts when ALL tasks are completed, cleared as a batch
+ */
+
+import type { FileTaskStore } from "./file-store.js";
+
+export type AutoClearMode = "never" | "on_list_complete" | "on_task_complete";
+
+export class AutoClearManager {
+	/** Per-task: turn when task was marked completed ("on_task_complete" mode). */
+	private completedAtTurn = new Map<string, number>();
+	/** Turn when ALL tasks became completed ("on_list_complete" mode). */
+	private allCompletedAtTurn: number | null = null;
+
+	constructor(
+		public getStore: () => FileTaskStore,
+		private getMode: () => AutoClearMode,
+		/** How many turns completed tasks linger before auto-clearing. */
+		private clearDelayTurns = 4,
+	) {}
+
+	/** Record a task completion. Call after updating status. */
+	trackCompletion(taskId: string, currentTurn: number): void {
+		const mode = this.getMode();
+		if (mode === "never") return;
+
+		if (mode === "on_task_complete") {
+			this.completedAtTurn.set(taskId, currentTurn);
+		} else if (mode === "on_list_complete") {
+			this.checkAllCompleted(currentTurn);
+		}
+	}
+
+	private checkAllCompleted(currentTurn: number): void {
+		const tasks = this.getStore().list();
+		if (tasks.length > 0 && tasks.every((t) => t.status === "completed")) {
+			if (this.allCompletedAtTurn === null) this.allCompletedAtTurn = currentTurn;
+		} else {
+			this.allCompletedAtTurn = null;
+		}
+	}
+
+	/** Reset batch countdown (e.g., when a new task is created). */
+	resetBatchCountdown(): void {
+		this.allCompletedAtTurn = null;
+	}
+
+	/** Reset all tracking state (e.g., on new session). */
+	reset(): void {
+		this.completedAtTurn.clear();
+		this.allCompletedAtTurn = null;
+	}
+
+	/**
+	 * Called on each turn start. Deletes tasks whose linger period has expired.
+	 * Returns true if any tasks were cleared.
+	 */
+	onTurnStart(currentTurn: number): boolean {
+		const mode = this.getMode();
+		let cleared = false;
+
+		if (mode === "on_task_complete") {
+			for (const [taskId, turn] of this.completedAtTurn) {
+				const task = this.getStore().get(taskId);
+				if (!task || task.status !== "completed") {
+					this.completedAtTurn.delete(taskId);
+				} else if (currentTurn - turn >= this.clearDelayTurns) {
+					this.getStore().delete(taskId);
+					this.completedAtTurn.delete(taskId);
+					cleared = true;
+				}
+			}
+		} else if (mode === "on_list_complete" && this.allCompletedAtTurn !== null) {
+			if (currentTurn - this.allCompletedAtTurn >= this.clearDelayTurns) {
+				this.getStore().clearCompleted();
+				this.allCompletedAtTurn = null;
+				cleared = true;
+			}
+		}
+
+		return cleared;
+	}
+}

package/src/component.ts

@@ -1,7 +1,19 @@
-import { matchesKey, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { priorityColor, priorityLabel } from "./state";
-import type { Task, TaskDetails } from "./types";
-import { PRIORITY_ORDER } from "./types";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+	Container,
+	matchesKey,
+	type SettingItem,
+	SettingsList,
+	Spacer,
+	Text,
+	truncateToWidth,
+} from "@earendil-works/pi-tui";
+import type { TodoConfig } from "./config.js";
+import { saveTodoConfig } from "./config.js";
+import type { FileTaskStore } from "./file-store.js";
+import { priorityColor, priorityLabel, renderTaskListResult } from "./state.js";
+import type { Task, TaskDetails } from "./types.js";
+import { PRIORITY_ORDER } from "./types.js";
 
 // ── /todos interactive viewer ──────────────────────────────────────────────────
 
@@ -28,19 +40,16 @@ export class TodoViewComponent {
 			this.onClose();
 			return;
 		}
-
 		if (matchesKey(data, "up") || data === "k") {
 			if (this.cursorIndex > 0) this.cursorIndex--;
 			this.invalidate();
 			return;
 		}
-
 		if (matchesKey(data, "down") || data === "j") {
 			if (this.cursorIndex < this.flatTasks.length - 1) this.cursorIndex++;
 			this.invalidate();
 			return;
 		}
-
 		if (data === "c") {
 			this.showCompleted = !this.showCompleted;
 			this.rebuildFlatTasks();
@@ -48,13 +57,11 @@ export class TodoViewComponent {
 			this.invalidate();
 			return;
 		}
-
 		if (matchesKey(data, "home") || data === "g") {
 			this.cursorIndex = 0;
 			this.invalidate();
 			return;
 		}
-
 		if (matchesKey(data, "end") || data === "G") {
 			this.cursorIndex = Math.max(0, this.flatTasks.length - 1);
 			this.invalidate();
@@ -162,7 +169,6 @@ export class TodoViewComponent {
 		const th = this.theme;
 		const isFocused = flatIdx === this.cursorIndex;
 
-		// ── Status icon ──
 		let icon: string;
 		if (task.status === "completed") {
 			icon = th.fg("success", "✓");
@@ -172,11 +178,9 @@ export class TodoViewComponent {
 			icon = th.fg("dim", "○");
 		}
 
-		// ── Priority badge ──
 		const pColor = priorityColor(task.priority);
 		const pLabel = th.fg(pColor, priorityLabel(task.priority));
 
-		// ── Content ──
 		let contentText: string;
 		if (task.status === "completed") {
 			contentText = th.fg("dim", th.strikethrough(task.content));
@@ -186,13 +190,25 @@ export class TodoViewComponent {
 			contentText = th.fg("muted", task.content);
 		}
 
-		// ── ID hint ──
 		const idHint = th.fg("dim", ` [${task.id}]`);
-
-		// ── Cursor indicator ──
 		const cursor = isFocused ? th.fg("accent", "❯") : " ";
 
-		return [truncateToWidth(`  ${cursor} ${icon} ${pLabel}  ${contentText}${idHint}`, width)];
+		// Dependency hint
+		let depHint = "";
+		if (task.blockedBy.length > 0) {
+			const openBlockers = task.blockedBy.filter((_bid) => {
+				// We only have the flat list, use basic check
+				return true; // shown for visibility
+			});
+			if (openBlockers.length > 0) {
+				depHint = th.fg("dim", ` ← blocked by ${openBlockers.map((id) => `#${id}`).join(", ")}`);
+			}
+		}
+		if (task.blocks.length > 0) {
+			depHint += th.fg("dim", ` → blocks ${task.blocks.map((id) => `#${id}`).join(", ")}`);
+		}
+
+		return [truncateToWidth(`  ${cursor} ${icon} ${pLabel}  ${contentText}${idHint}${depHint}`, width)];
 	}
 
 	private rebuildFlatTasks(): void {
@@ -201,7 +217,6 @@ export class TodoViewComponent {
 			.filter((t) => t.status === "pending")
 			.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
 		const done = this.showCompleted ? this.tasks.filter((t) => t.status === "completed") : [];
-
 		this.flatTasks = [...inProgress, ...pending, ...done];
 	}
 
@@ -210,55 +225,177 @@ export class TodoViewComponent {
 		this.cachedLines = undefined;
 	}
 
-	// ── Tool result rendering (inline, used in both tools) ─────────────────────
+	// ── Static tool result renderer ────────────────────────────────────────────
 
 	static renderTaskResult(details: TaskDetails | undefined, expanded: boolean, theme: any): any {
-		if (!details?.tasks?.length) {
-			return new Text(theme.fg("dim", "Task list cleared"), 0, 0);
-		}
+		return renderTaskListResult(details?.tasks ?? [], expanded, theme);
+	}
+}
+
+// ── Settings panel ──────────────────────────────────────────────────────────────
+
+export async function openTodoSettings(ui: any, cfg: TodoConfig, cwd: string, clearDelayTurns: number): Promise<void> {
+	await ui.custom((_tui: any, theme: any, _kb: any, done: (r: undefined) => void) => {
+		const items: SettingItem[] = [
+			{
+				id: "taskScope",
+				label: "Task storage",
+				description:
+					"memory: tasks live only in memory, lost when session ends. " +
+					"session: persisted per session (tasks-<sessionId>.json), survives resume. " +
+					"project: shared across all sessions (tasks.json). " +
+					"Takes effect on next session start.",
+				currentValue: cfg.taskScope ?? "session",
+				values: ["memory", "session", "project"],
+			},
+			{
+				id: "autoClearCompleted",
+				label: "Auto-clear completed tasks",
+				description:
+					"never: completed tasks stay visible until manually cleared. " +
+					"on_list_complete: cleared automatically after all tasks are done. " +
+					"on_task_complete: each task cleared shortly after it completes. " +
+					`Clearing lags ~${clearDelayTurns} turns.`,
+				currentValue: cfg.autoClearCompleted ?? "on_list_complete",
+				values: ["never", "on_list_complete", "on_task_complete"],
+			},
+		];
+
+		const list = new SettingsList(
+			items,
+			10,
+			getSettingsListTheme(),
+			(id, newValue) => {
+				if (id === "taskScope") {
+					cfg.taskScope = newValue as TodoConfig["taskScope"];
+					saveTodoConfig(cwd, cfg);
+				}
+				if (id === "autoClearCompleted") {
+					cfg.autoClearCompleted = newValue as TodoConfig["autoClearCompleted"];
+					saveTodoConfig(cwd, cfg);
+				}
+			},
+			() => done(undefined),
+		);
 
-		const list = details.tasks;
-		const doneCount = list.filter((t) => t.status === "completed").length;
-		const inProgCount = list.filter((t) => t.status === "in_progress").length;
-		const total = list.length;
-
-		// ── Summary line ──
-		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("  ");
-
-		// ── Task lines ──
-		const display = expanded ? list : list.slice(0, 5);
-		for (const t of display) {
-			let icon: string;
-			if (t.status === "completed") {
-				icon = theme.fg("success", "✓");
-			} else if (t.status === "in_progress") {
-				icon = theme.fg("accent", "●");
-			} else {
-				icon = theme.fg("dim", "○");
+		class SettingsPanel extends Container {
+			handleInput(data: string) {
+				list.handleInput(data);
 			}
+		}
 
-			const pColor = priorityColor(t.priority);
-			const pLabel = theme.fg(pColor, priorityLabel(t.priority));
+		const root = new SettingsPanel();
+		root.addChild(new Text(theme.bold(theme.fg("accent", "⚙  Todo Settings")), 0, 0));
+		root.addChild(new Spacer(1));
+		root.addChild(list);
+		return root;
+	});
+}
 
-			let content: string;
-			if (t.status === "completed") {
-				content = theme.fg("dim", theme.strikethrough(t.content));
-			} else if (t.status === "in_progress") {
-				content = theme.fg("text", theme.bold(t.content));
-			} else {
-				content = theme.fg("muted", t.content);
-			}
+// ── /todos detailed task viewer (select-based) ─────────────────────────────────
+
+export async function openTodosMenu(
+	ui: any,
+	store: FileTaskStore,
+	cfg: TodoConfig,
+	cwd: string,
+	onTaskUpdate: (taskId: string, status?: string) => void,
+): Promise<void> {
+	const AUTO_CLEAR_DELAY = 4;
+
+	const mainMenu = async (): Promise<void> => {
+		const tasks = store.list();
+		const completedCount = tasks.filter((t) => t.status === "completed").length;
+
+		const choices: string[] = [`View all tasks (${tasks.length})`];
+		if (completedCount > 0) choices.push(`Clear completed (${completedCount})`);
+		if (tasks.length > 0) choices.push(`Clear all (${tasks.length})`);
+		choices.push("⚙ Settings");
+
+		const choice = await ui.select("Tasks", choices);
+		if (!choice) return;
+
+		if (choice.startsWith("View")) {
+			return viewTasks();
+		} else if (choice.startsWith("Clear completed")) {
+			store.clearCompleted();
+			store.deleteFileIfEmpty();
+			onTaskUpdate("", undefined);
+			return mainMenu();
+		} else if (choice.startsWith("Clear all")) {
+			store.clearAll();
+			store.deleteFileIfEmpty();
+			onTaskUpdate("", undefined);
+			return mainMenu();
+		} else if (choice.startsWith("⚙")) {
+			await openTodoSettings(ui, cfg, cwd, AUTO_CLEAR_DELAY);
+			return mainMenu();
+		}
+	};
 
-			output += `\n${icon} ${pLabel}  ${content}`;
+	const viewTasks = async (): Promise<void> => {
+		const tasks = store.list();
+		if (tasks.length === 0) {
+			await ui.select("No tasks", ["← Back"]);
+			return mainMenu();
 		}
 
-		if (!expanded && list.length > 5) {
-			output += `\n${theme.fg("dim", `... ${list.length - 5} more`)}`;
+		const icon = (status: string) => {
+			if (status === "completed") return "✔";
+			if (status === "in_progress") return "◼";
+			return "◻";
+		};
+
+		const choices = tasks.map((t) => `${icon(t.status)} #${t.id} [${t.status}] ${t.content}`);
+		choices.push("← Back");
+
+		const selected = await ui.select("Tasks", choices);
+		if (!selected || selected === "← Back") return mainMenu();
+
+		const match = selected.match(/#([a-z0-9]+)/);
+		if (match) return viewTaskDetail(match[1]);
+		return viewTasks();
+	};
+
+	const viewTaskDetail = async (taskId: string): Promise<void> => {
+		const task = store.get(taskId);
+		if (!task) return viewTasks();
+
+		const actions: string[] = [];
+		if (task.status === "pending") actions.push("▸ Start (in_progress)");
+		if (task.status === "in_progress") actions.push("✓ Complete");
+		actions.push("✗ Delete");
+		actions.push("← Back");
+
+		const deps: string[] = [];
+		if (task.blockedBy.length > 0) deps.push(`Blocked by: ${task.blockedBy.map((id) => `#${id}`).join(", ")}`);
+		if (task.blocks.length > 0) deps.push(`Blocks: ${task.blocks.map((id) => `#${id}`).join(", ")}`);
+
+		const detailLines = [
+			`#${task.id} [${task.status}] ${task.content}`,
+			task.description ? `\n${task.description}` : "",
+			deps.length > 0 ? `\n${deps.join(" | ")}` : "",
+		]
+			.filter(Boolean)
+			.join("");
+
+		const action = await ui.select(detailLines, actions);
+
+		if (action === "▸ Start (in_progress)") {
+			store.update(taskId, { status: "in_progress" });
+			onTaskUpdate(taskId, "in_progress");
+			return viewTasks();
+		} else if (action === "✓ Complete") {
+			store.update(taskId, { status: "completed" });
+			onTaskUpdate(taskId, "completed");
+			return viewTasks();
+		} else if (action === "✗ Delete") {
+			store.update(taskId, { status: "deleted" });
+			onTaskUpdate(taskId, "deleted");
+			return viewTasks();
 		}
+		return viewTasks();
+	};
 
-		return new Text(output, 0, 0);
-	}
+	await mainMenu();
 }