@hank-warren/pi-loop 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @hank-warren/pi-loop
 
+## 0.3.0
+
+### Minor Changes
+
+- 3e94f24: drop the post-compaction continuation and harden the loop engine
+
+  **Removed:** the `postCompactContinuation` setting, the message it sent, and the
+  `session_compact` handler behind it. pi-goal already re-prompts the session after
+  a compaction for an active goal, and a loop requires an active goal, so pi-loop's
+  follow-up only ever doubled the queued messages and the tokens they cost. pi-goal
+  owns that message; pi-loop owns the compaction trigger and its instructions.
+  Threshold compaction is unchanged. An existing `pi-loop.json` carrying the removed
+  key keeps working — it is ignored, never rejected — but the settings row and the
+  session surface are gone, hence the minor bump.
+
+  **Terminal decisions at settle.** A settled boundary with no pending wake now
+  evaluates expiry, completion, and pi-goal's safety states, so a loop stops the
+  moment its goal does instead of up to one interval later. Poke and skip decisions
+  are ignored there: only the timer pokes.
+
+  **Delivery and compaction no longer lose or wedge state.** A poke is sent before
+  it is accounted for, so a refused delivery re-arms on the same cadence instead of
+  burning an iteration on a message that never arrived. A synchronous throw from
+  `ctx.compact` resets the in-flight flag rather than leaving every later tick
+  skipping as compaction-in-flight, and a failed compaction releases a held wake
+  just as a successful one does.
+
+  **Reading pi-goal through its completion clear** is now a bounded backward scan
+  over consecutive clears, so a completion still stops the loop when other entries
+  land on top of it. `resumeLoop` refuses a loop whose goal is gone, matching
+  `startLoop`. Compaction instructions receive the goal only while it is active.
+
+## 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

package/README.md

@@ -1,6 +1,6 @@
 # pi-loop — interval wakeups for the Pi coding agent
 
-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.
+Inspired by Claude Code's `/loop`, adapted to Pi: wake the session on an interval to keep an active [pi-goal](../pi-goal) goal moving, and keep long loops coherent across context compaction. pi-loop reads the fork's `goal-state` entries, so pair it with [`@hank-warren/pi-goal`](../pi-goal) rather than [upstream](https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-goal).
 
 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.
 
@@ -25,9 +25,11 @@ 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**: 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).
+4. **Goal state**: a missing goal (cleared mid-loop) **pauses** the loop; completion **stops** it — including through the clear that follows it, since pi-goal persists the finished goal and *then* clears the entry, so the newest entry at completion is a clear and the loop reads back past 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**: 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.
+6. **Poke**: a goal wake message restating the goal (plus the loop focus, when set). Every poke carries a marker (`<!-- pi-loop-poke:<id>:<n> -->`) so a wakeup is identifiable as loop-injected rather than user-typed. The marker is **provenance only** — pi-loop coalesces wakes in its own state and never reads the marker back to drop a delivery.
+
+Expiry, completion, and pi-goal's safety states are also evaluated whenever the session settles, so a loop stops as soon as its goal does rather than at the next scheduled tick. Only the timer pokes.
 
 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.
 
@@ -36,7 +38,7 @@ The footer widget shows `loop 5m · 3/25 · next 14:32`; `/loop status` shows th
 Long loops die by context exhaustion, not by failing. pi-loop owns the compaction path:
 
 - **Proactive compact at a threshold** (default 70% of the context window, `--compact-at` / settings): at an idle boundary, pi-loop triggers `/compact` itself with loop-specific instructions — preserve the objective and acceptance criteria verbatim, decisions and dead-ends, files modified, commands and unresolved errors, the next 1-3 actions, and carry prior summaries forward cumulatively. Pending pokes are held until the compaction completes. Pi's reserve-token auto-compaction remains as the fault handler.
-- **Post-compaction continuation**: after every compaction (whoever triggered it), a follow-up message restates the loop prompt, iteration, and — when a goal exists — the goal text plus pi-goal's accounting (iteration, automatic turns, token budget) so work resumes coherently instead of drifting. It never contains a dispatchable command.
+- **No post-compaction continuation of its own**: pi-goal already re-prompts the session after a compaction for an active goal, and a loop requires an active goal, so a second follow-up from pi-loop would only duplicate it — doubling queued messages and tokens. pi-goal owns that message; pi-loop owns the compaction trigger and its instructions.
 - Loop state itself lives in custom session entries, which compaction never touches, and survives session restarts (the timer re-arms on resume; expired loops are dropped with a notice).
 
 ## Settings
