pi-long-task 0.3.11 → 0.3.13

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+Notable changes to Pi Long Task are recorded here. This project follows semantic versioning.
+
+## 0.3.13 - 2026-07-22
+
+### Fixed
+
+- Require complete, machine-readable worker results and reject false completion after session errors, timeouts, or cancellation.
+- Bound worker and reviewer cancellation even when an SDK prompt or graceful follow-up does not settle.
+- Preserve checked TODO progress, durable attempt ordering, retry commit baselines, and accurate failure evidence.
+- Resume persisted goal-loop phases without repeating completed generation or execution work.
+- Enforce overall and iteration deadlines consistently across generation, execution, and review.
+- Retain structured terminal goal results and persisted cost totals across cancellation, failure, and resume paths.
+
+### Compatibility and maintenance
+
+- Declare the supported Node.js floor as 22.19.0 and document validation against Pi 0.80.7, 0.80.8, and 0.81.1.
+- Refresh the controllable transitive development lockfile resolutions for `brace-expansion` and `protobufjs`.

package/README.md

@@ -194,7 +194,7 @@ Use `with commits` or `commit true` only when you want Pi Long Task to create el
 
 ### 3. Monitor progress and completion
 
-During execution, Pi Long Task creates `tmp/pi-long-task/<run-id>/TODO.md` and `TASK_RESULT.md`, runs one isolated worker session per unfinished TODO in order, and retries unfinished tasks up to the configured attempt limit. In Pi TUI, watch the Long Task sidebar/widget for the active task, subtask checklist, task timeline, counts, and worker spend when available. In headless or non-UI runs, watch the partial tool-result updates in the main output. When the run finishes, the final response lists completed, failed, blocked, and remaining task counts plus the result and TODO file paths.
+During execution, Pi Long Task creates `tmp/pi-long-task/<run-id>/TODO.md` and `TASK_RESULT.md`, runs one isolated worker session per unfinished TODO in order, and retries unfinished tasks up to the configured attempt limit. Checked progress in pasted TODO markdown is preserved, so completed tasks are skipped when that artifact is supplied again. A task is marked complete only after the worker returns every required `TASK_RESULT` field without a session error, timeout, or cancellation, and the attempt evidence is appended before the TODO completion marker. In Pi TUI, watch the Long Task sidebar/widget for the active task, subtask checklist, task timeline, counts, and worker spend when available. In headless or non-UI runs, watch the partial tool-result updates in the main output. When the run finishes, the final response lists completed, failed, blocked, and remaining task counts plus the result and TODO file paths.
 
 ## What it looks like
 
@@ -331,16 +331,16 @@ When a `pi_goal_task` goal is already concrete, existing direct behavior is pres
 
 `pi_long_task` behavior is unchanged. Discovery is only enabled by default for `pi_goal_task`; direct long-task planning, TODO normalization, worker execution, progress display, retries, artifacts, and commit behavior continue to work as before.
 
-Goal-loop artifacts are stored under `tmp/pi-goal-task/<goal-run-id>/`, including `GOAL_STATE.json`, `GOAL_TRACE.jsonl`, `GOAL_RESULT.md`, optional `GOAL_SPEC.json` for discovered goals, and per-iteration generated TODO, worker, and reviewer files. Child TODO execution still writes normal `tmp/pi-long-task/<run-id>/` artifacts.
+Goal-loop artifacts are stored under `tmp/pi-goal-task/<goal-run-id>/`, including `GOAL_STATE.json`, `GOAL_TRACE.jsonl`, `GOAL_RESULT.md`, optional `GOAL_SPEC.json` for discovered goals, and per-iteration generated TODO, worker, and reviewer files. Persisted `pending`, `todo_generated`, `todo_executed`, `failed`, and reviewed boundaries can be resumed by SDK callers without rerunning completed phases or rewriting existing result/trace history. Child TODO execution still writes normal `tmp/pi-long-task/<run-id>/` artifacts.
 
 Safety controls:
 
 - `minIterations` prevents early success before the requested number of loops; default is `1`.
 - `maxIterations` stops retry loops when the reviewer keeps finding remaining work; default is `50`. If explicitly provided without `minIterations`, it is also used as the minimum target.
 - `timeoutMs` caps the overall goal loop; default is `172800000` ms (48 hours).
