pi-thread-engine 0.2.4 → 0.4.1

package/README.md

@@ -1,8 +1,11 @@
-# 🧵 pi-threads
+# 🧵 pi-thread-engine
 
-Thread engineering for [pi](https://github.com/badlogic/pi-mono) — all 7 thread types + stories.
+> *"When you start thinking in threads, you stop being a bottleneck and become an orchestrator."*
+> — @IndyDevDan, [Thinking in Threads](https://agenticengineer.com/thinking-in-threads)
 
-**Wraps pi-subagents** for P/C/B threads (inheriting agent specialization, chain artifacts, live progress). **Builds natively** what nobody else has: F-Thread (multi-model fusion), Z-Thread (verify gate), and Stories (goal → auto-decomposed thread phases).
+**Thread-Based Engineering** for [Pi Coding Agent](https://github.com/badlogic/pi-mono).
+7 thread types + stories + fusion + zero-touch + full TUI dashboard.
+Built on @IndyDevDan's framework from [agenticengineer.com](https://agenticengineer.com).
 
 ## Install
 
@@ -10,99 +13,203 @@ Thread engineering for [pi](https://github.com/badlogic/pi-mono) — all 7 threa
 pi install npm:pi-thread-engine
 ```
 
-Or from source:
+## The Thread Framework
 
-```bash
-pi install ./path/to/pi-threads
+Everything starts with the base thread:
+
+```
+PROMPT → TOOL CALLS → REVIEW
+  You      Agent       You
+```
+
+You show up at two nodes for maximum leverage. Your agent handles everything in between.
+
+Then you multiply:
+
+```
+Thread Types
+├── Base    → You → Agent → You (minutes)
+├── P       → Parallel 5+ agents (hours)
+├── C       → Checkpoint chains (high-stakes)
+├── F       → Fusion 9 agents, pick winner
+├── B       → Branch (orchestrator agents)
+├── L       → Long-running 26hrs (days)
+└── Z       → Zero-touch, no review (ultimate)
 ```
 
 ## Commands
 
-| Command | Type | Backend | What |
-|---------|------|---------|------|
-| `/pthread` | P-Thread | subagent | N independent tasks in parallel |
-| `/cthread` | C-Thread | subagent | Sequential phases via subagent chain |
-| `/bthread` | B-Thread | subagent | scout → plan → build → review pipeline |
-| `/fthread` | F-Thread | **native** | Same prompt → N models → compare (UNIQUE) |
-| `/zthread` | Z-Thread | **native** | Autonomous + verify command gate (UNIQUE) |
-| `/lthread` | L-Thread | native | Extended autonomous run |
-| `/story` | Stories | mixed | Auto-decompose goal into thread phases (UNIQUE) |
+| Command | Type | What |
+|---------|------|------|
+| `/threads` | Dashboard | TUI: 3-column status view, search, inline reply, keyboard nav |
+| `/pthread` | P-Thread | N independent tasks in parallel |
+| `/cthread` | C-Thread | Sequential phases with checkpoint reviews |
+| `/bthread` | B-Thread | scout → plan → build → review pipeline |
+| `/fthread` | F-Thread | Same prompt → N models → compare, pick winner |
+| `/zthread` | Z-Thread | Autonomous + verification gate (ships only if tests pass) |
+| `/lthread` | L-Thread | Extended autonomous run |
+| `/story` | Stories | Auto-decompose goal into thread phases |
+| `/agents` | Alias | Same as `/threads` — Claude muscle memory |
 
-## Unique Features (not in pi-subagents or pi-messenger)
+## Dashboard
 
-### Fusion (`/fthread`)
-Same prompt sent to multiple models in parallel. Compare results, pick the best.
+Run `/threads` (or `/agents`) to open the TUI dashboard:
 
 ```
+  🧵 Thread Dashboard
+  ═══════════════════════════════════════════
+
+  ⚡ Needs Input (2)
+  ▸ t-001  ████████░░  needs_input  /fix bug in auth     → "password has special chars"
+  ▸ t-003  ░░░░░░░░░  needs_input  /audit dependencies  → "found 3 vulnerable"
+
+  ⚙ Working (3)
+  ▸ t-002  ██████░░░░  running  /migrate database        ⏱ 4m 23s
+  ▸ t-004  ████░░░░░░  running  /build API endpoints     ⏱ 2m 11s
+  ▸ s-001  →scout→plan→build  running  /story add payments
+
+  ✓ Done (4)
+  ▸ t-005  ██████████  success  /refactor auth module     → "cleaned up 12 files"
+  ▸ t-006  ██████████  success  /update docs             → "30 pages updated"
+  ▸ t-007  ██████████  error    /deploy to prod          ✗ "missing env vars"
+
+  nav=↑↓ exp=Enter rep=i srch=/ kill=k rev=r prune=p quit=q
+```
+
+**Keyboard shortcuts:**
+- `↑↓` — navigate threads
+- `Enter` — expand/collapse thread details
+- `i` — inline reply (send message to blocked thread)
+- `/` — search/filter threads
+- `k` — kill selected thread
+- `r` — review selected thread results
+- `p` — prune (clear) finished threads
+- `q` — quit dashboard
+
+## Thread Types in Depth
+
+### P-Thread — Parallel
+Five in the terminal. Five to ten in the browser. Zero apologies.
+— *Boris Cherny, creator of Claude Code*
+
+```bash
+/pthread "Review all PRs" --count 8
+/pthread "Fix bug in auth" --count 3 --each
+```
+
+### C-Thread — Checkpoint Chains
+High-stakes work needs verification at critical junctures.
+Intentional chunking is a feature, not a bug.
+
+```bash
+/cthread "Migrate to new database" --phases scout,plan,build,test,deploy
+```
+
+### F-Thread — Fusion (pi-thread-engine unique)
+Nine agents. Nine parallel futures. Pick the winner.
+
+```bash
 /fthread "Design the caching architecture" --count 5
-/fthread "Refactor the auth module" --models anthropic/claude-sonnet-4,google/gemini-2.5-pro,openai/gpt-4o
+/fthread "Refactor the auth module" --models claude,gpt-4o,gemini-pro
 ```
 
-### Zero-Touch (`/zthread`)
-Autonomous execution with a verification gate. Only ships if the verify command passes.
+Best-of-N gives you confidence. Cherry-picking gives you quality.
+Each agent runs in complete isolation — no cross-contamination.
+
+### B-Thread — Branch/Meta-Agentic
+When agents manage agents. You become an Orchestrator of Intelligence.
 
+```bash
+/bthread "Build the checkout flow"
 ```
-/zthread "Fix all ESLint warnings" --verify "npm run lint"
-/zthread "Add input validation" --verify "npm test"
+
+Auto-runs: plan agent → scout → build → review → deploy
+
+### L-Thread — Long-Running
+A single prompt that ran 26 hours.
+
+```bash
+/lthread "Audit and fix all security vulnerabilities" --hours 24
 ```
 
-### Stories (`/story`)
-A goal gets auto-decomposed into thread phases. pi-threads picks the right thread type for each phase.
+### Z-Thread — Zero-Touch (pi-thread-engine unique)
+Maximum earned trust. No review node. Ships only if verification passes.
 
+```bash
+/zthread "Fix all ESLint warnings" --verify "npm run lint"
+/zthread "Add dark mode" --verify "npm test && npm run build"
 ```
+
+This is NOT vibe coding. Z-threads are the opposite:
+maximum earned trust through hundreds of iterations.
+
+### Stories — Goal Decomposition (pi-thread-engine unique)
+Auto-decompose a goal into thread phases. pi-thread-engine picks the right type for each.
+
+```bash
 /story "Add dark mode to the dashboard" --verify "npm test"
 ```
 
 Auto-generates phases:
 1. **Scout** (meta) — research the codebase
-2. **Plan** (fusion) — 3 models brainstorm approaches
-3. **Decide** (chained) — human picks the winner
+2. **Plan** (fusion) — 3 models brainstorm approaches  
+3. **Decide** (checkpoint) — human picks the winner
 4. **Build** (parallel) — implement across files
 5. **Verify** (zero) — run tests
 
-## Dashboard
+## LLM Tools
 
-```
-/threads          — show all threads + stories
-/threads kill t-001 — kill a thread
-/threads review   — see completed results (fusion shows comparison)
-/threads prune    — clear finished threads
-/stories          — list all stories with phase progress
+Use these inside any Pi prompt:
+
+```typescript
+thread_spawn({ type: "parallel", prompts: [...] })  // Start any thread type
+thread_status({ id: "t-001" })                       // Check progress
+thread_kill({ id: "t-001" })                         // Stop a thread
 ```
 
-## LLM Tools
+## The Core Four
 
-- `thread_spawn` — Start any thread type (auto-selects backend)
-- `thread_status` — Check progress of threads and stories
-- `thread_kill` — Stop a thread
+Every thread runs on these four pillars. Invest in all of them:
 
-## Architecture
+| Pillar | Description | pi-thread-engine |
+|--------|-------------|-----------------|
+| **Context** | Right information (no more, no less) | `~/.pi-memory/` integration |
+| **Model** | Capable of sustained reasoning | 324+ models via OpenRouter |
+| **Prompt** | Crystal-clear agentic engineering | Structured commands |
+| **Tools** | Self-verifying, comprehensive | 40+ pi-skills |
 
-```
-Wrapper layer (pi-subagents):     Native layer (pi -p):
-┌──────────────────────────┐     ┌────────────────────────┐
-│ /pthread  → /parallel    │     │ /fthread  → N models   │
-│ /cthread  → /chain       │     │ /zthread  → run+verify │
-│ /bthread  → scout chain  │     │ /lthread  → long run   │
-└──────────────────────────┘     └────────────────────────┘
-                    ↕                        ↕
-              ┌─────────────────────────────────┐
-              │  ThreadRegistry (state machine)  │
-              │  ThreadExecutor (dispatch)        │
-              │  /threads dashboard               │
-              │  /story orchestrator              │
-              └─────────────────────────────────┘
-```
+## Measuring Progress
 
-## The Thread Framework
+You know you're improving at agentic coding when:
+
+- **Width** ↑ — P-threads = 5x exploration per hour
+- **Time** ↑ — L-threads = 10min → 8hrs autonomous work
+- **Depth** ↑ — B-threads = one prompt → entire teams
+- **Checkpoints** ↓ — Earned trust through evidence
 
-Based on [thread-engineering](https://github.com/disler/agentic-coding-patterns):
+> *The common denominator: increase tool calls per unit of your attention.*
 
-> A thread is a unit of engineering work: prompt at the start, review at the end, agent tool calls in between.
-> The metric: **tool calls per unit of your attention**. Maximize this.
+## Architecture
 
 ```
-Base → P-Thread → C-Thread → F-Thread → B-Thread → L-Thread → Z-Thread
-                                                                  ↑
-                                                          The north star
+┌─────────────────────────────────────────────────────┐
+│                   pi-thread-engine                  │
+├─────────────┬──────────────┬────────────────────────┤
+│  Dashboard  │  Registry    │  Executor              │
+│  (TUI v3)   │  (state)     │  (dispatch)            │
+├─────────────┴──────────────┴────────────────────────┤
+│  Commands: /threads /pthread /cthread /fthread     │
+│            /bthread /zthread /lthread /story        │
+├─────────────────────────────────────────────────────┤
+│  Backends                                           │
+│  ├─ pi-subagents (P/C/B threads)                   │
+│  └─ native (F/Z/L threads, Stories)                 │
+└─────────────────────────────────────────────────────┘
 ```
+
+## Further Reading
+
+- [Thinking in Threads](https://agenticengineer.com/thinking-in-threads) — @IndyDevDan
+- [The Only Claude Code Competitor](https://agenticengineer.com/the-only-claude-code-competitor)
+- [Compute Advantage Equation](https://agenticengineer.com/compute-advantage-equation)
+- [Engineering with Exponentials](https://agenticengineer.com/state-of-ai-coding/engineering-with-exponentials)

package/docs/THREADS.md

@@ -0,0 +1,116 @@
+# Thread-Based Engineering
+
+> *"When you start thinking in threads, you stop being a bottleneck and become an orchestrator."*
+> — @IndyDevDan, [Thinking in Threads](https://agenticengineer.com/thinking-in-threads)
+
+This is the mental framework for agentic coding. Adapted from @IndyDevDan's article
+by @IndyDevDan, co-authored with Claude Opus 4.5.
+
+## The Core Four
+
+Every thread runs on these four pillars:
+
+| Pillar | Description | pi-thread-engine |
+|--------|-------------|-----------------|
+| **Context** | Right information (no more, no less) | pi-memory integration |
+| **Model** | Capable of sustained reasoning | Any of 324+ models |
+| **Prompt** | Crystal-clear agentic engineering | Structured thread commands |
+| **Tools** | Self-verifying, comprehensive | pi-skills ecosystem |
+
+## The Thread Taxonomy
+
+```
+Thread Types
+├── Base    → You → Agent → You (minutes)
+├── P       → Parallel 5+ agents (hours)
+├── C       → Checkpoint chains (high-stakes)
+├── F       → Fusion 9 agents, pick winner
+├── B       → Branch (orchestrator agents)
+├── L       → Long-running 26hrs (days)
+└── Z       → Zero-touch, no review (ultimate)
+```
+
+### Base Thread
+The atomic unit. Every prompt follows this shape:
+
+```
+PROMPT → TOOL CALLS → REVIEW
+  You      Agent       You
+```
+
+You show up at two nodes for maximum leverage: Prompt and Review.
+The middle is your agent executing tool calls.
+
+### P-Thread (Parallel)
+Five in the terminal. Five to ten in the browser. Zero apologies.
+— *Boris Cherny, creator of Claude Code*
+
+- In-loop: Active collaboration where you guide and redirect
+- Out-of-loop: Fire-and-forget tasks that complete while you focus elsewhere
+- Unlock: code review at scale, rapid exploration, verification through redundancy
+
+### C-Thread (Checkpoint/Chained)
+High-stakes work needs verification at critical junctures.
+
+- **Context constraints**: work exceeds context window
+- **Production stakes**: human verification prevents catastrophe
+
+> *Intentional chunking is a feature, not a bug.*
+
+### F-Thread (Fusion)
+Nine agents. Nine parallel futures. Pick the winner.
+
+- 3 Claude Code + 3 Gemini + 3 Codex all tackling the same problem
+- Best-of-N gives confidence. Cherry-picking gives quality.
+- Agent sandboxes: complete isolation, no cross-contamination
+
+> *"The future of rapid prototyping will be done with fusion threads."*
+
+### B-Thread (Branch/Meta-Agentic)
+When agents manage agents. You become an Orchestrator of Intelligence.
+
+- Simplest: one agent spawns another for a specific task
+- Full orchestration: plan agent + scout + build + review + deploy
+- Deterministic code orchestrating non-deterministic intelligence
+
+> *"This is meta-programming for the agentic age."*
+
+### L-Thread (Long-Running)
+A single prompt that ran 26 hours.
+
+- Prerequisites are demanding: Core Four must all be exceptional
+- Top agentic engineers kick off a prompt and go to sleep
+- 100x duration = 100x decisions your agent makes without you
+
+> *"Living software that works for us while we sleep."*
+
+### Z-Thread (Zero-Touch)
+The hidden level beyond review. Maximum earned trust.
+
+```
+PROMPT → AGENT → SHIP (no review node)
+```
+
+> *"It isn't that we don't look at the code. It's that we know we don't have to."*
+
+This is NOT vibe coding. Z-threads are the opposite:
+maximum earned trust through hundreds of iterations of context, prompt, and tools refinement.
+
+## Measuring Progress
+
+You measure improvement in threads:
+- **Width** (more threads): P-threads = 5x exploration
+- **Time** (longer threads): L-threads = 10min → 8hrs autonomous
+- **Depth** (thicker threads): B-threads = one prompt → entire teams
+- **Attention** (fewer checkpoints): Earn trust through evidence
+
+> *"The common denominator: increase tool calls per unit of your attention."*
+
+Stack these multipliers. Track them weekly. Watch them trend upward.
+
+## Further Reading
+
+- [Thinking in Threads](https://agenticengineer.com/thinking-in-threads) — @IndyDevDan
+- [The Only Claude Code Competitor](https://agenticengineer.com/the-only-claude-code-competitor)
+- [Compute Advantage Equation](https://agenticengineer.com/compute-advantage-equation)
+- [Engineering with Exponentials](https://agenticengineer.com/state-of-ai-coding/engineering-with-exponentials)

package/extensions/index.ts

@@ -1,7 +1,19 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@mariozechner/pi-ai";
+import { Type, type TUnsafe } from "@sinclair/typebox";
 import { Text } from "@mariozechner/pi-tui";
+
+// StringEnum helper (removed from pi-ai >=0.66)
+function StringEnum<T extends readonly string[]>(
+	values: T,
+	options?: { description?: string; default?: T[number] },
+): TUnsafe<T[number]> {
+	return Type.Unsafe<T[number]>({
+		type: "string",
+		enum: values as unknown as string[],
+		...(options?.description && { description: options.description }),
+		...(options?.default && { default: options.default }),
+	});
+}
 import { ThreadRegistry, formatElapsed } from "../src/core/registry.js";
 import { ThreadExecutor } from "../src/core/executor.js";
 import { createDashboard } from "../src/dashboard.js";
@@ -178,6 +190,26 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			// Default: open interactive TUI dashboard
+			// ── /agents alias (Claude-style muscle memory) ──────────────
+			pi.registerCommand("agents", {
+				description: "Alias for /threads — Claude-style Agent View dashboard",
+				handler: async (a, c) => {
+					// Forward to /threads
+					await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+						const dashboard = createDashboard(
+							registry,
+							theme,
+							() => done(),
+							(id) => { registry.kill(id); ctx.ui.notify(`Killed ${id}`, "warning"); tui.requestRender(); },
+							(id) => { const t = registry.get(id); if (t) { ctx.ui.notify(`Thread ${id}: ${t.tasks.map((tk) => `${tk.id}: ${tk.result?.slice(0,100) ?? tk.error ?? "(pending)"}`).join("\n")}`, "info"); } },
+							(id, message) => { executor.injectReply(id, message); ctx.ui.notify(`Replied to ${id}: ${message.slice(0, 50)}...`, "info"); tui.requestRender(); }
+						);
+						return { render: (w: number) => dashboard.render(w), invalidate: () => dashboard.invalidate(), handleInput: (data: string) => { dashboard.handleInput(data); tui.requestRender(); } };
+					});
+				},
+			});
+			// ── End /agents alias ───────────────────────────────────────
+
 			await ctx.ui.custom<void>((tui, theme, _kb, done) => {
 				const dashboard = createDashboard(
 					registry,
@@ -194,6 +226,12 @@ export default function (pi: ExtensionAPI) {
 							const preview = t.tasks.map((tk) => `${tk.id}: ${tk.result?.slice(0, 100) ?? tk.error ?? "(pending)"}`).join("\n");
 							ctx.ui.notify(`Thread ${id} results:\n${preview}`, "info");
 						}
+					},
+					(id, message) => {
+						// Inline reply — send message to blocked thread
+						executor.injectReply(id, message);
+						ctx.ui.notify(`Replied to ${id}: ${message.slice(0, 50)}...`, "info");
+						tui.requestRender();
 					}
 				);
 
@@ -542,7 +580,7 @@ export default function (pi: ExtensionAPI) {
 		parameters: Type.Object({
 			id: Type.Optional(Type.String({ description: "Thread ID (t-001) or Story ID (s-001). Omit for all." })),
 		}),
-		async execute(_toolCallId, params) {
+		async execute(_toolCallId, params, _signal?: any, _onUpdate?: any, _ctx?: any) {
 			if (params.id) {
 				// Check threads first
 				const t = registry.get(params.id);
@@ -579,7 +617,7 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
-				return { content: [{ type: "text", text: `ID ${params.id} not found` }], isError: true };
+				return { content: [{ type: "text", text: `ID ${params.id} not found` }], isError: true } as any;
 			}
 
 			// All
@@ -604,10 +642,10 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (lines.length === 0) {
-				return { content: [{ type: "text", text: "No threads or stories." }] };
+				return { content: [{ type: "text", text: "No threads or stories." }] } as any;
 			}
 
-			return { content: [{ type: "text", text: lines.join("\n") }] };
+			return { content: [{ type: "text", text: lines.join("\n") }] } as any;
 		},
 	});
 
@@ -618,11 +656,11 @@ export default function (pi: ExtensionAPI) {
 		parameters: Type.Object({
 			id: Type.String({ description: "Thread ID to kill" }),
 		}),
-		async execute(_toolCallId, params) {
+		async execute(_toolCallId, params, _signal?: any, _onUpdate?: any, _ctx?: any) {
 			const t = registry.get(params.id);
 			if (!t) return { content: [{ type: "text", text: `Thread ${params.id} not found` }], isError: true };
 			registry.kill(params.id);
-			return { content: [{ type: "text", text: `Thread ${params.id} killed.` }] };
+			return { content: [{ type: "text", text: `Thread ${params.id} killed.` }] } as any;
 		},
 	});
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-thread-engine",
-  "version": "0.2.4",
-  "description": "Thread engineering for pi — all 7 thread types, stories, fusion, zero-touch, TUI dashboard",
+  "version": "0.4.1",
+  "description": "Thread-Based Engineering for pi — all 7 thread types + stories + fusion + zero-touch + TUI dashboard. Based on @IndyDevDan framework from agenticengineer.com.",
   "type": "module",
   "license": "MIT",
   "author": "artale",
@@ -43,12 +43,16 @@
     "extensions/",
     "src/",
     "README.md",
-    "PLAN.md"
+    "PLAN.md",
+    "docs/"
   ],
   "peerDependencies": {
-    "@mariozechner/pi-ai": "^0.56.0",
-    "@mariozechner/pi-coding-agent": "^0.56.0",
-    "@mariozechner/pi-tui": "^0.56.0",
+    "@mariozechner/pi-coding-agent": ">=0.73.0",
+    "@mariozechner/pi-tui": ">=0.73.0",
+    "@mariozechner/pi-ai": ">=0.73.0",
     "@sinclair/typebox": "^0.34.48"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
   }
 }

package/src/core/executor.ts

@@ -197,4 +197,24 @@ export class ThreadExecutor {
 				return;
 		}
 	}
+
+	/** Inject a reply into a running thread — sends message to its session */
+	injectReply(threadId: string, message: string): void {
+		const thread = this.registry.get(threadId);
+		if (!thread) return;
+
+		// Mark the blocked task as no longer needing input
+		for (const task of thread.tasks) {
+			if (task.state === "needs_input") {
+				task.state = "running";
+			}
+		}
+
+		// Forward the reply to the running subagent session via sendUserMessage
+		// The subagent will pick up the new context and continue
+		this.pi.sendUserMessage(
+			`[Thread ${threadId}] Reply to blocked thread: ${message}`,
+			{ deliverAs: "followUp" }
+		);
+	}
 }

package/src/core/types.ts

@@ -2,7 +2,7 @@
 export type ThreadType = "base" | "parallel" | "chained" | "fusion" | "meta" | "long" | "zero";
 
 /** Thread lifecycle states */
-export type ThreadState = "pending" | "running" | "paused" | "completed" | "failed" | "killed";
+export type ThreadState = "pending" | "running" | "paused" | "completed" | "failed" | "killed" | "needs_input";
 
 /** How a thread is executed */
 export type ExecutionBackend = "subagent" | "native";

package/src/dashboard.ts

@@ -1,8 +1,7 @@
 /**
- * Interactive TUI dashboard for pi-threads.
- * Shows threads + stories in a navigable overlay.
- *
- * Keys: ↑↓ navigate, Enter expand, k kill, r review, p prune, q/Esc close
+ * Thread Dashboard v2 — Agent View-style grouping + inline reply + search
+ * Groups: Needs Input | Working | Done
+ * Keys: ↑↓ navigate, Enter expand, i reply, / search, k kill, p prune, q close
  */
 import { matchesKey, Key, truncateToWidth } from "@mariozechner/pi-tui";
 import type { ThreadRegistry } from "./core/registry.js";
@@ -12,11 +11,23 @@ export interface DashboardTheme {
 	bold: (text: string) => string;
 }
 
-interface DashboardRow {
+interface Row {
 	id: string;
 	kind: "thread" | "story";
 	label: string;
-	display: string;
+	state: string;
+	progress: string;
+	elapsed: string;
+	result: string;
+	error: string;
+	type: string;
+}
+
+interface Group {
+	name: string;
+	icon: string;
+	color: string;
+	rows: Row[];
 }
 
 export function createDashboard(
@@ -24,13 +35,21 @@ export function createDashboard(
 	theme: DashboardTheme,
 	onClose: () => void,
 	onKill?: (id: string) => void,
-	onReview?: (id: string) => void
+	onReview?: (id: string) => void,
+	onReply?: (id: string, message: string) => void
 ) {
 	let selected = 0;
 	let expanded: string | null = null;
-	let rows: DashboardRow[] = [];
+	let searchQuery = "";
+	let showSearch = false;
+	let replyTarget: string | null = null;
+	let replyBuffer = "";
+	let groups: Group[] = [];
 	let cachedWidth: number | undefined;
 
+	// Safety: cap at 100 rows to prevent terminal overflow
+	const MAX_ROWS = 100;
+
 	function stateIcon(state: string): string {
 		switch (state) {
 			case "running": return "⟳";
@@ -41,6 +60,7 @@ export function createDashboard(
 			case "executing": return "⚡";
 			case "verifying": return "🔍";
 			case "done": return "✅";
+			case "needs_input": return "⚠";
 			default: return "?";
 		}
 	}
@@ -50,6 +70,7 @@ export function createDashboard(
 			case "running": case "executing": return "warning";
 			case "completed": case "done": return "success";
 			case "failed": case "killed": return "error";
+			case "needs_input": return "warning";
 			default: return "muted";
 		}
 	}
@@ -66,25 +87,86 @@ export function createDashboard(
 		}
 	}
 
-	function buildRows(): DashboardRow[] {
-		const result: DashboardRow[] = [];
+	function buildGroups(): Group[] {
+		const allThreads = registry.all();
+		const allStories = registry.allStories();
 
-		// Stories first
-		for (const s of registry.allStories()) {
-			const phases = s.phases.map((p) => `${stateIcon(p.state)}${p.name}`).join("→");
-			const display = `📖 ${theme.fg("accent", s.id)} [${theme.fg(stateColor(s.state), s.state)}] ${s.goal.slice(0, 45)} ${theme.fg("dim", phases)}`;
-			result.push({ id: s.id, kind: "story", label: s.goal, display });
-		}
+		const needsInput: Row[] = [];
+		const working: Row[] = [];
+		const done: Row[] = [];
 
-		// Then threads
-		for (const t of registry.all()) {
+		for (const t of allThreads) {
 			const sum = registry.summarize(t);
-			const be = sum.backend === "subagent" ? theme.fg("dim", " [sub]") : "";
-			const display = `${typeIcon(sum.type)} ${theme.fg("accent", sum.id)} ${sum.type} [${theme.fg(stateColor(sum.state), sum.state)}] ${sum.progress} (${sum.elapsed})${be} ${sum.label.slice(0, 40)}`;
-			result.push({ id: sum.id, kind: "thread", label: sum.label, display });
+			const row: Row = {
+				id: sum.id,
+				kind: "thread",
+				label: sum.label,
+				state: sum.state,
+				progress: sum.progress,
+				elapsed: sum.elapsed,
+				result: t.tasks.find(x => x.result)?.result?.slice(0, 80) ?? "",
+				error: t.tasks.find(x => x.error)?.error?.slice(0, 80) ?? "",
+				type: t.type ?? "",
+			};
+			if (sum.state === "needs_input") needsInput.push(row);
+			else if (["running", "pending", "executing", "verifying", "planning"].includes(sum.state as string)) working.push(row);
+			else done.push(row);
+		}
+
+		for (const s of allStories) {
+			const row: Row = {
+				id: s.id,
+				kind: "story",
+				label: s.goal,
+				state: s.state,
+				progress: "",
+				elapsed: "",
+				result: "",
+				error: "",
+				type: "story",
+			};
+			if ((s.state as string) === "done" || (s.state as string) === "failed" || (s.state as string) === "completed") done.push(row);
+			else working.push(row);
+		}
+
+		const result: Group[] = [];
+		if (needsInput.length > 0) result.push({ name: "Needs Input", icon: "⚠", color: "warning", rows: needsInput });
+		if (working.length > 0) result.push({ name: "Working", icon: "⟳", color: "warning", rows: working });
+		if (done.length > 0) result.push({ name: "Done", icon: "✓", color: "success", rows: done });
+
+		if (searchQuery) {
+			const q = searchQuery.toLowerCase();
+			for (const g of result) {
+				g.rows = g.rows.filter(r => r.label.toLowerCase().includes(q) || r.id.toLowerCase().includes(q));
+			}
+		}
+
+		for (const g of result) {
+			if (g.rows.length > MAX_ROWS) g.rows.length = MAX_ROWS;
+		}
+
+		return result.filter(g => g.rows.length > 0);
+	}
+
+	function totalRows(): number {
+		let n = 0;
+		for (const g of groups) n += g.rows.length;
+		return n;
+	}
+
+	function getSelected(): { group: number; row: number } | null {
+		let idx = 0;
+		for (let gi = 0; gi < groups.length; gi++) {
+			for (let ri = 0; ri < groups[gi].rows.length; ri++) {
+				if (idx === selected) return { group: gi, row: ri };
+				idx++;
+			}
 		}
+		return null;
+	}
 
-		return result;
+	function ensureGroups() {
+		if (groups.length === 0) groups = buildGroups();
 	}
 
 	function renderExpanded(id: string, width: number): string[] {
@@ -92,7 +174,6 @@ export function createDashboard(
 		const indent = "    ";
 		const maxW = width - 6;
 
-		// Thread detail
 		const t = registry.get(id);
 		if (t) {
 			lines.push(theme.fg("accent", theme.bold(`  Thread ${t.id} (${t.type}) — ${t.state}`)));
@@ -113,7 +194,6 @@ export function createDashboard(
 			return lines;
 		}
 
-		// Story detail
 		const s = registry.getStory(id);
 		if (s) {
 			lines.push(theme.fg("accent", theme.bold(`  Story ${s.id} — ${s.state}`)));
@@ -132,82 +212,177 @@ export function createDashboard(
 		return [theme.fg("error", `  ${id} not found`)];
 	}
 
+	function tw(s: string, w: number): string {
+		return truncateToWidth(s, Math.max(1, w));
+	}
+
 	const component = {
 		handleInput(data: string) {
+			if (replyTarget !== null) {
+				if (matchesKey(data, Key.enter)) {
+					onReply?.(replyTarget, replyBuffer);
+					replyTarget = null;
+					replyBuffer = "";
+					cachedWidth = undefined;
+				} else if (matchesKey(data, Key.escape)) {
+					replyTarget = null;
+					replyBuffer = "";
+					cachedWidth = undefined;
+				} else if (data.length === 1 && !data.startsWith("\x1b") && data !== "[" && data !== "o") {
+					replyBuffer += data;
+					cachedWidth = undefined;
+				} else if (data === "Backspace" || data === "\x7f") {
+					replyBuffer = replyBuffer.slice(0, -1);
+					cachedWidth = undefined;
+				}
+				return;
+			}
+
 			if (matchesKey(data, Key.escape) || data === "q") {
 				onClose();
 				return;
 			}
-			if (matchesKey(data, Key.up) && selected > 0) {
-				selected--;
-				expanded = null;
+			if (data === "/") {
+				showSearch = !showSearch;
+				if (!showSearch) { searchQuery = ""; }
 				cachedWidth = undefined;
+				return;
 			}
-			if (matchesKey(data, Key.down) && selected < rows.length - 1) {
-				selected++;
-				expanded = null;
+			if (showSearch && data.length === 1) {
+				searchQuery += data;
 				cachedWidth = undefined;
+				return;
 			}
-			if (matchesKey(data, Key.enter) && rows[selected]) {
-				expanded = expanded === rows[selected].id ? null : rows[selected].id;
+			if (showSearch && (data === "Backspace" || data === "\x7f")) {
+				searchQuery = searchQuery.slice(0, -1);
 				cachedWidth = undefined;
+				return;
 			}
-			if (data === "k" && rows[selected]) {
-				onKill?.(rows[selected].id);
-				cachedWidth = undefined;
+
+			const total = totalRows();
+			if (matchesKey(data, Key.up) && selected > 0) { selected--; ensureGroups(); }
+			if (matchesKey(data, Key.down) && selected < total - 1) { selected++; ensureGroups(); }
+
+			if (data === "i") {
+				const sel = getSelected();
+				if (sel) {
+					replyTarget = groups[sel.group].rows[sel.row].id;
+					replyBuffer = "";
+					cachedWidth = undefined;
+				}
+				return;
 			}
-			if (data === "r" && rows[selected]) {
-				onReview?.(rows[selected].id);
-				cachedWidth = undefined;
+			if (matchesKey(data, Key.enter)) {
+				const sel = getSelected();
+				if (sel) {
+					const id = groups[sel.group].rows[sel.row].id;
+					expanded = expanded === id ? null : id;
+					cachedWidth = undefined;
+				}
+				return;
 			}
-			if (data === "p") {
-				registry.prune();
-				cachedWidth = undefined;
+			if (data === "k") {
+				const sel = getSelected();
+				if (sel) { onKill?.(groups[sel.group].rows[sel.row].id); cachedWidth = undefined; }
+				return;
 			}
+			if (data === "r") {
+				const sel = getSelected();
+				if (sel) { onReview?.(groups[sel.group].rows[sel.row].id); cachedWidth = undefined; }
+				return;
+			}
+			if (data === "p") { registry.prune(); ensureGroups(); cachedWidth = undefined; }
 		},
 
 		render(width: number): string[] {
-			// Rebuild rows every render (state changes)
-			rows = buildRows();
-
-			if (selected >= rows.length) selected = Math.max(0, rows.length - 1);
+			groups = buildGroups();
+			const total = totalRows();
+			if (selected >= total && total > 0) selected = total - 1;
 
 			const lines: string[] = [];
 			const border = "─".repeat(Math.min(width - 4, 80));
 
-			// Header
 			lines.push("");
 			lines.push(theme.fg("accent", theme.bold("  🧵 Thread Dashboard")));
-			lines.push(theme.fg("dim", `  ${border}`));
+			lines.push(theme.fg("dim", `  ${tw(border, width)}`));
 
-			if (rows.length === 0) {
+			if (groups.length === 0 && total === 0) {
 				lines.push("");
 				lines.push(theme.fg("muted", "  No threads or stories."));
 				lines.push(theme.fg("dim", "  Use /pthread /fthread /zthread /story to start."));
 			} else {
-				lines.push("");
-				for (let i = 0; i < rows.length; i++) {
-					const prefix = i === selected ? theme.fg("accent", " ▸ ") : "   ";
-					const row = rows[i];
-					const line = prefix + truncateToWidth(row.display, width - 4);
-					lines.push(line);
-
-					// Show expanded detail
-					if (expanded === row.id) {
-						lines.push(...renderExpanded(row.id, width));
-						lines.push("");
+				let flatIdx = 0;
+				for (const g of groups) {
+					// Group header
+					const gColor = g.color === "success" ? "success" : "accent";
+					lines.push("");
+					lines.push(theme.fg(gColor, `  ${g.icon} ${g.name} (${g.rows.length})`));
+
+					for (const row of g.rows) {
+						const isSelected = flatIdx === selected;
+						const prefix = isSelected ? theme.fg("accent", " ▸ ") : "   ";
+
+						let display: string;
+						if (row.kind === "story") {
+							const s = registry.getStory(row.id);
+							if (s) {
+								const phases = s.phases.map(p => `${stateIcon(p.state)}${p.name}`).join("→");
+								display = `📖 ${theme.fg("accent", row.id)} [${theme.fg(stateColor(row.state), row.state)}] ${tw(row.label, 22)} ${theme.fg("dim", tw(phases, 16))}`;
+							} else {
+								display = `📖 ${theme.fg("accent", row.id)} ${tw(row.label, 50)}`;
+							}
+						} else {
+							// Thread with progress bar + last output snippet
+							let progressBar = "░░░░░░░░░░";
+							if (row.result) {
+								progressBar = "██████████"; // done
+							} else if (row.state === "running" || row.state === "executing") {
+								progressBar = "████░░░░░░"; // in progress
+							} else if (row.state === "failed") {
+								progressBar = "✗✗✗✗✗✗✗✗✗✗"; // failed
+							}
+							const snippet = row.result
+								? `→${row.result.slice(0, 40)}`
+								: row.error
+									? `✗${row.error.slice(0, 40)}`
+								: row.elapsed
+									? `⏱${row.elapsed}`
+								: "";
+							display = `${typeIcon(row.type)} ${theme.fg("accent", row.id)} ${progressBar} [${theme.fg(stateColor(row.state), row.state)}] ${tw(row.label, 20)} ${theme.fg("muted", tw(snippet, 22))}`;
+						}
+
+						lines.push(tw(prefix + display, width));
+
+						if (isSelected && expanded === row.id) {
+							lines.push(...renderExpanded(row.id, width));
+							lines.push("");
+						}
+						flatIdx++;
 					}
 				}
 			}
 
+			// Reply mode banner
+			if (replyTarget !== null) {
+				lines.push("");
+				lines.push(tw(theme.fg("warning", theme.bold("  ┌─ REPLY ─────────────────────────────┐")), width));
+				lines.push(tw(theme.fg("warning", `  │ ${tw(replyTarget || "", 28).padEnd(28)} │`), width));
+				lines.push(tw(theme.fg("warning", `  │ ${tw(replyBuffer || "(type message)", 28).padEnd(28)} │`), width));
+				lines.push(tw(theme.fg("warning", `  │ Enter=send  Esc=cancel               │`), width));
+				lines.push(tw(theme.fg("warning", theme.bold("  └──────────────────────────────────────┘")), width));
+			}
+
 			// Footer
 			lines.push("");
-			lines.push(theme.fg("dim", `  ${border}`));
-			const help = "↑↓ navigate  Enter expand  k kill  r review  p prune  q close";
+			lines.push(theme.fg("dim", `  ${tw(border, width)}`));
+			const help = showSearch
+				? tw(`Search: ${searchQuery}_  Enter done  Esc cancel`, width - 4)
+				: tw("nav=↑↓ exp=Enter rep=i srch=/ kill=k rev=r prune=p quit=q", width - 4);
 			lines.push(theme.fg("dim", `  ${help}`));
 			lines.push("");
 
-			return lines;
+			// Final safety: truncate ALL lines
+			return lines.map(l => tw(l, width));
 		},
 
 		invalidate() {
@@ -216,4 +391,4 @@ export function createDashboard(
 	};
 
 	return component;
-}
+}