pi-goal-x 0.29.0 → 0.30.0

package/extensions/goal-events.ts

@@ -6,6 +6,7 @@ import {
 	goalEventMessageId,
 	hasAbortedAssistantMessage,
 	hasErrorAssistantMessage,
+	hasNetworkErrorAssistantMessage,
 	isAbortedAssistantMessage,
 	isErrorAssistantMessage,
 	isMeaningfulProgressToolCall,
@@ -92,6 +93,7 @@ export function compactGoalCheckpointContext(
 export function registerGoalEvents(core: GoalCore): void {
 	const { pi } = core;
 	let continuationAfterSettleFor: string | null = null;
+	let networkErrorRecoveryAfterSettleFor: string | null = null;
 
 	pi.on("context", async (event) => {
 		const messages = compactGoalCheckpointContext(event.messages, core.state.goal);
@@ -355,7 +357,10 @@ export function registerGoalEvents(core: GoalCore): void {
 			// evaluating whether the checkpoint is actionable.
 			core.reconcileFocusedGoalFromDisk(ctx);
 			core.runtime.setCheckpoint(incomingGoalId);
-			core.clearContinuationState();
+			// This can be the hidden checkpoint dispatched by the network-error
+			// timer. Clear ordinary continuation bookkeeping but retain the
+			// consecutive recovery count for a later failed retry.
+			core.clearContinuationState(false);
 			if (!core.isActionableContinuationGoal(incomingGoalId)) {
 				try {
 					ctx.abort?.();
@@ -372,6 +377,7 @@ export function registerGoalEvents(core: GoalCore): void {
 			// autoContinue nudge state so the user always gets a fresh chain.
 			core.runtime.setCheckpoint(null);
 			core.clearContinuationState();
+			networkErrorRecoveryAfterSettleFor = null;
 		}
 
 		if (!core.state.goal) {
@@ -471,6 +477,7 @@ export function registerGoalEvents(core: GoalCore): void {
 		const endedGoalId = core.runningGoalId;
 		core.runningGoalId = null;
 		continuationAfterSettleFor = null;
+		networkErrorRecoveryAfterSettleFor = null;
 
 		// Account for any tokens from aborted in-flight assistant messages so
 		// they are not silently lost (but charge them to the original goal).
@@ -481,7 +488,9 @@ export function registerGoalEvents(core: GoalCore): void {
 			core.accountProgress(ctx, { completedTurnTokens: abortedTokens });
 		}
 
-		core.runtime.clearContinuationState();
+		// Keep any prior recovery attempt while Pi finishes its own automatic
+		// retries. A user-driven path resets it through the default argument.
+		core.runtime.clearContinuationState(false);
 		if (!core.state.goal || core.state.goal.status !== "active" || !core.state.goal.autoContinue) return;
 		if (endedGoalId && core.state.goal.id !== endedGoalId) return;
 		if (!core.reconcileFocusedGoalFromDisk(ctx)) return;
@@ -492,11 +501,18 @@ export function registerGoalEvents(core: GoalCore): void {
 		// Provider failures are not completed work: persist and refresh the
 		// display, but never queue a continuation for a run whose messages
 		// include an assistant error (danim47c pattern).
+		if (hasNetworkErrorAssistantMessage(event.messages)) {
+			core.persist(ctx);
+			core.updateUI(ctx);
+			networkErrorRecoveryAfterSettleFor = core.state.goal.id;
+			return;
+		}
 		if (hasErrorAssistantMessage(event.messages)) {
 			core.persist(ctx);
 			core.updateUI(ctx);
 			return;
 		}
+		core.runtime.clearNetworkErrorBackoff();
 		core.persist(ctx);
 		core.updateUI(ctx);
 		// agent_end runs before pi finishes retries, compaction, terminating-tool
@@ -510,14 +526,32 @@ export function registerGoalEvents(core: GoalCore): void {
 	pi.on("agent_settled", async (_event, ctx) => {
 		const goalId = continuationAfterSettleFor;
 		continuationAfterSettleFor = null;
-		if (!goalId || !core.isActionableContinuationGoal(goalId)) return;
-		core.queueContinuation(ctx, true);
+		const networkErrorGoalId = networkErrorRecoveryAfterSettleFor;
+		networkErrorRecoveryAfterSettleFor = null;
+		if (goalId && core.isActionableContinuationGoal(goalId)) {
+			core.queueContinuation(ctx, true);
+			return;
+		}
+		if (!networkErrorGoalId || !core.isActionableContinuationGoal(networkErrorGoalId)) return;
+		const plan = core.runtime.scheduleNetworkErrorRetry(ctx, core.state.goal!);
+		if (plan) {
+			ctx.ui.notify(
+				`Provider network error. Retrying the goal in ${Math.round(plan.delayMs / 1000)}s (recovery ${plan.attempt}/${plan.maxAttempts}).`,
+				"warning",
+			);
+			return;
+		}
+		ctx.ui.notify(
+			"Provider network errors persisted after all recovery attempts. The goal remains active; resume it when the provider is healthy.",
+			"warning",
+		);
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
 		continuationAfterSettleFor = null;
+		networkErrorRecoveryAfterSettleFor = null;
 		core.accountProgress(ctx);
-		core.clearContinuationTimer();
+		core.clearContinuationState();
 		core.terminalInputUnsubscribe?.();
 		core.terminalInputUnsubscribe = null;
 		if (core.state.goal) core.persist(ctx);

package/extensions/goal-format.ts

@@ -226,6 +226,16 @@ export function isErrorAssistantMessage(message: unknown): boolean {
 	return raw?.role === "assistant" && raw.stopReason === "error";
 }
 
+/** A provider-declared network failure is safe for the bounded goal backoff. */
+export function isNetworkErrorAssistantMessage(message: unknown): boolean {
+	if (!isErrorAssistantMessage(message)) return false;
+	const raw = asRecord(message);
+	const details = [raw?.rawStopReason, raw?.errorMessage]
+		.filter((value): value is string => typeof value === "string")
+		.join(" ");
+	return /\bnetwork[_\s-]?error\b/i.test(details);
+}
+
 export function isToolUseAssistantMessage(message: unknown): boolean {
 	const raw = asRecord(message);
 	return raw?.role === "assistant" && raw.stopReason === "toolUse";
@@ -239,6 +249,10 @@ export function hasErrorAssistantMessage(messages: unknown[]): boolean {
 	return messages.some(isErrorAssistantMessage);
 }
 
+export function hasNetworkErrorAssistantMessage(messages: unknown[]): boolean {
+	return messages.some(isNetworkErrorAssistantMessage);
+}
+
 export function usageChannelTokens(value: unknown): number {
 	if (typeof value !== "number" || !Number.isFinite(value)) return 0;
 	return Math.max(0, Math.trunc(value));

package/extensions/goal-runtime.ts

@@ -12,6 +12,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { GoalCheckpointDetailsV2, GoalRecord } from "./goal-record.ts";
 import { checkpointTriggerPrompt } from "./prompts/goal-prompts.ts";
 import { POST_STOP_ALLOWED_TOOLS } from "./goal-tool-names.ts";
+import { networkErrorBackoffPlan, type NetworkErrorBackoffPlan } from "./network-error-backoff.ts";
 
 export const CONTINUATION_IDLE_RETRY_MS = 50;
 
@@ -31,6 +32,9 @@ export class GoalRuntime {
 	private continuationQueuedFor: string | null = null;
 	private continuationScheduledFor: string | null = null;
 	private continuationTimer: ReturnType<typeof setTimeout> | null = null;
+	private networkErrorRetryGoalId: string | null = null;
+	private networkErrorRetryAttempt = 0;
+	private networkErrorRetryTimer: ReturnType<typeof setTimeout> | null = null;
 
 	// ── turn-stop guard ──────────────────────────────────────────────────
 	private turnSeq = 0;
@@ -54,9 +58,10 @@ export class GoalRuntime {
 
 	// ── continuation scheduling ──────────────────────────────────────────
 
-	clearContinuationState(): void {
+	clearContinuationState(resetNetworkErrorBackoff = true): void {
 		this.clearContinuationTimer();
 		this.continuationQueuedFor = null;
+		if (resetNetworkErrorBackoff) this.clearNetworkErrorBackoff();
 	}
 
 	/** Clear the pending timer but keep the queued marker (used at session shutdown). */
@@ -98,6 +103,40 @@ export class GoalRuntime {
 	cancelContinuationFor(goalId: string): void {
 		if (this.continuationQueuedFor === goalId) this.continuationQueuedFor = null;
 		if (this.continuationScheduledFor === goalId) this.clearContinuationState();
+		if (this.networkErrorRetryGoalId === goalId) this.clearNetworkErrorBackoff();
+	}
+
+	/**
+	 * Schedule the next bounded recovery after Pi's built-in provider retries
+	 * have failed. The counter stays in memory and is cleared on a successful
+	 * turn or any user-owned cancellation path.
+	 */
+	scheduleNetworkErrorRetry(ctx: ExtensionContext, goal: GoalRecord): NetworkErrorBackoffPlan | null {
+		if (goal.status !== "active" || !goal.autoContinue || this.networkErrorRetryTimer) return null;
+		if (this.networkErrorRetryGoalId !== goal.id) {
+			this.networkErrorRetryGoalId = goal.id;
+			this.networkErrorRetryAttempt = 0;
+		}
+		const plan = networkErrorBackoffPlan(this.networkErrorRetryAttempt + 1);
+		if (!plan) return null;
+		this.networkErrorRetryAttempt = plan.attempt;
+		this.networkErrorRetryTimer = setTimeout(() => {
+			this.networkErrorRetryTimer = null;
+			if (!this.hooks.isActionable(goal.id)) return;
+			const currentGoal = this.hooks.getGoal();
+			if (!currentGoal || currentGoal.id !== goal.id) return;
+			this.queueContinuation(ctx, currentGoal, true);
+		}, plan.delayMs);
+		this.networkErrorRetryTimer.unref?.();
+		return plan;
+	}
+
+	/** Cancel and forget all goal-level network-error recovery state. */
+	clearNetworkErrorBackoff(): void {
+		if (this.networkErrorRetryTimer) clearTimeout(this.networkErrorRetryTimer);
+		this.networkErrorRetryTimer = null;
+		this.networkErrorRetryGoalId = null;
+		this.networkErrorRetryAttempt = 0;
 	}
 
 	/**

package/extensions/goal-state.ts

@@ -90,7 +90,7 @@ export interface GoalCore {
 	stopAuditAnimation(): void;
 	abortAudit(ctx: ExtensionContext): void;
 	clearContinuationTimer(): void;
-	clearContinuationState(): void;
+	clearContinuationState(resetNetworkErrorBackoff?: boolean): void;
 	clearActiveAccounting(): void;
 	advanceTurnSeq(): void;
 	currentTurnStoppedGoalId(): string | null;
@@ -357,8 +357,8 @@ export function createGoalCore(
 		runtime.clearContinuationTimer();
 	}
 
-	function clearContinuationState(): void {
-		runtime.clearContinuationState();
+	function clearContinuationState(resetNetworkErrorBackoff = true): void {
+		runtime.clearContinuationState(resetNetworkErrorBackoff);
 	}
 
 	function clearActiveAccounting(): void {

package/extensions/network-error-backoff.ts

@@ -0,0 +1,25 @@
+/**
+ * Bounded, goal-level recovery after Pi has exhausted its provider retries.
+ *
+ * Pi owns the immediate request retries. These longer delays are deliberately
+ * small in number and only apply to terminal `network_error` failures, so an
+ * unavailable provider never becomes an unbounded auto-continue loop.
+ */
+
+export const NETWORK_ERROR_BACKOFF_DELAYS_MS = [5_000, 10_000, 20_000, 40_000, 80_000] as const;
+
+export interface NetworkErrorBackoffPlan {
+	attempt: number;
+	maxAttempts: number;
+	delayMs: number;
+}
+
+/** Return the recovery plan for a one-based attempt, or undefined after the cap. */
+export function networkErrorBackoffPlan(attempt: number): NetworkErrorBackoffPlan | undefined {
+	if (!Number.isInteger(attempt) || attempt < 1 || attempt > NETWORK_ERROR_BACKOFF_DELAYS_MS.length) return undefined;
+	return {
+		attempt,
+		maxAttempts: NETWORK_ERROR_BACKOFF_DELAYS_MS.length,
+		delayMs: NETWORK_ERROR_BACKOFF_DELAYS_MS[attempt - 1]!,
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Goal mode extension for pi: durable long-running objectives, five model tools, structured tasks, independent completion audit, Sisyphus mode, auto-continue, and a status overlay.",
   "license": "MIT",
   "author": "pi-goal-x contributors",