@mrclrchtr/supi-review 2.6.1 → 2.8.0

package/README.md

@@ -134,9 +134,29 @@ Every `/supi-review` command run asks you to choose the reviewer model.
 - the picker only shows **scoped models** from Pi's `enabledModels` configuration
 - the current session model is preselected only when it is inside that scoped set
 - the selected model is used for both brief synthesis and the final review
-- no review model is persisted in settings
+- the command selection is not persisted
 
-Agent-driven tool runs use the current session model for preparation and all focused reviewers. The selected model is retained in the prepared plan so a model change between tool calls cannot silently alter the run.
+Agent-driven tool runs use the **Review → Agent tool model** setting in `/supi-settings` when `@mrclrchtr/supi-settings` is installed:
+
+- `current session model` is the default and preserves the active-session behavior
+- an explicit choice stores a canonical `provider/model-id` from Pi's scoped `enabledModels` set
+- the configured model is used for brief synthesis and every focused reviewer
+- project settings override global settings through the normal SuPi settings scopes
+- a configured model that is no longer scoped or available causes preparation to fail with a corrective error
+
+The resolved model is retained in the prepared plan, so changing the setting or active session model between tool calls cannot silently alter the run.
+
+For a standalone `supi-review` install without `supi-settings`, set the same value directly in the global `~/.pi/agent/supi/config.json` or project `.pi/supi/config.json` file:
+
+```json
+{
+  "review": {
+    "agentModel": "openai/gpt-5"
+  }
+}
+```
+
+Use `"current"` instead of a canonical model id to follow the active session model.
 
 ## Result shape
 
@@ -175,7 +195,8 @@ When a successful review contains review items, `supi-review` also injects an ag
 ## Source
 
 - `src/review.ts` — command orchestration and interactive flow
-- `src/model.ts` — explicit model selection helpers
+- `src/config.ts` — persisted agent-tool model setting and `/supi-settings` registration
+- `src/model.ts` — explicit and configured model selection helpers
 - `src/git.ts` — git snapshot resolution
 - `src/history/collect.ts` — compaction-style session-context serialization
 - `src/history/synthesize.ts` — brief synthesis orchestration

package/node_modules/@mrclrchtr/supi-core/README.md

@@ -43,7 +43,7 @@ Config file locations:
 - `registerSettingsCommand(pi)` — register `/supi-settings` (used by `@mrclrchtr/supi-settings`)
 - `openSettingsOverlay(pi, ctx)` — open the shared settings UI directly
 - `createInputSubmenu()` — helper for simple text-entry submenus
-- `createModelPickerSubmenu()` — helper for scoped model selection submenus
+- `createModelPickerSubmenu()` — helper for scoped model selection submenus, with optional host-owned choices and `disabled` control
 
 The built-in settings UI supports:
 

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

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

package/node_modules/@mrclrchtr/supi-core/src/settings/scoped-settings-list.ts

@@ -324,6 +324,7 @@ export class ScopedSettingsList {
             this.tui.requestRender();
           },
           this.ctx,
