@dumbmice/pi-todo-loop 0.1.1 → 0.2.0

package/src/index.ts

@@ -1,12 +1,13 @@
 /**
  * @dumbmice/pi-todo-loop — continuation driven by an rpiv-todo list.
  *
- * Pairs with `@juicesharp/rpiv-todo`; does not import or patch it. Three hooks:
+ * Pairs with `@juicesharp/rpiv-todo`; does not import or patch it. Hooks and tool:
  *
- *   context    append the live open-task list at the tail (never persisted),
- *              replacing a trailing marker so the request never ends user → user
- *   turn_end   request another turn while tasks are open, bounded by
- *              maxRounds / maxStrikes (see loop.ts)
+ *   context    drop a marker that would sit next to a human message, and
+ *              nothing else: the prompt is never rewritten with task state
+ *   turn_end   request another turn while tasks are open, bounded by maxRounds
+ *              (see loop.ts), and stop when the agent calls todo_loop_block
+ *   todo_loop_block  the agent's "I need a person" signal, scoped to one message
  *   /todoloop  status | pause | resume | reset
  *
  * Architecture notes worth keeping in mind when changing this file:
@@ -14,9 +15,8 @@
  *   - A `turn_end` continuation must leave the final message role != assistant,
  *     so one entry is mandatory (`_buildBoundaryContext().canContinue` in pi
  *     1.5.0). We append a `custom_message` with `display: false`.
- *   - Markers are never removed from history: they sit between assistant turns and
- *     are what keep the conversation alternating. A marker at the tail is replaced
- *     by the state block, so the request ends on exactly one user message.
+ *   - Markers are never added to a request by this extension, and are only removed
+ *     when one would sit next to a human message. A marker at the tail is the nudge.
  *   - pi's non-assistant requirement binds the *persisted projection* checked at
  *     `turn_end`, not the provider request (register item 3).
  *   - The marker customType is deliberately stable: sessions created by earlier
@@ -27,7 +27,6 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { loadConfig } from "./config.ts";
-import { renderInjection } from "./inject.ts";
 import { decide, initialState, type LoopState } from "./loop.ts";
 import { readSnapshot } from "./state.ts";
 
@@ -51,13 +50,22 @@ interface SessionContext {
 export const MARKER_TYPE = "todo-loop:continue";
 
 /**
- * Constant body. The marker keeps the persisted history alternating and gives
- * `turn_end` a non-assistant tail; it carries no counters, so a stale marker in
- * history cannot claim the loop is on some other round. It states the instruction
- * because with `injectState: false` this line is the only text the model receives.
+ * The only text this extension ever gives the model. It keeps the persisted
+ * history alternating, gives `turn_end` a non-assistant tail, and points at the
+ * todo tool rather than restating state: the list is the agent's to read.
+ * It carries no counters, so a stale marker in history cannot claim the loop is
+ * on some other round.
  */
 export const MARKER_BODY =
-	"Continue with the open todo tasks. If the human's latest instruction says to stop or limits what to do, do that instead.";
+	"Continue with the open todo tasks; use the todo tool to read and update the list. If the human's latest instruction says to stop or limits what to do, do that instead.";
+
+/**
+ * The same nudge, offered once per stall: this is the first stop since real progress
+ * that did not move the list, which is what a blocked agent looks like. The concession
+ * stays last — the block still ends by telling the model the human outranks it.
+ */
+export const MARKER_BODY_HINT =
+	"Continue with the open todo tasks; use the todo tool to read and update the list. If you cannot proceed without a person, call todo_loop_block with the reason. If the human's latest instruction says to stop or limits what to do, do that instead.";
 
 export const CONFIG_PATH = join(homedir(), ".pi/agent/todo-loop.json");
 const KILL_SWITCH_GLOBAL = join(homedir(), ".pi/agent/todo-loop-off");
@@ -97,13 +105,82 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 		}
 	};
 