-- `iterationTimeoutMs` caps each generated TODO worker iteration; default is `10800000` ms (3 hours).
-- `reviewerTimeoutMs` caps each reviewer session; default is `1800000` ms (30 minutes).
-- tool cancellation is passed through and stops the loop with `cancelled` status.
+- `iterationTimeoutMs` caps each generation, execution, and review sequence; default is `10800000` ms (3 hours).
+- `reviewerTimeoutMs` caps each reviewer session within the remaining overall and iteration budgets; default is `1800000` ms (30 minutes).
+- tool cancellation is passed through, bounded locally even if an SDK prompt does not settle after abort, and stops the loop with `cancelled` status.
 - `maxAttemptsPerTask` and `maxBashTimeoutMs` are forwarded to worker long-task runs.
 - `commit` controls whether implementation workers may commit; goal loops default to `commit true`, so pass `commit false` when you want to review all changes first.
 
@@ -414,12 +414,18 @@ When `commit` is `true`, it may commit eligible task changes after a task report
 
 - generated run files under `tmp/pi-long-task/`
 - generated `TASK_RESULT.md` files
-- files that were already dirty before the task started
+- files that were already dirty before the task's first attempt (the same protected baseline is retained across retries)
 
 This lets you keep existing local work separate from Pi Long Task changes.
 
 Commit messages are generated from the task title and adjusted to resemble recent commit-message style in the repository. Pi Long Task does not prefix commits with generated labels like `Complete TODO 1 — ...`.
 
+## Runtime compatibility
+
+Pi Long Task requires Node.js 22.19 or newer, matching the supported runtime of the Pi SDK versions used by the package. The extension and isolated-worker setup are validated against Pi 0.80.7 (legacy `AuthStorage`/`ModelRegistry`), Pi 0.80.8 (the `ModelRuntime` transition), and Pi 0.81.1. Older Pi releases may use the legacy fallback but are not part of the validated matrix.
+
+The Pi TUI is optional: JSON and print modes run without sidebar registration, and RPC mode uses the non-component widget path. Git is required only when commit mode is enabled. Model credentials are not required to load the extension, but they are required to execute planner, worker, or reviewer model sessions.
+
 ## Development and validation
 
 Run the local development checks:
