pi-long-task 0.6.0 → 0.7.1

package/src/worker_config.ts

@@ -3,11 +3,14 @@ import {
   resolveNetworkRecoveryConfig,
   type NetworkRecoveryConfigInput,
 } from "./network_recovery_config.ts";
+import { MAX_PLANNER_DURATION_MS, PlannerDurationConfigError } from "./planner_config.ts";
 
 export interface ParsedWorkerRuntimeConfig {
   modelName?: string;
   maxAttemptsPerTask?: number;
   taskTimeoutMs?: number;
+  todoTimeoutMs?: number;
+  todoGracefulShutdownMs?: number;
   maxBashTimeoutMs?: number;
   workerSessionReuseEnabled?: boolean;
   workerSessionReuseContextThresholdPercent?: number;
@@ -52,6 +55,8 @@ export function parseWorkerRuntimeConfig(text: string): ParsedWorkerRuntimeConfi
     ...(modelName ? { modelName } : {}),
     ...(state.maxAttemptsPerTask !== undefined ? { maxAttemptsPerTask: state.maxAttemptsPerTask } : {}),
     ...(state.taskTimeoutMs !== undefined ? { taskTimeoutMs: state.taskTimeoutMs } : {}),
+    ...(state.todoTimeoutMs !== undefined ? { todoTimeoutMs: state.todoTimeoutMs } : {}),
+    ...(state.todoGracefulShutdownMs !== undefined ? { todoGracefulShutdownMs: state.todoGracefulShutdownMs } : {}),
     ...(state.maxBashTimeoutMs !== undefined ? { maxBashTimeoutMs: state.maxBashTimeoutMs } : {}),
     ...(state.workerSessionReuseEnabled !== undefined
       ? { workerSessionReuseEnabled: state.workerSessionReuseEnabled }
@@ -135,14 +140,36 @@ function parseNaturalLanguageDirectives(text: string, state: MutableWorkerRuntim
 
   captureDurations(
     text,
-    /\b(?<!bash\s)(?<!max\s)(?:worker\s+|task\s+)?timeout\s*(?:is|=|:|to|of)?\s*(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?)/gi,
+    /\b(?:todo\s+)?(?:planner|planning)\s+timeout\s*(?:is|=|:|to|of)?\s*(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?)/gi,
+    (value) => {
+      state.todoTimeoutMs = value;
+    },
+  );
+  captureDurations(
+    text,
+    /\b(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h))\s+(?:todo\s+)?(?:planner|planning)\s+timeout\b/gi,
+    (value) => {
+      state.todoTimeoutMs = value;
+    },
+  );
+  captureDurations(
+    text,
+    /\b(?:todo\s+)?(?:planner|planning)\s+(?:grace(?:ful)?(?:\s+shutdown|\s+period)?|shutdown\s+grace(?:\s+period)?)\s*(?:duration\s*)?(?:is|=|:|to|of)?\s*(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?)/gi,
+    (value) => {
+      state.todoGracefulShutdownMs = value;
+    },
+    { allowZero: true },
+  );
+  captureDurations(
+    text,
+    /\b(?<!bash\s)(?<!max\s)(?<!planner\s)(?<!planning\s)(?:worker\s+|task\s+)?timeout\s*(?:is|=|:|to|of)?\s*(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?)/gi,
     (value) => {
       state.taskTimeoutMs = value;
     },
   );
   captureDurations(
     text,
-    /\b(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h))\s+(?:worker\s+|task\s+)?timeout\b/gi,
+    /\b(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h))[ \t]+(?:worker[ \t]+|task[ \t]+)?timeout\b/gi,
     (value) => {
       state.taskTimeoutMs = value;
     },
@@ -215,6 +242,16 @@ function applyDirective(key: string, value: string, state: MutableWorkerRuntimeC
     return;
   }
 
+  if (/\b(?:planner|planning)\b/.test(key) && /\b(?:grace|graceful|shutdown)\b/.test(key)) {
+    state.todoGracefulShutdownMs = requiredPlannerDuration("graceful-shutdown duration", value, true);
+    return;
+  }
+
+  if (/\b(?:planner|planning)\b/.test(key) && /\btimeout\b/.test(key)) {
+    state.todoTimeoutMs = requiredPlannerDuration("timeout", value, false);
+    return;
+  }
+
   if (/\bbash\b/.test(key) && /\btimeout\b/.test(key)) {
     const timeout = durationMsFromText(value, { allowBareSeconds: true });
     if (timeout !== undefined) {
@@ -268,6 +305,23 @@ function applyNetworkRecoveryDirective(key: string, value: string, state: Mutabl
   throw new NetworkRecoveryConfigError(`Unknown network recovery configuration directive: ${key}.`);
 }
 
+function requiredPlannerDuration(label: string, value: string, allowZero: boolean): number {
+  const trimmed = trimDirectiveValue(value)
+    .replace(/[.!]+$/g, "")
+    .trim();
+  const match = /^(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?$/i.exec(
+    trimmed,
+  );
+  const milliseconds = match ? durationMsFromText(trimmed, { allowBareSeconds: true, allowZero }) : undefined;
+  if (milliseconds === undefined || milliseconds > MAX_PLANNER_DURATION_MS) {
+    const minimum = allowZero ? "non-negative" : "positive";
+    throw new PlannerDurationConfigError(
+      `TODO planner ${label} must be a ${minimum} finite duration no greater than about 24.9 days (${MAX_PLANNER_DURATION_MS} milliseconds), for example 30s or 5m.`,
+    );
+  }
+  return milliseconds;
+}
+
 function requiredNetworkRecoveryDuration(label: string, value: string): number {
   const trimmed = trimDirectiveValue(value)
     .replace(/[.!]+$/g, "")
@@ -307,9 +361,17 @@ function captureNumbers(text: string, pattern: RegExp, apply: (value: number) =>
   }
 }
 
-function captureDurations(text: string, pattern: RegExp, apply: (value: number) => void): void {
+function captureDurations(
+  text: string,
+  pattern: RegExp,
+  apply: (value: number) => void,
+  options: { allowZero?: boolean } = {},
+): void {
   for (const match of text.matchAll(pattern)) {
-    const value = durationMsFromText(match[1] ?? "", { allowBareSeconds: true });
+    const value = durationMsFromText(match[1] ?? "", {
+      allowBareSeconds: true,
+      allowZero: options.allowZero,
+    });
     if (value !== undefined) {
       apply(value);
     }
@@ -373,7 +435,10 @@ function booleanSetting(value: string): boolean | undefined {
   return undefined;
 }
 
-function durationMsFromText(value: string, options: { allowBareSeconds: boolean }): number | undefined {
+function durationMsFromText(
+  value: string,
+  options: { allowBareSeconds: boolean; allowZero?: boolean },
+): number | undefined {
   const match = /(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?\b/i.exec(
     value,
   );
@@ -382,7 +447,7 @@ function durationMsFromText(value: string, options: { allowBareSeconds: boolean
   }
 
   const amount = Number.parseFloat(match[1] ?? "");
-  if (!Number.isFinite(amount) || amount <= 0) {
+  if (!Number.isFinite(amount) || amount < 0 || (!options.allowZero && amount === 0)) {
     return undefined;
   }
 
@@ -393,7 +458,9 @@ function durationMsFromText(value: string, options: { allowBareSeconds: boolean
 
   const multiplier = durationMultiplier(unit || "seconds");
   const milliseconds = Math.round(amount * multiplier);
-  return Number.isSafeInteger(milliseconds) && milliseconds > 0 ? milliseconds : undefined;
+  return Number.isSafeInteger(milliseconds) && (options.allowZero ? milliseconds >= 0 : milliseconds > 0)
+    ? milliseconds
+    : undefined;
 }
 
 function durationMultiplier(unit: string): number {

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 "";