@mrclrchtr/supi-review 2.6.0 → 2.7.0

package/src/tool/child-lifecycle-trace.ts

@@ -0,0 +1,329 @@
+import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+
+/** Maximum number of observed Child Lifecycle Trace entries retained per child run. */
+export const CHILD_LIFECYCLE_TRACE_MAX = 32;
+
+/** Maximum number of compact Recent Activity entries retained per child run. */
+export const RECENT_ACTIVITY_MAX = 10;
+
+/** Pi-defined assistant stop reasons safe to retain in diagnostics. */
+export type SafeAssistantStopReason = "stop" | "length" | "toolUse" | "error" | "aborted";
+
+type CompactionReason = "manual" | "threshold" | "overflow";
+
+const SAFE_ASSISTANT_STOP_REASONS = new Set<SafeAssistantStopReason>([
+  "stop",
+  "length",
+  "toolUse",
+  "error",
+  "aborted",
+]);
+const COMPACTION_REASONS = new Set<CompactionReason>(["manual", "threshold", "overflow"]);
+
+/** Return a stop reason only when it is one of Pi's defined lifecycle values. */
+export function toSafeAssistantStopReason(value: unknown): SafeAssistantStopReason | undefined {
+  return typeof value === "string" &&
+    SAFE_ASSISTANT_STOP_REASONS.has(value as SafeAssistantStopReason)
+    ? (value as SafeAssistantStopReason)
+    : undefined;
+}
+
+/** Read the child session's active registered tool names without exposing failures. */
+export function getRegisteredToolNames(session: AgentSession): Set<string> {
+  try {
+    const names = session.getActiveToolNames() as unknown;
+    return Array.isArray(names)
+      ? new Set(names.filter((name): name is string => typeof name === "string"))
+      : new Set();
+  } catch {
+    return new Set();
+  }
+}
+
+/** One allowlisted lifecycle transition retained for a managed child session. */
+export type ChildLifecycleTraceEntry =
+  | { type: "agent_start" }
+  | { type: "agent_end"; willRetry: boolean }
+  | { type: "agent_settled" }
+  | { type: "compaction_start"; reason: CompactionReason }
+  | {
+      type: "compaction_end";
+      reason: CompactionReason;
+      aborted: boolean;
+      willRetry: boolean;
+      hasResult: boolean;
+      hasError: boolean;
+    }
+  | { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number }
+  | { type: "auto_retry_end"; success: boolean; attempt: number; hasFinalError: boolean }
+  | {
+      type: "summarization_retry_scheduled";
+      attempt: number;
+      maxAttempts: number;
+      delayMs: number;
+    }
+  | {
+      type: "summarization_retry_attempt_start";
+      source: "branchSummary" | "compaction";
+      reason?: CompactionReason;
+    }
+  | { type: "summarization_retry_finished" }
+  | { type: "queue_update"; steeringCount: number; followUpCount: number }
+  | ChildLifecycleHostMarker;
+
+/** Minimal runner-control transitions that explain host-originated termination. */
+export type ChildLifecycleHostMarker =
+  | { type: "steer_requested"; reason: "submit" | "timeout" }
+  | { type: "timeout_expired" }
+  | { type: "abort_requested"; reason: "canceled" | "timeout" }
+  | { type: "prompt_rejected" };
+
+/** Bounded observed tail of lifecycle transitions for one managed child session. */
+export interface ChildLifecycleTrace {
+  entries: ChildLifecycleTraceEntry[];
+  droppedCount: number;
+}
+
+/**
+ * Retains only allowlisted lifecycle metadata for one managed child session.
+ *
+ * Entries are copied into a bounded observed tail so raw SDK events and their
+ * potentially sensitive payloads never escape the runner.
+ */
+export class ChildLifecycleTraceCollector {
+  private readonly entries: ChildLifecycleTraceEntry[] = [];
+  private readonly recentActivity: string[] = [];
+  private droppedCount = 0;
+
+  constructor(private readonly registeredToolNames: ReadonlySet<string> = new Set()) {}
+
+  /** Record one Pi session event when it belongs to the explicit allowlist. */
+  observe(event: AgentSessionEvent): void {
+    let entry: ChildLifecycleTraceEntry | undefined;
+    let activity: string | undefined;
+    try {
+      entry = mapLifecycleEvent(event);
+      activity = summarizeRecentActivity(event, this.registeredToolNames);
+    } catch {
+      return;
+    }
+
+    if (entry) this.push(entry);
+    if (activity) this.pushRecentActivity(activity);
+  }
+
+  /** Record an allowlisted runner-control transition. */
+  recordHostMarker(marker: ChildLifecycleHostMarker): void {
+    switch (marker.type) {
+      case "steer_requested":
+        if (marker.reason === "submit" || marker.reason === "timeout") {
+          this.push({ type: "steer_requested", reason: marker.reason });
+        }
+        break;
+      case "abort_requested":
+        if (marker.reason === "canceled" || marker.reason === "timeout") {
+          this.push({ type: "abort_requested", reason: marker.reason });
+        }
+        break;
+      case "timeout_expired":
+        this.push({ type: "timeout_expired" });
+        break;
+      case "prompt_rejected":
+        this.push({ type: "prompt_rejected" });
+        break;
+    }
+  }
+
+  /** Return an immutable-by-convention copy suitable for a failure artifact. */
+  snapshot(): ChildLifecycleTrace {
+    return {
+      entries: this.entries.map((entry) => ({ ...entry })),
+      droppedCount: this.droppedCount,
+    };
+  }
+
+  /** Return the separate, presentation-only Recent Activity lane. */
+  recentActivitySnapshot(): string[] {
+    return [...this.recentActivity];
+  }
+
+  private push(entry: ChildLifecycleTraceEntry): void {
+    this.entries.push(entry);
+    if (this.entries.length <= CHILD_LIFECYCLE_TRACE_MAX) return;
+
+    this.entries.shift();
+    this.droppedCount++;
+  }
+
+  private pushRecentActivity(activity: string): void {
+    this.recentActivity.push(activity);
+    if (this.recentActivity.length > RECENT_ACTIVITY_MAX) this.recentActivity.shift();
+  }
+}
+
+/** Format the complete retained Child Lifecycle Trace for parent-facing diagnostics. */
+export function formatChildLifecycleTrace(trace: ChildLifecycleTrace): string {
+  const tail =
+    trace.droppedCount > 0
+      ? `incomplete observed tail; ${trace.droppedCount} older ${trace.droppedCount === 1 ? "entry" : "entries"} dropped`
+      : "observed tail";
+  const entries = trace.entries.map(formatChildLifecycleTraceEntry);
+  const body = entries.length > 0 ? entries.join(" → ") : "(no observed lifecycle entries)";
+  return `Child Lifecycle Trace (${tail}): ${body}`;
+}
+
+function formatChildLifecycleTraceEntry(entry: ChildLifecycleTraceEntry): string {
+  switch (entry.type) {
+    case "agent_start":
+    case "agent_settled":
+    case "summarization_retry_finished":
+    case "timeout_expired":
+    case "prompt_rejected":
+      return entry.type;
+    case "agent_end":
+      return `agent_end(willRetry=${entry.willRetry})`;
+    case "compaction_start":
+      return `compaction_start(reason=${entry.reason})`;
+    case "compaction_end":
+      return `compaction_end(reason=${entry.reason}, aborted=${entry.aborted}, willRetry=${entry.willRetry}, hasResult=${entry.hasResult}, hasError=${entry.hasError})`;
+    case "auto_retry_start":
+      return `auto_retry_start(attempt=${entry.attempt}/${entry.maxAttempts}, delayMs=${entry.delayMs})`;
+    case "auto_retry_end":
+      return `auto_retry_end(success=${entry.success}, attempt=${entry.attempt}, hasFinalError=${entry.hasFinalError})`;
+    case "summarization_retry_scheduled":
+      return `summarization_retry_scheduled(attempt=${entry.attempt}/${entry.maxAttempts}, delayMs=${entry.delayMs})`;
+    case "summarization_retry_attempt_start":
+      return entry.reason
+        ? `summarization_retry_attempt_start(source=${entry.source}, reason=${entry.reason})`
+        : `summarization_retry_attempt_start(source=${entry.source})`;
+    case "queue_update":
+      return `queue_update(steering=${entry.steeringCount}, followUp=${entry.followUpCount})`;
+    case "steer_requested":
+      return `steer_requested(reason=${entry.reason})`;
+    case "abort_requested":
+      return `abort_requested(reason=${entry.reason})`;
+  }
+}
+
+function summarizeRecentActivity(
+  event: AgentSessionEvent,
+  registeredToolNames: ReadonlySet<string>,
+): string | undefined {
+  switch (event.type) {
+    case "message_end": {
+      const message = event.message as { role?: unknown; stopReason?: unknown };
+      if (message.role !== "assistant") return undefined;
+      const stopReason = toSafeAssistantStopReason(message.stopReason);
+      return `assistant:end${stopReason ? `:${stopReason}` : ""}`;
+    }
+    case "turn_start":
+      return "turn:start";
+    case "turn_end":
+      return "turn:end";
+    case "tool_execution_start":
+      return typeof event.toolName === "string" && registeredToolNames.has(event.toolName)
+        ? `tool:start:${event.toolName}`
+        : undefined;
+    case "tool_execution_end":
+      return typeof event.toolName === "string" &&
+        typeof event.isError === "boolean" &&
+        registeredToolNames.has(event.toolName)
+        ? `tool:end:${event.toolName}${event.isError ? ":error" : ""}`
+        : undefined;
+    default:
+      return undefined;
+  }
+}
+
+function isCompactionReason(value: unknown): value is CompactionReason {
+  return typeof value === "string" && COMPACTION_REASONS.has(value as CompactionReason);
+}
+
+function isSafeCount(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one explicit allowlist keeps copied event fields auditable
+function mapLifecycleEvent(event: AgentSessionEvent): ChildLifecycleTraceEntry | undefined {
+  switch (event.type) {
+    case "agent_start":
+      return { type: "agent_start" };
+    case "agent_end":
+      return typeof event.willRetry === "boolean"
+        ? { type: "agent_end", willRetry: event.willRetry }
+        : undefined;
+    case "agent_settled":
+      return { type: "agent_settled" };
+    case "compaction_start":
+      return isCompactionReason(event.reason)
+        ? { type: "compaction_start", reason: event.reason }
+        : undefined;
+    case "compaction_end":
+      return isCompactionReason(event.reason) &&
+        typeof event.aborted === "boolean" &&
+        typeof event.willRetry === "boolean"
+        ? {
+            type: "compaction_end",
+            reason: event.reason,
+            aborted: event.aborted,
+            willRetry: event.willRetry,
+            hasResult: event.result !== undefined,
+            hasError: event.errorMessage !== undefined,
+          }
+        : undefined;
+    case "auto_retry_start":
+      return isSafeCount(event.attempt) &&
+        isSafeCount(event.maxAttempts) &&
+        isSafeCount(event.delayMs)
+        ? {
+            type: "auto_retry_start",
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            delayMs: event.delayMs,
+          }
+        : undefined;
+    case "auto_retry_end":
+      return typeof event.success === "boolean" && isSafeCount(event.attempt)
+        ? {
+            type: "auto_retry_end",
+            success: event.success,
+            attempt: event.attempt,
+            hasFinalError: event.finalError !== undefined,
+          }
+        : undefined;
+    case "summarization_retry_scheduled":
+      return isSafeCount(event.attempt) &&
+        isSafeCount(event.maxAttempts) &&
+        isSafeCount(event.delayMs)
+        ? {
+            type: "summarization_retry_scheduled",
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            delayMs: event.delayMs,
+          }
+        : undefined;
+    case "summarization_retry_attempt_start":
+      if (event.source === "branchSummary") {
+        return { type: "summarization_retry_attempt_start", source: "branchSummary" };
+      }
+      return event.source === "compaction" && isCompactionReason(event.reason)
+        ? {
+            type: "summarization_retry_attempt_start",
+            source: "compaction",
+            reason: event.reason,
+          }
+        : undefined;
+    case "summarization_retry_finished":
+      return { type: "summarization_retry_finished" };
+    case "queue_update":
+      return Array.isArray(event.steering) && Array.isArray(event.followUp)
+        ? {
+            type: "queue_update",
+            steeringCount: event.steering.length,
+            followUpCount: event.followUp.length,
+          }
+        : undefined;
+    default:
+      return undefined;
+  }
+}

package/src/tool/review-handlers.ts

@@ -4,17 +4,13 @@ import {
   defineTool,
 } from "@earendil-works/pi-coding-agent";
 import type {
+  ChildFailureDiagnostics,
   RawReviewResult,
   ReviewInvocation,
   ReviewOutputEvent,
   ReviewProgress,
 } from "../types.ts";
-import {
-  buildFailureDebug,
-  extractLastAssistantDebug,
-  pushRecentEvent,
-  summarizeSessionEvent,
-} from "./review-debug.ts";
+import type { ChildLifecycleHostMarker } from "./child-lifecycle-trace.ts";
 import { buildProgressTokens } from "./runner-helpers.ts";
 import { reviewOutputSchema } from "./schemas.ts";
 
@@ -37,7 +33,8 @@ export interface RunnerContext {
   submitSteered: boolean;
   timeoutSteered: boolean;
   graceTurnsRemaining: number | undefined;
-  debug: { recentEvents: string[] };
+  getFailureDiagnostics: () => ChildFailureDiagnostics;
+  recordHostMarker: (marker: ChildLifecycleHostMarker) => void;
   /** Accumulated per-tool-label execution counts. */
   toolCounts: Record<string, number>;
   /** Set of distinct file paths inspected via read_snapshot_diff / read_snapshot_file. */
@@ -233,6 +230,7 @@ export function handleMessageEnd(
   if (msg.role !== "assistant" || msg.stopReason !== "stop") return;
 
   ctx.submitSteered = true;
+  ctx.recordHostMarker({ type: "steer_requested", reason: "submit" });
   ctx.session.steer(STEER_SUBMIT_MESSAGE).catch(() => {});
 }
 
@@ -256,28 +254,19 @@ export function handleAgentSettled(ctx: RunnerContext): void {
     return;
   }
 
-  const lastText = extractLastAssistantDebug(ctx.session)?.text;
   ctx.resolve(
     ctx.cleanup({
       kind: "failed",
-      reason: lastText
-        ? `Reviewer did not call submit_review. Assistant said: ${truncateText(lastText, 400)}`
-        : "Reviewer did not produce any output.",
+      failureCode: "missing-structured-output",
       snapshot: ctx.invocation.snapshot,
       brief: ctx.invocation.brief,
       modelId: ctx.invocation.model.canonicalId,
-      debug: buildFailureDebug({
-        progress: ctx.progress,
-        session: ctx.session,
-        recentEvents: ctx.debug.recentEvents,
-      }),
+      diagnostics: ctx.getFailureDiagnostics(),
     }),
   );
 }
 
 export function handleSessionEvent(event: AgentSessionEvent, ctx: RunnerContext): void {
-  pushRecentEvent(ctx.debug.recentEvents, summarizeSessionEvent(event));
-
   switch (event.type) {
     case "turn_end":
       handleTurnEnd(ctx);
@@ -300,35 +289,25 @@ export function handleSessionEvent(event: AgentSessionEvent, ctx: RunnerContext)
   }
 }
 
-function truncateText(text: string, maxLen: number): string {
-  if (text.length <= maxLen) return text;
-  return `${text.slice(0, maxLen)}... (${text.length - maxLen} more chars)`;
-}
-
 // ---------------------------------------------------------------------------
 // Hard-abort helper (called from handleTurnEnd when grace turns expire)
 // ---------------------------------------------------------------------------
 
 function doFinalAbort(ctx: RunnerContext): void {
   emitProgress(ctx);
+  ctx.recordHostMarker({ type: "abort_requested", reason: "timeout" });
   void ctx.session
     .abort()
     .catch(() => {})
     .finally(() => {
-      const partialText = extractLastAssistantDebug(ctx.session)?.text;
       ctx.resolve(
         ctx.cleanup({
           kind: "timeout" as const,
           snapshot: ctx.invocation.snapshot,
           timeoutMs: ctx.invocation.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-          partialOutput: partialText,
           brief: ctx.invocation.brief,
           modelId: ctx.invocation.model.canonicalId,
-          debug: buildFailureDebug({
-            progress: ctx.progress,
-            session: ctx.session,
-            recentEvents: ctx.debug.recentEvents,
-          }),
+          diagnostics: ctx.getFailureDiagnostics(),
         }),
       );
     });

package/src/tool/review-runner.ts

@@ -6,7 +6,7 @@ import {
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import type { RawReviewResult, ReviewInvocation, ReviewOutputEvent } from "../types.ts";
-import { buildFailureDebug, extractLastAssistantDebug } from "./review-debug.ts";
+import { createEarlyCancellationDiagnostics } from "./child-failure-diagnostics.ts";
 import {
   createSubmitReviewTool,
   handleSessionEvent,
@@ -42,7 +42,6 @@ async function createReviewerSession(
   const { session } = await createAgentSession({
     cwd: invocation.cwd,
     model: invocation.model.model,
-    modelRegistry: invocation.modelRegistry,
     thinkingLevel: clampThinkingLevel(invocation.model.model, "max"),
     tools: [
       "read",
@@ -70,16 +69,12 @@ function buildTimeoutResult(
   runner: ReviewerRunnerState,
 ): RawReviewResult {
   return {
-    kind: "timeout" as const,
+    kind: "timeout",
     snapshot: runner.invocation.snapshot,
     timeoutMs: runner.invocation.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     brief: runner.invocation.brief,
     modelId: runner.invocation.model.canonicalId,
-    debug: buildFailureDebug({
-      progress: lcCtx.progress,
-      session: lcCtx.session,
-      recentEvents: runner.debug.recentEvents,
-    }),
+    diagnostics: lcCtx.getFailureDiagnostics(),
   };
 }
 
@@ -88,34 +83,26 @@ function buildCanceledResult(
   runner: ReviewerRunnerState,
 ): RawReviewResult {
   return {
-    kind: "canceled" as const,
+    kind: "canceled",
     snapshot: runner.invocation.snapshot,
     brief: runner.invocation.brief,
     modelId: runner.invocation.model.canonicalId,
-    debug: buildFailureDebug({
-      progress: lcCtx.progress,
-      session: lcCtx.session,
-      recentEvents: runner.debug.recentEvents,
-    }),
+    diagnostics: lcCtx.getFailureDiagnostics(),
   };
 }
 
 function buildFailedResult(
-  reason: string,
+  failureCode: "prompt-rejected" | "unexpected-runner-failure",
   lcCtx: LifecycleCtx<RawReviewResult>,
   runner: ReviewerRunnerState,
 ): RawReviewResult {
   return {
-    kind: "failed" as const,
-    reason,
+    kind: "failed",
+    failureCode,
     snapshot: runner.invocation.snapshot,
     brief: runner.invocation.brief,
     modelId: runner.invocation.model.canonicalId,
-    debug: buildFailureDebug({
-      progress: lcCtx.progress,
-      session: lcCtx.session,
-      recentEvents: runner.debug.recentEvents,
-    }),
+    diagnostics: lcCtx.getFailureDiagnostics(),
   };
 }
 
@@ -125,49 +112,43 @@ interface ReviewerRunnerState {
   submitSteered: boolean;
   timeoutSteered: boolean;
   graceTurnsRemaining: number | undefined;
-  debug: { recentEvents: string[] };
 }
 
 // ---------------------------------------------------------------------------
 // Steer / abort helpers
 // ---------------------------------------------------------------------------
 
-/** Abort the session and resolve with a timeout result (from lifecycle context). */
+/** Abort the session and resolve with a timeout result from the lifecycle context. */
 function doFinalAbortFromLifecycle(
   lcCtx: LifecycleCtx<RawReviewResult>,
   runner: ReviewerRunnerState,
 ): void {
+  if (lcCtx.state.settled || lcCtx.state.aborting) return;
+
   lcCtx.state.aborting = true;
+  lcCtx.recordHostMarker({ type: "abort_requested", reason: "timeout" });
   void lcCtx.session
     .abort()
     .catch(() => {})
     .finally(() => {
-      const partialText = extractLastAssistantDebug(lcCtx.session)?.text;
       lcCtx.resolve(
         lcCtx.cleanup({
-          kind: "timeout" as const,
+          kind: "timeout",
           snapshot: runner.invocation.snapshot,
           timeoutMs: runner.invocation.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-          partialOutput: partialText,
           brief: runner.invocation.brief,
           modelId: runner.invocation.model.canonicalId,
-          debug: buildFailureDebug({
-            progress: lcCtx.progress,
-            session: lcCtx.session,
-            recentEvents: runner.debug.recentEvents,
-          }),
+          diagnostics: lcCtx.getFailureDiagnostics(),
         }),
       );
     });
 }
 
 /**
- * Build the custom `onTimeout` handler for the review runner.
+ * Build the custom soft-timeout behavior for reviewer sessions.
  *
- * When the soft timeout fires, the handler:
- * 1. Steers the reviewer session to wrap up
- * 2. Starts a grace timer (hard abort after GRACE_TURNS or HARD_ABORT_GRACE_MS)
- * 3. If steer fails, immediately hard-aborts
+ * The shared lifecycle runner records `timeout_expired`; this runner adds a
+ * timeout steering marker and later records the hard-abort marker if needed.
  */
 function buildReviewTimeoutHandler(
   runner: ReviewerRunnerState,
@@ -175,9 +156,9 @@ function buildReviewTimeoutHandler(
 ): void {
   runner.timeoutSteered = true;
   runner.graceTurnsRemaining = GRACE_TURNS;
+  lcCtx.recordHostMarker({ type: "steer_requested", reason: "timeout" });
 
   const hardAbortTimer = setTimeout(() => {
-    if (lcCtx.state.settled) return;
     doFinalAbortFromLifecycle(lcCtx, runner);
   }, HARD_ABORT_GRACE_MS);
   hardAbortTimer.unref?.();
@@ -200,7 +181,6 @@ function buildRunnerCtx(runner: ReviewerRunnerState): RunnerContext {
   ctx.submitSteered = runner.submitSteered;
   ctx.timeoutSteered = runner.timeoutSteered;
   ctx.graceTurnsRemaining = runner.graceTurnsRemaining;
-  ctx.debug = runner.debug;
   ctx.toolCounts = {};
   ctx.inspectedFiles = new Set();
   return ctx;
@@ -217,6 +197,8 @@ function syncCtxFromLifecycle(
   ctx.cleanup = lcCtx.cleanup;
   ctx.state = lcCtx.state;
   ctx.startTime = lcCtx.startTime;
+  ctx.getFailureDiagnostics = lcCtx.getFailureDiagnostics;
+  ctx.recordHostMarker = lcCtx.recordHostMarker;
   ctx.submitSteered = runner.submitSteered;
   ctx.timeoutSteered = runner.timeoutSteered;
   ctx.graceTurnsRemaining = runner.graceTurnsRemaining;
@@ -240,6 +222,7 @@ export async function runReviewer(invocation: ReviewInvocation): Promise<RawRevi
       snapshot: invocation.snapshot,
       brief: invocation.brief,
       modelId: invocation.model.canonicalId,
+      diagnostics: createEarlyCancellationDiagnostics(),
     };
   }
 
@@ -256,10 +239,10 @@ export async function runReviewer(invocation: ReviewInvocation): Promise<RawRevi
       snapshotDiffTool,
       snapshotFileTool,
     );
-  } catch (error) {
+  } catch {
     return {
       kind: "failed",
-      reason: `Failed to create reviewer session: ${error instanceof Error ? error.message : String(error)}`,
+      failureCode: "session-creation-failed",
       snapshot: invocation.snapshot,
       brief: invocation.brief,
       modelId: invocation.model.canonicalId,
@@ -272,9 +255,7 @@ export async function runReviewer(invocation: ReviewInvocation): Promise<RawRevi
     submitSteered: false,
     timeoutSteered: false,
     graceTurnsRemaining: undefined,
-    debug: { recentEvents: [] },
   };
-
   const ctx = buildRunnerCtx(runner);
 
   return runWithLifecycle<RawReviewResult>({
@@ -289,7 +270,7 @@ export async function runReviewer(invocation: ReviewInvocation): Promise<RawRevi
     },
     onTimeout: (lcCtx) => buildReviewTimeoutHandler(runner, lcCtx),
     canceledResult: (lcCtx) => buildCanceledResult(lcCtx, runner),
-    failedResult: (reason, lcCtx) => buildFailedResult(reason, lcCtx, runner),
+    failedResult: (failureCode, lcCtx) => buildFailedResult(failureCode, lcCtx, runner),
     timeoutResult: (_, lcCtx) => buildTimeoutResult(lcCtx, runner),
   });
 }

package/src/tool/runner-helpers.ts

@@ -5,20 +5,6 @@
  * eliminate duplication.
  */
 
-/** Extract the last assistant text from a session's message history. */
-export function extractLastAssistantText(
-  messages: ArrayLike<unknown> | undefined,
-): string | undefined {
-  if (!messages) return undefined;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i] as { role?: string; content?: unknown } | undefined;
-    if (message?.role !== "assistant") continue;
-    const text = extractAssistantText(message.content);
-    if (text) return text;
-  }
-  return undefined;
-}
-
 /** Extract text content from a message content value (string | content-part[]). */
 export function extractAssistantText(content: unknown): string | undefined {
   if (typeof content === "string") {