+          row.field.field,
         ),
         onDone: () => {
           this.submenu = null;

package/node_modules/@mrclrchtr/supi-core/src/settings/settings-schema.ts

@@ -91,9 +91,23 @@ export interface StringListField extends BaseField {
   kind: "stringList";
 }
 
+/** One non-model choice shown before the scoped models in a model picker. */
+export interface ModelPickerStaticOption {
+  /** Persisted value for the choice. */
+  value: string;
+  /** Human-readable picker label. */
+  label: string;
+  /** Optional explanation shown alongside the label. */
+  description?: string;
+}
+
 /** Model picker backed by the scoped model set. */
 export interface ModelPickerField extends BaseField {
   kind: "modelPicker";
+  /** Additional host-owned choices shown before scoped models. */
+  staticOptions?: ModelPickerStaticOption[];
+  /** Whether to include the built-in `disabled` choice. Defaults to true. */
+  includeDisabled?: boolean;
 }
 
 /**

package/node_modules/@mrclrchtr/supi-core/src/settings/settings-submenus.ts

@@ -14,6 +14,7 @@ import {
   Text,
 } from "@earendil-works/pi-tui";
 import { getSelectableModels } from "../model-selection.ts";
+import type { ModelPickerField } from "./settings-schema.ts";
 
 /**
  * Creates a pi-tui Input-backed submenu component with enter-to-confirm
@@ -57,25 +58,26 @@ export function createInputSubmenu(
 }
 
 /**
- * Creates a model picker submenu for settings with "disabled" as the first option.
+ * Creates a model picker submenu backed by the scoped model set.
+ *
+ * The built-in `disabled` choice remains enabled by default. Callers can add
+ * host-owned static choices or omit `disabled` through the field options.
  */
 export function createModelPickerSubmenu(
   currentValue: string,
   done: (selectedValue?: string) => void,
   ctx?: ExtensionContext,
+  options: Pick<ModelPickerField, "includeDisabled" | "staticOptions"> = {},
 ): {
   render: (width: number) => string[];
   invalidate: () => void;
   handleInput: (data: string) => boolean;
 } {
-  const items = buildModelItems(ctx);
-  const initialIndex =
-    currentValue === "disabled"
-      ? 0
-      : Math.max(
-          0,
-          items.findIndex((item) => item.value === currentValue),
-        );
+  const items = buildModelItems(ctx, options);
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((item) => item.value === currentValue),
+  );
 
   const container = new Container();
   container.addChild(new Text("  Select model", 1, 0));
@@ -105,20 +107,35 @@ export function createModelPickerSubmenu(
   };
 }
 
-/** Build selectable model items with "disabled" as the first option. */
-function buildModelItems(ctx?: ExtensionContext): SelectItem[] {
-  const items: SelectItem[] = [
-    { value: "disabled", label: "disabled", description: "No model selected" },
-  ];
+/** Build static choices followed by the selectable scoped models. */
+function buildModelItems(
+  ctx: ExtensionContext | undefined,
+  options: Pick<ModelPickerField, "includeDisabled" | "staticOptions">,
+): SelectItem[] {
+  const items: SelectItem[] = [];
+  const seen = new Set<string>();
+  for (const option of options.staticOptions ?? []) {
+    if (seen.has(option.value)) continue;
+    items.push({ ...option });
+    seen.add(option.value);
+  }
+
+  if (options.includeDisabled !== false && !seen.has("disabled")) {
+    items.push({ value: "disabled", label: "disabled", description: "No model selected" });
+    seen.add("disabled");
+  }
+
   if (!ctx) return items;
   const models = getSelectableModels(ctx);
   for (const model of models) {
+    if (seen.has(model.canonicalId)) continue;
     const suffix = model.isCurrent ? "  [current]" : "";
     items.push({
       value: model.canonicalId,
       label: `${model.canonicalId}${suffix}`,
       description: model.label !== model.canonicalId ? model.label : undefined,
     });
+    seen.add(model.canonicalId);
   }
   return items;
 }

package/node_modules/@mrclrchtr/supi-core/src/settings.ts

@@ -20,6 +20,7 @@ export type {
   DeclarativeSettingsOptions,
   EnumField,
   ModelPickerField,
+  ModelPickerStaticOption,
   NumberField,
   ScopedFieldValue,
   SettingsField,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-review",
-  "version": "2.6.1",
+  "version": "2.8.0",
   "description": "SuPi Review extension — session-aware review command and agent tools",
   "license": "MIT",
   "repository": {
@@ -31,7 +31,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "2.6.1"
+    "@mrclrchtr/supi-core": "2.8.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"

package/src/config.ts

@@ -0,0 +1,55 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadSupiConfig } from "@mrclrchtr/supi-core/config";
+import { registerDeclarativeSettings } from "@mrclrchtr/supi-core/settings";
+import { CURRENT_SESSION_REVIEW_MODEL } from "./model.ts";
+
+/** Persisted configuration for agent-driven Session-Aware Review. */
+export interface ReviewConfig extends Record<string, unknown> {
+  /** Canonical `provider/model-id`, or `current` to use the active session model. */
+  agentModel: string;
+}
+
+/** Shared SuPi config section owned by supi-review. */
+export const REVIEW_CONFIG_SECTION = "review";
+
+/** Package defaults for supi-review configuration. */
+export const REVIEW_DEFAULTS: ReviewConfig = {
+  agentModel: CURRENT_SESSION_REVIEW_MODEL,
+};
+
+/** Load merged, validated supi-review configuration for a workspace. */
+export function loadReviewConfig(cwd: string, homeDir?: string): ReviewConfig {
+  const raw = loadSupiConfig(REVIEW_CONFIG_SECTION, cwd, REVIEW_DEFAULTS, { homeDir });
+  const agentModel =
+    typeof raw.agentModel === "string" && raw.agentModel.trim()
+      ? raw.agentModel.trim()
+      : REVIEW_DEFAULTS.agentModel;
+  return { agentModel };
+}
+
+/** Register the Review section contributed to `/supi-settings`. */
+export function registerReviewSettings(pi: ExtensionAPI, homeDir?: string): void {
+  registerDeclarativeSettings(pi, {
+    id: REVIEW_CONFIG_SECTION,
+    label: "Review",
+    section: REVIEW_CONFIG_SECTION,
+    defaults: REVIEW_DEFAULTS,
+    fields: [
+      {
+        kind: "modelPicker",
+        key: "agentModel",
+        label: "Agent tool model",
+        description: "Model used for brief synthesis and reviewers started by supi_review_prepare.",
+        includeDisabled: false,
+        staticOptions: [
+          {
+            value: CURRENT_SESSION_REVIEW_MODEL,
+            label: "current session model",
+            description: "Use the model active when supi_review_prepare starts",
+          },
+        ],
+      },
+    ],
+    ...(homeDir ? { homeDir } : {}),
+  });
+}

package/src/model.ts

@@ -2,6 +2,9 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getSelectableModels } from "@mrclrchtr/supi-core/model-selection";
 import type { ReviewModelSelection } from "./types.ts";
 
+/** Sentinel that resolves to the model active when review preparation starts. */
+export const CURRENT_SESSION_REVIEW_MODEL = "current";
+
 /** Build the canonical `provider/modelId` string used throughout the review flow. */
 export { toCanonicalModelId } from "@mrclrchtr/supi-core/model-selection";
 
@@ -35,3 +38,33 @@ export function getCurrentReviewModel(
     isCurrent: true,
   };
 }
