pi-long-task 0.5.0 → 0.7.0

package/src/goal_todo_generation.ts

@@ -3,13 +3,23 @@ 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,
   extractAndValidateTodoMarkdown,
+  todoPlanningOnlyPromptBlock,
   validateTodoMarkdown,
 } from "./todo_generator.ts";
 
@@ -29,10 +39,14 @@ export interface GoalTodoGenerationOptions {
   modelName?: string;
   thinkingLevel?: string;
   maxBashTimeoutMs?: number;
+  todoTimeoutMs?: number;
+  todoGracefulShutdownMs?: number;
+  networkRecovery?: Readonly<NetworkRecoveryConfig>;
   now?: () => Date;
   additionalContext?: string;
   outputPath?: string;
   goalSpecification?: GoalSpecification;
+  onNetworkRecovery?: (event: NetworkRecoveryEvent) => void;
 }
 
 export interface GoalTodoGenerationResult {
@@ -92,7 +106,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 +125,38 @@ export async function runGoalTodoGenerationLongTask(
     taskThinking: options.thinkingLevel,
     taskTimeoutMs: childTimeoutMs,
     maxBashTimeoutMs: options.maxBashTimeoutMs,
-  });
+    todoTimeoutMs: options.todoTimeoutMs,
+    todoGracefulShutdownMs: options.todoGracefulShutdownMs,
+    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);
@@ -178,16 +230,17 @@ export function buildGoalTodoGenerationTaskPayload(options: {
 
 - Long task goal: ${oneLine(options.state.goal)}
 - This is goal-loop TODO generation iteration ${options.iteration} for goal run ${options.state.goalRunId}.
-- Only generate TODO markdown for future workers; do not implement, edit, test, refactor, or otherwise perform the goal work in this generation run.
 - Write the generated Pi Long Task-compatible TODO markdown to \`${options.outputPath}\`.
 - Do not wrap the generated file in a code fence and do not include commentary outside the TODO markdown in that file.
 - Keep generated tasks focused, independently assignable, and safe for separate worker sessions.
 ${iterationPolicy}
 ${
   options.goalSpecification
-    ? "- A persisted goal specification is available; derive implementation TODOs from that specification rather than only the original vague goal.\n- Ensure generated tasks explicitly cover relevant requirement IDs, milestones, acceptance criteria, verification gates, constraints, and definition-of-done items from the specification.\n- Include spec IDs (for example REQ-*, MS-*, AC-*, VG-*) in generated task goals/status/verification/done-when guidance wherever applicable.\n"
+    ? "- A persisted goal specification is available; derive implementation TODOs from it rather than only the original vague goal.\n- Preserve its requirement IDs, milestones, acceptance criteria, verification gates, constraints, and definition of done in the relevant tasks. Reference each applicable spec ID (for example REQ-*, MS-*, AC-*, VG-*) where it is most useful instead of duplicating it in every task field.\n"
     : ""
 }
+${todoPlanningOnlyPromptBlock()}
+
 ## Progress
 
 - [ ] TODO 1 — Generate Pi Long Task TODO markdown
@@ -199,16 +252,12 @@ ${
 **Goal:** Convert the high-level goal into a valid Pi Long Task TODO plan for the next implementation long task.
 
 **Status:**
-- [ ] Analyze the high-level goal and any iteration context.
-- [ ] Create TODO markdown that starts with \`# Pi Long Task TODO\`.
-- [ ] Include a \`## Progress\` section with one unchecked \`- [ ] TODO N — Title\` line per generated task.
-- [ ] Include a \`---\` separator before generated task sections.
-- [ ] Include sequential \`## TODO N — Title\` sections with \`**Goal:**\`, \`**Status:**\`, \`**Verify:**\`, and \`**Done when:**\` guidance.
-- [ ] Write only the generated TODO markdown to \`${options.outputPath}\`.
+- [ ] Derive focused future-worker tasks from the goal, constraints, and iteration context without performing that work.
+- [ ] Render the required Progress list and sequential task sections with Goal, Status, Verify, and Done when fields.
+- [ ] Write only the concise generated TODO markdown to \`${options.outputPath}\`.
 
 **Verify:**
-- Confirm the file at \`${options.outputPath}\` exists.
-- Confirm it starts with \`# Pi Long Task TODO\`, has a \`## Progress\` section, a \`---\` separator, sequential TODO sections, unchecked status checkboxes, and concrete verification instructions.
+- Confirm \`${options.outputPath}\` contains valid TODO markdown with preserved constraints, compact task sections, unchecked statuses, and concrete checks.
 
 **Done when:**
 - \`${options.outputPath}\` contains valid Pi Long Task-compatible TODO markdown for achieving the high-level goal.
@@ -259,6 +308,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 +626,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

@@ -80,6 +80,8 @@ function toolDetails(result: CoordinatorResult) {
     remainingTasks: result.remainingTasks,
     taskProgress: result.taskProgress,
     workerCostTotal: result.workerCostTotal,
+    plannerBudget: result.plannerBudget,
+    capabilityWarnings: result.capabilityWarnings,
     summary: result.summary,
     goal: result.goal,
     error: result.error,
@@ -349,7 +351,15 @@ function renderSidebarRows(update: CoordinatorProgressUpdate | undefined, theme:
   rows.push(renderSidebarStateLine(update, theme));
 
   if (!progress || progress.tasks.length === 0) {
-    rows.push("", sidebarHeading("Context", theme), theme.fg("muted", "Waiting for TODO plan"));
+    const planningStatus =
+      update.phase === "planning" ? normalizeActiveStatus(update.activeStatus ?? update.message) : undefined;
+    rows.push(
+      "",
+      sidebarHeading(planningStatus ? "Planning timing" : "Context", theme),
+      ...(planningStatus
+        ? wrapPlainText(planningStatus, width, 8).map((line) => theme.fg("accent", line))
+        : [theme.fg("muted", "Waiting for TODO plan")]),
+    );
     if (update.workerCostTotal > 0) {
       rows.push(theme.fg("muted", `${formatCost(update.workerCostTotal)} spent`));
     }
@@ -566,6 +576,8 @@ function sidebarUpdateStateDetails(update: CoordinatorProgressUpdate): {
   }
 
   switch (update.phase) {
+    case "capability_warning":
+      return { icon: "!", label: "Capability warning", color: "warning" };
     case "planning":
       return { icon: "+", label: "Planning", color: "warning" };
     case "planned":
@@ -576,6 +588,8 @@ function sidebarUpdateStateDetails(update: CoordinatorProgressUpdate): {
       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":