pi-long-task 0.5.0 → 0.6.0

package/src/worker_config.ts

@@ -1,3 +1,9 @@
+import {
+  NetworkRecoveryConfigError,
+  resolveNetworkRecoveryConfig,
+  type NetworkRecoveryConfigInput,
+} from "./network_recovery_config.ts";
+
 export interface ParsedWorkerRuntimeConfig {
   modelName?: string;
   maxAttemptsPerTask?: number;
@@ -5,6 +11,7 @@ export interface ParsedWorkerRuntimeConfig {
   maxBashTimeoutMs?: number;
   workerSessionReuseEnabled?: boolean;
   workerSessionReuseContextThresholdPercent?: number;
+  networkRecovery?: NetworkRecoveryConfigInput;
 }
 
 type MutableWorkerRuntimeConfig = ParsedWorkerRuntimeConfig & { provider?: string; model?: string };
@@ -36,6 +43,9 @@ export function parseWorkerRuntimeConfig(text: string): ParsedWorkerRuntimeConfi
 
   parseLineDirectives(text, state);
   parseNaturalLanguageDirectives(text, state);
+  if (state.networkRecovery) {
+    resolveNetworkRecoveryConfig(state.networkRecovery);
+  }
 
   const modelName = combineProviderAndModel(state.provider, state.model);
   return {
@@ -49,6 +59,7 @@ export function parseWorkerRuntimeConfig(text: string): ParsedWorkerRuntimeConfi
     ...(state.workerSessionReuseContextThresholdPercent !== undefined
       ? { workerSessionReuseContextThresholdPercent: state.workerSessionReuseContextThresholdPercent }
       : {}),
+    ...(state.networkRecovery ? { networkRecovery: { ...state.networkRecovery } } : {}),
   };
 }
 
