pi-harness-runtime 1.1.459 → 1.1.460

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.1.460](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.448...v1.1.460) (2026-10-28)
+
+
+### Features
+
+* **delegation:** a child is only a child when it really ran ([ac4e678](https://github.com/ManotLuijiu/pi-harness-runtime/commit/ac4e6782d7d4bc4941e458425c8a9f38a51fc9d4))
+* **delegation:** the scope of a request is measured before it is judged ([684b6a5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/684b6a55184f63d3be24c48dcecfb0b13410dc15))
+* **honcho:** the memory service speaks the native MCP of Pi ([f9f740c](https://github.com/ManotLuijiu/pi-harness-runtime/commit/f9f740c12869bae4c4380afbe8c76e12388bb744))
+* **jev:** the pending question carries the ask and the answer ([a792133](https://github.com/ManotLuijiu/pi-harness-runtime/commit/a792133e517fb8c12d3363e98942f3af30270f27))
+* **jev:** the pending question counts down to the decision ([d0cc171](https://github.com/ManotLuijiu/pi-harness-runtime/commit/d0cc171223986b2d32c670b6c1c74712fe0a4ad8))
+* **keys:** the key files are repaired when their permissions are unsafe ([e9c2c26](https://github.com/ManotLuijiu/pi-harness-runtime/commit/e9c2c26b287665b56ed749de269737e8403bb8af))
+* **merge:** a manual run can leave the merge to the pull request event ([b3d1950](https://github.com/ManotLuijiu/pi-harness-runtime/commit/b3d1950b5941c78ccd56951acdafd1d4afbe1bff))
+* **phase:** the agent owns the todo list and the harness says so ([c489370](https://github.com/ManotLuijiu/pi-harness-runtime/commit/c489370bd7926aece8cb1a77aa20ca2d2672f1fb))
+* **review:** the review starts on its own when the implementation is done ([04f51f5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/04f51f599cd3222b6c74dd8fadb1373bd72d9bd7))
+* **status:** the status line names the phase, the progress and the children ([0167bf3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/0167bf396a0b987c1d44f3b869351976a951dd65))
+* **test:** the task waits for the final tier of the validation plan ([fa147db](https://github.com/ManotLuijiu/pi-harness-runtime/commit/fa147dbf7d50d56e6ea48c6d8fbb4fcb190caf8a))
+* **validation:** a large job starts with a measured pilot ([425964b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/425964b04a3d4fa02adfabed47ff62c5ec2b9c28))
+* **validation:** the size of a job is a fact, not a phrase ([8aa6c11](https://github.com/ManotLuijiu/pi-harness-runtime/commit/8aa6c119565d0f8412dc8aeafa6b295d47d3f093))
+
+
+### Bug Fixes
+
+* **ci:** every run of a required check counts, and the worst one decides ([da9e0da](https://github.com/ManotLuijiu/pi-harness-runtime/commit/da9e0da6b0ca29cb320764fd5fc1b8a8dee8b1e0))
+* **ci:** the newest attempt of a run decides, not the attempt that failed ([9d7adcc](https://github.com/ManotLuijiu/pi-harness-runtime/commit/9d7adcc31cbacc517c3c1a9bcd3956be94c908ef))
+* **hooks:** a tag is checked through the commit behind it ([c823e8e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/c823e8e1f6973c62b5449a97c101759a4d5cbba5))
+* **jev:** the alternatives of a question are parsed without a quadratic pattern ([63016a3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/63016a3f0488acb801990dd46770c00d382b5858))
+* **keys:** the key directory is audited as a tree ([081cc75](https://github.com/ManotLuijiu/pi-harness-runtime/commit/081cc75ac8ceff36b0d619c3f76371dc08459d3c))
+* **merge:** the boolean input is read as a boolean ([971b716](https://github.com/ManotLuijiu/pi-harness-runtime/commit/971b7169a43db382dbdeb6bb9bab02ab56e0351c))
+* **merge:** the manual job needs the right of the merge ([7ba685e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/7ba685ec43d815f90aa35b742579e87e76c69209))
+* **merge:** the merge of the pull request is the GraphQL mutation ([972bab4](https://github.com/ManotLuijiu/pi-harness-runtime/commit/972bab4b0f7faf1b0047f3bb767ef6db3de4b2fa))
+* **merge:** the workflow merges the pull request the gates cleared ([d7639ec](https://github.com/ManotLuijiu/pi-harness-runtime/commit/d7639ec9b83723510acb4a5c4e23d5d6167c3af6))
+* **release:** a manual release keeps the version of its manifest ([122e661](https://github.com/ManotLuijiu/pi-harness-runtime/commit/122e661ea48cb8aff14c71dbd0221a4cf0ba4c8e))
+* **release:** the alignment names the reason of a failure ([5814dd0](https://github.com/ManotLuijiu/pi-harness-runtime/commit/5814dd0b780f5839cf8011ed0cbbbb31e7eb0418))
+* **release:** the channels of the package name the release ([a7a273f](https://github.com/ManotLuijiu/pi-harness-runtime/commit/a7a273ffe8398e2b5b07ef1c321777de41792c6e))
+* **release:** the release publishes and leaves the channels alone ([5871746](https://github.com/ManotLuijiu/pi-harness-runtime/commit/5871746589c1281d855dbeb591b02419fa43f22e))
+* **release:** the release pull request names the version of its branch ([a846e83](https://github.com/ManotLuijiu/pi-harness-runtime/commit/a846e83e6de6e529f4bca05e869db0b5eebb37c5))
+* **release:** the release scans the tree of the commit it publishes ([7d47a0b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/7d47a0b5406480a1e1d3a52623a76aabd1e2d0ba))
+
 ### [1.1.459](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.448...v1.1.459) (2026-10-28)
 
 

package/harness/pending-countdown.ts

@@ -0,0 +1,348 @@
+/**
+ * The live countdown of a pending question.
+ *
+ * The harness asks a human a question and waits. The wait has a deadline,
+ * and the countdown shows the remaining time in the status row of the TUI
+ * and starts the decision of the judge exactly at that deadline.
+ *
+ * The module owns the two policies of the wait:
+ *
+ * - the first countdown counts down to the deadline of the decision, which
+ *   is derived from the moment the wait started,
+ * - the recheck counts down to the next attempt, after the judge asked to
+ *   wait longer.
+ *
+ * The caller cannot pass a deadline of its own: the displayed deadline and
+ * the deadline the judge uses therefore cannot drift apart.
+ *
+ * The countdown is bound to one request. Every start replaces the previous
+ * binding and every stop releases the timer, so there is never more than
+ * one countdown and never a timer without a request.
+ */
+
+/** What the countdown counts to. */
+export type CountdownMode = "initial" | "recheck";
+
+/** The state of the countdown that is drawn in the status row. */
+export interface CountdownView {
+	/** The request the countdown belongs to. */
+	requestId: string;
+	/** The milliseconds that are left. Never negative. */
+	remainingMs: number;
+	/** The remaining time as "MM:SS". */
+	remaining: string;
+	/** What the countdown counts to. */
+	mode: CountdownMode;
+}
+
+/** The dependencies of a countdown. */
+export interface PendingCountdownDeps {
+	/** Draw the countdown in the status row. */
+	render: (view: CountdownView) => void;
+	/** The deadline was reached and the decision is due. */
+	onDeadline: (requestId: string) => void;
+	/**
+	 * Is the request still the pending one?
+	 *
+	 * A tick of a question that was answered or replaced in the meantime
+	 * must not redraw its status and must not trigger a decision.
+	 */
+	isPending: (requestId: string) => boolean;
+	/** A failing callback of the countdown is reported here. */
+	onError?: (error: unknown) => void;
+	/** The wait is over: the status row is cleared. */
+	onStop?: (requestId: string | null) => void;
+	/** The minutes the judge waits for a human answer. */
+	waitMinutes: number;
+	/** The milliseconds until the next attempt after the judge asked to wait. */
+	recheckIntervalMs: number;
+	/** The clock (the tests drive it). */
+	now?: () => number;
+	/** The timer that drives the ticks (the tests drive it). */
+	setInterval?: (callback: () => void, ms: number) => unknown;
+	/** The timer that stops the ticks (the tests drive it). */
+	clearInterval?: (handle: unknown) => void;
+	/** The tick interval in milliseconds. */
+	tickMs?: number;
+}
+
+/** The milliseconds between two ticks of the display. */
+const COUNTDOWN_TICK_MS = 1_000;
+
+/**
+ * The smallest tick interval.
+ *
+ * A shorter interval would repaint the status row faster than a reader can
+ * follow it and would waste the event loop of the harness.
+ */
+const MIN_TICK_MS = 100;
+
+/**
+ * The deadline of the decision.
+ *
+ * The deadline is derived from the moment the wait started, so the
+ * countdown and the judge share one timestamp.
+ */
+export function decisionDeadlineAt(startedAt: number, waitMinutes: number): number {
+	const minutes = Number.isFinite(waitMinutes) ? Math.max(0, waitMinutes) : 0;
+	const started = Number.isFinite(startedAt) ? startedAt : 0;
+	return started + minutes * 60_000;
+}
+
+/**
+ * The remaining time as "MM:SS".
+ *
+ * A time that is not a number is shown as an empty countdown: a status row
+ * must never claim a time that does not exist.
+ */
+export function formatRemainingTime(remainingMs: number): string {
+	const safeMs = Number.isFinite(remainingMs) ? Math.max(0, remainingMs) : 0;
+	const totalSeconds = Math.floor(safeMs / 1_000);
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+
+/** The binding of a running countdown. */
+interface CountdownBinding {
+	requestId: string;
+	deadlineAt: number;
+	mode: CountdownMode;
+}
+
+/**
+ * The countdown of one pending question.
+ *
+ * The countdown renders at once: the status row must show the remaining
+ * time without waiting for the first tick.
+ */
+export class PendingQuestionCountdown {
+	private readonly deps: PendingCountdownDeps;
+	private readonly now: () => number;
+	private readonly startTimer: (callback: () => void, ms: number) => unknown;
+	private readonly stopTimer: (handle: unknown) => void;
+	private readonly tickMs: number;
+	private handle: unknown = null;
+	private binding: CountdownBinding | null = null;
+	/**
+	 * Bumped on every start and every stop.
+	 *
+	 * A tick of an older generation belongs to a binding that is gone: it is
+	 * ignored instead of redrawing a status or triggering a decision.
+	 */
+	private generation = 0;
+	/**
+	 * True while the countdown owns the wait.
+	 *
+	 * The countdown stays engaged after its deadline fired, until the
+	 * decision path stops it or replaces it. The fallback poll uses this to
+	 * stay out of the way of the accurate timer.
+	 */
+	private engaged = false;
+	/**
+	 * True when the deadline fired and the decision did not start yet.
+	 *
+	 * The countdown owns the wait in that state, but it has no timer: the
+	 * caller arms it again when the decision did not start.
+	 */
+	private deadlineFired = false;
+
+	constructor(deps: PendingCountdownDeps) {
+		this.deps = deps;
+		this.now = deps.now ?? (() => Date.now());
+		this.startTimer =
+			deps.setInterval ??
+			((callback, ms) => setInterval(callback, ms) as unknown);
+		this.stopTimer =
+			deps.clearInterval ??
+			((handle) => clearInterval(handle as NodeJS.Timeout));
+		this.tickMs = Math.max(MIN_TICK_MS, deps.tickMs ?? COUNTDOWN_TICK_MS);
+	}
+
+	/** Does the countdown own the current wait? */
+	get active(): boolean {
+		return this.engaged;
+	}
+
+	/** Did the deadline fire and is the decision still due? */
+	get fired(): boolean {
+		return this.deadlineFired;
+	}
+
+	/** The request the countdown belongs to. */
+	get requestId(): string | null {
+		return this.binding?.requestId ?? null;
+	}
+
+	/** What the countdown counts to. */
+	get mode(): CountdownMode | null {
+		return this.binding?.mode ?? null;
+	}
+
+	/**
+	 * Start the countdown of a request, or replace the running one.
+	 *
+	 * The deadline of the decision is derived from the moment the wait
+	 * started: the caller passes that timestamp, the countdown computes the
+	 * deadline. The countdown and the judge therefore share one timestamp.
+	 */
+	start(requestId: string, startedAt: number): void {
+		this.begin(requestId, decisionDeadlineAt(startedAt, this.deps.waitMinutes), "initial");
+	}
+
+	/**
+	 * Start the countdown of the next attempt.
+	 *
+	 * The judge asked to wait longer: the countdown counts down to the next
+	 * attempt instead of to the deadline of the decision.
+	 */
+	startRecheck(requestId: string): void {
+		this.begin(requestId, this.now() + this.deps.recheckIntervalMs, "recheck");
+	}
+
+	/**
+	 * Stop the countdown and release its timer.
+	 *
+	 * Stopping is idempotent: a countdown that is not running can be stopped
+	 * as often as the cleanup paths need. The status row is cleared with it,
+	 * so a dead countdown never leaves a row that claims a decision is due.
+	 */
+	stop(): void {
+		const requestId = this.binding?.requestId ?? null;
+		this.engaged = false;
+		this.deadlineFired = false;
+		this.generation += 1;
+		this.clearTimer();
+		this.binding = null;
+		this.safeCall(() => this.deps.onStop?.(requestId));
+	}
+
+	/** Bind the countdown to a request and start its timer. */
+	private begin(requestId: string, deadlineAt: number, mode: CountdownMode): void {
+		this.clearTimer();
+		this.generation += 1;
+		const generation = this.generation;
+		this.binding = { requestId, deadlineAt, mode };
+		this.engaged = true;
+		this.deadlineFired = false;
+		try {
+			this.handle = this.startTimer(() => this.tick(generation), this.tickMs);
+		} catch (error) {
+			// The timer could not be created: the countdown owns nothing, so
+			// it must not claim the wait. The row of the countdown is
+			// cleared with it, so no row claims a decision that is not due.
+			this.engaged = false;
+			this.binding = null;
+			this.safeCall(() => this.deps.onStop?.(requestId));
+			this.report(error);
+			return;
+		}
+		this.tick(generation);
+	}
+
+	/**
+	 * One tick of the countdown.
+	 *
+	 * The tick is a no-op when it belongs to a binding that is gone, or
+	 * when the request it counts for is no longer the pending one.
+	 */
+	private tick(generation: number): void {
+		if (!this.engaged || generation !== this.generation) return;
+		const binding = this.binding;
+		if (!binding) return;
+
+		let remainingMs: number;
+		try {
+			if (!this.deps.isPending(binding.requestId)) {
+				// The question was answered or replaced: the countdown of
+				// that question is over.
+				this.stop();
+				return;
+			}
+			// The callback may have stopped the countdown: the binding of
+			// this tick is gone and must not be drawn any more.
+			if (!this.engaged || generation !== this.generation) return;
+			remainingMs = Math.max(0, binding.deadlineAt - this.now());
+		} catch (error) {
+			// A failing callback must never escape the timer: the countdown
+			// stops and the failure is reported.
+			this.stop();
+			this.report(error);
+			return;
+		}
+
+		if (remainingMs <= 0) {
+			// The deadline is reached. The timer stops, the countdown stays
+			// engaged until the decision path stops it or replaces it, so
+			// the fallback poll does not start a second decision.
+			this.clearTimer();
+			this.deadlineFired = true;
+			// The countdown reaches its zero before the decision starts.
+			this.safeRender({
+				requestId: binding.requestId,
+				remainingMs: 0,
+				remaining: formatRemainingTime(0),
+				mode: binding.mode,
+			});
+			// A failing decision handler must not leave a countdown that owns
+			// the wait without a timer: the countdown stops, so the fallback
+			// poll can take over.
+			try {
+				this.deps.onDeadline(binding.requestId);
+			} catch (error) {
+				this.stop();
+				this.report(error);
+			}
+			return;
+		}
+
+		this.safeRender({
+			requestId: binding.requestId,
+			remainingMs,
+			remaining: formatRemainingTime(remainingMs),
+			mode: binding.mode,
+		});
+	}
+
+	/** Draw the countdown, and report a failing status row. */
+	private safeRender(view: CountdownView): void {
+		try {
+			this.deps.render(view);
+		} catch (error) {
+			this.stop();
+			this.report(error);
+		}
+	}
+
+	/** Run a callback of the countdown without letting it escape. */
+	private safeCall(action: () => void): void {
+		try {
+			action();
+		} catch (error) {
+			this.report(error);
+		}
+	}
+
+	/** Report a failure without letting the report escape. */
+	private report(error: unknown): void {
+		try {
+			this.deps.onError?.(error);
+		} catch {
+			// The report of a failure must not become a new failure.
+		}
+	}
+
+	/** Release the timer of the countdown. */
+	private clearTimer(): void {
+		if (this.handle === null) return;
+		const handle = this.handle;
+		this.handle = null;
+		try {
+			this.stopTimer(handle);
+		} catch (error) {
+			// The timer is already released from the point of view of the
+			// countdown: the failure is reported, nothing is left behind.
+			this.report(error);
+		}
+	}
+}

package/index.ts

@@ -42,6 +42,10 @@ import {
 	relayShouldBeReported,
 } from "./harness/startup-report.ts";
 import { localSkillsReport, skillsReport } from "./harness/skills-startup.ts";
+import {
+	PendingQuestionCountdown,
+	type CountdownView,
+} from "./harness/pending-countdown.ts";
 import { isChannelDisabled, setChannelDisabled } from "./harness/notification-settings.ts";
 // The Honcho contract lives with the Honcho integration. A type-only import
 // is erased at runtime, so the startup keeps loading the module lazily.
@@ -292,6 +296,9 @@ const sharedState = {
 	validationLedger: null as unknown,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	updateAutoContinueStatus: null as any,
+	// The live countdown of the pending question. The channels stop it when
+	// a human answer arrives.
+	pendingCountdown: null as PendingQuestionCountdown | null,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	pqController: null as any,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -335,6 +342,8 @@ function applyChannelApproval(
 	// cleared after a successful resolution.
 	sharedState.waitingForUserSince = null;
 	sharedState.updateAutoContinueStatus?.("IDLE");
+	// The countdown of the answered question is over with it.
+	sharedState.pendingCountdown?.stop();
 
 	if (result.resolution === "yes") {
 		(sharedState.todoContinuationController as any)?.resume?.();
@@ -932,6 +941,12 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		let lastUserMessage: Date | null = null;
 		let autoContinueTimer: NodeJS.Timeout | null = null;
 		let _inferenceInProgress = false; // Track for overlap prevention
+		// The timing of the wait. The countdown in the status row and the
+		// decision of the judge use the same constants, so the displayed
+		// deadline and the decision can never drift apart.
+		const AUTO_CONTINUE_INTERVAL_MS = 60 * 1000; // Fallback poll: every minute
+		const MIN_WAIT_MINUTES = 5; // Minimum wait before auto-continue
+		const MAX_WAIT_MINUTES = 30; // After this the work pauses instead of waiting
 		// A continuation was dispatched and its turn has not settled yet.
 		// The gate owns that state: the status stays "RUN" until the turn
 		// settles, and no timer may clear it in the meantime.
@@ -1023,6 +1038,15 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 			}
 		});
 		let _sessionId = Date.now().toString(36); // Track session for cancellation
+		// The session of the Pi runtime. A countdown belongs to the session
+		// that asked the question.
+		let _piSessionId = "";
+		// The session the running countdown belongs to. A countdown of a
+		// session that is gone must not draw its status any more.
+		let _countdownSessionId = "";
+		// The request the row of the footer belongs to. A countdown that
+		// stops must not clear the row of a newer question.
+		let _countdownRowRequestId: string | null = null;
 		let _lastNotifiedQuestion = ""; // Track last question to prevent repeat notifications
 		let _completedNotifiedFor: string | null = null; // Track completion notification deduplication
 
@@ -1048,36 +1072,164 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 			ERROR: "Auto-continue unavailable",
 		} as const;
 
+		// The live countdown of the pending question.
+		//
+		// It owns the deadline of the wait: it shows the remaining time in
+		// the status row once per second and starts the decision of the
+		// judge exactly at the deadline. The fallback poll only takes over
+		// when there is no countdown, so a decision is never started twice.
+		const pendingCountdown = new PendingQuestionCountdown({
+			// The two policies of the wait belong to the countdown, so the
+			// displayed deadline and the deadline of the judge cannot drift
+			// apart.
+			waitMinutes: MIN_WAIT_MINUTES,
+			recheckIntervalMs: AUTO_CONTINUE_INTERVAL_MS,
+			render: (view: CountdownView) => {
+				_countdownRowRequestId = view.requestId;
+				updateAutoContinueStatus(
+					"WAITING",
+					view.requestId.slice(0, 8),
+					view.mode === "recheck"
+						? `Jev will recheck in ${view.remaining}`
+						: `Jev decision in ${view.remaining}`,
+				);
+			},
+			onDeadline: (requestId: string) => {
+				logToFile("[auto-continue]", "The decision deadline was reached:", requestId);
+				checkAndAutoContinue("countdown")
+					.then(() => {
+						// The decision did not start - another one was still in
+						// flight, or the wait was gone before it ran. The
+						// deadline is not lost: the countdown is armed again
+						// and the decision follows.
+						if (pendingCountdown.fired && pendingCountdown.requestId === requestId) {
+							pendingCountdown.startRecheck(requestId);
+						}
+					})
+					.catch((error) => {
+						logToFile("[auto-continue]", "The decision failed:", oneLineError(error));
+						// The decision did not run: the countdown releases the
+						// wait, so the fallback poll can take over again.
+						pendingCountdown.stop();
+					});
+			},
+			isPending: (requestId: string) => {
+				// The wait must still belong to the request: a late tick of
+				// an answered or replaced question must not draw its status
+				// and must not trigger a decision.
+				if (!waitingForUserSince) return false;
+				if (_countdownSessionId !== _piSessionId) return false;
+				const current = sharedState.pqController?.getCurrentQuestion?.();
+				if (!current) return false;
+				return (
+					current.requestId === requestId &&
+					(current.state === "pending" || current.state === "evaluating")
+				);
+			},
+			onStop: (requestId: string | null) => {
+				// The countdown is over: the row is cleared with it, so no
+				// row claims a decision that is not due any more. Only the row
+				// of that countdown is cleared: a row of another state - the
+				// judge continues, for example - belongs to that state, and
+				// the row of a newer question belongs to that question.
+				if (_countdownRowRequestId && requestId && _countdownRowRequestId !== requestId) {
+					return;
+				}
+				_countdownRowRequestId = null;
+				if (_currentAutoContinueState.startsWith("[WAIT]")) {
+					_currentAutoContinueState = "";
+					_setAutoContinueStatus?.(undefined);
+				}
+			},
+			onError: (error: unknown) => {
+				logToFile("[auto-continue]", "The countdown failed:", oneLineError(error));
+			},
+		});
+		sharedState.pendingCountdown = pendingCountdown;
+
 		// Wire shared state for callback handlers
 		sharedState.waitingForUserSince = waitingForUserSince;
 		sharedState.updateAutoContinueStatus = updateAutoContinueStatus;
 
-		// Update auto-continue status in TUI footer
-		function updateAutoContinueStatus(state: keyof typeof AC_STATE_MESSAGES, requestId?: string): void {
-			if (!_setAutoContinueStatus) return;
+		/**
+		 * Start the countdown of a pending question.
+		 *
+		 * The deadline of the decision is derived from the wait that is
+		 * already running, so the displayed deadline and the decision of
+		 * the judge can never drift apart.
+		 */
+		function startPendingCountdown(requestId: string): void {
+			_countdownSessionId = _piSessionId;
+			const startedAt = waitingForUserSince?.getTime() ?? Date.now();
+			pendingCountdown.start(requestId, startedAt);
+		}
+
+		/**
+		 * Start the countdown of the next attempt.
+		 *
+		 * The judge asked to wait longer: the countdown counts down to the
+		 * next attempt instead of to the deadline of the decision.
+		 */
+		function startRecheckCountdown(requestId: string): void {
+			_countdownSessionId = _piSessionId;
+			pendingCountdown.startRecheck(requestId);
+		}
 
+		// Update auto-continue status in TUI footer
+		function updateAutoContinueStatus(
+			state: keyof typeof AC_STATE_MESSAGES,
+			requestId?: string,
+			detail?: string,
+		): void {
 			const message = AC_STATE_MESSAGES[state];
 			if (state === "IDLE") {
-				// Clear status
-				_setAutoContinueStatus(undefined);
-				_currentAutoContinueState = "";
-			} else {
-				const statusText = requestId
-					? `[${AC_STATE[state]}] ${message} | ${requestId}`
-					: `[${AC_STATE[state]}] ${message}`;
-
-				// Only update if state changed (prevent flicker)
-				if (statusText !== _currentAutoContinueState) {
-					_setAutoContinueStatus(statusText);
-					_currentAutoContinueState = statusText;
+				// Only the row is cleared here: the countdown belongs to the
+				// wait, not to the row. A settled continuation must not stop
+				// the countdown of a question that the agent asked in the
+				// same turn, and it must not blank its row either.
+				if (!pendingCountdown.active) {
+					_currentAutoContinueState = "";
+					_setAutoContinueStatus?.(undefined);
 				}
+				return;
+			}
+
+			const parts = [`[${AC_STATE[state]}] ${message}`];
+			if (requestId) parts.push(requestId);
+			if (detail) parts.push(detail);
+			const statusText = parts.join(" | ");
+
+			// Only update if state changed (prevent flicker). The state is
+			// kept even without a UI binding: a session that starts without
+			// a TUI shows the current state as soon as the UI is there.
+			if (statusText !== _currentAutoContinueState) {
+				_currentAutoContinueState = statusText;
+				_setAutoContinueStatus?.(statusText);
 			}
 		}
 
 		// Capture UI context from session_start
 		pi.on("session_start", (_event, ctx) => {
+			// The session of the runtime: the countdown of a question belongs
+			// to the session that asked it.
+			const sessionId = (
+				ctx as { sessionManager?: { getSessionId?: () => string | undefined } }
+			).sessionManager?.getSessionId?.();
+			if (typeof sessionId === "string" && sessionId) {
+				if (_piSessionId && _piSessionId !== sessionId) {
+					// The session changed: the countdown of the old session
+					// is over with it.
+					pendingCountdown.stop();
+				}
+				_piSessionId = sessionId;
+			}
 			if (ctx.hasUI && ctx.ui) {
 				_setAutoContinueStatus = ctx.ui.setStatus.bind(ctx.ui, "harness-auto-continue");
+				// A session without a TUI collected the state already: it is
+				// shown as soon as the UI is there.
+				if (_currentAutoContinueState) {
+					_setAutoContinueStatus(_currentAutoContinueState);
+				}
 			}
 
 		});
@@ -1090,6 +1242,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 				autoContinueTimer = null;
 			}
 
+			// The countdown of the pending question is over with the session.
+			pendingCountdown.stop();
+
 			// Clear UI binding and status
 			if (_setAutoContinueStatus) {
 				_setAutoContinueStatus(undefined);
@@ -1148,6 +1303,8 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 			waitingForUserSince = null;
 			sharedState.waitingForUserSince = null;
 			_lastNotifiedQuestion = "";
+			// The question is answered: the countdown of the wait is over.
+			pendingCountdown.stop();
 			updateAutoContinueStatus("IDLE");
 			// Dispatch answer to Pi
 			const message = answer === "yes" ? "yes" : "not yet";
@@ -1224,8 +1381,10 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 					// Use question.requestId as the jobId for callback matching
 					const questionJobId = question.requestId;
 
-					// Update TUI status - use short ID for display
-					updateAutoContinueStatus("WAITING", questionJobId.slice(0, 8));
+					// The status row counts down to the decision of the judge.
+					// The countdown is bound to this request, so a newer
+					// question replaces it.
+					startPendingCountdown(questionJobId);
 
 				// Get task context for additional info
 				const taskContext = await getTaskContext().catch(() => ({ total: 0, completed: 0, remaining: [] as string[] }));
@@ -1388,6 +1547,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 				if (waitingForUserSince) {
 					waitingForUserSince = null;
 					_lastNotifiedQuestion = "";
+					// The user answered in Pi: the countdown of the wait is
+					// over with it.
+					pendingCountdown.stop();
 					updateAutoContinueStatus("IDLE");
 					// Cancel pending question on user response
 					// (User answered via Pi instead of button)
@@ -1397,18 +1559,22 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		});
 
 		// Periodic check for auto-continue decision
-		const AUTO_CONTINUE_INTERVAL_MS = 60 * 1000; // Check every 1 minute
-		const MIN_WAIT_MINUTES = 5; // Minimum wait before auto-continue
-		const MAX_WAIT_MINUTES = 30; // After this the work pauses instead of waiting
 
-		const checkAndAutoContinue = async () => {
+		const checkAndAutoContinue = async (source: "countdown" | "poll" = "poll") => {
 			// Prevent overlap if inference is already in progress
 			if (_inferenceInProgress) {
+				// A deadline that was blocked is armed again by the caller of
+				// the countdown, so the decision is not lost.
 				return;
 			}
 
 			if (!waitingForUserSince) return;
 
+			// The countdown owns the wait while it runs: the fallback poll
+			// only takes over when there is no countdown, so the decision is
+			// never started twice.
+			if (source === "poll" && pendingCountdown.active) return;
+
 			// Capture session ID at check time for post-inference validation
 			const checkSessionId = _sessionId;
 			// Use same hash algorithm as detection
@@ -1470,6 +1636,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 				if (taskContext.total === 0 && !hasPendingQuestion) {
 					logToFile("[auto-continue]", "No tasks and no pending questions, skipping auto-continue check");
 					_inferenceInProgress = false;
+					// The countdown is over: the fallback poll takes over the
+					// next attempt.
+					pendingCountdown.stop();
 					return;
 				}
 
@@ -1624,15 +1793,20 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 						if (waitBelongsToRequest(questionContext?.requestId)) {
 							waitingForUserSince = null;
 							sharedState.waitingForUserSince = null;
+							// The request expired: the countdown of the wait
+							// is over with it.
+							pendingCountdown.stop();
 							updateAutoContinueStatus("IDLE");
 						}
 					} else {
-						// The request stays open: the next poll asks again
-						// until the deadline closes it.
-						updateAutoContinueStatus(
-							"WAITING",
-							questionContext?.requestId.slice(0, 8),
-						);
+						// The request stays open: the countdown counts down to
+						// the next check, so the retry does not wait for the
+						// fallback poll.
+						if (questionContext?.requestId) {
+							startRecheckCountdown(questionContext.requestId);
+						} else {
+							updateAutoContinueStatus("WAITING");
+						}
 					}
 				} else {
 					// Close the question with the Jev decision. The buttons of
@@ -1669,6 +1843,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 							waitingForUserSince = null;
 							sharedState.waitingForUserSince = null;
 							_lastNotifiedQuestion = "";
+							// The stale decision is discarded: the countdown
+							// of the wait is over with it.
+							pendingCountdown.stop();
 							updateAutoContinueStatus("IDLE");
 						} else {
 							logToFile(
@@ -1692,6 +1869,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 							waitingForUserSince = null;
 							sharedState.waitingForUserSince = null;
 							_lastNotifiedQuestion = "";
+							// The work pauses for a human: the countdown of
+							// the wait is over with it.
+							pendingCountdown.stop();
 							updateAutoContinueStatus("IDLE");
 						}
 						return;
@@ -1725,6 +1905,8 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 					waitingForUserSince = null;
 					sharedState.waitingForUserSince = null;
 					_lastNotifiedQuestion = "";
+					// The question is closed: the countdown of the wait is over.
+					pendingCountdown.stop();
 
 					// The status stays "RUN" until the turn that the steer
 					// started has settled. A timer would clear it while the
@@ -1735,6 +1917,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 				_inferenceInProgress = false;
 			} catch {
 				_inferenceInProgress = false;
+				// The countdown is over: the fallback poll takes over the next
+				// attempt.
+				pendingCountdown.stop();
 				updateAutoContinueStatus("ERROR");
 				addHarnessMessage("Jev", "auto-continue evaluation failed", "err", [
 					"How to fix: Check logs at /tmp/pi-harness.log for API errors",
@@ -2108,7 +2293,10 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		});
 
 		// Start periodic check
-		autoContinueTimer = setInterval(checkAndAutoContinue, AUTO_CONTINUE_INTERVAL_MS);
+		autoContinueTimer = setInterval(
+			() => checkAndAutoContinue("poll"),
+			AUTO_CONTINUE_INTERVAL_MS,
+		);
 		if (jevKeyMissing) {
 			// Without a provider the health check cannot run. The missing-key
 			// message (with its fix commands) stays the visible one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/agent-policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/agent-policy",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Agent policy runtime for pi-harness - enforces mandatory rule delivery and mutation gating",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/checkpoint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/checkpoint",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Enhanced checkpoint system with incremental snapshots, diff-based storage, and recovery strategies",
   "type": "module",
   "main": "./dist/index.js",

package/packages/clipboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/codex-watcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/codex-watcher",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Watches Codex CLI sessions and emits visible messages for PING-PONG monitoring",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/config-capture/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/config-capture",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Auto-capture API-fetched configuration values to AGENTS.md",
   "type": "module",
   "main": "src/index.ts",

package/packages/contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/contracts",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "description": "RPC schema definitions for pi-harness runtime",
   "main": "./dist/index.js",

package/packages/cookie-sanitizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/cookie-sanitizer",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — cookie sanitizer (provider-quota cookie file normaliser)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/evaluation-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/evaluation-engine",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Evaluation engine for pi-harness runtime (RFC-0057)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/event-bus/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/event-bus",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/event-store/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/event-store",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/experience-replay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/experience-replay",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Experience replay for debugging and reproducibility (RFC-0059)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/file-copy-helper/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/file-copy-helper",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Injects cp/sudo cp rule when user asks to mimic/copy files",
   "type": "module",
   "main": "dist/index.js",

package/packages/intent-analyzer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/intent-analyzer",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/jev-judge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/jev-judge",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Jev Judge - Structured decision model for agent routing, E2E testing, and automated decisions",
   "type": "module",
   "main": "./dist/index.js",

package/packages/knowledge-retrieval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/knowledge-retrieval",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Knowledge retrieval via TencentDB-Agent-Memory MCP (RFC-0105)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/learning-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/learning-engine",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Learning engine for extracting lessons from runtime execution (RFC-0058)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/logging/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/logging",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "description": "Centralized structured application logging with buffered Cloudflare R2 and webhook transports",
   "main": "./dist/index.js",

package/packages/memory-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/memory-engine",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Memory engine with OKF integration for durable knowledge management (RFC-0060)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/notification/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/notification",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — notification",
   "type": "module",
   "main": "./dist/index.js",

package/packages/paperclip-integration/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/paperclip-integration",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Paperclip API integration: poll agent inbox, route tasks to pi.dev, Telegram alerts",
   "type": "module",
   "main": "./dist/index.js",

package/packages/performance-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/performance-optimizer",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Performance optimization analyzer for pi-harness runtime (RFC-0056)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/privilege-broker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/privilege-broker",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Privilege Broker — capability registry and command executor for autonomous runtime (RFC-0101 §7)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/prompt-compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/prompt-compiler",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Deterministic prompt compiler for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/providers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/providers",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — providers",
   "type": "module",
   "main": "./dist/index.js",

package/packages/qdrant-skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/qdrant-skills",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Qdrant vector search integration for Hermes-style skill system",
   "type": "module",
   "main": "./dist/index.js",

package/packages/quota-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/quota-manager",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — quota-manager",
   "type": "module",
   "main": "./dist/index.js",

package/packages/relay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/relay",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "type": "module",
   "description": "Cloud relay for remote access - T3 Connect style for pi-harness",
   "main": "./dist/index.js",

package/packages/skill-mcp-client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/skill-mcp-client",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "MCP client for Skills SaaS backend",
   "type": "module",
   "main": "./dist/index.js",

package/packages/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/skills",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "File-based skill system with pi.dev compatibility and Hermes self-improvement",
   "type": "module",
   "main": "src/index.ts",

package/packages/todo-bd-sync/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/todo-bd-sync",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Two-way sync between rpiv-todo overlay and bd issue tracker",
   "type": "module",
   "main": "src/index.ts",

package/packages/token-estimation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-estimation",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — token-estimation",
   "type": "module",
   "main": "./dist/index.js",

package/packages/tooling-preference/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tooling-preference",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — JS/TS tooling preference (Biome vs ESLint/Prettier) proposal",
   "type": "module",
   "main": "./dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/trajectory",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Trajectory capture for the write-review loop — persists cycle records for learning",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tui",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — tui",
   "type": "module",
   "main": "./dist/index.js",

package/packages/two-phase-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/two-phase-review",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "pi-harness-runtime — two-phase implementation and review workflow (queue review signals, gate the phase, scope the diff)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/types",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Shared TypeScript types for pi-harness-runtime packages",
   "type": "module",
   "main": "./dist/index.js",

package/packages/webmcp-tester/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/webmcp-tester",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "WebMCP-powered E2E testing for pi-harness - natural language test scenarios",
   "type": "module",
   "main": "./dist/index.js",

package/packages/wiki/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/wiki",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "LLM Wiki integration for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/write-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/write-review",
-  "version": "1.1.459",
+  "version": "1.1.460",
   "description": "Two-agent write-review loop with blackboard coordination",
   "type": "module",
   "main": "src/index.ts",