@hank-warren/pi-loop 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @hank-warren/pi-loop
+
+## 0.2.1
+
+### Patch Changes
+
+- 2b22273: Stop the loop with "goal completed" when pi-goal clears its state entry after completion. pi-goal persists the finished goal (status complete) and then writes a clear (goal: null), so by the loop's next tick the last goal-state entry was the clear and the loop paused as goal-missing instead of stopping as goal-complete. readGoalSnapshot now reads a completed goal through its completion clear; a clear over any non-complete goal (user /goal clear mid-flight) still pauses the loop.
+
+## 0.2.0
+
+### Minor Changes
+
+- 4e16c70: Redesign inline invocation to be tool-mediated, fixing message loss, "Agent is already processing a prompt" errors, and uninterruptible turns caused by the input-splitting approach (extension-sent messages are never dispatched as commands, so the re-sent `/goal` reached the model as plain text and the user's prose was dropped).
+
+  pi-goal: new `goal_start` tool reuses the `/goal` command's exact activation path; mid-prompt `/goal <objective>` and line-leading `goal: <objective>` invocations now append a one-line reminder to the otherwise-untouched message so the model calls the tool — nothing is cut, split, or re-sent. The `inlineInvocation` setting gates the reminder.
+
+  pi-loop: loops now require an active pi-goal goal to operate — start refuses without one, a cleared goal pauses the loop, completion still stops it. `/loop` is user-typed only: the inline `/loop` input handler and the `pokePreamble`/`inlineInvocation` settings are removed, and the loop prompt is now an optional focus added to goal pokes.

package/README.md

@@ -1,21 +1,22 @@
 # pi-loop — interval wakeups for the Pi coding agent
 
-Inspired by Claude Code's `/loop`, adapted to Pi: re-run a prompt on an interval, rescue a stalled session that has an unfinished [pi-goal](https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-goal) goal, and keep long loops coherent across context compaction.
+Inspired by Claude Code's `/loop`, adapted to Pi: wake the session on an interval to keep an active [pi-goal](https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-goal) goal moving, and keep long loops coherent across context compaction.
 
-pi-loop is a **pacemaker, not an evaluator**: it owns *when* the session wakes; pi-goal owns *whether the work is done*. It reads pi-goal's `goal-state` and pi-plan-mode's `plan-mode-state` session entries read-only and fail-open — with neither installed it still runs plain recurring-prompt loops.
+pi-loop is a **pacemaker, not an evaluator**: it owns *when* the session wakes; pi-goal owns *whether the work is done*. **Loops require an active goal to operate** — the goal evaluator is the stop criterion, so a loop without a goal has nothing to decide when it is done. Coupling is read-only, fail-open reads of pi-goal's `goal-state` and pi-plan-mode's `plan-mode-state` session entries.
 
 ## Usage
 
 ```
-/loop 5m check my PR, address review comments, fix CI   # recurring prompt every 5 minutes
-/loop 30m                                               # pi-goal goal active: poke it every 30 minutes
-/loop                                                   # manager TUI (status, pause/resume, edit, settings, stop)
+/goal get CI green                          # loops need an active goal first
+/loop 30m                                   # poke the goal every 30 minutes if the session stalls
+/loop 10m recheck the pipeline              # optional focus text added to every poke
+/loop                                       # manager TUI (status, pause/resume, edit, settings, stop)
 /loop status | pause | resume | stop | settings
-/loop --max 20 --compact-at 60% 10m <prompt>            # per-loop overrides
+/loop --max 20 --compact-at 60% 10m         # per-loop overrides
 ```
 
 - **Intervals** are `<number><unit>` with unit `s`/`m`/`h`/`d`, parsed by the extension (never the model), minimum 1 minute (smaller values clamp, and the effective value is echoed).
-- `/loop` also works **mid-prompt** (`get CI green — /loop 10m recheck the pipeline`): the command dispatches first and the surrounding prose follows. Backtick code is ignored; messages with images pass through. Toggle with the `inlineInvocation` setting.
+- `/loop` is deliberately **user-typed only** — the model never starts or stops loops. (Inline `/goal` invocation is the [pi-goal fork](https://github.com/hank-warren/pi-extensions/tree/main/packages/pi-goal)'s `goal_start` tool.)
 
 ## What a wakeup does
 
@@ -24,9 +25,9 @@ Each tick evaluates, in order:
 1. **Expired?** Loops hard-expire after `maxLoopDuration` (default 7 days) — a forgotten loop is bounded.
 2. **Plan mode active?** Skip quietly; never inject prompts into a planning conversation.
 3. **Agent busy?** Never interrupt: coalesce into a single pending wake delivered at the next fully-settled idle boundary. N missed ticks collapse into one poke.
-4. **Goal state** (when pi-goal has a goal): completion **stops** the loop; a safety pause (`paused`/`blocked`/`usage_limited`/`budget_limited`) **pauses** the loop — pi-loop never pokes past pi-goal's circuit breakers; an `active` or `goal_wait`-waiting goal in an idle session is exactly the stall this extension exists for, so it pokes toward the goal (a tick is the external wake `goal_wait` arranges).
+4. **Goal state**: a missing goal (cleared mid-loop) **pauses** the loop; completion **stops** it; a safety pause (`paused`/`blocked`/`usage_limited`/`budget_limited`, or any unknown status) **pauses** it — pi-loop never pokes past pi-goal's circuit breakers. An `active` or `goal_wait`-waiting goal in an idle session is exactly the stall this extension exists for, so it pokes toward the goal (a tick is the external wake `goal_wait` arranges).
 5. **Iteration cap** (default 25 delivered pokes, `--max`/settings, explicit `unlimited` opt-in): stop.
-6. **Poke**: the stored prompt (with a short scheduled-iteration preamble) or a goal wake message. Every loop-injected message carries a provenance marker (`<!-- pi-loop-poke:<id>:<n> -->`) so wakeups are distinguishable from user prompts and stale wakes are dropped.
+6. **Poke**: a goal wake message restating the goal (plus the loop focus, when set). Every loop-injected message carries a provenance marker (`<!-- pi-loop-poke:<id>:<n> -->`) so wakeups are distinguishable from user prompts and stale wakes are dropped.
 
 The footer widget shows `loop 5m · 3/25 · next 14:32`; `/loop status` shows the full card including the last tick's decision and reason.
 
@@ -51,13 +52,11 @@ Long loops die by context exhaustion, not by failing. pi-loop owns the compactio
     "threshold": 0.7,
     "postCompactContinuation": true,
     "instructions": null
-  },
-  "pokePreamble": null,
-  "inlineInvocation": true
+  }
 }
 ```
 
-`maxIterations: null` means unlimited. `compaction.instructions` and `pokePreamble` override the built-in templates.
+`maxIterations: null` means unlimited. `compaction.instructions` overrides the built-in template.
 
 ## Install
 
@@ -65,7 +64,7 @@ Long loops die by context exhaustion, not by failing. pi-loop owns the compactio
 pi install npm:@hank-warren/pi-loop
 ```
 
