@matthewfl/pi-jtodo 0.0.1 → 0.0.3

package/README.md

@@ -41,6 +41,8 @@ Deliberately **not** ported from jcode: the `/overnight` mission mode (presumes
 - **Write-time gate**: a write that closes a group (or the implicit ungrouped list) without an honest `end_to_end_ownership` claim is **rejected whole** — stored state is returned unchanged with an actionable message naming the failing groups. A first plan write with severely low intent gets an immediate in-band continuation.
 - **Turn-end gates** (when the agent settles): incomplete todos → auto-poke ("You have N incomplete todos. Continue working, or update the todo tool."). Fully settled → the deferred quality digest (intent/feedback-loop weak points), then the completion-confidence and confidence-spike gates — each naming the flagged `#id`s — with an attempt budget, an unchanged-signature early stop, and a done notice when validation passes.
 - **Follow-ups are attributed**: pokes, digests, and gate challenges travel as custom messages (LLM-visible as user-role text, transcript-visible as `pi-jtodo/followup`), so reload/resume never re-renders them as user prompts.
+- **The poke waits `pokeDelayMs` before firing** (default 20s, pi-simple-goal's restart-countdown pattern): when the agent stops with open todos the settle schedules the poke instead of sending it, and the widget shows `· poke in Ns` counting down. **If the user starts typing during the window, the poke is canceled and poking pauses** until the next agent run, so a user who is about to take over is never fought by the machine. The completion/spike gates, the deferred digest, the watchdog re-fire, and manual `/todos poke on|trigger` stay immediate — gates respond to the agent's own claims, manual pokes are explicit.
+- **Escape pauses, it does not silence** (pi-simple-goal pattern): a raw `\x1b` keypress within 5s of an aborted run marks it as the user's stop — the settle is quiet and the poke pauses until the user re-engages; the next agent run lifts the pause and re-arms. Aborts with no recent Escape behind them are machinery (compaction, `ctx.abort()`, transport, provider stacks mislabeling the interrupt as an error): their settle is quiet but the cycle stays armed and the starvation watchdog covers a lost continuation. The only sticky off is `/todos poke off`.
 
 ## Display
 
@@ -55,6 +57,7 @@ Deliberately **not** ported from jcode: the `/overnight` mission mode (presumes
 {
 	"enabled": true,
 	"autoPoke": true,
+	"pokeDelayMs": 20000,
 	"completionGateMaxAttempts": 5,
 	"maxGateObservations": 256,
 	"maxConsecutivePokesWithoutProgress": 0,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@matthewfl/pi-jtodo",
-	"version": "0.0.1",
+	"version": "0.0.3",
 	"description": "Quality-gated todo tool for Pi: confidence scores with tool-owned histories, plan and per-goal assessments, write-time ownership rejection, turn-end completion/spike gates, deferred quality digests, auto-poke continuation, starvation watchdog, and a live todo strip.",
 	"type": "module",
 	"scripts": {

package/src/config.ts

@@ -2,6 +2,7 @@
  * Optional per-user configuration: ~/.pi/agent/state/pi-jtodo/config.json
  * Missing or unreadable config falls back to defaults. Gate thresholds are
  * calibration constants (see constants.ts) and deliberately NOT configurable.
+ * PI_JTODO_STATE_DIR overrides the state directory (embedding/tests).
  */
 
 import * as fs from "node:fs";
@@ -13,6 +14,13 @@ export interface TodoConfig {
 	enabled: boolean;
 	/** Arm the auto-poke cycle when each session starts (TUI/RPC only). */
 	autoPoke: boolean;
+	/**
+	 * Delay before the settle poke fires when the agent stops with open
+	 * todos (pi-simple-goal restartDelayMs pattern). While the poke waits,
+	 * any terminal input (the user starts typing) cancels it and pauses
+	 * poking until the next agent run. 0 = immediate (pure jcode).
+	 */
+	pokeDelayMs: number;
 	/** Turn-end re-validation budget before the gate stalls and disarms. */
 	completionGateMaxAttempts: number;
 	/** Cap on the turn-scoped observation log; oldest dropped first. */
@@ -38,6 +46,7 @@ export interface TodoConfig {
 export const DEFAULT_CONFIG: TodoConfig = {
 	enabled: true,
 	autoPoke: true,
+	pokeDelayMs: 20_000,
 	completionGateMaxAttempts: TODO_COMPLETION_GATE_MAX_ATTEMPTS,
 	maxGateObservations: MAX_GATE_OBSERVATIONS,
 	maxConsecutivePokesWithoutProgress: 0,
@@ -52,14 +61,10 @@ export const DEFAULT_CONFIG: TodoConfig = {
 
 export function loadConfig(): TodoConfig {
 	try {
-		const p = path.join(
-			os.homedir(),
-			".pi",
-			"agent",
-			"state",
-			"pi-jtodo",
-			"config.json",
-		);
+		const stateDir =
+			process.env.PI_JTODO_STATE_DIR ??
+			path.join(os.homedir(), ".pi", "agent", "state", "pi-jtodo");
+		const p = path.join(stateDir, "config.json");
 		const parsed = JSON.parse(fs.readFileSync(p, "utf8"));
 		if (typeof parsed === "object" && parsed !== null) {
 			return { ...DEFAULT_CONFIG, ...parsed };

package/src/constants.ts

@@ -26,6 +26,12 @@ export const TODO_COMPLETION_GATE_MAX_ATTEMPTS = 5;
 /** Upper bound on retained turn-scoped observations; oldest dropped first. */
 export const MAX_GATE_OBSERVATIONS = 256;
 
+// Window in which a raw Escape keypress is considered the cause of an aborted
+// run (user stopped it on purpose). Outside this window an abort is machinery
+// (compaction, ctx.abort(), transport) and the poke cycle stays armed.
+// Same value and rationale as pi-simple-goal's ESCAPE_ABORT_WINDOW_MS.
+export const ESCAPE_ABORT_WINDOW_MS = 5_000;
+
 /** customType for all synthetic gate follow-ups (custom session messages). */
 export const FOLLOWUP_CUSTOM_TYPE = "pi-jtodo/followup";
 

package/src/index.ts

@@ -32,6 +32,7 @@ import type {
 import { Text } from "@earendil-works/pi-tui";
 import {
 	CYCLE_CUSTOM_TYPE,
+	ESCAPE_ABORT_WINDOW_MS,
 	FOLLOWUP_CUSTOM_TYPE,
 	NOTICE_COMPLETION_CHALLENGED,
 	NOTICE_DIGEST_QUEUED,
@@ -89,6 +90,7 @@ import { normalizeTodoInput } from "./normalize.js";
 import { TodoParams, type TodoParamsInput } from "./schema.js";
 import { TodoListComponent } from "./viewer.js";
 import { TODO_WIDGET_ID, makeTodoWidget } from "./widget.js";
+import { createPokeScheduler } from "./poke-scheduler.js";
 import { createWatchdog } from "./watchdog.js";
 
 // ============================================================================
@@ -150,6 +152,31 @@ export default function (pi: ExtensionAPI) {
 	// pi-specific: once the user has explicitly silenced the poke (poke off,
 	// or Esc-interrupting a run), new open work must NOT re-arm it.
 	let pokeExplicitlyOff = false;
+	// Whether the most recent completed agent run was Esc-aborted, recorded
+	// from the agent_end event itself (the run's own messages). Entry-scanning
+	// heuristics misclassify aborts when a queued user message (compaction
+	// resume, steer) lands after the aborted assistant message; an
+	// Esc-aborted run must never restart the agent via a poke.
+	let lastRunAborted = false;
+	// Goal-plugin-style Escape correlation (pi-simple-goal): a raw Escape
+	// keypress observed via terminal input marks the NEXT aborted run as the
+	// user's stop. Aborts with no recent Escape behind them are machinery
+	// (compaction, ctx.abort(), transport) and keep the poke cycle armed.
+	let lastEscapeAt = 0;
+	// Set when an Escape-classified abort pauses the poke. NOT sticky: the
+	// next agent run (user re-engaged, or machinery resumed) lifts it and
+	// re-arms, per the user's "stop the poke for the next while" rule.
+	let escPokePaused = false;
+	let unsubscribeTerminalInput: (() => void) | undefined;
+	// pi-simple-goal restartDelayMs pattern (see sendSettlePoke): the settle
+	// poke can wait pokeDelayMs before firing; any terminal input during the
+	// window cancels it and pauses poking until the next agent run.
+	// 0 = immediate (pure jcode).
+	const pokeScheduler = createPokeScheduler(config.pokeDelayMs);
+	let pokeTickTimer: NodeJS.Timeout | undefined;
+	// Whether the raw-input listener is subscribed (TUI only). A delayed
+	// poke is only safe when typing can cancel it; otherwise fire immediately.
+	let terminalInputActive = false;
 	// Whether poking is allowed at all. session_start (when emitted — the
 	// SDK harness and some embedders never emit it) re-derives this from
 	// its ctx.hasUI; elsewhere starts optimistic, matching the module-level
@@ -164,6 +191,7 @@ export default function (pi: ExtensionAPI) {
 	let idleNudgeSent = false;
 
 	function disarm() {
+		cancelPendingPoke();
 		autoPokeArmed = false;
 		lastPokeTargets = undefined;
 		cycle = freshCycleFlags();
@@ -237,6 +265,8 @@ export default function (pi: ExtensionAPI) {
 						() => state,
 						() => ({
 							armed: autoPokeArmed,
+							escPaused: escPokePaused,
+							pokePendingAt: pokeScheduler.deadlineAt(),
 							gateAttempts: cycle.gateAttempts,
 							gateMaxAttempts: config.completionGateMaxAttempts,
 							pokeTargets: lastPokeTargets,
@@ -250,6 +280,55 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	/** Cancel a pending delayed poke (if any) and stop its countdown tick. */
+	function cancelPendingPoke(): void {
+		pokeScheduler.cancel();
+		if (pokeTickTimer !== undefined) {
+			clearInterval(pokeTickTimer);
+			pokeTickTimer = undefined;
+		}
+	}
+
+	/**
+	 * Send the settle poke, honoring pokeDelayMs (pi-simple-goal's restart
+	 * countdown pattern): schedule it so the user can take over during the
+	 * window — any typing cancels the poke and pauses the cycle — or fire
+	 * immediately when no delay is configured, the raw-input listener is not
+	 * subscribed (nothing could cancel it), or this is a manual trigger.
+	 */
+	function sendSettlePoke(ctx: ExtensionContext, immediate: boolean): void {
+		const fire = (): void => {
+			cancelPendingPoke();
+			const todos = incompleteTodos();
+			if (!config.enabled || !autoPokeArmed || escPokePaused || todos.length === 0) {
+				return; // state changed while the poke waited
+			}
+			if (watchdogCtx && !watchdogCtx.isIdle()) {
+				return; // something already restarted the agent
+			}
+			watchdog.notifyActivity();
+			lastPokeTargets = new Set(todos.map((t) => t.id));
+			notify(
+				ctx,
+				`👉 ${todos.length} incomplete todo${todos.length === 1 ? "" : "s"}. We poked it for you. ${NOTICE_POKE_OFF_HINT}`,
+			);
+			void sendGateFollowUp(buildAutoPokeMessage(todos.length));
+			refreshWidget(ctx);
+		};
+		if (!immediate && config.pokeDelayMs > 0 && terminalInputActive) {
+			pokeScheduler.schedule(fire);
+			if (pokeTickTimer === undefined) {
+				pokeTickTimer = setInterval(() => {
+					if (watchdogCtx) refreshWidget(watchdogCtx);
+				}, 1000);
+				if (typeof pokeTickTimer.unref === "function") pokeTickTimer.unref();
+			}
+			refreshWidget(ctx); // surface "poke in Ns" immediately
+		} else {
+			fire();
+		}
+	}
+
 	// ------------------------------------------------------------------------
 	// Branch-aware state (replaces jcode's per-session JSON files)
 	// ------------------------------------------------------------------------
@@ -432,16 +511,16 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	/** True when the last assistant message on this branch was aborted (Esc). */
-	function wasLastRunAborted(ctx: ExtensionContext): boolean {
-		const entries = ctx.sessionManager.getEntries();
-		for (let i = entries.length - 1; i >= 0; i--) {
-			const entry = entries[i];
-			if (entry.type !== "message") continue;
-			const message = (entry as { message?: { role?: string; stopReason?: string } }).message;
-			if (message?.role === "assistant") return message.stopReason === "aborted";
-			if (message?.role === "user") return false;
-		}
-		return false;
+	function wasLastRunAborted(): boolean {
+		return lastRunAborted;
+	}
+
+	// Some provider stacks (pi-robust-provider observed live: errorMessage
+	// "This operation was aborted") finalize an Esc-aborted request as a
+	// generic error whose text still names the abort. Those are user
+	// interrupts, not provider failures, and must never restart the agent.
+	function looksInterrupted(stopReason: string | undefined, errorMessage: string | undefined): boolean {
+		return stopReason === "error" && typeof errorMessage === "string" && /abort/i.test(errorMessage);
 	}
 
 	function countAssistantTurnsSinceUser(ctx: ExtensionContext): number {
@@ -463,7 +542,7 @@ export default function (pi: ExtensionAPI) {
 	 * completion-confidence and spike gates (budgeted), then disarm with a
 	 * done notice.
 	 */
-	async function runTurnEndCheck(ctx: ExtensionContext): Promise<void> {
+	async function runTurnEndCheck(ctx: ExtensionContext, immediatePoke = false): Promise<void> {
 		const todos = state.todos;
 		if (todos.length === 0) {
 			// jcode: a settle with no todos at all silently disarms the poke.
@@ -474,6 +553,12 @@ export default function (pi: ExtensionAPI) {
 
 		const incomplete = incompleteTodos();
 		if (incomplete.length > 0) {
+			if (escPokePaused) {
+				// The user paused poking (Escape, or typing during the poke
+				// window): quiet until the next agent run lifts the pause.
+				refreshWidget(ctx);
+				return;
+			}
 			cycle.gateAttempts = 0;
 			if (config.maxConsecutivePokesWithoutProgress > 0) {
 				const signature = JSON.stringify(
@@ -491,12 +576,10 @@ export default function (pi: ExtensionAPI) {
 					return;
 				}
 			}
-			notify(
-				ctx,
-				`👉 ${incomplete.length} incomplete todo${incomplete.length === 1 ? "" : "s"}. We poked it for you. ${NOTICE_POKE_OFF_HINT}`,
-			);
-			lastPokeTargets = new Set(incomplete.map((t) => t.id));
-			await sendGateFollowUp(buildAutoPokeMessage(incomplete.length));
+			// The poke itself may be delayed (pokeDelayMs): sendSettlePoke
+			// schedules it so the user can take over by typing, or fires
+			// immediately for manual /todos poke triggers.
+			sendSettlePoke(ctx, immediatePoke);
 			return;
 		}
 
@@ -584,7 +667,9 @@ export default function (pi: ExtensionAPI) {
 		isArmed: () => autoPokeArmed,
 		isIdle: () => watchdogCtx?.isIdle() ?? false,
 		incompleteCount: () => incompleteTodos().length,
-		wasAborted: () => (watchdogCtx ? wasLastRunAborted(watchdogCtx) : false),
+		wasAborted: () => lastRunAborted,
+		// The watchdog must not inject through an Esc- or typing-pause either.
+		isPaused: () => escPokePaused,
 		idleMs: config.watchdogIdleMs,
 		maxRePokes: config.watchdogMaxRePokes,
 		onFire: () => {
@@ -761,6 +846,7 @@ export default function (pi: ExtensionAPI) {
 		if (action === "on" || action === "trigger") {
 			autoPokeArmed = true;
 			pokeExplicitlyOff = false;
+			escPokePaused = false;
 			cycle = freshCycleFlags();
 			settledWithoutProgress = 0;
 			lastChallengedSignature = undefined;
@@ -779,7 +865,7 @@ export default function (pi: ExtensionAPI) {
 				ctx.ui.notify("Poke queued. We'll re-check for unfinished todos after this turn.", "info");
 				return;
 			}
-			await runTurnEndCheck(ctx);
+			await runTurnEndCheck(ctx, true);
 			refreshWidget(ctx);
 			return;
 		}
@@ -793,19 +879,100 @@ export default function (pi: ExtensionAPI) {
 	// Events
 	// ------------------------------------------------------------------------
 
+	pi.on("agent_end", (event) => {
+		// Record the most recent run's abort status straight from the run's
+		// own messages; agent_settled reads this (it fires after agent_end).
+		const messages = event.messages as Array<{ role?: string; stopReason?: string; errorMessage?: string }>;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const m = messages[i];
+			if (m.role === "assistant") {
+				lastRunAborted = m.stopReason === "aborted" || looksInterrupted(m.stopReason, m.errorMessage);
+				break;
+			}
+		}
+		watchdog.notifyActivity();
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		// A pending delayed poke is moot once a new run starts: this run's
+		// settle will schedule a fresh one if todos remain open.
+		cancelPendingPoke();
+		// A new run means the user (or machinery) re-engaged: an Esc pause
+		// lifts outside the abort-correlation window where the just-triggered
+		// teardown is still settling (pi-simple-goal's maybeResumeOnActivity).
+		if (escPokePaused && Date.now() - lastEscapeAt > ESCAPE_ABORT_WINDOW_MS) {
+			escPokePaused = false;
+			if (config.enabled && config.autoPoke && !pokeExplicitlyOff && pokeUiAllowed) {
+				autoPokeArmed = true;
+				cycle = freshCycleFlags();
+			}
+			refreshWidget(ctx);
+		}
+		watchdog.notifyActivity();
+	});
+
+	pi.on("session_before_compact", () => {
+		watchdog.notifyActivity(); // compaction can run long; never starve the watchdog
+	});
+	pi.on("session_compact", () => {
+		watchdog.notifyActivity();
+	});
+	pi.on("session_compact_failed", () => {
+		watchdog.notifyActivity();
+	});
+
 	pi.on("session_start", (_event, ctx) => {
 		watchdogCtx = ctx;
 		watchdog.notifyActivity();
+		cancelPendingPoke(); // a stale delayed poke never crosses sessions
 		idleNudgeSent = false;
 		pendingObservations.length = 0;
 		cycle = freshCycleFlags();
+		lastRunAborted = false;
 		settledWithoutProgress = 0;
 		lastSettledSignature = undefined;
 		lastChallengedSignature = undefined;
 		lastPokeTargets = undefined;
 		pokeExplicitlyOff = false;
+		escPokePaused = false;
+		lastEscapeAt = 0;
 		pokeUiAllowed = ctx.hasUI;
 		autoPokeArmed = config.autoPoke && ctx.hasUI;
+		// TUI only: watch raw terminal input for the Escape key so an aborted
+		// run can be correlated with the user's actual keypress (pi-simple-goal
+		// pattern). stopReason alone is unreliable: provider stacks can
+		// finalize an abort as a generic error naming the abort.
+		try {
+			const uictx = ctx as { mode?: string; ui: { onTerminalInput?: (cb: (data: string) => unknown) => () => void } };
+			if (uictx.mode === "tui" && typeof uictx.ui.onTerminalInput === "function") {
+				unsubscribeTerminalInput = uictx.ui.onTerminalInput((data) => {
+					watchdog.notifyActivity(); // any keystroke is user activity
+					if (data === "\x1b" || data === "\x1b\x1b" || data === "\x1b[27u") {
+						lastEscapeAt = Date.now();
+						// Escape = manual control (goal-plugin pattern): cancel any
+						// pending delayed poke and hold poking until the next run.
+						cancelPendingPoke();
+						if (!escPokePaused) {
+							escPokePaused = true;
+							refreshWidget(ctx);
+						}
+						return undefined;
+					}
+					if (pokeScheduler.isPending()) {
+						// Typing during the poke window cancels the poke and pauses
+						// the cycle (pi-simple-goal restart-countdown behavior).
+						cancelPendingPoke();
+						escPokePaused = true;
+						refreshWidget(ctx);
+					}
+					return undefined;
+				});
+				terminalInputActive = true;
+			}
+		} catch {
+			// Non-TUI or older pi: aborts fall back to machinery classification.
+			terminalInputActive = false;
+		}
 		reconstructState(ctx);
 		refreshWidget(ctx);
 	});
@@ -839,6 +1006,12 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", () => {
 		clearInterval(watchdogTimer);
+		cancelPendingPoke();
+		if (unsubscribeTerminalInput) {
+			unsubscribeTerminalInput();
+			unsubscribeTerminalInput = undefined;
+		}
+		terminalInputActive = false;
 		watchdogCtx = undefined;
 	});
 
@@ -857,10 +1030,19 @@ export default function (pi: ExtensionAPI) {
 		if (!ctx.isIdle()) return;
 		// jcode's Esc: an interrupted run disarms auto-poke entirely and
 		// injects no follow-up of any kind.
-		if (wasLastRunAborted(ctx)) {
-			disarm();
-			pokeExplicitlyOff = true; // Esc = the user said stop; new work must not re-arm.
-			refreshWidget(ctx);
+		if (wasLastRunAborted()) {
+			// Escape correlation (pi-simple-goal pattern): only an aborted run
+			// with a RECENT raw Escape keypress behind it is the user's stop —
+			// that quiets the settle and pauses the poke until the next run.
+			// Any other abort (compaction, ctx.abort(), transport, provider
+			// stacks mislabeling the interrupt) is machinery: stay quiet and keep
+			// the cycle armed; the watchdog covers a genuinely lost continuation.
+			if (lastEscapeAt > 0 && Date.now() - lastEscapeAt <= ESCAPE_ABORT_WINDOW_MS) {
+				disarm();
+				escPokePaused = true; // not sticky: the next agent run lifts it
+				refreshWidget(ctx);
+				return;
+			}
 			return;
 		}
 		if (!autoPokeArmed) {

package/src/poke-scheduler.ts

@@ -0,0 +1,54 @@
+/**
+ * Pure delayed-poke scheduler (pi-simple-goal restartDelayMs pattern).
+ *
+ * The settle poke can be delayed (config.pokeDelayMs): while a poke is
+ * pending, any terminal input cancels it and pauses poking until the next
+ * agent run (see index.ts). This module owns only the timer lifecycle so it
+ * can be unit-tested without pi. A delayMs of 0 fires synchronously, which
+ * preserves the immediate (pure jcode) behavior with no branching at the
+ * call sites.
+ */
+
+export interface PokeScheduler {
+	/** Schedule a delayed poke, replacing any pending one. */
+	schedule(fire: () => void): void;
+	/** Cancel the pending poke (if any). */
+	cancel(): void;
+	/** Whether a poke is currently scheduled and waiting. */
+	isPending(): boolean;
+	/** Epoch ms when the pending poke fires; 0 when none pending. */
+	deadlineAt(): number;
+}
+
+export function createPokeScheduler(delayMs: number): PokeScheduler {
+	let timer: NodeJS.Timeout | undefined;
+	let deadline = 0;
+
+	const clear = (): void => {
+		if (timer !== undefined) {
+			clearTimeout(timer);
+			timer = undefined;
+		}
+		deadline = 0;
+	};
+
+	return {
+		schedule(fire: () => void): void {
+			if (delayMs <= 0) {
+				fire();
+				return;
+			}
+			clear();
+			deadline = Date.now() + delayMs;
+			timer = setTimeout(() => {
+				timer = undefined;
+				deadline = 0;
+				fire();
+			}, delayMs);
+			if (typeof timer.unref === "function") timer.unref();
+		},
+		cancel: clear,
+		isPending: (): boolean => timer !== undefined,
+		deadlineAt: (): number => deadline,
+	};
+}

package/src/watchdog.ts

@@ -19,6 +19,8 @@ export interface WatchdogDeps {
 	isIdle: () => boolean;
 	incompleteCount: () => number;
 	wasAborted: () => boolean;
+	/** Esc- or typing-paused cycle: the watchdog must not inject either. */
+	isPaused: () => boolean;
 	idleMs: number;
 	maxRePokes: number;
 	/** Re-send the auto-poke follow-up (fire-and-forget is fine). */
@@ -49,6 +51,13 @@ export function createWatchdog(deps: WatchdogDeps): Watchdog {
 				lastActivity = now;
 				return;
 			}
+			if (deps.isPaused()) {
+				// A paused cycle (Escape, or typing during the poke window) means
+				// the user took control; the watchdog stays quiet and the window
+				// restarts so unpausing (next agent run) gets a fresh idle period.
+				lastActivity = now;
+				return;
+			}
 			if (deps.incompleteCount() === 0) {
 				lastActivity = now;
 				rePokes = 0;

package/src/widget.ts

@@ -30,6 +30,10 @@ export interface TodoWidgetComponent {
 /** Machine state the header tail should surface. */
 export interface WidgetRuntime {
 	armed: boolean;
+	/** An Escape-paused cycle: suppressed until the user re-engages */
+	escPaused?: boolean;
+	/** Epoch ms when a delayed poke fires; 0 = none pending (pokeDelayMs). */
+	pokePendingAt?: number;
 	gateAttempts: number;
 	gateMaxAttempts: number;
 	/** Ids of the todos that caused the most recent poke/gate challenge */
@@ -105,7 +109,20 @@ function buildLeftColumn(
 	// user has been seeing.
 	let status: string;
 	if (!allSettled) {
-		status = runtime.armed ? "· auto-poke" : "· poke off";
+		const pendingIn =
+			runtime.pokePendingAt && runtime.pokePendingAt > 0
+				? Math.max(1, Math.ceil((runtime.pokePendingAt - Date.now()) / 1000))
+				: 0;
+		// A pause (Escape, or typing during the poke window) outranks the armed
+		// state: the cycle stays armed underneath but is held, so the user must
+		// see "poke paused", not a misleading "auto-poke".
+		status = runtime.escPaused
+				? "· poke paused"
+				: runtime.armed
+					? pendingIn > 0
+						? `· poke in ${pendingIn}s`
+						: "· auto-poke"
+					: "· poke off";
 	} else if (summary.needs_validation) {
 		status =
 			runtime.gateAttempts > 0

package/tests/test-todo.cjs

@@ -17,6 +17,13 @@ const os = require("node:os");
 const path = require("node:path");
 const fs = require("node:fs");
 
+// Point the extension's config at a scratch state dir BEFORE its module
+// loads: the e2e suite runs with a fast pokeDelayMs (400ms) so delayed-poke
+// scenarios exercise the real scheduler without waiting the real 20s.
+const TEST_STATE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "pi-jtodo-cfg-"));
+fs.writeFileSync(path.join(TEST_STATE_DIR, "config.json"), JSON.stringify({ pokeDelayMs: 400 }));
+process.env.PI_JTODO_STATE_DIR = TEST_STATE_DIR;
+
 let PI_PKG;
 try {
 	PI_PKG = path.dirname(require.resolve("@earendil-works/pi-coding-agent/package.json"));
@@ -39,6 +46,31 @@ function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
 
 async function freshSession(extraLoaderOptions) {
 	const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-jtodo-test-"));
+	// Recording UI context: bindExtensions() fires session_start (arming +
+	// branch replay + raw-input listener), widgets/notices are recorded, and
+	// tests can inject synthetic keystrokes (the Esc/typing paths are
+	// TUI-only otherwise — this closes the harness blind spot).
+	const rec = { inputHandler: undefined, widgets: [], notifies: [] };
+	const uiContext = {
+		select: async () => undefined,
+		confirm: async () => false,
+		input: async () => undefined,
+		editor: async () => undefined,
+		notify: (message, type) => { rec.notifies.push({ message, type }); },
+		onTerminalInput: (handler) => {
+			rec.inputHandler = handler;
+			return () => { if (rec.inputHandler === handler) rec.inputHandler = undefined; };
+		},
+		setStatus: () => {},
+		setWorkingMessage: () => {},
+		setWorkingVisible: () => {},
+		setWorkingIndicator: () => {},
+		setWidget: (key, content) => {
+			const i = rec.widgets.findIndex((w) => w.key === key);
+			if (i >= 0) rec.widgets.splice(i, 1);
+			if (content !== undefined) rec.widgets.push({ key, content });
+		},
+	};
 	const loader = new pi.DefaultResourceLoader({
 		cwd,
 		agentDir: pi.getAgentDir(),
@@ -53,7 +85,10 @@ async function freshSession(extraLoaderOptions) {
 		resourceLoader: loader,
 		tools: ["todo"],
 	});
+	await session.bindExtensions({ uiContext, mode: "tui" });
 	return {
+		rec,
+		sendKeys: (data) => { if (rec.inputHandler) rec.inputHandler(data); },
 		session,
 		exec: (params, signal) =>
 			session
@@ -389,7 +424,7 @@ async function suiteA() {
 			alias: { "@earendil-works/pi-tui": `${PI_PKG}/node_modules/@earendil-works/pi-tui/dist/index.js` },
 		});
 		const { createWatchdog } = await jiti.import(path.join(EXT_DIR, "watchdog.ts"));
-		let t = 0, armed = true, idle = true, open = 3, aborted = false;
+		let t = 0, armed = true, idle = true, open = 3, aborted = false, paused = false;
 		const fires = [], starves = [];
 		const wd = createWatchdog({
 			now: () => t,
@@ -397,6 +432,7 @@ async function suiteA() {
 			isIdle: () => idle,
 			incompleteCount: () => open,
 			wasAborted: () => aborted,
+			isPaused: () => paused,
 			idleMs: 90_000,
 			maxRePokes: 3,
 			onFire: (n) => fires.push(n),
@@ -428,10 +464,47 @@ async function suiteA() {
 		// unarmed never fires
 		armed = false; aborted = false; t += 400_000; wd.tick();
 		const unarmedQuiet = fires.length === 4;
-		if (fires[0] === 1 && fires[1] === 2 && postponed && capped && resetWorks && settledQuiet && abortWins && unarmedQuiet) {
-			ok("T14 watchdog", "fire/postpone/cap/reset/settled-quiet/abort/unarmed all correct");
+		// paused cycle (Esc or typing took over): watchdog stays quiet and the
+		// idle window restarts each paused tick, so unpausing gets a fresh window
+		armed = true; paused = true; t += 400_000; wd.tick();
+		const pausedQuiet = fires.length === 4;
+		paused = false; t += 50_000; wd.tick(); // window restarted by the paused tick
+		const pausedWindowRestarted = fires.length === 4;
+		t += 91_000; wd.tick(); // fresh full window after unpausing -> 5th fire
+		const resumedAfterPause = fires.length === 5 && fires.at(-1) === 1;
+		if (fires[0] === 1 && fires[1] === 2 && postponed && capped && resetWorks && settledQuiet && abortWins && unarmedQuiet && pausedQuiet && pausedWindowRestarted && resumedAfterPause) {
+			ok("T14 watchdog", "fire/postpone/cap/reset/settled-quiet/abort/unarmed/paused-quiet all correct");
 		} else {
-			bad("T14 watchdog", JSON.stringify({ fires, starves, postponed, capped, resetWorks, settledQuiet, abortWins, unarmedQuiet }));
+			bad("T14 watchdog", JSON.stringify({ fires, starves, postponed, capped, resetWorks, settledQuiet, abortWins, unarmedQuiet, pausedQuiet, pausedWindowRestarted, resumedAfterPause }));
+		}
+	});
+
+	// T20: delayed-poke scheduler (pure timer module, real clock).
+	await run("T20 poke scheduler", async () => {
+		const { createJiti } = require(`${PI_PKG}/node_modules/jiti/lib/jiti.cjs`);
+		const jiti = createJiti(__filename, {
+			alias: { "@earendil-works/pi-tui": `${PI_PKG}/node_modules/@earendil-works/pi-tui/dist/index.js` },
+		});
+		const { createPokeScheduler } = await jiti.import(path.join(EXT_DIR, "poke-scheduler.ts"));
+		const fired = [];
+		const s = createPokeScheduler(80);
+		const idleStart = !s.isPending() && s.deadlineAt() === 0;
+		s.schedule(() => fired.push("a"));
+		const pending = s.isPending() && s.deadlineAt() > Date.now();
+		s.cancel();
+		const cancelWorks = !s.isPending() && fired.length === 0 && s.deadlineAt() === 0;
+		s.schedule(() => fired.push("a"));
+		s.schedule(() => fired.push("b")); // replaces the pending poke
+		await sleep(200);
+		const firedOnceLatest = fired.join(",") === "b" && !s.isPending();
+		const zeroDelay = createPokeScheduler(0);
+		const syncFired = [];
+		zeroDelay.schedule(() => syncFired.push("now"));
+		const immediate = syncFired.join(",") === "now" && !zeroDelay.isPending();
+		if (idleStart && pending && cancelWorks && firedOnceLatest && immediate) {
+			ok("T20 poke scheduler", "schedule/cancel/deadline/replacement/zero-delay all correct");
+		} else {
+			bad("T20 poke scheduler", JSON.stringify({ idleStart, pending, cancelWorks, firedOnceLatest, immediate, fired }));
 		}
 	});
 
@@ -590,6 +663,12 @@ async function suiteA() {
 		const empty = widget.renderTodoWidgetLines({ todos: [], plan: {}, goals: [] }, rtOn, 6, 60, stubTheme);
 		const unarmed = widget.renderTodoWidgetLines(state, rtOff, 6, 60, stubTheme);
 		const offMarker = unescape(unarmed.at(-1)).includes("poke off");
+		// Esc-pause label must be distinct from the sticky /todos poke off state.
+		const rtEscPaused = { armed: false, escPaused: true, gateAttempts: 0, gateMaxAttempts: 5 };
+		const escPausedLine = widget.renderTodoWidgetLines(state, rtEscPaused, 6, 60, stubTheme);
+		const escPausedMarker =
+			unescape(escPausedLine.at(-1)).includes("poke paused") &&
+			!unescape(escPausedLine.at(-1)).includes("poke off");
 		// value-rank: shown item lines are exactly a(in_progress), then pending
 		// in declaration order; settled items are pushed into the overflow.
 		const shownIds = lines.slice(1, -1).map((l) => (unescape(l).match(/#(\w+)/) || [])[1]);
@@ -682,10 +761,10 @@ async function suiteA() {
 			markRow("g-warn")?.includes("🟡") && markRow("g-ok")?.includes("✔") &&
 			markRow("g-act")?.includes("🚧") && markRow("g-wait")?.includes("🔲") &&
 			markRow("g-nogoal")?.includes("–");
-		if (firstIsHeader && bottomStatus && inProgressOnTop && capped && openBreakdown && withinWidth && armedMarker && ranked && lateLeads && indented && empty.length === 0 && !unescape(unarmed.at(-1)).includes("auto-poke") && offMarker && confTails && gateShown && doneShown && intentShown && multiClean && icons && finger && tableHeader && activeFirst && verifyCells && builderCells && tableFooter && tableDropped && aligned && allAligned) {
+		if (firstIsHeader && bottomStatus && inProgressOnTop && capped && openBreakdown && withinWidth && armedMarker && ranked && lateLeads && indented && empty.length === 0 && !unescape(unarmed.at(-1)).includes("auto-poke") && offMarker && escPausedMarker && confTails && gateShown && doneShown && intentShown && multiClean && icons && finger && tableHeader && activeFirst && verifyCells && builderCells && tableFooter && tableDropped && aligned && allAligned) {
 			ok("T13 widget", "intention header + bottom status + table (Todo Goal) correct");
 		} else {
-			bad("T13 widget", JSON.stringify({ firstIsHeader, bottomStatus, inProgressOnTop, capped, withinWidth, offMarker, confTails, gateShown, doneShown, intentShown, multiClean, icons, finger, tableHeader, activeFirst, verifyCells, builderCells, tableFooter, tableDropped, aligned, allAligned, intentLines, mixedTbl }, null, 1));
+			bad("T13 widget", JSON.stringify({ firstIsHeader, bottomStatus, inProgressOnTop, capped, withinWidth, offMarker, escPausedMarker, confTails, gateShown, doneShown, intentShown, multiClean, icons, finger, tableHeader, activeFirst, verifyCells, builderCells, tableFooter, tableDropped, aligned, allAligned, intentLines, mixedTbl }, null, 1));
 		}
 	});
 }
@@ -699,6 +778,7 @@ function makeMockStreamSimple(calls, script) {
 	return function streamSimple(model, context, options) {
 		callIndex += 1;
 		calls.push({ index: callIndex, context });
+		if (typeof script.onRequest === "function") script.onRequest(context);
 		const step = callIndex;
 		const scriptCall = script.call;
 		const scriptText = script.text;
@@ -717,8 +797,22 @@ function makeMockStreamSimple(calls, script) {
 				stopReason: "pending",
 				timestamp: Date.now(),
 			};
-			try {
+		try {
 				stream.push({ type: "start", partial: output });
+				if (script.gateAt === step) {
+					// Hold the stream open so the test can abort mid-flight; honor the
+					// abort signal exactly like pi's own providers do (openai-completions.js).
+					const signal = options?.signal;
+					if (signal?.aborted) throw new Error("Request was aborted");
+					await new Promise((resolve, reject) => {
+						const onAbort = () => reject(new Error("Request was aborted"));
+						signal?.addEventListener("abort", onAbort, { once: true });
+						(script.gatePromise || Promise.resolve()).then(
+							() => { signal?.removeEventListener("abort", onAbort); resolve(); },
+							reject,
+						);
+					});
+				}
 				const toolCall = scriptCall(step);
 				if (toolCall) {
 					output.content.push(toolCall);
@@ -737,9 +831,12 @@ function makeMockStreamSimple(calls, script) {
 				stream.push({ type: "done", reason: output.stopReason, message: output });
 				stream.end();
 			} catch (err) {
-				output.stopReason = "error";
+				output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+				// Simulate provider stacks (pi-robust-provider observed live) that
+				// finalize an abort as a generic error naming the abort.
+				if (script.misclassifiedAbortAt === step) output.stopReason = "error";
 				output.errorMessage = err.message;
-				stream.push({ type: "error", reason: "error", error: output });
+				stream.push({ type: "error", reason: output.stopReason, error: output });
 				stream.end();
 			}
 		})();
@@ -909,6 +1006,14 @@ const SCRIPT_B3 = {
 
 async function runScenario(name, script, assertions) {
 	const calls = [];
+	if (script.abortAtCall) {
+		// Gate the abortAtCall'th provider call mid-stream so the test can abort
+		// the run deterministically while it is in flight.
+		script.gateAt = script.abortAtCall;
+		script.gatePromise = new Promise((resolve) => {
+			script.releaseGate = resolve;
+		});
+	}
 	const mockFactory = {
 		name: "mock-provider",
 		factory: (api) => {
@@ -922,20 +1027,86 @@ async function runScenario(name, script, assertions) {
 			});
 		},
 	};
-	await run(name, async ({ session }) => {
+	await run(name, async ({ session, rec }) => {
 		await session.setModel(MOCK_MODEL);
+		let abortTimerFired = false;
+		if (script.abortAtCall) {
+			// prompt() resolves only after every queued follow-up run finishes, so
+			// the poll loop below can never reach the gated call. Simulate Esc from
+			// a timer: abort once the gated provider call has actually started.
+			const startedAt = Date.now();
+			const abortWhenStarted = () => {
+				if (calls.length >= script.abortAtCall) {
+					abortTimerFired = true;
+					// Raw Escape first (TUI Esc = user stop): this is exactly what the
+					// real terminal delivers to the listener before pi aborts the run.
+					if (script.escBeforeAbort && rec.inputHandler) {
+						rec.inputHandler("\x1b");
+						try {
+							const w = rec.widgets.find((x) => x.key === "pi-jtodo");
+							const th = { fg: (_c, s) => String(s), bold: (s) => String(s) };
+							const component = typeof w?.content === "function" ? w.content(null, th) : w?.content;
+							script.escPaint = (component?.render?.(120) ?? []).map(String);
+						} catch { script.escPaint = []; }
+					}
+					if (script.compactInsteadOfAbort) session.compact();
+					else session.abort();
+					// Safety net: if the abort somehow never reaches the mock, release
+					// the gate so the scenario fails with diagnostics instead of hanging.
+					setTimeout(() => { if (script.releaseGate) script.releaseGate(); }, 3000);
+				} else if (Date.now() - startedAt < 12_000) {
+					setTimeout(abortWhenStarted, 100);
+				}
+			};
+			setTimeout(abortWhenStarted, 300);
+		}
 		await session.prompt("begin");
 
 		const deadline = Date.now() + 20_000;
 		let prompted = false;
+		let aborted = false;
+		let resumed = false;
+		let inputArmed = false;
+		let inputSent = false;
 		while (Date.now() < deadline) {
 			if (!prompted && script.promptAfter && calls.length >= script.promptAfter) {
 				prompted = true;
 				void session.prompt(script.promptText ?? "continue");
 			}
+			if (!inputArmed && script.inputAfter && calls.length >= script.inputAfter.call) {
+				inputArmed = true;
+				// Synthetic keystroke lands while the session is idle with a poke
+				// pending (the typing/Esc paths are TUI-only otherwise).
+				setTimeout(() => {
+					inputSent = true;
+					if (rec.inputHandler) rec.inputHandler(script.inputAfter.data);
+					// Snapshot the paint synchronously: the widget is a live thunk
+					// factory, so building + rendering it later would show the final
+					// state instead of the paused moment.
+					try {
+						const w = rec.widgets.find((x) => x.key === "pi-jtodo");
+						const th = { fg: (_c, s) => String(s), bold: (s) => String(s) };
+						const component = typeof w?.content === "function" ? w.content(null, th) : w?.content;
+						script.inputAfter.paint = (component?.render?.(120) ?? []).map(String);
+					} catch { script.inputAfter.paint = []; }
+				}, script.inputAfter.atMs);
+			}
+			if (inputSent && script.promptAfterInput && !prompted) {
+				prompted = true;
+				void session.prompt(script.promptText ?? "resume");
+			}
+			if (!aborted && script.abortAtCall && calls.length >= script.abortAtCall) {
+				aborted = true; // bookkeeping only; the timer above fired the Esc
+				if (!abortTimerFired) session.abort();
+			}
+			if (aborted && !resumed) {
+				resumed = true;
+				await sleep(1500); // let the abort settle (disarm + quiet) run first
+				void session.prompt(script.resumeText ?? "resume after the interrupt");
+			}
 			if (calls.length >= script.calls) {
 				await sleep(800);
-				if (calls.length === script.calls) break; // no further provider activity
+				if (calls.length >= script.calls && calls.length <= (script.callsMax ?? script.calls)) break; // done
 			}
 			await sleep(100);
 		}
@@ -943,8 +1114,9 @@ async function runScenario(name, script, assertions) {
 		const customs = entries
 			.filter((e) => e.type === "custom_message" && e.customType === "pi-jtodo/followup")
 			.map((e) => (typeof e.content === "string" ? e.content : ""));
-		if (calls.length !== script.calls) {
-			bad(`${name} flow`, `expected ${script.calls} provider calls, got ${calls.length}; customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const inRange = calls.length >= script.calls && calls.length <= (script.callsMax ?? script.calls);
+		if (!inRange) {
+			bad(`${name} flow`, `expected ${script.calls}${script.callsMax ? `..${script.callsMax}` : ""} provider calls, got ${calls.length}; customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
 			return;
 		}
 
@@ -952,7 +1124,7 @@ async function runScenario(name, script, assertions) {
 			(e) => e.type === "message" && e.message?.role === "toolResult" && e.message?.toolName === "todo",
 		);
 		const lastDetails = todoResults.at(-1)?.message?.details;
-		await assertions({ calls, customs, lastDetails });
+		await assertions({ calls, customs, lastDetails, entries, widgets: rec.widgets });
 	}, { extensionFactories: [mockFactory] });
 }
 
@@ -1021,6 +1193,308 @@ async function suiteB() {
 		if (done) ok("B3 final state", "both waves completed");
 		else bad("B3 final state", JSON.stringify(lastDetails?.todos));
 	});
+
+	// B4: Esc (session.abort) on the poke-driven run must disarm and inject
+	// NOTHING afterwards, even though open todos remain. Flow: run A writes an
+	// open todo and ends (settle #1 pokes), the poke-driven run B is aborted
+	// mid-stream (the user's exact complaint), and both the abort settle and
+	// the resumed run's settle stay quiet via the agent_end abort flag.
+	// B4: an abort with NO raw Escape behind it is machinery (ctx.abort(),
+	// extension-initiated, transport). Under the pi-simple-goal Escape model
+	// the poke cycle stays armed: the aborted settle is quiet, but a resumed
+	// run that still leaves todos open pokes normally. The real user-Esc pause
+	// (raw \x1b keypress) is TUI-only and verified live, not in the SDK harness.
+	const SCRIPT_B4 = {
+		call(step) {
+			if (step === 1) {
+				return {
+					type: "toolCall", id: "call-open", name: "todo",
+					arguments: {
+						todos: [{ content: "machinery abort guard", status: "in_progress", priority: "high", id: "e1", group: "esc", confidence: 96 }],
+						plan: { user_intention: "machinery abort e2e", understands_user_intent: 97 },
+						goals: [{ group: "esc", closed_feedback_loop: 97, feedback_loop: "abort keeps armed" }],
+					},
+				};
+			}
+			if (step === 5) {
+				return {
+					type: "toolCall", id: "call-done", name: "todo",
+					arguments: {
+						todos: [{ content: "machinery abort guard", status: "completed", priority: "high", id: "e1", group: "esc", confidence: 96, completion_confidence: 96 }],
+						goals: [{ group: "esc", closed_feedback_loop: 97, feedback_loop: "abort keeps armed", end_to_end_ownership: 96 }],
+					},
+				};
+			}
+			return null;
+		},
+		text(step) {
+			if (step === 2) return "Todos written.";
+			if (step === 3) return "Poked: working on it, mid-stream.";
+			if (step === 4) return "Resumed after the interrupt, still working.";
+			return "All done now.";
+		},
+		abortAtCall: 3, // abort run B, the poke-driven continuation
+		resumeText: "resume after the interrupt",
+		calls: 6,
+	};
+	await runScenario("B4 machinery abort keeps the poke cycle armed", SCRIPT_B4, async ({ customs, entries }) => {
+		const pokes = customs.filter((t) => t.includes("You have 1 incomplete todo."));
+		if (pokes.length === 2) ok("B4 poke before and after abort", "poke #1 at the write settle, poke #2 after the resumed run — cycle stayed armed");
+		else bad("B4 poke before and after abort", `pokes=${pokes.length} customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		if (customs.length === 2) ok("B4 aborted settle quiet", "the abort settle itself injected nothing");
+		else bad("B4 aborted settle quiet", `customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const stopReasons = entries
+			.filter((e) => e.type === "message" && e.message?.role === "assistant")
+			.map((e) => e.message.stopReason);
+		if (stopReasons.includes("aborted")) ok("B4 harness abort recorded", `assistant stopReasons=${JSON.stringify(stopReasons)}`);
+		else bad("B4 harness abort recorded", `no aborted stopReason; stopReasons=${JSON.stringify(stopReasons)}`);
+	});
+
+	// B5: pi-robust-provider observed live finalizing an Esc abort as a plain
+	// error whose text names the abort ("This operation was aborted"). The
+	// error-text fallback must classify it as a user interrupt and stay quiet.
+	// B5: pi-robust-provider observed live finalizing an Esc abort as a plain
+	// error whose text names the abort ("This operation was aborted"). Under
+	// the raw-Escape classification model a stopReason mislabel changes
+	// NOTHING: with no Escape keypress observed this is machinery, the settle is
+	// quiet, and the cycle stays armed. The real-Esc correlation is live-only.
+	const SCRIPT_B5 = {
+		call(step) {
+			if (step === 1) {
+				return {
+					type: "toolCall", id: "call-open", name: "todo",
+					arguments: {
+						todos: [{ content: "misclassified abort guard", status: "in_progress", priority: "high", id: "m1", group: "esc", confidence: 96 }],
+						plan: { user_intention: "misclassified abort e2e", understands_user_intent: 97 },
+						goals: [{ group: "esc", closed_feedback_loop: 97, feedback_loop: "error-naming-abort keeps armed" }],
+					},
+				};
+			}
+			if (step === 5) {
+				return {
+					type: "toolCall", id: "call-done", name: "todo",
+					arguments: {
+						todos: [{ content: "misclassified abort guard", status: "completed", priority: "high", id: "m1", group: "esc", confidence: 96, completion_confidence: 96 }],
+						goals: [{ group: "esc", closed_feedback_loop: 97, feedback_loop: "error-naming-abort keeps armed", end_to_end_ownership: 96 }],
+					},
+				};
+			}
+			return null;
+		},
+		text(step) {
+			if (step === 2) return "Todos written.";
+			if (step === 3) return "Poked: working, mid-stream.";
+			if (step === 4) return "Resumed after the interrupt, still working.";
+			return "All done now.";
+		},
+		abortAtCall: 3,
+		misclassifiedAbortAt: 3, // the abort finalizes as stopReason "error" naming the abort
+		resumeText: "resume after the interrupt",
+		calls: 6,
+	};
+	await runScenario("B5 error-naming-abort (robust-provider) is machinery", SCRIPT_B5, async ({ customs, entries }) => {
+		const pokes = customs.filter((t) => t.includes("You have 1 incomplete todo."));
+		if (pokes.length === 2) ok("B5 poke before and after abort", "misclassified abort did not suppress the cycle");
+		else bad("B5 poke before and after abort", `pokes=${pokes.length} customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		if (customs.length === 2) ok("B5 aborted settle quiet", "the error-naming-abort settle injected nothing");
+		else bad("B5 aborted settle quiet", `customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const interrupted = entries
+			.filter((e) => e.type === "message" && e.message?.role === "assistant")
+			.find((e) => /abort/i.test(e.message?.errorMessage ?? ""));
+		if (interrupted?.message?.stopReason === "error") ok("B5 interrupt finalized as error", "errorMessage names the abort, stopReason is error");
+		else bad("B5 interrupt finalized as error", `stopReason=${interrupted?.message?.stopReason} err=${interrupted?.message?.errorMessage}`);
+	});
+
+	// B6: compaction aborts the in-flight run but guarantees a continuation —
+	// a system interrupt. Its settle must stay quiet WITHOUT disarming and
+	// WITHOUT the sticky Esc off, so the resumed run's settle pokes normally.
+	let b6DoneSent = false;
+	let b6PokesSeen = 0;
+	const SCRIPT_B6 = {
+		onRequest(context) {
+			// Count auto-poke messages already in the request history; robust
+			// to compaction consuming 1 or 2 provider calls. User-role content may
+			// be a string or a block array (same extraction as contextUserTexts).
+			const texts = (context?.messages ?? [])
+				.filter((m) => m?.role === "user")
+				.map((m) =>
+					typeof m?.content === "string"
+						? m.content
+						: (m?.content ?? []).map((c) => c?.text ?? "").join(""),
+				);
+			b6PokesSeen = texts.filter((t) => t.includes("You have 1 incomplete todo.")).length;
+		},
+		call(step) {
+			if (step === 1) {
+				return {
+					type: "toolCall", id: "call-open", name: "todo",
+					arguments: {
+						todos: [{ content: "compaction window guard", status: "in_progress", priority: "high", id: "c1", group: "esc", confidence: 96 }],
+						plan: { user_intention: "compaction window e2e", understands_user_intent: 97 },
+						goals: [{ group: "esc", closed_feedback_loop: 97, feedback_loop: "armed survives compaction" }],
+					},
+				};
+			}
+			// Only the run driven by poke #2 completes the todo, so poke #2
+			// provably fired (the resumed run before it must leave it open).
+			if (step >= 5 && b6PokesSeen >= 2 && !b6DoneSent) {
+				b6DoneSent = true;
+				return {
+					type: "toolCall", id: "call-done", name: "todo",
+					arguments: {
+						todos: [{ content: "compaction window guard", status: "completed", priority: "high", id: "c1", group: "esc", confidence: 96, completion_confidence: 96 }],
+						goals: [{ group: "esc", closed_feedback_loop: 97, feedback_loop: "armed survives compaction", end_to_end_ownership: 96 }],
+					},
+				};
+			}
+			return null;
+		},
+		text(step) {
+			if (step === 2) return "Todos written. " + "Detailed work log entries accumulate here. ".repeat(2600);
+			if (step === 3) return "Poked: working, mid-stream.";
+			return "Continuing after compaction.";
+		},
+		abortAtCall: 3,
+		compactInsteadOfAbort: true, // session.compact() aborts the gated run (system interrupt)
+		promptAfter: 4, // after the compaction summarization call, resume the agent
+		promptText: "resume the work",
+		calls: 7,
+		callsMax: 9, // compaction may consume 1 or 2 provider calls
+	};
+	await runScenario("B6 compaction abort keeps the poke cycle armed", SCRIPT_B6, async ({ customs, entries }) => {
+		const pokes = customs.filter((t) => t.includes("You have 1 incomplete todo."));
+		if (pokes.length === 2) ok("B6 armed preserved", "poke #1 pre-abort, poke #2 after the resumed run — no sticky-off");
+		else bad("B6 armed preserved", `pokes=${pokes.length} customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const noisy = customs.filter((t) => t.includes("rose too sharply") || t.includes("not high enough") || t.includes("todo quality review"));
+		if (noisy.length === 0) ok("B6 no spurious gates", "clean scores produced no challenges/digest");
+		else bad("B6 no spurious gates", JSON.stringify(noisy));
+		const stopReasons = entries
+			.filter((e) => e.type === "message" && e.message?.role === "assistant")
+			.map((e) => e.message.stopReason);
+		if (stopReasons.includes("aborted")) ok("B6 compaction abort recorded", `stopReasons=${JSON.stringify(stopReasons)}`);
+		else bad("B6 compaction abort recorded", `no aborted stopReason; stopReasons=${JSON.stringify(stopReasons)}`);
+	});
+
+	// B7: typing during the pokeDelayMs window cancels the pending poke and
+	// pauses the cycle; the pause lifts at the next agent run (goal-plugin
+	// pattern) and the resumed run finishes cleanly.
+	const SCRIPT_B7 = {
+		call(step) {
+			if (step === 1) {
+				return {
+					type: "toolCall", id: "call-open", name: "todo",
+					arguments: {
+						todos: [{ content: "typing-cancel guard", status: "in_progress", priority: "high", id: "t1", group: "tc", confidence: 96 }],
+						plan: { user_intention: "typing cancel e2e", understands_user_intent: 97 },
+						goals: [{ group: "tc", closed_feedback_loop: 97, feedback_loop: "typing cancels the pending poke" }],
+					},
+				};
+			}
+			if (step === 3) {
+				return {
+					type: "toolCall", id: "call-done", name: "todo",
+					arguments: {
+						todos: [{ content: "typing-cancel guard", status: "completed", priority: "high", id: "t1", group: "tc", confidence: 96, completion_confidence: 96 }],
+						goals: [{ group: "tc", closed_feedback_loop: 97, feedback_loop: "typing cancels the pending poke", end_to_end_ownership: 96 }],
+					},
+				};
+			}
+			return null;
+		},
+		text(step) {
+			if (step === 2) return "Todos written.";
+			return "Done after the resume.";
+		},
+		inputAfter: { call: 2, atMs: 150, data: "x" },
+		promptAfterInput: true,
+		promptText: "resume working on the todos",
+		calls: 4,
+	};
+	await runScenario("B7 typing cancels the pending poke", SCRIPT_B7, async ({ customs, widgets, lastDetails }) => {
+		if (customs.length === 0) ok("B7 typing cancel + pause", "the user keystroke canceled the pending poke; the resume run lifted the pause and finished quietly");
+		else bad("B7 typing cancel + pause", `customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const pausedPaint = SCRIPT_B7.inputAfter.paint?.some((l) => l.includes("poke paused"));
+		if (pausedPaint) ok("B7 widget pause paint", "the widget bottom line rendered 'poke paused' while held");
+		else bad("B7 widget pause paint", JSON.stringify(SCRIPT_B7.inputAfter.paint ?? null, (k, v) => (typeof v === "string" ? v.replace(/\x1b\[[0-9;]*m/g, "") : v)));
+		const done = lastDetails?.todos?.[0]?.status === "completed";
+		if (done) ok("B7 resume completed the todo", "the resumed run closed the item and the cycle ended clean");
+		else bad("B7 resume completed the todo", JSON.stringify(lastDetails?.todos));
+	});
+
+	// B8: Escape during the poke window cancels the pending poke and holds the
+	// pause for the Esc window; a resume inside that window stays quiet.
+	const SCRIPT_B8 = {
+		call(step) {
+			if (step === 1) {
+				return {
+					type: "toolCall", id: "call-open", name: "todo",
+					arguments: {
+						todos: [{ content: "esc-window guard", status: "in_progress", priority: "high", id: "e1", group: "ew", confidence: 96 }],
+						plan: { user_intention: "esc window e2e", understands_user_intent: 97 },
+						goals: [{ group: "ew", closed_feedback_loop: 97, feedback_loop: "esc holds the pause inside the window" }],
+					},
+				};
+			}
+			return null;
+		},
+		text(step) {
+			if (step === 2) return "Todos written.";
+			return "Resumed inside the Esc window, still working.";
+		},
+		inputAfter: { call: 2, atMs: 150, data: "\x1b" },
+		promptAfterInput: true,
+		promptText: "resume while the Esc window is open",
+		calls: 3,
+	};
+	await runScenario("B8 Esc during poke window holds the pause", SCRIPT_B8, async ({ customs, widgets }) => {
+		if (customs.length === 0) ok("B8 esc cancel + held pause", "Escape canceled the pending poke and the in-window resume settle stayed quiet");
+		else bad("B8 esc cancel + held pause", `customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const pausedPaint = SCRIPT_B8.inputAfter.paint?.some((l) => l.includes("poke paused"));
+		if (pausedPaint) ok("B8 widget pause paint", "'poke paused' rendered during the held pause");
+		else bad("B8 widget pause paint", JSON.stringify(SCRIPT_B8.inputAfter.paint ?? null, (k, v) => (typeof v === "string" ? v.replace(/\x1b\[[0-9;]*m/g, "") : v)));
+	});
+
+	// B9: a raw Escape observed right before an abort classifies the run as the
+	// user's stop — the settle disarms and pauses instead of re-poking. This is
+	// the regression pin for the missing-constant crash the old suite missed
+	// (the Esc path only runs when terminal input has been seen).
+	const SCRIPT_B9 = {
+		call(step) {
+			if (step === 1) {
+				return {
+					type: "toolCall", id: "call-open", name: "todo",
+					arguments: {
+						todos: [{ content: "user-esc guard", status: "in_progress", priority: "high", id: "u1", group: "ue", confidence: 96 }],
+						plan: { user_intention: "user esc e2e", understands_user_intent: 97 },
+						goals: [{ group: "ue", closed_feedback_loop: 97, feedback_loop: "user Esc pauses the poke" }],
+					},
+				};
+			}
+			return null;
+		},
+		text(step) {
+			if (step === 2) return "Todos written.";
+			if (step === 3) return "Poked: working on it, mid-stream.";
+			return "Resumed inside the Esc window.";
+		},
+		abortAtCall: 3,
+		escBeforeAbort: true,
+		resumeText: "resume after the user interrupt",
+		calls: 4,
+	};
+	await runScenario("B9 user Esc abort pauses the poke", SCRIPT_B9, async ({ customs, entries, widgets }) => {
+		const pokes = customs.filter((t) => t.includes("You have 1 incomplete todo."));
+		if (pokes.length === 1) ok("B9 user-Esc settle quiet", "poke #1 at the write settle; the Esc-aborted settle and the in-window resume settle injected nothing");
+		else bad("B9 user-Esc settle quiet", `pokes=${pokes.length} customs=${JSON.stringify(customs.map((t) => t.slice(0, 60)))}`);
+		const stopReasons = entries
+			.filter((e) => e.type === "message" && e.message?.role === "assistant")
+			.map((e) => e.message.stopReason);
+		if (stopReasons.includes("aborted")) ok("B9 aborted run recorded", `stopReasons=${JSON.stringify(stopReasons)}`);
+		else bad("B9 aborted run recorded", `stopReasons=${JSON.stringify(stopReasons)}`);
+		const pausedPaint = SCRIPT_B9.escPaint?.some((l) => l.includes("poke paused"));
+		if (pausedPaint) ok("B9 widget pause paint", "'poke paused' rendered right after the user Esc");
+		else bad("B9 widget pause paint", JSON.stringify(SCRIPT_B9.escPaint ?? null, (k, v) => (typeof v === "string" ? v.replace(/\x1b\[[0-9;]*m/g, "") : v)));
+	});
 }
 
 // ============================================================================