pi-thread-engine 0.4.6 → 0.4.9

package/docs/HELLO_PYTHON.md

@@ -0,0 +1,68 @@
+# Python `hello_world()` Utility
+
+> A lightweight Python entry point for pi-thread-engine — useful for
+> Pi extension scripts that prefer Python over TypeScript.
+
+## Purpose
+
+Mirrors the TypeScript `helloWorld()` function (`src/hello.ts`) as a
+simple verification utility. Calling `hello_world()` returns the
+canonical greeting string `"Hello, World!"` with zero side effects.
+
+## Usage
+
+### Import
+
+```python
+from scripts.hello import hello_world
+
+greeting = hello_world()
+print(greeting)  # Hello, World!
+```
+
+### CLI invocation
+
+```bash
+python scripts/hello.py
+# Hello, World!
+```
+
+## Tests
+
+```bash
+python -m unittest scripts/test_hello.py -v
+```
+
+Expected output:
+
+```
+test_returns_hello_world_string (scripts.test_hello.TestHelloWorld.test_returns_hello_world_string)
+hello_world() should return exactly 'Hello, World!'. ... ok
+test_returns_string_type (scripts.test_hello.TestHelloWorld.test_returns_string_type)
+hello_world() should return a str instance. ... ok
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.000s
+
+OK
+```
+
+## Implementation
+
+| Aspect | Detail |
+|--------|--------|
+| **File** | `scripts/hello.py` |
+| **Function** | `hello_world() -> str` |
+| **Return value** | `"Hello, World!"` |
+| **Framework** | Python 3 (stdlib only) |
+| **Test framework** | `unittest` (stdlib) |
+| **Test file** | `scripts/test_hello.py` |
+
+## Integration
+
+The Python test is integrated into the project's test suite via
+`scripts/test.sh` (step 4). Run the full suite with:
+
+```bash
+bash scripts/test.sh
+```

package/extensions/index.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { Type, type TUnsafe } from "@sinclair/typebox";
 import { Text } from "@mariozechner/pi-tui";
 
@@ -18,8 +18,10 @@ import { ThreadRegistry, formatElapsed } from "../src/core/registry.js";
 import { ThreadExecutor } from "../src/core/executor.js";
 import { createDashboard } from "../src/dashboard.js";
 import type { Thread, ThreadType, Story, StoryPhase } from "../src/core/types.js";
