@fyeeme/pi-goal 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [1.0.2] - 2026-09-16
+
+### Changed
+
+- Prompt copy in the injected `<todo_context>` block: stale-item guidance now reads "stale, already finished, or superseded" (was "no longer active pointer") and ends with "Statuses only change through explicit todo ops — call `start` on the task you are working on" instead of the stale-in-progress phrasing.
+
+## [1.0.1] - 2026-09-11
+
+### Added
+
+- Footer task progress: with pi-todo live, the goal status segment appends ` · <closed>/<total> tasks` (closed = completed + abandoned, empty phases ignored) — e.g. `🎯 Goal 12K/399K · 3/10 tasks`. Restored from `todo-phases` session entries on session start/tree navigation.
+- Missing `todo_updated` event wiring: pi-goal now subscribes to pi-todo's documented `todo_updated` broadcast (payload-validated), keeping the todo context and footer progress live between session restores. Previously `todoPhases` only refreshed on session start/tree navigation, so in-session todo mutations left the context stale.
+
 ## [1.0.0] - 2026-09-09
 
 ### Added

package/README.md

@@ -14,7 +14,7 @@ Source: [oh-my-pi](https://github.com/can1357/oh-my-pi) (a fork of badlogic/pi-m
 - **Interrupt safety** — Esc interrupts pause the goal (never complete it); usage accumulated so far is kept. Resuming a session auto-pauses a still-active goal, since the run that owned it is gone.
 - **`/goal` command** — `set <objective>`, `show`, `pause`, `resume`, `drop`, `budget <N|off>`, or an interactive menu when called without arguments. Typing an objective while a goal is active (or paused) is rejected with omp's status/warning; `/goal drop` and the menu's Drop confirm before discarding.
 - **`/guided-goal [rough objective]`** — the agent interviews you in normal chat (success criteria, verification method, attempt cap, scope boundaries, stop conditions) and then creates the goal itself via `goal create`.
-- **Footer status** — a `<icon> Goal <used/budget>` segment (omp `renderGoalMode` unicode icon set: 🎯 active, ⏸ paused, ⚠ budget-limited) while the goal is enabled or paused. Completed goals stay visible in the transcript after reloads via a persistent `goal-completed` entry renderer.
+- **Footer status** — a `<icon> Goal <used/budget>` segment (omp `renderGoalMode` unicode icon set: 🎯 active, ⏸ paused, ⚠ budget-limited) while the goal is enabled or paused. With [pi-todo](../pi-todo) live, a ` · <closed>/<total> tasks` suffix tracks todo progress (live via `todo_updated`, restored from session entries). Completed goals stay visible in the transcript after reloads via a persistent `goal-completed` entry renderer.
 - **pi-todo integration** — when [pi-todo](../pi-todo) is installed, the goal context message includes a live `<todo_context>` block so continuations treat todos as current state, not stale transcript decoration.
 
 ## Install
@@ -35,7 +35,7 @@ or copy/link this directory into `~/.pi/agent/extensions/` (global) or `.pi/exte
 /goal drop
 ```
 
-Status line: a `<icon> Goal <used/budget>` segment appears in the footer while a goal is enabled or paused (omp footer segment semantics).
+Status line: a `<icon> Goal <used/budget>` segment appears in the footer while a goal is enabled or paused (omp footer segment semantics); with pi-todo live it becomes `🎯 Goal 12K/399K · 3/10 tasks`.
 
 ## Session persistence
 

package/index.ts

@@ -49,7 +49,8 @@
  *   - `pi.events.emit("goal_updated", { goal, state })` after every runtime
  *     transition (goal may be null; state undefined after drop)
  *   - reads `todo_updated` events + "todo-phases" entries from pi-todo to
- *     render the goal todo context (works without pi-todo installed)
+ *     render the goal todo context and the footer task progress (works
+ *     without pi-todo installed)
  */
 
 // Prompt lives in a static .md asset next to this module (published with the
@@ -78,7 +79,13 @@ import { GoalRuntime } from "./src/runtime.ts";
 import type { Goal, GoalModeState, GoalTokenUsage } from "./src/state.ts";
 import { cloneGoal } from "./src/state.ts";
 import { renderTemplate } from "./src/template.ts";
-import { buildTodoContext, restoreTodoPhases, type TodoPhase } from "./src/todo-bridge.ts";
+import {
+	buildTodoContext,
+	parseTodoPhases,
+	restoreTodoPhases,
+	todoProgress,
+	type TodoPhase,
+} from "./src/todo-bridge.ts";
 import { runGoalEvaluator } from "./src/evaluator.ts";
 import { createGoalTool, type GoalToolDeps } from "./src/tool.ts";
 
@@ -167,9 +174,10 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		}
 	}
 
