@hank-warren/pi-loop 0.2.1 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @hank-warren/pi-loop
 
+## 0.3.1
+
+### Patch Changes
+
+- 910f77a: stop invalidating the prompt cache, and stop re-sending the goal block every turn
+
+  Goal mode has to keep the objective and its rules in front of the model on every
+  turn. It did that twice: a full block appended to the system prompt with the
+  running budget counter embedded in it, and a near-complete copy re-sent as a
+  stored user message on every automatic continuation. pi-loop restated the
+  objective a third time in every poke.
+
+  Anthropic caches `tools → system → messages` as one prefix, so the moving budget
+  counter invalidated the system _and_ conversation cache on every turn of a
+  budgeted goal. Verified against the installed pi-ai Anthropic adapter
+  (`buildParams` places `cache_control` on the system block and the last user
+  message, and the `before_agent_start` append lands inside that cached block).
+
+  **Static per goal.** The system append is now byte-identical across turns of the
+  same goal and states only the budget _total_, so it changes only when the goal
+  does — start, edit, clear — which is one accepted cache rewrite per boundary.
+  Pinned as the cache-stability contract: same goal, different tokens used,
+  iteration, and elapsed time produce identical output.
+
+  **Dynamic per wake.** Kickoff, continuation, and poke messages shrink to
+  pointer-sized triggers carrying the continuation number, budget usage, and wake
+  reason, and point at the system prompt for the rest. Measured at ~4 chars/token:
+  kickoff 805 → 53, continuation 840 → 54, poke 86 → 64, system append 807 → 820
+  (+13 once per goal, the price of stability). Stored conversation tokens for a
+  25-iteration goal: 20,965 → 1,349. The resume, edit, and waiting-resume prompts
+  keep the full block — they are rare, user-initiated, and already a cache
+  boundary.
+
+  **Legibility.** Those messages now collapse to one-line transcript chips
+  (`⟳ goal continuation #4 · budget 12k/100k`, `⏰ loop wake 4/25 · stalled`) via
+  markdown transformers, which are display-only by Pi's contract: the stored
+  message and the model's context are untouched. New goal and loop widgets above
+  the editor carry the counters that left the system prompt — objective, budget
+  fraction, iteration, automatic turns for the goal; interval, iteration/cap, next
+  wake, and focus for the loop.
+
+  **Cross-extension assumption.** pi-loop's poke no longer restates the objective,
+  because loops require an active goal and pokes are ordinary user messages that
+  go through `before_agent_start`, so every poke turn already carries pi-goal's
+  system append. Documented in both READMEs; if pokes are ever delivered by a path
+  that bypasses that hook, the poke must carry the objective again.
+
+## 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

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,18 +25,24 @@ 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 — the wake header, why it fired (stalled or the external wake for a waiting goal), and 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.
 
