pi-long-task 0.4.0 → 0.6.0

package/src/goal_todo_generation.ts

@@ -3,9 +3,18 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 import { runCoordinator, type CoordinatorResult, type RunCoordinatorOptions } from "./coordinator.ts";
-import { type GoalIterationState, type GoalLoopState, recordGeneratedTodo, startGoalIteration } from "./goal_loop.ts";
+import {
+  excludeNetworkOutageFromGoalDeadlines,
+  type GoalIterationState,
+  type GoalLoopState,
+  recordGeneratedTodo,
+  startGoalIteration,
+} from "./goal_loop.ts";
 import { GoalStateStore } from "./goal_state.ts";
 import 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 { parseTasks } from "./todo_parser.ts";
 import {
   applyGoalInstructionsToTodoMarkdown,
@@ -29,10 +38,12 @@ export interface GoalTodoGenerationOptions {
   modelName?: string;
   thinkingLevel?: string;
   maxBashTimeoutMs?: number;
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
   now?: () => Date;
   additionalContext?: string;
   outputPath?: string;
   goalSpecification?: GoalSpecification;
+  onNetworkRecovery?: (event: NetworkRecoveryEvent) => void;
 }
 
 export interface GoalTodoGenerationResult {
@@ -92,7 +103,14 @@ export async function runGoalTodoGenerationLongTask(
     );
   }
 
-  const childResult = await (options.longTaskRunner ?? runCoordinator)({
+  let excludedOutageMs = 0;
+  const captureOutage = (event: NetworkRecoveryEvent) => {
+    if (event.type === "cleanup") {
+      excludedOutageMs += event.state.elapsedMs;
+    }
+    options.onNetworkRecovery?.(event);
+  };
+  const childOptions: RunCoordinatorOptions = {
     inputText: payload,
     commit: false,
     goal: state.goal,
@@ -104,7 +122,36 @@ export async function runGoalTodoGenerationLongTask(
     taskThinking: options.thinkingLevel,
     taskTimeoutMs: childTimeoutMs,
     maxBashTimeoutMs: options.maxBashTimeoutMs,
-  });
+    networkRecovery: options.networkRecovery,
+    onNetworkRecovery: captureOutage,
+  };
+
+  let childResult: CoordinatorResult | undefined;
+  let childFailure: unknown;
+  try {
+    childResult = await runGoalPlannerWithNetworkRecovery(
+      options.longTaskRunner ?? runCoordinator,
+      childOptions,
+      options.networkRecovery,
+      options.abortSignal,
+      now,
+      captureOutage,
+    );
+  } catch (error) {
+    childFailure = error;
+  }
+
+  if (excludedOutageMs > 0) {
+    state = excludeNetworkOutageFromGoalDeadlines(state, excludedOutageMs, "planner", { now: now() });
+    await persistStateChange(store, previousTraceLength, state);
+    previousTraceLength = state.trace.length;
+  }
+  if (childFailure !== undefined) {
+    throw childFailure;
+  }
+  if (!childResult) {
+    throw new GoalTodoGenerationError("TODO-generation planner ended without a coordinator result.");
+  }
 
   throwIfAborted(options.abortSignal);
   const rawOutput = await readGeneratedTodo(rawTodoPath, childResult);
@@ -259,6 +306,45 @@ async function persistStateChange(
   await store.appendNewTraceEvents(previousTraceLength, state);
 }
 
+/**
+ * Resume the TODO-generation child under its stable run ID. This child is
+ * constrained to one replaceable generated-plan artifact (never implementation
+ * work), while the default coordinator durably resumes its TODO evidence and
+ * rotates provider-failed sessions. Network probes therefore neither create a
+ * goal iteration nor consume a normal child task attempt.
+ */
+async function runGoalPlannerWithNetworkRecovery(
+  runner: GoalTodoGenerationLongTaskRunner,
+  childOptions: RunCoordinatorOptions,
+  networkRecovery: Readonly<NetworkRecoveryConfig> | undefined,
+  abortSignal: AbortSignal | undefined,
+  now: () => Date,
+  onRecoveryEvent: (event: NetworkRecoveryEvent) => void,
+): Promise<CoordinatorResult> {
+  const run = (recoverySignal?: AbortSignal) =>
+    runner({
+      ...childOptions,
+      abortSignal: combineAbortSignals(abortSignal, recoverySignal),
+    });
+
+  try {
+    return await run();
+  } catch (initialFailure) {
+    if (!networkRecovery?.enabled || !classifyNetworkFailure(initialFailure).recoverable) {
+      throw initialFailure;
+    }
+    const recovered = await recoverNetworkOperation({
+      initialFailure,
+      config: networkRecovery,
+      signal: abortSignal,
+      now: () => now().getTime(),
+      onEvent: onRecoveryEvent,
+      retry: ({ signal }) => run(signal),
+    });
+    return recovered.value;
+  }
+}
+
 async function readGeneratedTodo(rawTodoPath: string, childResult: CoordinatorResult): Promise<string> {
   try {
     return await readFile(rawTodoPath, "utf8");
@@ -538,6 +624,13 @@ function sha256(value: string): string {
   return createHash("sha256").update(value).digest("hex");
 }
 
+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 throwIfAborted(signal: AbortSignal | undefined): void {
   if (signal?.aborted) {
     throw new GoalTodoGenerationError("TODO generation was aborted before producing a generated TODO.");

package/src/index.ts

@@ -276,10 +276,8 @@ function renderSidebarWidgetLines(update: CoordinatorProgressUpdate): string[] {
   const progress = update.taskProgress;
   const summary = progress?.summary;
   const statusDetails = sidebarUpdateStateDetails(update);
-  const lines = [
-    "Pi Long Task",
-    `${statusDetails.icon} ${statusDetails.label} · ${update.activeStatus ?? update.message}`,
-  ];
+  const statusText = normalizeActiveStatus(update.activeStatus ?? update.message);
+  const lines = ["Pi Long Task", `${statusDetails.icon} ${statusDetails.label} · ${statusText}`];
   if (summary) {
     lines.push(
       `Tasks: ${summary.completedTasks}/${summary.totalTasks} · ${summary.completedPercent}%` +
@@ -396,7 +394,8 @@ function renderSidebarRows(update: CoordinatorProgressUpdate | undefined, theme:
     rows.push(theme.fg("success", "No active task"));
   }
 
-  const activeStatus = update.activeStatus ?? normalizeMessageForSidebar(update.message, update);
+  const rawActiveStatus = update.activeStatus ?? normalizeMessageForSidebar(update.message, update);
+  const activeStatus = rawActiveStatus ? normalizeActiveStatus(rawActiveStatus) : undefined;
   if (currentTask && activeStatus) {
     rows.push("", sidebarHeading("Active status", theme));
     rows.push(...wrapPlainText(activeStatus, width, 6).map((line) => theme.fg("accent", line)));
@@ -573,8 +572,12 @@ function sidebarUpdateStateDetails(update: CoordinatorProgressUpdate): {
       return { icon: "✓", label: "Plan ready", color: "success" };
     case "task_start":
       return { icon: "▢", label: "Running task", color: "accent" };
+    case "worker_session":
+      return { icon: "↻", label: "Worker session", color: "accent" };
     case "worker_tool":
       return { icon: "+", label: "Worker tool", color: "warning" };
+    case "network_wait":
+      return { icon: "↻", label: "Waiting for connection", color: "warning" };
     case "task_done":
       return { icon: "✓", label: "Task complete", color: "success" };
     case "task_blocked":
@@ -681,6 +684,18 @@ function normalizeMessageForSidebar(updateMessage: string, update: CoordinatorPr
   return title && message.includes(title) && message.length <= title.length + 16 ? undefined : message;
 }
 
+function normalizeActiveStatus(status: string): string {
+  const normalized = status.trim();
+  const firstOutcome = /^(Finished|Failed):\s*/i.exec(normalized)?.[1];
+  if (!firstOutcome) {
+    return normalized;
+  }
+
+  const activity = normalized.replace(/^(?:(?:Finished|Failed):\s*)+/i, "");
+  const outcome = firstOutcome.toLowerCase() === "failed" ? "Failed" : "Finished";
+  return activity ? `${outcome}: ${activity}` : `${outcome}:`;
+}
+
 function wrapPlainText(text: string, width: number, limit?: number): string[] {
   const safeWidth = Math.max(8, width);
   const words = text.trim().split(/\s+/).filter(Boolean);