-	const state: LoopState & { paused: boolean; reason: string; lastOpenCount: number } = {
+	const state: LoopState & {
+		paused: boolean;
+		reason: string;
+		lastOpenCount: number;
+		/** Set by `todo_loop_block`: this message waits for a human. */
+		waiting: { reason: string; anchor: string } | null;
+	} = {
 		...initialState(),
 		paused: false,
 		reason: "idle",
 		lastOpenCount: 0,
+		waiting: null,
 	};
 
+	// The agent's own exit. A blocked agent looks exactly like a lazy one from the
+	// loop's side, so the loop cannot detect it — but the agent can say so. One
+	// sentence of state, scoped to this message: the human's next message resumes.
+	pi.registerTool({
+		name: "todo_loop_block",
+		label: "Block the todo loop",
+		description:
+			"Stop the automatic continuation loop for the rest of this message because you need a person: a decision, a review, a credential or information only the human has. The human is shown your reason and their next message resumes the loop. Use it only when you cannot proceed on the open tasks without them.",
+		parameters: {
+			type: "object",
+			properties: {
+				reason: { type: "string", description: "What you need from the human, in one sentence." },
+			},
+			required: ["reason"],
+			additionalProperties: false,
+		},
+		async execute(_id: any, params: any, _signal: any, _onUpdate: any, ctx: SessionContext) {
+			// The hooks respect the kill switch and pause; a tool must not be the one
+			// surface that keeps talking after the extension was switched off.
+			if (isDisabled(ctx) || state.paused) {
+				return {
+					content: [
+						{ type: "text", text: "The todo loop is not running in this session, so there is nothing to block." },
+					],
+					details: undefined,
+				};
+			}
+			// Model-authored and rendered in the TUI: one line, bounded, no control characters.
+			// `\p{Cc}` covers C0 and C1 (U+0085 NEL and U+009B CSI included); the slice is by
+			// code point, so a cut at the limit cannot split a surrogate pair.
+			const cleaned = String(params?.reason ?? "")
+				.replace(/\p{Cc}+/gu, " ")
+				.replace(/\s+/g, " ")
+				.trim();
+			const reason = [...cleaned].slice(0, 200).join("");
+			if (reason === "") {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "todo_loop_block needs a reason: one sentence saying what you need from the human.",
+						},
+					],
+					details: undefined,
+				};
+			}
+			const snapshot = readSnapshot(branchEntries(ctx));
+			state.waiting = { reason, anchor: snapshot.anchor };
+			state.reason = `waiting for you: ${reason}`;
+			ctx.ui?.notify?.(`todo-loop: waiting for you — ${reason}`, "info");
+			return {
+				content: [
+					{
+						type: "text",
+						text: `The loop is stopped for this message; the human sees: ${reason}. Do not start other work — wait for their next message.`,
+					},
+				],
+				details: undefined,
+			};
+		},
+	});
+
 	pi.on("context", async (event: any, ctx: SessionContext) => {
 		if (isDisabled(ctx) || state.paused) return undefined;
 		// A hook that rewrites an unknown payload into a one-message request is
@@ -111,73 +188,43 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 		if (!Array.isArray(event?.messages)) return undefined;
 
 		const original = event.messages as unknown[];
-		const config = loadConfig(configPath);
-		// No injection configured: nothing below needs the branch at all.
-		if (!config.injectState) return undefined;
-
-		const snapshot = readSnapshot(branchEntries(ctx));
-		const injecting = snapshot.open.length > 0;
-		if (!injecting) return undefined;
-
-		// The marker is persisted between assistant turns, so it is what keeps the
-		// history alternating: assistant → marker(user) → assistant. Stripping the
-		// historical ones would expose runs of consecutive assistant messages, which
-		// alternation-requiring providers reject. So markers stay in history; only a
-		// marker sitting at the tail (the continuation request about to be made) is
-		// replaced by the state block, so the request never ends on user → user.
-		const text = { type: "text", text: renderInjection(snapshot, config, { reconcile: state.rounds >= 1 }) };
 		const record = (message: unknown): Record<string, unknown> | null =>
 			typeof message === "object" && message !== null ? (message as Record<string, unknown>) : null;
 		const isMarker = (message: unknown): boolean => record(message)?.customType === MARKER_TYPE;
-		// pi projects every role except these to a user-role message in the request:
-		// `custom`, `bashExecution`, `branchSummary`, `compactionSummary`, and plain
-		// `user`. Anything else is user-role for the purpose of alternation, so the test
-		// is a whitelist of non-user roles — the direction that merges rather than
-		// appending a second user message.
+		// pi projects every role except these to a user-role message in the request.
 		const NON_USER_ROLES = new Set(["assistant", "toolResult", "system", "tool"]);
 		const isUserRole = (message: unknown): boolean => {
 			const role = record(message)?.role;
 			return typeof role === "string" && !NON_USER_ROLES.has(role);
 		};
 
-		// A marker only earns its place *between* two assistant turns, where it is the
-		// alternation glue. Anywhere else it is redundant bookkeeping that would sit
-		// next to a real user message and break alternation: drop it. That covers a
-		// marker at the tail, a marker followed by a human message, and two markers in
-		// a row.
-		const kept = (original as unknown[]).filter((message, index, list) => {
+		// Nothing is ever *added* to a request: the prompt the human sends, and every
+		// tool turn, go out exactly as built. The one thing this hook may do is remove
+		// the marker this extension itself appended, when it would sit next to a human
+		// message and project to `user → user` — an adjacency pi's providers reject, and
+		// one the extension created. Between two assistant turns the marker stays: it is
+		// the glue that keeps that pair alternating.
+		const neighbour = (list: unknown[], from: number, step: number): unknown => {
+			for (let index = from; index >= 0 && index < list.length; index += step) {
+				if (!isMarker(list[index])) return list[index];
+			}
+			return undefined;
+		};
+		const kept = original.filter((message, index, list) => {
 			if (!isMarker(message)) return true;
-			const previous = list[index - 1];
-			const next = list[index + 1];
-			// Both neighbours must exist and neither may be user-role: `[A, M, H]` and
-			// `[A, H, M, A]` both leave a marker next to a human message, which is the
-			// adjacency this filter exists to prevent.
-			return previous !== undefined && next !== undefined && !isUserRole(previous) && !isUserRole(next);
+			// Keep only the first marker of a run: that is what preserves
+			// `assistant → marker → assistant`, while testing the literal neighbours drops
+			// the whole run and leaves two assistant turns adjacent.
+			if (isMarker(list[index - 1])) return false;
+			const previous = neighbour(list, index - 1, -1);
+			const next = neighbour(list, index + 1, 1);
+			// Drop it only when it would project to `user → user`: next to a human message,
+			// on either side. A marker at the tail is the nudge itself — dropping it would
+			// leave the continuation request ending on an assistant turn.
+			return !isUserRole(previous) && !isUserRole(next);
 		});
 
-		// Nothing left to attach to: an empty request would be an instruction with no prompt.
-		if (kept.length === 0) return undefined;
-
-		const tail = kept[kept.length - 1];
-		const tailRole = record(tail)?.role;
-		// pi rebuilds the content of `bashExecution`, `branchSummary` and
-		// `compactionSummary` from their own fields and ignores `content`, so merging
-		// into one of those would silently drop the block. Only `user` and `custom`
-		// honour `content`; the others get a separate message.
-		const mergeable = tailRole === "user" || tailRole === "custom";
-		if (tail !== null && isUserRole(tail) && mergeable) {
-			// Merge into the human's own message rather than adding a second one after it.
-			const entry = tail as Record<string, unknown>;
-			const existing = Array.isArray(entry.content)
-				? (entry.content as unknown[])
-				: typeof entry.content === "string" && entry.content !== ""
-					? [{ type: "text", text: entry.content }]
-					: [];
-			const content = [...existing, text];
-			return { messages: [...kept.slice(0, -1), { ...entry, content }] };
-		}
-
-		return { messages: [...kept, { role: "user", content: [text], timestamp: Date.now() }] };
+		return kept.length === original.length ? undefined : { messages: kept };
 	});
 
 	pi.on("turn_end", async (event: any, ctx: SessionContext) => {
@@ -192,10 +239,9 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 		// would be redundant — and counting it as a round spends the budget on work the
 		// loop did not cause. Only a settle (no tool results) can spend a round.
 		//
-		// A tool turn is still *work*, so it clears a pending strike: without this, a
-		// model that runs tools and never updates the list (the case this extension is
-		// for) collects two strikes across its settles and stops with "no progress"
-		// while it was working the whole time.
+		// A tool turn is *work*, so it clears the stall counter and re-arms the block
+		// hint: an agent that keeps working is not stuck, and a later stall is a new
+		// question rather than a repeat of the old one.
 		// A list that goes open -> clear in a turn whose only tool calls were `todo` is
 		// the loop's success state and its failure state at once. Never police it;
 		// just do not launder the trust: say so once.
@@ -210,13 +256,30 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 			}
 		}
 		state.lastOpenCount = snapshot.open.length;
+		// The human answered: the block belonged to the previous message.
+		if (state.waiting !== null && state.waiting.anchor !== snapshot.anchor) {
+			state.waiting = null;
+			state.reason = "resumed by user";
+		}
 
 		if (toolResultCount > 0) {
 			if (String(event?.outcome) !== "completed") {
 				state.reason = `stopped: turn outcome was ${String(event?.outcome)}`;
 				return undefined;
 			}
-			state.strikes = 0;
+			state.stalled = 0;
+			state.hintSent = false;
+			return undefined;
+		}
+
+		// The agent asked for a person. Nothing continues until the human answers; their
+		// next message is a new anchor, so the block clears itself.
+		if (state.waiting !== null && state.waiting.anchor === snapshot.anchor) {
+			const waiting = `waiting for you: ${state.waiting.reason}`;
+			if (state.reason !== waiting) {
+				state.reason = waiting;
+				ctx.ui?.notify?.(`todo-loop: ${waiting}`, "info");
+			}
 			return undefined;
 		}
 
@@ -251,7 +314,7 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 				{
 					type: "custom_message",
 					customType: MARKER_TYPE,
-					content: MARKER_BODY,
+					content: decision.hint ? MARKER_BODY_HINT : MARKER_BODY,
 					display: false,
 				},
 			],
@@ -281,7 +344,11 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 				return;
 			}
 			if (command === "reset") {
-				Object.assign(state, initialState(), { paused: state.paused, reason: "counters reset" });
+				Object.assign(state, initialState(), {
+					paused: state.paused,
+					reason: "counters reset",
+					waiting: null,
+				});
 				ctx.ui?.notify?.("todo-loop: counters reset", "info");
 				return;
 			}