+
+/**
+ * Resolve the configured model for an agent-driven review.
+ *
+ * `current` preserves the historical behavior. Explicit canonical model ids
+ * must be both available and present in Pi's current scoped model set.
+ */
+export function resolveAgentReviewModel(
+  ctx: Pick<ExtensionContext, "cwd" | "modelRegistry" | "model">,
+  configuredModelId: string,
+  enabledModelPatterns?: string[],
+): ReviewModelSelection | undefined {
+  const modelId = configuredModelId.trim();
+  if (modelId === CURRENT_SESSION_REVIEW_MODEL) {
+    return getCurrentReviewModel(ctx);
+  }
+
+  const selection = getSelectableReviewModels(
+    { cwd: ctx.cwd, modelRegistry: ctx.modelRegistry, model: undefined },
+    enabledModelPatterns,
+  ).find((candidate) => candidate.canonicalId === modelId);
+  if (!selection) return undefined;
+
+  return {
+    ...selection,
+    isCurrent: ctx.model
+      ? `${ctx.model.provider}/${ctx.model.id}` === selection.canonicalId
+      : false,
+  };
+}

package/src/review.ts

@@ -1,12 +1,14 @@
 import { buildSessionContext, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { WidgetProgress } from "@mrclrchtr/supi-core/progress-widget";
 import { runWithProgressWidget } from "@mrclrchtr/supi-core/tool-framework";
+import { registerReviewSettings } from "./config.ts";
 import { resolveBranchSnapshot, resolveCommitSnapshot, resolveWorkingTreeSnapshot } from "./git.ts";
 import { serializeSessionContext } from "./history/collect.ts";
 import { synthesizeReviewBrief } from "./history/synthesize.ts";
 import { normalizeReviewResult } from "./review-result.ts";
 import { buildReviewPacket } from "./target/packet.ts";
 import { registerAgentReviewTools } from "./tool/agent-review-tools.ts";
+import { createUnobservedChildFailureDiagnostics } from "./tool/child-failure-diagnostics.ts";
 import { runReviewer } from "./tool/review-runner.ts";
 import type {
   BriefSynthesisRunResult,
@@ -17,13 +19,18 @@ import type {
   ReviewTargetSpec,
 } from "./types.ts";
 import { collectReviewNote, previewReviewPlan, selectModel, selectTarget } from "./ui/flow.ts";
-import { formatReviewContent } from "./ui/format-content.ts";
+import {
+  formatBriefSynthesisFailureContent,
+  formatBriefSynthesisFailureCopy,
+  formatReviewContent,
+} from "./ui/format-content.ts";
 import { registerReviewRenderer } from "./ui/renderer.ts";
 
 type CommandContext = Parameters<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>[1];
 
 export default function reviewExtension(pi: ExtensionAPI) {
   registerReviewRenderer(pi);
+  registerReviewSettings(pi);
   registerAgentReviewTools(pi);
 
   pi.registerCommand("supi-review", {
@@ -74,22 +81,21 @@ async function handleInteractive(ctx: CommandContext, pi: ExtensionAPI): Promise
   );
 
   if (!synthesis) {
-    notifyBriefDone(
-      pi,
-      {
-        kind: "failed",
-        reason: "Brief synthesis encountered an unexpected error",
-      } as BriefSynthesisRunResult,
-      snapshot,
-      model.canonicalId,
-    );
-    ctx.ui.notify("Brief synthesis was canceled or failed", "warning");
+    const failure: BriefSynthesisRunResult = {
+      kind: "failed",
+      failureCode: "unexpected-runner-failure",
+      diagnostics: createUnobservedChildFailureDiagnostics(),
+    };
+    notifyBriefDone(pi, failure, snapshot, model.canonicalId);
+    injectBriefSynthesisFailureMessage(pi, failure, snapshot, model.canonicalId);
+    ctx.ui.notify(formatBriefSynthesisFailureCopy(failure), "warning");
     return;
   }
 
   notifyBriefDone(pi, synthesis, snapshot, model.canonicalId);
 
   if (synthesis.kind !== "success") {
+    injectBriefSynthesisFailureMessage(pi, synthesis, snapshot, model.canonicalId);
     notifySynthesisFailure(synthesis, ctx);
     return;
   }
@@ -122,14 +128,17 @@ async function handleInteractive(ctx: CommandContext, pi: ExtensionAPI): Promise
   );
 
   if (!rawResult) {
-    notifyReviewDone(pi, {
+    const failure: ReviewResult = {
       kind: "failed",
-      reason: "Review encountered an unexpected error",
+      failureCode: "unexpected-runner-failure",
+      diagnostics: createUnobservedChildFailureDiagnostics(),
       snapshot,
       brief,
       modelId: model.canonicalId,
-    } as ReviewResult);
-    ctx.ui.notify("Review was canceled or failed", "warning");
+    };
+    notifyReviewDone(pi, failure);
+    injectReviewMessage(pi, failure);
+    ctx.ui.notify("Reviewer ended unexpectedly.", "warning");
     return;
   }
 
@@ -172,20 +181,27 @@ function notifySynthesisFailure(
   result: Exclude<BriefSynthesisRunResult, { kind: "success" }>,
   ctx: CommandContext,
 ): void {
-  switch (result.kind) {
-    case "failed":
-      ctx.ui.notify(result.reason, "error");
-      break;
-    case "timeout":
-      ctx.ui.notify(
-        `Brief synthesis timed out after ${(result.timeoutMs / 1000).toFixed(0)}s`,
-        "warning",
-      );
-      break;
-    case "canceled":
-      ctx.ui.notify("Review canceled", "warning");
-      break;
-  }
+  ctx.ui.notify(
+    formatBriefSynthesisFailureCopy(result),
+    result.kind === "failed" ? "error" : "warning",
+  );
+}
+
+/** Persist a brief-synthesis failure so bounded diagnostics remain inspectable in parent history. */
+function injectBriefSynthesisFailureMessage(
+  pi: ExtensionAPI,
+  result: Exclude<BriefSynthesisRunResult, { kind: "success" }>,
+  snapshot: ReviewSnapshot,
+  modelId: string,
+): void {
+  pi.sendMessage({
+    customType: "supi-review",
+    content: formatBriefSynthesisFailureContent(result),
+    display: true,
+    details: {
+      briefSynthesisFailure: { result, snapshot, modelId },
+    },
+  });
 }
 
 /** Ring the terminal bell so the user knows to check back. */

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

@@ -10,9 +10,10 @@ import {
   truncateHead,
 } from "@earendil-works/pi-coding-agent";
 import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
+import { loadReviewConfig } from "../config.ts";
 import { isCommitObjectId, summarizeReviewSnapshot } from "../git.ts";
 import { serializeSessionContext } from "../history/collect.ts";
-import { getCurrentReviewModel } from "../model.ts";
+import { CURRENT_SESSION_REVIEW_MODEL, resolveAgentReviewModel } from "../model.ts";
 import { ReviewPlanStore } from "../session/review-plan-store.ts";
 import type {
   BriefEvaluation,
@@ -20,6 +21,7 @@ import type {
   ReviewProgress,
   ReviewTargetSpec,
 } from "../types.ts";
+import { formatBriefSynthesisFailureCopy } from "../ui/format-content.ts";
 import { formatAgentReviewBatch, formatPreparedAgentReview } from "../ui/review-tool-format.ts";
 import {
   type AgentReviewProgressDetails,
@@ -35,6 +37,7 @@ import {
   runAgentReviewSchema,
 } from "./agent-review-schemas.ts";
 import { prepareAgentReviewPlan, runAgentReviewBatch } from "./agent-review-workflow.ts";
+import { formatChildLifecycleTrace } from "./child-lifecycle-trace.ts";
 import {
   PREPARE_REVIEW_TOOL_NAME,
   prepareReviewPromptGuidelines,
@@ -62,8 +65,16 @@ export function registerAgentReviewTools(
     // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const input = params as PrepareAgentReviewInput;
-      const model = getCurrentReviewModel(ctx);
-      if (!model) throw new Error("No current session model is available for review preparation.");
+      const configuredModelId = loadReviewConfig(ctx.cwd).agentModel;
+      const model = resolveAgentReviewModel(ctx, configuredModelId);
+      if (!model) {
+        if (configuredModelId === CURRENT_SESSION_REVIEW_MODEL) {
+          throw new Error("No current session model is available for review preparation.");
+        }
+        throw new Error(
+          `Configured agent review model "${configuredModelId}" is not available in Pi's scoped model set. Choose another model in /supi-settings.`,
+        );
+      }
 
       const target = parseTarget(input);
       const sessionContext = buildSessionContext(
@@ -228,14 +239,12 @@ function formatPreparationFailure(
   outcome: Exclude<Awaited<ReturnType<typeof prepareAgentReviewPlan>>, { kind: "prepared" }>,
 ): string {
   if (outcome.kind === "no-snapshot") return outcome.reason;
-  switch (outcome.result.kind) {
-    case "failed":
-      return `Brief synthesis failed: ${outcome.result.reason}`;
-    case "canceled":
-      return "Brief synthesis was canceled.";
-    case "timeout":
-      return `Brief synthesis timed out after ${(outcome.result.timeoutMs / 1_000).toFixed(0)}s.`;
-  }
+
+  const { result } = outcome;
+  const trace = result.diagnostics?.lifecycleTrace;
+  return trace
+    ? `${formatBriefSynthesisFailureCopy(result)}\n\n${formatChildLifecycleTrace(trace)}`
+    : formatBriefSynthesisFailureCopy(result);
 }
 
 function activateRunTool(pi: ExtensionAPI): void {

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

@@ -22,8 +22,8 @@ import type {
   ReviewTargetSpec,
   SynthesizedReviewBrief,
 } from "../types.ts";
+import { createUnobservedChildFailureDiagnostics } from "./child-failure-diagnostics.ts";
 import { runReviewer } from "./review-runner.ts";
-
 /** Inputs required to synthesize and retain one agent-driven review plan. */
 export interface PrepareAgentReviewWorkflowInput {
   cwd: string;
@@ -35,13 +35,11 @@ export interface PrepareAgentReviewWorkflowInput {
   onProgress?: (progress: ReviewProgress) => void;
   planStore: ReviewPlanStore;
 }
-
 /** Typed preparation outcome before any reviewer child session starts. */
 export type PrepareAgentReviewWorkflowOutcome =
   | { kind: "prepared"; plan: StoredAgentReviewPlan }
   | { kind: "no-snapshot"; reason: string }
   | { kind: "synthesis-failed"; result: Exclude<BriefSynthesisRunResult, { kind: "success" }> };
-
 /** Inputs required to critique and execute one prepared review plan. */
 export interface RunAgentReviewWorkflowInput {
   cwd: string;
@@ -55,13 +53,11 @@ export interface RunAgentReviewWorkflowInput {
   onReviewerDone?: (reviewerId: string) => void;
   planStore: ReviewPlanStore;
 }
-
 /** Typed batch outcome after validation and snapshot freshness checks. */
 export type RunAgentReviewWorkflowOutcome =
   | { kind: "completed"; details: AgentReviewBatchDetails }
   | { kind: "invalid"; reason: string }
   | { kind: "stale"; reason: string };
-
 /** Prepare one session-scoped review plan without starting reviewer sessions. */
 export async function prepareAgentReviewPlan(
   input: PrepareAgentReviewWorkflowInput,
@@ -74,15 +70,27 @@ export async function prepareAgentReviewPlan(
     };
   }
 
-  const synthesis = await synthesizeReviewBrief({
-    model: input.model,
-    cwd: input.cwd,
-    snapshot,
-    serializedContext: input.serializedContext,
-    note: input.note,
-    signal: input.signal,
-    onProgress: input.onProgress,
-  });
+  let synthesis: BriefSynthesisRunResult;
+  try {
+    synthesis = await synthesizeReviewBrief({
+      model: input.model,
+      cwd: input.cwd,
+      snapshot,
+      serializedContext: input.serializedContext,
+      note: input.note,
+      signal: input.signal,
+      onProgress: input.onProgress,
+    });
+  } catch {
+    return {
+      kind: "synthesis-failed",
+      result: {
+        kind: "failed",
+        failureCode: "unexpected-runner-failure",
+        diagnostics: createUnobservedChildFailureDiagnostics(),
+      },
+    };
+  }
   if (synthesis.kind !== "success") {
     return { kind: "synthesis-failed", result: synthesis };
   }
@@ -195,13 +203,14 @@ async function runAssignment(
       onProgress: (progress) => input.onReviewerProgress?.(assignment.id, progress),
     });
     return { assignment, result: compactReviewResult(normalizeReviewResult(rawResult)) };
-  } catch (error) {
+  } catch {
     return {
       assignment,
       result: {
         kind: "failed",
-        reason: `Reviewer session failed unexpectedly: ${error instanceof Error ? error.message : String(error)}`,
+        failureCode: "unexpected-runner-failure",
         modelId: plan.model.canonicalId,
+        diagnostics: createUnobservedChildFailureDiagnostics(),
       },
     };
   }
@@ -212,21 +221,30 @@ function compactReviewResult(result: ReviewResult): AgentReviewerResult {
     case "success":
       return { kind: "success", output: result.output, modelId: result.modelId };
     case "failed":
+      return result.failureCode === "session-creation-failed"
+        ? {
+            kind: "failed",
+            failureCode: result.failureCode,
+            modelId: result.modelId,
+          }
+        : {
+            kind: "failed",
+            failureCode: result.failureCode,
+            modelId: result.modelId,
+            diagnostics: result.diagnostics,
+          };
+    case "canceled":
       return {
-        kind: "failed",
-        reason: result.reason,
+        kind: "canceled",
         modelId: result.modelId,
-        debug: result.debug,
+        diagnostics: result.diagnostics,
       };
-    case "canceled":
-      return { kind: "canceled", modelId: result.modelId, debug: result.debug };
     case "timeout":
       return {
         kind: "timeout",
         timeoutMs: result.timeoutMs,
-        partialOutput: result.partialOutput,
         modelId: result.modelId,
-        debug: result.debug,
+        diagnostics: result.diagnostics,
       };
   }
 }