pi-long-task 0.3.12 → 0.3.13

package/src/goal_todo_execution.ts

@@ -120,6 +120,23 @@ export async function runGoalTodoExecutionLongTask(
 
   const progressEvents: CoordinatorProgressUpdate[] = [];
   const workerStartedAt = now();
+  const childTimeoutMs = timeoutForIteration(iteration, state, workerStartedAt);
+  if (childTimeoutMs <= 0) {
+    const failure = await recordExecutionFailure({
+      state,
+      iteration,
+      store,
+      previousTraceLength,
+      progressLogPath,
+      message: `Goal iteration ${iteration.iteration} has no time remaining for TODO execution.`,
+      error: new Error("iteration deadline exceeded"),
+      now,
+    });
+    throw new GoalTodoExecutionError(failure.workerResult.summary, {
+      state: failure.state,
+      workerResult: failure.workerResult,
+    });
+  }
   let childResult: CoordinatorResult;
   try {
     childResult = await (options.longTaskRunner ?? runCoordinator)({
@@ -132,7 +149,7 @@ export async function runGoalTodoExecutionLongTask(
       workerModel: options.model,
       workerModelName: options.modelName,
       taskThinking: options.thinkingLevel,
-      taskTimeoutMs: timeoutForIteration(iteration, state, now()),
+      taskTimeoutMs: childTimeoutMs,
       maxBashTimeoutMs: options.maxBashTimeoutMs,
       maxAttemptsPerTask: options.maxAttemptsPerTask,
       onProgress: (update) => {
@@ -294,14 +311,14 @@ async function writeProgressLog(progressLogPath: string, events: CoordinatorProg
 }
 
 function timeoutForIteration(iteration: GoalIterationState, state: GoalLoopState, now: Date): number {
-  if (!iteration.deadlineAt) {
-    return state.limits.iterationTimeoutMs;
-  }
-  const remaining = Date.parse(iteration.deadlineAt) - now.getTime();
-  if (!Number.isFinite(remaining) || remaining <= 0) {
-    return 1_000;
+  const iterationRemaining = iteration.deadlineAt
+    ? Date.parse(iteration.deadlineAt) - now.getTime()
+    : state.limits.iterationTimeoutMs;
+  const overallRemaining = state.deadlineAt ? Date.parse(state.deadlineAt) - now.getTime() : state.limits.timeoutMs;
+  if (!Number.isFinite(iterationRemaining) || !Number.isFinite(overallRemaining)) {
+    return 0;
   }
-  return Math.min(state.limits.iterationTimeoutMs, Math.max(1_000, Math.floor(remaining)));
+  return Math.floor(Math.min(state.limits.iterationTimeoutMs, iterationRemaining, overallRemaining));
 }
 
 function errorMessage(error: unknown): string {

package/src/goal_todo_generation.ts

@@ -85,6 +85,12 @@ export async function runGoalTodoGenerationLongTask(
   });
   const payloadPath = path.join(iterationDir, GOAL_TODO_GENERATION_PAYLOAD_FILE);
   await writeFile(payloadPath, payload, "utf8");
+  const childTimeoutMs = timeoutForIteration(iteration, state, now());
+  if (childTimeoutMs <= 0) {
+    throw new GoalTodoGenerationError(
+      `Goal iteration ${iteration.iteration} has no time remaining for TODO generation.`,
+    );
+  }
 
   const childResult = await (options.longTaskRunner ?? runCoordinator)({
     inputText: payload,
@@ -96,7 +102,7 @@ export async function runGoalTodoGenerationLongTask(
     workerModel: options.model,
     workerModelName: options.modelName,
     taskThinking: options.thinkingLevel,
-    taskTimeoutMs: timeoutForIteration(iteration, state, now()),
+    taskTimeoutMs: childTimeoutMs,
     maxBashTimeoutMs: options.maxBashTimeoutMs,
   });
 
@@ -125,6 +131,7 @@ export async function runGoalTodoGenerationLongTask(
       generatorRunDir: childResult.runDir,
       generatorResultPath: childResult.resultPath,
       generatorTaskResultPath: childResult.taskResultPath,
+      generatorWorkerCostTotal: childResult.workerCostTotal,
     },
     { now: now() },
   );
@@ -467,14 +474,14 @@ function ensureTrailingNewline(value: string): string {
 }
 
 function timeoutForIteration(iteration: GoalIterationState, state: GoalLoopState, now: Date): number {
-  if (!iteration.deadlineAt) {
-    return state.limits.iterationTimeoutMs;
-  }
-  const remaining = Date.parse(iteration.deadlineAt) - now.getTime();
-  if (!Number.isFinite(remaining) || remaining <= 0) {
-    return 1_000;
+  const iterationRemaining = iteration.deadlineAt
+    ? Date.parse(iteration.deadlineAt) - now.getTime()
+    : state.limits.iterationTimeoutMs;
+  const overallRemaining = state.deadlineAt ? Date.parse(state.deadlineAt) - now.getTime() : state.limits.timeoutMs;
+  if (!Number.isFinite(iterationRemaining) || !Number.isFinite(overallRemaining)) {
+    return 0;
   }
-  return Math.min(state.limits.iterationTimeoutMs, Math.max(1_000, Math.floor(remaining)));
+  return Math.floor(Math.min(state.limits.iterationTimeoutMs, iterationRemaining, overallRemaining));
 }
 
 function buildPreviousIterationContext(state: GoalLoopState): string {

package/src/result_writer.ts

@@ -3,7 +3,7 @@ export const PARTIAL_STATUSES = new Set(["partial", "incomplete", "blocked", "fa
 
 const TASK_RESULT_MARKER_RE = /TASK_RESULT\s*:/gi;
 const STATUS_LINE_RE = /^\s*status\s*:\s*([A-Za-z_-]+)\s*$/im;
-const FENCED_BLOCK_RE = /```[^\r\n`]*\r?\n([\s\S]*?)\r?\n```/g;
+const REQUIRED_LIST_FIELDS = ["changes", "verification", "remaining"] as const;
 
 export interface TaskResultBlock {
   marker: "TASK_RESULT";
@@ -11,6 +11,14 @@ export interface TaskResultBlock {
   fenced: boolean;
 }
 
+export interface ParsedTaskResult {
+  status: string;
+  summary: string;
+  changes: string[];
+  verification: string[];
+  remaining: string[];
+}
+
 export function isDoneStatus(status: string): boolean {
   return DONE_STATUSES.has(status.trim().toLowerCase());
 }
@@ -28,6 +36,33 @@ export function hasTaskResultStatus(assistantText: string): boolean {
   return Boolean(block && STATUS_LINE_RE.test(block.body));
 }
 
+export function parseCompleteTaskResult(assistantText: string): ParsedTaskResult | undefined {
+  const block = extractTaskResultBlock(assistantText);
+  if (!block) {
+    return undefined;
+  }
+
+  const fields = parseResultFields(block.body);
+  const status = fields.scalars.get("status")?.trim().toLowerCase() ?? "";
+  const summary = fields.scalars.get("summary")?.trim() ?? "";
+  if (!status || !summary || (!isDoneStatus(status) && !isPartialStatus(status))) {
+    return undefined;
+  }
+
+  const lists = Object.fromEntries(
+    REQUIRED_LIST_FIELDS.map((field) => [field, fields.lists.get(field) ?? []]),
+  ) as Record<(typeof REQUIRED_LIST_FIELDS)[number], string[]>;
+  if (REQUIRED_LIST_FIELDS.some((field) => lists[field].length === 0)) {
+    return undefined;
+  }
+
+  return { status, summary, ...lists };
+}
+
+export function hasCompleteTaskResult(assistantText: string): boolean {
+  return parseCompleteTaskResult(assistantText) !== undefined;
+}
+
 export function parseReportedStatus(assistantText: string): string {
   const block = extractTaskResultBlock(assistantText);
   const searchText = block ? block.body : assistantText || "";
@@ -56,41 +91,72 @@ export const summarizeAssistantResult = extractResultSummary;
 
 export function extractTaskResultBlock(assistantText: string): TaskResultBlock | undefined {
   const text = assistantText || "";
-  const fencedBlocks = fencedCodeBlocks(text);
-  for (let idx = fencedBlocks.length - 1; idx >= 0; idx -= 1) {
-    const body = taskResultBodyFromText(fencedBlocks[idx]);
-    if (body !== undefined) {
-      return { marker: "TASK_RESULT", body, fenced: true };
-    }
-  }
-
-  const body = taskResultBodyFromText(text);
-  if (body === undefined) {
-    return undefined;
-  }
-  return { marker: "TASK_RESULT", body: stripTrailingFence(body), fenced: false };
-}
-
-function taskResultBodyFromText(text: string): string | undefined {
   TASK_RESULT_MARKER_RE.lastIndex = 0;
   let match: RegExpExecArray | null;
   let lastMatch: RegExpExecArray | undefined;
   while ((match = TASK_RESULT_MARKER_RE.exec(text)) !== null) {
     lastMatch = match;
   }
-
   if (!lastMatch) {
     return undefined;
   }
 
-  return text.slice(lastMatch.index + lastMatch[0].length).trim();
+  const markerEnd = lastMatch.index + lastMatch[0].length;
+  const fence = enclosingFence(text, lastMatch.index);
+  const bodyEnd = fence?.end ?? text.length;
+  return {
+    marker: "TASK_RESULT",
+    body: text.slice(markerEnd, bodyEnd).trim(),
+    fenced: Boolean(fence),
+  };
 }
 
-function fencedCodeBlocks(text: string): string[] {
-  FENCED_BLOCK_RE.lastIndex = 0;
-  return [...text.matchAll(FENCED_BLOCK_RE)].map((match) => match[1]);
+function enclosingFence(text: string, position: number): { end: number } | undefined {
+  const fenceRe = /^(`{3,})[^\r\n`]*\r?\n/gm;
+  let match: RegExpExecArray | null;
+  while ((match = fenceRe.exec(text)) !== null) {
+    const contentStart = match.index + match[0].length;
+    const closeRe = new RegExp(`^${match[1]}\\s*$`, "gm");
+    closeRe.lastIndex = contentStart;
+    const close = closeRe.exec(text);
+    if (!close) {
+      continue;
+    }
+    if (position >= contentStart && position < close.index) {
+      return { end: close.index };
+    }
+    fenceRe.lastIndex = close.index + close[0].length;
+  }
+  return undefined;
 }
 
-function stripTrailingFence(text: string): string {
-  return text.replace(/\r?\n```\s*$/g, "").trim();
+function parseResultFields(body: string): {
+  scalars: Map<string, string>;
+  lists: Map<string, string[]>;
+} {
+  const scalars = new Map<string, string>();
+  const lists = new Map<string, string[]>();
+  let currentList: string | undefined;
+
+  for (const line of body.replace(/\r\n?/g, "\n").split("\n")) {
+    const field = /^\s*([A-Za-z_-]+)\s*:\s*(.*?)\s*$/.exec(line);
+    if (field) {
+      const name = field[1].toLowerCase();
+      currentList = REQUIRED_LIST_FIELDS.includes(name as (typeof REQUIRED_LIST_FIELDS)[number]) ? name : undefined;
+      if (currentList) {
+        lists.set(currentList, []);
+      } else {
+        scalars.set(name, field[2]);
+      }
+      continue;
+    }
+
+    if (currentList) {
+      const bullet = /^\s*[-*+]\s+(.+?)\s*$/.exec(line);
+      if (bullet?.[1]) {
+        lists.get(currentList)?.push(bullet[1]);
+      }
+    }
+  }
+  return { scalars, lists };
 }

package/src/todo_generator.ts

@@ -24,6 +24,7 @@ interface ExistingTask {
   taskId: string;
   title: string;
   body: string;
+  done: boolean;
 }
 
 export function todoMarkdownFromString(rawInput: string, goal?: string): string | undefined {
@@ -73,9 +74,6 @@ export function validateTodoMarkdown(markdown: string): void {
   if (!PROGRESS_HEADING_RE.test(trimmed)) {
     throw new TodoGenerationError("TODO markdown must include a `## Progress` section.");
   }
-  if (!/^---\s*$/m.test(trimmed)) {
-    throw new TodoGenerationError("TODO markdown must include a `---` separator before task sections.");
-  }
 
   let tasks;
   try {
@@ -91,6 +89,11 @@ export function validateTodoMarkdown(markdown: string): void {
     throw new TodoGenerationError("TODO markdown must include at least one task section.");
   }
 
+  const progressEntries = validatedProgressEntries(markdown, tasks[0].startLine - 1);
+  if (progressEntries.length !== tasks.length) {
+    throw new TodoGenerationError("Progress section must contain exactly one line for every task section.");
+  }
+
   tasks.forEach((task, idx) => {
     const expectedId = String(idx + 1);
     if (task.taskId !== expectedId) {
@@ -99,9 +102,11 @@ export function validateTodoMarkdown(markdown: string): void {
       );
     }
 
-    const progressLine = progressLineRegex(task.taskId, task.title);
-    if (!progressLine.test(markdown)) {
-      throw new TodoGenerationError(`Progress section must include an unchecked line for TODO ${task.taskId}.`);
+    const progressEntry = progressEntries[idx];
+    if (progressEntry?.taskId !== task.taskId || progressEntry.title !== task.title) {
+      throw new TodoGenerationError(
+        `Progress section entry ${idx + 1} must match TODO ${task.taskId} — ${task.title}.`,
+      );
     }
 
     if (!/\*\*Goal:\*\*/.test(task.section)) {
@@ -310,7 +315,7 @@ function normalizeExistingTodoMarkdown(input: string): string {
   }
 
   const globalInstructions = extractGlobalInstructions(input);
-  const progress = tasks.map((task, idx) => `- [ ] TODO ${idx + 1} — ${task.title}`).join("\n");
+  const progress = tasks.map((task, idx) => `- [${task.done ? "x" : " "}] TODO ${idx + 1} — ${task.title}`).join("\n");
   const sections = tasks.map((task, idx) => normalizeTaskSection({ ...task, taskId: String(idx + 1) })).join("\n\n");
 
   const globalBlock = globalInstructions ? `\n\n${globalInstructions}` : "";
@@ -318,17 +323,18 @@ function normalizeExistingTodoMarkdown(input: string): string {
 }
 
 function extractExistingTasks(input: string): ExistingTask[] {
-  TODO_HEADING_RE.lastIndex = 0;
-  const matches = [...input.matchAll(TODO_HEADING_RE)];
-  return matches.map((match, idx) => {
-    const bodyStart = (match.index ?? 0) + match[0].length;
-    const bodyEnd = idx + 1 < matches.length ? (matches[idx + 1].index ?? input.length) : input.length;
-    return {
-      taskId: match[1],
-      title: cleanTitle(match[2]),
-      body: input.slice(bodyStart, bodyEnd).trim(),
-    };
-  });
+  let tasks;
+  try {
+    tasks = parseTasks(input);
+  } catch {
+    return [];
+  }
+  return tasks.map((task) => ({
+    taskId: task.taskId,
+    title: cleanTitle(task.title),
+    body: task.section.replace(/^##\s+TODO\s+\d+\s+[—-]\s+.*(?:\r?\n)?/, "").trim(),
+    done: task.done,
+  }));
 }
 
 function extractGlobalInstructions(input: string): string {
@@ -424,12 +430,57 @@ function lowercaseFirst(value: string): string {
   return `${value[0].toLocaleLowerCase()}${value.slice(1)}`;
 }
 
-function progressLineRegex(taskId: string, title: string): RegExp {
-  return new RegExp(`^\\s*-\\s+\\[ \\]\\s+TODO\\s+${escapeRegExp(taskId)}\\s+[—-]\\s+${escapeRegExp(title)}\\s*$`, "m");
-}
+function validatedProgressEntries(
+  markdown: string,
+  firstTaskIndex: number,
+): Array<{ taskId: string; title: string; done: boolean }> {
+  const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+  const visible = visibleLineIndexes(lines);
+  const progressIndex = visible.find((idx) => idx < firstTaskIndex && /^##\s+Progress\s*$/i.test(lines[idx].trim()));
+  if (progressIndex === undefined) {
+    throw new TodoGenerationError("TODO markdown must include a `## Progress` section before task sections.");
+  }
+  const separatorIndex = visible.find(
+    (idx) => idx > progressIndex && idx < firstTaskIndex && /^---\s*$/.test(lines[idx].trim()),
+  );
+  if (separatorIndex === undefined) {
+    throw new TodoGenerationError("TODO markdown must include a `---` separator before task sections.");
+  }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const entries: Array<{ taskId: string; title: string; done: boolean }> = [];
+  for (let idx = progressIndex + 1; idx < separatorIndex; idx += 1) {
+    if (!visible.includes(idx)) {
+      continue;
+    }
+    const match = /^\s*-\s+\[([ xX])\]\s+TODO\s+(\d+)\s+[—-]\s+(.+?)\s*$/.exec(lines[idx]);
+    if (match) {
+      entries.push({ taskId: match[2], title: match[3].trim(), done: match[1].toLowerCase() === "x" });
+    } else if (/\bTODO\s+\d+\b/i.test(lines[idx])) {
+      throw new TodoGenerationError(`Malformed progress entry: ${lines[idx].trim()}`);
+    }
+  }
+  return entries;
+}
+
+function visibleLineIndexes(lines: readonly string[]): number[] {
+  const indexes: number[] = [];
+  let fence: string | undefined;
+  for (let idx = 0; idx < lines.length; idx += 1) {
+    const match = /^\s*(`{3,}|~{3,})/.exec(lines[idx]);
+    if (match) {
+      const marker = match[1];
+      if (!fence) {
+        fence = marker;
+      } else if (marker[0] === fence[0] && marker.length >= fence.length) {
+        fence = undefined;
+      }
+      continue;
+    }
+    if (!fence) {
+      indexes.push(idx);
+    }
+  }
+  return indexes;
 }
 
 function fencedMarkdownBlocks(text: string): string[] {

package/src/todo_parser.ts

@@ -25,6 +25,8 @@ export class TodoParseError extends Error {
 const TASK_HEADING_RE = /^##\s+TODO\s+(\d+)\s+[—-]\s+(.+?)\s*$/;
 const CHECKBOX_RE = /^(\s*-\s+\[)([ xX])(\].*)$/;
 const GLOBAL_PROGRESS_HEADING_RE = /^##\s+Progress\s*$/i;
+const FIELD_HEADING_RE = /^\*\*[^*\r\n]+:\*\*\s*$/;
+const FENCE_LINE_RE = /^\s*(`{3,}|~{3,})/;
 
 function progressRegexForTask(taskId: string): RegExp {
   return new RegExp(`^(\\s*-\\s+\\[)([ xX])(\\]\\s+TODO\\s+${escapeRegExp(taskId)}\\b.*)$`);
@@ -54,18 +56,32 @@ interface TaskHeading {
 
 function parseTaskHeadings(lines: string[]): TaskHeading[] {
   const headings: TaskHeading[] = [];
+  let fence: string | undefined;
 
   lines.forEach((line, idx) => {
-    const match = TASK_HEADING_RE.exec(stripLineBreaks(line));
-    if (!match) {
+    const stripped = stripLineBreaks(line);
+    const fenceMatch = FENCE_LINE_RE.exec(stripped);
+    if (fenceMatch) {
+      const marker = fenceMatch[1];
+      if (!fence) {
+        fence = marker;
+      } else if (marker[0] === fence[0] && marker.length >= fence.length) {
+        fence = undefined;
+      }
+      return;
+    }
+    if (fence) {
       return;
     }
 
-    headings.push({
-      startIdx: idx,
-      taskId: match[1],
-      title: match[2].trim(),
-    });
+    const match = TASK_HEADING_RE.exec(stripped);
+    if (match) {
+      headings.push({
+        startIdx: idx,
+        taskId: match[1],
+        title: match[2].trim(),
+      });
+    }
   });
 
   return headings;
@@ -73,9 +89,17 @@ function parseTaskHeadings(lines: string[]): TaskHeading[] {
 
 function findProgressDone(lines: string[], taskId: string): boolean | undefined {
   const regex = progressRegexForTask(taskId);
+  const progressStart = lines.findIndex((line) => GLOBAL_PROGRESS_HEADING_RE.test(stripLineBreaks(line).trim()));
+  if (progressStart < 0) {
+    return undefined;
+  }
 
-  for (const line of lines) {
-    const match = regex.exec(stripLineBreaks(line));
+  for (let idx = progressStart + 1; idx < lines.length; idx += 1) {
+    const stripped = stripLineBreaks(lines[idx]);
+    if (/^\s*---\s*$/.test(stripped) || TASK_HEADING_RE.test(stripped)) {
+      break;
+    }
+    const match = regex.exec(stripped);
     if (match) {
       return match[2].toLowerCase() === "x";
     }
@@ -114,7 +138,7 @@ function findStatusItems(lines: string[], startIdx: number, endIdx: number): Tas
       continue;
     }
 
-    if (seenCheckbox) {
+    if (FIELD_HEADING_RE.test(stripped) || seenCheckbox) {
       break;
     }
   }
@@ -152,7 +176,7 @@ function markStatusBlockDone(lines: string[], startIdx: number, endIdx: number):
       continue;
     }
 
-    if (seenCheckbox) {
+    if (FIELD_HEADING_RE.test(stripped) || seenCheckbox) {
       break;
     }
   }

package/src/worker_session.ts

@@ -1,7 +1,13 @@
 import path from "node:path";
 
 import { coverageGoalAction, coverageGoalVerification, parseCoverageGoal } from "./coverage_goal.ts";
-import { hasTaskResult, hasTaskResultStatus, isDoneStatus, parseReportedStatus } from "./result_writer.ts";
+import {
+  hasCompleteTaskResult,
+  hasTaskResult,
+  isDoneStatus,
+  parseCompleteTaskResult,
+  parseReportedStatus,
+} from "./result_writer.ts";
 import type { Task } from "./todo_parser.ts";
 
 export interface WorkerTaskPromptOptions {
@@ -436,6 +442,7 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
   let messageUsageCostTotal = 0;
   let hasMessageUsageCost = false;
   let sessionStatsCostTotal: number | undefined;
+  let resolvePromptWait: (() => void) | undefined;
 
   const prompt = buildTaskPrompt(options);
   const taskTimeoutSeconds = options.taskTimeoutSeconds ?? DEFAULT_TASK_TIMEOUT_SECONDS;
@@ -483,38 +490,86 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
     timers.add(timer);
   };
 
-  const requestGracefulTaskResult = async (message: string, options: { shutdown?: boolean } = {}) => {
+  const requestGracefulTaskResult = (message: string, options: { shutdown?: boolean } = {}) => {
     if (!session || finished || aborted) {
       return;
     }
     if (options.shutdown) {
       shutdownRequested = true;
     }
-    if (session.isBashRunning && session.abortBash) {
-      session.abortBash();
-      compactionEvents.push("aborted running bash before graceful shutdown request");
-    }
-    if ((session.isStreaming || session.isBashRunning) && session.steer) {
-      await session.steer(message);
-    } else {
-      await session.prompt(message);
+    try {
+      if (session.isBashRunning && session.abortBash) {
+        session.abortBash();
+        compactionEvents.push("aborted running bash before graceful shutdown request");
+      }
+      const request =
+        (session.isStreaming || session.isBashRunning) && session.steer
+          ? session.steer(message)
+          : session.followUp
+            ? session.followUp(message)
+            : session.steer
+              ? session.steer(message)
+              : undefined;
+      if (!request) {
+        compactionEvents.push("graceful TASK_RESULT request skipped: session does not support steer/followUp");
+        return;
+      }
+      void request.catch((exc: unknown) => {
+        compactionEvents.push(`graceful TASK_RESULT request failed: ${errorMessage(exc)}`);
+      });
+    } catch (exc) {
+      compactionEvents.push(`graceful TASK_RESULT request failed: ${errorMessage(exc)}`);
     }
   };
 
-  const abortSession = async (reason: string) => {
+  const abortSession = (reason: string) => {
     if (!session || finished || aborted) {
       return;
     }
     aborted = true;
     shutdownRequested = true;
     error = error ?? reason;
-    await session.abort?.();
+    try {
+      const abortResult = session.abort?.();
+      void Promise.resolve(abortResult).catch((exc: unknown) => {
+        compactionEvents.push(`session abort failed: ${errorMessage(exc)}`);
+      });
+    } catch (exc) {
+      compactionEvents.push(`session abort failed: ${errorMessage(exc)}`);
+    }
+    resolvePromptWait?.();
+    resolvePromptWait = undefined;
   };
 
-  const abortListener = () => {
-    void abortSession("worker session aborted by outer signal").catch((exc: unknown) => {
-      compactionEvents.push(`abort by outer signal failed: ${errorMessage(exc)}`);
+  const waitForPrompt = async (text: string): Promise<void> => {
+    if (!session) {
+      return;
+    }
+    let settled = false;
+    const completed = new Promise<void>((resolve) => {
+      resolvePromptWait = resolve;
     });
+    void session.prompt(text).then(
+      () => {
+        settled = true;
+        resolvePromptWait?.();
+        resolvePromptWait = undefined;
+      },
+      (exc: unknown) => {
+        settled = true;
+        error = error ?? errorMessage(exc);
+        resolvePromptWait?.();
+        resolvePromptWait = undefined;
+      },
+    );
+    await completed;
+    if (!settled && !aborted) {
+      error = error ?? "worker prompt ended without settling";
+    }
+  };
+
+  const abortListener = () => {
+    abortSession("worker session aborted by outer signal");
   };
 
   try {
@@ -612,12 +667,12 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
     options.abortSignal?.addEventListener("abort", abortListener, { once: true });
 
     if (taskTimeoutSeconds > 0) {
-      schedule(async () => {
-        if (finished || hasTaskResultStatus(assistantText)) {
+      schedule(() => {
+        if (finished || hasCompleteTaskResult(assistantText)) {
           return;
         }
         timedOut = true;
-        await requestGracefulTaskResult(buildTimeLimitMessage(taskTimeoutSeconds), { shutdown: true });
+        requestGracefulTaskResult(buildTimeLimitMessage(taskTimeoutSeconds), { shutdown: true });
         if (gracefulShutdownSeconds > 0) {
           schedule(
             () => abortSession(`task exceeded ${taskTimeoutSeconds.toFixed(0)}s timeout`),
@@ -627,12 +682,14 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
       }, taskTimeoutSeconds * 1000);
     }
 
-    await session.prompt(prompt);
+    await waitForPrompt(prompt);
     assistantText = latestAssistantText(session, assistantText);
 
-    if (!hasTaskResultStatus(assistantText) && !aborted && !options.abortSignal?.aborted) {
-      contextObservations.push("missing TASK_RESULT status after initial prompt; requested required block once");
-      await requestGracefulTaskResult(buildMissingTaskResultMessage());
+    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 = latestAssistantText(session, assistantText);
     }
   } catch (exc) {
@@ -647,7 +704,11 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
       sessionFile = session.sessionFile ?? sessionFile;
       sessionId = session.sessionId ?? sessionId;
       sessionStatsCostTotal = await workerUsageCostFromSessionStats(session);
-      session.dispose?.();
+      try {
+        await Promise.resolve(session.dispose?.());
+      } catch (exc) {
+        compactionEvents.push(`session dispose failed: ${errorMessage(exc)}`);
+      }
     }
   }
 
@@ -655,7 +716,8 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
     assistantText = buildLongTaskFailureTaskResult(error ?? (timedOut ? "task timed out" : "worker session aborted"));
   }
 
-  const reportedStatus = parseReportedStatus(assistantText);
+  const parsedResult = parseCompleteTaskResult(assistantText);
+  const reportedStatus = parsedResult?.status ?? parseReportedStatus(assistantText);
   const capturedWorkerCost = selectWorkerCostTotal({
     messageCostTotal: hasMessageUsageCost ? messageUsageCostTotal : undefined,
     statsCostTotal: sessionStatsCostTotal,
@@ -666,7 +728,7 @@ export async function runWorkerTask(options: RunWorkerTaskOptions): Promise<Sess
     startedAt,
     endedAt: now().toISOString(),
     reportedStatus,
-    done: isDoneStatus(reportedStatus),
+    done: Boolean(parsedResult && isDoneStatus(reportedStatus) && !error && !aborted && !timedOut),
     assistantText,
     sessionFile,
     sessionId,