@cr1ms0n/pi-subagent 0.8.9 → 0.9.0

package/src/orchestrator.ts

@@ -94,51 +94,89 @@ export async function runTasks(
   const worktrees = options.worktrees ?? new WorktreeManager();
   const handles: Array<WorktreeHandle | undefined> = new Array(specs.length);
   const prepared: TaskSpec[] = [];
+  let setupTimedOut = false;
+  const progress: Partial<TaskResult>[] = [];
+  const checkpoint = (index: number, partial: Partial<TaskResult>) => {
+    progress[index] = { ...progress[index], ...partial };
+    options.onTaskProgress?.(index, partial);
+  };
 
   try {
     for (let index = 0; index < specs.length; index++) {
       if (options.signal?.aborted) throw new Error("Subagent run cancelled before worktree setup");
       const spec = { ...specs[index]! };
+      const setupController = new AbortController();
+      const setupSignal = options.signal ? AbortSignal.any([options.signal, setupController.signal]) : setupController.signal;
+      let setupTimer: NodeJS.Timeout | undefined;
+      if (spec.deadline !== undefined) {
+        const remaining = spec.deadline - Date.now();
+        if (remaining <= 0) {
+          setupTimedOut = true;
+          throw new Error("Subagent deadline expired before setup");
+        }
+        setupTimer = setTimeout(() => { setupTimedOut = true; setupController.abort(); }, remaining);
+        setupTimer.unref?.();
+      }
+      try {
       if (spec.isolation === "worktree") {
-        const handle = await worktrees.create(spec.cwd || process.cwd(), spec.task.slice(0, 20), options.signal, {
+        const handle = await worktrees.create(spec.cwd || process.cwd(), spec.task.slice(0, 20), setupSignal, {
           includeWip: spec.includeWip === true,
         });
         handles[index] = handle;
         spec.cwd = handle.cwd;
         // Announce the worktree immediately so live runs can shield it from GC sweeps.
-        options.onTaskProgress?.(index, {
+        checkpoint(index, {
           worktree: { cwd: handle.cwd, branch: handle.branch, baseCommit: handle.baseCommit, changed: false },
         });
       }
+      if (setupSignal.aborted) throw new Error("Subagent setup was cancelled or exceeded its task deadline");
       prepared.push(spec);
+      } finally { if (setupTimer) clearTimeout(setupTimer); }
     }
   } catch (error) {
-    // Setup failure: remove only unchanged worktrees. Preserve modified ones.
-    for (const handle of handles.filter((h): h is WorktreeHandle => !!h)) {
-      await worktrees.finalize(handle).catch(() => {});
+    // Keep retained worktree pointers and report cleanup failures per task.
+    const setupErrors: Array<string | undefined> = [];
+    for (let index = 0; index < handles.length; index++) {
+      const handle = handles[index];
+      if (!handle) continue;
+      try {
+        const final = await worktrees.finalize(handle);
+        progress[index] = { ...progress[index], worktree: final.changed
+          ? { cwd: final.cwd, branch: final.branch, baseCommit: final.baseCommit, changed: true, diffSummary: final.diffSummary }
+          : undefined };
+      } catch (error) {
+        setupErrors[index] = `Worktree finalization failed: ${error instanceof Error ? error.message : String(error)}`;
+        // Its state is uncertain; preserve the handle for inspection/recovery.
+        progress[index] = { ...progress[index], worktree: { cwd: handle.cwd, branch: handle.branch, baseCommit: handle.baseCommit, changed: true } };
+      }
     }
-    if (options.signal?.aborted) {
+    {
+      const setupState: RunState = setupTimedOut ? "timeout" : options.signal?.aborted ? "cancelled" : "failed";
       const results = specs.map<TaskResult>((spec, index) => ({
-        label: `task-${index + 1}`,
+        ...progress[index],
+        index,
+        label: spec.label || `task-${index + 1}`,
         task: spec.task,
         model: spec.model,
-        state: "cancelled",
+        routing: spec.routing,
+        state: setupState,
         exitCode: 1,
-        messages: [],
-        stderr: "",
-        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, cost: 0, contextTokens: 0, turns: 0 },
-        stopReason: "cancelled",
-        errorMessage: error instanceof Error ? error.message : String(error),
+        messages: progress[index]?.messages ?? [],
+        stderr: progress[index]?.stderr ?? "",
+        usage: progress[index]?.usage ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, cost: 0, contextTokens: 0, turns: 0 },
+        stopReason: setupTimedOut ? "timeout" : options.signal?.aborted ? "cancelled" : "setup_error",
+        timeoutPhase: setupTimedOut ? "starting" : undefined,
+        errorMessage: [error instanceof Error ? error.message : String(error), setupErrors[index]].filter(Boolean).join("; "),
         thinking: spec.thinking,
         profile: spec.profile,
+        backend: spec.backend ?? "pi",
         canWrite: spec.canWrite,
         outputFile: spec.output,
         outputMode: spec.outputMode,
         protocol: { headerSeen: false, assistantEndSeen: false, agentEndSeen: false, agentSettledSeen: false, validEvents: 0, parseErrors: 0 },
       }));
-      return { mode: specs.length > 1 ? "parallel" : "single", results, state: "cancelled", summary: "Subagent run cancelled during setup" };
+      return { mode: specs.length > 1 ? "parallel" : "single", results, state: setupState, summary: summarize(results) };
     }
-    throw error;
   }
 
   const runOne = async (index: number): Promise<TaskResult> => {
@@ -168,7 +206,7 @@ export async function runTasks(
         semaphore,
         options.getPiCommand ?? createGetPiCommand(),
         options.sessionDir,
-        (partial) => options.onTaskProgress?.(index, {
+        (partial) => checkpoint(index, {
           ...partial,
           attempts: attempt > 1 ? attempt : undefined,
           usage: partial.usage && priorUsage ? addUsage(priorUsage, partial.usage) : partial.usage,
@@ -184,11 +222,11 @@ export async function runTasks(
       result = await runner.run(attemptSpec, options.signal);
       if (priorUsage) result.usage = addUsage(priorUsage, result.usage);
 
-      const canRetry = attempt < maxAttempts && !options.signal?.aborted && isTransientFailure(result);
+      const canRetry = attempt < maxAttempts && !options.signal?.aborted && (spec.deadline === undefined || Date.now() < spec.deadline) && isTransientFailure(result);
       if (!canRetry) break;
       priorUsage = result.usage;
       const nextModel = fallbacks[attempt - 1];
-      options.onTaskProgress?.(index, {
+      checkpoint(index, {
         state: "queued",
         model: nextModel ?? spec.model,
         attempts: attempt + 1,
@@ -203,6 +241,7 @@ export async function runTasks(
         result.errorMessage += ` (after ${attemptedModels.length} attempts: ${attemptedModels.join(" → ")})`;
       }
     }
+    result.routing = spec.routing;
     result.index = index;
     result.label = spec.label || `task-${index + 1}`;
     result.outputMode = spec.outputMode;
@@ -237,7 +276,24 @@ export async function runTasks(
     return result;
   };
 
-  const results = await Promise.all(prepared.map((_, index) => runOne(index)));
+  // One unexpected task failure must not release run ownership while siblings still
+  // execute, or discard their results. Each task settles before the aggregate does.
+  const results = await Promise.all(prepared.map(async (spec, index): Promise<TaskResult> => {
+    try { return await runOne(index); }
+    catch (error) {
+      const partial = progress[index];
+      return {
+        ...partial, index, label: spec.label || `task-${index + 1}`, task: spec.task,
+        model: partial?.model ?? spec.model, routing: spec.routing, thinking: spec.thinking,
+        profile: spec.profile, backend: spec.backend ?? "pi", canWrite: spec.canWrite,
+        outputFile: spec.output, outputMode: spec.outputMode,
+        state: "failed", exitCode: 1, messages: partial?.messages ?? [], stderr: partial?.stderr ?? "",
+        usage: partial?.usage ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+        stopReason: "error", errorMessage: error instanceof Error ? error.message : String(error),
+        protocol: partial?.protocol ?? { headerSeen: false, assistantEndSeen: false, agentEndSeen: false, agentSettledSeen: false, validEvents: 0, parseErrors: 0 },
+      };
+    }
+  }));
   return {
     mode: results.length > 1 ? "parallel" : "single",
     results,