pi-anchorloop 2.4.1 → 2.7.0

package/pi/book.ts

@@ -1,6 +1,7 @@
 /**
- * pi extension: the loop book. The first `todo` create or `kind` declaration opens a loop and its book. The agent declares only
- * what the program cannot observe (`kind` with its intent and anchor command, a non-command `verify`,
+ * pi extension: the loop book. The first `todo` create opens a loop and its book as `inline`, its intent the first todo's subject
+ * and its anchor a stated `Reality anchor:` line or the todo's `metadata.anchor`; a `kind` declaration opens one too. The agent declares only
+ * what the program cannot observe (`kind` to choose `reviewed` or `durable`, a non-command `verify`,
  * `fresh-read`, `friction`, `reflect`, `skip`, `back`, `close`); the extension derives the rest from
  * evidence: production edits, the exit code of the anchor command, reviewer results, durable artifacts,
  * and the fresh-reader subagent. A phase machine over that evidence warns once per jump and never blocks;
@@ -19,6 +20,7 @@ import {
 	anchorCommand,
 	appendEntry,
 	artifactKind,
+	bases,
 	childId,
 	childIds,
 	childLines,
@@ -35,6 +37,7 @@ import {
 	openLoop,
 	replayTodos,
 	refsOf,
+	repoRootOf,
 	retryPairs,
 	resolveRef,
 	reviewTrend,
@@ -50,6 +53,8 @@ import {
 	touchRepoBeforeMerge,
 	validFollowup,
 	verifyAfterLastAct,
+	workingTrees,
+	adoptableRun,
 } from "./support/book.ts";
 import { classify } from "./support/jev.ts";
 import { REVIEWLESS, SEQUENCES, computePhases, describe, incompleteBefore, outsideWork, reachLine, reachOf, unansweredReach } from "./support/phases.ts";
@@ -62,9 +67,6 @@ const REVIEWERS = new Set(["reviewer", "adversarial-reviewer"]);
 const BLOCKING = /Blocking\s*:?\**\s*:?\s*P0\s*=\s*(\d+)\D{0,5}P1\s*=\s*(\d+)/gi;
 const ANCHOR_LINE = /Reality anchor:[ \t]*(.*)/;
 
-export const OPEN_LINE =
-	"anchorloop: a loop is open. Declare it with `anchorloop_stage` {stage: kind, kind: quick|inline|reviewed|durable, intent: <one line>, anchor: <check command>}.";
-
 type Params = {
 	stage: (typeof STAGES)[number];
 	kind?: (typeof KINDS)[number];
@@ -330,7 +332,7 @@ function statedAnchor(message: { role?: string; content?: unknown } | undefined)
 	return found ? found[1].trim().slice(0, 300) || "(stated on the next line)" : undefined;
 }
 
-const STATUS_KEY = "anchorloop";
+const WIDGET_KEY = "anchorloop";
 
 const reply = (text: string) => ({ content: [{ type: "text" as const, text }], details: undefined });
 
@@ -402,6 +404,23 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	/** True while no `kind` call has chosen the kind: the loop still holds the `inline` a todo create opened it with. */
+	function kindIsDefault(entries: Entry[]): boolean {
+		return !entries.some((entry) => entry.stage === "kind" && typeof entry.kind === "string" && entry.auto !== true);
+	}
+
+	/** Opens the loop at the first todo create as `inline`: the first todo's subject is the intent, a stated `Reality anchor:` line or its `metadata.anchor` the anchor. */
+	function openFromTodo(ctx: ExtensionContext, details: unknown): Book {
+		const book = createBook(ctx);
+		touchRepo(book, join(ctx.cwd, "_"));
+		const first = (taskDetails(details) ?? [])[0];
+		book.entries.push(appendEntry(book.path, "kind", { kind: "inline", auto: true, ...(first?.subject ? { intent: clip(first.subject.replace(/\s+/g, " ").trim(), 200) } : {}) }));
+		recordPriorAnchor(book, ctx);
+		const anchor = first?.metadata?.anchor;
+		if (typeof anchor === "string" && anchor.trim() && !anchorCommand(book.entries)) book.entries.push(appendEntry(book.path, "anchor", { check: anchor.trim() }));
+		return book;
+	}
+
 	function close(book: Book, ctx: ExtensionContext, verdict: string): { text: string; snapshot?: Snapshot } {
 		const todos = replayTodos(ctx.sessionManager.getBranch());
 		const undisposed = todos.filter((task) => isOpenTask(task) && !validFollowup(task.metadata?.followup));
@@ -415,7 +434,6 @@ export default function (pi: ExtensionAPI) {
 		const kind = currentKind(book.entries);
 		const phases = phasesOf(book, ctx);
 		const missing = incompleteBefore(phases, "close");
-		const notice = verdict === "landed" && missing.length ? `anchorloop: closed with phases not shown complete: ${missing.map((status) => `${status.name} (${status.note})`).join("; ")}.` : undefined;
 		const diff = diffAgainstBases(book.entries);
 		const friction = allFriction(book.entries);
 		const phaseList = phases.statuses.map((status) => ({ phase: status.name, state: status.state === "skipped" && status.auto ? "auto-skipped" : status.state === "missing" ? "not shown complete" : status.state, ...(status.state === "skipped" ? { note: status.note } : {}) }));
@@ -434,25 +452,16 @@ export default function (pi: ExtensionAPI) {
 			followups: todos.filter((task) => isOpenTask(task)).map((task) => ({ task: task.subject, followup: task.metadata?.followup })),
 		};
 		const unreflected = friction.filter((item) => !item.reflected);
-		const tail = unreflected.length
-			? ` Unreflected friction for the Reflexive Pass: ${unreflected.map((item) => `${item.ref} (${item.found})`).join("; ")}.`
-			: "";
-		const named = (item: (typeof phaseList)[number]) => `${item.phase}${item.note ? ` (${item.note})` : ""}`;
-		const doneNames = phaseList.filter((item) => item.state === "done").map((item) => item.phase);
-		const skippedNames = phaseList.filter((item) => item.state === "skipped" || item.state === "auto-skipped").map(named);
-		const openNames = phaseList.filter((item) => item.state === "not shown complete").map((item) => item.phase);
-		const shown = [
-			`done: ${doneNames.join(", ") || "none"}`,
-			...(skippedNames.length ? [`skipped: ${skippedNames.join(", ")}`] : []),
-			...(openNames.length ? [`${verdict === "landed" ? "not complete" : "not reached"}: ${openNames.join(", ")}`] : []),
-		].join("; ");
-		const back = summary.back.length ? `; back ${summary.back.join(", ")}` : "";
-		const text = `Loop closed (${verdict}): phases ${shown}; ${summary.reviewTrend}; diff ${diff.summary.split("\n").join("; ")}${back}.${tail}`;
-		const after = notice ? `\n${notice}` : "";
+		// The agent has just done the finished phases, so the result names only what is left.
+		const text = [
+			`closed (${verdict}).`,
+			...(missing.length ? [`${verdict === "landed" ? "not complete" : "not reached"}: ${missing.map((status) => (verdict === "landed" ? `${status.name} (${status.note})` : status.name)).join("; ")}.`] : []),
+			...(unreflected.length ? [`unreflected friction: ${unreflected.map((item) => `${item.ref} (${item.found})`).join("; ")}.`] : []),
+		].join(" ");
 		if (kept) {
 			// A child's book stays for the main session to read and delete.
 			appendEntry(book.path, "close", { verdict, summary: text.slice(0, 500) });
-			return { text: `${text} The book stays for the main session.${after}` };
+			return { text: `${text} The book stays for the main session.` };
 		}
 		// Jev judges the loop as it stood at close; the book is gone by the time the result is judged.
 		const snap = kind === "quick" ? undefined : snapshot(book, ctx);
@@ -461,38 +470,33 @@ export default function (pi: ExtensionAPI) {
 			for (const { book: child } of findChildBooks(id)) deleteBook(child.path);
 		}
 		deleteBook(book.path);
-		return { text: `${text} The book is deleted. Clear the todo list now (todo action: clear).${after}`, snapshot: snap };
+		return { text: `${text} Clear the todo list.`, snapshot: snap };
 	}
 
 	pi.registerTool({
 		name: "anchorloop_stage",
 		label: "Loop stage",
 		description:
-			"Declare only what the extension cannot observe in the anchorloop loop book. " +
-			"`kind` (kind, intent, optional anchor command; call again to set the anchor, or with `reason` to change the kind or answer a re-classification): quick (act, check), inline (anchor, act, verify), reviewed (adds review), durable (adds decide, grill, spec, read, approve, design); every kind ends with reflect, close. " +
-			"When an anchor run or declared verify of a quick or inline loop finds the change reaching 3 source files, 2 modules, or a README, changelog, or *.schema.json beside code, its verify waits for a `kind` call with `reason`. " +
-			"`verify` (note; only for an anchor that is not a command), `fresh-read` (a fresh-context read of the spec is done), `friction` (tried, found, led_by), `reflect` (friction ids, class misdirection|gap|resolved, action), " +
-			"`skip` / `back` (phase, reason), `close` (verdict), `read` (view the book). Edits, anchor runs, reviews, and spec files are read from evidence. " +
-			"A loop opens with the first `todo` create; `close` refuses while a pending or in-progress todo lacks metadata.followup.",
+			"Loop book; the first `todo` create opens a loop as inline. stage: kind (kind, intent, anchor; reason to change the kind or answer a reach notice), verify (note; only for a check not run in bash), fresh-read, friction (tried, found, led_by), reflect (friction ids, class, action), skip/back (phase, reason), close (verdict; refuses while an open todo lacks metadata.followup), read. Edits, anchor runs, reviews, and specs are read from evidence.",
 		parameters: {
 			type: "object",
 			properties: {
 				stage: { type: "string", enum: [...STAGES] },
-				kind: { type: "string", enum: [...KINDS], description: "stage kind: the loop kind; a later call with `reason` changes it" },
-				intent: { type: "string", description: "stage kind: one line on what the loop delivers" },
-				anchor: { type: "string", description: "stage kind: the check command whose exit code observes the result" },
-				note: { type: "string", description: "stage verify: what was observed; stage fresh-read: who read the spec" },
-				result: { type: "string", enum: ["pass", "fail"], description: "stage verify; default pass" },
-				tried: { type: "string", description: "stage friction: the attempt that failed" },
-				found: { type: "string", description: "stage friction: what the failure revealed" },
-				led_by: { type: "string", description: "stage friction: the skill or instruction line that prompted the attempt, or `none`" },
-				friction: { type: "array", items: { type: ["string", "number"] }, description: "stage reflect: friction ids (`3`, or `worker#2` for a child's)" },
-				class: { type: "string", enum: ["misdirection", "gap", "resolved"], description: "stage reflect" },
-				action: { type: "string", description: "stage reflect: what was done, such as solid-loop, memory, or a commit" },
-				phase: { type: "string", description: "stage skip or back: the phase" },
-				reason: { type: "string", description: "stage skip or back: why; stage kind: why the kind changes, or why it still fits the measured reach" },
-				verdict: { type: "string", enum: ["landed", "blocked", "abandoned"], description: "stage close" },
-				view: { type: "string", enum: ["summary", "all"], description: "stage read; default summary" },
+				kind: { type: "string", enum: [...KINDS] },
+				intent: { type: "string" },
+				anchor: { type: "string", description: "the check command" },
+				note: { type: "string" },
+				result: { type: "string", enum: ["pass", "fail"] },
+				tried: { type: "string" },
+				found: { type: "string" },
+				led_by: { type: "string", description: "the instruction that misled the attempt, or `none`" },
+				friction: { type: "array", items: { type: ["string", "number"] }, description: "ids: `3`, `worker#2`" },
+				class: { type: "string", enum: ["misdirection", "gap", "resolved"] },
+				action: { type: "string" },
+				phase: { type: "string" },
+				reason: { type: "string" },
+				verdict: { type: "string", enum: ["landed", "blocked", "abandoned"] },
+				view: { type: "string", enum: ["summary", "all"] },
 			},
 			required: ["stage"],
 			additionalProperties: false,
@@ -533,22 +537,17 @@ export default function (pi: ExtensionAPI) {
 		if (stage === "kind") {
 			if (!params.kind && !params.intent && !params.anchor && !params.reason) throw new Error("kind needs `kind`, `intent`, `anchor`, or `reason`");
 			if (!had && (!params.kind || !params.intent)) throw new Error("the first kind declaration needs `kind` and a one-line `intent`");
+			// The kind a todo create defaulted to is not a choice yet, so choosing another needs no reason.
 			const changed = had !== undefined && params.kind !== undefined && had !== params.kind;
-			if (changed && !params.reason) throw new Error(`changing the kind from ${had} to ${params.kind} needs \`reason\`: the reach grew, the user added scope, a user-owned decision appeared, or the change turned out smaller`);
+			if (changed && !params.reason && !kindIsDefault(book.entries)) throw new Error(`changing the kind from ${had} to ${params.kind} needs \`reason\`: the reach grew, the user added scope, a user-owned decision appeared, or the change turned out smaller`);
 			touchRepo(book, join(ctx.cwd, "_"));
-			const notes: string[] = [];
 			if (params.kind || params.intent || params.reason) {
 				// A reason answers the reach measured now, so a later threshold asks again.
 				const answer = params.reason ? { reason: params.reason, crossed: reachOf(book.entries, ctx.cwd).crossed } : {};
 				appendEntry(book.path, "kind", { kind: params.kind ?? had, ...(params.intent ? { intent: params.intent } : {}), ...answer });
-				const why = params.reason ? ` (${params.reason})` : "";
-				notes.push(changed ? `kind changed: ${had} → ${params.kind}${why}` : `kind: ${params.kind ?? had}${why}`);
-			}
-			if (params.anchor) {
-				appendEntry(book.path, "anchor", { check: params.anchor });
-				notes.push(`anchor: ${params.anchor}`);
 			}
-			return reply(notes.join("\n"));
+			if (params.anchor) appendEntry(book.path, "anchor", { check: params.anchor });
+			return reply("ok");
 		}
 		if (stage === "verify") {
 			if (!params.note) throw new Error("verify needs a `note` saying what was observed");
@@ -557,17 +556,17 @@ export default function (pi: ExtensionAPI) {
 			const entry = appendEntry(book.path, recorded, { declared: true, note: params.note, result, exit: result === "pass" ? 0 : 1, ...reachField(book, ctx.cwd) });
 			book.entries.push(entry);
 			const notice = reachNotice(book, entry);
-			return reply(`${recorded} declared: ${result} — ${params.note}${notice ? `\n${notice}` : ""}`);
+			return reply(notice ? `ok\n${notice}` : "ok");
 		}
 		if (stage === "fresh-read") {
 			appendEntry(book.path, "goldfish", { source: "declared", ...(params.note ? { note: params.note } : {}) });
-			return reply("fresh-read recorded.");
+			return reply("ok");
 		}
 		if (stage === "friction") {
 			if (!params.tried || !params.found) throw new Error("friction needs `tried` and `found`");
 			const id = frictionOf(book.entries).length + 1;
 			appendEntry(book.path, "friction", { id, tried: params.tried, found: params.found, led_by: params.led_by || "none" });
-			return reply(`friction #${id} recorded.`);
+			return reply(`friction #${id}`);
 		}
 		if (stage === "reflect") {
 			const known = allFriction(book.entries).map((item) => item.ref);
@@ -576,7 +575,7 @@ export default function (pi: ExtensionAPI) {
 			const unknown = ids.filter((id) => !known.includes(id));
 			if (unknown.length) throw new Error(`unknown friction ${unknown.join(", ")}; known: ${known.join(", ") || "none"}`);
 			appendEntry(book.path, "reflect", { friction: ids, class: params.class, ...(params.action ? { action: params.action } : {}) });
-			return reply(`reflect recorded for ${ids.join(", ")} (${params.class}).`);
+			return reply("ok");
 		}
 		// skip and back
 		const phase = params.phase;
@@ -584,7 +583,7 @@ export default function (pi: ExtensionAPI) {
 		if (!phase || !known.includes(phase)) throw new Error(`${stage} needs \`phase\`, one of ${known.join(", ")} for a ${had ?? "undeclared"} loop`);
 		if (!params.reason) throw new Error(`${stage} needs a \`reason\``);
 		appendEntry(book.path, stage, { phase, reason: params.reason });
-		return reply(stage === "skip" ? `${phase}: skipped (${params.reason}).` : `back to ${phase} (${params.reason}); later phases count as incomplete until their conditions hold again.`);
+		return reply("ok");
 	}
 
 	pi.on(
@@ -621,6 +620,38 @@ export default function (pi: ExtensionAPI) {
 		return reach && unansweredReach(book.entries, reach).length > 0 ? `anchorloop: ${reachLine(reach, currentKind(book.entries))}.` : undefined;
 	}
 
+	/** The repos the loop works in: the repos it changed and the one it runs in. */
+	function loopRepos(book: Book, cwd: string): string[] {
+		const here = repoRootOf(join(cwd, "_"));
+		return [...new Set([...bases(book.entries).map((base) => base.repo), ...(here ? [here] : [])])];
+	}
+
+	function loopTrees(book: Book, cwd: string): string[] {
+		return workingTrees(loopRepos(book, cwd));
+	}
+
+	/** A child's anchor run carries the trees it ran on, so the coordinator can tell whether it holds that same state. */
+	function treesField(book: Book, cwd: string): { trees?: string[] } {
+		const trees = loopTrees(book, cwd);
+		return trees.length ? { trees } : {};
+	}
+
+	/**
+	 * Records a linked child's passing run of the loop anchor as this loop's verify when the loop now holds exactly the state
+	 * that run checked (after a merge lands a worker's branch, or when a child that worked in this checkout returns), so the
+	 * coordinator does not run the anchor a second time. Any other state, or another command, leaves verify to its own run.
+	 */
+	function adoptChildRun(book: Book, cwd: string): void {
+		const anchor = anchorCommand(book.entries);
+		if (!anchor || verifyAfterLastAct(book.entries) || !book.entries.some((entry) => entry.stage === "link")) return;
+		const repos = loopRepos(book, cwd);
+		const trees = workingTrees(repos);
+		const found = adoptableRun(book.entries, anchor, trees, repos, cwd);
+		if (!found) return;
+		const last = `adopted from ${found.name}${found.run.last ? `: ${String(found.run.last)}` : ""}`.slice(0, 200);
+		book.entries.push(appendEntry(book.path, "verify", { command: anchor.slice(0, 200), exit: 0, last, adopted: found.name, trees, ...reachField(book, cwd) }));
+	}
+
 	/**
 	 * Records what a finished bash call shows: runs of the loop anchor, of task anchors, and a first commit as the change.
 	 * Returns the re-classification line when an anchor run of an unreviewed loop measured a reach no `kind` answer covers.
@@ -636,9 +667,10 @@ export default function (pi: ExtensionAPI) {
 		// A failed run keeps its key line, so a rerun that passes can name what failed without the whole output.
 		const keyOf = (code: unknown) => (typeof code === "number" && code !== 0 ? { key: keyLine(output) } : {});
 		if (anchor && anchorRun(command, anchor)) {
-			const recorded = childId() !== undefined || currentKind(book.entries) === "quick" ? "check" : "verify";
+			const child = childId() !== undefined;
+			const recorded = child || currentKind(book.entries) === "quick" ? "check" : "verify";
 			const code = anchorExit(command, anchor, exit);
-			const entry = appendEntry(book.path, recorded, { command: anchor.slice(0, 200), exit: code, last, ...keyOf(code), ...reachField(book, cwd) });
+			const entry = appendEntry(book.path, recorded, { command: anchor.slice(0, 200), exit: code, last, ...keyOf(code), ...reachField(book, cwd), ...(child ? treesField(book, cwd) : {}) });
 			book.entries.push(entry);
 			const reach = reachNotice(book, entry);
 			if (reach) notices.push(reach);
@@ -648,11 +680,14 @@ export default function (pi: ExtensionAPI) {
 			const code = anchorExit(command, task.anchor, exit);
 			book.entries.push(appendEntry(book.path, "taskrun", { id: task.id, command: task.anchor.slice(0, 200), exit: code, last, ...keyOf(code) }));
 		}
-		notices.push(...autoFriction(book));
+		autoFriction(book);
 		const merged = mergeRun(command);
-		if (exit === 0 && merged && !/Already up[ -]to[ -]date/i.test(last ?? "") && book.entries.at(-1)?.stage !== "edit") {
-			touchRepoBeforeMerge(book, resolve(String(book.header.cwd ?? process.cwd()), merged.dir), merged.verb);
-			book.entries.push(appendEntry(book.path, "edit", { via: "merge" }));
+		if (exit === 0 && merged && !/Already up[ -]to[ -]date/i.test(last ?? "")) {
+			if (book.entries.at(-1)?.stage !== "edit") {
+				touchRepoBeforeMerge(book, resolve(String(book.header.cwd ?? process.cwd()), merged.dir), merged.verb);
+				book.entries.push(appendEntry(book.path, "edit", { via: "merge" }));
+			}
+			adoptChildRun(book, cwd);
 		}
 		if (exit === 0 && /\bgit\b[^|;&]*\bcommit\b/.test(command) && !book.entries.some((entry) => entry.stage === "edit")) {
 			const cwd = String(book.header.cwd ?? "");
@@ -664,10 +699,10 @@ export default function (pi: ExtensionAPI) {
 	/**
 	 * Records one friction line for each anchor that passed again after it had passed and then failed. A pair is recorded
 	 * once, and not at all when the agent recorded a friction entry itself after the failure. The pairs one command
-	 * completes in one bash call (it is both the loop and a task anchor) share one entry. Returns the lines that tell the agent.
+	 * completes in one bash call (it is both the loop and a task anchor) share one entry. No instruction owns such a slip, so
+	 * the entry is reflected as `resolved` at once and the agent is told nothing.
 	 */
-	function autoFriction(book: Book): string[] {
-		const lines: string[] = [];
+	function autoFriction(book: Book): void {
 		const open = new Map<string, string[]>();
 		for (const pair of retryPairs(book.entries)) {
 			const id = `${pair.key}#${pair.fail}`;
@@ -688,24 +723,23 @@ export default function (pi: ExtensionAPI) {
 			const found = clip(String(failed.key ?? keyLine(String(failed.last ?? ""))) || "failed with no output");
 			const number = frictionOf(book.entries).length + 1;
 			book.entries.push(appendEntry(book.path, "friction", { id: number, tried, found, led_by: "none", auto: true, pairs }));
-			lines.push(`anchorloop: friction #${number} recorded from the ${tried}: ${found}. Classify it with \`reflect\` before close.`);
+			book.entries.push(appendEntry(book.path, "reflect", { friction: [String(number)], class: "resolved", action: "auto-recorded rerun" }));
 		}
-		return lines;
 	}
 
-	/** The footer line: the loop's kind, its last complete phase, the next one, and the friction still to reflect. */
+	/** The line below the editor: the loop's kind, its last complete phase, the next one, and the friction still to reflect; cleared when no loop is open. */
 	function showStatus(ctx: ExtensionContext): void {
-		if (typeof ctx.ui?.setStatus !== "function") return;
+		if (typeof ctx.ui?.setWidget !== "function") return;
 		const book = openLoop(ctx);
 		if (!book) {
-			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.setWidget(WIDGET_KEY, undefined);
 			return;
 		}
 		const phases = phasesOf(book, ctx);
 		const open = allFriction(book.entries).filter((item) => !item.reflected).length;
 		const kind = phases.kind === "undeclared" ? "no kind" : phases.kind;
 		const at = `${phases.current}${phases.current === "start" ? "" : " ✓"} → ${phases.next}`;
-		ctx.ui.setStatus(STATUS_KEY, `anchorloop ${kind} · ${at}${open ? ` · ${open} friction to reflect` : ""}`);
+		ctx.ui.setWidget(WIDGET_KEY, [`⚓ ${kind} · ${at}${open ? ` · ${open} friction` : ""}`], { placement: "belowEditor" });
 	}
 
 	pi.on(
@@ -721,14 +755,10 @@ export default function (pi: ExtensionAPI) {
 			if (event.toolName === "todo") {
 				const input = event.input as { action?: unknown; id?: unknown };
 				let open = openLoop(ctx);
-				const opens = !open && input.action === "create";
-				if (!open && opens) {
-					open = createBook(ctx);
-					recordPriorAnchor(open, ctx);
-				}
+				if (!open && input.action === "create") open = openFromTodo(ctx, event.details);
 				if (!open) return;
 				recordTasks(open, event.details, input, ctx.cwd);
-				return opens ? { content: [...event.content, { type: "text" as const, text: OPEN_LINE }] } : undefined;
+				return;
 			}
 			const book = openLoop(ctx);
 			if (!book) return;
@@ -833,8 +863,12 @@ function headAndTail(text: string): string {
 			const book = openLoop(ctx);
 			if (!book) return;
 			const stated = statedAnchor(message);
-			if (stated && !book.entries.some((entry) => entry.stage === "anchor" && entry.check === stated)) appendEntry(book.path, "anchor", { check: stated, line: true });
+			if (stated && !book.entries.some((entry) => entry.stage === "anchor" && entry.check === stated)) {
+				appendEntry(book.path, "anchor", { check: stated, line: true });
+				showStatus(ctx);
+			}
 			if (message.role !== "custom" || message.customType !== "subagent_result" || subagent) return;
+			adoptChildRun(book, ctx.cwd);
 			const agent = String(message.details?.agent ?? "");
 			if (REVIEWERS.has(agent)) {
 				const d = message.details ?? {};

package/pi/decision-tool.ts

@@ -55,18 +55,16 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "anchorloop_decision",
 		label: "Decision trail",
-		description:
-			"Append one row to a decision trail TSV (scratch/decisions-<task-slug>.tsv): a fork chosen, a unit completed, a pivot, or a blocker. " +
-			"Pass `start` with your run id instead of the row fields when picking up a trail another run wrote.",
+		description: "Append one row to scratch/decisions-<slug>.tsv for a fork, pivot, or blocker (git log holds completed units). `start` = your run id when picking up a trail.",
 		parameters: {
 			type: "object",
 			properties: {
-				log: { type: "string", description: "Trail path, relative to the working directory" },
-				start: { type: "string", description: "Run id; writes a start row and ignores the row fields" },
-				decision: { type: "string", description: "What was chosen or done, one line" },
-				why: { type: "string", description: "The reason in plain words" },
-				evidence: { type: "string", description: "A pointer: commit, file:line, or artifact path" },
-				result: { type: "string", description: "Outcome or predicate state" },
+				log: { type: "string" },
+				start: { type: "string" },
+				decision: { type: "string" },
+				why: { type: "string" },
+				evidence: { type: "string", description: "commit, file:line, or path" },
+				result: { type: "string" },
 			},
 			required: ["log"],
 			additionalProperties: false,

package/pi/second-thought.ts

@@ -4,8 +4,13 @@
  * summary, phase (current, next, missing), verify state, open todos, tasks, and friction, and judges only
  * whether the current phase's completion condition truly holds and whether to advance, go back, or ask
  * the user. It runs when a run settles and the book gained an entry since the last judgment, and at a
- * `close` declaration. The advisory is one line leading with `next → <phase>`; it continues the run once
- * when Jev agrees to advance and the next phase is a verify, review, or fix. A run that arranged a wake
+ * `close` declaration. The advisory is `next: <phase> (<missing>)` plus Jev's concerns, and is sent only when it
+ * changes the agent's next action: Jev has a concern, todos are still open without a followup, or the run
+ * continues. It continues the run once when Jev agrees to advance and the next phase is a verify, review, or
+ * fix, or when todos are still open without a followup (unless Jev says to ask the user). Away from close the
+ * advisory names up to three of those todos and asks the agent to continue, complete, or settle each with
+ * `metadata.followup`. An advisory with the same next phase, concerns, and open todo ids is sent once. At
+ * close only concerns are sent. A run that arranged a wake
  * (a monitor, a loop, a subagent) is waiting, not finished, and is not judged. Outside a loop nothing
  * runs, nor in a `quick` loop, whose only prompt is the close reminder; a subagent session registers
  * nothing, since the agent that spawned it judges its result.
@@ -14,7 +19,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { currentKind, guarded, openLoop } from "./support/book.ts";
 import { type Answers, classify } from "./support/jev.ts";
-import { type Snapshot, snapshot } from "./support/snapshot.ts";
+import { type Snapshot, listTodos, snapshot } from "./support/snapshot.ts";
 import { isSubagent } from "./support/subagent.ts";
 
 export { isSubagent, snapshot };
@@ -87,32 +92,52 @@ export function readVerdict(answers: Answers): Verdict | undefined {
 	};
 }
 
-export function assess(verdict: Verdict, snap: Snapshot): { found: string[]; notes: string[] } {
+export function assess(verdict: Verdict, snap: Snapshot): { found: string[] } {
 	const found: string[] = [];
-	const notes: string[] = [];
 	if (verdict.done < THRESHOLDS.doneBelow) found.push("evidence not shown to cover the intent");
-	if (verdict.review === THRESHOLDS.reviewTier) {
-		if (snap.reviewClear) notes.push("review rated full, but a review recorded after the last change found no blocking finding");
-		else found.push("needs full independent review");
-	}
+	// A review recorded after the last change with no blocking finding already covers the full-review rating.
+	if (verdict.review === THRESHOLDS.reviewTier && !snap.reviewClear) found.push("needs full independent review");
 	if (verdict.quality < THRESHOLDS.qualityBelow) found.push("result below the intent");
-	return { found, notes };
+	return { found };
 }
 
-/** True when Jev agrees to advance and the next phase is one the agent can act on now. */
+/** True when Jev agrees to advance and the next phase is one the agent can act on now, or open todos wait and the user is not needed. */
 export function continues(verdict: Verdict, snap: Snapshot): boolean {
+	if (snap.unsettled.length && verdict.move !== "ask-user") return true;
 	return verdict.move === "advance" && ACTIONABLE.has(snap.next);
 }
 
-/** One line: the program's next phase and its gap, Jev's move and scores, and, away from close, the call to act. */
-export function message(verdict: Verdict, snap: Snapshot, found: string[], notes: string[], atClose = false): string {
-	const extra = [...found, ...notes];
-	return (
-		`Second thought (Jev, advisory): next → ${snap.next}${snap.missing ? ` (missing: ${snap.missing})` : ""}; ` +
-		`${verdict.move}; done ${verdict.done.toFixed(2)}, review ${verdict.review}, quality ${verdict.quality.toFixed(2)}/3` +
-		`${extra.length ? `; ${extra.join("; ")}` : ""}.` +
-		(!atClose && continues(verdict, snap) ? ` Do ${snap.next} now, or say why it does not apply.` : "")
-	);
+/** What Jev's move adds to the program's reading when it is not "advance". */
+const MOVE_CONCERN: Record<Move, string | undefined> = { advance: undefined, back: "earlier evidence does not hold", "ask-user": "needs the user's decision" };
+
+/** Jev's concerns: a move against the program's reading, then the assessment findings. */
+export function concerns(verdict: Verdict, found: string[]): string[] {
+	const move = MOVE_CONCERN[verdict.move];
+	return move ? [move, ...found] : found;
+}
+
+/** The open todos the agent must answer, or the call to put them to the user. */
+function todoCall(verdict: Verdict, snap: Snapshot): string {
+	const list = `open: ${listTodos(snap.unsettled)}`;
+	return verdict.move === "ask-user"
+		? `${list} — ask the user about them with ask_user_question before ending the turn`
+		: `${list} — continue each, complete it, or set metadata.followup (a ticket id, \`memory\`, or \`drop — <reason>\`)`;
+}
+
+/** The advisory: the program's next phase and its gap, Jev's concerns, and, away from close, the open todos. Empty at close without concerns. */
+export function message(verdict: Verdict, snap: Snapshot, found: string[], atClose = false): string {
+	const list = concerns(verdict, found);
+	if (atClose) return list.length ? `Jev: ${list.join("; ")}.` : "";
+	return [
+		`next: ${snap.next}${snap.missing ? ` (${snap.missing})` : ""}`,
+		...(list.length ? [`concerns: ${list.join("; ")}`] : []),
+		...(snap.unsettled.length ? [todoCall(verdict, snap)] : []),
+	].join("\n");
+}
+
+/** What makes two advisories the same: the next phase, the concerns, and the open todo ids; the wording of the gap may change. */
+function adviceKey(verdict: Verdict, snap: Snapshot, found: string[]): string {
+	return JSON.stringify([snap.next, concerns(verdict, found), snap.unsettled.map((task) => task.id)]);
 }
 
 export default function (pi: ExtensionAPI) {
@@ -163,9 +188,10 @@ export default function (pi: ExtensionAPI) {
 			if (!snap) return;
 			const judgment = await judge(ctx, snap);
 			if (!judgment?.verdict) return;
-			const { found, notes } = assess(judgment.verdict, snap);
+			const { found } = assess(judgment.verdict, snap);
 			pi.appendEntry(ENTRY_TYPE, { ...judgment.verdict, at: "close", concerns: found });
-			return { content: [...event.content, { type: "text" as const, text: `\n${message(judgment.verdict, snap, found, notes, true)}` }] };
+			const text = message(judgment.verdict, snap, found, true);
+			return text ? { content: [...event.content, { type: "text" as const, text: `\n${text}` }] } : undefined;
 		}),
 	);
 
@@ -186,14 +212,17 @@ export default function (pi: ExtensionAPI) {
 			// A later handler's boundary result replaces the entries an earlier one returned, so carry them along.
 			const earlier = event.entries ?? [];
 			if (!judgment.verdict) return { entries: [...earlier, record({ verdict: "unknown", reason: judgment.reason })] };
-			const { found, notes } = assess(judgment.verdict, snap);
-			const text = message(judgment.verdict, snap, found, notes);
-			if (told.get(id) === text) return;
-			told.set(id, text);
+			const { found } = assess(judgment.verdict, snap);
+			const verdictEntry = record({ ...judgment.verdict, concerns: found });
 			const proceed = !continued && continues(judgment.verdict, snap);
+			// Jev agrees and nothing needs the agent: the verdict is recorded and nothing is said.
+			const speaks = proceed || snap.unsettled.length > 0 || concerns(judgment.verdict, found).length > 0;
+			const key = adviceKey(judgment.verdict, snap, found);
+			if (!speaks || told.get(id) === key) return { entries: [...earlier, verdictEntry] };
+			told.set(id, key);
 			if (proceed) continued = true;
 			return {
-				entries: [...earlier, record({ ...judgment.verdict, concerns: found }), { type: "custom_message" as const, customType: ENTRY_TYPE, content: text, display: true }],
+				entries: [...earlier, verdictEntry, { type: "custom_message" as const, customType: ENTRY_TYPE, content: message(judgment.verdict, snap, found), display: true }],
 				...(proceed ? { continue: true } : {}),
 			};
 		}),