pi-long-task 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Notable changes to Pi Long Task are recorded here. This project follows semantic versioning.
 
+## 0.7.1 - 2026-09-23
+
+### Performance
+
+- Coalesce and cap retained worker token-delta events instead of returning thousands of tiny diagnostic objects, while preserving complete final assistant results.
+- Bound and throttle live worker commentary so long streamed responses do not trigger quadratic text processing or excessive progress renders.
+- Keep planner-generated task counts lean by combining tightly coupled implementation, test, and documentation work, and guide workers to batch independent inspection and use focused checks.
+
 ## 0.7.0 - 2026-09-08
 
 ### Added

package/README.md

@@ -258,6 +258,10 @@ Pi Long Task coordinates a long request from planning through task completion:
 5. **Write run artifacts:** the coordinator writes the generated/normalized `TODO.md`, `TASK_RESULT.md`, attempt summaries, and final run details to `tmp/pi-long-task/<run-id>/`.
 6. **Commit only when enabled:** if `commit` is `true`, Pi Long Task may create a commit after each completed task using only eligible task changes. If commits are disabled, no commits are created; even when enabled, commits can be skipped when there are no eligible changes or the task outcome is not commit-worthy.
 
+### Low-overhead streaming and planning
+
+Pi Long Task keeps live status responsive without serializing every model token as a separate diagnostic event. Worker text updates use a bounded rolling status buffer, progress publication is throttled, and retained token deltas are coalesced and capped; the complete final assistant result remains available in each outcome. Planning prompts also tell the planner to use the fewest safe worker handoffs and to keep tightly coupled implementation, tests, and documentation in one assignment when they share context.
+
 ### Adaptive worker-session reuse
 
 Reuse is enabled by default. Related sequential TODOs in the same coordinator run and worktree may share one idle Pi `AgentSession`, which avoids repeated startup and repository exploration. Reuse does not merge task semantics: every TODO still gets its complete current assignment, an explicit boundary from the previous assignment, its own result extraction, attempts, progress, and `TASK_RESULT` outcome.