-Works standalone; pairs best with `npm:@hank-warren/pi-goal` (or upstream `@narumitw/pi-goal`) for goal-evaluated stop criteria.
+Requires a goal extension for its session entries: `npm:@hank-warren/pi-goal` (recommended) or upstream `@narumitw/pi-goal`.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-loop",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Interval wakeups for Pi: recurring prompt re-runs, stall rescue toward an active pi-goal goal, and loop-aware compaction that survives long sessions.",
   "type": "module",
   "keywords": [

package/src/decide.ts

@@ -3,8 +3,9 @@
  * decides what a wakeup does, so the full decision matrix is unit-testable
  * without timers or a Pi runtime.
  *
- * Precedence (approved plan): loop liveness → expiry → plan mode → busy →
- * goal state → iteration cap → poke.
+ * Precedence: loop liveness → expiry → plan mode → busy → goal presence and
+ * state (loops require an active pi-goal goal to operate) → iteration cap →
+ * poke.
  */
 
 import { GOAL_SAFETY_STATUSES, type GoalSnapshot, type LoopState } from "./state.js";
@@ -25,7 +26,8 @@ export type TickDecision =
 	| { action: "skip"; reason: "plan-mode-active" | "agent-busy" | "compaction-in-flight" }
 	| { action: "stop"; reason: "goal-complete" | "max-iterations" }
 	| { action: "pause"; reason: "goal-safety"; cause: string }
-	| { action: "poke"; reason: "recurring-prompt" | "goal-stalled" | "goal-waiting" };
+	| { action: "pause"; reason: "goal-missing" }
+	| { action: "poke"; reason: "goal-stalled" | "goal-waiting" };
 
 export function decideTick(loop: LoopState, env: TickEnvironment): TickDecision {
 	if (loop.status !== "active") return { action: "none", reason: "loop-not-active" };
@@ -35,28 +37,26 @@ export function decideTick(loop: LoopState, env: TickEnvironment): TickDecision
 	if (env.busy) return { action: "skip", reason: "agent-busy" };
 
 	const goal = env.goal;
-	if (goal) {
-		if (goal.status === "complete") return { action: "stop", reason: "goal-complete" };
-		if ((GOAL_SAFETY_STATUSES as readonly string[]).includes(goal.status)) {
-			return { action: "pause", reason: "goal-safety", cause: goal.status };
-		}
-		if (goal.status !== "active") {
-			// Unknown status from a newer pi-goal: treat like a safety state
-			// rather than poking past a guard we do not understand.
-			return { action: "pause", reason: "goal-safety", cause: goal.status };
-		}
+	// Loops require a goal to operate: the goal evaluator owns the stop
+	// criterion, so a loop with no goal has nothing to decide when it is done.
+	if (!goal) return { action: "pause", reason: "goal-missing" };
+	if (goal.status === "complete") return { action: "stop", reason: "goal-complete" };
+	if ((GOAL_SAFETY_STATUSES as readonly string[]).includes(goal.status)) {
+		return { action: "pause", reason: "goal-safety", cause: goal.status };
+	}
+	if (goal.status !== "active") {
+		// Unknown status from a newer pi-goal: treat like a safety state
+		// rather than poking past a guard we do not understand.
+		return { action: "pause", reason: "goal-safety", cause: goal.status };
 	}
 
 	if (loop.maxIterations !== null && loop.iteration >= loop.maxIterations) {
 		return { action: "stop", reason: "max-iterations" };
 	}
 
-	if (goal) {
-		// An idle session with an active goal is exactly the stall/wait case:
-		// pi-goal continues on its own at every idle boundary, so idleness at
-		// tick time means its continuation was lost, or the goal is waiting on
-		// an external event — which this wakeup is.
-		return { action: "poke", reason: goal.waiting ? "goal-waiting" : "goal-stalled" };
-	}
-	return { action: "poke", reason: "recurring-prompt" };
+	// An idle session with an active goal is exactly the stall/wait case:
+	// pi-goal continues on its own at every idle boundary, so idleness at
+	// tick time means its continuation was lost, or the goal is waiting on
+	// an external event — which this wakeup is.
+	return { action: "poke", reason: goal.waiting ? "goal-waiting" : "goal-stalled" };
 }

package/src/index.ts

@@ -1,14 +1,14 @@
 /**
- * pi-loop: Claude-Code-/loop-inspired pacemaker for Pi with hybrid semantics
- * (recurring prompt re-runs plus stall rescue) and loop-aware compaction.
- * The loop owns *when* the session wakes; @narumitw/pi-goal (or the
+ * pi-loop: Claude-Code-/loop-inspired pacemaker for Pi. A loop wakes the
+ * session on an interval to keep an active pi-goal goal moving (stall rescue
+ * and goal_wait wakes) with loop-aware compaction. Loops require an active
+ * goal: the loop owns *when* the session wakes; @narumitw/pi-goal (or the
  * @hank-warren/pi-goal fork) owns *whether the work is done*, read through
  * its `goal-state` session entries only.
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { completeLoopArguments, parseLoopCommand } from "./command.js";
-import { registerInlineInvocation } from "./inline-invocation.js";
 import { LoopController, type LoopControllerOptions } from "./loop.js";
 import { showLoopManager, showLoopSettings } from "./manager.js";
 
@@ -17,7 +17,7 @@ export default function loop(pi: ExtensionAPI, options: LoopControllerOptions =
 
 	pi.registerCommand("loop", {
 		description:
-			"Wake the session on an interval: /loop [--max N] [--compact-at 60%] <interval> [prompt]",
+			"Wake the session on an interval to keep the active /goal moving: /loop [--max N] [--compact-at 60%] <interval> [focus]",
 		getArgumentCompletions: (prefix: string) => completeLoopArguments(prefix),
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			const command = parseLoopCommand(args);
@@ -80,5 +80,4 @@ export default function loop(pi: ExtensionAPI, options: LoopControllerOptions =
 	pi.on("session_compact", async (_event, ctx) => {
 		controller.onSessionCompact(ctx);
 	});
-	registerInlineInvocation(pi, controller);
 }

package/src/loop.ts

@@ -8,8 +8,9 @@
  * - Pokes deliver only at a fully idle boundary; a tick that lands while the
  *   agent is busy coalesces into a single pending wake delivered at the next
  *   agent_settled. Missed ticks never stack.
- * - pi-goal owns "whether the work is done": its safety states pause the loop,
- *   its completion stops it, and its thresholds ride along in the
+ * - Loops require an active pi-goal goal to operate: pi-goal owns "whether
+ *   the work is done". Its safety states pause the loop, its completion stops
+ *   it, a missing goal pauses the loop, and its thresholds ride along in the
  *   post-compaction continuation. Coupling is read-only session entries.
  * - The loop's proactive compaction is the normal compaction path; Pi's
  *   reserve-token auto-compaction is the fault handler.
@@ -28,7 +29,6 @@ import {
 	buildCompactionInstructions,
 	buildGoalPoke,
 	buildPostCompactContinuation,
-	buildPromptPoke,
 } from "./messages.js";
 import {
 	DEFAULT_LOOP_SETTINGS,
@@ -201,7 +201,9 @@ export class LoopController {
 			case "pause":
 				this.transition(
 					"paused",
-					`pi-goal reports the goal is ${decision.cause}; resolve it, then /loop resume`,
+					decision.reason === "goal-missing"
+						? "loops require an active goal; start one with /goal <objective>, then /loop resume"
+						: `pi-goal reports the goal is ${decision.cause}; resolve it, then /loop resume`,
 				);
 				return;
 			case "poke":
@@ -213,14 +215,11 @@ export class LoopController {
 	private deliverPoke(
 		ctx: ExtensionContext,
 		env: TickEnvironment,
-		reason: "recurring-prompt" | "goal-stalled" | "goal-waiting",
+		reason: "goal-stalled" | "goal-waiting",
 	): void {
 		const loop = this.state;
-		if (!loop) return;
-		const message =
-			reason === "recurring-prompt" || !env.goal
-				? buildPromptPoke(loop, this.settings.pokePreamble)
-				: buildGoalPoke(loop, env.goal, reason === "goal-waiting" ? "goal-waiting" : "goal-stalled");
+		if (!loop || !env.goal) return;
+		const message = buildGoalPoke(loop, env.goal, reason);
 		this.state = { ...loop, iteration: loop.iteration + 1, lastWakeAt: env.now };
 		this.persist();
 		this.pi.sendUserMessage(message);
@@ -315,7 +314,7 @@ export class LoopController {
 			`Expires: ${new Date(loop.expiresAt).toLocaleString()}`,
 			`Proactive compaction: ${loop.compactAt === null ? "off" : `at ${Math.round(loop.compactAt * 100)}% of context`}`,
 		];
-		if (loop.prompt) lines.push(`Prompt: ${loop.prompt}`);
+		if (loop.prompt) lines.push(`Focus: ${loop.prompt}`);
 		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
 		if (goal) lines.push(`Goal (pi-goal): ${goal.status} — ${goal.text}`);
 		if (this.nextWakeAt && loop.status === "active") {
@@ -335,9 +334,9 @@ export class LoopController {
 		this.sessionCtx = ctx;
 		const now = this.now();
 		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
-		if (!start.prompt && goal?.status !== "active") {
+		if (goal?.status !== "active") {
 			ctx.ui.notify(
-				"A prompt is required unless a pi-goal goal is active: /loop <interval> <prompt>.",
+				"Loops require an active goal to operate. Start one first: /goal <objective>, then /loop <interval> [focus].",
 				"error",
 			);
 			return;
@@ -369,9 +368,8 @@ export class LoopController {
 		const clampNote = start.clamped
 			? ` (requested ${formatDuration(start.requestedMs)}, clamped to the ${formatDuration(start.intervalMs)} minimum)`
 			: "";
-		const target = start.prompt ? "the loop prompt" : "the active goal";
 		ctx.ui.notify(
-			`Loop started: every ${formatDuration(start.intervalMs)}${clampNote}, first wake at ${formatClock(now + start.intervalMs)}, poking ${target}. Stop with /loop stop.`,
+			`Loop started: every ${formatDuration(start.intervalMs)}${clampNote}, first wake at ${formatClock(now + start.intervalMs)}, poking the active goal${start.prompt ? " with the loop focus" : ""}. Stop with /loop stop.`,
 			"info",
 		);
 	}

package/src/manager.ts

@@ -27,8 +27,8 @@ export async function showLoopManager(
 	for (;;) {
 		const loop = controller.state;
 		const options: string[] = ["Status"];
-		if (loop?.status === "active") options.push("Pause", "Edit prompt", "Edit interval", "Stop");
-		else if (loop?.status === "paused") options.push("Resume", "Edit prompt", "Edit interval", "Stop");
+		if (loop?.status === "active") options.push("Pause", "Edit focus", "Edit interval", "Stop");
+		else if (loop?.status === "paused") options.push("Resume", "Edit focus", "Edit interval", "Stop");
 		else options.push("Start a loop…");
 		options.push("Settings");
 		const choice = await ctx.ui.select(`Pi Loop${loop ? ` · ${loop.status}` : ""}`, options);
@@ -49,7 +49,7 @@ export async function showLoopManager(
 			case "Start a loop…":
 				await startFromMenu(controller, ctx);
 				break;
-			case "Edit prompt":
+			case "Edit focus":
 				await editPrompt(controller, ctx);
 				break;
 			case "Edit interval":
@@ -80,11 +80,14 @@ async function startFromMenu(
 		return;
 	}
 	const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
-	const promptText = await ctx.ui.input(
-		goal?.status === "active"
-			? "Loop prompt (optional: empty pokes the active goal)"
-			: "Loop prompt",
-	);
+	if (goal?.status !== "active") {
+		ctx.ui.notify(
+			"Loops require an active goal to operate. Start one first: /goal <objective>.",
+			"error",
+		);
+		return;
+	}
+	const promptText = await ctx.ui.input("Loop focus (optional, added to every goal poke)");
 	if (promptText === undefined) return;
 	const prompt = promptText.trim();
 	controller.startLoop(ctx, {
@@ -99,21 +102,16 @@ async function startFromMenu(
 async function editPrompt(controller: LoopController, ctx: ExtensionCommandContext): Promise<void> {
 	const loop = controller.state;
 	if (!loop || loop.status === "stopped") return;
-	const next = await ctx.ui.input("Loop prompt", loop.prompt ?? "");
+	const next = await ctx.ui.input("Loop focus (optional, added to every goal poke)", loop.prompt ?? "");
 	if (next === undefined) return;
 	const prompt = next.trim();
-	const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
-	if (!prompt && goal?.status !== "active") {
-		ctx.ui.notify("A prompt is required unless a pi-goal goal is active.", "error");
-		return;
-	}
 	if (prompt) controller.state = { ...loop, prompt };
 	else {
 		const { prompt: _dropped, ...rest } = loop;
 		controller.state = rest;
 	}
 	controller.persist();
-	ctx.ui.notify("Loop prompt updated.", "info");
+	ctx.ui.notify("Loop focus updated.", "info");
 }
 
 async function editInterval(
@@ -156,7 +154,6 @@ export async function showLoopSettings(
 			`Max loop duration: ${s.maxLoopDuration}`,
 			`Proactive compaction: ${s.compaction.enabled ? `On at ${Math.round(s.compaction.threshold * 100)}%` : "Off"}`,
 			`Post-compact continuation: ${s.compaction.postCompactContinuation ? "On" : "Off"}`,
-			`Inline /loop: ${s.inlineInvocation ? "On" : "Off"}`,
 		];
 		const choice = await ctx.ui.select("Pi Loop Settings", items);
 		if (choice === undefined) return;
@@ -205,8 +202,6 @@ export async function showLoopSettings(
 			}
 		} else if (index === 3) {
 			next.compaction.postCompactContinuation = !s.compaction.postCompactContinuation;
-		} else if (index === 4) {
-			next.inlineInvocation = !s.inlineInvocation;
 		} else {
 			continue;
 		}

package/src/messages.ts

@@ -15,15 +15,6 @@ function formatIteration(loop: LoopState): string {
 	return `${loop.iteration + 1}/${cap}`;
 }
 
-/** The recurring-prompt poke: the stored prompt with a short scheduled preamble. */
-export function buildPromptPoke(loop: LoopState, preambleOverride: string | null): string {
-	const preamble =
-		preambleOverride ??
-		`Scheduled loop iteration ${formatIteration(loop)} (every ${formatDuration(loop.intervalMs)}). Continue the recurring task below; if its work is exhausted, say so instead of inventing new work.`;
-	const prompt = loop.prompt ?? "";
-	return appendPokeMarker(`${preamble}\n\n${prompt}`.trim(), loop.id, loop.iteration + 1);
-}
-
 /** The goal-bound poke: restate the goal and wake goal_wait if applicable. */
 export function buildGoalPoke(
 	loop: LoopState,
@@ -57,7 +48,7 @@ export function buildCompactionInstructions(
 	const objective = goal
 		? `The session is working toward this goal: ${goal.text}`
 		: loop.prompt
-			? `The session is running a recurring task: ${loop.prompt}`
+			? `The session is running a recurring loop focused on: ${loop.prompt}`
 			: "The session is running a recurring loop.";
 	return [
 		`${objective}`,
@@ -86,7 +77,7 @@ export function buildPostCompactContinuation(
 		"Context was just compacted. Loop status, restored from outside the context window:",
 		`- loop iteration: ${loop.iteration}${loop.maxIterations === null ? "" : ` of ${loop.maxIterations}`}, waking every ${formatDuration(loop.intervalMs)}`,
 	];
-	if (loop.prompt) lines.push(`- recurring task: ${loop.prompt}`);
+	if (loop.prompt) lines.push(`- loop focus: ${loop.prompt}`);
 	if (goal) {
 		lines.push(`- active goal (status ${goal.status}): ${goal.text}`);
 		const thresholds: string[] = [];

package/src/settings.ts

@@ -28,10 +28,6 @@ export interface LoopSettings {
 	/** Wall-clock expiry for a loop, e.g. "7d" (research: bound forgotten loops). */
 	maxLoopDuration: string;
 	compaction: LoopCompactionSettings;
-	/** Override for the built-in poke preamble template. */
-	pokePreamble: string | null;
-	/** Recognize /loop mid-prompt. */
-	inlineInvocation: boolean;
 }
 
 export const DEFAULT_LOOP_SETTINGS: LoopSettings = {
@@ -43,8 +39,6 @@ export const DEFAULT_LOOP_SETTINGS: LoopSettings = {
 		postCompactContinuation: true,
 		instructions: null,
 	},
-	pokePreamble: null,
-	inlineInvocation: true,
 };
 
 export type LoopSettingsLoadResult =
@@ -95,26 +89,10 @@ export function normalizeLoopSettings(value: unknown): LoopSettings | undefined
 		return undefined;
 	}
 
-	const pokePreamble = readNullableString(
-		record,
-		"pokePreamble",
-		DEFAULT_LOOP_SETTINGS.pokePreamble,
-	);
-	if (pokePreamble === false) return undefined;
-
-	const inlineInvocation = readBoolean(
-		record,
-		"inlineInvocation",
-		DEFAULT_LOOP_SETTINGS.inlineInvocation,
-	);
-	if (typeof inlineInvocation !== "boolean") return undefined;
-
 	return {
 		maxIterations,
 		maxLoopDuration,
 		compaction: { enabled, threshold, postCompactContinuation, instructions },
-		pokePreamble,
-		inlineInvocation,
 	};
 }
 
@@ -201,8 +179,6 @@ export function saveLoopSettings(settings: LoopSettings, settingsPath = loopSett
 			maxIterations: normalized.maxIterations,
 			maxLoopDuration: normalized.maxLoopDuration,
 			compaction: { ...compaction, ...normalized.compaction },
-			pokePreamble: normalized.pokePreamble,
-			inlineInvocation: normalized.inlineInvocation,
 		},
 		null,
 		2,

package/src/state.ts

@@ -87,11 +87,17 @@ interface SessionEntryLike {
 }
 
 function lastCustomEntryData(entries: unknown[], customType: string): unknown {
-	for (let index = entries.length - 1; index >= 0; index -= 1) {
+	return lastCustomEntryDatas(entries, customType, 1)[0];
+}
+
+/** Newest-first data of the last `limit` custom entries of `customType`. */
+function lastCustomEntryDatas(entries: unknown[], customType: string, limit: number): unknown[] {
+	const datas: unknown[] = [];
+	for (let index = entries.length - 1; index >= 0 && datas.length < limit; index -= 1) {
 		const entry = entries[index] as SessionEntryLike | undefined;
-		if (entry?.type === "custom" && entry.customType === customType) return entry.data;
+		if (entry?.type === "custom" && entry.customType === customType) datas.push(entry.data);
 	}
-	return undefined;
+	return datas;
 }
 
 /** Restore the persisted loop state from a session branch, fail-open. */
@@ -120,11 +126,26 @@ export interface GoalSnapshot {
  * entry shape is not recognizably a goal. Only fields pi-loop consumes are
  * extracted; unknown statuses are preserved verbatim so the caller can treat
  * anything outside its known sets conservatively.
+ *
+ * Completion race: pi-goal persists the finished goal (status "complete") and
+ * then clears the entry (goal: null), so by the loop's next tick the last
+ * entry is the clear. A clear whose immediately preceding entry is a complete
+ * goal therefore reports that complete goal — the loop must stop with
+ * "goal completed", not pause as goal-missing. A clear over any other status
+ * (user /goal clear mid-flight) still reads as no goal.
  */
 export function readGoalSnapshot(entries: unknown[]): GoalSnapshot | undefined {
-	const data = ownRecord(lastCustomEntryData(entries, GOAL_STATE_ENTRY_TYPE));
-	if (!data) return undefined;
-	const goal = ownRecord(data.goal);
+	const datas = lastCustomEntryDatas(entries, GOAL_STATE_ENTRY_TYPE, 2);
+	const newest = ownRecord(datas[0]);
+	if (!newest) return undefined;
+	const goal = parseGoalSnapshot(newest.goal);
+	if (goal) return goal;
+	const cleared = parseGoalSnapshot(ownRecord(datas[1])?.goal);
+	return cleared?.status === "complete" ? cleared : undefined;
+}
+
+function parseGoalSnapshot(value: unknown): GoalSnapshot | undefined {
+	const goal = ownRecord(value);
 	if (!goal) return undefined;
 	const status = typeof goal.status === "string" ? goal.status : undefined;
 	const text = typeof goal.text === "string" ? goal.text.trim() : "";

package/src/inline-command.ts

@@ -1,89 +0,0 @@
-/**
- * Inline slash-command detection.
- *
- * Pi dispatches extension commands only when a message *starts* with the
- * command token; a command mentioned mid-prompt arrives as plain text. This
- * helper finds the first inline occurrence of a command token so the caller
- * can dispatch it and deliver the surrounding prose separately.
- *
- * This module is deliberately package-agnostic: every package-specific detail
- * is a parameter so the file can be duplicated byte-for-byte into sibling
- * packages (see DUPLICATED_SOURCES in scripts/validate.py once a second copy
- * exists). Edit one copy, then copy it over the other.
- */
-
-export interface InlineCommandSplit {
-	/** Text before the command token, trailing whitespace removed. */
-	prose: string;
-	/** Everything after the command token to end of message, trimmed. */
-	commandArgs: string;
-}
-
-/**
- * Find the first inline `/<commandName>` occurrence in `text`.
- *
- * Detection rules:
- * - The token must be preceded by start-of-line or whitespace and followed by
- *   whitespace plus a non-empty remainder. A bare trailing `/cmd` mention or a
- *   path-like `foo/cmd` never matches.
- * - A token at position 0 is ignored: that is Pi's native dispatch position.
- * - Occurrences inside backtick code (inline spans and fenced blocks) are
- *   ignored. Code regions are approximated by the CommonMark backtick-run
- *   rule: a run of N backticks opens a region closed by the next run of
- *   exactly N backticks.
- *
- * Returns undefined when no qualifying occurrence exists.
- */
-export function extractInlineCommand(
-	text: string,
-	commandName: string,
-): InlineCommandSplit | undefined {
-	const token = `/${commandName}`;
-	const code = codeRegions(text);
-	let searchFrom = 0;
-	while (searchFrom < text.length) {
-		const index = text.indexOf(token, searchFrom);
-		if (index === -1) return undefined;
-		searchFrom = index + 1;
-		if (index === 0) continue;
-		const before = text[index - 1];
-		if (before !== undefined && !/\s/.test(before)) continue;
-		const afterToken = text[index + token.length];
-		if (afterToken === undefined || !/\s/.test(afterToken)) continue;
-		if (insideRegion(code, index)) continue;
-		const commandArgs = text.slice(index + token.length).trim();
-		if (!commandArgs) continue;
-		return {
-			prose: text.slice(0, index).trimEnd(),
-			commandArgs,
-		};
-	}
-	return undefined;
-}
-
-type Region = readonly [start: number, end: number];
-
-function codeRegions(text: string): Region[] {
-	const regions: Region[] = [];
-	const runs: Array<{ index: number; length: number }> = [];
-	const runPattern = /`+/g;
-	for (let match = runPattern.exec(text); match; match = runPattern.exec(text)) {
-		runs.push({ index: match.index, length: match[0].length });
-	}
-	for (let open = 0; open < runs.length; open += 1) {
-		const opener = runs[open];
-		if (opener === undefined) continue;
-		for (let close = open + 1; close < runs.length; close += 1) {
-			const closer = runs[close];
-			if (closer === undefined || closer.length !== opener.length) continue;
-			regions.push([opener.index, closer.index + closer.length]);
-			open = close;
-			break;
-		}
-	}
-	return regions;
-}
-
-function insideRegion(regions: readonly Region[], index: number): boolean {
-	return regions.some(([start, end]) => index >= start && index < end);
-}

package/src/inline-invocation.ts

@@ -1,39 +0,0 @@
-/**
- * Inline /loop invocation: recognize `/loop <args>` mid-prompt through Pi's
- * input pipeline, dispatch it command-first, and deliver surrounding prose as
- * a follow-up. Same design as the pi-goal fork's inline /goal; the detection
- * helper (inline-command.ts) is duplicated byte-for-byte from
- * packages/pi-goal and registered in DUPLICATED_SOURCES.
- */
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { extractInlineCommand } from "./inline-command.js";
-import type { LoopController } from "./loop.js";
-
-export const INLINE_LOOP_COMMAND = "loop";
-
-export function registerInlineInvocation(pi: ExtensionAPI, controller: LoopController) {
-	pi.on("input", (event) => {
-		// Messages sent by extensions (including our own re-dispatch below) are
-		// never rewritten; leading "/loop" is consumed by Pi's command dispatch
-		// before this event fires, so recursion is impossible either way.
-		if (event.source === "extension") return;
-		if (!controller.settings.inlineInvocation) return;
-		// A message with attached images is passed through untouched: splitting
-		// it would detach the images from the text they belong to.
-		if (event.images && event.images.length > 0) return;
-		const split = extractInlineCommand(event.text, INLINE_LOOP_COMMAND);
-		if (!split) return;
-		// While the agent streams, Pi requires an explicit delivery mode; reuse
-		// the mode the original message would have used.
-		const deliverAs = event.streamingBehavior;
-		pi.sendUserMessage(
-			`/${INLINE_LOOP_COMMAND} ${split.commandArgs}`,
-			deliverAs ? { deliverAs } : undefined,
-		);
-		if (split.prose) {
-			pi.sendUserMessage(split.prose, { deliverAs: "followUp" });
-		}
-		return { action: "handled" as const };
-	});
-}