@@ -159,6 +170,11 @@ function parseNaturalLanguageDirectives(text: string, state: MutableWorkerRuntim
 }
 
 function applyDirective(key: string, value: string, state: MutableWorkerRuntimeConfig): void {
+  if (/\bnetwork\b/.test(key) && /\brecover(?:y|ies)?\b/.test(key)) {
+    applyNetworkRecoveryDirective(key, value, state);
+    return;
+  }
+
   if (/\breuse\b/.test(key) && /\b(?:threshold|context)\b/.test(key)) {
     const threshold = percentageFromText(value);
     if (threshold !== undefined) {
@@ -215,6 +231,64 @@ function applyDirective(key: string, value: string, state: MutableWorkerRuntimeC
   }
 }
 
+function applyNetworkRecoveryDirective(key: string, value: string, state: MutableWorkerRuntimeConfig): void {
+  const recovery = (state.networkRecovery ??= {});
+
+  if (/\bbase\b/.test(key) && /\bdelay\b/.test(key)) {
+    recovery.baseDelayMs = requiredNetworkRecoveryDuration("base delay", value);
+    return;
+  }
+  if (/\bmax(?:imum)?\b/.test(key) && /\bdelay\b/.test(key)) {
+    recovery.maxDelayMs = requiredNetworkRecoveryDuration("maximum delay", value);
+    return;
+  }
+  if (/\b(?:outage|duration|wait)\b/.test(key)) {
+    const normalized = trimDirectiveValue(value)
+      .toLowerCase()
+      .replace(/[.!]+$/g, "")
+      .trim();
+    if (/^(?:unlimited|indefinite|indefinitely|until cancelled|until canceled)$/.test(normalized)) {
+      recovery.maxOutageMs = null;
+      return;
+    }
+    recovery.maxOutageMs = requiredNetworkRecoveryDuration("maximum outage", value);
+    return;
+  }
+  if (/\b(?:enabled?|enablement)\b/.test(key) || /\bnetwork recovery\b/.test(key)) {
+    const enabled = booleanSetting(value);
+    if (enabled === undefined) {
+      throw new NetworkRecoveryConfigError(
+        "Network recovery must be configured as enabled/disabled, on/off, true/false, or yes/no.",
+      );
+    }
+    recovery.enabled = enabled;
+    return;
+  }
+
+  throw new NetworkRecoveryConfigError(`Unknown network recovery configuration directive: ${key}.`);
+}
+
+function requiredNetworkRecoveryDuration(label: string, value: string): number {
+  const trimmed = trimDirectiveValue(value)
+    .replace(/[.!]+$/g, "")
+    .trim();
+  const match = /^(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?$/i.exec(
+    trimmed,
+  );
+  if (!match) {
+    throw new NetworkRecoveryConfigError(
+      `Network recovery ${label} must be a positive finite duration (for example 1000ms, 30s, or 5m).`,
+    );
+  }
+  const milliseconds = durationMsFromText(trimmed, { allowBareSeconds: true });
+  if (milliseconds === undefined) {
+    throw new NetworkRecoveryConfigError(
+      `Network recovery ${label} must be a positive finite duration (for example 1000ms, 30s, or 5m).`,
+    );
+  }
+  return milliseconds;
+}
+
 function captureTokens(text: string, pattern: RegExp, apply: (token: string) => void): void {
   for (const match of text.matchAll(pattern)) {
     const token = modelToken(match[1] ?? "");

package/src/worker_session.ts

@@ -8,14 +8,25 @@ import {
   parseCompleteTaskResult,
   parseReportedStatus,
 } from "./result_writer.ts";
+import type { NetworkRecoveryConfig } from "./network_recovery_config.ts";
 import type { Task } from "./todo_parser.ts";
 
+export interface WorkerNetworkRecoveryContext {
+  /** One-based coordinator network retry count; this is not a task attempt. */
+  retryCount: number;
+  durableEvidencePath: string;
+  priorSessionId?: string;
+  failure: string;
+}
+
 export interface WorkerTaskPromptOptions {
   todoPath: string;
   task: Pick<Task, "taskId" | "title" | "section">;
   attempt: number;
   commitRequested: boolean;
   previousAttempts?: string;
+  /** Continuity supplied only when a failed transport session is replaced. */
+  networkRecoveryContext?: WorkerNetworkRecoveryContext;
   globalInstructions?: string;
   goal?: string;
   maxBashTimeoutSeconds: number;
@@ -43,6 +54,18 @@ Previous attempts for this same assigned task are below. Use them only as contin
 \`\`\`text
 ${previousAttempts}
 \`\`\`
+`
+    : "";
+
+  const recovery = options.networkRecoveryContext;
+  const recoveryText = recovery
+    ? `
+Network recovery continuation (network retry ${recovery.retryCount}, still ordinary task attempt ${options.attempt}):
+- The prior worker session ended only after Pi's bounded provider-request retries were exhausted: ${recovery.failure}
+- Durable interruption evidence was recorded in \`${recovery.durableEvidencePath}\`${recovery.priorSessionId ? ` for session \`${recovery.priorSessionId}\`` : ""}.
+- The prior session may already have completed tool calls and changed the working tree. Inspect the durable evidence and current files before acting.
+- Continue this same TODO from its current state. Never blindly replay prior edits, commands, commits, external writes, or other side effects.
+- Report one final TASK_RESULT for the assignment only after verifying what remains.
 `
     : "";
 
@@ -93,7 +116,7 @@ Rules:
 - Do not run bash commands with timeout greater than ${options.maxBashTimeoutSeconds.toFixed(0)} seconds. For long full-suite checks, run once with a bounded timeout and report any timeout/failure in TASK_RESULT instead of continuing indefinitely.
 - If TODO-file global instructions restrict scope, obey them strictly. If the task appears to require out-of-scope code changes, stop and report \`status: blocked\` instead of changing those files.
 
-${globalText}Assigned task content only:
+${globalText}${recoveryText}Assigned task content only:
 
 \`\`\`markdown
 ${options.task.section.trimEnd()}
@@ -289,6 +312,8 @@ export type WorkerSessionFactory = (options: CreateWorkerSessionOptions) => Prom
 export interface RunWorkerTaskOptions extends WorkerTaskPromptOptions, CreateWorkerSessionOptions {
   taskTimeoutSeconds?: number;
   gracefulShutdownSeconds?: number;
+  /** Normalized coordinator policy for resuming this operation after transient transport failure. */
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
   abortSignal?: AbortSignal;
   sessionFactory?: WorkerSessionFactory;
   onEvent?: (event: CapturedWorkerEvent) => void;
@@ -353,6 +378,8 @@ export interface SessionOutcome {
   timedOut: boolean;
   aborted: boolean;
   error?: string;
+  /** Original provider/transport failure retained for coordinator classification. */
+  failure?: unknown;
 }
 
 export function buildMissingTaskResultMessage(): string {
@@ -512,6 +539,7 @@ export async function runWorkerTaskAssignment(
   let timedOut = false;
   let aborted = false;
   let error: string | undefined;
+  let failure: unknown;
   let finished = false;
   let turnCount = 0;
   let messageUsageCostTotal = 0;
@@ -637,6 +665,7 @@ export async function runWorkerTaskAssignment(
       },
       (exc: unknown) => {
         settled = true;
+        failure ??= exc;
         error = error ?? errorMessage(exc);
         resolvePromptWait?.();
         resolvePromptWait = undefined;
@@ -773,6 +802,7 @@ export async function runWorkerTaskAssignment(
       assistantText = latestInvocationAssistantText(session, assistantText, invocationMessageStart, !reusedAssignment);
     }
   } catch (exc) {
+    failure ??= exc;
     error = error ?? errorMessage(exc);
   } finally {
     finished = true;
@@ -823,6 +853,7 @@ export async function runWorkerTaskAssignment(
     timedOut,
     aborted: aborted || cancelled,
     error,
+    ...(failure === undefined ? {} : { failure }),
   };
 }
 
@@ -872,6 +903,7 @@ export function buildWorkerSessionCreationFailureOutcome(
     timedOut: false,
     aborted: Boolean(options.abortSignal?.aborted),
     error: message,
+    failure: error,
   };
 }