-import { writeFileSync } from "fs";
-import { join } from "path";
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+import { createWorktree, removeWorktree, listWorktrees, pushWorktreeChanges, cleanupAll, isGitRepo, branchName, findRepoRoot } from "../src/core/worktree.js";
+import { helloWorld } from "../src/hello-world.js";
 
 // ── Export helper ───────────────────────────────────────────
 function exportThread(id: string, r: ThreadRegistry, cwd: string): string | null {
@@ -54,7 +56,11 @@ export default function (pi: ExtensionAPI) {
 		const threads = registry.all().filter((t) => t.state !== "killed");
 		const stories = registry.allStories();
 		if (threads.length > 0 || stories.length > 0) {
-			pi.appendEntry("pi-threads-state", { threads, stories, timestamp: Date.now() });
+			try {
+				pi.appendEntry("pi-threads-state", { threads, stories, timestamp: Date.now() });
+			} catch {
+				// Extension contexts can go stale after session replacement; persistence is best-effort.
+			}
 		}
 	}
 
@@ -80,8 +86,10 @@ export default function (pi: ExtensionAPI) {
 
 	// ── Status bar ───────────────────────────────────────────────
 
+	let clearStatusHandler: (() => void) | undefined;
 	pi.on("session_start", async (_event, ctx) => {
-		registry.on(() => {
+		clearStatusHandler?.();
+		clearStatusHandler = registry.on(() => {
 			const running = registry.byState("running");
 			const stories = registry.allStories().filter((s) => s.state === "executing" || s.state === "planning");
 			const parts: string[] = [];
@@ -98,7 +106,11 @@ export default function (pi: ExtensionAPI) {
 				);
 			}
 
-			ctx.ui.setStatus("pi-threads", parts.length > 0 ? parts.join(" ") : undefined);
+			try {
+				ctx.ui.setStatus("pi-threads", parts.length > 0 ? parts.join(" ") : undefined);
+			} catch {
+				// Status updates are best-effort; command/session contexts may go stale.
+			}
 		});
 	});
 
@@ -124,6 +136,7 @@ export default function (pi: ExtensionAPI) {
 		return tasks;
 	}
 
+
 	function stateIcon(state: string): string {
 		switch (state) {
 			case "running": return "⟳";
@@ -137,16 +150,54 @@ export default function (pi: ExtensionAPI) {
 
 	function typeIcon(type: string): string {
 		switch (type) {
+			case "base": return "•";
 			case "parallel": return "⫘";
 			case "chained": return "⟶";
 			case "fusion": return "⊕";
 			case "meta": return "◎";
 			case "long": return "∞";
 			case "zero": return "⊘";
+			case "worktree": return "🌳";
+			case "plan": return "⌁";
+			case "scheduled": return "⏰";
 			default: return "·";
 		}
 	}
 
+	async function openDashboard(ctx: ExtensionCommandContext) {
+		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) {
+						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) => {
+					executor.injectReply(id, message);
+					ctx.ui.notify(`Replied to ${id}: ${message.slice(0, 50)}...`, "info");
+					tui.requestRender();
+				},
+				(id) => { const p = exportThread(id, registry, ctx.cwd); if (p) ctx.ui.notify(`Exported to ${p}`, "info"); }
+			);
+
+			return {
+				render: (w: number) => dashboard.render(w),
+				invalidate: () => dashboard.invalidate(),
+				handleInput: (data: string) => { dashboard.handleInput(data); tui.requestRender(); },
+			};
+		});
+	}
+
 	// ── /threads — unified TUI dashboard ─────────────────────────
 
 	pi.registerCommand("threads", {
@@ -240,69 +291,21 @@ export default function (pi: ExtensionAPI) {
 				}
 				const ts = new Date().toISOString().slice(0, 19).replace(/[T:]/g, "-");
 				const fn = "threads-" + ts + ".md";
-				const outPath = require("path").join(ctx.cwd, fn);
-				require("fs").writeFileSync(outPath, md.join("\n"), "utf8");
+				const outPath = join(ctx.cwd, fn);
+				writeFileSync(outPath, md.join("\n"), "utf8");
 				ctx.ui.notify("Exported to " + outPath, "info");
 				return;
 			}
 
-			// 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(); },
-							(id) => { const p = exportThread(id, registry, ctx.cwd); if (p) ctx.ui.notify(`Exported to ${p}`, "info"); }
-						);
-						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,
-					theme,
-					() => done(),
-					(id) => {
-						registry.kill(id);
-						ctx.ui.notify(`Killed ${id}`, "warning");
-						tui.requestRender();
-					},
-					(id) => {
-						const t = registry.get(id);
-						if (t) {
-							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();
-					},
-					(id) => { const p = exportThread(id, registry, ctx.cwd); if (p) ctx.ui.notify(`Exported to ${p}`, "info"); }
-				);
-
-				return {
-					render: (w: number) => dashboard.render(w),
-					invalidate: () => dashboard.invalidate(),
-					handleInput: (data: string) => { dashboard.handleInput(data); tui.requestRender(); },
-				};
-			});
+			await openDashboard(ctx);
 		},
 	});
 
