pi-long-task 0.1.3 → 0.3.0

package/README.md

@@ -6,19 +6,22 @@ It is useful when you want Pi to handle a multi-step change without losing track
 
 ## What you get
 
-When you ask Pi to use `pi_long_task`, it will:
+When you ask Pi to run a long task, it will:
 
-1. Create or clean up a TODO plan from your request.
-2. Work through each unfinished TODO task in order.
-3. Record progress and final results under `tmp/pi-long-task/<run-id>/`.
-4. Return a summary with completed, failed, blocked, and remaining task counts.
-5. Optionally commit completed work after each task.
+1. Recognize natural-language requests like "run a long task with commits" and route them to `pi_long_task`.
+2. Create or clean up a TODO plan from your request.
+3. Work through each unfinished TODO task in order.
+4. Show the current task and inferred subtask progress while it runs.
+5. Record progress and final results under `tmp/pi-long-task/<run-id>/`.
+6. Return a summary with completed, failed, blocked, and remaining task counts.
+7. Optionally commit completed work after each task.
 
 A finished run gives you:
 
 - a concise status summary in Pi
 - a generated `TODO.md`
 - a generated `TASK_RESULT.md`
+- live progress for the active task and its `**Status:**` checkbox subtasks
 - commit hashes when commits were enabled and created
 - any remaining or blocked tasks clearly listed
 
@@ -42,11 +45,23 @@ Or install the local checkout so Pi can load it normally:
 pi install /path/to/pi-long-task
 ```
 
-After installing, start `pi` in your target project and ask it to use the `pi_long_task` tool.
+After installing, start `pi` in your target project and ask it to run a long task.
+
+To update an existing npm install:
+
+```bash
+pi update npm:pi-long-task
+```
+
+Or update all installed Pi extension packages:
+
+```bash
+pi update --extensions
+```
 
 ## Usage
 
-Use natural language:
+Use natural language; you do not need to mention `pi_long_task` explicitly:
 
 ```text
 Run a long task without commits to add tests for the parser and fix any failures.
@@ -92,8 +107,22 @@ The tool has two inputs:
 
 For natural-language requests, Pi Long Task routes phrases like "run a long task with commits" to the tool with commits enabled. If you ask for a long task without mentioning commits, commits stay disabled.
 
+Natural-language routing intentionally avoids informational questions, such as "How do I run a long task with commits?", and explicit tool calls are left unchanged.
+
 No other public options are required.
 
+## Progress display
+
+While a task is running, Pi Long Task shows the active TODO and subtasks parsed from that task's `**Status:**` checkbox list.
+
+Status markers are:
+
+- `○` not started
+- green `●` done
+- orange `●` inferred as in progress
+
+Because workers currently report structured results at the end of a task, in-progress subtask state is inferred: the first unchecked status item is shown as in progress while the task runs.
+
 ## Commits and files
 
 When `commit` is `false`, Pi Long Task never creates commits.