@@ -50,7 +52,6 @@ Long loops die by context exhaustion, not by failing. pi-loop owns the compactio
   "compaction": {
     "enabled": true,
     "threshold": 0.7,
-    "postCompactContinuation": true,
     "instructions": null
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-loop",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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/index.ts

@@ -77,7 +77,4 @@ export default function loop(pi: ExtensionAPI, options: LoopControllerOptions =
 	pi.on("agent_settled", async (_event, ctx) => {
 		controller.onAgentSettled(ctx);
 	});
-	pi.on("session_compact", async (_event, ctx) => {
-		controller.onSessionCompact(ctx);
-	});
 }

package/src/loop.ts

@@ -10,10 +10,14 @@
  *   agent_settled. Missed ticks never stack.
  * - 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.
+ *   it, and a missing goal pauses the loop. Coupling is read-only session
+ *   entries.
+ * - Terminal decisions (expiry, completion, safety) also land at a settled
+ *   boundary, so the loop settles as soon as the goal does; only the timer
+ *   ever pokes.
  * - The loop's proactive compaction is the normal compaction path; Pi's
- *   reserve-token auto-compaction is the fault handler.
+ *   reserve-token auto-compaction is the fault handler. pi-goal owns the
+ *   post-compaction re-prompt: the loop sends none of its own.
  */
 
 import { randomUUID } from "node:crypto";
@@ -25,11 +29,7 @@ import type {
 import type { LoopStartArguments } from "./command.js";
 import { decideTick, type TickDecision, type TickEnvironment } from "./decide.js";
 import { formatClock, formatDuration, parseDuration } from "./interval.js";
-import {
-	buildCompactionInstructions,
-	buildGoalPoke,
-	buildPostCompactContinuation,
-} from "./messages.js";
+import { buildCompactionInstructions, buildGoalPoke } from "./messages.js";
 import {
 	DEFAULT_LOOP_SETTINGS,
 	type LoopSettings,
@@ -63,7 +63,6 @@ export class LoopController {
 	private timer: NodeJS.Timeout | undefined;
 	private nextWakeAt: number | undefined;
 	private wakePending = false;
-	private pendingLoopId: string | undefined;
 	private sessionCtx: ExtensionContext | undefined;
 
 	constructor(pi: ExtensionAPI, options: LoopControllerOptions = {}) {
@@ -77,7 +76,6 @@ export class LoopController {
 	onSessionStart(ctx: ExtensionContext): void {
 		this.clearTimer();
 		this.wakePending = false;
-		this.pendingLoopId = undefined;
 		this.compacting = false;
 		this.lastDecision = undefined;
 		this.sessionCtx = ctx;
@@ -102,7 +100,6 @@ export class LoopController {
 	onSessionShutdown(): void {
 		this.clearTimer();
 		this.wakePending = false;
-		this.pendingLoopId = undefined;
 		this.sessionCtx = undefined;
 	}
 
@@ -111,26 +108,30 @@ export class LoopController {
 		if (!this.state || this.state.status !== "active") return;
 		if (this.maybeStartCompaction(ctx)) return;
 		if (this.wakePending) {
-			if (this.pendingLoopId !== this.state.id) {
-				// Stale wake from a replaced loop: drop it (research: CC #57660).
-				this.wakePending = false;
-				this.pendingLoopId = undefined;
-				return;
-			}
 			this.wakePending = false;
-			this.pendingLoopId = undefined;
 			this.runTick(ctx);
+			return;
 		}
+		this.settleTerminalState(ctx);
 	}
 
-	onSessionCompact(ctx: ExtensionContext): void {
-		this.sessionCtx = ctx;
-		if (!this.state || this.state.status !== "active") return;
-		if (!this.settings.compaction.postCompactContinuation) return;
-		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
-		this.pi.sendUserMessage(buildPostCompactContinuation(this.state, goal), {
-			deliverAs: "followUp",
-		});
+	/**
+	 * A settled boundary with no wake pending still evaluates the terminal
+	 * decisions — expiry, a completed or missing goal, a pi-goal safety state —
+	 * so the loop settles the moment the goal does instead of up to one interval
+	 * later. Poke and skip decisions are deliberately ignored here: only the
+	 * timer pokes, and settling is not a schedule.
+	 */
+	private settleTerminalState(ctx: ExtensionContext): void {
+		const loop = this.state;
+		if (!loop) return;
+		const env = this.gatherEnvironment(ctx);
+		const decision = decideTick(loop, env);
+		if (decision.action !== "expire" && decision.action !== "stop" && decision.action !== "pause") {
+			return;
+		}
+		this.lastDecision = { ...decision, at: env.now };
+		this.applyTerminalDecision(loop, decision);
 	}
 
 	// --- tick machinery ---
@@ -174,9 +175,6 @@ export class LoopController {
 		switch (decision.action) {
 			case "none":
 				return;
-			case "expire":
-				this.transition("stopped", "loop expired (maxLoopDuration reached)");
-				return;
 			case "skip":
 				if (decision.reason === "plan-mode-active") {
 					// Plan mode may end without an agent_settled we can use, so
@@ -186,10 +184,26 @@ export class LoopController {
 					// Busy or compacting: coalesce into one pending wake that
 					// the next agent_settled (or compaction onComplete) delivers.
 					this.wakePending = true;
-					this.pendingLoopId = loop.id;
 				}
 				this.updateWidget();
 				return;
+			case "poke":
+				this.deliverPoke(env, decision.reason);
+				return;
+			default:
+				this.applyTerminalDecision(loop, decision);
+				return;
+		}
+	}
+
+	private applyTerminalDecision(
+		loop: LoopState,
+		decision: Extract<TickDecision, { action: "expire" | "stop" | "pause" }>,
+	): void {
+		switch (decision.action) {
+			case "expire":
+				this.transition("stopped", "loop expired (maxLoopDuration reached)");
+				return;
 			case "stop":
 				this.transition(
 					"stopped",
@@ -206,23 +220,31 @@ export class LoopController {
 						: `pi-goal reports the goal is ${decision.cause}; resolve it, then /loop resume`,
 				);
 				return;
-			case "poke":
-				this.deliverPoke(ctx, env, decision.reason);
-				return;
 		}
 	}
 
-	private deliverPoke(
-		ctx: ExtensionContext,
-		env: TickEnvironment,
-		reason: "goal-stalled" | "goal-waiting",
-	): void {
+	/**
+	 * Send first, then account. Pi can refuse the delivery (a busy or compacting
+	 * session), and an iteration persisted before the send would burn the
+	 * maxIterations cap on a poke that never arrived; on a throw the loop re-arms
+	 * on the same cadence and retries at the next wake.
+	 */
+	private deliverPoke(env: TickEnvironment, reason: "goal-stalled" | "goal-waiting"): void {
 		const loop = this.state;
 		if (!loop || !env.goal) return;
-		const message = buildGoalPoke(loop, env.goal, reason);
+		try {
+			this.pi.sendUserMessage(buildGoalPoke(loop, env.goal, reason));
+		} catch (error) {
+			this.sessionCtx?.ui.notify(
+				`pi-loop could not deliver a wake: ${formatError(error)}. Retrying at the next interval.`,
+				"warning",
+			);
+			this.scheduleTick(loop.intervalMs);
+			this.updateWidget();
+			return;
+		}
 		this.state = { ...loop, iteration: loop.iteration + 1, lastWakeAt: env.now };
 		this.persist();
-		this.pi.sendUserMessage(message);
 		this.scheduleTick(this.state.intervalMs);
 		this.updateWidget();
 	}
@@ -237,30 +259,45 @@ export class LoopController {
 		if (usage.tokens / usage.contextWindow < loop.compactAt) return false;
 		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
 		this.compacting = true;
-		ctx.compact({
-			customInstructions: buildCompactionInstructions(
-				loop,
-				goal,
-				this.settings.compaction.instructions,
-			),
-			onComplete: () => {
-				this.compacting = false;
-				const currentCtx = this.sessionCtx;
-				// A pending wake held during compaction delivers at the next
-				// settled boundary; nudge in case that boundary already passed.
-				if (currentCtx && this.wakePending) this.onAgentSettled(currentCtx);
-			},
-			onError: (error) => {
-				this.compacting = false;
-				this.sessionCtx?.ui.notify(
-					`pi-loop compaction failed: ${error instanceof Error ? error.message : String(error)}`,
-					"warning",
-				);
-			},
-		});
+		try {
+			ctx.compact({
+				customInstructions: buildCompactionInstructions(
+					loop,
+					// A completed or otherwise finished goal is no longer the
+					// objective the summary must preserve.
+					goal?.status === "active" ? goal : undefined,
+					this.settings.compaction.instructions,
+				),
+				onComplete: () => {
+					this.compacting = false;
+					this.nudgeHeldWake();
+				},
+				onError: (error) => {
+					this.compacting = false;
+					this.sessionCtx?.ui.notify(`pi-loop compaction failed: ${formatError(error)}`, "warning");
+					this.nudgeHeldWake();
+				},
+			});
+		} catch (error) {
+			// A synchronous refusal (a torn-down runner) must not leave the loop
+			// skipping every tick as compaction-in-flight for the rest of the
+			// session.
+			this.compacting = false;
+			ctx.ui.notify(`pi-loop compaction could not start: ${formatError(error)}`, "warning");
+			return false;
+		}
 		return true;
 	}
 
+	/**
+	 * A wake held during compaction delivers at the next settled boundary;
+	 * nudge in case that boundary already passed while compaction ran.
+	 */
+	private nudgeHeldWake(): void {
+		const ctx = this.sessionCtx;
+		if (ctx && this.wakePending) this.onAgentSettled(ctx);
+	}
+
 	// --- state transitions & presentation ---
 
 	private transition(status: "paused" | "stopped", why: string): void {
@@ -268,7 +305,6 @@ export class LoopController {
 		this.state = { ...this.state, status };
 		this.clearTimer();
 		this.wakePending = false;
-		this.pendingLoopId = undefined;
 		this.persist();
 		this.sessionCtx?.ui.notify(`Loop ${status}: ${why}.`, "info");
 		this.updateWidget();
@@ -361,7 +397,6 @@ export class LoopController {
 			expiresAt: now + expiryMs,
 		};
 		this.wakePending = false;
-		this.pendingLoopId = undefined;
 		this.persist();
 		this.scheduleTick(start.intervalMs);
 		this.updateWidget();
@@ -395,6 +430,15 @@ export class LoopController {
 			this.transition("stopped", "loop expired (maxLoopDuration reached)");
 			return;
 		}
+		// Same guard as startLoop: resuming into a finished or missing goal would
+		// only stop or pause again at the first tick.
+		if (readGoalSnapshot(ctx.sessionManager.getBranch())?.status !== "active") {
+			ctx.ui.notify(
+				"Loops require an active goal to operate. Start one first: /goal <objective>, then /loop resume.",
+				"error",
+			);
+			return;
+		}
 		this.state = { ...loop, status: "active" };
 		this.persist();
 		this.scheduleTick(loop.intervalMs);
@@ -422,3 +466,7 @@ export class LoopController {
 		this.transition("stopped", why);
 	}
 }
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/manager.ts

@@ -153,7 +153,6 @@ export async function showLoopSettings(
 			`Max iterations: ${s.maxIterations === null ? "Unlimited" : s.maxIterations}`,
 			`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"}`,
 		];
 		const choice = await ctx.ui.select("Pi Loop Settings", items);
 		if (choice === undefined) return;
@@ -200,8 +199,6 @@ export async function showLoopSettings(
 				next.compaction.enabled = true;
 				next.compaction.threshold = fraction;
 			}
-		} else if (index === 3) {
-			next.compaction.postCompactContinuation = !s.compaction.postCompactContinuation;
 		} else {
 			continue;
 		}

package/src/markers.ts

@@ -1,20 +1,20 @@
 /**
- * Provenance markers for loop-injected messages, following pi-goal's marker
+ * Provenance marker for loop-injected pokes, following pi-goal's marker
  * pattern: an HTML comment the model and transcript can see but that reads as
- * metadata, letting stale or duplicate deliveries be detected (research:
- * Claude Code's untagged auto-fires made wakeups indistinguishable from user
- * prompts, issue #57660).
+ * metadata, so a wakeup is identifiable as loop-injected rather than
+ * user-typed (research: Claude Code's untagged auto-fires made wakeups
+ * indistinguishable from user prompts, issue #57660).
+ *
+ * Provenance only. Nothing in pi-loop reads the marker back to drop stale or
+ * duplicate deliveries — the engine coalesces wakes in its own state, and the
+ * marker exists for the model, the transcript, and sibling extensions.
  */
 
 const POKE_MARKER_PREFIX = "pi-loop-poke:";
-const CONTINUATION_MARKER_PREFIX = "pi-loop-continuation:";
 
 const POKE_MARKER_PATTERN = new RegExp(
 	`<!--\\s*${escapeRegExpText(POKE_MARKER_PREFIX)}([^\\s:>]+):(\\d+)\\s*-->`,
 );
-const CONTINUATION_MARKER_PATTERN = new RegExp(
-	`<!--\\s*${escapeRegExpText(CONTINUATION_MARKER_PREFIX)}([^\\s>]+)\\s*-->`,
-);
 
 export function appendPokeMarker(prompt: string, loopId: string, iteration: number): string {
 	return `${prompt}\n\n<!-- ${POKE_MARKER_PREFIX}${loopId}:${iteration} -->`;
@@ -28,14 +28,6 @@ export function extractPokeMarker(
 	return { loopId: match[1], iteration: Number(match[2]) };
 }
 
-export function appendContinuationMarker(prompt: string, loopId: string): string {
-	return `${prompt}\n\n<!-- ${CONTINUATION_MARKER_PREFIX}${loopId} -->`;
-}
-
-export function extractContinuationMarker(prompt: string): string | undefined {
-	return CONTINUATION_MARKER_PATTERN.exec(prompt)?.[1];
-}
-
 function escapeRegExpText(value: string) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

package/src/messages.ts

@@ -1,13 +1,13 @@
 /**
- * Builders for every loop-injected message: pokes, the proactive compaction
- * instructions, and the post-compaction continuation. Pure string functions so
- * tests can pin their contracts — most importantly that the continuation never
- * embeds a runnable /loop command (research: Claude Code compaction summaries
- * re-executed scheduling commands, issue #50554).
+ * Builders for every loop-injected message: pokes and the proactive compaction
+ * instructions. Pure string functions so tests can pin their contracts — most
+ * importantly that no loop-injected message embeds a runnable /loop command
+ * (research: Claude Code compaction summaries re-executed scheduling commands,
+ * issue #50554).
  */
 
 import { formatDuration } from "./interval.js";
-import { appendContinuationMarker, appendPokeMarker } from "./markers.js";
+import { appendPokeMarker } from "./markers.js";
 import type { GoalSnapshot, LoopState } from "./state.js";
 
 function formatIteration(loop: LoopState): string {
@@ -41,6 +41,7 @@ export function buildGoalPoke(
  */
 export function buildCompactionInstructions(
 	loop: LoopState,
+	/** The goal only when it is still active; a finished goal is not the objective. */
 	goal: GoalSnapshot | undefined,
 	override: string | null,
 ): string {
@@ -62,38 +63,3 @@ export function buildCompactionInstructions(
 		"Discard raw tool output, file contents that live on disk, and duplicate exploration.",
 	].join("\n");
 }
-
-/**
- * The post-compaction continuation message. Restates the loop and goal state
- * (including pi-goal's thresholds) so work resumes coherently. Deliberately
- * references /loop only as inert prose-free metadata: no line of this message
- * is a dispatchable command.
- */
-export function buildPostCompactContinuation(
-	loop: LoopState,
-	goal: GoalSnapshot | undefined,
-): string {
-	const lines = [
-		"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(`- loop focus: ${loop.prompt}`);
-	if (goal) {
-		lines.push(`- active goal (status ${goal.status}): ${goal.text}`);
-		const thresholds: string[] = [];
-		if (goal.iteration !== undefined) thresholds.push(`goal iteration ${goal.iteration}`);
-		if (goal.automaticModelTurns !== undefined) {
-			thresholds.push(`${goal.automaticModelTurns} automatic turns used`);
-		}
-		if (goal.tokensUsed !== undefined) {
-			thresholds.push(
-				`${goal.tokensUsed} tokens used${goal.tokenBudget !== undefined ? ` of a ${goal.tokenBudget} budget` : ""}`,
-			);
-		}
-		if (thresholds.length > 0) lines.push(`- goal accounting: ${thresholds.join(", ")}`);
-	}
-	lines.push(
-		"Re-read any plan, progress, or state files the work relies on before continuing, then resume from the next concrete action.",
-	);
-	return appendContinuationMarker(lines.join("\n"), loop.id);
-}

package/src/settings.ts

@@ -17,7 +17,6 @@ export interface LoopCompactionSettings {
 	enabled: boolean;
 	/** Fraction of the context window that triggers a proactive compact. */
 	threshold: number;
-	postCompactContinuation: boolean;
 	/** Override for the built-in compaction instruction template. */
 	instructions: string | null;
 }
@@ -36,7 +35,6 @@ export const DEFAULT_LOOP_SETTINGS: LoopSettings = {
 	compaction: {
 		enabled: true,
 		threshold: 0.7,
-		postCompactContinuation: true,
 		instructions: null,
 	},
 };
@@ -63,12 +61,10 @@ export function normalizeLoopSettings(value: unknown): LoopSettings | undefined
 	const compactionValue = Object.hasOwn(record, "compaction") ? record.compaction : undefined;
 	if (compactionValue !== undefined && !ownRecord(compactionValue)) return undefined;
 	const compactionRecord = ownRecord(compactionValue) ?? {};
+	// `postCompactContinuation` was removed in favour of pi-goal owning the
+	// post-compaction re-prompt; a file still carrying it is preserved as an
+	// unknown field and ignored, never rejected.
 	const enabled = readBoolean(compactionRecord, "enabled", DEFAULT_LOOP_SETTINGS.compaction.enabled);
-	const postCompactContinuation = readBoolean(
-		compactionRecord,
-		"postCompactContinuation",
-		DEFAULT_LOOP_SETTINGS.compaction.postCompactContinuation,
-	);
 	const threshold = Object.hasOwn(compactionRecord, "threshold")
 		? compactionRecord.threshold
 		: DEFAULT_LOOP_SETTINGS.compaction.threshold;
@@ -79,7 +75,6 @@ export function normalizeLoopSettings(value: unknown): LoopSettings | undefined
 	);
 	if (
 		typeof enabled !== "boolean" ||
-		typeof postCompactContinuation !== "boolean" ||
 		instructions === false ||
 		typeof threshold !== "number" ||
 		!Number.isFinite(threshold) ||
@@ -92,7 +87,7 @@ export function normalizeLoopSettings(value: unknown): LoopSettings | undefined
 	return {
 		maxIterations,
 		maxLoopDuration,
-		compaction: { enabled, threshold, postCompactContinuation, instructions },
+		compaction: { enabled, threshold, instructions },
 	};
 }
 

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. */
@@ -104,6 +110,9 @@ export function restoreLoopState(entries: unknown[]): LoopState | undefined {
 
 export const GOAL_SAFETY_STATUSES = ["paused", "blocked", "usage_limited", "budget_limited"] as const;
 
+/** How many `goal-state` entries a clear may be scanned back through. */
+const GOAL_CLEAR_SCAN_LIMIT = 8;
+
 export interface GoalSnapshot {
 	status: string;
 	text: string;
@@ -120,11 +129,31 @@ 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. When the newest entry is a clear (or unreadable), scan
+ * back over the consecutive run of clears for the goal they cleared: a
+ * complete goal is reported, so the loop stops with "goal completed" instead
+ * of pausing as goal-missing. A clear over any other status (user /goal clear
+ * mid-flight) still reads as no goal. The scan is bounded so a long history of
+ * clears cannot make the read walk the branch.
  */
 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, GOAL_CLEAR_SCAN_LIMIT);
+	const newest = parseGoalSnapshot(ownRecord(datas[0])?.goal);
+	if (newest) return newest;
+	for (let index = 1; index < datas.length; index += 1) {
+		const cleared = parseGoalSnapshot(ownRecord(datas[index])?.goal);
+		// Another clear or an unreadable entry: keep scanning back.
+		if (!cleared) continue;
+		return cleared.status === "complete" ? cleared : undefined;
+	}
+	return 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() : "";