-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.
+**A poke does not restate the objective**, and this is a deliberate cross-extension assumption. Loops require an active goal, and pi-goal appends the objective, `goal_id`, and goal-mode rules to the system prompt of *every* goal turn — including poke turns, because pokes are delivered as ordinary user messages that go through `before_agent_start`. Restating the goal in the poke would store a duplicate copy in the conversation on every wake for no benefit. The token-lean contract is pinned in `test/messages.test.ts`; the matching cache-stability contract lives in [pi-goal](https://github.com/hank-warren/pi-extensions/tree/main/packages/pi-goal#fork-feature-cache-safe-token-lean-injections). If pokes are ever delivered by a path that bypasses `before_agent_start` (for example `pi.sendMessage({triggerTurn})`, which calls the agent directly), this assumption breaks and the poke must carry the objective again.
+
+In the transcript, a poke renders as a one-line chip (`⏰ loop wake 4/25 · stalled`) via a markdown transformer. That hook is display-only by Pi's contract — the stored message and the model's context are untouched.
+
+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 status shows `loop 5m · 3/25 · next 14:32`, and a widget above the editor shows the same state with the loop focus beneath it; `/loop status` shows the full card including the last tick's decision and reason.
 
 ## Loop-aware compaction
 
 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 +56,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.1",
+  "version": "0.3.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": [
@@ -38,6 +38,7 @@
     "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   }
 }

package/src/index.ts

@@ -11,9 +11,13 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { completeLoopArguments, parseLoopCommand } from "./command.js";
 import { LoopController, type LoopControllerOptions } from "./loop.js";
 import { showLoopManager, showLoopSettings } from "./manager.js";
+import { registerLoopMessageRendering } from "./render.js";
 
 export default function loop(pi: ExtensionAPI, options: LoopControllerOptions = {}) {
 	const controller = new LoopController(pi, options);
+	// Collapse loop pokes into one-line transcript chips (display-only; the
+	// stored message and model context are untouched).
+	registerLoopMessageRendering(pi);
 
 	pi.registerCommand("loop", {
 		description:
@@ -77,7 +81,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,
@@ -43,6 +43,7 @@ import {
 	readPlanModeEnabled,
 	restoreLoopState,
 } from "./state.js";
+import { clearLoopWidget, updateLoopWidget } from "./widget.js";
 
 export const LOOP_STATUS_KEY = "loop";
 
@@ -63,7 +64,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 +77,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 +101,7 @@ export class LoopController {
 	onSessionShutdown(): void {
 		this.clearTimer();
 		this.wakePending = false;
-		this.pendingLoopId = undefined;
+		if (this.sessionCtx) clearLoopWidget(this.sessionCtx.ui);
 		this.sessionCtx = undefined;
 	}
 
@@ -111,26 +110,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 +177,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 +186,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 +222,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, 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 +261,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 +307,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();
@@ -283,6 +321,10 @@ export class LoopController {
 		const ui = this.sessionCtx?.ui;
 		if (!ui) return;
 		const loop = this.state;
+		updateLoopWidget(
+			ui,
+			loop ? { loop, wakePending: this.wakePending, nextWakeAt: this.nextWakeAt } : undefined,
+		);
 		if (!loop || loop.status === "stopped") {
 			ui.setStatus(LOOP_STATUS_KEY, undefined);
 			return;
@@ -361,7 +403,6 @@ export class LoopController {
 			expiresAt: now + expiryMs,
 		};
 		this.wakePending = false;
-		this.pendingLoopId = undefined;
 		this.persist();
 		this.scheduleTick(start.intervalMs);
 		this.updateWidget();
@@ -395,6 +436,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 +472,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 {
@@ -15,22 +15,23 @@ function formatIteration(loop: LoopState): string {
 	return `${loop.iteration + 1}/${cap}`;
 }
 
-/** The goal-bound poke: restate the goal and wake goal_wait if applicable. */
-export function buildGoalPoke(
-	loop: LoopState,
-	goal: GoalSnapshot,
-	reason: "goal-stalled" | "goal-waiting",
-): string {
+/**
+ * The goal-bound poke: wake the session and point at the goal without
+ * restating it. Loops require an active pi-goal goal, so every poke turn
+ * already carries the objective, goal_id, and goal-mode rules through
+ * pi-goal's system prompt append; restating them here would store duplicate
+ * tokens in the conversation on every wake (see README: cross-extension
+ * assumption). Only the dynamic per-wake state (iteration, reason) belongs in
+ * this tail message.
+ */
+export function buildGoalPoke(loop: LoopState, reason: "goal-stalled" | "goal-waiting"): string {
 	const lines = [
 		`Scheduled loop wakeup ${formatIteration(loop)} (every ${formatDuration(loop.intervalMs)}).`,
 		reason === "goal-waiting"
 			? "This is the external wake for your waiting goal. Re-check whatever the goal was waiting on and continue."
-			: "The session went idle but the active goal is not complete. Continue working toward it.",
-		"",
-		`Active goal: ${goal.text}`,
+			: "The session went idle but the active goal is not complete. Continue working toward it — the objective and goal-mode rules are in the system prompt.",
 	];
 	if (loop.prompt) lines.push("", `Loop focus: ${loop.prompt}`);
-	lines.push("", "Use the goal tools (goal_complete, goal_blocked, goal_wait) when their conditions are met.");
 	return appendPokeMarker(lines.join("\n"), loop.id, loop.iteration + 1);
 }
 
@@ -41,6 +42,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 +64,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/render.ts

@@ -0,0 +1,33 @@
+/**
+ * Display-only compaction of loop-injected pokes.
+ *
+ * Pokes are already token-lean, but they still render as multi-line prompt
+ * text plus a provenance marker comment. This transformer collapses each into
+ * a one-line themed chip in the transcript. Display-only by Pi contract: the
+ * stored message and model context are untouched, and pokes keep being
+ * delivered through sendUserMessage so pi-goal's before_agent_start hook
+ * (which appends the goal system prompt) still fires for every poke turn.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { extractPokeMarker } from "./markers.js";
+
+const POKE_HEAD_PATTERN = /^Scheduled loop wakeup (\S+) \(every ([^)]+)\)\./u;
+const POKE_FOCUS_PATTERN = /^Loop focus: (.+)$/mu;
+
+export function registerLoopMessageRendering(pi: ExtensionAPI) {
+	pi.registerMarkdownTransformer((markdown, { messageType }) => {
+		if (messageType !== "user") return markdown;
+		return compactPokeMessage(markdown) ?? markdown;
+	});
+}
+
+/** Exported for tests: the poke chip, or undefined when not ours. */
+export function compactPokeMessage(markdown: string) {
+	if (!extractPokeMarker(markdown)) return undefined;
+	const head = POKE_HEAD_PATTERN.exec(markdown);
+	if (!head) return undefined;
+	const reason = markdown.includes("external wake") ? "waiting" : "stalled";
+	const focus = POKE_FOCUS_PATTERN.exec(markdown)?.[1];
+	return `*⏰ loop wake ${head[1]} · ${reason}${focus ? ` · ${focus}` : ""}*`;
+}

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

@@ -110,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;
@@ -129,19 +132,24 @@ export interface GoalSnapshot {
  *
  * 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.
+ * 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 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;
+	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 {

package/src/widget.ts

@@ -0,0 +1,81 @@
+/**
+ * The loop widget: a compact themed line above the editor mirroring the
+ * footer status (interval · iteration/cap · next wake), with the loop focus
+ * dimmed below it when set.
+ *
+ * Presentation only: every entry point tolerates a host without setWidget
+ * (test fixtures, print mode) and swallows render-side failures, because a
+ * widget must never interrupt loop state transitions.
+ */
+
+import { Text } from "@earendil-works/pi-tui";
+import { formatClock, formatDuration } from "./interval.js";
+import type { LoopState } from "./state.js";
+
+export const LOOP_WIDGET_KEY = "loop";
+
+interface WidgetTheme {
+	bold?: (text: string) => string;
+	fg?: (color: string, text: string) => string;
+}
+
+type WidgetHost = { setWidget?: unknown };
+
+export interface LoopWidgetView {
+	loop: LoopState;
+	/** A wake is held for the next idle boundary. */
+	wakePending: boolean;
+	/** Epoch ms of the next scheduled tick, when armed. */
+	nextWakeAt: number | undefined;
+}
+
+export function updateLoopWidget(ui: WidgetHost, view: LoopWidgetView | undefined) {
+	const setWidget = resolveSetWidget(ui);
+	if (!setWidget) return;
+	try {
+		if (!view || view.loop.status === "stopped") {
+			setWidget(LOOP_WIDGET_KEY, undefined);
+			return;
+		}
+		setWidget(LOOP_WIDGET_KEY, (_tui: unknown, theme: WidgetTheme) => {
+			const bold = theme.bold ?? identity;
+			const dim = (text: string) => theme.fg?.("dim", text) ?? text;
+			const focus = view.loop.prompt ? `\n${dim(`  focus: ${view.loop.prompt}`)}` : "";
+			return new Text(`${bold(loopWidgetLine(view))}${focus}`);
+		});
+	} catch {
+		// Presentation only; a widget failure must never break a loop transition.
+	}
+}
+
+export function clearLoopWidget(ui: WidgetHost) {
+	const setWidget = resolveSetWidget(ui);
+	if (!setWidget) return;
+	try {
+		setWidget(LOOP_WIDGET_KEY, undefined);
+	} catch {
+		// Presentation only.
+	}
+}
+
+export function loopWidgetLine(view: LoopWidgetView) {
+	const loop = view.loop;
+	if (loop.status === "paused") return "⏸ loop paused";
+	const cap = loop.maxIterations === null ? "∞" : `${loop.maxIterations}`;
+	const next = view.wakePending
+		? "next on idle"
+		: view.nextWakeAt !== undefined
+			? `next ${formatClock(view.nextWakeAt)}`
+			: "next unscheduled";
+	return `⟳ loop every ${formatDuration(loop.intervalMs)} · ${loop.iteration}/${cap} · ${next}`;
+}
+
+function identity(text: string) {
+	return text;
+}
+
+function resolveSetWidget(ui: WidgetHost) {
+	return typeof ui.setWidget === "function"
+		? (ui.setWidget as (key: string, content: unknown) => void).bind(ui)
+		: undefined;
+}