@@ -106,6 +135,8 @@ When `commit` is `true`, it may commit eligible task changes after a task report
 
 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 — ...`.
+
 ## Validate the install
 
 Run the local checks:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "type": "module",
   "description": "Pi extension for breaking down and running long coding tasks safely.",
   "keywords": [

package/src/coordinator.ts

@@ -11,13 +11,14 @@ import type {
 import { commitAfterSession, gitDirtyPaths, shouldCommitOutcome, type CommitAfterSessionResult } from "./git.ts";
 import { formatCoordinatorResultMessage } from "./render.ts";
 import { extractResultSummary } from "./result_writer.ts";
+import { buildTaskProgressModel, type TaskProgressModel, type TaskProgressStatus } from "./task_progress.ts";
 import {
   buildTodoCreationPrompt,
   extractTodoMarkdown,
   todoMarkdownFromString,
   validateTodoMarkdown,
 } from "./todo_generator.ts";
-import { incompleteTasks, markTaskDone, parseTasks, todoGlobalInstructions, type Task } from "./todo_parser.ts";
+import { markTaskDone, parseTasks, todoGlobalInstructions, type Task } from "./todo_parser.ts";
 import {
   createIsolatedWorkerSession,
   lastAssistantTextFromMessages,
@@ -49,7 +50,7 @@ export type CoordinatorProgressPhase =
   | "task_failed"
   | "complete";
 
-export type CoordinatorProgressItemStatus = "empty" | "in_progress" | "done";
+export type CoordinatorProgressItemStatus = "empty" | "in_progress" | "done" | "failed" | "blocked";
 
 export interface CoordinatorProgressTask {
   taskId: string;
@@ -79,8 +80,10 @@ export interface CoordinatorProgressUpdate {
   workerEventType?: string;
   isError?: boolean;
   totalTasks?: number;
+  workerCostTotal: number;
   currentTask?: CoordinatorProgressTask;
   subtasks?: CoordinatorProgressSubtask[];
+  taskProgress?: TaskProgressModel;
 }
 
 export type CoordinatorProgressHandler = (update: CoordinatorProgressUpdate) => void;
@@ -142,10 +145,19 @@ export interface CoordinatorResult {
   outcomes: SessionOutcome[];
   commits: CoordinatorCommitSummary[];
   attempts: TaskAttemptSummary[];
+  taskProgress: TaskProgressModel;
+  workerCostTotal: number;
   commit: boolean;
   error?: string;
 }
 
+interface WorkerCostState {
+  total: number;
+  finalizedByWorker: Map<string, number>;
+  liveByWorker: Map<string, number>;
+  liveByMessage: Map<string, number>;
+}
+
 interface RuntimeOptions {
   cwd: string;
   runId: string;
@@ -164,6 +176,7 @@ interface RuntimeOptions {
   todoSessionFactory?: WorkerSessionFactory;
   now: () => Date;
   onProgress?: CoordinatorProgressHandler;
+  workerCostState: WorkerCostState;
 }
 
 export async function runCoordinator(options: RunCoordinatorOptions): Promise<CoordinatorResult> {
@@ -184,13 +197,15 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
     emitProgress(runtime, `Created TODO plan with ${initialTasks.length} task(s).`, {
       phase: "planned",
       totalTasks: initialTasks.length,
+      taskProgress: buildTaskProgressModel({ tasks: initialTasks }),
     });
 
     const previousAttempts = new Map<string, string[]>();
     let failure: string | undefined;
 
     while (!runtime.abortSignal?.aborted) {
-      const nextTask = incompleteTasks(todoMarkdown)[0];
+      const tasksBeforeAttempt = parseTasks(todoMarkdown);
+      const nextTask = tasksBeforeAttempt.find((task) => !task.done);
       if (!nextTask) {
         break;
       }
@@ -205,6 +220,11 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
           title: nextTask.title,
           attempt,
           ...currentTaskProgress(nextTask, "in_progress"),
+          taskProgress: buildTaskProgressModel({
+            tasks: tasksBeforeAttempt,
+            attempts,
+            currentTaskId: nextTask.taskId,
+          }),
         },
       );
       const preExistingDirtyPaths = options.commit
@@ -224,9 +244,10 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
         abortSignal: runtime.abortSignal,
         sessionFactory: runtime.workerSessionFactory,
         now: runtime.now,
-        onEvent: (event) => emitWorkerEventProgress(runtime, nextTask, attempt, event),
+        onEvent: (event) => emitWorkerEventProgress(runtime, tasksBeforeAttempt, nextTask, attempts, attempt, event),
       });
       outcomes.push(outcome);
+      finalizeWorkerCost(runtime.workerCostState, outcome);
 
       if (outcome.done) {
         todoMarkdown = markTaskDone(todoMarkdown, nextTask.taskId);
@@ -270,7 +291,16 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
         await appendCommitNote(runtime.taskResultPath, commitResult);
       }
 
-      emitTaskOutcomeProgress(runtime, nextTask, outcome, taskCommitHash, taskCommitError, taskCommitSkipped);
+      emitTaskOutcomeProgress(
+        runtime,
+        parseTasks(todoMarkdown),
+        nextTask,
+        attempts,
+        outcome,
+        taskCommitHash,
+        taskCommitError,
+        taskCommitSkipped,
+      );
 
       const attemptSummary = resultTextForPreviousAttempt(outcome);
       previousAttempts.set(nextTask.taskId, [...(previousAttempts.get(nextTask.taskId) ?? []), attemptSummary]);
@@ -304,6 +334,7 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       blockedTasks,
       failedTasks,
     });
+    const taskProgress = buildCompletionTaskProgressModel(finalTasks, attempts, status);
     const summary = failure
       ? `Pi Long Task ${status}: ${failure}`
       : `Pi Long Task completed ${completedTasks}/${finalTasks.length} task(s).`;
@@ -325,6 +356,8 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       outcomes,
       commits,
       attempts,
+      taskProgress,
+      workerCostTotal: runtime.workerCostState.total,
       commit: options.commit,
       error: failure,
     };
@@ -333,6 +366,7 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       phase: "complete",
       status,
       totalTasks: finalTasks.length,
+      taskProgress,
     });
     return result;
   } catch (error) {
@@ -362,11 +396,17 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       outcomes,
       commits,
       attempts,
+      taskProgress: buildTaskProgressModel({ tasks: [], attempts }),
+      workerCostTotal: runtime.workerCostState.total,
       commit: options.commit,
       error: message,
     };
     result.message = formatCoordinatorResultMessage(result);
-    emitProgress(runtime, "Pi Long Task failed.", { phase: "complete", status: "failed" });
+    emitProgress(runtime, "Pi Long Task failed.", {
+      phase: "complete",
+      status: "failed",
+      taskProgress: buildTaskProgressModel({ tasks: [], attempts }),
+    });
     return result;
   }
 }
@@ -440,23 +480,101 @@ function buildRuntimeOptions(options: RunCoordinatorOptions): RuntimeOptions {
     todoSessionFactory: options.todoSessionFactory,
     now: options.now ?? (() => new Date()),
     onProgress: options.onProgress,
+    workerCostState: createWorkerCostState(),
   };
 }
 
 function emitProgress(
   runtime: RuntimeOptions,
   message: string,
-  update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath">,
+  update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath" | "workerCostTotal">,
 ): void {
   runtime.onProgress?.({
     message,
     runId: runtime.runId,
     todoPath: runtime.todoPath,
     resultPath: runtime.taskResultPath,
+    workerCostTotal: runtime.workerCostState.total,
     ...update,
   });
 }
 
+function createWorkerCostState(): WorkerCostState {
+  return {
+    total: 0,
+    finalizedByWorker: new Map(),
+    liveByWorker: new Map(),
+    liveByMessage: new Map(),
+  };
+}
+
+function recordLiveWorkerCost(
+  state: WorkerCostState,
+  worker: string,
+  event: { usageCostTotal?: number; usageCostKey?: string },
+): boolean {
+  if (state.finalizedByWorker.has(worker) || event.usageCostTotal === undefined || !event.usageCostKey) {
+    return false;
+  }
+
+  const cost = finiteNonNegativeNumber(event.usageCostTotal);
+  if (cost === undefined) {
+    return false;
+  }
+
+  const messageKey = `${worker}:${event.usageCostKey}`;
+  if (state.liveByMessage.get(messageKey) === cost) {
+    return false;
+  }
+
+  state.liveByMessage.set(messageKey, cost);
+  recomputeLiveWorkerCost(state, worker);
+  recomputeWorkerCostTotal(state);
+  return true;
+}
+
+function finalizeWorkerCost(
+  state: WorkerCostState,
+  outcome: Pick<SessionOutcome, "task" | "attempt" | "workerCostTotal">,
+): void {
+  const worker = workerKey(outcome.task.taskId, outcome.attempt);
+  state.finalizedByWorker.set(worker, finiteNonNegativeNumber(outcome.workerCostTotal) ?? 0);
+  state.liveByWorker.delete(worker);
+  for (const messageKey of state.liveByMessage.keys()) {
+    if (messageKey.startsWith(`${worker}:`)) {
+      state.liveByMessage.delete(messageKey);
+    }
+  }
+  recomputeWorkerCostTotal(state);
+}
+
+function recomputeLiveWorkerCost(state: WorkerCostState, worker: string): void {
+  let total = 0;
+  for (const [messageKey, cost] of state.liveByMessage) {
+    if (messageKey.startsWith(`${worker}:`)) {
+      total += cost;
+    }
+  }
+  state.liveByWorker.set(worker, total);
+}
+
+function recomputeWorkerCostTotal(state: WorkerCostState): void {
+  let total = 0;
+  for (const cost of state.finalizedByWorker.values()) {
+    total += cost;
+  }
+  for (const [worker, cost] of state.liveByWorker) {
+    if (!state.finalizedByWorker.has(worker)) {
+      total += cost;
+    }
+  }
+  state.total = total;
+}
+
+function workerKey(taskId: string, attempt: number): string {
+  return `${taskId}:${attempt}`;
+}
+
 function currentTaskProgress(
   task: Pick<Task, "taskId" | "title" | "statusItems">,
   status: CoordinatorProgressItemStatus,
@@ -475,14 +593,14 @@ function subtaskProgress(
   task: Pick<Task, "statusItems">,
   taskStatus: CoordinatorProgressItemStatus,
 ): CoordinatorProgressSubtask[] {
-  let markedInProgress = false;
+  let markedActive = false;
   return task.statusItems.map((item) => {
     if (item.done || taskStatus === "done") {
       return { text: item.text, status: "done" };
     }
-    if (taskStatus === "in_progress" && !markedInProgress) {
-      markedInProgress = true;
-      return { text: item.text, status: "in_progress" };
+    if ((taskStatus === "in_progress" || taskStatus === "failed" || taskStatus === "blocked") && !markedActive) {
+      markedActive = true;
+      return { text: item.text, status: taskStatus };
     }
     return { text: item.text, status: "empty" };
   });
@@ -490,15 +608,37 @@ function subtaskProgress(
 
 function emitWorkerEventProgress(
   runtime: RuntimeOptions,
+  tasks: readonly Task[],
   task: Pick<Task, "taskId" | "title" | "statusItems">,
+  attempts: readonly TaskAttemptSummary[],
   attempt: number,
-  event: { type: string; toolName?: string; isError?: boolean },
+  event: { type: string; toolName?: string; isError?: boolean; usageCostTotal?: number; usageCostKey?: string },
 ): void {
+  if (event.usageCostTotal !== undefined) {
+    const changed = recordLiveWorkerCost(runtime.workerCostState, workerKey(task.taskId, attempt), event);
+    if (changed) {
+      emitProgress(
+        runtime,
+        `TODO ${task.taskId}: worker cost updated to ${formatCost(runtime.workerCostState.total)}.`,
+        {
+          phase: "worker_tool",
+          taskId: task.taskId,
+          title: task.title,
+          attempt,
+          status: "in_progress",
+          workerEventType: event.type,
+          ...currentTaskProgress(task, "in_progress"),
+          taskProgress: buildTaskProgressModel({ tasks, attempts, currentTaskId: task.taskId }),
+        },
+      );
+    }
+  }
+
   if (!event.toolName || (event.type !== "tool_execution_start" && event.type !== "tool_execution_end")) {
     return;
   }
   const action = event.type === "tool_execution_start" ? "started" : event.isError ? "failed" : "finished";
-  const update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath"> = {
+  const update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath" | "workerCostTotal"> = {
     phase: "worker_tool",
     taskId: task.taskId,
     title: task.title,
@@ -508,6 +648,7 @@ function emitWorkerEventProgress(
     workerEventType: event.type,
     isError: event.isError,
     ...currentTaskProgress(task, "in_progress"),
+    taskProgress: buildTaskProgressModel({ tasks, attempts, currentTaskId: task.taskId }),
   };
   if (event.isError) {
     update.status = "failed";
@@ -517,7 +658,9 @@ function emitWorkerEventProgress(
 
 function emitTaskOutcomeProgress(
   runtime: RuntimeOptions,
+  tasks: readonly Task[],
   task: Pick<Task, "taskId" | "title" | "statusItems">,
+  attempts: readonly TaskAttemptSummary[],
   outcome: SessionOutcome,
   commitHash: string | undefined,
   commitError: string | undefined,
@@ -536,13 +679,19 @@ function emitTaskOutcomeProgress(
     : outcome.reportedStatus === "blocked"
       ? "task_blocked"
       : "task_failed";
-  const update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath"> = {
+  const update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath" | "workerCostTotal"> = {
     phase,
     taskId: task.taskId,
     title: task.title,
     attempt: outcome.attempt,
     status: outcome.reportedStatus,
-    ...currentTaskProgress(task, outcome.done ? "done" : "in_progress"),
+    ...currentTaskProgress(task, outcomeProgressItemStatus(outcome)),
+    taskProgress: buildTaskProgressModel({
+      tasks,
+      attempts,
+      currentTaskId: task.taskId,
+      currentTaskStatus: outcomeTaskProgressStatus(outcome),
+    }),
   };
   if (commitHash) {
     update.commitHash = commitHash;
@@ -556,6 +705,50 @@ function emitTaskOutcomeProgress(
   emitProgress(runtime, `TODO ${task.taskId} ${statusText}${commitText}.`, update);
 }
 
+function buildCompletionTaskProgressModel(
+  tasks: readonly Task[],
+  attempts: readonly TaskAttemptSummary[],
+  status: CoordinatorStatus,
+): TaskProgressModel {
+  if (status === "done") {
+    return buildTaskProgressModel({ tasks, attempts });
+  }
+
+  const lastIncompleteAttempt = [...attempts].reverse().find((attempt) => !attempt.done);
+  if (!lastIncompleteAttempt) {
+    return buildTaskProgressModel({ tasks, attempts });
+  }
+
+  return buildTaskProgressModel({
+    tasks,
+    attempts,
+    currentTaskId: lastIncompleteAttempt.taskId,
+    currentTaskStatus: outcomeTaskProgressStatus(lastIncompleteAttempt),
+  });
+}
+
+function outcomeTaskProgressStatus(outcome: Pick<SessionOutcome, "done" | "reportedStatus">): TaskProgressStatus {
+  if (outcome.done) {
+    return "completed";
+  }
+  if (outcome.reportedStatus === "blocked") {
+    return "blocked";
+  }
+  return "failed";
+}
+
+function outcomeProgressItemStatus(
+  outcome: Pick<SessionOutcome, "done" | "reportedStatus">,
+): CoordinatorProgressItemStatus {
+  if (outcome.done) {
+    return "done";
+  }
+  if (outcome.reportedStatus === "blocked") {
+    return "blocked";
+  }
+  return "failed";
+}
+
 function initialTaskResultMarkdown(runId: string): string {
   return `# Pi Long Task TASK_RESULT\n\nRun: ${runId}\n`;
 }