@@ -429,6 +435,8 @@ cd /path/to/pi-long-task
 npm run check
 ```
 
+The development SDK tracks current Pi releases. There is no separate build command: Pi loads the TypeScript extension directly through its supported package loader, while `npm run typecheck` validates the source without emitting JavaScript.
+
 Check that Pi can load the extension:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "type": "module",
   "description": "Pi extension for breaking down and running long coding tasks safely.",
   "keywords": [
@@ -11,6 +11,7 @@
     "pi-extension"
   ],
   "files": [
+    "CHANGELOG.md",
     "LICENSE",
     "README.md",
     "scripts",
@@ -38,9 +39,9 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.74.2",
-    "@earendil-works/pi-coding-agent": "^0.74.2",
-    "@earendil-works/pi-tui": "^0.74.2",
+    "@earendil-works/pi-ai": "^0.81.1",
+    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@earendil-works/pi-tui": "^0.81.1",
     "@eslint/js": "^10.0.1",
     "@types/node": "^25.9.3",
     "eslint": "^10.5.0",
@@ -60,5 +61,8 @@
   "bugs": {
     "url": "https://github.com/thestuntcoder/pi-long-task/issues"
   },
-  "homepage": "https://github.com/thestuntcoder/pi-long-task#readme"
+  "homepage": "https://github.com/thestuntcoder/pi-long-task#readme",
+  "engines": {
+    "node": ">=22.19.0"
+  }
 }

package/src/coordinator.ts

@@ -228,14 +228,21 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
   await mkdir(runtime.runDir, { recursive: true });
   await writeFile(runtime.taskResultPath, initialTaskResultMarkdown(runtime.runId), "utf8");
   let planningComplete = false;
+  let latestTodoMarkdown: string | undefined;
+  let latestTasks: Task[] = [];
+  let activeTask: Task | undefined;
+  let activeAttempt: number | undefined;
+  const protectedDirtyPathsByTask = new Map<string, Set<string>>();
 
   try {
     emitProgress(runtime, "Creating TODO plan...", { phase: "planning" });
     let todoMarkdown = await generateOrNormalizeTodoMarkdown(inputText, runtime);
     validateTodoMarkdown(todoMarkdown);
     planningComplete = true;
+    latestTodoMarkdown = todoMarkdown;
     await writeFile(runtime.todoPath, todoMarkdown, "utf8");
     const initialTasks = parseTasks(todoMarkdown);
+    latestTasks = initialTasks;
     emitProgress(runtime, `Created TODO plan with ${initialTasks.length} task(s).`, {
       phase: "planned",
       totalTasks: initialTasks.length,
@@ -247,6 +254,7 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
 
     while (!runtime.abortSignal?.aborted) {
       const tasksBeforeAttempt = parseTasks(todoMarkdown);
+      latestTasks = tasksBeforeAttempt;
       const nextTask = tasksBeforeAttempt.find((task) => !task.done);
       if (!nextTask) {
         break;
@@ -269,9 +277,15 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
           }),
         },
       );
-      const preExistingDirtyPaths = options.commit
-        ? await gitDirtyPaths(runtime.cwd, runtime.taskResultPath, runtime.todoPath, runtime.runDir)
-        : new Set<string>();
+      let preExistingDirtyPaths = protectedDirtyPathsByTask.get(nextTask.taskId);
+      if (!preExistingDirtyPaths) {
+        preExistingDirtyPaths = options.commit
+          ? await gitDirtyPaths(runtime.cwd, runtime.taskResultPath, runtime.todoPath, runtime.runDir)
+          : new Set<string>();
+        protectedDirtyPathsByTask.set(nextTask.taskId, preExistingDirtyPaths);
+      }
+      activeTask = nextTask;
+      activeAttempt = attempt;
       const outcome = await runtime.workerRunner({
         cwd: runtime.cwd,
         todoPath: runtime.todoPath,
@@ -294,11 +308,6 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       outcomes.push(outcome);
       finalizeWorkerCost(runtime.workerCostState, outcome);
 
-      if (outcome.done) {
-        todoMarkdown = markTaskDone(todoMarkdown, nextTask.taskId);
-        await writeFile(runtime.todoPath, todoMarkdown, "utf8");
-      }
-
       const attemptDetails: TaskAttemptSummary = {
         taskId: nextTask.taskId,
         title: nextTask.title,
@@ -310,6 +319,14 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       attempts.push(attemptDetails);
       await appendTaskResult(runtime.taskResultPath, nextTask, outcome);
 
+      if (outcome.done) {
+        todoMarkdown = markTaskDone(todoMarkdown, nextTask.taskId);
+        latestTodoMarkdown = todoMarkdown;
+        await writeFile(runtime.todoPath, todoMarkdown, "utf8");
+      }
+      activeTask = undefined;
+      activeAttempt = undefined;
+
       let taskCommitHash: string | undefined;
       let taskCommitError: string | undefined;
       let taskCommitSkipped: string | undefined;
@@ -360,12 +377,13 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       }
     }
 
-    if (runtime.abortSignal?.aborted && !failure) {
-      failure = "Pi Long Task run aborted.";
-    }
-
     const finalTodoMarkdown = await readFile(runtime.todoPath, "utf8");
     const finalTasks = parseTasks(finalTodoMarkdown);
+    latestTodoMarkdown = finalTodoMarkdown;
+    latestTasks = finalTasks;
+    if (runtime.abortSignal?.aborted && !failure && finalTasks.some((task) => !task.done)) {
+      failure = "Pi Long Task run aborted.";
+    }
     const completedTasks = finalTasks.filter((task) => task.done).length;
     const remainingTasks = remainingTaskSummaries(finalTasks, attempts);
     const blockedTasks = remainingTasks.filter((task) => task.status === "blocked").length;
@@ -427,12 +445,41 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       ? `${message} See ${runtime.taskResultPath} for planner diagnostics.`
       : message;
     const summary = `Pi Long Task failed: ${resultError}`;
+    const failureNote =
+      planningComplete && activeTask
+        ? `TODO ${activeTask.taskId} — ${activeTask.title} (attempt ${activeAttempt ?? "unknown"}) failed: ${message}`
+        : message;
     try {
-      await appendFailureNote(runtime.taskResultPath, message, !planningComplete ? runtime.plannerDiagnostics : []);
+      await appendFailureNote(runtime.taskResultPath, failureNote, !planningComplete ? runtime.plannerDiagnostics : []);
     } catch {
       // Best effort only; the original error is returned below.
     }
 
+    if (planningComplete && activeTask && activeAttempt !== undefined) {
+      attempts.push({
+        taskId: activeTask.taskId,
+        title: activeTask.title,
+        attempt: activeAttempt,
+        reportedStatus: "failed",
+        done: false,
+        error: message,
+      });
+    }
+    if (planningComplete) {
+      try {
+        latestTodoMarkdown = await readFile(runtime.todoPath, "utf8");
+        latestTasks = parseTasks(latestTodoMarkdown);
+      } catch {
+        // Retain the last valid in-memory task snapshot.
+      }
+    }
+    const completedTasks = latestTasks.filter((task) => task.done).length;
+    const remainingTasks = remainingTaskSummaries(latestTasks, attempts);
+    const blockedTasks = remainingTasks.filter((task) => task.status === "blocked").length;
+    const failedTasks = remainingTasks.filter(
+      (task) => task.status !== "blocked" && task.status !== "not_started",
+    ).length;
+    const taskProgress = buildCompletionTaskProgressModel(latestTasks, attempts, "failed");
     const result: CoordinatorResult = {
       status: "failed",
       summary,
@@ -442,16 +489,16 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       todoPath: runtime.todoPath,
       resultPath: runtime.taskResultPath,
       taskResultPath: runtime.taskResultPath,
-      totalTasks: 0,
-      completedTasks: 0,
-      failedTasks: 0,
-      blockedTasks: 0,
+      totalTasks: latestTasks.length,
+      completedTasks,
+      failedTasks,
+      blockedTasks,
       attemptedTasks: attempts.length,
-      remainingTasks: [],
+      remainingTasks,
       outcomes,
       commits,
       attempts,
-      taskProgress: buildTaskProgressModel({ tasks: [], attempts }),
+      taskProgress,
       workerCostTotal: runtime.workerCostState.total,
       commit: options.commit,
       goal: runtime.goal,
@@ -461,7 +508,8 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
     emitProgress(runtime, "Pi Long Task failed.", {
       phase: "complete",
       status: "failed",
-      taskProgress: buildTaskProgressModel({ tasks: [], attempts }),
+      totalTasks: latestTasks.length,
+      taskProgress,
     });
     return result;
   }

package/src/goal_loop.ts

@@ -68,6 +68,7 @@ export interface GeneratedTodoState {
   generatorRunDir?: string;
   generatorResultPath?: string;
   generatorTaskResultPath?: string;
+  generatorWorkerCostTotal?: number;
 }
 
 export interface GoalWorkerResultState {
@@ -401,6 +402,35 @@ export function recordReviewerResult(
   });
 }
 
+export function failGoalLoop(
+  state: GoalLoopState,
+  reason: string,
+  options: { now?: Date; status?: "failed" | "partial" } = {},
+): GoalLoopState {
+  if (isTerminalGoalLoopStatus(state.status)) {
+    return state;
+  }
+  const timestamp = (options.now ?? new Date()).toISOString();
+  const status = options.status ?? "failed";
+  const phase: GoalLoopPhase = status === "failed" ? "failed" : "complete";
+  const completion: GoalCompletionState = { status, reason, completedAt: timestamp };
+  const iterations = state.iterations.map((iteration) =>
+    iteration.iteration === state.currentIteration && !isTerminalIterationStatus(iteration.status)
+      ? { ...iteration, status: "failed" as const, updatedAt: timestamp, completion }
+      : iteration,
+  );
+  return withTrace(
+    { ...state, status, phase, completion, iterations, updatedAt: timestamp },
+    {
+      timestamp,
+      phase,
+      event: status === "partial" ? "timeout" : "failed",
+      message: reason,
+      iteration: state.currentIteration || undefined,
+    },
+  );
+}
+
 export function cancelGoalLoop(
   state: GoalLoopState,
   reason = "Goal loop cancellation requested.",