pi-long-task 0.3.15 → 0.3.17

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 Notable changes to Pi Long Task are recorded here. This project follows semantic versioning.
 
+## 0.3.17 - 2026-08-26
+
+### Fixed
+
+- Prevent repeated `Finished:` and `Failed:` prefixes from accumulating in the sidebar's active status across tool events.
+- Reset the active status at every tool start so a completed tool's status cannot leak into the next tool.
+
+## 0.3.16 - 2026-08-20
+
+### Changed
+
+- Make the sidebar's "Active status" follow live worker commentary and tool activity instead of repeating a generic coordinator message.
+- Show active bash commands and read, edit, and write paths, including tool completion or failure state.
+- Preserve the latest worker activity across unrelated cost updates while keeping the compact fallback layout unchanged.
+
 ## 0.3.15 - 2026-08-20
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "type": "module",
   "description": "Pi coding agent extension that breaks large coding requests into tracked TODOs and runs them in isolated AI worker sessions. A long-running task runner and subagent orchestrator for Pi, with a live TUI progress sidebar, retries, goal loops, and optional per-task git commits.",
   "keywords": [

package/src/coordinator.ts

@@ -96,6 +96,7 @@ export interface CoordinatorProgressUpdate {
   commitSkipped?: string;
   toolName?: string;
   workerEventType?: string;
+  activeStatus?: string;
   isError?: boolean;
   totalTasks?: number;
   workerCostTotal: number;
@@ -215,6 +216,9 @@ interface RuntimeOptions {
   now: () => Date;
   onProgress?: CoordinatorProgressHandler;
   workerCostState: WorkerCostState;
+  workerActivityByWorker: Map<string, string>;
+  workerTextByWorker: Map<string, string>;
+  workerTextPublishedLengthByWorker: Map<string, number>;
   plannerDiagnostics: PlannerDiagnostic[];
 }
 
@@ -261,6 +265,12 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       }
 
       const attempt = (previousAttempts.get(nextTask.taskId)?.length ?? 0) + 1;
+      const initialActivity =
+        nextTask.statusItems.find((item) => !item.done)?.text ?? `Starting TODO ${nextTask.taskId}`;
+      const worker = workerKey(nextTask.taskId, attempt);
+      runtime.workerActivityByWorker.set(worker, initialActivity);
+      runtime.workerTextByWorker.delete(worker);
+      runtime.workerTextPublishedLengthByWorker.delete(worker);
       emitProgress(
         runtime,
         `Running TODO ${nextTask.taskId} — ${nextTask.title}${attempt > 1 ? ` (attempt ${attempt})` : ""}...`,
@@ -269,6 +279,7 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
           taskId: nextTask.taskId,
           title: nextTask.title,
           attempt,
+          activeStatus: initialActivity,
           ...currentTaskProgress(nextTask, "in_progress"),
           taskProgress: buildTaskProgressModel({
             tasks: tasksBeforeAttempt,
@@ -792,6 +803,9 @@ function buildRuntimeOptions(options: RunCoordinatorOptions): RuntimeOptions {
     now: options.now ?? (() => new Date()),
     onProgress: options.onProgress,
     workerCostState: createWorkerCostState(),
+    workerActivityByWorker: new Map(),
+    workerTextByWorker: new Map(),
+    workerTextPublishedLengthByWorker: new Map(),
     plannerDiagnostics: [],
   };
 }
@@ -950,11 +964,74 @@ function emitWorkerEventProgress(
   task: Pick<Task, "taskId" | "title" | "statusItems">,
   attempts: readonly TaskAttemptSummary[],
   attempt: number,
-  event: { type: string; toolName?: string; isError?: boolean; usageCostTotal?: number; usageCostKey?: string },
+  event: {
+    type: string;
+    toolName?: string;
+    activity?: string;
+    textDelta?: string;
+    isError?: boolean;
+    usageCostTotal?: number;
+    usageCostKey?: string;
+  },
 ): void {
-  if (event.usageCostTotal !== undefined) {
-    const changed = recordLiveWorkerCost(runtime.workerCostState, workerKey(task.taskId, attempt), event);
-    if (changed) {
+  const worker = workerKey(task.taskId, attempt);
+  let activeStatus = runtime.workerActivityByWorker.get(worker);
+
+  if (event.type === "message_update" && event.textDelta) {
+    const workerText = `${runtime.workerTextByWorker.get(worker) ?? ""}${event.textDelta}`;
+    runtime.workerTextByWorker.set(worker, workerText);
+    const streamedStatus = activeStatusFromWorkerText(workerText);
+    const publishedLength = runtime.workerTextPublishedLengthByWorker.get(worker) ?? 0;
+    const publishBoundary = /[\n.!?:]\s*$/.test(event.textDelta) || streamedStatus.length - publishedLength >= 48;
+    if (streamedStatus && publishBoundary) {
+      activeStatus = streamedStatus;
+      runtime.workerActivityByWorker.set(worker, activeStatus);
+      runtime.workerTextPublishedLengthByWorker.set(worker, streamedStatus.length);
+      emitProgress(runtime, activeStatus, {
+        phase: "worker_tool",
+        taskId: task.taskId,
+        title: task.title,
+        attempt,
+        status: "in_progress",
+        workerEventType: event.type,
+        activeStatus,
+        ...currentTaskProgress(task, "in_progress"),
+        taskProgress: buildTaskProgressModel({ tasks, attempts, currentTaskId: task.taskId }),
+      });
+    }
+    return;
+  }
+
+  if (event.type === "message_end") {
+    runtime.workerTextByWorker.delete(worker);
+    runtime.workerTextPublishedLengthByWorker.delete(worker);
+  }
+
+  if (event.activity) {
+    activeStatus = event.activity;
+    runtime.workerActivityByWorker.set(worker, activeStatus);
+  }
+
+  const costChanged =
+    event.usageCostTotal !== undefined && recordLiveWorkerCost(runtime.workerCostState, worker, event);
+
+  if (event.type === "message_end" && event.activity) {
+    emitProgress(runtime, event.activity, {
+      phase: "worker_tool",
+      taskId: task.taskId,
+      title: task.title,
+      attempt,
+      status: "in_progress",
+      workerEventType: event.type,
+      activeStatus,
+      ...currentTaskProgress(task, "in_progress"),
+      taskProgress: buildTaskProgressModel({ tasks, attempts, currentTaskId: task.taskId }),
+    });
+    return;
+  }
+
+  if (!event.toolName || (event.type !== "tool_execution_start" && event.type !== "tool_execution_end")) {
+    if (costChanged) {
       emitProgress(
         runtime,
         `TODO ${task.taskId}: worker cost updated to ${formatCost(runtime.workerCostState.total)}.`,
@@ -965,17 +1042,29 @@ function emitWorkerEventProgress(
           attempt,
           status: "in_progress",
           workerEventType: event.type,
+          activeStatus,
           ...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";
+  if (event.type === "tool_execution_end") {
+    const previousActivity = stripToolOutcomePrefix(
+      runtime.workerActivityByWorker.get(worker) ?? `Running ${event.toolName}`,
+    );
+    activeStatus = event.isError ? `Failed: ${previousActivity}` : `Finished: ${previousActivity}`;
+    runtime.workerActivityByWorker.set(worker, activeStatus);
+  } else {
+    // Every tool start begins a new activity. Keeping the previous tool's completed
+    // status here causes each later tool end to prepend another "Finished:" label.
+    activeStatus = event.activity ?? `Running ${event.toolName}`;
+    runtime.workerActivityByWorker.set(worker, activeStatus);
+  }
+
   const update: Omit<CoordinatorProgressUpdate, "message" | "runId" | "todoPath" | "resultPath" | "workerCostTotal"> = {
     phase: "worker_tool",
     taskId: task.taskId,
@@ -984,6 +1073,7 @@ function emitWorkerEventProgress(
     status: action,
     toolName: event.toolName,
     workerEventType: event.type,
+    activeStatus,
     isError: event.isError,
     ...currentTaskProgress(task, "in_progress"),
     taskProgress: buildTaskProgressModel({ tasks, attempts, currentTaskId: task.taskId }),
@@ -991,7 +1081,16 @@ function emitWorkerEventProgress(
   if (event.isError) {
     update.status = "failed";
   }
-  emitProgress(runtime, `TODO ${task.taskId}: worker tool ${event.toolName} ${action}.`, update);
+  emitProgress(runtime, activeStatus, update);
+}
+
+function stripToolOutcomePrefix(activity: string): string {
+  return activity.replace(/^(?:(?:Finished|Failed):\s*)+/i, "");
+}
+
+function activeStatusFromWorkerText(text: string): string {
+  const taskResultIndex = text.indexOf("TASK_RESULT:");
+  return (taskResultIndex >= 0 ? text.slice(0, taskResultIndex) : text).replace(/\s+/g, " ").trim();
 }
 
 function emitTaskOutcomeProgress(

package/src/index.ts

@@ -277,7 +277,7 @@ function renderSidebarWidgetLines(update: CoordinatorProgressUpdate): string[] {
   const statusDetails = sidebarUpdateStateDetails(update);
   const lines = [
     "Pi Long Task",
-    ...wrapPlainText(`${statusDetails.icon} ${statusDetails.label} · ${update.message}`, 96),
+    `${statusDetails.icon} ${statusDetails.label} · ${update.activeStatus ?? update.message}`,
   ];
   if (summary) {
     lines.push(
@@ -293,9 +293,7 @@ function renderSidebarWidgetLines(update: CoordinatorProgressUpdate): string[] {
     const currentTask = currentIndex >= 0 ? progress.tasks[currentIndex] : undefined;
     if (currentTask) {
       const details = taskStatusDetails(currentTask.status);
-      lines.push(
-        ...wrapPlainText(`${details.label}: ${details.icon} TODO ${currentTask.taskId} — ${currentTask.title}`, 96),
-      );
+      lines.push(`${details.label}: ${details.icon} TODO ${currentTask.taskId} — ${currentTask.title}`);
     }
   }
   if (update.workerCostTotal > 0) {
@@ -397,10 +395,10 @@ function renderSidebarRows(update: CoordinatorProgressUpdate | undefined, theme:
     rows.push(theme.fg("success", "No active task"));
   }
 
-  const message = normalizeMessageForSidebar(update.message, update);
-  if (currentTask && message) {
+  const activeStatus = update.activeStatus ?? normalizeMessageForSidebar(update.message, update);
+  if (currentTask && activeStatus) {
     rows.push("", sidebarHeading("Active status", theme));
-    rows.push(...wrapPlainText(message, width, 6).map((line) => theme.fg("dim", line)));
+    rows.push(...wrapPlainText(activeStatus, width, 6).map((line) => theme.fg("accent", line)));
   }
 
   rows.push("", sidebarHeading("Task timeline", theme));

package/src/worker_session.ts

@@ -275,6 +275,7 @@ export interface CapturedWorkerEvent {
   type: string;
   textDelta?: string;
   toolName?: string;
+  activity?: string;
   isError?: boolean;
   note?: string;
   usageCostTotal?: number;
@@ -887,18 +888,25 @@ function summarizeWorkerEvent(event: unknown): CapturedWorkerEvent | undefined {
   }
 
   if (event.type.startsWith("tool_execution_")) {
+    const toolName = typeof event.toolName === "string" ? event.toolName : undefined;
     return {
       type: event.type,
-      toolName: typeof event.toolName === "string" ? event.toolName : undefined,
+      toolName,
+      activity:
+        event.type === "tool_execution_start" && toolName ? workerToolActivity(toolName, event.args) : undefined,
       isError: typeof event.isError === "boolean" ? event.isError : undefined,
     };
   }
 
   if (event.type === "message_end") {
     const usageCostTotal = workerUsageCostFromEvent(event);
-    return usageCostTotal === undefined
-      ? { type: event.type }
-      : { type: event.type, usageCostTotal, usageCostKey: workerUsageCostKeyFromEvent(event) };
+    const activity = workerAssistantActivity(assistantMessageText(event.message));
+    return {
+      type: event.type,
+      activity: activity || undefined,
+      usageCostTotal,
+      usageCostKey: usageCostTotal === undefined ? undefined : workerUsageCostKeyFromEvent(event),
+    };
   }
 
   if (
@@ -915,6 +923,36 @@ function summarizeWorkerEvent(event: unknown): CapturedWorkerEvent | undefined {
   return undefined;
 }
 
+function workerToolActivity(toolName: string, argsValue: unknown): string {
+  const args = isRecord(argsValue) ? argsValue : undefined;
+  const path = args && typeof args.path === "string" ? args.path : "";
+
+  switch (toolName) {
+    case "bash": {
+      const command = args && typeof args.command === "string" ? oneLine(args.command) : "";
+      return command ? `$ ${command}` : "Running bash";
+    }
+    case "read":
+      return path ? `Reading ${path}` : "Reading a file";
+    case "edit":
+      return path ? `Editing ${path}` : "Editing a file";
+    case "write":
+      return path ? `Writing ${path}` : "Writing a file";
+    default:
+      return `Running ${toolName}`;
+  }
+}
+
+function workerAssistantActivity(text: string): string {
+  const taskResultIndex = text.indexOf("TASK_RESULT:");
+  const activity = oneLine(taskResultIndex >= 0 ? text.slice(0, taskResultIndex) : text);
+  return activity || (taskResultIndex >= 0 ? "Reporting task results" : "");
+}
+
+function oneLine(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
 export function workerUsageCostFromEvent(event: unknown): number | undefined {
   if (!isRecord(event)) {
     return undefined;