-	/** omp status-line/segments.ts renderGoalMode: segment visible only while
+/** omp status-line/segments.ts renderGoalMode: segment visible only while
 	 *  enabled or paused; text "<icon> Goal used[/budget]" (goal.statusInFooter
-	 *  defaults to true, so usage always renders). */
+	 *  defaults to true, so usage always renders). pi-goal deviation: with
+	 *  live pi-todo phases a ` · <closed>/<total> tasks` suffix is appended. */
 	function updateStatus(): void {
 		const ctx = currentCtx;
 		if (!ctx) return;
@@ -181,7 +189,9 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		const goal = state.goal;
 		const used = formatNumber(goal.tokensUsed);
 		const budget = goal.tokenBudget !== undefined ? `/${formatNumber(goal.tokenBudget)}` : "";
-		ctx.ui.setStatus("goal", `${goalStatusIcon(goal.status)} Goal ${used}${budget}`);
+		const progress = todoProgress(todoPhases);
+		const tasks = progress ? ` · ${progress.closed}/${progress.total} tasks` : "";
+		ctx.ui.setStatus("goal", `${goalStatusIcon(goal.status)} Goal ${used}${budget}${tasks}`);
 	}
 
 	function notify(text: string, severity: "info" | "warning" | "error" = "info"): void {
@@ -581,6 +591,16 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		updateStatus();
 	});
 
+	// pi-todo contract: { phases } arrives over the shared event bus after
+	// every successful todo mutation. Keeps the goal todo context and the
+	// footer task progress live between session restores.
+	pi.events.on("todo_updated", (data) => {
+		const phases = parseTodoPhases((data as { phases?: unknown } | undefined)?.phases);
+		if (!phases) return;
+		todoPhases = phases;
+		updateStatus();
+	});
+
 	// Blocking ctx.ui dialogs (drop confirm, objective editor, /goal menu,
 	// budget input — plus other extensions' ask_user). While one is open the
 	// agent is not running, and a continuation must not start behind the modal.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fyeeme/pi-goal",
-	"version": "1.0.0",
+	"version": "1.0.2",
 	"description": "Goal mode for pi \u2014 one persistent autonomous objective looped until verified success: goal tool (create/get/complete/resume/drop), token/time budget accounting with budget-limit steering, automatic continuation turns, /goal and /guided-goal commands, and a goal_updated event bus for other extensions.",
 	"type": "module",
 	"license": "MIT",

package/src/prompts/goal-todo-context.md

@@ -1,6 +1,6 @@
 <todo_context>
 Persisted todos: live progress state for current goal, not old transcript decoration; goal continuations lack visible user nudge → treat as live state.
