@mrclrchtr/supi-review 3.0.0 → 3.1.0

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
   "license": "MIT",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-review",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "SuPi Review extension — caller-defined read-only review tasks for users and agents",
   "license": "MIT",
   "repository": {
@@ -31,7 +31,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "3.0.0"
+    "@mrclrchtr/supi-core": "3.1.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"

package/src/git.ts

@@ -17,7 +17,6 @@ import type {
   ReviewTargetSpec,
 } from "./types.ts";
 
-const FULL_COMMIT_ID_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
 const DIFF_FLAGS = ["--no-ext-diff", "--no-textconv", "--binary"] as const;
 
 function parseNullList(text: string): string[] {
@@ -40,17 +39,12 @@ export function parseDiffStats(text: string, fileCount?: number): DiffStats {
   return { files: fileCount ?? files, additions, deletions };
 }
 
-/** Validate the agent-facing full Git object-id syntax before invoking Git. */
-export function isFullCommitId(value: string): boolean {
-  return FULL_COMMIT_ID_RE.test(value);
-}
-
 async function resolveCommit(cwd: string, value: string): Promise<string | undefined> {
-  if (!isFullCommitId(value)) return undefined;
-  const type = (await gitAllowExit(cwd, ["cat-file", "-t", value], [128])).trim();
+  const canonical = (await gitAllowExit(cwd, ["rev-parse", "--verify", value], [1, 128])).trim();
+  if (!canonical) return undefined;
+  const type = (await gitAllowExit(cwd, ["cat-file", "-t", canonical], [128])).trim();
   if (type !== "commit") return undefined;
-  const canonical = (await git(cwd, ["rev-parse", "--verify", value])).trim().toLowerCase();
-  return canonical === value.toLowerCase() ? canonical : undefined;
+  return canonical.toLowerCase();
 }
 
 async function headCommit(cwd: string): Promise<string | undefined> {
@@ -131,9 +125,16 @@ async function comparisonSnapshot(
     resolveCommit(cwd, requested.baseCommit),
     headCommit(cwd),
   ]);
-  if (!base || !head) return undefined;
+  if (!base) {
+    throw new Error(`Commit ${requested.baseCommit.slice(0, 7)} not found in this repository.`);
+  }
+  if (!head) {
+    throw new Error("No HEAD commit found in this repository.");
+  }
   const mergeBase = (await gitAllowExit(cwd, ["merge-base", base, head], [1])).trim();
-  if (!mergeBase) return undefined;
+  if (!mergeBase) {
+    throw new Error(`No common ancestor between ${base.slice(0, 7)} and ${head.slice(0, 7)}.`);
+  }
   const [diffText, names] = await Promise.all([
     git(cwd, ["diff", ...DIFF_FLAGS, mergeBase, head]),
     git(cwd, ["diff", "--name-only", "-z", mergeBase, head]),
@@ -160,7 +161,9 @@ async function commitSnapshot(
   requested: Extract<ReviewTargetSpec, { kind: "commit" }>,
 ): Promise<ReviewSnapshot | undefined> {
   const commit = await resolveCommit(cwd, requested.commit);
-  if (!commit) return undefined;
+  if (!commit) {
+    throw new Error(`Commit ${requested.commit.slice(0, 7)} not found in this repository.`);
+  }
   const parent = await commitParent(cwd, commit);
   const [diffText, names] = await Promise.all([
     parent

package/src/review.ts

@@ -1,6 +1,5 @@
 import { buildSessionContext, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Box } from "@earendil-works/pi-tui";
-import { Value } from "typebox/value";
 import { loadReviewConfig, registerReviewSettings } from "./config.ts";
 import { listLocalBranches, listRecentCommits } from "./git.ts";
 import { collectPlannerContext } from "./history/collect.ts";
@@ -8,8 +7,7 @@ import { getSelectableReviewModels, resolveAgentReviewModel } from "./model.ts";
 import { ReviewPlanStore } from "./session/review-plan-store.ts";
 import { formatReviewBatch, registerAgentReviewTools } from "./tool/agent-review-tools.ts";
 import { pageText } from "./tool/output-page.ts";
-import { normalizeReviewInput, prepareReview, runReview } from "./tool/review-workflow.ts";
-import { reviewInputSchema } from "./tool/schemas.ts";
+import { prepareReview, runReview } from "./tool/review-workflow.ts";
 import { renderRunResult } from "./tui/run.ts";
 import type { ReviewInput, ReviewModelSelection, ReviewTargetSpec } from "./types.ts";
 
@@ -58,25 +56,59 @@ async function selectReviewerModel(ctx: CommandContext): Promise<ReviewModelSele
   return models.find((model) => model.canonicalId === id);
 }
 
-/** Parse editor JSON through the same structural and semantic contract as agent input. */
-export async function editReview(
+/** Edit one task's instructions via a focused editor. Returns undefined on cancel. */
+async function editTaskInstructions(
+  ctx: CommandContext,
+  opts: { index: number; taskCount: number; id: string; defaultInstructions: string },
+): Promise<string | undefined> {
+  const { index, taskCount, id, defaultInstructions } = opts;
+  const label = taskCount > 1 ? `Task ${index + 1} of ${taskCount}: ${id}` : `Task: ${id}`;
+  const instructions = await ctx.ui.editor(label, defaultInstructions);
+  if (instructions === undefined) return undefined;
+  if (!instructions.trim()) {
+    ctx.ui.notify("Task instructions must not be blank.", "error");
+    return undefined;
+  }
+  return instructions.trim();
+}
+
+/** Step-by-step wizard: edit each task's instructions in its own focused editor. */
+async function editReviewInteractive(
   ctx: CommandContext,
   review: ReviewInput,
+  { allowResize }: { allowResize: boolean },
 ): Promise<ReviewInput | undefined> {
-  const text = await ctx.ui.editor("Edit review tasks (JSON)", JSON.stringify(review, null, 2));
-  if (text === undefined) return undefined;
-  try {
-    const parsed: unknown = JSON.parse(text);
-    if (!Value.Check(reviewInputSchema, parsed)) {
-      ctx.ui.notify("Review tasks do not match the required review schema.", "error");
-      return undefined;
-    }
-    return normalizeReviewInput(parsed);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Review tasks must be valid JSON.";
-    ctx.ui.notify(message, "error");
-    return undefined;
+  let taskCount = review.tasks.length;
+
+  if (allowResize) {
+    const countStr = await ctx.ui.select("How many review tasks?", ["1", "2", "3", "4"]);
+    if (!countStr) return undefined;
+    taskCount = Number(countStr);
   }
+
+  const tasks: ReviewInput["tasks"] = [];
+  for (let i = 0; i < taskCount; i++) {
+    const existing = review.tasks[i];
+    const id = existing?.id ?? `task-${i + 1}`;
+    const defaultInstructions = existing?.instructions ?? "";
+
+    const instructions = await editTaskInstructions(ctx, {
+      index: i,
+      taskCount,
+      id,
+      defaultInstructions,
+    });
+    if (instructions === undefined) return undefined;
+    tasks.push({ id, instructions });
+  }
+
+  const result: ReviewInput = { tasks };
+  if (review.sharedContext) {
+    const sharedContext = await ctx.ui.editor("Shared context (optional)", review.sharedContext);
+    if (sharedContext === undefined) return undefined;
+    if (sharedContext.trim()) result.sharedContext = sharedContext.trim();
+  }
+  return result;
 }
 
 async function runCommand(
@@ -89,12 +121,15 @@ async function runCommand(
   if (!target) return;
   const reviewerModel = await selectReviewerModel(ctx);
   if (!reviewerModel) return;
-  const planning = await ctx.ui.select("Review planning", ["Write tasks", "Suggest tasks"]);
+  const planning = await ctx.ui.select("Review planning", [
+    "Write my own tasks",
+    "AI suggests tasks",
+  ]);
   if (!planning) return;
 
   let review = DEFAULT_REVIEW;
   let planId: string | undefined;
-  if (planning === "Suggest tasks") {
+  if (planning === "AI suggests tasks") {
     const config = loadReviewConfig(ctx.cwd);
     const plannerModel = resolveAgentReviewModel(ctx, config.plannerModel);
     if (!plannerModel) {
@@ -122,7 +157,9 @@ async function runCommand(
     planId = outcome.plan.id;
   }
 
-  const edited = await editReview(ctx, review);
+  const edited = await editReviewInteractive(ctx, review, {
+    allowResize: planning === "Write my own tasks",
+  });
   if (!edited) return;
   const approved = await ctx.ui.confirm(
     "Run review?",

package/src/tool/agent-review-schemas.ts

@@ -5,10 +5,11 @@ import type { ReviewInput, ReviewTargetSpec } from "../types.ts";
 import { reviewInputSchema } from "./schemas.ts";
 
 const commitId = Type.String({
-  minLength: 40,
+  minLength: 7,
   maxLength: 64,
-  pattern: "^(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$",
-  description: "Full hexadecimal Git commit object id (40 or 64 characters).",
+  pattern: "^[0-9a-fA-F]{7,64}$",
+  description:
+    "Git commit hash (7-64 hex characters). Short hashes are resolved to full commit ids.",
 });
 const targetSchema = Type.Object(
   {
@@ -73,16 +74,22 @@ function parseTarget(input: {
   baseCommit?: string;
   commit?: string;
 }): ReviewTargetSpec {
-  if (input.kind === "working-tree" && !input.baseCommit && !input.commit) {
+  if (input.kind === "working-tree") {
     return { kind: "working-tree" };
   }
-  if (input.kind === "comparison" && input.baseCommit && !input.commit) {
+  if (input.kind === "comparison") {
+    if (!input.baseCommit) {
+      throw new Error(`Comparison targets require a baseCommit (full 40- or 64-char commit id).`);
+    }
     return { kind: "comparison", baseCommit: input.baseCommit };
   }
-  if (input.kind === "commit" && input.commit && !input.baseCommit) {
+  if (input.kind === "commit") {
+    if (!input.commit) {
+      throw new Error(`Commit targets require a commit field (full 40- or 64-char commit id).`);
+    }
     return { kind: "commit", commit: input.commit };
   }
-  throw new Error(`Target fields do not match target kind "${input.kind}".`);
+  throw new Error(`Unknown target kind "${input.kind}".`);
 }
 
 /** Validate and narrow preparation input after provider-level JSON parsing. */

package/src/tool/agent-review-tools.ts

@@ -15,6 +15,7 @@ import {
   prepareReviewSchema,
   runReviewSchema,
 } from "./agent-review-schemas.ts";
+import { formatChildFailureDiagnostics } from "./child-failure-diagnostics.ts";
 import { pageText } from "./output-page.ts";
 import { prepareReview, runReview } from "./review-workflow.ts";
 
@@ -54,10 +55,26 @@ function formatTaskResult(result: ReviewTaskResult): string[] {
     `Model: ${result.modelId}`,
     `Packet SHA-256: ${result.packetHash}`,
   ];
-  if (result.status === "failed") return [...lines, `Status: failed (${result.failureCode})`];
-  if (result.status === "canceled") return [...lines, "Status: canceled"];
+  if (result.status === "failed") {
+    lines.push(`Status: failed (${result.failureCode})`);
+    if (result.diagnostics) {
+      lines.push("", ...formatChildFailureDiagnostics(result.diagnostics));
+    }
+    return lines;
+  }
+  if (result.status === "canceled") {
+    lines.push("Status: canceled");
+    if (result.diagnostics) {
+      lines.push("", ...formatChildFailureDiagnostics(result.diagnostics));
+    }
+    return lines;
+  }
   if (result.status === "timeout") {
-    return [...lines, `Status: timeout (${result.timeoutMs} ms)`];
+    lines.push(`Status: timeout (${result.timeoutMs} ms)`);
+    if (result.diagnostics) {
+      lines.push("", ...formatChildFailureDiagnostics(result.diagnostics));
+    }
+    return lines;
   }
   lines.push(`Verdict: ${result.verdict.toUpperCase()}`, "", result.summary);
   for (const finding of result.findings) {

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

@@ -8,6 +8,7 @@ import type {
 import {
   type ChildLifecycleTrace,
   ChildLifecycleTraceCollector,
+  extractLastLifecycleErrorText,
   formatChildLifecycleTrace,
   getRegisteredToolNames,
   toSafeAssistantStopReason,
@@ -40,6 +41,8 @@ export function buildChildFailureDiagnostics(
     recentActivity: input.recentActivity.length > 0 ? [...input.recentActivity] : undefined,
     lastAssistantStopReason: lastAssistant?.stopReason,
     lastAssistantToolCalls: lastAssistant?.toolCalls,
+    lastAssistantErrorText: lastAssistant?.errorText,
+    lastLifecycleErrorText: extractLastLifecycleErrorText(input.lifecycleTrace),
   };
 }
 
@@ -95,6 +98,13 @@ export function formatChildFailureDiagnostics(diagnostics: ChildFailureDiagnosti
     diagnostics.lastAssistantToolCalls && diagnostics.lastAssistantToolCalls.length > 0
       ? `- Last assistant tools: ${diagnostics.lastAssistantToolCalls.join(", ")}`
       : undefined,
+    diagnostics.lastAssistantErrorText
+      ? `- Last assistant error: ${diagnostics.lastAssistantErrorText}`
+      : undefined,
+    diagnostics.lastLifecycleErrorText &&
+    diagnostics.lastLifecycleErrorText !== diagnostics.lastAssistantErrorText
+      ? `- Lifecycle error: ${diagnostics.lastLifecycleErrorText}`
+      : undefined,
     `- ${formatChildLifecycleTrace(diagnostics.lifecycleTrace)}`,
   ];
   return lines.filter((line): line is string => !!line);
@@ -103,6 +113,7 @@ export function formatChildFailureDiagnostics(diagnostics: ChildFailureDiagnosti
 interface LastAssistantMetadata {
   stopReason?: string;
   toolCalls?: string[];
+  errorText?: string;
 }
 
 function extractLastAssistantMetadata(session: AgentSession): LastAssistantMetadata | undefined {
@@ -117,9 +128,11 @@ function extractLastAssistantMetadata(session: AgentSession): LastAssistantMetad
 
       const stopReason = toSafeAssistantStopReason(message.stopReason);
       const toolCalls = extractAssistantToolCalls(message.content, registeredToolNames);
+      const errorText = stopReason === "error" ? extractAssistantErrorText(message) : undefined;
       return {
         stopReason,
         toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        errorText,
       };
     }
     return undefined;
@@ -143,3 +156,48 @@ function extractAssistantToolCalls(content: unknown, registeredToolNames: Set<st
     })
     .filter((name): name is string => !!name);
 }
+
+/** Extract error text from content text parts when the model embeds an error message. */
+function extractContentErrorText(content: unknown): string | undefined {
+  if (!Array.isArray(content)) return undefined;
+  const textParts = content
+    .filter(
+      (part): part is { type: "text"; text: string } =>
+        typeof part === "object" &&
+        part !== null &&
+        (part as { type?: unknown }).type === "text" &&
+        typeof (part as { text?: unknown }).text === "string",
+    )
+    .map((part) => part.text);
+  if (textParts.length === 0) return undefined;
+  const joined = textParts.join("\n").trim();
+  return joined || undefined;
+}
+
+/** Scan enumerable message keys for any error-like string property as a fallback. */
+function scanMessageKeysForError(message: Record<string, unknown>): string | undefined {
+  for (const key of Object.keys(message)) {
+    if (!/error|message|reason/i.test(key)) continue;
+    const value = message[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return undefined;
+}
+
+/** Extract error text from an errored assistant message, trying content text parts first then top-level error fields. */
+function extractAssistantErrorText(message: Record<string, unknown>): string | undefined {
+  // 1. Try content text parts (model may embed error in text)
+  const contentError = extractContentErrorText(message.content);
+  if (contentError) return contentError;
+
+  // 2. Try top-level error message (provider-level error payload)
+  if (typeof message.errorMessage === "string" && message.errorMessage.trim()) {
+    return message.errorMessage;
+  }
+  if (typeof message.error === "string" && message.error.trim()) {
+    return message.error;
+  }
+
+  // 3. Fallback: scan enumerable keys for any error-like string property
+  return scanMessageKeysForError(message);
+}

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

@@ -53,9 +53,16 @@ export type ChildLifecycleTraceEntry =
       willRetry: boolean;
       hasResult: boolean;
       hasError: boolean;
+      errorText?: string;
     }
   | { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number }
-  | { type: "auto_retry_end"; success: boolean; attempt: number; hasFinalError: boolean }
+  | {
+      type: "auto_retry_end";
+      success: boolean;
+      attempt: number;
+      hasFinalError: boolean;
+      finalErrorText?: string;
+    }
   | {
       type: "summarization_retry_scheduled";
       attempt: number;
@@ -161,6 +168,20 @@ export class ChildLifecycleTraceCollector {
   }
 }
 
+/**
+ * Extract error text from the most recent lifecycle entry that carries an error.
+ * Checks compaction_end.errorText and auto_retry_end.finalErrorText.
+ */
+export function extractLastLifecycleErrorText(trace: ChildLifecycleTrace): string | undefined {
+  // Walk backwards to find the most recent error
+  for (let i = trace.entries.length - 1; i >= 0; i--) {
+    const entry = trace.entries[i];
+    if (entry.type === "compaction_end" && entry.errorText) return entry.errorText;
+    if (entry.type === "auto_retry_end" && entry.finalErrorText) return entry.finalErrorText;
+  }
+  return undefined;
+}
+
 /** Format the complete retained Child Lifecycle Trace for parent-facing diagnostics. */
 export function formatChildLifecycleTrace(trace: ChildLifecycleTrace): string {
   const tail =
@@ -185,11 +206,11 @@ function formatChildLifecycleTraceEntry(entry: ChildLifecycleTraceEntry): string
     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})`;
+      return `compaction_end(reason=${entry.reason}, aborted=${entry.aborted}, willRetry=${entry.willRetry}, hasResult=${entry.hasResult}, hasError=${entry.hasError}${entry.errorText ? `, error=${JSON.stringify(entry.errorText)}` : ""})`;
     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})`;
+      return `auto_retry_end(success=${entry.success}, attempt=${entry.attempt}, hasFinalError=${entry.hasFinalError}${entry.finalErrorText ? `, error=${JSON.stringify(entry.finalErrorText)}` : ""})`;
     case "summarization_retry_scheduled":
       return `summarization_retry_scheduled(attempt=${entry.attempt}/${entry.maxAttempts}, delayMs=${entry.delayMs})`;
     case "summarization_retry_attempt_start":
@@ -269,6 +290,10 @@ function mapLifecycleEvent(event: AgentSessionEvent): ChildLifecycleTraceEntry |
             willRetry: event.willRetry,
             hasResult: event.result !== undefined,
             hasError: event.errorMessage !== undefined,
+            errorText:
+              typeof event.errorMessage === "string" && event.errorMessage.trim()
+                ? event.errorMessage
+                : undefined,
           }
         : undefined;
     case "auto_retry_start":
@@ -289,6 +314,10 @@ function mapLifecycleEvent(event: AgentSessionEvent): ChildLifecycleTraceEntry |
             success: event.success,
             attempt: event.attempt,
             hasFinalError: event.finalError !== undefined,
+            finalErrorText:
+              typeof event.finalError === "string" && event.finalError.trim()
+                ? event.finalError
+                : undefined,
           }
         : undefined;
     case "summarization_retry_scheduled":

package/src/tool/review-workflow.ts

@@ -119,13 +119,24 @@ function plannerPrompt(snapshot: ReviewSnapshot, context: string): string {
   ].join("\n");
 }
 
+/** Translate a resolveReviewSnapshot error to a no-target reason. */
+function snapshotErrorReason(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return "No reviewable changes found.";
+}
+
 /** Resolve and store a one-shot plan, optionally asking the advisory Planner for tasks. */
 export async function prepareReview(input: PrepareReviewInput) {
   input.onUpdate?.({
     content: [{ type: "text", text: "Resolving target…" }],
     details: {},
   });
-  const snapshot = await resolveReviewSnapshot(input.cwd, input.target);
+  let snapshot: Awaited<ReturnType<typeof resolveReviewSnapshot>>;
+  try {
+    snapshot = await resolveReviewSnapshot(input.cwd, input.target);
+  } catch (error) {
+    return { kind: "no-target" as const, reason: snapshotErrorReason(error) };
+  }
   if (!snapshot) return { kind: "no-target" as const, reason: "No reviewable changes found." };
   let plannerDraft: PlannerDraft | undefined;
   if (input.planning === "suggest") {
@@ -258,7 +269,12 @@ export async function runReview(input: RunReviewInput) {
   let provenance: ReviewBatchDetails["provenance"] = "caller-supplied";
 
   if (input.mode === "direct") {
-    const resolved = await resolveReviewSnapshot(input.cwd, input.target);
+    let resolved: Awaited<ReturnType<typeof resolveReviewSnapshot>>;
+    try {
+      resolved = await resolveReviewSnapshot(input.cwd, input.target);
+    } catch (error) {
+      return { kind: "no-target" as const, reason: snapshotErrorReason(error) };
+    }
     if (!resolved) return { kind: "no-target" as const, reason: "No reviewable changes found." };
     snapshot = resolved;
     review = normalizeReviewInput(input.review);

package/src/tui/common.ts

@@ -9,6 +9,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { type Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { formatEvidenceBadge } from "@mrclrchtr/supi-core/evidence-badge";
 import type {
+  ChildFailureDiagnostics,
   FindingEffort,
   FindingImpact,
   ReviewFinding,
@@ -118,6 +119,64 @@ function renderFinding(container: Container, finding: ReviewFinding, theme: Them
   container.addChild(new Spacer(1));
 }
 
+/** Build a compact diagnostics section for non-completed (failed/canceled/timeout) task results. */
+function buildNonCompletedSection(
+  container: Container,
+  result: ReviewTaskResult & { status: "failed" | "canceled" | "timeout" },
+  theme: Theme,
+): void {
+  const diagnostics: ChildFailureDiagnostics | undefined =
+    "diagnostics" in result ? result.diagnostics : undefined;
+  if (!diagnostics) return;
+
+  container.addChild(new Spacer(1));
+  container.addChild(
+    new Text(
+      theme.fg("dim", `${diagnostics.turns} turns · ${diagnostics.toolUses} tool uses`),
+      1,
+      0,
+    ),
+  );
+
+  if (diagnostics.lastAssistantStopReason) {
+    container.addChild(
+      new Text(
+        theme.fg(
+          diagnostics.lastAssistantStopReason === "error" ? "error" : "dim",
+          `Last assistant stop: ${diagnostics.lastAssistantStopReason}`,
+        ),
+        1,
+        0,
+      ),
+    );
+  }
+
+  if (diagnostics.lastAssistantErrorText) {
+    const truncated =
+      diagnostics.lastAssistantErrorText.length > 200
+        ? `${diagnostics.lastAssistantErrorText.slice(0, 200)}…`
+        : diagnostics.lastAssistantErrorText;
+    container.addChild(new Text(theme.fg("error", truncated), 1, 0));
+  } else if (diagnostics.lastLifecycleErrorText) {
+    const truncated =
+      diagnostics.lastLifecycleErrorText.length > 200
+        ? `${diagnostics.lastLifecycleErrorText.slice(0, 200)}…`
+        : diagnostics.lastLifecycleErrorText;
+    container.addChild(new Text(theme.fg("error", truncated), 1, 0));
+  } else if (diagnostics.lastAssistantStopReason === "error") {
+    container.addChild(
+      new Text(
+        theme.fg(
+          "dim",
+          "The model produced an error with no further details — check provider quota, auth, or configuration.",
+        ),
+        1,
+        0,
+      ),
+    );
+  }
+}
+
 /** Build an expanded-view section for a single review task result. */
 export function buildTaskSection(
   container: Container,
@@ -159,7 +218,10 @@ export function buildTaskSection(
   container.addChild(new Text(metaParts.join("  "), 1, 0));
 
   // Completed task — show summary and findings
-  if (result.status !== "completed") return;
+  if (result.status !== "completed") {
+    buildNonCompletedSection(container, result, theme);
+    return;
+  }
 
   if (result.summary) {
     container.addChild(new Spacer(1));

package/src/types.ts

@@ -109,6 +109,10 @@ export interface ChildFailureDiagnostics {
   recentActivity?: string[];
   lastAssistantStopReason?: string;
   lastAssistantToolCalls?: string[];
+  /** Error text extracted from the last assistant message when stopReason is "error". */
+  lastAssistantErrorText?: string;
+  /** Error text extracted from the most recent lifecycle event (compaction_end, auto_retry_end). */
+  lastLifecycleErrorText?: string;
 }
 
 export type ChildFailedResult =