@@ -426,6 +430,7 @@ Pi session statistics can be cumulative across reused assignments. `outcomes[].w
 
 ## Feature reference
 
+- **Low-overhead execution:** coalesce and bound streamed token diagnostics, throttle live commentary updates, and minimize unnecessary model handoffs without dropping final worker results.
 - **Adaptive TODO-planner budgets:** deterministically extend the normal 5-minute budget for explicit large item sets, up to 15 minutes, while preserving exact caller overrides.
 - **Visible planner timing:** report effective budget, extension reason, elapsed/remaining time, grace entry, and safe partial-output diagnostics across CLI/TUI and headless progress.
 - **Capability-aware planning:** warn when isolated workers are explicitly asked to use disabled extensions or unavailable browser tools, then constrain the plan to honest alternatives or a blocked result.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "description": "Pi coding agent extension that breaks large coding requests into tracked TODOs and runs them in bounded, adaptively reused 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

@@ -101,6 +101,11 @@ import {
 
 export type { CoordinatorStatus } from "./types.ts";
 
+const WORKER_PROGRESS_MAX_BUFFER_CHARS = 2_048;
+const WORKER_PROGRESS_MAX_STATUS_CHARS = 800;
+const WORKER_PROGRESS_MIN_CHARACTER_DELTA = 256;
+const WORKER_PROGRESS_MIN_INTERVAL_MS = 100;
+
 export const DEFAULT_COORDINATOR_OPTIONS = {
   maxAttemptsPerTask: 3,
   taskTimeoutMs: 900_000,
@@ -385,7 +390,9 @@ interface RuntimeOptions {
   workerCostState: WorkerCostState;
   workerActivityByWorker: Map<string, string>;
   workerTextByWorker: Map<string, string>;
+  workerTextLengthByWorker: Map<string, number>;
   workerTextPublishedLengthByWorker: Map<string, number>;
+  workerTextPublishedAtByWorker: Map<string, number>;
   plannerDiagnostics: PlannerDiagnostic[];
   capabilityWarnings: WorkerCapabilityWarning[];
   workerSessionMetrics: WorkerSessionMetrics;
@@ -1183,7 +1190,9 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
       activeTaskReference = taskPlanReference;
       runtime.workerActivityByWorker.set(worker, initialActivity);
       runtime.workerTextByWorker.delete(worker);
+      runtime.workerTextLengthByWorker.delete(worker);
       runtime.workerTextPublishedLengthByWorker.delete(worker);
+      runtime.workerTextPublishedAtByWorker.delete(worker);
       emitProgress(
         runtime,
         `Running TODO ${nextTask.taskId} — ${nextTask.title}${attempt > 1 ? ` (attempt ${attempt})` : ""}...`,
@@ -2208,7 +2217,9 @@ function buildRuntimeOptions(options: RunCoordinatorOptions): RuntimeOptions {
     workerCostState: createWorkerCostState(),
     workerActivityByWorker: new Map(),
     workerTextByWorker: new Map(),
+    workerTextLengthByWorker: new Map(),
     workerTextPublishedLengthByWorker: new Map(),
+    workerTextPublishedAtByWorker: new Map(),
     plannerDiagnostics: [],
     capabilityWarnings,
     workerSessionMetrics: createWorkerSessionMetrics(),
@@ -2668,15 +2679,23 @@ function emitWorkerEventProgress(
   let activeStatus = runtime.workerActivityByWorker.get(worker);
 
   if (event.type === "message_update" && event.textDelta) {
-    const workerText = `${runtime.workerTextByWorker.get(worker) ?? ""}${event.textDelta}`;
+    const previousText = runtime.workerTextByWorker.get(worker) ?? "";
+    const workerText = `${previousText}${event.textDelta}`.slice(-WORKER_PROGRESS_MAX_BUFFER_CHARS);
+    const receivedLength = (runtime.workerTextLengthByWorker.get(worker) ?? 0) + event.textDelta.length;
     runtime.workerTextByWorker.set(worker, workerText);
+    runtime.workerTextLengthByWorker.set(worker, receivedLength);
     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) {
+    const publishedAt = runtime.workerTextPublishedAtByWorker.get(worker);
+    const nowMs = runtime.now().getTime();
+    const sentenceBoundary = /[\n.!?:]\s*$/.test(event.textDelta);
+    const enoughTimeElapsed = publishedAt === undefined || nowMs - publishedAt >= WORKER_PROGRESS_MIN_INTERVAL_MS;
+    const enoughNewText = receivedLength - publishedLength >= WORKER_PROGRESS_MIN_CHARACTER_DELTA;
+    if (streamedStatus && ((sentenceBoundary && enoughTimeElapsed) || enoughNewText)) {
       activeStatus = streamedStatus;
       runtime.workerActivityByWorker.set(worker, activeStatus);
-      runtime.workerTextPublishedLengthByWorker.set(worker, streamedStatus.length);
+      runtime.workerTextPublishedLengthByWorker.set(worker, receivedLength);
+      runtime.workerTextPublishedAtByWorker.set(worker, nowMs);
       emitProgress(runtime, activeStatus, {
         phase: "worker_tool",
         taskId: task.taskId,
@@ -2694,7 +2713,9 @@ function emitWorkerEventProgress(
 
   if (event.type === "message_end") {
     runtime.workerTextByWorker.delete(worker);
+    runtime.workerTextLengthByWorker.delete(worker);
     runtime.workerTextPublishedLengthByWorker.delete(worker);
+    runtime.workerTextPublishedAtByWorker.delete(worker);
   }
 
   if (event.activity) {
@@ -2780,7 +2801,9 @@ function stripToolOutcomePrefix(activity: string): string {
 
 function activeStatusFromWorkerText(text: string): string {
   const taskResultIndex = text.indexOf("TASK_RESULT:");
-  return (taskResultIndex >= 0 ? text.slice(0, taskResultIndex) : text).replace(/\s+/g, " ").trim();
+  const normalized = (taskResultIndex >= 0 ? text.slice(0, taskResultIndex) : text).replace(/\s+/g, " ").trim();
+  if (normalized.length <= WORKER_PROGRESS_MAX_STATUS_CHARS) return normalized;
+  return `… ${normalized.slice(-WORKER_PROGRESS_MAX_STATUS_CHARS + 2)}`;
 }
 
 function emitObsoleteTaskOutcomeProgress(

package/src/session_guard.ts

@@ -23,6 +23,8 @@ export interface GuardedSessionPromptOptions {
   dispose?: boolean;
 }
 
+const MAX_CAPTURED_SESSION_EVENTS = 512;
+
 export interface GuardedSessionPromptResult {
   assistantText: string;
   /** True when the primary prompt deadline elapsed, even if the prompt safely completed during grace. */
@@ -54,7 +56,7 @@ export async function runGuardedSessionPrompt(
   const events: unknown[] = [];
   const timers = new Set<ReturnType<typeof setTimeout>>();
   let assistantText = "";
-  let currentAssistantText = "";
+  let currentAssistantTextChunks: string[] = [];
   let outputObserved = false;
   let timedOut = false;
   let graceExpired = false;
@@ -198,18 +200,19 @@ export async function runGuardedSessionPrompt(
     } else {
       unsubscribe = session.subscribe((event: unknown) => {
         events.push(event);
+        if (events.length > MAX_CAPTURED_SESSION_EVENTS) events.shift();
         if (isAssistantMessageStart(event)) {
-          currentAssistantText = "";
+          currentAssistantTextChunks = [];
+          assistantText = "";
         }
         const delta = assistantTextDeltaFromEvent(event);
         if (delta !== undefined) {
-          currentAssistantText += delta;
-          assistantText = currentAssistantText || assistantText;
+          if (delta) currentAssistantTextChunks.push(delta);
           outputObserved ||= delta.trim().length > 0;
         } else {
           const text = assistantTextFromEvent(event);
           if (text) {
-            currentAssistantText = text;
+            currentAssistantTextChunks = [text];
             assistantText = text;
             outputObserved ||= text.trim().length > 0;
           }
@@ -259,7 +262,7 @@ export async function runGuardedSessionPrompt(
     clearTimers();
     options.abortSignal?.removeEventListener("abort", abortListener);
     unsubscribe?.();
-    assistantText = latestAssistantText(session, events, assistantText);
+    assistantText = latestAssistantText(session, events, currentAssistantTextChunks.join("") || assistantText);
     outputObserved ||= assistantText.trim().length > 0 && assistantText !== assistantTextAtStart;
     if (options.dispose !== false) {
       try {
@@ -331,8 +334,10 @@ function latestAssistantText(session: WorkerSessionLike, events: unknown[], fall
   if (fromMessages) {
     return fromMessages;
   }
-  const fromEvents = lastAssistantTextFromEvents(events);
-  return fromEvents || fallback;
+  if (fallback) {
+    return fallback;
+  }
+  return lastAssistantTextFromEvents(events);
 }
 
 function timeoutMs(value: number | undefined): number {

package/src/todo_generator.ts

@@ -259,6 +259,7 @@ export function todoPlanningOnlyPromptBlock(capabilityConstraints: readonly stri
 - Do not perform requested end work: do not implement or write code, execute research or report findings, create requested creative output (prose, stories, copy, designs, or assets), or produce any other final deliverable.
 - Use future-worker action language; do not claim work is complete or invent results.
 - Keep repeated task sections compact: use a one-sentence Goal and Done when, plus only the necessary Status and Verify bullets. Omit rationale, lengthy analysis, summaries, duplicated context, unrequested examples, and boilerplate.
+- Minimize worker handoffs because each TODO starts another model assignment. Use the fewest tasks that safely preserve dependencies and explicit boundaries; combine tightly coupled implementation, tests, and documentation that use the same context. Do not create separate setup, audit, or final-verification tasks when that work belongs inside an implementation task.
 - Preserve every instruction, constraint, required deliverable, and acceptance condition from the source request and supplied planning context. Put shared constraints above ## Progress and task-specific requirements in the relevant task.${capabilityBlock}`;
 }
 