-Before substantial work: compare next action with todos. If item stale, already finished, or no longer active pointer, call `todo` first: mark done or rewrite list. Do not leave stale in_progress while working on later phases.
+Before substantial work: compare next action with todos. If an item is stale, already finished, or superseded, call `todo` first: mark done or rewrite the list. Statuses only change through explicit todo ops — call `start` on the task you are working on.
 
 Overall: {{closed}}/{{total}} done, {{open}} open.
 {{#each phases}}

package/src/todo-bridge.ts

@@ -89,6 +89,30 @@ export function restoreTodoPhases(entries: readonly unknown[]): TodoPhase[] {
 	return [];
 }
 
+/** Validate an unknown value (e.g. a `todo_updated` event payload) as phases. */
+export function parseTodoPhases(value: unknown): TodoPhase[] | undefined {
+	if (!Array.isArray(value) || !value.every(isTodoPhase)) return undefined;
+	return value.map((phase) => ({
+		name: phase.name,
+		tasks: phase.tasks.map((task) => ({ content: task.content, status: task.status })),
+	}));
+}
+
+/** Footer progress over non-empty phases, same gate as buildTodoContext. */
+export function todoProgress(phases: TodoPhase[]): { closed: number; total: number } | undefined {
+	const nonEmpty = phases.filter((phase) => phase.tasks.length > 0);
+	if (nonEmpty.length === 0) return undefined;
+	let closed = 0;
+	let total = 0;
+	for (const phase of nonEmpty) {
+		for (const task of phase.tasks) {
+			total++;
+			if (task.status === "completed" || task.status === "abandoned") closed++;
+		}
+	}
+	return { closed, total };
+}
+
 /** omp #sanitizeGoalTodoText: XML-escape and flatten control characters. */
 function sanitizeTodoText(text: string): string {
 	return escapeXmlText(text)
@@ -110,20 +134,11 @@ export function buildTodoContext(phases: TodoPhase[], todoToolActive: boolean):
 	const nonEmpty = phases.filter((phase) => phase.tasks.length > 0);
 	if (nonEmpty.length === 0) return undefined;
 
-	let total = 0;
-	let closed = 0;
-	let open = 0;
+	const { closed, total } = todoProgress(nonEmpty)!;
+	const open = total - closed;
 	const promptPhases = nonEmpty.map((phase) => ({
 		name: sanitizeTodoText(phase.name),
-		tasks: phase.tasks.map((task) => {
-			total++;
-			if (task.status === "completed" || task.status === "abandoned") {
-				closed++;
-			} else {
-				open++;
-			}
-			return { content: sanitizeTodoText(task.content), status: task.status };
-		}),
+		tasks: phase.tasks.map((task) => ({ content: sanitizeTodoText(task.content), status: task.status })),
 	}));
 
 	return renderTemplate(goalTodoContextPrompt, {

package/test/index.test.ts

@@ -30,6 +30,7 @@ interface FakeHost {
 		{ handler: (args: string, ctx: unknown) => Promise<void>; getArgumentCompletions?: (prefix: string) => unknown }
 	>;
 	handlers: Map<string, Array<(event: unknown, ctx: unknown) => unknown>>;
+	busHandlers: Map<string, Array<(data: unknown) => void>>;
 	entries: Array<{ type: string; customType: string; data?: unknown; id: string }>;
 	sentMessages: Array<{
 		customType: string;
@@ -51,6 +52,7 @@ function fakeHost(): FakeHost {
 		tools: [],
 		commands: {},
 		handlers: new Map(),
+		busHandlers: new Map(),
 		entries: [],
 		sentMessages: [],
 		sentUserMessages: [],
@@ -101,7 +103,12 @@ function fakeHost(): FakeHost {
 			emit: (channel: string, data: unknown) => {
 				host.emitted.push({ channel, data });
 			},
-			on: () => () => {},
+			on: (channel: string, handler: (data: unknown) => void) => {
+				const list = host.busHandlers.get(channel) ?? [];
+				list.push(handler);
+				host.busHandlers.set(channel, list);
+				return () => {};
+			},
 		},
 	} as unknown as ExtensionAPI;
 	return host;
@@ -141,6 +148,12 @@ async function fire(host: FakeHost, event: string, payload: unknown, ctx?: unkno
 	}
 }
 
+function fireBus(host: FakeHost, channel: string, data: unknown): void {
+	for (const handler of host.busHandlers.get(channel) ?? []) {
+		handler(data);
+	}
+}
+
 function goalTool(host: FakeHost): Record<string, unknown> {
 	const tool = host.tools.find((t) => t.name === "goal");
 	if (!tool) throw new Error("goal tool not registered");
@@ -518,6 +531,71 @@ describe("pi-goal extension wiring", () => {
 		expect(host.statuses.get("goal")).toBe("🎯 Goal 0");
 	});
 
+	// ------------------------------------------------------------
+	// Footer task progress (pi-todo integration)
+	// ------------------------------------------------------------
+
+	it("shows live pi-todo task progress in the footer (todo_updated event)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		expect(host.statuses.get("goal")).toBe("🎯 Goal 0");
+
+		fireBus(host, "todo_updated", {
+			phases: [
+				{
+					name: "P1",
+					tasks: [
+						{ content: "a", status: "completed" },
+						{ content: "b", status: "in_progress" },
+					],
+				},
+			],
+		});
+		expect(host.statuses.get("goal")).toBe("🎯 Goal 0 · 1/2 tasks");
+	});
+
+	it("ignores malformed todo_updated payloads (footer keeps the plain segment)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+
+		fireBus(host, "todo_updated", { phases: "nope" });
+		fireBus(host, "todo_updated", {});
+		fireBus(host, "todo_updated", undefined);
+		expect(host.statuses.get("goal")).toBe("🎯 Goal 0");
+	});
+
+	it("restores footer task progress from todo-phases entries on session_start", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		const entries = [
+			...makeEntries(baseGoal, true),
+			{
+				type: "custom",
+				customType: "todo-phases",
+				id: "t1",
+				data: {
+					phases: [
+						{
+							name: "P1",
+							tasks: [
+								{ content: "a", status: "completed" },
+								{ content: "b", status: "pending" },
+							],
+						},
+					],
+				},
+			},
+		];
+		const ctx = createContext(host, { entries });
+		await fire(host, "session_start", { type: "session_start", reason: "resume" }, ctx);
+		// Cold resume pauses the goal; the restored progress still renders.
+		expect(host.statuses.get("goal")).toBe("⏸ Goal 0 · 1/2 tasks");
+	});
+
 	it("registers /goal argument completions (omp buildArgumentCompletions shape)", () => {
 		const host = fakeHost();
 		defaultExport(host.pi);

package/test/tool.test.ts

@@ -12,7 +12,7 @@ import { IMPOSSIBLE_REPORT_CAP } from "../src/tool.ts";
 import { GOAL_CLEARED_ENTRY_TYPE, GOAL_STATE_ENTRY_TYPE, restoreGoalFromEntries } from "../src/restore.ts";
 import { GoalRuntime, type GoalRuntimeHost } from "../src/runtime.ts";
 import type { Goal, GoalModeState, GoalRuntimeEvent, GoalTokenUsage, GoalToolDetails } from "../src/state.ts";
-import { buildTodoContext, restoreTodoPhases } from "../src/todo-bridge.ts";
+import { buildTodoContext, parseTodoPhases, restoreTodoPhases, todoProgress } from "../src/todo-bridge.ts";
 import {
 	buildGoalToolResponse,
 	createGoalTool,
@@ -525,4 +525,34 @@ describe("todo bridge", () => {
 		expect(context).toContain("P<1>");
 		expect(context).toContain("a & b");
 	});
+
+	it("counts footer progress over non-empty phases only (completed + abandoned closed)", () => {
+		expect(
+			todoProgress([
+				{
+					name: "P1",
+					tasks: [
+						{ content: "a", status: "completed" },
+						{ content: "b", status: "abandoned" },
+						{ content: "c", status: "in_progress" },
+					],
+				},
+				{ name: "P2", tasks: [{ content: "d", status: "pending" }] },
+				{ name: "empty", tasks: [] },
+			]),
+		).toEqual({ closed: 2, total: 4 });
+		expect(todoProgress([{ name: "empty", tasks: [] }])).toBeUndefined();
+		expect(todoProgress([])).toBeUndefined();
+	});
+
+	it("validates todo_updated event payloads (parseTodoPhases)", () => {
+		const phases = [{ name: "P1", tasks: [{ content: "a", status: "pending" }] }];
+		expect(parseTodoPhases(phases)).toEqual(phases);
+		// defensive clone, not the caller's objects
+		expect(parseTodoPhases(phases)).not.toBe(phases);
+		expect(parseTodoPhases(undefined)).toBeUndefined();
+		expect(parseTodoPhases("nope")).toBeUndefined();
+		expect(parseTodoPhases([{ name: "P1", tasks: [{ content: "a", status: "bogus" }] }])).toBeUndefined();
+		expect(parseTodoPhases([{ tasks: [] }])).toBeUndefined();
+	});
 });