@structupath/pi-tilldone 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 StructuPath LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# pi-tilldone
+
+Task discipline for the [Pi coding agent](https://pi.dev): the agent **must declare what it's going to do before it's allowed to do it** — and gets nudged until it's actually done.
+
+"todo" → "tilldone": work *till* it's *done*.
+
+By [StructuPath](https://structupath.ai).
+
+## Install
+
+```bash
+pi install npm:@structupath/pi-tilldone
+```
+
+## Why
+
+Todo-list extensions record what the agent plans to do. TillDone **enforces** it:
+
+- **Hard gate** — write/execute tools are blocked until the agent creates a task list and marks a task in-progress. Read-only tools (read, grep, find, ls, glob) stay open so it can explore before planning.
+- **Single focus** — only one task can be in-progress at a time; toggling a new one auto-pauses the old one.
+- **Completion nudge** — if the agent stops with incomplete tasks, it gets pushed back to work: *"Don't stop until it's done!"* (once per user turn, so it can't loop forever).
+- **Survives everything** — state is reconstructed from the session on start, switch, fork, and tree navigation.
+
+## UI
+
+- **Footer** — live task list with title, progress `[done/total]`, and per-status counts
+- **Widget** — prominent `● WORKING ON #3 <task>` banner below the editor
+- **Status line** — compact summary
+- **/tilldone** — full-screen overlay with every task
+
+The agent drives it through a single `tilldone` tool: `new-list`, `add` (single or batch), `toggle` (cycles idle → inprogress → done), `update`, `remove`, `list`, `clear`. Destructive actions (`new-list` over an existing list, `clear`) ask **you** to confirm first.
+
+## Bonus: cmux integration
+
+If you run Pi inside [cmux](https://cmux.io), the bundled `cmux-status` extension syncs task state to your workspace tabs — at a glance, across every parallel agent:
+
+| Tab color | Meaning |
+|---|---|
+| 🟡 yellow | working — a task is in progress |
+| 🟢 green | all tasks done (+ desktop notification) |
+| 🟠 orange | blocked — tasks exist, none in progress |
+| ⚪ gray | idle — no tasks yet |
+
+Tab title shows `⚡ <list> [2/5]`, tab description shows the current task. Outside cmux it no-ops silently — zero overhead.
+
+## License
+
+MIT
+
+---
+
+More Pi packages from StructuPath: [`@structupath/pi-steel`](https://pi.dev/packages/@structupath/pi-steel) — structural steel estimating skills.

package/extensions/.a5c/logs/babysitter-stop-hook.log

@@ -0,0 +1,7 @@
+[INFO] 2026-07-20T01:12:06.965Z handleHookRunStop started
+[INFO] 2026-07-20T01:12:06.966Z Hook input received
+[INFO] 2026-07-20T01:12:06.966Z [session=a8a94862-1ef3-468c-a826-a2661f015a52] Session ID: a8a94862-1ef3-468c-a826-a2661f015a52
+[INFO] 2026-07-20T01:12:06.966Z [session=a8a94862-1ef3-468c-a826-a2661f015a52] Resolved pluginRoot: /Users/vics/.claude/plugins/cache/a5c-ai/babysitter/4.0.157
+[INFO] 2026-07-20T01:12:06.966Z [session=a8a94862-1ef3-468c-a826-a2661f015a52] Resolved stateDir: /Users/vics/.a5c/state
+[INFO] 2026-07-20T01:12:06.966Z [session=a8a94862-1ef3-468c-a826-a2661f015a52] Checking session file at: /Users/vics/.a5c/state/a8a94862-1ef3-468c-a826-a2661f015a52.md
+[INFO] 2026-07-20T01:12:06.966Z [session=a8a94862-1ef3-468c-a826-a2661f015a52] No active loop found for session a8a94862-1ef3-468c-a826-a2661f015a52 — allowing exit

package/extensions/cmux-status.ts

@@ -0,0 +1,205 @@
+/**
+ * cmux Status Extension — Colored Tabs & Progress
+ *
+ * Syncs agent task state to cmux workspace visuals:
+ * - Tab COLOR reflects status (idle/working/done/error)
+ * - Tab TITLE shows progress (emoji + task count)
+ * - Tab DESCRIPTION shows the current in-progress task
+ *
+ * Hooks into tilldone tool calls and agent lifecycle events.
+ * Only activates when running inside cmux (CMUX_WORKSPACE_ID is set).
+ *
+ * Usage: installed with @structupath/pi-tilldone; no-ops outside cmux
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+// ── Color Palette ──────────────────────────────────────────────────────
+
+const COLORS = {
+	idle: "#6b7280",     // gray — no tasks yet
+	working: "#eab308",  // yellow — tasks in progress
+	done: "#22c55e",     // green — all tasks complete
+	error: "#ef4444",    // red — something went wrong
+	blocked: "#f97316",  // orange — tasks exist but none in progress
+} as const;
+
+const STATUS_EMOJI = {
+	idle: "💤",
+	working: "⚡",
+	done: "✅",
+	error: "❌",
+	blocked: "⏸️",
+} as const;
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function isCmux(): boolean {
+	return !!process.env.CMUX_WORKSPACE_ID;
+}
+
+async function cmux(pi: ExtensionAPI, ...args: string[]): Promise<string> {
+	try {
+		const { stdout } = await pi.exec("cmux", args);
+		return stdout.trim();
+	} catch {
+		return "";
+	}
+}
+
+// ── State ──────────────────────────────────────────────────────────────
+
+let originalTitle = "";
+let originalTitleCaptured = false;
+
+type Status = keyof typeof COLORS;
+
+interface TaskSnapshot {
+	total: number;
+	done: number;
+	inprogress: number;
+	idle: number;
+	currentTask: string;
+	listTitle: string;
+}
+
+function deriveStatus(snap: TaskSnapshot): Status {
+	if (snap.total === 0) return "idle";
+	if (snap.done === snap.total) return "done";
+	if (snap.inprogress > 0) return "working";
+	if (snap.idle > 0) return "blocked";
+	return "idle";
+}
+
+function buildTitle(snap: TaskSnapshot, status: Status): string {
+	const emoji = STATUS_EMOJI[status];
+	if (snap.total === 0) return originalTitle || `${emoji} Ready`;
+
+	const progress = `${snap.done}/${snap.total}`;
+	const label = snap.listTitle || "Tasks";
+	return `${emoji} ${label} [${progress}]`;
+}
+
+function buildDescription(snap: TaskSnapshot, status: Status): string {
+	if (status === "done") return `All ${snap.total} tasks complete ✓`;
+	if (status === "idle") return "";
+	if (status === "blocked") return "Waiting — no task in progress";
+	return snap.currentTask ? `► ${snap.currentTask}` : "Working...";
+}
+
+// ── Tilldone tool result details (shared shape with tilldone.ts) ───────
+
+interface TillDoneTask {
+	id: number;
+	text: string;
+	status: "idle" | "inprogress" | "done";
+}
+
+interface TillDoneDetails {
+	tasks: TillDoneTask[];
+	listTitle?: string;
+}
+
+function snapshotFromDetails(details: TillDoneDetails): TaskSnapshot {
+	const tasks = details.tasks;
+	return {
+		total: tasks.length,
+		done: tasks.filter((t) => t.status === "done").length,
+		inprogress: tasks.filter((t) => t.status === "inprogress").length,
+		idle: tasks.filter((t) => t.status === "idle").length,
+		currentTask: tasks.find((t) => t.status === "inprogress")?.text ?? "",
+		listTitle: details.listTitle ?? "",
+	};
+}
+
+// ── Main Extension ─────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+	if (!isCmux()) return; // silently skip if not in cmux
+
+	let lastSnap: TaskSnapshot = {
+		total: 0, done: 0, inprogress: 0, idle: 0,
+		currentTask: "", listTitle: "",
+	};
+	let lastStatus: Status = "idle";
+
+	async function captureOriginalTitle() {
+		if (originalTitleCaptured) return;
+		originalTitleCaptured = true;
+		// Get current workspace name before we modify it
+		const tree = await cmux(pi, "current-workspace");
+		const match = tree.match(/workspace:\d+\s+(.+?)(?:\s+\[selected\])?$/m);
+		if (match) {
+			originalTitle = match[1].trim();
+		}
+	}
+
+	async function updateCmux(snap: TaskSnapshot) {
+		const status = deriveStatus(snap);
+		const title = buildTitle(snap, status);
+		const desc = buildDescription(snap, status);
+
+		// Only update if something changed
+		const statusChanged = status !== lastStatus;
+		const snapChanged = JSON.stringify(snap) !== JSON.stringify(lastSnap);
+		if (!statusChanged && !snapChanged) return;
+
+		lastSnap = { ...snap };
+		lastStatus = status;
+
+		// Fire all updates in parallel
+		const updates: Promise<string>[] = [
+			cmux(pi, "workspace-action", "--action", "set-color", "--color", COLORS[status]),
+			cmux(pi, "rename-workspace", title),
+		];
+		if (desc) {
+			updates.push(cmux(pi, "workspace-action", "--action", "set-description", "--description", desc));
+		} else {
+			updates.push(cmux(pi, "workspace-action", "--action", "clear-description"));
+		}
+
+		await Promise.all(updates);
+	}
+
+	// ── Hooks ──────────────────────────────────────────────────────────
+
+	pi.on("session_start", async () => {
+		await captureOriginalTitle();
+	});
+
+	// After every tilldone tool call, refresh cmux state from the
+	// structured details the tilldone tool attaches to its result
+	pi.on("tool_result", async (event) => {
+		await captureOriginalTitle();
+
+		if (event.toolName !== "tilldone") return;
+
+		const details = event.details as TillDoneDetails | undefined;
+		if (!details?.tasks) return;
+
+		await updateCmux(snapshotFromDetails(details));
+	});
+
+	// On agent end, do a final status update from the last known state
+	pi.on("agent_end", async () => {
+		if (lastSnap.total > 0) {
+			await updateCmux(lastSnap);
+			// If all done, send a notification too
+			if (lastSnap.done === lastSnap.total) {
+				await cmux(pi, "notify", "--title", "✅ All Tasks Complete",
+					"--body", `${lastSnap.listTitle}: ${lastSnap.total} tasks done`);
+			}
+		}
+	});
+
+	// Clean up on session shutdown — restore original title and clear color
+	pi.on("session_shutdown", async () => {
+		if (originalTitle) {
+			await Promise.all([
+				cmux(pi, "rename-workspace", originalTitle),
+				cmux(pi, "workspace-action", "--action", "clear-color"),
+				cmux(pi, "workspace-action", "--action", "clear-description"),
+			]);
+		}
+	});
+}

package/extensions/tilldone.ts

@@ -0,0 +1,733 @@
+/**
+ * TillDone Extension — Work Till It's Done
+ *
+ * A task-driven discipline extension. The agent MUST define what it's going
+ * to do (via `tilldone add`) before it can use any other tools. On agent
+ * completion, if tasks remain incomplete, the agent gets nudged to continue
+ * or mark them done. Play on words: "todo" → "tilldone" (work till done).
+ *
+ * Three-state lifecycle:  idle → inprogress → done
+ *
+ * Each list has a title and description that give the tasks a theme.
+ * Use `new-list` to start a fresh list. `clear` wipes tasks with user confirm.
+ *
+ * UI surfaces:
+ * - Footer:  persistent task list with live progress + list title
+ * - Widget:  prominent "current task" display (the inprogress task)
+ * - Status:  compact summary in the status line
+ * - /tilldone:  interactive overlay with full task details
+ *
+ * Usage: pi install npm:@structupath/pi-tilldone
+ */
+
+import { StringEnum } from "@mariozechner/pi-ai";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import { Container, matchesKey, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { Type } from "typebox";
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+type TaskStatus = "idle" | "inprogress" | "done";
+
+interface Task {
+	id: number;
+	text: string;
+	status: TaskStatus;
+}
+
+interface TillDoneDetails {
+	action: string;
+	tasks: Task[];
+	nextId: number;
+	listTitle?: string;
+	listDescription?: string;
+	error?: string;
+}
+
+const TillDoneParams = Type.Object({
+	action: StringEnum(["new-list", "add", "toggle", "remove", "update", "list", "clear"] as const),
+	text: Type.Optional(Type.String({ description: "Task text (for add/update), or list title (for new-list)" })),
+	texts: Type.Optional(Type.Array(Type.String(), { description: "Multiple task texts (for add). Use this to batch-add several tasks at once." })),
+	description: Type.Optional(Type.String({ description: "List description (for new-list)" })),
+	id: Type.Optional(Type.Number({ description: "Task ID (for toggle/remove/update)" })),
+});
+
+// ── Status helpers ─────────────────────────────────────────────────────
+
+const STATUS_ICON: Record<TaskStatus, string> = { idle: "○", inprogress: "●", done: "✓" };
+const NEXT_STATUS: Record<TaskStatus, TaskStatus> = { idle: "inprogress", inprogress: "done", done: "idle" };
+const STATUS_LABEL: Record<TaskStatus, string> = { idle: "idle", inprogress: "in progress", done: "done" };
+
+// ── /tilldone overlay component ────────────────────────────────────────
+
+class TillDoneListComponent {
+	private tasks: Task[];
+	private title: string | undefined;
+	private desc: string | undefined;
+	private theme: Theme;
+	private onClose: () => void;
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+
+	constructor(tasks: Task[], title: string | undefined, desc: string | undefined, theme: Theme, onClose: () => void) {
+		this.tasks = tasks;
+		this.title = title;
+		this.desc = desc;
+		this.theme = theme;
+		this.onClose = onClose;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.onClose();
+		}
+	}
+
+	render(width: number): string[] {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+
+		const lines: string[] = [];
+		const th = this.theme;
+
+		lines.push("");
+		const heading = this.title
+			? th.fg("accent", ` ${this.title} `)
+			: th.fg("accent", " TillDone ");
+		const headingLen = this.title ? this.title.length + 2 : 10;
+		lines.push(truncateToWidth(
+			th.fg("borderMuted", "─".repeat(3)) + heading +
+			th.fg("borderMuted", "─".repeat(Math.max(0, width - 3 - headingLen))),
+			width,
+		));
+
+		if (this.desc) {
+			lines.push(truncateToWidth(`  ${th.fg("muted", this.desc)}`, width));
+		}
+		lines.push("");
+
+		if (this.tasks.length === 0) {
+			lines.push(truncateToWidth(`  ${th.fg("dim", "No tasks yet. Ask the agent to add some!")}`, width));
+		} else {
+			const done = this.tasks.filter((t) => t.status === "done").length;
+			const active = this.tasks.filter((t) => t.status === "inprogress").length;
+			const idle = this.tasks.filter((t) => t.status === "idle").length;
+
+			lines.push(truncateToWidth(
+				"  " +
+				th.fg("success", `${done} done`) + th.fg("dim", "  ") +
+				th.fg("accent", `${active} active`) + th.fg("dim", "  ") +
+				th.fg("muted", `${idle} idle`),
+				width,
+			));
+			lines.push("");
+
+			for (const task of this.tasks) {
+				const icon = task.status === "done"
+					? th.fg("success", STATUS_ICON.done)
+					: task.status === "inprogress"
+						? th.fg("accent", STATUS_ICON.inprogress)
+						: th.fg("dim", STATUS_ICON.idle);
+				const id = th.fg("accent", `#${task.id}`);
+				const text = task.status === "done"
+					? th.fg("dim", task.text)
+					: task.status === "inprogress"
+						? th.fg("success", task.text)
+						: th.fg("muted", task.text);
+				lines.push(truncateToWidth(`  ${icon} ${id} ${text}`, width));
+			}
+		}
+
+		lines.push("");
+		lines.push(truncateToWidth(`  ${th.fg("dim", "Press Escape to close")}`, width));
+		lines.push("");
+
+		this.cachedWidth = width;
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}
+
+// ── Extension entry point ──────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+	let tasks: Task[] = [];
+	let nextId = 1;
+	let listTitle: string | undefined;
+	let listDescription: string | undefined;
+	let nudgedThisCycle = false;
+
+	// ── Snapshot for details ───────────────────────────────────────────
+
+	const makeDetails = (action: string, error?: string): TillDoneDetails => ({
+		action,
+		tasks: [...tasks],
+		nextId,
+		listTitle,
+		listDescription,
+		...(error ? { error } : {}),
+	});
+
+	// ── UI refresh ─────────────────────────────────────────────────────
+
+	const refreshWidget = (ctx: ExtensionContext) => {
+		const current = tasks.find((t) => t.status === "inprogress");
+
+		if (!current) {
+			ctx.ui.setWidget("tilldone-current", undefined);
+			return;
+		}
+
+		ctx.ui.setWidget("tilldone-current", (_tui, theme) => {
+			const container = new Container();
+			const borderFn = (s: string) => theme.fg("dim", s);
+
+			container.addChild(new Text("", 0, 0));
+			container.addChild(new DynamicBorder(borderFn));
+			const content = new Text("", 1, 0);
+			container.addChild(content);
+			container.addChild(new DynamicBorder(borderFn));
+
+			return {
+				render(width: number): string[] {
+					const cur = tasks.find((t) => t.status === "inprogress");
+					if (!cur) return [];
+
+					const line =
+						theme.fg("accent", "● ") +
+						theme.fg("dim", "WORKING ON  ") +
+						theme.fg("accent", `#${cur.id}`) +
+						theme.fg("dim", "  ") +
+						theme.fg("success", cur.text);
+
+					content.setText(truncateToWidth(line, width - 4));
+					return container.render(width);
+				},
+				invalidate() { container.invalidate(); },
+			};
+		}, { placement: "belowEditor" });
+	};
+
+	const refreshFooter = (ctx: ExtensionContext) => {
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			const unsub = footerData.onBranchChange(() => tui.requestRender());
+
+			return {
+				dispose: unsub,
+				invalidate() {},
+				render(width: number): string[] {
+					const done = tasks.filter((t) => t.status === "done").length;
+					const active = tasks.filter((t) => t.status === "inprogress").length;
+					const idle = tasks.filter((t) => t.status === "idle").length;
+					const total = tasks.length;
+
+					// ── Line 1: list title + progress (left), counts (right) ──
+					const titleDisplay = listTitle
+						? theme.fg("accent", ` ${listTitle} `)
+						: theme.fg("dim", " TillDone ");
+
+					const l1Left = total === 0
+						? titleDisplay + theme.fg("muted", "no tasks")
+						: titleDisplay +
+							theme.fg("warning", "[") +
+							theme.fg("success", `${done}`) +
+							theme.fg("dim", "/") +
+							theme.fg("success", `${total}`) +
+							theme.fg("warning", "]");
+
+					const l1Right = total === 0
+						? ""
+						: theme.fg("dim", STATUS_ICON.idle + " ") + theme.fg("muted", `${idle}`) +
+							theme.fg("dim", "  ") +
+							theme.fg("accent", STATUS_ICON.inprogress + " ") + theme.fg("accent", `${active}`) +
+							theme.fg("dim", "  ") +
+							theme.fg("success", STATUS_ICON.done + " ") + theme.fg("success", `${done}`) +
+							theme.fg("dim", " ");
+
+					const pad1 = " ".repeat(Math.max(1, width - visibleWidth(l1Left) - visibleWidth(l1Right)));
+					const line1 = truncateToWidth(l1Left + pad1 + l1Right, width, "");
+
+					if (total === 0) return [line1];
+
+					// ── Rows: inprogress first, then most recent done, max 5 ──
+					const activeTasks = tasks.filter((t) => t.status === "inprogress");
+					const doneTasks = tasks.filter((t) => t.status === "done").reverse();
+					const visible = [...activeTasks, ...doneTasks].slice(0, 5);
+					const remaining = total - visible.length;
+
+					const rows = visible.map((t) => {
+						const icon = t.status === "done"
+							? theme.fg("success", STATUS_ICON.done)
+							: theme.fg("accent", STATUS_ICON.inprogress);
+						const text = t.status === "done"
+							? theme.fg("dim", t.text)
+							: theme.fg("success", t.text);
+						return truncateToWidth(` ${icon} ${text}`, width, "");
+					});
+
+					if (remaining > 0) {
+						rows.push(truncateToWidth(
+							` ${theme.fg("dim", `  +${remaining} more`)}`,
+							width, "",
+						));
+					}
+
+					return [line1, ...rows];
+				},
+			};
+		});
+	};
+
+	const refreshUI = (ctx: ExtensionContext) => {
+		if (tasks.length === 0) {
+			ctx.ui.setStatus("📋 TillDone: no tasks", "tilldone");
+		} else {
+			const remaining = tasks.filter((t) => t.status !== "done").length;
+			const label = listTitle ? `📋 ${listTitle}` : "📋 TillDone";
+			ctx.ui.setStatus(`${label}: ${tasks.length} tasks (${remaining} remaining)`, "tilldone");
+		}
+
+		refreshWidget(ctx);
+		refreshFooter(ctx);
+	};
+
+	// ── State reconstruction from session ──────────────────────────────
+
+	const reconstructState = (ctx: ExtensionContext) => {
+		tasks = [];
+		nextId = 1;
+		listTitle = undefined;
+		listDescription = undefined;
+
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type !== "message") continue;
+			const msg = entry.message;
+			if (msg.role !== "toolResult" || msg.toolName !== "tilldone") continue;
+
+			const details = msg.details as TillDoneDetails | undefined;
+			if (details) {
+				tasks = details.tasks;
+				nextId = details.nextId;
+				listTitle = details.listTitle;
+				listDescription = details.listDescription;
+			}
+		}
+
+		refreshUI(ctx);
+	};
+
+	// session_start covers startup, reload, new, resume, and fork
+	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+
+	// ── Blocking gate ──────────────────────────────────────────────────
+	// Only blocks write/execute tools. Read-only tools (read, grep, find,
+	// ls, glob) are always allowed so agents can explore before planning.
+	// Subagent tools and dispatch tools are also whitelisted.
+
+	const READ_ONLY_TOOLS = new Set([
+		"read", "grep", "find", "ls", "glob",
+		"query_experts",
+		"subagent_create", "subagent_continue", "subagent_list", "subagent_remove",
+		"dispatch_agent",
+		"run_chain",
+	]);
+
+	pi.on("tool_call", async (event, _ctx) => {
+		if (event.toolName === "tilldone") return { block: false };
+		if (READ_ONLY_TOOLS.has(event.toolName)) return { block: false };
+
+		const pending = tasks.filter((t) => t.status !== "done");
+		const active = tasks.filter((t) => t.status === "inprogress");
+
+		if (tasks.length === 0) {
+			return {
+				block: true,
+				reason: "🚫 No TillDone tasks defined. Use `tilldone new-list` or `tilldone add` to define your tasks before using write/execute tools.",
+			};
+		}
+		if (pending.length === 0) {
+			return {
+				block: true,
+				reason: "🚫 All TillDone tasks are done. Use `tilldone add` for new tasks or `tilldone new-list` to start a fresh list.",
+			};
+		}
+		if (active.length === 0) {
+			return {
+				block: true,
+				reason: "🚫 No task is in progress. Use `tilldone toggle` to mark a task as inprogress before doing any work.",
+			};
+		}
+
+		return { block: false };
+	});
+
+	// ── Auto-nudge on agent_end ────────────────────────────────────────
+
+	pi.on("agent_end", async (_event, _ctx) => {
+		const incomplete = tasks.filter((t) => t.status !== "done");
+		if (incomplete.length === 0 || nudgedThisCycle) return;
+
+		nudgedThisCycle = true;
+
+		const taskList = incomplete
+			.map((t) => `  ${STATUS_ICON[t.status]} #${t.id} [${STATUS_LABEL[t.status]}]: ${t.text}`)
+			.join("\n");
+
+		pi.sendMessage(
+			{
+				customType: "tilldone-nudge",
+				content: `⚠️ You still have ${incomplete.length} incomplete task(s):\n\n${taskList}\n\nEither continue working on them or mark them done with \`tilldone toggle\`. Don't stop until it's done!`,
+				display: true,
+			},
+			{ triggerTurn: true },
+		);
+	});
+
+	pi.on("input", async () => {
+		nudgedThisCycle = false;
+		return { action: "continue" as const };
+	});
+
+	// ── Register tilldone tool ─────────────────────────────────────────
+
+	pi.registerTool({
+		name: "tilldone",
+		label: "TillDone",
+		description:
+			"Manage your task list. You MUST add tasks before using any other tools. " +
+			"Actions: new-list (text=title, description), add (text or texts[] for batch), toggle (id) — cycles idle→inprogress→done, remove (id), update (id + text), list, clear. " +
+			"Always toggle a task to inprogress before starting work on it, and to done when finished. " +
+			"Use new-list to start a themed list with a title and description. " +
+			"IMPORTANT: If the user's new request does not fit the current list's theme, use clear to wipe the slate and new-list to start fresh.",
+		parameters: TillDoneParams,
+
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			switch (params.action) {
+				case "new-list": {
+					if (!params.text) {
+						return {
+							content: [{ type: "text" as const, text: "Error: text (title) required for new-list" }],
+							details: makeDetails("new-list", "text required"),
+						};
+					}
+
+					// If a list already exists, confirm before replacing
+					if (tasks.length > 0 || listTitle) {
+						const confirmed = await ctx.ui.confirm(
+							"Start a new list?",
+							`This will replace${listTitle ? ` "${listTitle}"` : " the current list"} (${tasks.length} task(s)). Continue?`,
+							{ timeout: 30000 },
+						);
+						if (!confirmed) {
+							return {
+								content: [{ type: "text" as const, text: "New list cancelled by user." }],
+								details: makeDetails("new-list", "cancelled"),
+							};
+						}
+					}
+
+					tasks = [];
+					nextId = 1;
+					listTitle = params.text;
+					listDescription = params.description || undefined;
+
+					const result = {
+						content: [{
+							type: "text" as const,
+							text: `New list: "${listTitle}"${listDescription ? ` — ${listDescription}` : ""}`,
+						}],
+						details: makeDetails("new-list"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				case "list": {
+					const header = listTitle ? `${listTitle}:` : "";
+					const result = {
+						content: [{
+							type: "text" as const,
+							text: tasks.length
+								? (header ? header + "\n" : "") +
+									tasks.map((t) => `[${STATUS_ICON[t.status]}] #${t.id} (${t.status}): ${t.text}`).join("\n")
+								: "No tasks defined yet.",
+						}],
+						details: makeDetails("list"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				case "add": {
+					const items = params.texts?.length ? params.texts : params.text ? [params.text] : [];
+					if (items.length === 0) {
+						return {
+							content: [{ type: "text" as const, text: "Error: text or texts required for add" }],
+							details: makeDetails("add", "text required"),
+						};
+					}
+					const added: Task[] = [];
+					for (const item of items) {
+						const t: Task = { id: nextId++, text: item, status: "idle" };
+						tasks.push(t);
+						added.push(t);
+					}
+					const msg = added.length === 1
+						? `Added task #${added[0].id}: ${added[0].text}`
+						: `Added ${added.length} tasks: ${added.map((t) => `#${t.id}`).join(", ")}`;
+					const result = {
+						content: [{ type: "text" as const, text: msg }],
+						details: makeDetails("add"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				case "toggle": {
+					if (params.id === undefined) {
+						return {
+							content: [{ type: "text" as const, text: "Error: id required for toggle" }],
+							details: makeDetails("toggle", "id required"),
+						};
+					}
+					const task = tasks.find((t) => t.id === params.id);
+					if (!task) {
+						return {
+							content: [{ type: "text" as const, text: `Task #${params.id} not found` }],
+							details: makeDetails("toggle", `#${params.id} not found`),
+						};
+					}
+					const prev = task.status;
+					task.status = NEXT_STATUS[task.status];
+
+					// Enforce single inprogress — demote any other active task
+					const demoted: Task[] = [];
+					if (task.status === "inprogress") {
+						for (const t of tasks) {
+							if (t.id !== task.id && t.status === "inprogress") {
+								t.status = "idle";
+								demoted.push(t);
+							}
+						}
+					}
+
+					let msg = `Task #${task.id}: ${prev} → ${task.status}`;
+					if (demoted.length > 0) {
+						msg += `\n(Auto-paused ${demoted.map((t) => `#${t.id}`).join(", ")} → idle. Only one task can be in progress at a time.)`;
+					}
+
+					const result = {
+						content: [{
+							type: "text" as const,
+							text: msg,
+						}],
+						details: makeDetails("toggle"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				case "remove": {
+					if (params.id === undefined) {
+						return {
+							content: [{ type: "text" as const, text: "Error: id required for remove" }],
+							details: makeDetails("remove", "id required"),
+						};
+					}
+					const idx = tasks.findIndex((t) => t.id === params.id);
+					if (idx === -1) {
+						return {
+							content: [{ type: "text" as const, text: `Task #${params.id} not found` }],
+							details: makeDetails("remove", `#${params.id} not found`),
+						};
+					}
+					const removed = tasks.splice(idx, 1)[0];
+					const result = {
+						content: [{ type: "text" as const, text: `Removed task #${removed.id}: ${removed.text}` }],
+						details: makeDetails("remove"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				case "update": {
+					if (params.id === undefined) {
+						return {
+							content: [{ type: "text" as const, text: "Error: id required for update" }],
+							details: makeDetails("update", "id required"),
+						};
+					}
+					if (!params.text) {
+						return {
+							content: [{ type: "text" as const, text: "Error: text required for update" }],
+							details: makeDetails("update", "text required"),
+						};
+					}
+					const toUpdate = tasks.find((t) => t.id === params.id);
+					if (!toUpdate) {
+						return {
+							content: [{ type: "text" as const, text: `Task #${params.id} not found` }],
+							details: makeDetails("update", `#${params.id} not found`),
+						};
+					}
+					const oldText = toUpdate.text;
+					toUpdate.text = params.text;
+					const result = {
+						content: [{ type: "text" as const, text: `Updated #${toUpdate.id}: "${oldText}" → "${toUpdate.text}"` }],
+						details: makeDetails("update"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				case "clear": {
+					if (tasks.length > 0) {
+						const confirmed = await ctx.ui.confirm(
+							"Clear TillDone list?",
+							`This will remove all ${tasks.length} task(s)${listTitle ? ` from "${listTitle}"` : ""}. Continue?`,
+							{ timeout: 30000 },
+						);
+						if (!confirmed) {
+							return {
+								content: [{ type: "text" as const, text: "Clear cancelled by user." }],
+								details: makeDetails("clear", "cancelled"),
+							};
+						}
+					}
+
+					const count = tasks.length;
+					tasks = [];
+					nextId = 1;
+					listTitle = undefined;
+					listDescription = undefined;
+
+					const result = {
+						content: [{ type: "text" as const, text: `Cleared ${count} task(s)` }],
+						details: makeDetails("clear"),
+					};
+					refreshUI(ctx);
+					return result;
+				}
+
+				default:
+					return {
+						content: [{ type: "text" as const, text: `Unknown action: ${params.action}` }],
+						details: makeDetails("list", `unknown action: ${params.action}`),
+					};
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("tilldone ")) + theme.fg("muted", args.action);
+			if (args.texts?.length) text += ` ${theme.fg("dim", `${args.texts.length} tasks`)}`;
+			else if (args.text) text += ` ${theme.fg("dim", `"${args.text}"`)}`;
+			if (args.description) text += ` ${theme.fg("dim", `— ${args.description}`)}`;
+			if (args.id !== undefined) text += ` ${theme.fg("accent", `#${args.id}`)}`;
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded }, theme) {
+			const details = result.details as TillDoneDetails | undefined;
+			if (!details) {
+				const text = result.content[0];
+				return new Text(text?.type === "text" ? text.text : "", 0, 0);
+			}
+
+			if (details.error) {
+				return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+			}
+
+			const taskList = details.tasks;
+
+			switch (details.action) {
+				case "new-list": {
+					let msg = theme.fg("success", "✓ New list ") + theme.fg("accent", `"${details.listTitle}"`);
+					if (details.listDescription) {
+						msg += theme.fg("dim", ` — ${details.listDescription}`);
+					}
+					return new Text(msg, 0, 0);
+				}
+
+				case "list": {
+					if (taskList.length === 0) return new Text(theme.fg("dim", "No tasks"), 0, 0);
+
+					let listText = "";
+					if (details.listTitle) {
+						listText += theme.fg("accent", details.listTitle) + theme.fg("dim", "  ");
+					}
+					listText += theme.fg("muted", `${taskList.length} task(s):`);
+					const display = expanded ? taskList : taskList.slice(0, 5);
+					for (const t of display) {
+						const icon = t.status === "done"
+							? theme.fg("success", STATUS_ICON.done)
+							: t.status === "inprogress"
+								? theme.fg("accent", STATUS_ICON.inprogress)
+								: theme.fg("dim", STATUS_ICON.idle);
+						const itemText = t.status === "done"
+							? theme.fg("dim", t.text)
+							: t.status === "inprogress"
+								? theme.fg("success", t.text)
+								: theme.fg("muted", t.text);
+						listText += `\n${icon} ${theme.fg("accent", `#${t.id}`)} ${itemText}`;
+					}
+					if (!expanded && taskList.length > 5) {
+						listText += `\n${theme.fg("dim", `... ${taskList.length - 5} more`)}`;
+					}
+					return new Text(listText, 0, 0);
+				}
+
+				case "add": {
+					const text = result.content[0];
+					const msg = text?.type === "text" ? text.text : "";
+					return new Text(theme.fg("success", "✓ ") + theme.fg("muted", msg), 0, 0);
+				}
+
+				case "toggle": {
+					const text = result.content[0];
+					const msg = text?.type === "text" ? text.text : "";
+					return new Text(theme.fg("accent", "⟳ ") + theme.fg("muted", msg), 0, 0);
+				}
+
+				case "remove": {
+					const text = result.content[0];
+					const msg = text?.type === "text" ? text.text : "";
+					return new Text(theme.fg("warning", "✕ ") + theme.fg("muted", msg), 0, 0);
+				}
+
+				case "update": {
+					const text = result.content[0];
+					const msg = text?.type === "text" ? text.text : "";
+					return new Text(theme.fg("success", "✓ ") + theme.fg("muted", msg), 0, 0);
+				}
+
+				case "clear":
+					return new Text(theme.fg("success", "✓ ") + theme.fg("muted", "Cleared all tasks"), 0, 0);
+
+				default:
+					return new Text(theme.fg("dim", "done"), 0, 0);
+			}
+		},
+	});
+
+	// ── /tilldone command ──────────────────────────────────────────────
+
+	pi.registerCommand("tilldone", {
+		description: "Show all TillDone tasks on the current branch",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/tilldone requires interactive mode", "error");
+				return;
+			}
+
+			await ctx.ui.custom<void>((_tui, theme, _kb, done) => {
+				return new TillDoneListComponent(tasks, listTitle, listDescription, theme, () => done());
+			});
+		},
+	});
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@structupath/pi-tilldone",
+  "version": "0.1.0",
+  "description": "Task-discipline extension for the Pi coding agent — the agent must declare tasks before it can touch write/execute tools, and gets nudged until every task is done. Includes cmux tab-status integration.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "tasks",
+    "todo",
+    "discipline",
+    "planning",
+    "agent-workflow",
+    "cmux"
+  ],
+  "author": "StructuPath (https://structupath.ai)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/StructuPath/pi-tilldone.git"
+  },
+  "homepage": "https://structupath.ai",
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/tilldone.ts",
+      "./extensions/cmux-status.ts"
+    ]
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  }
+}