@mrclrchtr/supi-review 2.6.1 → 2.8.0

package/src/tool/brief-runner.ts

@@ -11,7 +11,8 @@ import type {
   BriefSynthesisRunResult,
   SynthesizedReviewBrief,
 } from "../types.ts";
-import { buildProgressTokens, extractLastAssistantText } from "./runner-helpers.ts";
+import { createEarlyCancellationDiagnostics } from "./child-failure-diagnostics.ts";
+import { buildProgressTokens } from "./runner-helpers.ts";
 import { reviewBriefSchema } from "./schemas.ts";
 import { type LifecycleCtx, runWithLifecycle } from "./session-lifecycle.ts";
 
@@ -88,24 +89,19 @@ function emitBriefProgress(
 
 /** Finalize after retries and compaction recovery, never at the earlier `agent_end` boundary. */
 function handleAgentSettled(options: {
-  session: AgentSession;
   brief: SynthesizedReviewBrief | undefined;
   state: { settled: boolean; aborting: boolean };
   cleanup: (result: BriefSynthesisRunResult) => BriefSynthesisRunResult;
+  getFailureDiagnostics: LifecycleCtx<BriefSynthesisRunResult>["getFailureDiagnostics"];
 }): BriefSynthesisRunResult | undefined {
-  const { session, brief, state, cleanup } = options;
-  if (state.settled || state.aborting) {
-    return undefined;
-  }
-  if (brief) {
-    return cleanup({ kind: "success", brief });
-  }
-  const lastText = extractLastAssistantText(session.messages);
+  const { brief, state, cleanup, getFailureDiagnostics } = options;
+  if (state.settled || state.aborting) return undefined;
+  if (brief) return cleanup({ kind: "success", brief });
+
   return cleanup({
     kind: "failed",
-    reason: lastText
-      ? `Brief synthesizer did not call submit_review_brief. Assistant said: ${lastText}`
-      : "Brief synthesizer did not produce any output.",
+    failureCode: "missing-structured-output",
+    diagnostics: getFailureDiagnostics(),
   });
 }
 
@@ -114,7 +110,7 @@ export async function runBriefSynthesis(
   invocation: BriefSynthesisInvocation,
 ): Promise<BriefSynthesisRunResult> {
   if (invocation.signal?.aborted) {
-    return { kind: "canceled" };
+    return { kind: "canceled", diagnostics: createEarlyCancellationDiagnostics() };
   }
 
   const resultHolder: { value: SynthesizedReviewBrief | undefined } = { value: undefined };
@@ -123,11 +119,8 @@ export async function runBriefSynthesis(
   let session: AgentSession;
   try {
     session = await createBriefSession(invocation, submitBriefTool);
-  } catch (error) {
-    return {
-      kind: "failed",
-      reason: `Failed to create brief synthesis session: ${error instanceof Error ? error.message : String(error)}`,
-    };
+  } catch {
+    return { kind: "failed", failureCode: "session-creation-failed" };
   }
 
   return runWithLifecycle<BriefSynthesisRunResult>({
@@ -155,10 +148,10 @@ export async function runBriefSynthesis(
           break;
         case "agent_settled": {
           const result = handleAgentSettled({
-            session,
             brief: resultHolder.value,
             state: ctx.state,
             cleanup: ctx.cleanup,
+            getFailureDiagnostics: ctx.getFailureDiagnostics,
           });
           if (result) {
             ctx.resolve(result);
@@ -169,11 +162,19 @@ export async function runBriefSynthesis(
           break;
       }
     },
-    canceledResult: () => ({ kind: "canceled" as const }),
-    failedResult: (reason) => ({
+    canceledResult: (ctx) => ({
+      kind: "canceled" as const,
+      diagnostics: ctx.getFailureDiagnostics(),
+    }),
+    failedResult: (failureCode, ctx) => ({
       kind: "failed" as const,
-      reason,
+      failureCode,
+      diagnostics: ctx.getFailureDiagnostics(),
+    }),
+    timeoutResult: (ms, ctx) => ({
+      kind: "timeout" as const,
+      timeoutMs: ms,
+      diagnostics: ctx.getFailureDiagnostics(),
     }),
-    timeoutResult: (ms) => ({ kind: "timeout" as const, timeoutMs: ms }),
   });
 }

package/src/tool/child-failure-diagnostics.ts

@@ -0,0 +1,145 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type {
+  ChildFailureCode,
+  ChildFailureDiagnostics,
+  ChildStage,
+  ReviewProgress,
+} from "../types.ts";
+import {
+  type ChildLifecycleTrace,
+  ChildLifecycleTraceCollector,
+  formatChildLifecycleTrace,
+  getRegisteredToolNames,
+  toSafeAssistantStopReason,
+} from "./child-lifecycle-trace.ts";
+import { buildProgressTokens } from "./runner-helpers.ts";
+
+/** Inputs used to create one safe non-success child-run diagnostic artifact. */
+export interface BuildChildFailureDiagnosticsInput {
+  progress: ReviewProgress;
+  lifecycleTrace: ChildLifecycleTrace;
+  recentActivity: string[];
+  session?: AgentSession;
+}
+
+/** Build diagnostics from allowlisted control metadata only. */
+export function buildChildFailureDiagnostics(
+  input: BuildChildFailureDiagnosticsInput,
+): ChildFailureDiagnostics {
+  const { session } = input;
+  const tokens = session
+    ? buildProgressTokens(() => session.getSessionStats())
+    : input.progress.tokens;
+  const lastAssistant = session ? extractLastAssistantMetadata(session) : undefined;
+
+  return {
+    lifecycleTrace: input.lifecycleTrace,
+    turns: input.progress.turns,
+    toolUses: input.progress.toolUses,
+    tokens,
+    recentActivity: input.recentActivity.length > 0 ? [...input.recentActivity] : undefined,
+    lastAssistantStopReason: lastAssistant?.stopReason,
+    lastAssistantToolCalls: lastAssistant?.toolCalls,
+  };
+}
+
+/** Create safe diagnostics when a host failure occurred without observed child lifecycle events. */
+export function createUnobservedChildFailureDiagnostics(): ChildFailureDiagnostics {
+  return buildChildFailureDiagnostics({
+    progress: { turns: 0, toolUses: 0 },
+    lifecycleTrace: { entries: [], droppedCount: 0 },
+    recentActivity: [],
+  });
+}
+
+/** Create safe cancellation diagnostics when no child session was started. */
+export function createEarlyCancellationDiagnostics(): ChildFailureDiagnostics {
+  const collector = new ChildLifecycleTraceCollector();
+  collector.recordHostMarker({ type: "abort_requested", reason: "canceled" });
+  return buildChildFailureDiagnostics({
+    progress: { turns: 0, toolUses: 0 },
+    lifecycleTrace: collector.snapshot(),
+    recentActivity: collector.recentActivitySnapshot(),
+  });
+}
+
+/** Generate static parent-facing copy for a host-owned child failure code. */
+export function formatChildFailureCopy(stage: ChildStage, code: ChildFailureCode): string {
+  const label = stage === "brief-synthesis" ? "Brief synthesis" : "Reviewer";
+  switch (code) {
+    case "session-creation-failed":
+      return `${label} session could not be created.`;
+    case "prompt-rejected":
+      return `${label} prompt was rejected before it ran.`;
+    case "missing-structured-output":
+      return `${label} ended without the required structured output.`;
+    case "unexpected-runner-failure":
+      return `${label} ended unexpectedly.`;
+  }
+}
+
+/** Format the complete retained safe diagnostic artifact for parent-facing text. */
+export function formatChildFailureDiagnostics(diagnostics: ChildFailureDiagnostics): string[] {
+  const lines = [
+    `- Turns: ${diagnostics.turns}`,
+    `- Tool uses: ${diagnostics.toolUses}`,
+    diagnostics.tokens
+      ? `- Tokens: ${diagnostics.tokens.input} in / ${diagnostics.tokens.output} out / ${diagnostics.tokens.total} total`
+      : undefined,
+    diagnostics.recentActivity && diagnostics.recentActivity.length > 0
+      ? `- Recent activity: ${diagnostics.recentActivity.join(" → ")}`
+      : undefined,
+    diagnostics.lastAssistantStopReason
+      ? `- Last assistant stop: ${diagnostics.lastAssistantStopReason}`
+      : undefined,
+    diagnostics.lastAssistantToolCalls && diagnostics.lastAssistantToolCalls.length > 0
+      ? `- Last assistant tools: ${diagnostics.lastAssistantToolCalls.join(", ")}`
+      : undefined,
+    `- ${formatChildLifecycleTrace(diagnostics.lifecycleTrace)}`,
+  ];
+  return lines.filter((line): line is string => !!line);
+}
+
+interface LastAssistantMetadata {
+  stopReason?: string;
+  toolCalls?: string[];
+}
+
+function extractLastAssistantMetadata(session: AgentSession): LastAssistantMetadata | undefined {
+  try {
+    const messages = session.messages as unknown;
+    if (!Array.isArray(messages)) return undefined;
+
+    const registeredToolNames = getRegisteredToolNames(session);
+    for (let index = messages.length - 1; index >= 0; index--) {
+      const message = messages[index] as Record<string, unknown> | undefined;
+      if (message?.role !== "assistant") continue;
+
+      const stopReason = toSafeAssistantStopReason(message.stopReason);
+      const toolCalls = extractAssistantToolCalls(message.content, registeredToolNames);
+      return {
+        stopReason,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      };
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function extractAssistantToolCalls(content: unknown, registeredToolNames: Set<string>): string[] {
+  if (!Array.isArray(content)) return [];
+
+  return content
+    .map((part) => {
+      if (typeof part !== "object" || !part) return undefined;
+      const tool = part as { type?: unknown; name?: unknown };
+      return tool.type === "toolCall" &&
+        typeof tool.name === "string" &&
+        registeredToolNames.has(tool.name)
+        ? tool.name
+        : undefined;
+    })
+    .filter((name): name is string => !!name);
+}

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(),
         }),
       );
     });