package/src/worker_session.ts

@@ -113,6 +113,7 @@ Rules:
 - If you need to stop because context is high or the work is blocked, leave the repository in a safe state and report \`status: partial\` or \`status: blocked\`.
 - Use the repository's AGENTS.md/project instructions.
 - Run focused verification commands when practical.
+- Minimize latency: batch independent reads and searches when possible, avoid repeated repository-wide scans, and prefer focused checks over full suites unless the task requires a full suite.
 - Do not run bash commands with timeout greater than ${options.maxBashTimeoutSeconds.toFixed(0)} seconds. For long full-suite checks, run once with a bounded timeout and report any timeout/failure in TASK_RESULT instead of continuing indefinitely.
 - If TODO-file global instructions restrict scope, obey them strictly. If the task appears to require out-of-scope code changes, stop and report \`status: blocked\` instead of changing those files.
 
@@ -253,6 +254,9 @@ export const DEFAULT_WORKER_TOOLS = ["read", "bash", "edit", "write", "grep", "f
 export const DEFAULT_WORKER_THINKING_LEVEL = "high";
 export const DEFAULT_TASK_TIMEOUT_SECONDS = 60 * 60;
 export const DEFAULT_GRACEFUL_SHUTDOWN_SECONDS = 60;
+/** Keep streamed diagnostics useful without returning thousands of token-delta objects. */
+export const MAX_CAPTURED_WORKER_EVENTS = 256;
+export const MAX_CAPTURED_STREAM_TEXT_CHARS = 4_096;
 
 export interface WorkerSessionLike {
   prompt(text: string, options?: Record<string, unknown>): Promise<void>;
@@ -532,7 +536,7 @@ export async function runWorkerTaskAssignment(
   const compactionEvents: string[] = [];
   const events: CapturedWorkerEvent[] = [];
   let assistantText = "";
-  let currentAssistantText = "";
+  let currentAssistantTextChunks: string[] = [];
   let sessionFile: string | undefined;
   let sessionId: string | undefined;
   let shutdownRequested = false;
@@ -561,7 +565,7 @@ export async function runWorkerTaskAssignment(
   const timers = new Set<ReturnType<typeof setTimeout>>();
 
   const capture = (event: CapturedWorkerEvent) => {
-    events.push(event);
+    retainCapturedWorkerEvent(events, event);
     options.onEvent?.(event);
   };
 
@@ -711,7 +715,8 @@ export async function runWorkerTaskAssignment(
         case "message_start": {
           const message = event.message;
           if (isRecord(message) && message.role === "assistant") {
-            currentAssistantText = "";
+            currentAssistantTextChunks = [];
+            assistantText = "";
           }
           break;
         }
@@ -719,8 +724,7 @@ export async function runWorkerTaskAssignment(
           const assistantEvent = event.assistantMessageEvent;
           if (isRecord(assistantEvent) && assistantEvent.type === "text_delta") {
             const delta = typeof assistantEvent.delta === "string" ? assistantEvent.delta : "";
-            currentAssistantText += delta;
-            assistantText = currentAssistantText || assistantText;
+            if (delta) currentAssistantTextChunks.push(delta);
           }
           break;
         }
@@ -728,6 +732,7 @@ export async function runWorkerTaskAssignment(
           const messageText = assistantMessageText(event.message);
           if (messageText) {
             assistantText = messageText;
+            currentAssistantTextChunks = [messageText];
           }
           recordWorkerUsageCost(workerUsageCostFromEvent(event), workerUsageCostKeyFromEvent(event));
           break;
@@ -777,7 +782,8 @@ export async function runWorkerTaskAssignment(
 
     if (taskTimeoutSeconds > 0) {
       schedule(() => {
-        if (finished || hasCompleteTaskResult(assistantText)) {
+        const currentAssistantText = currentAssistantTextChunks.join("") || assistantText;
+        if (finished || hasCompleteTaskResult(currentAssistantText)) {
           return;
         }
         timedOut = true;
@@ -792,14 +798,24 @@ export async function runWorkerTaskAssignment(
     }
 
     await waitForPrompt(prompt);
-    assistantText = latestInvocationAssistantText(session, assistantText, invocationMessageStart, !reusedAssignment);
+    assistantText = latestInvocationAssistantText(
+      session,
+      currentAssistantTextChunks.join("") || assistantText,
+      invocationMessageStart,
+      !reusedAssignment,
+    );
 
     if (!hasCompleteTaskResult(assistantText) && !error && !aborted && !timedOut && !options.abortSignal?.aborted) {
       contextObservations.push(
         "missing TASK_RESULT status after initial prompt, or required fields were incomplete; requested required block once",
       );
       await waitForPrompt(buildMissingTaskResultMessage());
-      assistantText = latestInvocationAssistantText(session, assistantText, invocationMessageStart, !reusedAssignment);
+      assistantText = latestInvocationAssistantText(
+        session,
+        currentAssistantTextChunks.join("") || assistantText,
+        invocationMessageStart,
+        !reusedAssignment,
+      );
     }
   } catch (exc) {
     failure ??= exc;
@@ -809,7 +825,12 @@ export async function runWorkerTaskAssignment(
     clearTimers();
     options.abortSignal?.removeEventListener("abort", abortListener);
     unsubscribe?.();
-    assistantText = latestInvocationAssistantText(session, assistantText, invocationMessageStart, !reusedAssignment);
+    assistantText = latestInvocationAssistantText(
+      session,
+      currentAssistantTextChunks.join("") || assistantText,
+      invocationMessageStart,
+      !reusedAssignment,
+    );
     sessionFile = session.sessionFile ?? sessionFile;
     sessionId = session.sessionId ?? sessionId;
     sessionStatsEnd = await workerSessionStatsSnapshot(session);
@@ -907,6 +928,23 @@ export function buildWorkerSessionCreationFailureOutcome(
   };
 }
 
+function retainCapturedWorkerEvent(events: CapturedWorkerEvent[], event: CapturedWorkerEvent): void {
+  if (event.type === "message_update" && event.textDelta !== undefined) {
+    const previous = events.at(-1);
+    if (previous?.type === "message_update" && previous.textDelta !== undefined) {
+      previous.textDelta = `${previous.textDelta}${event.textDelta}`.slice(-MAX_CAPTURED_STREAM_TEXT_CHARS);
+      return;
+    }
+  }
+
+  events.push(event);
+  if (events.length <= MAX_CAPTURED_WORKER_EVENTS) return;
+
+  // Prefer evicting token-stream diagnostics over lifecycle/tool evidence.
+  const streamedIndex = events.findIndex((item) => item.type === "message_update");
+  events.splice(streamedIndex >= 0 ? streamedIndex : 0, 1);
+}
+
 function textFromContentPart(item: unknown): string {
   if (!isRecord(item)) {
     return "";