@@ -677,6 +870,20 @@ function positiveMilliseconds(value: number | undefined, fallback: number): numb
   return fallback;
 }
 
+function finiteNonNegativeNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function formatCost(value: number): string {
+  if (value === 0) {
+    return "$0";
+  }
+  if (value < 0.01) {
+    return `$${value.toFixed(4)}`;
+  }
+  return `$${value.toFixed(2)}`;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }

package/src/index.ts

@@ -1,10 +1,60 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 
 import { runCoordinator, type CoordinatorProgressUpdate, type CoordinatorResult } from "./coordinator.ts";
 import { longTaskInputTransform } from "./input_router.ts";
 import { renderLongTaskToolCall, renderLongTaskToolResult } from "./render.ts";
 import { PiLongTaskParams } from "./types.ts";
 
+export function createWorkerCostAccumulator() {
+  let pendingWorkerCostTotal = 0;
+
+  return {
+    add(cost: number): void {
+      const value = finiteNonNegativeNumber(cost);
+      if (value && value > 0) {
+        pendingWorkerCostTotal += value;
+      }
+    },
+    applyToAssistantMessage(message: AssistantMessage): AssistantMessage | undefined {
+      if (pendingWorkerCostTotal <= 0) {
+        return undefined;
+      }
+
+      const replacement = addWorkerCostToAssistantMessage(message, pendingWorkerCostTotal);
+      if (replacement) {
+        pendingWorkerCostTotal = 0;
+      }
+      return replacement;
+    },
+  };
+}
+
+export function addWorkerCostToAssistantMessage(
+  message: AssistantMessage,
+  workerCostTotal: number,
+): AssistantMessage | undefined {
+  const workerCost = finiteNonNegativeNumber(workerCostTotal);
+  if (!workerCost || workerCost <= 0) {
+    return undefined;
+  }
+
+  return {
+    ...message,
+    usage: {
+      ...message.usage,
+      cost: {
+        ...message.usage.cost,
+        total: message.usage.cost.total + workerCost,
+      },
+    },
+  };
+}
+
+function finiteNonNegativeNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
 function toolDetails(result: CoordinatorResult) {
   return {
     runId: result.runId,
@@ -18,11 +68,24 @@ function toolDetails(result: CoordinatorResult) {
     failedTasks: result.failedTasks,
     blockedTasks: result.blockedTasks,
     remainingTasks: result.remainingTasks,
+    taskProgress: result.taskProgress,
+    workerCostTotal: result.workerCostTotal,
     summary: result.summary,
   };
 }
 
 export default function registerPiLongTaskExtension(pi: ExtensionAPI) {
+  const workerCostAccumulator = createWorkerCostAccumulator();
+
+  pi.on("message_end", (event) => {
+    if (event.message.role !== "assistant") {
+      return undefined;
+    }
+
+    const message = workerCostAccumulator.applyToAssistantMessage(event.message);
+    return message ? { message } : undefined;
+  });
+
   pi.on("input", (event) => {
     if (event.source === "extension") {
       return { action: "continue" as const };
@@ -63,6 +126,7 @@ export default function registerPiLongTaskExtension(pi: ExtensionAPI) {
         abortSignal: signal,
         onProgress: publishProgress,
       });
+      workerCostAccumulator.add(result.workerCostTotal);
 
       return {
         content: [