+	pi.registerCommand("agents", {
+		description: "Alias for /threads — Claude-style Agent View dashboard",
+		handler: async (_args, ctx) => openDashboard(ctx),
+	});
+
 	// ── /pthread — parallel via subagent ─────────────────────────
 
 	pi.registerCommand("pthread", {
@@ -320,19 +323,24 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	// ── /cthread — chained via subagent ──────────────────────────
+	// ── /cthread — chained with human checkpoints ─────────────────
 
 	pi.registerCommand("cthread", {
-		description: 'C-Thread: sequential phases via subagent chain. Usage: /cthread "phase 1" "phase 2"',
+		description: 'C-Thread: sequential phases with human checkpoints. Usage: /cthread "phase 1" "phase 2"',
 		handler: async (args, ctx) => {
 			if (!args?.trim()) { ctx.ui.notify('Usage: /cthread "phase 1" "phase 2"', "error"); return; }
 			const phases = parseTaskArgs(args);
 			if (phases.length < 2) { ctx.ui.notify("Need at least 2 phases", "error"); return; }
 
-			const thread = registry.create("chained", `Chain: ${phases.length} phases`, phases, { cwd: ctx.cwd, backend: "subagent" });
+			const thread = registry.create("chained", `Chain: ${phases.length} phases`, phases, { cwd: ctx.cwd, backend: "native" });
 
-			ctx.ui.notify(`🧵 C-Thread ${thread.id}: ${phases.length} phases via subagent chain...`, "info");
-			executor.dispatch(thread);
+			ctx.ui.notify(`🧵 C-Thread ${thread.id}: ${phases.length} phases with checkpoints...`, "info");
+			executor.dispatch(thread, {
+				onCheckpoint: async (phase, task) => ctx.ui.confirm(
+					"C-Thread checkpoint",
+					`Phase ${phase} complete. Continue to phase ${phase + 1}: ${task.label}?`
+				),
+			});
 		},
 	});
 
@@ -468,6 +476,236 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── /wthread — worktree isolation (port from Grok CLI) ────
+
+	pi.registerCommand("wthread", {
+		description: 'W-Thread: run task in isolated git worktree. Usage: /wthread "task" or /wthread list, push, discard, cleanup',
+		handler: async (args, ctx) => {
+			if (!args?.trim()) {
+				ctx.ui.notify('Usage: /wthread "task" | /wthread list | /wthread push <id> [message] | /wthread discard <id> | /wthread cleanup', "error");
+				return;
+			}
+
+			// Subcommands
+			const parts = args.trim().split(/\s+/);
+			const sub = parts[0].toLowerCase();
+
+			if (sub === "list") {
+				if (!isGitRepo(ctx.cwd)) { ctx.ui.notify("Not in a git repo", "error"); return; }
+				const wts = listWorktrees(ctx.cwd);
+				if (wts.length === 0) { ctx.ui.notify("No active worktrees", "info"); return; }
+				const lines = wts.map((w) =>
+					`  ${w.threadId} → ${w.branch} @ ${w.path} ${w.dirty ? "⚠ dirty" : ""} (↑${w.ahead} ↓${w.behind})`
+				);
+				ctx.ui.notify(`Worktrees (${wts.length}):\n${lines.join("\n")}`, "info");
+				return;
+			}
+
+			if (sub === "cleanup") {
+				if (!isGitRepo(ctx.cwd)) { ctx.ui.notify("Not in a git repo", "error"); return; }
+				const result = cleanupAll(ctx.cwd);
+				ctx.ui.notify(`Cleaned: ${result.removed} worktrees (${result.failed} failed)`, result.failed > 0 ? "warning" : "info");
+				return;
+			}
+
+			if (sub === "push") {
+				if (parts.length < 2) { ctx.ui.notify('Usage: /wthread push <id> [message]', "error"); return; }
+				const threadId = parts[1];
+				const msg = parts.slice(2).join(" ") || undefined;
+				const ok = pushWorktreeChanges(ctx.cwd, threadId, msg);
+				ctx.ui.notify(ok ? `Pushed ${threadId} changes` : "Push failed", ok ? "info" : "error");
+				return;
+			}
+
+			if (sub === "discard" || sub === "remove") {
+				if (parts.length < 2) { ctx.ui.notify('Usage: /wthread discard <id>', "error"); return; }
+				const threadId = parts[1];
+				const ok = removeWorktree(ctx.cwd, threadId);
+				ctx.ui.notify(ok ? `Discarded ${threadId} worktree` : "Discard failed", ok ? "info" : "error");
+				return;
+			}
+
+			// Default: create worktree and run task
+			if (!isGitRepo(ctx.cwd)) { ctx.ui.notify("Not in a git repo — can't create worktree", "error"); return; }
+
+			const task = args.trim();
+			const thread = registry.create("worktree", `W: ${task.slice(0, 40)}`, [task], {
+				cwd: ctx.cwd,
+				backend: "native",
+			});
+
+			ctx.ui.notify(`🌳 W-Thread ${thread.id}: Creating worktree for "${task.slice(0, 50)}"...`, "info");
+
+			executor.dispatch(thread).then(() => {
+				if (thread.state === "completed") {
+					ctx.ui.notify(`✅ W-Thread ${thread.id} done in worktree! Use /wthread push ${thread.id} to merge.`, "info");
+				} else {
+					ctx.ui.notify(`❌ W-Thread ${thread.id} ${thread.state}`, "error");
+				}
+			});
+		},
+	});
+
+	// ── /plan — Plan mode (port from Grok CLI) ────────────────
+
+	let planFile: string | null = null;
+	let planApproved = false;
+
+	pi.registerCommand("plan", {
+		description: 'Plan mode: write, review, and approve a plan before execution. Usage: /plan "goal" | /plan approve | /plan reject | /plan status',
+		handler: async (args, ctx) => {
+			if (!args?.trim()) {
+				ctx.ui.notify("Usage: /plan <goal> | /plan approve | /plan reject | /plan status", "error");
+				return;
+			}
+
+			const sub = args.trim().toLowerCase();
+
+			if (sub === "approve") {
+				if (!planFile) { ctx.ui.notify("No active plan. Use /plan \"goal\" first.", "error"); return; }
+				planApproved = true;
+				ctx.ui.notify("✅ Plan approved! You can now execute the planned work.", "info");
+				return;
+			}
+
+			if (sub === "reject") {
+				planFile = null;
+				planApproved = false;
+				ctx.ui.notify("✗ Plan rejected. Revise and re-submit with /plan \"goal\".", "warning");
+				return;
+			}
+
+			if (sub === "status") {
+				if (planFile && existsSync(planFile)) {
+					const content = readFileSync(planFile, "utf8");
+					const status = planApproved ? "✅ Approved" : "⏳ Awaiting approval";
+					ctx.ui.notify(`Plan status: ${status}\n\n${content.slice(0, 1000)}`, "info");
+				} else {
+					ctx.ui.notify("No active plan.", "info");
+				}
+				return;
+			}
+
+			// Create a new plan
+			const goal = args.trim();
+			planApproved = false;
+
+			// Create plan directory
+			const planDir = join(ctx.cwd, ".pi", "plans");
+			if (!existsSync(planDir)) mkdirSync(planDir, { recursive: true });
+			const ts = new Date().toISOString().slice(0, 19).replace(/[T:]/g, "-");
+			planFile = join(planDir, `plan-${ts}.md`);
+
+			const planMd = [
+				`# Plan: ${goal}`,
+				"",
+				"## Goal",
+				goal,
+				"",
+				"## Approach",
+				"(Generated by agent — review and edit before approving)",
+				"",
+				"## Steps",
+				"1. ",
+				"2. ",
+				"3. ",
+				"",
+				"## Verification",
+				"- ",
+				"",
+				"---",
+				`Created: ${new Date().toISOString()}`,
+				"Status: draft (run `/plan approve` to approve, `/plan reject` to reject)",
+			].join("\n");
+
+			writeFileSync(planFile, planMd, "utf8");
+			ctx.ui.notify(
+				`📋 Plan created at ${planFile}\nReview it, then run /plan approve or /plan reject.`,
+				"info"
+			);
+		},
+	});
+
+	// ── /loop — Scheduled recurring tasks (port from Grok CLI) ─
+
+	const scheduler = new Map<string, { interval: number; prompt: string; timer: ReturnType<typeof setInterval> | null }>();
+
+	function parseInterval(input: string): number | null {
+		const m = input.match(/^(\d+)(s|m|h|d)$/);
+		if (!m) return null;
+		const n = parseInt(m[1]);
+		switch (m[2]) {
+			case "s": return n * 1000;
+			case "m": return n * 60 * 1000;
+			case "h": return n * 3600 * 1000;
+			case "d": return n * 86400 * 1000;
+			default: return null;
+		}
+	}
+
+	pi.registerCommand("loop", {
+		description: 'Schedule a recurring task. Usage: /loop 5m "check test status" | /loop list | /loop stop <id>',
+		handler: async (args, ctx) => {
+			if (!args?.trim()) {
+				ctx.ui.notify("Usage: /loop <interval> <prompt> | /loop list | /loop stop <id>", "error");
+				return;
+			}
+
+			const parts = args.trim().split(/\s+/);
+			const sub = parts[0].toLowerCase();
+
+			if (sub === "list") {
+				if (scheduler.size === 0) { ctx.ui.notify("No scheduled tasks.", "info"); return; }
+				const lines: string[] = [];
+				for (const [id, task] of scheduler) {
+					const intervalStr = `${task.interval / 1000}s`;
+					lines.push(`  ${id}: every ${intervalStr} — "${task.prompt.slice(0, 50)}"`);
+				}
+				ctx.ui.notify(`Scheduled tasks (${scheduler.size}):\n${lines.join("\n")}`, "info");
+				return;
+			}
+
+			if (sub === "stop" && parts.length >= 2) {
+				const id = parts[1];
+				const task = scheduler.get(id);
+				if (!task) { ctx.ui.notify(`No scheduled task with id ${id}`, "error"); return; }
+				if (task.timer) clearInterval(task.timer);
+				scheduler.delete(id);
+				ctx.ui.notify(`Stopped ${id}`, "info");
+				return;
+			}
+
+			// Parse: /loop 5m "prompt"
+			const intervalStr = parts[0];
+			const interval = parseInterval(intervalStr);
+			if (!interval) { ctx.ui.notify(`Invalid interval: ${intervalStr}. Use format: 30s, 5m, 2h, 1d`, "error"); return; }
+
+			const prompt = parts.slice(1).join(" ");
+			if (!prompt) { ctx.ui.notify("No prompt specified", "error"); return; }
+
+			const id = `loop-${Date.now()}`;
+			ctx.ui.notify(`⏰ /loop ${id}: every ${intervalStr} — "${prompt.slice(0, 50)}"`, "info");
+
+			// Fire immediately
+			const thread = registry.create("scheduled", `Loop: ${prompt.slice(0, 40)}`, [prompt], {
+				cwd: ctx.cwd,
+				backend: "native",
+			});
+			executor.dispatch(thread);
+
+			// Schedule recurring
+			const timer = setInterval(() => {
+				const t = registry.create("scheduled", `Loop: ${prompt.slice(0, 40)}`, [prompt], {
+					cwd: ctx.cwd,
+					backend: "native",
+				});
+				executor.dispatch(t);
+			}, interval);
+
+			scheduler.set(id, { interval, prompt, timer });
+		},
+	});
+
 	// ── /story — STORIES (the unique layer) ──────────────────────
 
 	pi.registerCommand("story", {
@@ -556,6 +794,16 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── /hello — Greeting command ───────────────────────────────
+
+	pi.registerCommand("hello", {
+		description: 'Say hello. Usage: /hello [name]',
+		handler: async (args, ctx) => {
+			const name = args?.trim() || undefined;
+			ctx.ui.notify(helloWorld(name), "info");
+		},
+	});
+
 	// ── LLM-callable tools ───────────────────────────────────────
 
 	pi.registerTool({
@@ -563,15 +811,19 @@ export default function (pi: ExtensionAPI) {
 		label: "Thread Spawn",
 		description: [
 			"Spawn a thread. Types:",
+			"- base: one prompt -> tool calls -> review (native)",
 			"- parallel: N independent tasks in parallel (via subagent)",
-			"- chained: sequential phases with checkpoints (via subagent)",
-			"- meta: scout→plan→build→review pipeline (via subagent)",
+			"- chained: sequential phases with human checkpoints (native)",
+			"- meta: scout -> plan -> build -> review pipeline (via subagent)",
 			"- fusion: same prompt to N agents/models, compare results (native, UNIQUE)",
 			"- zero: autonomous + verification command gate (native, UNIQUE)",
 			"- long: extended autonomous run (native)",
+			"- worktree: run in isolated git worktree (native, extension beyond article)",
+			"- plan: structured plan -> approve -> execute gate (native, extension beyond article)",
+			"- scheduled: recurring scheduled task (native, extension beyond article)",
 		].join("\n"),
 		parameters: Type.Object({
-			type: StringEnum(["parallel", "fusion", "chained", "meta", "long", "zero"] as const),
+			type: StringEnum(["base", "parallel", "fusion", "chained", "meta", "long", "zero", "worktree", "plan", "scheduled"] as const),
 			prompts: Type.Array(Type.String(), { description: "Task prompts" }),
 			models: Type.Optional(Type.Array(Type.String(), { description: "Models for fusion (e.g. ['anthropic/claude-sonnet-4', 'google/gemini-2.5-pro'])" })),
 			count: Type.Optional(Type.Number({ description: "Agent count for fusion (default 3)" })),
@@ -592,8 +844,9 @@ export default function (pi: ExtensionAPI) {
 				taskPrompts = [prompts[0]]; // Meta delegates to subagent chain internally
 			}
 
-			// Auto-select backend
-			const backend = backendOverride ?? (type === "fusion" || type === "zero" || type === "long" ? "native" : "subagent");
+			// Auto-select backend: P/B use subagents; C/F/L/Z and extension types run natively.
+			const nativeTypes = new Set(["base", "chained", "fusion", "zero", "long", "worktree", "plan", "scheduled"]);
+			const backend: import("../src/core/types.js").ExecutionBackend = (backendOverride as import("../src/core/types.js").ExecutionBackend) ?? (nativeTypes.has(String(type)) ? "native" as const : "subagent" as const);
 
 			const label = type === "fusion"
 				? `Fusion: ${prompts[0]?.slice(0, 40)}`
@@ -608,7 +861,12 @@ export default function (pi: ExtensionAPI) {
 			});
 
 			// Dispatch (async — runs in background)
-			executor.dispatch(thread);
+			executor.dispatch(thread, type === "chained" ? {
+				onCheckpoint: async (phase, task) => ctx.ui.confirm(
+					"C-Thread checkpoint",
+					`Phase ${phase} complete. Continue to phase ${phase + 1}: ${task.label}?`
+				),
+			} : undefined);
 
 			const modelInfo = models ? ` Models: ${models.join(", ")}` : "";
 			const verifyInfo = verify ? ` Verify: ${verify}` : "";
@@ -622,7 +880,7 @@ export default function (pi: ExtensionAPI) {
 				details: { threadId: thread.id, type, taskCount: taskPrompts.length, backend },
 			};
 		},
-		renderCall(args, theme) {
+		renderCall(args: any, theme: any) {
 			return new Text(
 				theme.fg("toolTitle", theme.bold("thread_spawn ")) +
 					theme.fg("accent", args.type) +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-thread-engine",
-  "version": "0.4.6",
+  "version": "0.4.9",
   "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",
@@ -21,22 +21,31 @@
   "pi": {
     "extensions": [
       "./extensions/index.ts"
-    ]
+    ],
+    "commands": ["threads","agents","pthread","cthread","bthread","fthread","zthread","lthread","wthread","plan","tloop","story","stories","hello"],
+    "tools": ["thread_spawn","thread_status","thread_kill"]
   },
   "files": [
+    "_lib/",
     "extensions/",
     "src/",
     "README.md",
     "PLAN.md",
     "docs/"
   ],
+  "scripts": {
+    "build": "bash scripts/build.sh",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
   "devDependencies": {
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": ">=0.73.0",
-    "@mariozechner/pi-tui": ">=0.73.0",
-    "@mariozechner/pi-ai": ">=0.73.0",
+    "@earendil-works/pi-ai": ">=0.73.0",
+    "@earendil-works/pi-coding-agent": ">=0.73.0",
+    "@earendil-works/pi-tui": ">=0.73.0",
     "@sinclair/typebox": "^0.34.48"
   }
 }