@@ -299,20 +366,26 @@ export default function todoLoop(pi: any, options: TodoLoopOptions = {}): void {
 			}
 
 			const snapshot = readSnapshot(branchEntries(ctx));
+			const waitingNow = state.waiting !== null && state.waiting.anchor === snapshot.anchor;
 			const mode = isDisabled(ctx)
 				? "DISABLED (kill-switch present)"
 				: state.paused
 					? "PAUSED"
-					: state.reason.startsWith("stopped:")
-						? "stopped (next human message starts a new budget)"
-						: "active";
+					: waitingNow
+						? "waiting (the agent asked for you; your next message resumes)"
+						: state.reason.startsWith("stopped:")
+							? "stopped (next human message starts a new budget)"
+							: "active";
 			ctx.ui?.notify?.(
 				[
 					`todo-loop ${mode}`,
-					`rounds ${state.rounds}/${config.maxRounds} · strikes ${state.strikes}/${config.maxStrikes}`,
-					`open ${snapshot.open.length}/${snapshot.tasks.length} tracked · inject ${config.injectState ? "on" : "off"}`,
+					`rounds ${state.rounds}/${config.maxRounds} · stalled ${state.stalled}`,
+					// Only while it still belongs to this message: the human's next one
+					// resumes the loop even though the reason is still in memory.
+					...(waitingNow ? [`waiting: ${(state.waiting as { reason: string }).reason}`] : []),
+					`open ${snapshot.open.length}/${snapshot.tasks.length} tracked`,
 					`anchor ${snapshot.anchor || "(none)"}`,
-					`last: ${state.reason}`,
+					`last: ${waitingNow ? `waiting for you: ${(state.waiting as { reason: string }).reason}` : state.reason}`,
 					`config ${configPath}`,
 				].join("\n"),
 				"info",

package/src/loop.ts

@@ -9,11 +9,16 @@
 export interface LoopState {
 	/** Continuations started since the last human message. */
 	rounds: number;
-	/** Consecutive turns that neither ran a tool nor changed the task list. */
-	strikes: number;
+	/**
+	 * Consecutive settles that neither ran a tool nor changed the task list. No cap:
+	 * it decides when to offer the block tool, not when to give up.
+	 */
+	stalled: number;
+	/** Whether the "call todo_loop_block" clause has already been offered this stall. */
+	hintSent: boolean;
 	/** Task signature at the previous decision, to detect list changes. */
 	lastSignature: string;
-	/** Settles since the list last changed: a stale list stops on the cap, not on strikes. */
+	/** Settles since the list last changed: a stale list stops on the cap. */
 	staleSettles: number;
 	/** Id of the user message the current budget belongs to. */
 	anchor: string;
@@ -22,19 +27,10 @@ export interface LoopState {
 export interface LoopConfig {
 	/** Max consecutive auto-continuations per human message. */
 	maxRounds: number;
-	/** Consecutive no-progress turns tolerated before stopping. */
-	maxStrikes: number;
-	/** Inject the live task list at the tail of every request. */
-	injectState: boolean;
-	/** Max open tasks rendered in that injection. */
-	maxInjectedTasks: number;
 }
 
 export const DEFAULTS: LoopConfig = {
 	maxRounds: 12,
-	maxStrikes: 2,
-	injectState: true,
-	maxInjectedTasks: 6,
 };
 
 export type DecisionInput = {
@@ -60,17 +56,24 @@ export interface Decision {
 	/** True when the caller should persist `rounds` as they are (no reset). */
 	next: LoopState;
 	reason: string;
+	/**
+	 * True when this continuation should carry the "if you cannot proceed without a
+	 * person, call todo_loop_block" clause. Offered once per stall: this is the first
+	 * stop since real progress that did not move the list — the shape a blocked agent
+	 * has.
+	 */
+	hint: boolean;
 }
 
 /**
  * A stop keeps the counters. Only a new human message starts a new budget: a cap
- * or strike stop that cleared them would re-arm the full budget on the next
+ * or cap stop that cleared them would re-arm the full budget on the next
  * `turn_end` under the same anchor (another extension's continuation, a provider
  * retry). A queued human message is a new anchor by definition, so it resets the
  * budget the ordinary way.
  */
 function stop(state: LoopState, reason: string): Decision {
-	return { continue: false, next: { ...state }, reason };
+	return { continue: false, next: { ...state }, hint: false, reason };
 }
 
 /**
@@ -85,7 +88,7 @@ export function decide(input: DecisionInput): Decision {
 	// A new human message owns a fresh budget.
 	let current: LoopState =
 		input.anchor !== state.anchor
-			? { ...state, rounds: 0, strikes: 0, lastSignature: "", staleSettles: 0, anchor: input.anchor }
+			? { ...state, rounds: 0, stalled: 0, hintSent: false, lastSignature: "", staleSettles: 0, anchor: input.anchor }
 			: { ...state };
 
 	if (input.outcome !== "completed") {
@@ -97,35 +100,42 @@ export function decide(input: DecisionInput): Decision {
 
 	const progressed = input.toolResultCount > 0 || input.signature !== current.lastSignature;
 	if (progressed) {
-		current.strikes = 0;
+		// Work re-arms the hint: a second stall, after real progress, is a new question.
+		current.stalled = 0;
+		current.hintSent = false;
 		current.staleSettles = 0;
 	} else {
 		current.staleSettles += 1;
-		// A budget must never read above the cap it is measured against (`strikes 3/2`).
-		current.strikes = Math.min(current.strikes + 1, config.maxStrikes);
-		if (current.strikes >= config.maxStrikes) {
-			return stop(
-				current,
-				`stopped: ${current.strikes} consecutive turns with no progress, ${input.openCount} open`,
-			);
-		}
+		current.stalled += 1;
 	}
 
+	// A repeat stop is the shape a blocked agent has: it already answered once, it did
+	// not move the list, and it stopped again. Offer the block tool there — once per
+	// stall — and never stop the loop for it. The only stops are a clear list, the
+	// round cap, an error, and the agent asking for a person.
+	const hint = current.stalled >= 1 && !current.hintSent;
+
 	if (current.rounds >= config.maxRounds) {
 		const stale =
 			current.staleSettles >= 2 ? `, list unchanged for ${current.staleSettles} settles` : "";
-		return stop(current, `stopped: round cap ${config.maxRounds} reached, ${input.openCount} open${stale}`);
+		// A hint that comes due on the cap round has no continuation left to ride in.
+		// Do not drop it silently: the human reads the reason, and the agent may be
+		// blocked rather than done.
+		const stalled = hint ? ", the agent stalled and may need a person" : "";
+		return stop(current, `stopped: round cap ${config.maxRounds} reached, ${input.openCount} open${stale}${stalled}`);
 	}
 
 	current.rounds += 1;
 	current.lastSignature = input.signature;
+	if (hint) current.hintSent = true;
 	return {
 		continue: true,
 		next: current,
+		hint,
 		reason: `continuing: round ${current.rounds}/${config.maxRounds}, ${input.openCount} open`,
 	};
 }
 
 export function initialState(): LoopState {
-	return { rounds: 0, strikes: 0, lastSignature: "", staleSettles: 0, anchor: "" };
+	return { rounds: 0, stalled: 0, hintSent: false, lastSignature: "", staleSettles: 0, anchor: "" };
 }

package/src/inject.ts

@@ -1,97 +0,0 @@
-/**
- * The state injection.
- *
- * Appended at the tail of every request by the `context` hook and never
- * persisted. Two properties matter:
- *
- *   - It is the *whole* open list (bounded), not a hint to call `list`. After
- *     compaction the model has no other way to learn the list still exists.
- *   - It is a user-role block appended at the tail, replacing a trailing
- *     continuation marker so the request never ends on two user-role messages.
- */
-
-import type { LoopConfig } from "./loop.ts";
-import type { Snapshot } from "./state.ts";
-
-export const INJECT_TAG = "todo_loop_state";
-
-function label(status: string, subject: string, activeForm?: string): string {
-	if (status === "in_progress" && activeForm) return activeForm;
-	return subject || "(untitled)";
-}
-
-/**
- * One line of model-authored text, rendered inside a tag at the end of a request.
- *
- * A task subject is written by the model, possibly from a fetched page or a repo
- * file, so it must not be able to: close the tag (`</`), start a new line that reads
- * like one of our own directives, or push the block to an unbounded size.
- */
-export function sanitizeLabel(text: string): string {
-	// Every Unicode line terminator, not just \n: U+2028/9 and NEL (U+0085) split a
-	// line for some readers, which is the channel this function exists to close.
-	const flattened = text.replace(/[\r\n\t\u2028\u2029\u0085]+/g, " ");
-	// C0/C1 controls, bidi overrides and isolates, zero-width and BOM characters: a
-	// NUL can break JSON encoding and a bidi override can visually reverse a line.
-	const cleaned = flattened.replace(
-		/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069\ufeff]/g,
-		"",
-	);
-	// No tag can be opened or closed from task text: `<` is escaped, which also covers
-	// `</` and a bare `<todo_loop_state>` that would invert the block's nesting.
-	const escaped = cleaned.replaceAll("<", "&lt;").replaceAll("&lt;", "&lt;");
-	// Bound the working set before materialising code points (a 1 MB subject would
-	// otherwise allocate a 1M-element array per row); 480 UTF-16 units can hold far
-	// more than the 120 code points that survive.
-	const bounded = escaped.length > 480 ? escaped.slice(0, 480) : escaped;
-	// By code point, never UTF-16 units: `slice` can cut a surrogate pair in half and
-	// leave a lone surrogate in the request.
-	const points = Array.from(bounded).slice(0, 120).join("");
-	// An unpaired surrogate already in the payload survives `Array.from`; drop it so the
-	// request is always valid UTF-16.
-	return points.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "").trim();
-}
-
-export interface InjectionOptions {
-	/**
-	 * Add the reconciliation clause. Off for the first nudge of a chain, on afterwards:
-	 * handing a model an explicit "fix the list" instruction on its first sighting
-	 * invites it to reshape the list instead of doing the work, while after one nudge a
-	 * drifted list is the likelier explanation.
-	 */
-	reconcile?: boolean;
-}
-
-const RECONCILE_CLAUSE = [
-	"If this list has drifted from the work, reconcile it now: update statuses,",
-	"add what is missing, and remove what no longer applies.",
-].join("\n");
-
-export function renderInjection(
-	snapshot: Snapshot,
-	config: LoopConfig,
-	options: InjectionOptions = {},
-): string {
-	const shown = snapshot.open.slice(0, config.maxInjectedTasks);
-	const rows = shown.map(
-		(task) =>
-			`  ${task.id}. [${sanitizeLabel(task.status)}] ${sanitizeLabel(
-				label(task.status, task.subject, task.activeForm),
-			)}`,
-	);
-	const hidden = snapshot.open.length - shown.length;
-
-	return [
-		`<${INJECT_TAG}>`,
-		`${snapshot.open.length} tracked task(s) are still open on this branch:`,
-		...rows,
-		...(hidden > 0 ? [`  ... and ${hidden} more`] : []),
-		"The human's latest message outranks everything above: if it says to stop, to wait,",
-		"or limits what to do, do that instead and say so in one line. Otherwise carry on",
-		"with the open tasks, and move a task to in_progress when you start it and to",
-		"completed only once it is actually verified — if a task cannot be verified now,",
-		"leave it open and say what is blocking it.",
-		...(options.reconcile ? [RECONCILE_CLAUSE] : []),
-		`</${INJECT_TAG}>`,
-	].join("\n");
-}