@gavin-hu/my-pi-agent 0.19.0 → 0.20.0

package/extensions/plan/todos.ts

@@ -22,6 +22,16 @@ export interface TodoMerge {
 	skipped: number;
 	/** Existing items kept as they were. */
 	kept: number;
+	/**
+	 * Untouched items dropped because they were seeded by an earlier approval of this
+	 * plan and are no longer one of its steps: the plan was renamed or rewritten.
+	 */
+	replaced: number;
+	/**
+	 * Older seeds kept because someone had already started or finished them. Deleting one
+	 * would erase work a reader did, so they are reported instead of replaced.
+	 */
+	stale: number;
 	/** Plan steps left out because the list reached its cap. */
 	deferred: number;
 	/**
@@ -89,9 +99,38 @@ function contentKey(content: string): string {
  * (still subject to the same duplicate and cap rules) but is not counted as a
  * step, because it is not one.
  */
-export function mergeTodos(existing: ExistingTodo[], steps: PlanStep[], max: number, trailing?: PlanStep): TodoMerge {
+export function mergeTodos(
+	existing: ExistingTodo[],
+	steps: PlanStep[],
+	max: number,
+	trailing?: PlanStep,
+	/** What an earlier approval of this plan seeded, when there was one. */
+	previous?: readonly string[],
+): TodoMerge {
 	const limit = Number.isInteger(max) && max > 0 ? max : DEFAULT_TODO_MAX;
-	const todos: ExistingTodo[] = existing.map((todo) =>
+	// A plan refined after approval is approved again over the list its first approval
+	// made. An item this plan seeded that is no longer one of its steps is a leftover, and
+	// only an item *this plan seeded* is a candidate: a user's own item is never touched.
+	const ours = new Set((previous ?? []).map(contentKey));
+	const current = new Set(steps.map((step) => contentKey(step.content)));
+	if (trailing) current.add(contentKey(trailing.content));
+	let replaced = 0;
+	let stale = 0;
+	const kept: ExistingTodo[] = [];
+	for (const todo of existing) {
+		const key = contentKey(todo.content);
+		if (ours.has(key) && !current.has(key)) {
+			// An untouched leftover is bookkeeping and goes; one someone acted on is
+			// evidence of work, and is named rather than deleted.
+			if (todo.status === "pending") {
+				replaced += 1;
+				continue;
+			}
+			stale += 1;
+		}
+		kept.push(todo);
+	}
+	const todos: ExistingTodo[] = kept.map((todo) =>
 		todo.status === "in_progress" && !todo.activeForm ? { ...todo, activeForm: todo.content } : todo,
 	);
 	const seen = new Set(todos.map((todo) => contentKey(todo.content)));
@@ -126,5 +165,14 @@ export function mergeTodos(existing: ExistingTodo[], steps: PlanStep[], max: num
 		}
 	}
 
-	return { todos, added, skipped, kept: existing.length, deferred, trailing: trailingOutcome };
+	return {
+		todos,
+		added,
+		skipped,
+		kept: existing.length - replaced,
+		replaced,
+		stale,
+		deferred,
+		trailing: trailingOutcome,
+	};
 }

package/extensions/plan/tools/exit.ts

@@ -213,7 +213,16 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 			}
 
 			runtime.disable(ctx);
-			const { steps, merged, error } = await seedTodos(pi, ctx, decision.plan.content);
+			// A plan refined and approved again seeds over the list its first approval made:
+			// the steps that approval appended are the ones this one may replace.
+			const previous = runtime.seeded(decision.plan.path);
+			const { steps, merged, error } = await seedTodos(pi, ctx, decision.plan.content, previous);
+			if (error === undefined && steps.length > 0) {
+				runtime.markSeeded(
+					decision.plan.path,
+					steps.map((step) => step.content),
+				);
+			}
 			const goal = await finalizeGoal(pi, ctx, decision.plan);
 			const listing =
 				steps.length > 0

package/extensions/plan/tools/todo-seed.ts

@@ -36,14 +36,16 @@ export async function seedTodos(
 	pi: ExtensionAPI,
 	ctx: ExtensionToolContext,
 	plan: string,
+	/** What an earlier approval of the same plan appended, when it was approved before. */
+	previous?: readonly string[],
 ): Promise<{ steps: PlanStep[]; merged?: TodoMerge; error?: string }> {
 	const steps = extractPlanSteps(plan);
 	const verification = verificationItem(plan);
 	if (steps.length === 0 && !verification) return { steps };
-	const merged = mergeTodos(lastTodos(ctx.sessionManager.getBranch()), steps, todoMaxItems(pi), verification);
+	const merged = mergeTodos(lastTodos(ctx.sessionManager.getBranch()), steps, todoMaxItems(pi), verification, previous);
 	// Nothing new to write: every step (and the verification item) is already in
 	// the list, or the list is full, so a rewrite would only churn the widget.
-	if (merged.added === 0 && merged.trailing !== "added") return { steps, merged };
+	if (merged.added === 0 && merged.trailing !== "added" && merged.replaced === 0) return { steps, merged };
 	const outcome = await ctx.executeTool(TODO_TOOL, { todos: merged.todos });
 	if (!outcome.isError) return { steps, merged };
 	// The nested call fails both when the tool is unavailable and when it rejects

package/extensions/plan/tools/write.ts

@@ -93,8 +93,19 @@ export function registerWriteTool(pi: ExtensionAPI, runtime: PlanRuntime): void
 				// write; say so once, where the user is looking.
 				const moved = runtime.plans.takeNotice();
 				if (moved) ctx.ui.notify(moved, "info");
+				// A refinement says where the text it replaced went: a reviewer's comment that was
+				// carried to a block that moved can be checked against what she actually read.
+				const kept =
+					file.replaced === undefined ? "" : `, keeping the revision it replaced at ${file.replaced.relativePath}`;
+				// A plan that was approved before is now out of step with the todo list, and
+				// the list is only re-seeded by approving it again. Say so here, where the
+				// refinement is made, instead of letting the two disagree in silence.
+				const reseed =
+					runtime.seeded(file.path) === undefined
+						? ""
+						: " This plan was approved before: its todo items are the ones that approval seeded, and approving it again replaces the steps that changed (an item you started or finished is left alone and named).";
 				return textResult(
-					`Wrote the plan to ${file.relativePath}. Call exit_plan_mode with plan_path: ${file.path}${stepElisionNote(summary.elided)}`,
+					`Wrote the plan to ${file.relativePath}${kept}. Call exit_plan_mode with plan_path: ${file.path}${stepElisionNote(summary.elided)}${reseed}`,
 					{ path: file.path, relativePath: file.relativePath, bytes: file.bytes } satisfies WritePlanDetails,
 				);
 			} catch (error) {

package/extensions/plan/types.ts

@@ -50,6 +50,21 @@ export interface ReviewBaselineEntry {
 	sections: SectionDigest[];
 }
 
+/**
+ * What one approval put into the todo list, so the next approval can replace it.
+ *
+ * A plan refined after it was approved is approved again, and the list still holds the
+ * items seeded the first time. Their texts are the only record of which items came from
+ * this plan, so a re-approval keeps them to recognise — and replace — its own leftovers
+ * without touching an item the user was already tracking.
+ */
+export interface SeededStepsEntry {
+	/** Resolved path of the approved plan file. */
+	path: string;
+	/** The step texts the approval appended, in order. */
+	steps: string[];
+}
+
 /** Structured result carried in `enter_plan_mode`'s `details`. */
 export interface EnterPlanModeDetails {
 	/** Whether the user agreed to enter plan mode. */

package/extensions/plan/web-blocks.ts

@@ -0,0 +1,89 @@
+/**
+ * The review page's block navigation: which block is active, and how a key walks them.
+ *
+ * The fourth capability out of the review client's template literal. Each function takes
+ * the document it reads and returns the index it computed, so the client keeps the one
+ * variable (`activeIndex`) and these own the rules: clamp to the blocks that exist, start
+ * at the first or last when nothing is active, and land beside the reader rather than
+ * jumping to the middle of the page.
+ *
+ * `el` comes from the runtime, declared here because this source is spliced into the same
+ * bundle; the declaration emits nothing.
+ */
+
+import type { ClientNode } from "../../lib/web/client-runtime.ts";
+
+/** The island's view of one block, as far as navigation needs it. */
+export interface IslandBlock {
+	start: number;
+	kind?: string;
+}
+
+/**
+ * The rendered blocks.
+ *
+ * A rebuild replaces them, so this is read fresh rather than remembered: the array a
+ * caller holds goes stale the moment `renderPlan` throws the DOM away.
+ */
+export function blockElements(planEl: ClientNode | null): ClientNode[] {
+	if (!planEl) return [];
+	const nodes = planEl.querySelectorAll(".bf-block");
+	const blocks: ClientNode[] = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const block = nodes[i];
+		if (block) blocks.push(block);
+	}
+	return blocks;
+}
+
+/**
+ * Make one block active and bring it into view, or say nothing when there are no blocks.
+ *
+ * `null` means "nothing changed": a page with no blocks has no active block, and the
+ * caller keeps the index it had rather than being reset to zero.
+ */
+export function setActive(planEl: ClientNode | null, index: number): number | null {
+	const blocks = blockElements(planEl);
+	if (blocks.length === 0) return null;
+	const next = Math.max(0, Math.min(blocks.length - 1, index));
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		if (block) block.classList.toggle("bf-block--active", i === next);
+	}
+	const current = blocks[next];
+	if (current && current.scrollIntoView) current.scrollIntoView({ block: "nearest" });
+	return next;
+}
+
+/**
+ * The index one step from `activeIndex`, or `null` when there is nothing to walk.
+ *
+ * With nothing active yet, `j` starts at the top and `k` at the bottom, which is what a
+ * reader pressing either key on a fresh page expects.
+ */
+export function moveActive(planEl: ClientNode | null, activeIndex: number, delta: number): number | null {
+	const blocks = blockElements(planEl);
+	if (blocks.length === 0) return null;
+	const next = activeIndex < 0 ? (delta < 0 ? blocks.length - 1 : 0) : activeIndex + delta;
+	return setActive(planEl, next);
+}
+
+/**
+ * The rendered block and its island block for a source line, when both exist.
+ *
+ * Both halves are required: a rendered block with no island entry has nothing to comment
+ * on, and an island entry with no rendered block is a comment the page cannot place.
+ */
+export function blockAtLine(
+	planEl: ClientNode | null,
+	blocks: readonly IslandBlock[],
+	line: number,
+): { wrap: ClientNode; block: IslandBlock } | null {
+	const wrap = planEl ? planEl.querySelector('.bf-block[data-line="' + line + '"]') : null;
+	let block: IslandBlock | undefined;
+	for (const candidate of blocks) if (candidate.start === line) block = candidate;
+	return wrap && block ? { wrap, block } : null;
+}
+
+/** The block rules as source, for the client bundle. */
+export const WEB_BLOCKS_JS = [blockElements, setActive, moveActive, blockAtLine].map(String).join("\n\n");

package/extensions/plan/web-chrome.ts

@@ -8,10 +8,7 @@
  */
 
 export const WEB_CHROME_JS = String.raw`  function setStatus(text, kind) {
-    if (!statusEl) return;
-    statusEl.textContent = text || "";
-    statusEl.title = text || "";
-    statusEl.className = kind ? "bf-status bf-status--" + kind : "bf-status";
+    if (statusEl) paintStatus(statusEl, text, kind);
   }
 
   // The always-visible header chip: connection, comment count, and whether
@@ -56,7 +53,8 @@ export const WEB_CHROME_JS = String.raw`  function setStatus(text, kind) {
       titleEl.textContent = data.title;
       titleEl.title = data.title;
     }
-    if (data.title) document.title = "Plan review \u00b7 " + data.title;
+    // The document's own <title> already names the plan, rendered with the page: a second
+    // copy of the same sentence in script is a tab title that can disagree with the head.
   }
 
   function updateProgress() {