pi-long-task 0.3.12 → 0.3.13

package/src/goal_orchestrator.ts

@@ -8,9 +8,11 @@ import {
   type GoalDiscoveryEntrypoint,
   type GoalDiscoveryRunner,
 } from "./goal_discovery.ts";
-import type { GoalLoopLimits, GoalLoopStatus } from "./goal_loop.ts";
+import type { GoalIterationStatus, GoalLoopLimits, GoalLoopStatus } from "./goal_loop.ts";
 import {
+  cancelGoalLoop,
   createGoalLoopState,
+  failGoalLoop,
   goalLoopStopReason,
   startGoalIteration,
   type GoalLoopLimitInput,
@@ -145,8 +147,8 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
   let goalSpecification: GoalSpecification | undefined = await store.tryLoadGoalSpecification();
 
   await store.saveState(state);
-  await store.initializeResult(state);
-  await store.appendNewTraceEvents(0, state);
+  await store.initializeResultIfMissing(state);
+  await store.appendNewTraceEvents(await store.durableTraceLength(), state);
   const publish = (phase: GoalLoopProgressPhase, message: string, extra: Partial<GoalLoopProgressUpdate> = {}) => {
     options.onProgress?.({
       message,
@@ -165,136 +167,201 @@ export async function runGoalLoop(options: RunGoalLoopOptions): Promise<GoalLoop
       tracePath: store.paths.tracePath,
       goalSpecPath: store.paths.goalSpecPath,
       discoveryDecision,
-      workerCostTotal: accumulatedWorkerCost(executionResults, generationResults),
-      reviewerCostTotal: accumulatedReviewerCost(reviewResults),
-      totalCost: accumulatedWorkerCost(executionResults, generationResults) + accumulatedReviewerCost(reviewResults),
+      workerCostTotal: accumulatedWorkerCost(state),
+      reviewerCostTotal: accumulatedReviewerCost(state),
+      totalCost: accumulatedWorkerCost(state) + accumulatedReviewerCost(state),
       ...extra,
     });
   };
 
   publish("goal_start", `Starting goal loop: ${state.goal}`);
 
-  if (!goalLoopStopReason(state, { now: now(), abortSignal: options.abortSignal })) {
-    goalSpecification = await maybeRunGoalDiscovery({
-      state,
-      store,
-      discoveryDecision,
-      existingSpecification: goalSpecification,
-      options,
-      now,
-      publish,
-    });
-  }
-
-  while (state.status === "running") {
-    const stopReason = goalLoopStopReason(state, { now: now(), abortSignal: options.abortSignal });
-    if (stopReason) {
-      const previousTraceLength = state.trace.length;
-      state = startGoalIteration(state, { now: now(), abortSignal: options.abortSignal });
-      await persistStateChange(store, previousTraceLength, state);
-      break;
-    }
-
-    const nextIteration = state.currentIteration > 0 ? state.currentIteration : state.iterations.length + 1;
-    publish("todo_generation_start", `Goal iteration ${nextIteration}: generating TODO markdown.`, {
-      iteration: nextIteration,
-    });
-    const generation = await runGoalTodoGenerationLongTask({
-      state,
-      cwd: options.cwd,
-      store,
-      longTaskRunner: options.todoGenerationRunner,
-      abortSignal: options.abortSignal,
-      model: options.model,
-      modelName: options.modelName,
-      thinkingLevel: options.thinkingLevel,
-      maxBashTimeoutMs: options.maxBashTimeoutMs,
-      now,
-      goalSpecification,
-    });
-    generationResults.push(generation);
-    state = generation.state;
-    publish("todo_generated", `Goal iteration ${state.currentIteration}: generated TODO markdown.`, {
-      iteration: state.currentIteration,
-    });
-
-    try {
-      publish(
-        "todo_execution_start",
-        `Goal iteration ${state.currentIteration}: running generated TODO as a long task.`,
-        {
-          iteration: state.currentIteration,
-        },
-      );
-      const execution = await runGoalTodoExecutionLongTask({
+  try {
+    if (!goalLoopStopReason(state, { now: now(), abortSignal: options.abortSignal })) {
+      goalSpecification = await maybeRunGoalDiscovery({
         state,
-        cwd: options.cwd,
         store,
-        longTaskRunner: options.todoExecutionRunner,
-        abortSignal: options.abortSignal,
-        model: options.model,
-        modelName: options.modelName,
-        thinkingLevel: options.thinkingLevel,
-        maxBashTimeoutMs: options.maxBashTimeoutMs,
-        maxAttemptsPerTask: options.maxAttemptsPerTask,
-        commit: options.commit,
+        discoveryDecision,
+        existingSpecification: goalSpecification,
+        options,
         now,
-        onProgress: (update) => {
-          publish("todo_execution_start", `Goal iteration ${state.currentIteration}: ${update.message}`, {
-            iteration: state.currentIteration,
-            workerStatus: update.status,
-            childProgress: update,
-          });
-          options.onWorkerProgress?.(update);
-        },
+        publish,
       });
-      executionResults.push(execution);
-      state = execution.state;
-      publish(
-        "todo_executed",
-        `Goal iteration ${state.currentIteration}: worker finished with ${execution.childResult.status}.`,
-        {
+    }
+
+    while (state.status === "running") {
+      const phaseNow = now();
+      const stopReason = goalLoopStopReason(state, { now: phaseNow, abortSignal: options.abortSignal });
+      if (stopReason) {
+        const previousTraceLength = state.trace.length;
+        state = startGoalIteration(state, { now: phaseNow, abortSignal: options.abortSignal });
+        await persistStateChange(store, previousTraceLength, state);
+        break;
+      }
+
+      const current = state.iterations.find((item) => item.iteration === state.currentIteration);
+      if (current && isActiveIterationPhase(current.status) && deadlineExpired(current.deadlineAt, phaseNow)) {
+        const previousTraceLength = state.trace.length;
+        state = failGoalLoop(state, `Goal iteration ${current.iteration} exceeded its iteration deadline.`, {
+          now: phaseNow,
+          status: "partial",
+        });
+        await persistStateChange(store, previousTraceLength, state);
+        break;
+      }
+
+      const currentStatus = current?.status;
+      if (!current || currentStatus === "reviewed_incomplete") {
+        const nextIteration = state.iterations.length + 1;
+        publish("todo_generation_start", `Goal iteration ${nextIteration}: generating TODO markdown.`, {
+          iteration: nextIteration,
+        });
+        const generation = await runGoalTodoGenerationLongTask({
+          state,
+          cwd: options.cwd,
+          store,
+          longTaskRunner: options.todoGenerationRunner,
+          abortSignal: options.abortSignal,
+          model: options.model,
+          modelName: options.modelName,
+          thinkingLevel: options.thinkingLevel,
+          maxBashTimeoutMs: options.maxBashTimeoutMs,
+          now,
+          goalSpecification,
+        });
+        generationResults.push(generation);
+        state = generation.state;
+        publish("todo_generated", `Goal iteration ${state.currentIteration}: generated TODO markdown.`, {
+          iteration: state.currentIteration,
+        });
+        continue;
+      }
+
+      if (currentStatus === "pending") {
+        publish("todo_generation_start", `Goal iteration ${current.iteration}: resuming TODO generation.`, {
+          iteration: current.iteration,
+        });
+        const generation = await runGoalTodoGenerationLongTask({
+          state,
+          cwd: options.cwd,
+          store,
+          longTaskRunner: options.todoGenerationRunner,
+          abortSignal: options.abortSignal,
+          model: options.model,
+          modelName: options.modelName,
+          thinkingLevel: options.thinkingLevel,
+          maxBashTimeoutMs: options.maxBashTimeoutMs,
+          now,
+          goalSpecification,
+        });
+        generationResults.push(generation);
+        state = generation.state;
+        publish("todo_generated", `Goal iteration ${state.currentIteration}: generated TODO markdown.`, {
           iteration: state.currentIteration,
-          workerStatus: execution.childResult.status,
-        },
-      );
-    } catch (error) {
-      if (error instanceof GoalTodoExecutionError && error.state) {
-        state = error.state;
-      } else {
-        throw new GoalLoopOrchestratorError(`Goal TODO execution failed: ${errorMessage(error)}`, {
-          cause: error,
+        });
+        continue;
+      }
+
+      if (currentStatus === "todo_generated") {
+        publish("todo_execution_start", `Goal iteration ${current.iteration}: running generated TODO as a long task.`, {
+          iteration: current.iteration,
+        });
+        try {
+          const execution = await runGoalTodoExecutionLongTask({
+            state,
+            cwd: options.cwd,
+            store,
+            longTaskRunner: options.todoExecutionRunner,
+            abortSignal: options.abortSignal,
+            model: options.model,
+            modelName: options.modelName,
+            thinkingLevel: options.thinkingLevel,
+            maxBashTimeoutMs: options.maxBashTimeoutMs,
+            maxAttemptsPerTask: options.maxAttemptsPerTask,
+            commit: options.commit,
+            now,
+            onProgress: (update) => {
+              publish("todo_execution_start", `Goal iteration ${state.currentIteration}: ${update.message}`, {
+                iteration: state.currentIteration,
+                workerStatus: update.status,
+                childProgress: update,
+              });
+              options.onWorkerProgress?.(update);
+            },
+          });
+          executionResults.push(execution);
+          state = execution.state;
+          publish(
+            "todo_executed",
+            `Goal iteration ${state.currentIteration}: worker finished with ${execution.childResult.status}.`,
+            {
+              iteration: state.currentIteration,
+              workerStatus: execution.childResult.status,
+            },
+          );
+        } catch (error) {
+          if (error instanceof GoalTodoExecutionError && error.state) {
+            state = error.state;
+          } else {
+            throw error;
+          }
+        }
+        continue;
+      }
+
+      if (currentStatus === "todo_executed" || currentStatus === "failed") {
+        publish("review_start", `Goal iteration ${current.iteration}: reviewing goal completion.`, {
+          iteration: current.iteration,
+        });
+        const review = await runGoalReviewSession({
           state,
+          cwd: options.cwd,
+          store,
+          reviewerRunner: options.reviewerRunner,
+          abortSignal: options.abortSignal,
+          model: options.model,
+          modelName: options.modelName,
+          thinkingLevel: options.thinkingLevel,
+          now,
+          goalSpecification,
+          timeoutMs: remainingReviewTimeout(state, current.deadlineAt, now()),
         });
+        reviewResults.push(review);
+        state = review.state;
+        publish(
+          "reviewed",
+          `Goal iteration ${review.iteration.iteration}: reviewer decided ${review.reviewerResult.decision}.`,
+          {
+            iteration: review.iteration.iteration,
+            reviewerDecision: review.reviewerResult.decision,
+            remainingWork: review.reviewerResult.remainingWork,
+          },
+        );
+        continue;
       }
-    }
 
-    publish("review_start", `Goal iteration ${state.currentIteration}: reviewing goal completion.`, {
-      iteration: state.currentIteration,
-    });
-    const review = await runGoalReviewSession({
-      state,
-      cwd: options.cwd,
-      store,
-      reviewerRunner: options.reviewerRunner,
-      abortSignal: options.abortSignal,
-      model: options.model,
-      modelName: options.modelName,
-      thinkingLevel: options.thinkingLevel,
-      now,
-      goalSpecification,
-    });
-    reviewResults.push(review);
-    state = review.state;
-    publish(
-      "reviewed",
-      `Goal iteration ${review.iteration.iteration}: reviewer decided ${review.reviewerResult.decision}.`,
-      {
-        iteration: review.iteration.iteration,
-        reviewerDecision: review.reviewerResult.decision,
-        remainingWork: review.reviewerResult.remainingWork,
-      },
-    );
+      throw new GoalLoopOrchestratorError(`Cannot resume goal iteration ${current.iteration} from ${currentStatus}.`, {
+        state,
+      });
+    }
+  } catch (error) {
+    const errorState = stateFromError(error);
+    if (errorState) {
+      state = errorState;
+    } else {
+      try {
+        state = await store.loadState();
+      } catch {
+        // Retain the latest in-memory state when no newer durable state is available.
+      }
+    }
+    if (state.status === "running") {
+      const previousTraceLength = state.trace.length;
+      state = options.abortSignal?.aborted
+        ? cancelGoalLoop(state, `Goal loop aborted: ${errorMessage(error)}`, { now: now() })
+        : failGoalLoop(state, `Goal loop failed: ${errorMessage(error)}`, { now: now() });
+      await persistStateChange(store, previousTraceLength, state);
+    }
   }
 
   publish("complete", `Goal loop ${state.status}: ${state.completion?.reason ?? "finished"}`);
@@ -365,18 +432,42 @@ async function persistStateChange(
   await store.appendNewTraceEvents(previousTraceLength, state);
 }
 
-function accumulatedWorkerCost(
-  executionResults: GoalTodoExecutionResult[],
-  generationResults: GoalTodoGenerationResult[],
-): number {
-  return sumFinite([
-    ...executionResults.map((result) => result.childResult.workerCostTotal),
-    ...generationResults.map((result) => result.childResult.workerCostTotal),
-  ]);
+function isActiveIterationPhase(status: GoalIterationStatus): boolean {
+  return status === "pending" || status === "todo_generated" || status === "todo_executed" || status === "failed";
+}
+
+function deadlineExpired(deadlineAt: string | undefined, now: Date): boolean {
+  return Boolean(deadlineAt && now.getTime() >= Date.parse(deadlineAt));
+}
+
+function remainingReviewTimeout(state: GoalLoopState, iterationDeadlineAt: string | undefined, now: Date): number {
+  const remaining = [
+    state.limits.reviewerTimeoutMs,
+    state.deadlineAt ? Date.parse(state.deadlineAt) - now.getTime() : Number.POSITIVE_INFINITY,
+    iterationDeadlineAt ? Date.parse(iterationDeadlineAt) - now.getTime() : Number.POSITIVE_INFINITY,
+  ].filter((value) => Number.isFinite(value));
+  return Math.max(1, Math.floor(Math.min(...remaining)));
+}
+
+function stateFromError(error: unknown): GoalLoopState | undefined {
+  if (typeof error !== "object" || error === null || !("state" in error)) {
+    return undefined;
+  }
+  const state = (error as { state?: unknown }).state;
+  return state && typeof state === "object" ? (state as GoalLoopState) : undefined;
+}
+
+function accumulatedWorkerCost(state: GoalLoopState): number {
+  return sumFinite(
+    state.iterations.flatMap((iteration) => [
+      iteration.generatedTodo?.generatorWorkerCostTotal,
+      iteration.workerResult?.workerCostTotal,
+    ]),
+  );
 }
 
-function accumulatedReviewerCost(reviewResults: GoalReviewResult[]): number {
-  return sumFinite(reviewResults.map((result) => result.sessionResult.reviewerCostTotal));
+function accumulatedReviewerCost(state: GoalLoopState): number {
+  return sumFinite(state.iterations.map((iteration) => iteration.reviewerResult?.reviewerCostTotal));
 }
 
 function sumFinite(values: Array<number | undefined>): number {

package/src/goal_review.ts

@@ -10,14 +10,14 @@ import {
   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 {
-  assistantTextFromEvent,
   createIsolatedWorkerSession,
   DEFAULT_WORKER_TOOLS,
-  lastAssistantTextFromMessages,
   workerUsageCostFromEvent,
   workerUsageCostFromStats,
+  workerUsageCostKeyFromEvent,
   type WorkerSessionFactory,
 } from "./worker_session.ts";
 
@@ -36,6 +36,7 @@ export interface GoalReviewOptions {
   now?: () => Date;
   sessionFactory?: WorkerSessionFactory;
   goalSpecification?: GoalSpecification;
+  timeoutMs?: number;
 }
 
 export interface GoalReviewResult {
@@ -121,7 +122,7 @@ export async function runGoalReviewSession(options: GoalReviewOptions): Promise<
       prompt: payload,
       cwd: path.resolve(options.cwd ?? process.cwd()),
       abortSignal: options.abortSignal,
-      timeoutMs: state.limits.reviewerTimeoutMs,
+      timeoutMs: options.timeoutMs ?? state.limits.reviewerTimeoutMs,
       model: options.model,
       modelName: options.modelName,
       thinkingLevel: options.thinkingLevel,
@@ -149,6 +150,36 @@ export async function runGoalReviewSession(options: GoalReviewOptions): Promise<
   const rawReviewerOutput = sessionResult.assistantText;
   await writeFile(rawReviewPath, rawReviewerOutput, "utf8");
 
+  if (sessionResult.aborted) {
+    const reason = sessionResult.error ?? "Goal review was aborted.";
+    state = cancelGoalLoop(state, reason, { now: now() });
+    await persistStateChange(store, previousTraceLength, state);
+    await store.writeIterationSnapshot(currentIteration(state, iteration.iteration));
+    throw new GoalReviewError(reason, { state });
+  }
+  if (sessionResult.timedOut || sessionResult.error) {
+    const message = sessionResult.timedOut
+      ? `Reviewer session timed out: ${sessionResult.error ?? "time budget exceeded"}`
+      : `Reviewer session failed: ${sessionResult.error}`;
+    const failure = await recordReviewFailure({
+      state,
+      iteration,
+      store,
+      previousTraceLength,
+      payloadPath,
+      rawReviewPath,
+      message,
+      error: sessionResult.error ?? message,
+      rawReviewerOutput,
+      sessionResult,
+      now,
+    });
+    throw new GoalReviewError(failure.reviewerResult.summary, {
+      state: failure.state,
+      reviewerResult: failure.reviewerResult,
+    });
+  }
+
   let reviewerResult: GoalReviewerResultState;
   try {
     reviewerResult = {
@@ -322,33 +353,17 @@ function minimumIterationRemainingWork(state: GoalLoopState): string[] {
 
 export async function runGoalReviewerSession(options: GoalReviewerRunnerOptions): Promise<GoalReviewerSessionResult> {
   const sessionFactory = options.sessionFactory ?? createIsolatedWorkerSession;
-  const events: unknown[] = [];
-  let assistantText = "";
-  let timedOut = false;
-  let aborted = false;
-  let error: string | undefined;
   let reviewerCostTotal = 0;
   let session: Awaited<ReturnType<typeof sessionFactory>>["session"] | undefined;
-  let unsubscribe: (() => void) | undefined;
-  let timeout: ReturnType<typeof setTimeout> | undefined;
-
-  const abortSession = async (reason: string) => {
-    if (!session || aborted) {
-      return;
-    }
-    aborted = true;
-    error = error ?? reason;
-    await session.abort?.();
-  };
-  const abortListener = () => {
-    void abortSession("reviewer session aborted by outer signal").catch((exc: unknown) => {
-      error = error ?? errorMessage(exc);
-    });
-  };
+  const costsByMessage = new Map<string, number>();
 
   try {
     if (options.abortSignal?.aborted) {
-      throw new Error("reviewer session aborted before start");
+      return {
+        assistantText: "",
+        aborted: true,
+        error: errorMessage(options.abortSignal.reason ?? "reviewer session aborted before start"),
+      };
     }
     const factoryResult = await sessionFactory({
       cwd: options.cwd,
@@ -358,55 +373,65 @@ export async function runGoalReviewerSession(options: GoalReviewerRunnerOptions)
       thinkingLevel: options.thinkingLevel,
     });
     session = factoryResult.session;
-    unsubscribe = session.subscribe((event: unknown) => {
-      events.push(event);
-      const text = assistantTextFromEvent(event);
-      if (text) {
-        assistantText = text;
-      }
-      const cost = workerUsageCostFromEvent(event);
-      if (cost !== undefined) {
-        reviewerCostTotal = Math.max(reviewerCostTotal, cost);
-      }
+    const promptResult = await runGuardedSessionPrompt({
+      session,
+      prompt: options.prompt,
+      abortSignal: options.abortSignal,
+      timeoutMs: options.timeoutMs,
+      gracefulShutdownMs: 0,
+      diagnostics: factoryResult.diagnostics,
+      dispose: false,
+      onEvent: (event) => {
+        const cost = workerUsageCostFromEvent(event);
+        if (cost === undefined) {
+          return;
+        }
+        const key = workerUsageCostKeyFromEvent(event);
+        if (key) {
+          costsByMessage.set(key, cost);
+          reviewerCostTotal = [...costsByMessage.values()].reduce((total, item) => total + item, 0);
+        } else {
+          reviewerCostTotal += cost;
+        }
+      },
     });
-    options.abortSignal?.addEventListener("abort", abortListener, { once: true });
-    if (options.timeoutMs > 0) {
-      timeout = setTimeout(() => {
-        timedOut = true;
-        void abortSession(`reviewer exceeded ${options.timeoutMs}ms timeout`).catch((exc: unknown) => {
-          error = error ?? errorMessage(exc);
-        });
-      }, options.timeoutMs);
+
+    try {
+      const stats = session.getSessionStats ? await session.getSessionStats() : undefined;
+      const statsCost = workerUsageCostFromStats(stats);
+      if (statsCost !== undefined) {
+        reviewerCostTotal = statsCost;
+      }
+    } catch {
+      // Event-based accounting remains available when session stats fail.
     }
-    await session.prompt(options.prompt);
-    assistantText = latestAssistantText(session, assistantText);
+
+    return {
+      assistantText: promptResult.assistantText,
+      reviewerSessionId: promptResult.sessionId,
+      reviewerSessionFile: promptResult.sessionFile,
+      reviewerCostTotal,
+      timedOut: promptResult.timedOut,
+      aborted: promptResult.aborted,
+      error: promptResult.error,
+    };
   } catch (exc) {
-    error = error ?? errorMessage(exc);
+    return {
+      assistantText: "",
+      reviewerSessionId: session?.sessionId,
+      reviewerSessionFile: session?.sessionFile,
+      reviewerCostTotal,
+      error: errorMessage(exc),
+    };
   } finally {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    options.abortSignal?.removeEventListener("abort", abortListener);
-    unsubscribe?.();
     if (session) {
-      assistantText = latestAssistantText(session, assistantText);
-      const statsCost = session.getSessionStats ? workerUsageCostFromStats(await session.getSessionStats()) : undefined;
-      if (statsCost !== undefined) {
-        reviewerCostTotal = statsCost;
+      try {
+        await Promise.resolve(session.dispose?.());
+      } catch {
+        // Cleanup is best-effort and must not replace a useful reviewer outcome.
       }
-      session.dispose?.();
     }
   }
-
-  return {
-    assistantText,
-    reviewerSessionId: session?.sessionId,
-    reviewerSessionFile: session?.sessionFile,
-    reviewerCostTotal,
-    timedOut,
-    aborted: aborted || Boolean(options.abortSignal?.aborted),
-    error,
-  };
 }
 
 function currentReviewableIteration(state: GoalLoopState): GoalIterationState {
@@ -584,13 +609,6 @@ function defaultSummary(decision: GoalReviewerDecision): string {
   }
 }
 
-function latestAssistantText(
-  session: { getLastAssistantText?: () => string | undefined; messages?: unknown[] },
-  fallback: string,
-): string {
-  return session.getLastAssistantText?.() || lastAssistantTextFromMessages(session.messages) || fallback;
-}
-
 function markdownFence(value: string, language: string): string {
   const ticks = longestBacktickRun(value) + 1;
   const fence = "`".repeat(Math.max(3, ticks));

package/src/goal_state.ts

@@ -97,6 +97,31 @@ export class GoalStateStore {
     }
   }
 
+  async initializeResultIfMissing(state: GoalLoopState): Promise<boolean> {
+    try {
+      await readFile(this.paths.resultPath, "utf8");
+      return false;
+    } catch (error) {
+      if (!isNodeErrnoException(error) || error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await this.initializeResult(state);
+    return true;
+  }
+
+  async durableTraceLength(): Promise<number> {
+    try {
+      const text = await readFile(this.paths.tracePath, "utf8");
+      return text.split(/\r?\n/).filter((line) => line.trim()).length;
+    } catch (error) {
+      if (isNodeErrnoException(error) && error.code === "ENOENT") {
+        return 0;
+      }
+      throw error;
+    }
+  }
+
   async initializeResult(state: GoalLoopState): Promise<void> {
     validateGoalLoopState(state);
     await this.ensureRunDir();