pi-long-task 0.5.0 → 0.7.0

package/src/goal_discovery.ts

@@ -13,6 +13,7 @@ import {
 } from "./goal_spec.ts";
 import type { GoalLoopState } from "./goal_loop.ts";
 import type { GoalStateStore } from "./goal_state.ts";
+import type { NetworkRecoveryConfig } from "./network_recovery_config.ts";
 
 export type GoalDiscoveryEntrypoint = "pi_goal_task" | "pi_long_task";
 export type GoalDiscoveryRoute = "discovery" | "direct";
@@ -41,6 +42,7 @@ export interface GoalDiscoveryRunnerOptions {
   model?: unknown;
   modelName?: string;
   thinkingLevel?: string;
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
   now: () => Date;
 }
 

package/src/goal_loop.ts

@@ -92,6 +92,13 @@ export interface GoalWorkerResultState {
 
 export type GoalReviewerDecision = "complete" | "incomplete" | "blocked" | "failed";
 
+export interface GoalReviewerRecoveryState {
+  interruptions: number;
+  evidencePaths: string[];
+  reviewerCostTotal: number;
+  updatedAt: string;
+}
+
 export interface GoalReviewerResultState {
   decision: GoalReviewerDecision;
   complete: boolean;
@@ -130,6 +137,7 @@ export interface GoalIterationState {
   deadlineAt?: string;
   generatedTodo?: GeneratedTodoState;
   workerResult?: GoalWorkerResultState;
+  reviewerRecovery?: GoalReviewerRecoveryState;
   reviewerResult?: GoalReviewerResultState;
   completion?: GoalCompletionState;
 }
@@ -402,6 +410,70 @@ export function recordReviewerResult(
   });
 }
 
+export function excludeNetworkOutageFromGoalDeadlines(
+  state: GoalLoopState,
+  outageMs: number,
+  operation: "planner" | "reviewer",
+  options: { now?: Date } = {},
+): GoalLoopState {
+  if (!Number.isFinite(outageMs) || outageMs <= 0 || isTerminalGoalLoopStatus(state.status)) {
+    return state;
+  }
+
+  const excludedMs = Math.ceil(outageMs);
+  const timestamp = (options.now ?? new Date()).toISOString();
+  const iterations = state.iterations.map((iteration) =>
+    iteration.iteration === state.currentIteration && iteration.deadlineAt
+      ? { ...iteration, deadlineAt: shiftTimestamp(iteration.deadlineAt, excludedMs), updatedAt: timestamp }
+      : iteration,
+  );
+  return withTrace(
+    {
+      ...state,
+      deadlineAt: state.deadlineAt ? shiftTimestamp(state.deadlineAt, excludedMs) : undefined,
+      iterations,
+      updatedAt: timestamp,
+    },
+    {
+      timestamp,
+      phase: state.phase,
+      event: "network_wait_excluded",
+      message: `Excluded ${excludedMs}ms of ${operation} network recovery from goal-loop deadlines.`,
+      iteration: state.currentIteration || undefined,
+      details: { operation, outageMs: excludedMs },
+    },
+  );
+}
+
+export function recordReviewerRecoveryEvidence(
+  state: GoalLoopState,
+  iterationNumber: number,
+  recovery: Omit<GoalReviewerRecoveryState, "updatedAt">,
+  options: { now?: Date } = {},
+): GoalLoopState {
+  const timestamp = (options.now ?? new Date()).toISOString();
+  return updateIteration(state, iterationNumber, ["todo_executed", "failed"], timestamp, (item) => ({
+    item: {
+      ...item,
+      updatedAt: timestamp,
+      reviewerRecovery: { ...recovery, evidencePaths: [...recovery.evidencePaths], updatedAt: timestamp },
+    },
+    phase: state.phase,
+    trace: {
+      timestamp,
+      phase: state.phase,
+      event: "reviewer_network_interrupted",
+      message: `Preserved ${recovery.interruptions} interrupted reviewer call(s) during network recovery.`,
+      iteration: iterationNumber,
+      details: {
+        interruptions: recovery.interruptions,
+        evidencePaths: recovery.evidencePaths,
+        reviewerCostTotal: recovery.reviewerCostTotal,
+      },
+    },
+  }));
+}
+
 export function failGoalLoop(
   state: GoalLoopState,
   reason: string,
@@ -597,6 +669,10 @@ function withTrace(state: GoalLoopState, event: GoalLoopTraceEvent): GoalLoopSta
   return { ...state, trace: [...state.trace, event] };
 }
 
