pi-delegation-policy 0.3.2 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.4.0 - 2026-08-27
+
+### Added
+
+- Added a compact effective-policy preview, selector guidance, and available public model metadata to the `/delegate` panel.
+
+### Changed
+
+- Require exact `provider/model` references for delegation guidance instead of relying on a launcher default.
+- Clarified task-fit role selection, preference tie-breaks, dynamic advisory thinking, and current panel and status diagnostics.
+- Raised the Pi peer requirement and explicitly checked baseline to `0.84.3`.
+
 ## 0.3.2 - 2026-08-26
 
 ### Documentation

package/README.md

@@ -2,7 +2,7 @@
 
 A local Pi extension that helps the main agent decide **when delegation is worth it** and which exact models to use for the Small, Medium, Large, and optional UI Design roles. It provides guidance; it is not a subagent runner.
 
-> **Status:** Version **0.3.2** is the latest published package. The package accepts Pi `>=0.84.1`; Pi `0.84.1` is the explicitly validated baseline (newer versions are not claimed as tested).
+> **Status:** Version **0.4.0** is the latest published package. The package requires Pi `>=0.84.3`; Pi `0.84.3` is the explicitly checked baseline (newer versions are not claimed as tested).
 >
 > **Docs:** [Read the documentation site](https://yivas.github.io/pi-delegation-policy/).
 
@@ -27,7 +27,7 @@ pi install npm:pi-delegation-policy
 1. Open `/delegate` (or press `Alt+G` in Pi's TUI).
 2. Configure exact, authenticated Small, Medium, and Large provider/model references. UI Design is optional.
 3. Select `normal` or `aggressive`, then choose **Apply changes**.
-4. Run `/delegate status` and inspect the footer for `D:NORM` or `D:AGG`. `D:ERR` means an active required role is invalid; no policy is injected.
+4. Run `/delegate status` and inspect the exact role references and their sources. `D:ERR` means an active required role is invalid; no policy is injected.
 5. The applied state affects the **next** agent run. An agent already running is not rewritten.
 
 See the [end-to-end getting-started guide](https://yivas.github.io/pi-delegation-policy/getting-started/) and [configuration reference](https://yivas.github.io/pi-delegation-policy/configuration/) for details.
@@ -43,11 +43,11 @@ See the [end-to-end getting-started guide](https://yivas.github.io/pi-delegation
 /delegate reset                   Reset this branch to off and other fields to global defaults
 ```
 
-The editor is a bounded, keyboard-first panel. It shows model ID first and `[provider]` last, fuzzy-searches provider, model ID, and display name, and shows at most 10 model rows. Inheritance actions stay pinned while searching. Changes are drafts until **Apply changes**; saving effective configuration as defaults updates the global file without applying the draft, and closing a modified draft requires explicit discard.
+The editor is a bounded, keyboard-first panel. It shows model ID first and `[provider]` last, fuzzy-searches provider, model ID, and display name, and shows at most 10 model rows. It also shows a compact effective-policy preview, field explanations, and public model metadata when Pi supplies it. Changes are drafts until **Apply changes**; saving effective configuration as defaults updates the global file without applying the draft, and closing a modified draft requires explicit discard.
 
 ## Configuration and safety
 
-Global defaults are stored at `~/.pi/agent/delegation-policy.json` (schema version 2). The file stores optional intensity, preference, exact role references, and an optional UI Design reference; it never stores thinking. A valid active mode requires exact, available, in-scope, authenticated Small, Medium, and Large references. Invalid active configuration fails closed as `D:ERR` with no policy injection; `off` is always `D:OFF`.
+Global defaults are stored at `~/.pi/agent/delegation-policy.json` (schema version 2). The file stores optional intensity, preference, exact role references, and an optional UI Design reference; it never stores thinking. A valid active mode requires exact, available, in-scope, authenticated Small, Medium, and Large references. Before every delegated launch, the policy requires the selected role's exact combined reference as `model: "provider/model"`; it does not rely on an ambient launcher default. Invalid active configuration fails closed as `D:ERR` with no policy injection; `off` is always `D:OFF`.
 
 The extension stores only policy settings and provider/model identifiers in local defaults and session entries. Review local configuration before sharing diagnostics, and remove credentials, prompts, personal paths, session files, and unredacted logs from reports. See the [limits and privacy reference](https://yivas.github.io/pi-delegation-policy/limits-and-privacy/) and [security policy](https://github.com/Yivas/pi-delegation-policy/blob/main/SECURITY.md).
 

package/SECURITY.md

@@ -14,4 +14,4 @@ Include the affected version or commit, operating system, Pi version, reproducti
 
 ## Supported versions
 
-Only the latest published version is supported. Version 0.3.2 is the current supported release.
+Only the latest published version is supported. Version 0.4.0 is the current supported release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-delegation-policy",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "private": false,
   "description": "A Pi extension for configurable delegation intensity and exact subagent role model references.",
   "type": "module",
@@ -36,12 +36,14 @@
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.84.1"
+    "@earendil-works/pi-ai": ">=0.84.3",
+    "@earendil-works/pi-coding-agent": ">=0.84.3",
+    "@earendil-works/pi-tui": ">=0.84.3"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.84.1",
-    "@earendil-works/pi-coding-agent": "0.84.1",
-    "@earendil-works/pi-tui": "0.84.1",
+    "@earendil-works/pi-ai": "0.84.3",
+    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@earendil-works/pi-tui": "0.84.3",
     "@eslint/js": "^9.39.5",
     "@types/node": "^22.0.0",
     "ajv": "^8.20.0",

package/src/delegate-panel.ts

@@ -12,6 +12,7 @@ import {
   type TUI,
 } from "@earendil-works/pi-tui";
 import { resolveDelegateState } from "./config.ts";
+import { buildPolicyPreview } from "./prompt.ts";
 import {
   INTENSITIES,
   PREFERENCES,
@@ -52,6 +53,7 @@ export interface DelegatePanelOptions {
   session: SessionDelegateState;
   candidates: Model<Api>[];
   diagnostics: string[];
+  hasRuntimeError: boolean;
   onApply: (draft: SessionDelegateState) => Promise<boolean>;
   onSaveDefaults: (draft: SessionDelegateState) => Promise<GlobalDefaults | undefined>;
   onDone: (result: DelegatePanelResult) => void;
@@ -74,6 +76,15 @@ const FIELD_LABELS: Record<DelegateField, string> = {
   uiDesign: "UI Design",
 };
 
+const FIELD_DESCRIPTIONS: Record<DelegateField, string> = {
+  intensity: "When delegation is worth considering.",
+  preference: "Tie-break only; task fit decides the role first.",
+  small: "Bounded, planned, and verifiable execution.",
+  medium: "Planning, ambiguity, synthesis, and coordination.",
+  large: "Exceptional unblocker for persistent hard problems.",
+  uiDesign: "Visual direction and review only; never implementation.",
+};
+
 const ACTION_LABELS: Record<PanelAction, string> = {
   apply: "Apply changes",
   "save-defaults": "Save effective configuration as defaults",
@@ -132,6 +143,17 @@ function sortedModels(models: readonly Model<Api>[]): Model<Api>[] {
   });
 }
 
+function modelMetadata(model: Model<Api> | undefined): string[] {
+  if (!model) return [];
+  const details: string[] = [];
+  if (model.name !== undefined) details.push(`Model Name: ${model.name}`);
+  if (model.api !== undefined) details.push(`API: ${model.api}`);
+  if (model.reasoning !== undefined) details.push(`Reasoning: ${model.reasoning ? "yes" : "no"}`);
+  if (model.contextWindow !== undefined) details.push(`Context: ${model.contextWindow}`);
+  if (model.maxTokens !== undefined) details.push(`Max output: ${model.maxTokens}`);
+  return details;
+}
+
 function visibleBlockRange(blocks: string[][], selected: number, budget: number): [number, number] {
   if (blocks.length === 0) return [0, 0];
   const safeSelected = Math.max(0, Math.min(selected, blocks.length - 1));
@@ -169,6 +191,7 @@ export class DelegatePanel implements Component, Focusable {
   private readonly theme: Theme;
   private readonly candidates: Model<Api>[];
   private readonly diagnostics: string[];
+  private readonly hasRuntimeError: boolean;
   private readonly onApply: DelegatePanelOptions["onApply"];
   private readonly onSaveDefaults: DelegatePanelOptions["onSaveDefaults"];
   private readonly onDone: DelegatePanelOptions["onDone"];
@@ -191,6 +214,7 @@ export class DelegatePanel implements Component, Focusable {
     this.draft = cloneSession(options.session);
     this.candidates = sortedModels(options.candidates);
     this.diagnostics = [...options.diagnostics];
+    this.hasRuntimeError = options.hasRuntimeError;
     this.onApply = options.onApply;
     this.onSaveDefaults = options.onSaveDefaults;
     this.onDone = options.onDone;
@@ -332,9 +356,7 @@ export class DelegatePanel implements Component, Focusable {
     ];
     const notice =
       this.message ??
-      (this.diagnostics.length > 0
-        ? { kind: "error" as const, text: "Warning: global defaults are invalid." }
-        : undefined);
+      (this.diagnostics[0] ? { kind: "error" as const, text: this.diagnostics[0] } : undefined);
     if (notice) {
       lines.push(
         truncateToWidth(
@@ -365,6 +387,8 @@ export class DelegatePanel implements Component, Focusable {
 
   private renderSettings(width: number, budget: number): string[] {
     const effective = resolveDelegateState(this.global, this.draft);
+    const preview = this.renderPolicyPreview(width, budget, effective);
+    const settingsBudget = Math.max(1, budget - preview.length);
     const blocks = SETTINGS_ITEMS.map((item, index) => {
       const selected = index === this.settingsIndex;
       if (FIELD_IDS.includes(item as DelegateField)) {
@@ -381,6 +405,7 @@ export class DelegatePanel implements Component, Focusable {
         if (width < 48) {
           return [
             selectedLine(this.theme, FIELD_LABELS[field], width, selected),
+            ...wrapTextWithAnsi(`  ${FIELD_DESCRIPTIONS[field]}`, width),
             ...wrapTextWithAnsi(`  ${value}`, width),
             ...details.flatMap((line) =>
               wrapTextWithAnsi(this.theme.fg("dim", `  ${line}`), width),
@@ -391,7 +416,10 @@ export class DelegatePanel implements Component, Focusable {
         const first = `${FIELD_LABELS[field].padEnd(labelWidth)}${value}`;
         return [
           selectedLine(this.theme, first, width, selected),
-          ...wrapTextWithAnsi(this.theme.fg("dim", `  ${details.join(" · ")}`), width),
+          ...wrapTextWithAnsi(
+            this.theme.fg("dim", `  ${FIELD_DESCRIPTIONS[field]} · ${details.join(" · ")}`),
+            width,
+          ),
         ];
       }
       const action = item as PanelAction;
@@ -401,7 +429,25 @@ export class DelegatePanel implements Component, Focusable {
       return [disabled ? this.theme.fg("dim", line) : line];
     });
 
-    return this.renderBlockViewport(blocks, this.settingsIndex, width, budget);
+    return [
+      ...preview,
+      ...this.renderBlockViewport(blocks, this.settingsIndex, width, settingsBudget),
+    ];
+  }
+
+  private renderPolicyPreview(
+    width: number,
+    budget: number,
+    effective: ReturnType<typeof resolveDelegateState>,
+  ): string[] {
+    const lines =
+      effective.intensity !== "off" && this.hasRuntimeError
+        ? ["D:ERR · policy unavailable; fix the reported role diagnostics"]
+        : buildPolicyPreview(effective);
+    const maximum = width >= 60 && budget >= 8 ? 4 : 2;
+    return ["Effective policy preview", ...lines]
+      .slice(0, maximum)
+      .map((line) => truncateToWidth(this.theme.fg("dim", line), width, ""));
   }
 
   private sourceDetails(field: DelegateField): string[] {
@@ -439,12 +485,30 @@ export class DelegatePanel implements Component, Focusable {
     mode: Extract<PanelMode, { kind: "enum" }>,
   ): string[] {
     const values = mode.field === "intensity" ? INTENSITIES : PREFERENCES;
+    const descriptions =
+      mode.field === "intensity"
+        ? {
+            off: "No policy is injected.",
+            normal: "Delegate when the expected benefit clearly outweighs overhead.",
+            aggressive: "Delegate suitable substantial work by default.",
+          }
+        : {
+            efficient: "Tie-break comparable fits toward Small.",
+            standard: "No extra Small or Medium bias.",
+            intensive: "Tie-break comparable fits toward Medium.",
+          };
+    const globalValue =
+      this.global[mode.field] ?? (mode.field === "intensity" ? "off" : "standard");
     const options = [
-      `${USE_GLOBAL_DEFAULT} (${this.global[mode.field] ?? (mode.field === "intensity" ? "off" : "standard")})`,
-      ...values,
+      {
+        label: `${USE_GLOBAL_DEFAULT} (${globalValue})`,
+        description: "Use the current global value.",
+      },
+      ...values.map((value) => ({ label: value, description: descriptions[value] })),
     ];
     const blocks = options.map((option, index) => [
-      selectedLine(this.theme, option, width, index === mode.selected),
+      selectedLine(this.theme, option.label, width, index === mode.selected),
+      ...wrapTextWithAnsi(this.theme.fg("dim", `  ${option.description}`), width),
     ]);
     return this.renderBlockViewport(blocks, mode.selected, width, budget);
   }
@@ -471,15 +535,20 @@ export class DelegatePanel implements Component, Focusable {
     );
     const dividerRows = budget > pinnedLines.length + 3 ? 1 : 0;
     const selectedChoice = choices[mode.selected];
-    const selectedName =
-      selectedChoice?.kind === "model" && selectedChoice.description
-        ? [`  Model Name: ${selectedChoice.description}`]
+    const metadata =
+      selectedChoice?.kind === "model"
+        ? modelMetadata(
+            this.candidates.find(
+              (model) =>
+                modelKey({ provider: model.provider, model: model.id }) === selectedChoice.key,
+            ),
+          )
         : [];
-    const detailRows = selectedName.length > 0 && budget > pinnedLines.length + 6 ? 2 : 0;
-    const availableListRows = Math.max(
-      0,
-      budget - 2 - pinnedLines.length - dividerRows - detailRows,
-    );
+    const fixedRows = 2 + pinnedLines.length + dividerRows;
+    const availableDetailRows = Math.max(0, budget - fixedRows - 1);
+    const details = metadata.slice(0, availableDetailRows);
+    const detailRows = details.length > 0 ? details.length + 1 : 0;
+    const availableListRows = Math.max(0, budget - fixedRows - detailRows);
     const listBudget = Math.min(11, availableListRows);
     const modelBlocks = models.map((choice, index) => {
       const combinedIndex = index + pinnedCount;
@@ -512,7 +581,7 @@ export class DelegatePanel implements Component, Focusable {
       ...pinnedLines,
       ...(dividerRows ? [this.theme.fg("borderMuted", "─".repeat(width))] : []),
       ...modelLines,
-      ...(detailRows ? ["", ...selectedName.map((line) => this.theme.fg("muted", line))] : []),
+      ...(detailRows ? ["", ...details.map((line) => this.theme.fg("muted", `  ${line}`))] : []),
     ].slice(0, budget);
   }
 

package/src/index.ts

@@ -6,6 +6,7 @@ import type {
 import type { AutocompleteItem } from "@earendil-works/pi-tui";
 import { buildDelegationPolicy } from "./prompt.ts";
 import {
+  formatModelRef,
   hasRuntimeError,
   loadRuntime,
   sessionEntry,
@@ -54,19 +55,15 @@ async function openEditor(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void
   updateStatus(ctx, await refresh(ctx));
 }
 
-function configuredLabel(value: unknown): string {
-  return value ? "configured" : "unset";
-}
-
 export function statusText(state: RuntimeState): string {
   const { effective } = state;
   const details = [
     `${statusLabel(state)} intensity=${effective.intensity} (${effective.source.intensity})`,
     `preference=${effective.preference} (${effective.source.preference})`,
-    `small=${configuredLabel(effective.small)} (${effective.source.small})`,
-    `medium=${configuredLabel(effective.medium)} (${effective.source.medium})`,
-    `large=${configuredLabel(effective.large)} (${effective.source.large})`,
-    `ui-design=${configuredLabel(effective.uiDesign)} (${effective.source.uiDesign})`,
+    `small=${formatModelRef(effective.small)} (${effective.source.small})`,
+    `medium=${formatModelRef(effective.medium)} (${effective.source.medium})`,
+    `large=${formatModelRef(effective.large)} (${effective.source.large})`,
+    `ui-design=${formatModelRef(effective.uiDesign)} (${effective.source.uiDesign})`,
   ];
 
   if (effective.intensity !== "off" && state.runtimeErrors.length > 0) {

package/src/prompt.ts

@@ -1,35 +1,42 @@
 import { hasRuntimeError, type RuntimeState } from "./runtime.ts";
-import type { ModelRef, Preference } from "./types.ts";
+import type { EffectiveDelegateState, ModelRef, Preference } from "./types.ts";
 
 const NORMAL_POLICY =
   "Delegate substantial, separable work only when the expected benefit clearly outweighs briefing, supervision, review, and integration cost. Count parallelism as a benefit only when valuable work can advance now or elapsed time matters. A merely possible fresh perspective is not enough by itself. Keep borderline work with the main agent.";
 const AGGRESSIVE_POLICY =
   "Default to delegating substantial, separable, independently checkable work with a clear objective and acceptance criteria. Delegate when the benefit is plausible even if not proven, including a useful independent perspective. Keep work with the main agent when it is poorly bounded, tightly coupled, dominated by integration or final accountability, or has clearly prohibitive delegation overhead.";
 
-const ROLE_SELECTION_POLICY = `Choose the role and thinking together from the combination of:
-- task demand: execute, search, plan, decide, or unblock;
-- difficulty: clarity, ambiguity, dependencies, risk, and competing hypotheses;
-- quantity: files, modules, systems, sources, and context volume.
-No single factor decides the role.
+const ROLE_SELECTION_POLICY = `Choose the role by task fit before considering model preference:
+- demand: execute, search, plan, decide, coordinate, or unblock;
+- difficulty: clarity, ambiguity, dependencies, competing hypotheses, and risk;
+- quantity: files, modules, systems, sources, and context volume;
+- error and review cost: what can go wrong, how costly it is to detect, and what evidence is needed.
+No single factor decides the role. Select the smallest role that can satisfy the acceptance criteria and evidence requirements.
 
-Use Small habitually for bounded, planned, and verifiable work: concrete searches, scoped exploration, defined implementation, focused documentation, tests, reviews, mechanical changes, evident bugs, and bounded UI implementation whose design and stack are decided. Difficult but well-defined execution can remain Small with higher thinking.
+Use Small for bounded, planned, and verifiable execution: concrete searches, scoped exploration, defined implementation, focused documentation, tests, reviews, mechanical changes, evident bugs, and bounded UI implementation whose design and stack are decided. Difficult but well-defined execution can remain Small with higher thinking.
 
-Use Medium directly when the combined demands materially require defining a plan, reducing meaningful ambiguity, broad synthesis, tracing several modules, comparing sources or options, coordinating substantial context, or making difficult decisions. These are evidence, not automatic triggers. Small does not need to fail first.
+Use Medium directly when the combined task fit materially requires planning, reducing meaningful ambiguity, broad synthesis, tracing several modules, comparing sources or options, coordinating substantial context, or making difficult decisions. Small does not need to fail first.
 
 Use Large only to unblock genuinely stuck work: persistent failures, severe framework conflicts, contradictory hypotheses, or reliable prior evidence that ordinary roles have not produced a trustworthy answer. Do not require ceremonial failed attempts. Large remains exceptional.
 
-Large quantities of repetitive, independent work favor multiple Small delegations; volume alone does not justify Medium or Large. Agent type does not determine the model role. A clearly better task fit overrides preference; preference only shifts credible Small/Medium choices.
+Large quantities of repetitive, independent work favor multiple Small delegations; volume alone does not justify Medium or Large. Agent type does not determine the model role. Apply preference only when Small and Medium are comparably credible fits.
 
 In every intensity, keep global strategy, coordination, integration, final review, and work whose essential context is too costly or risky to transfer with the main agent.`;
 
 function preferenceGuidance(preference: Preference): string {
   if (preference === "efficient") {
-    return "Favor Small more strongly than standard. When Small can safely satisfy the acceptance criteria, choose it unless Medium provides a material advantage.";
+    return "Use efficient only as a Small tie-break when Small and Medium are comparably credible. Do not choose Small when Medium is a materially better task fit.";
   }
   if (preference === "intensive") {
-    return "When Small and Medium are both credible, normally prefer Medium. Keep Small for work that is clearly narrow, routine, mechanical, or an especially clear Small fit.";
+    return "Use intensive only as a Medium tie-break when Small and Medium are comparably credible. Do not choose Medium when Small is the clearly better task fit.";
   }
-  return "Choose Small on a genuine Small/Medium tie; otherwise follow the role-selection policy above.";
+  return "Standard adds no Small or Medium bias; follow task fit.";
+}
+
+function preferencePreview(preference: Preference): string {
+  if (preference === "efficient") return "efficient breaks comparable fits toward Small";
+  if (preference === "intensive") return "intensive breaks comparable fits toward Medium";
+  return "standard has no extra bias";
 }
 
 function promptString(value: string): string {
@@ -43,6 +50,25 @@ function formatReference(reference: ModelRef): string {
   return `provider=${promptString(reference.provider)} model=${promptString(reference.model)}`;
 }
 
+function formatLaunchModel(reference: ModelRef): string {
+  return promptString(`${reference.provider}/${reference.model}`);
+}
+
+export function buildPolicyPreview(effective: EffectiveDelegateState): string[] {
+  if (effective.intensity === "off") return ["off · no policy injected"];
+
+  const { small, medium, large } = effective;
+  if (!small) return ["active · Small not configured · no policy can be injected"];
+  if (!medium) return ["active · Medium not configured · no policy can be injected"];
+  if (!large) return ["active · Large not configured · no policy can be injected"];
+
+  return [
+    `${effective.intensity} · task fit first · ${preferencePreview(effective.preference)}`,
+    `Small ${formatLaunchModel(small)} · Medium ${formatLaunchModel(medium)} · Large ${formatLaunchModel(large)}`,
+    "Every launch must include the selected exact model; thinking stays dynamic.",
+  ];
+}
+
 export function buildDelegationPolicy(state: RuntimeState): string | undefined {
   if (state.effective.intensity === "off" || hasRuntimeError(state)) return undefined;
 
@@ -51,7 +77,7 @@ export function buildDelegationPolicy(state: RuntimeState): string | undefined {
 
   const intensityPolicy = effective.intensity === "normal" ? NORMAL_POLICY : AGGRESSIVE_POLICY;
   const uiDesign = effective.uiDesign
-    ? `\n- UI Design: ${formatReference(effective.uiDesign)}. Use this role only for visual design direction, exploration, or review. Never use it to implement an interface, write code, or run tests.`
+    ? `\n- UI Design: ${formatReference(effective.uiDesign)}; launch with model: ${formatLaunchModel(effective.uiDesign)}. Use this role only for visual design direction, exploration, or review. Never use it to implement an interface, write code, or run tests.`
     : "";
 
   return `<delegation_policy>
@@ -62,12 +88,12 @@ ${ROLE_SELECTION_POLICY}
 
 Model preference: ${effective.preference}. ${preferenceGuidance(effective.preference)}
 
-Use the exact provider and model for the selected role. The references below use JSON string syntax; interpret escaped characters as JSON before use. Do not invent a fallback model or role. Choose thinking dynamically for each delegation from task demand, difficulty, quantity, and the selected model's capabilities. Do not treat thinking as persisted configuration.
+Before every delegated launch, name the selected role, take its exact combined provider/model reference below, and include it in the call as model: "provider/model" using the JSON-escaped value shown for that role. Do not omit model, inherit an ambient launcher default, substitute another model, or invent a fallback model or role. Choose thinking dynamically for each delegation from task demand, difficulty, quantity, risk, review cost, and the selected model's capabilities. Thinking is advisory and is not persisted configuration.
 
 Roles:
-- Small: ${formatReference(effective.small)}
-- Medium: ${formatReference(effective.medium)}
-- Large: ${formatReference(effective.large)}${uiDesign}
+- Small: ${formatReference(effective.small)}; launch with model: ${formatLaunchModel(effective.small)}
+- Medium: ${formatReference(effective.medium)}; launch with model: ${formatLaunchModel(effective.medium)}
+- Large: ${formatReference(effective.large)}; launch with model: ${formatLaunchModel(effective.large)}${uiDesign}
 
 This is guidance for the main agent. It does not create, execute, route, supervise, or enforce delegated work.
 </delegation_policy>`;

package/src/ui.ts

@@ -6,7 +6,7 @@ import {
   writeConfig,
 } from "./config.ts";
 import { DelegatePanel, type DelegatePanelResult } from "./delegate-panel.ts";
-import { loadRuntime, modelCandidates, sessionEntry } from "./runtime.ts";
+import { hasRuntimeError, loadRuntime, modelCandidates, sessionEntry } from "./runtime.ts";
 
 export async function openDelegateEditor(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void> {
   if (!ctx.hasUI) return;
@@ -29,7 +29,8 @@ export async function openDelegateEditor(ctx: ExtensionContext, pi: ExtensionAPI
         global: state.global,
         session: state.session,
         candidates,
-        diagnostics: state.diagnostics.map((diagnostic) => diagnostic.message),
+        diagnostics: state.runtimeErrors,
+        hasRuntimeError: hasRuntimeError(state),
         onApply: async (draft) => {
           const session = structuredClone(draft);
           sessionEntry(pi, { ...state, session });