+function shiftTimestamp(timestamp: string, deltaMs: number): string {
+  return new Date(Date.parse(timestamp) + deltaMs).toISOString();
+}
+
 function positiveInteger(value: number | undefined, fallback: number): number {
   return optionalPositiveInteger(value) ?? fallback;
 }

package/src/goal_orchestrator.ts

@@ -20,6 +20,17 @@ import {
 } from "./goal_loop.ts";
 import { GoalStateStore } from "./goal_state.ts";
 import type { GoalSpecification } from "./goal_spec.ts";
+import {
+  formatNetworkRecoveryStatus,
+  type NetworkRecoveryEvent,
+  type NetworkRecoveryEventType,
+} from "./network_recovery.ts";
+import {
+  resolveNetworkRecoveryConfig,
+  type NetworkRecoveryConfig,
+  type NetworkRecoveryConfigInput,
+} from "./network_recovery_config.ts";
+import { validatePlannerGracefulShutdownMs, validatePlannerTimeoutMs } from "./planner_config.ts";
 import { runGoalReviewSession, type GoalReviewResult, type GoalReviewerRunner } from "./goal_review.ts";
 import {
   runGoalTodoExecutionLongTask,
@@ -43,6 +54,7 @@ export type GoalLoopProgressPhase =
   | "todo_executed"
   | "review_start"
   | "reviewed"
+  | "network_wait"
   | "complete";
 
 export interface GoalLoopProgressUpdate {
@@ -70,6 +82,12 @@ export interface GoalLoopProgressUpdate {
   reviewerCostTotal: number;
   totalCost: number;
   childProgress?: CoordinatorProgressUpdate;
+  networkRecoveryEvent?: NetworkRecoveryEventType;
+  networkRetryCount?: number;
+  networkOutageElapsedMs?: number;
+  networkNextRetryAtMs?: number;
+  networkNextRetryInMs?: number;
+  networkFailureReason?: string;
 }
 
 export type GoalLoopProgressHandler = (update: GoalLoopProgressUpdate) => void;
@@ -92,10 +110,14 @@ export interface RunGoalLoopOptions extends GoalLoopLimitInput {
   thinkingLevel?: string;
   maxBashTimeoutMs?: number;
   maxAttemptsPerTask?: number;
+  todoTimeoutMs?: number;
+  todoGracefulShutdownMs?: number;
+  networkRecovery?: NetworkRecoveryConfigInput;
   commit?: boolean;
   now?: () => Date;
   onWorkerProgress?: (update: CoordinatorProgressUpdate) => void;
   onProgress?: GoalLoopProgressHandler;
+  onNetworkRecovery?: (event: NetworkRecoveryEvent) => void;
 }
 
 export interface GoalLoopRunResult {
@@ -120,6 +142,9 @@ export class GoalLoopOrchestratorError extends Error {
 
 export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoopRunResult> {
   const now = options.now ?? (() => new Date());
+  const networkRecovery = resolveNetworkRecoveryConfig(options.networkRecovery);
+  const todoTimeoutMs = validatePlannerTimeoutMs(options.todoTimeoutMs);
+  const todoGracefulShutdownMs = validatePlannerGracefulShutdownMs(options.todoGracefulShutdownMs);
   let state =
     options.initialState ??
     createGoalLoopState({
@@ -149,7 +174,9 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
   await store.saveState(state);
   await store.initializeResultIfMissing(state);
   await store.appendNewTraceEvents(await store.durableTraceLength(), state);
+  let progressClosed = false;
   const publish = (phase: GoalLoopProgressPhase, message: string, extra: Partial<GoalLoopProgressUpdate> = {}) => {
+    if (progressClosed) return;
     options.onProgress?.({
       message,
       phase,
@@ -173,6 +200,39 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
       ...extra,
     });
   };
+  const recoveryProgress = (
+    restorePhase: GoalLoopProgressPhase,
+    restoreMessage: string,
+    extra: Partial<GoalLoopProgressUpdate> = {},
+  ) => {
+    let cleaned = false;
+    return (event: NetworkRecoveryEvent) => {
+      options.onNetworkRecovery?.(event);
+      if (cleaned || progressClosed) return;
+      if (event.type === "cleanup") {
+        cleaned = true;
+        return;
+      }
+      if (event.type === "recovered") {
+        publish(restorePhase, restoreMessage, extra);
+        return;
+      }
+      if (isTerminalNetworkRecoveryProgressEvent(event.type)) return;
+
+      const nowMs = event.state.outageStartedAtMs + event.state.elapsedMs;
+      const message = formatNetworkRecoveryStatus(event);
+      publish("network_wait", message, {
+        ...extra,
+        networkRecoveryEvent: event.type,
+        networkRetryCount: event.state.retryCount,
+        networkOutageElapsedMs: event.state.elapsedMs,
+        networkNextRetryAtMs: event.state.nextRetryAtMs,
+        networkNextRetryInMs:
+          event.state.nextRetryAtMs === undefined ? undefined : Math.max(0, event.state.nextRetryAtMs - nowMs),
+        networkFailureReason: event.state.lastFailure.reason,
+      });
+    };
+  };
 
   publish("goal_start", `Starting goal loop: ${state.goal}`);
 
@@ -186,6 +246,7 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
         options,
         now,
         publish,
+        networkRecovery,
       });
     }
 
@@ -226,8 +287,16 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
           modelName: options.modelName,
           thinkingLevel: options.thinkingLevel,
           maxBashTimeoutMs: options.maxBashTimeoutMs,
+          todoTimeoutMs,
+          todoGracefulShutdownMs,
+          networkRecovery,
           now,
           goalSpecification,
+          onNetworkRecovery: recoveryProgress(
+            "todo_generation_start",
+            `Goal iteration ${nextIteration}: generating TODO markdown.`,
+            { iteration: nextIteration },
+          ),
         });
         generationResults.push(generation);
         state = generation.state;
@@ -251,8 +320,16 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
           modelName: options.modelName,
           thinkingLevel: options.thinkingLevel,
           maxBashTimeoutMs: options.maxBashTimeoutMs,
+          todoTimeoutMs,
+          todoGracefulShutdownMs,
+          networkRecovery,
           now,
           goalSpecification,
+          onNetworkRecovery: recoveryProgress(
+            "todo_generation_start",
+            `Goal iteration ${current.iteration}: resuming TODO generation.`,
+            { iteration: current.iteration },
+          ),
         });
         generationResults.push(generation);
         state = generation.state;
@@ -278,6 +355,9 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
             thinkingLevel: options.thinkingLevel,
             maxBashTimeoutMs: options.maxBashTimeoutMs,
             maxAttemptsPerTask: options.maxAttemptsPerTask,
+            todoTimeoutMs,
+            todoGracefulShutdownMs,
+            networkRecovery,
             commit: options.commit,
             now,
             onProgress: (update) => {
@@ -324,7 +404,13 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
           thinkingLevel: options.thinkingLevel,
           now,
           goalSpecification,
+          networkRecovery,
           timeoutMs: remainingReviewTimeout(state, current.deadlineAt, now()),
+          onNetworkRecovery: recoveryProgress(
+            "review_start",
+            `Goal iteration ${current.iteration}: reviewing goal completion.`,
+            { iteration: current.iteration },
+          ),
         });
         reviewResults.push(review);
         state = review.state;
@@ -365,6 +451,7 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
   }
 
   publish("complete", `Goal loop ${state.status}: ${state.completion?.reason ?? "finished"}`);
+  progressClosed = true;
 
   return {
     state,
@@ -385,6 +472,7 @@ async function maybeRunGoalDiscovery(options: {
   options: RunGoalLoopOptions;
   now: () => Date;
   publish: (phase: GoalLoopProgressPhase, message: string, extra?: Partial<GoalLoopProgressUpdate>) => void;
+  networkRecovery: Readonly<NetworkRecoveryConfig>;
 }): Promise<GoalSpecification | undefined> {
   if (options.discoveryDecision.route !== "discovery") {
     return options.existingSpecification;
@@ -407,6 +495,7 @@ async function maybeRunGoalDiscovery(options: {
       model: options.options.model,
       modelName: options.options.modelName,
       thinkingLevel: options.options.thinkingLevel,
+      networkRecovery: options.networkRecovery,
       now: options.now,
     });
     await options.store.saveGoalSpecification(spec);
@@ -467,7 +556,11 @@ function accumulatedWorkerCost(state: GoalLoopState): number {
 }
 
 function accumulatedReviewerCost(state: GoalLoopState): number {
-  return sumFinite(state.iterations.map((iteration) => iteration.reviewerResult?.reviewerCostTotal));
+  return sumFinite(
+    state.iterations.map(
+      (iteration) => iteration.reviewerResult?.reviewerCostTotal ?? iteration.reviewerRecovery?.reviewerCostTotal,
+    ),
+  );
 }
 
 function sumFinite(values: Array<number | undefined>): number {
@@ -477,6 +570,10 @@ function sumFinite(values: Array<number | undefined>): number {
   );
 }
 
+function isTerminalNetworkRecoveryProgressEvent(type: NetworkRecoveryEventType): boolean {
+  return type === "failed" || type === "cancelled" || type === "outage_expired";
+}
+
 function requiredGoal(goal: string | undefined): string {
   const trimmed = goal?.trim();
   if (!trimmed) {

package/src/goal_review.ts

@@ -3,18 +3,22 @@ import path from "node:path";
 
 import {
   cancelGoalLoop,
+  excludeNetworkOutageFromGoalDeadlines,
   type GoalIterationState,
   type GoalLoopState,
   type GoalReviewerDecision,
   type GoalReviewerResultState,
+  recordReviewerRecoveryEvidence,
   recordReviewerResult,
 } from "./goal_loop.ts";
 import { GoalStateStore } from "./goal_state.ts";
 import { runGuardedSessionPrompt } from "./session_guard.ts";
 import { goalSpecificationToMarkdown, type GoalSpecification } from "./goal_spec.ts";
+import { classifyNetworkFailure } from "./network_failure.ts";
+import { recoverNetworkOperation, type NetworkRecoveryEvent } from "./network_recovery.ts";
+import type { NetworkRecoveryConfig } from "./network_recovery_config.ts";
 import {
   createIsolatedWorkerSession,
-  DEFAULT_WORKER_TOOLS,
   workerUsageCostFromEvent,
   workerUsageCostFromStats,
   workerUsageCostKeyFromEvent,
@@ -23,6 +27,8 @@ import {
 
 export const GOAL_REVIEW_PAYLOAD_FILE = "REVIEW_TASK.md";
 export const GOAL_REVIEW_RAW_FILE = "REVIEW_RESULT_RAW.txt";
+/** Reviewer retries are constrained to inspection and read-only verification. */
+export const GOAL_REVIEWER_TOOLS = ["read", "bash", "grep", "find", "ls"] as const;
 
 export interface GoalReviewOptions {
   state: GoalLoopState;
@@ -36,7 +42,9 @@ export interface GoalReviewOptions {
   now?: () => Date;
   sessionFactory?: WorkerSessionFactory;
   goalSpecification?: GoalSpecification;
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
   timeoutMs?: number;
+  onNetworkRecovery?: (event: NetworkRecoveryEvent) => void;
 }
 
 export interface GoalReviewResult {
@@ -59,6 +67,7 @@ export interface GoalReviewerRunnerOptions {
   modelName?: string;
   thinkingLevel?: string;
   sessionFactory?: WorkerSessionFactory;
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
 }
 
 export interface GoalReviewerSessionResult {
@@ -69,6 +78,8 @@ export interface GoalReviewerSessionResult {
   timedOut?: boolean;
   aborted?: boolean;
   error?: string;
+  /** Untouched provider/transport failure retained for coordinator recovery classification. */
+  failure?: unknown;
 }
 
 export type GoalReviewerRunner = (options: GoalReviewerRunnerOptions) => Promise<GoalReviewerSessionResult>;
@@ -91,7 +102,7 @@ export class GoalReviewError extends Error {
 export async function runGoalReviewSession(options: GoalReviewOptions): Promise<GoalReviewResult> {
   const now = options.now ?? (() => new Date());
   let state = options.state;
-  const previousTraceLength = state.trace.length;
+  let previousTraceLength = state.trace.length;
   const store =
     options.store ?? new GoalStateStore({ cwd: options.cwd, goalRunId: state.goalRunId, goalRunDir: state.goalRunDir });
 
@@ -116,19 +127,78 @@ export async function runGoalReviewSession(options: GoalReviewOptions): Promise<
     throw new GoalReviewError("Goal review was aborted before starting.", { state });
   }
 
-  let sessionResult: GoalReviewerSessionResult;
+  const interruptedResults: GoalReviewerSessionResult[] = [];
+  const interruptedEvidencePaths: string[] = [];
+  let excludedOutageMs = 0;
+  const captureOutage = (event: NetworkRecoveryEvent) => {
+    if (event.type === "cleanup") {
+      excludedOutageMs += event.state.elapsedMs;
+    }
+    options.onNetworkRecovery?.(event);
+  };
+
+  let sessionResult: GoalReviewerSessionResult | undefined;
+  let sessionFailure: unknown;
   try {
-    sessionResult = await (options.reviewerRunner ?? runGoalReviewerSession)({
-      prompt: payload,
-      cwd: path.resolve(options.cwd ?? process.cwd()),
+    sessionResult = await runReviewerWithNetworkRecovery({
+      runner: options.reviewerRunner ?? runGoalReviewerSession,
+      runnerOptions: {
+        prompt: payload,
+        cwd: path.resolve(options.cwd ?? process.cwd()),
+        abortSignal: options.abortSignal,
+        timeoutMs: options.timeoutMs ?? state.limits.reviewerTimeoutMs,
+        model: options.model,
+        modelName: options.modelName,
+        thinkingLevel: options.thinkingLevel,
+        sessionFactory: options.sessionFactory,
+        networkRecovery: options.networkRecovery,
+      },
+      networkRecovery: options.networkRecovery,
       abortSignal: options.abortSignal,
-      timeoutMs: options.timeoutMs ?? state.limits.reviewerTimeoutMs,
-      model: options.model,
-      modelName: options.modelName,
-      thinkingLevel: options.thinkingLevel,
-      sessionFactory: options.sessionFactory,
+      now,
+      interruptedResults,
+      interruptedEvidencePaths,
+      iterationDir,
+      onInterruption: async () => {
+        state = recordReviewerRecoveryEvidence(
+          state,
+          iteration.iteration,
+          {
+            interruptions: interruptedResults.length,
+            evidencePaths: interruptedEvidencePaths,
+            reviewerCostTotal: reviewerCost(interruptedResults),
+          },
+          { now: now() },
+        );
+        await persistStateChange(store, previousTraceLength, state);
+        previousTraceLength = state.trace.length;
+      },
+      onRecoveryEvent: captureOutage,
     });
   } catch (error) {
+    sessionFailure = error;
+  }
+
+  if (excludedOutageMs > 0) {
+    state = excludeNetworkOutageFromGoalDeadlines(state, excludedOutageMs, "reviewer", { now: now() });
+  }
+  if (state.trace.length !== previousTraceLength) {
+    await persistStateChange(store, previousTraceLength, state);
+    previousTraceLength = state.trace.length;
+  }
+
+  if (sessionFailure !== undefined && options.abortSignal?.aborted) {
+    const reason = `Goal review was aborted during network recovery: ${errorMessage(
+      options.abortSignal.reason ?? sessionFailure,
+    )}`;
+    state = cancelGoalLoop(state, reason, { now: now() });
+    await persistStateChange(store, previousTraceLength, state);
+    await store.writeIterationSnapshot(currentIteration(state, iteration.iteration));
+    throw new GoalReviewError(reason, { cause: sessionFailure, state });
+  }
+
+  if (sessionFailure !== undefined) {
+    const interruptedResult = combineReviewerSessionCosts(interruptedResults);
     const failure = await recordReviewFailure({
       state,
       iteration,
@@ -136,17 +206,23 @@ export async function runGoalReviewSession(options: GoalReviewOptions): Promise<
       previousTraceLength,
       payloadPath,
       rawReviewPath,
-      message: `Reviewer session failed: ${errorMessage(error)}`,
-      error,
+      message: `Reviewer session failed: ${errorMessage(sessionFailure)}`,
+      error: sessionFailure,
+      sessionResult: interruptedResult,
       now,
     });
     throw new GoalReviewError(failure.reviewerResult.summary, {
-      cause: error,
+      cause: sessionFailure,
       state: failure.state,
       reviewerResult: failure.reviewerResult,
     });
   }
 
+  sessionResult = combineReviewerSessionCosts(interruptedResults, sessionResult);
+  if (!sessionResult) {
+    throw new GoalReviewError("Reviewer session ended without a result.", { state });
+  }
+
   const rawReviewerOutput = sessionResult.assistantText;
   await writeFile(rawReviewPath, rawReviewerOutput, "utf8");
 
@@ -367,7 +443,7 @@ export async function runGoalReviewerSession(options: GoalReviewerRunnerOptions)
     }
     const factoryResult = await sessionFactory({
       cwd: options.cwd,
-      tools: DEFAULT_WORKER_TOOLS,
+      tools: GOAL_REVIEWER_TOOLS,
       model: options.model,
       modelName: options.modelName,
       thinkingLevel: options.thinkingLevel,
@@ -414,6 +490,7 @@ export async function runGoalReviewerSession(options: GoalReviewerRunnerOptions)
       timedOut: promptResult.timedOut,
       aborted: promptResult.aborted,
       error: promptResult.error,
+      failure: promptResult.failure,
     };
   } catch (exc) {
     return {
@@ -422,6 +499,7 @@ export async function runGoalReviewerSession(options: GoalReviewerRunnerOptions)
       reviewerSessionFile: session?.sessionFile,
       reviewerCostTotal,
       error: errorMessage(exc),
+      failure: exc,
     };
   } finally {
     if (session) {
@@ -434,6 +512,119 @@ export async function runGoalReviewerSession(options: GoalReviewerRunnerOptions)
   }
 }
 
+async function runReviewerWithNetworkRecovery(options: {
+  runner: GoalReviewerRunner;
+  runnerOptions: GoalReviewerRunnerOptions;
+  networkRecovery: Readonly<NetworkRecoveryConfig> | undefined;
+  abortSignal: AbortSignal | undefined;
+  now: () => Date;
+  interruptedResults: GoalReviewerSessionResult[];
+  interruptedEvidencePaths: string[];
+  iterationDir: string;
+  onInterruption: () => Promise<void>;
+  onRecoveryEvent: (event: NetworkRecoveryEvent) => void;
+}): Promise<GoalReviewerSessionResult> {
+  const run = async (recoverySignal?: AbortSignal): Promise<GoalReviewerSessionResult> => {
+    const result = await options.runner({
+      ...options.runnerOptions,
+      abortSignal: combineAbortSignals(options.abortSignal, recoverySignal),
+    });
+    const networkFailure = recoverableReviewerFailure(result);
+    if (networkFailure === undefined) {
+      return result;
+    }
+
+    options.interruptedResults.push(result);
+    options.interruptedEvidencePaths.push(
+      await writeInterruptedReviewEvidence(options.iterationDir, options.interruptedResults.length, result),
+    );
+    await options.onInterruption();
+    throw new ReviewerNetworkFailure(networkFailure, result);
+  };
+
+  try {
+    return await run();
+  } catch (initialFailure) {
+    const classification = classifyNetworkFailure(initialFailure);
+    if (!options.networkRecovery?.enabled || !classification.recoverable) {
+      throw initialFailure;
+    }
+    const recovered = await recoverNetworkOperation({
+      initialFailure,
+      config: options.networkRecovery,
+      signal: options.abortSignal,
+      now: () => options.now().getTime(),
+      onEvent: options.onRecoveryEvent,
+      retry: ({ signal }) => run(signal),
+    });
+    return recovered.value;
+  }
+}
+
+class ReviewerNetworkFailure extends Error {
+  readonly sessionResult: GoalReviewerSessionResult;
+
+  constructor(failure: unknown, sessionResult: GoalReviewerSessionResult) {
+    super(sessionResult.error ?? errorMessage(failure), { cause: failure });
+    this.name = "ReviewerNetworkFailure";
+    this.sessionResult = sessionResult;
+  }
+}
+
+function recoverableReviewerFailure(result: GoalReviewerSessionResult): unknown | undefined {
+  if (result.aborted || result.timedOut || !result.error) {
+    return undefined;
+  }
+  const failure = result.failure ?? new Error(result.error);
+  return classifyNetworkFailure(failure).recoverable ? failure : undefined;
+}
+
+async function writeInterruptedReviewEvidence(
+  iterationDir: string,
+  interruption: number,
+  result: GoalReviewerSessionResult,
+): Promise<string> {
+  const outputPath = path.join(
+    iterationDir,
+    `REVIEW_RESULT_NETWORK_INTERRUPTED_${String(interruption).padStart(2, "0")}.txt`,
+  );
+  const evidence = result.assistantText.trim()
+    ? result.assistantText
+    : `[No assistant text was captured.]\n\n${result.error ?? "Transient reviewer network failure."}\n`;
+  await writeFile(outputPath, evidence, "utf8");
+  return outputPath;
+}
+
+function reviewerCost(results: readonly GoalReviewerSessionResult[]): number {
+  return results.reduce(
+    (total, result) =>
+      total +
+      (typeof result.reviewerCostTotal === "number" && Number.isFinite(result.reviewerCostTotal)
+        ? result.reviewerCostTotal
+        : 0),
+    0,
+  );
+}
+
+function combineReviewerSessionCosts(
+  interrupted: readonly GoalReviewerSessionResult[],
+  final?: GoalReviewerSessionResult,
+): GoalReviewerSessionResult | undefined {
+  if (!final && interrupted.length === 0) {
+    return undefined;
+  }
+  const base = final ?? interrupted.at(-1)!;
+  const reviewerCostTotal = reviewerCost([...interrupted, ...(final ? [final] : [])]);
+  return { ...base, reviewerCostTotal };
+}
+
+function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
+  const available = signals.filter((signal): signal is AbortSignal => Boolean(signal));
+  if (available.length === 0) return undefined;
+  if (available.length === 1) return available[0];
+  return AbortSignal.any(available);
+}
+
 function currentReviewableIteration(state: GoalLoopState): GoalIterationState {
   const iteration = currentIteration(state, state.currentIteration);
   if (iteration.status !== "todo_executed" && iteration.status !== "failed") {

package/src/goal_todo_execution.ts

@@ -15,6 +15,7 @@ import {
   recordWorkerResult,
 } from "./goal_loop.ts";
 import { GoalStateStore } from "./goal_state.ts";
+import type { NetworkRecoveryConfig } from "./network_recovery_config.ts";
 import { validateTodoMarkdown } from "./todo_generator.ts";
 
 export const GOAL_TODO_EXECUTION_PROGRESS_FILE = "WORKER_PROGRESS.jsonl";
@@ -32,6 +33,9 @@ export interface GoalTodoExecutionOptions {
   thinkingLevel?: string;
   maxBashTimeoutMs?: number;
   maxAttemptsPerTask?: number;
+  todoTimeoutMs?: number;
+  todoGracefulShutdownMs?: number;
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
   commit?: boolean;
   now?: () => Date;
   onProgress?: (update: CoordinatorProgressUpdate) => void;
@@ -152,6 +156,9 @@ export async function runGoalTodoExecutionLongTask(
       taskTimeoutMs: childTimeoutMs,
       maxBashTimeoutMs: options.maxBashTimeoutMs,
       maxAttemptsPerTask: options.maxAttemptsPerTask,
+      todoTimeoutMs: options.todoTimeoutMs,
+      todoGracefulShutdownMs: options.todoGracefulShutdownMs,
+      networkRecovery: options.networkRecovery,
       onProgress: (update) => {
         progressEvents.push(update);
         options.onProgress?.(update);