Surface plugin load warnings as plugin ! and in /plugins

Standing plugin diagnostics were easy to miss as startup notices. Keep them as a prompt attention mark shared with mcp !\, attribute warnings per plugin, and show them in the /plugins surface. Also document the current Enter steer / Alt+Enter queue / Ctrl+C stop mid-run gestures.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -180,8 +180,8 @@ Unmatched shell auto-allows. Writes under the session state root (`~/.corbits/pr
 
 `ChatInputProps` carries `isProcessing?: boolean` and `onInterrupt?: (message: string) => void`. When `isProcessing` is true:
 
-- **Enter** calls `onInterrupt`. `App.handleInterrupt` calls `requestStop()` synchronously — which calls `sendAbortRef.current.abort()` — before `resolveAtMentions` yields, ensuring the abort signal reaches the in-flight HTTP request before any async work begins.
-- **Alt+Enter** calls `onSubmit` immediately, pushing the message onto `pendingQueueRef` for drain at the next `connector.reply`.
+- **Enter** soft-steers — enqueues kind `"steer"` and delivers at the next tool.boundary (does not interrupt).
+- **Alt+Enter** queues a follow-up (kind `"queue"`) delivered only when the run goes idle. **Ctrl+C** stops the run.
 
 `src/tui/stream-event-map.ts` maps reactor events onto the bridge's inbound events, and `src/tui/turn-state.ts` tracks the turn's status. `src/tui/turns-to-blocks.ts` hydrates a resumed session's stored turns into the same content blocks.
 
@@ -364,7 +364,7 @@ the directors guard on; the full set of reactor and stream event types is
 treat that as canonical rather than this section or any other doc's partial
 list.
 
-Mid-run queue/steer/interrupt state is a pure state machine in `src/tui/session-queue.ts` (interaction contract §3): `enqueue` (kind `"queue"`) and `enqueueSteer` (kind `"steer"`) share one pending pool, drained steer-first, then queue, both FIFO within their class. The prompt hint (`src/tui/stream.ts`, `PROMPT_HINT`) reads `Enter queue · Alt+Enter steer · Ctrl+C stop`.
+Mid-run queue/steer/interrupt state is a pure state machine in `src/tui/session-queue.ts` (interaction contract §3): `enqueue` (kind `"queue"`) and `enqueueSteer` (kind `"steer"`) share one pending pool, drained steer-first, then queue, both FIFO within their class. Mid-run gestures: Enter soft-steers (drain at tool.boundary), Alt+Enter queues a follow-up (drain on idle), Ctrl+C stops.
 
 ### Lifecycle Hooks
 

src/plugins/diagnostics.test.ts

@@ -8,6 +8,8 @@ import {
   emitPluginWarningSummary,
   formatPluginWarningsSummary,
   pluginWarningSink,
+  pluginWarningSubjectId,
+  warningsForPluginEntry,
 } from "./diagnostics.js";
 import { loadPluginEntry } from "./loader.js";
 
@@ -79,6 +81,40 @@ describe("formatPluginWarningsSummary", () => {
   });
 });
 
+describe("pluginWarningSubjectId / warningsForPluginEntry", () => {
+  test("extracts agent and tool-plugin subject ids", () => {
+    expect(
+      pluginWarningSubjectId(
+        'agent a: skill "style" referenced but not found in skill search path',
+      ),
+    ).toBe("a");
+    expect(
+      pluginWarningSubjectId('tool-plugin: failed to start "exa": boom'),
+    ).toBe("exa");
+    expect(pluginWarningSubjectId("other problem")).toBeUndefined();
+  });
+
+  test("attributes skill-miss warnings via plugin id or agent profile id", () => {
+    const warnings = [
+      'agent a: skill "style" referenced but not found in skill search path',
+      'agent b: skill "philosophy" referenced but not found in skill search path',
+      'tool-plugin: failed to start "exa": boom',
+    ];
+    expect(
+      warningsForPluginEntry(warnings, {
+        id: "pack",
+        agentProfiles: [{ id: "a" }],
+      }),
+    ).toEqual([
+      'agent a: skill "style" referenced but not found in skill search path',
+    ]);
+    expect(warningsForPluginEntry(warnings, { id: "exa" })).toEqual([
+      'tool-plugin: failed to start "exa": boom',
+    ]);
+    expect(warningsForPluginEntry(warnings, { id: "other" })).toEqual([]);
+  });
+});
+
 describe("emitPluginWarningSummary", () => {
   test("writes one summary line via custom sink", () => {
     const diag = createPluginLoadDiagnostics();

src/plugins/diagnostics.ts

@@ -105,3 +105,34 @@ export function emitPluginWarningSummary(
 export function emitPluginWarningLog(diag: PluginLoadDiagnostics): void {
   emitPluginWarningSummary(diag, (line) => pluginDiagnosticsLogger.warn(line));
 }
+
+/**
+ * Extract a plugin or agent id a warning names, when present. Skill-miss lines
+ * lead with `agent <id>:`; tool-plugin start failures quote the candidate id.
+ */
+export function pluginWarningSubjectId(warning: string): string | undefined {
+  const agent = /^agent ([^:]+):/.exec(warning)?.[1];
+  if (agent !== undefined) return agent;
+  const tool = /tool-plugin: failed to start "([^"]+)"/.exec(warning)?.[1];
+  if (tool !== undefined) return tool;
+  return undefined;
+}
+
+/**
+ * Warnings attributable to one plugin: subject id matches the plugin id or any
+ * of its agent profile ids.
+ */
+export function warningsForPluginEntry(
+  warnings: readonly string[],
+  plugin: {
+    readonly id: string;
+    readonly agentProfiles?: readonly { readonly id: string }[];
+  },
+): string[] {
+  const ids = new Set<string>([plugin.id]);
+  for (const profile of plugin.agentProfiles ?? []) ids.add(profile.id);
+  return warnings.filter((w) => {
+    const subject = pluginWarningSubjectId(w);
+    return subject !== undefined && ids.has(subject);
+  });
+}

src/tui/command-surfaces.test.ts

@@ -84,6 +84,21 @@ describe("surface labels", () => {
     ).toBe("exa — enabled")
   })
 
+  test("plugin label surfaces standing load warnings", () => {
+    expect(
+      pluginRowLabel({
+        id: "agents",
+        name: "agents",
+        enabled: true,
+        credentials: [],
+        credentialValues: {},
+        warnings: [
+          'agent a: skill "style" referenced but not found in skill search path',
+        ],
+      }),
+    ).toBe("agents — enabled — has warnings")
+  })
+
 })
 
 /** Build a settings deps bag over a mutable snapshot, recording every write. */
@@ -396,6 +411,37 @@ function pluginActionDeps(overrides?: Partial<PluginEntry>): {
 }
 
 describe("plugins surface admin actions", () => {
+  test("load warnings appear as a summary row under /plugins", async () => {
+    await withShell(async (shell) => {
+      const warnings = [
+        'agent a: skill "style" referenced but not found in skill search path',
+        'agent a: skill "philosophy" referenced but not found in skill search path',
+      ]
+      const { deps } = pluginActionDeps({
+        id: "agents",
+        name: "agents",
+        kind: "agent",
+        enabled: true,
+        credentials: [],
+        credentialValues: {},
+        warnings,
+        agentProfiles: [{ id: "a" }],
+      })
+      // pluginActionDeps builds PluginsSurfaceDeps without loadWarnings; splice it in.
+      const plugins = deps.plugins!
+      const withWarnings: CommandSurfaceDeps = {
+        ...deps,
+        plugins: {
+          ...plugins,
+          loadWarnings: () => warnings,
+        },
+      }
+      openCommandSurface(shell, "plugins", withWarnings)
+      expect(shell.overlayItems.some((l) => l.includes("2 skills missing"))).toBe(true)
+      expect(shell.overlayItems.some((l) => l.includes("has warnings"))).toBe(true)
+    })
+  })
+
   test("c opens credentials, typing a 40+ char key and s saves it in full", async () => {
     await withShell(async (shell) => {
       const { deps, calls } = pluginActionDeps()

src/tui/command-surfaces.ts

@@ -10,6 +10,7 @@
 
 import type { KeyEvent } from "@opentui/core"
 
+import { formatPluginWarningsSummary } from "../plugins/diagnostics.js"
 import { maskEcho, maskSecret } from "./provider-setup.js"
 import { residualIdFromSelection, type ResidualCatalogEntry } from "./residuals.js"
 import {
@@ -54,6 +55,11 @@ export type PluginEntry = {
   readonly agentProfiles?: readonly { readonly id: string; readonly description?: string }[]
   /** Absolute path an untrusted path-origin plugin was discovered at. */
   readonly originPath?: string
+  /**
+   * Standing load warnings attributable to this plugin (skill misses named by
+   * agent id, failed tool starts, …). Surfaced in the row hint and description.
+   */
+  readonly warnings?: readonly string[]
 }
 
 /** Result of a verify/addPath admin action, reported via `deps.notify`. */
@@ -98,6 +104,12 @@ export type PluginsSurfaceDeps = {
   readonly webProviders: () => readonly WebProviderChoice[]
   readonly currentWebProvider: () => string | undefined
   readonly setWebProvider: (id: string | undefined) => Promise<void> | void
+  /**
+   * Standing session-level load warnings (or the full set when attribution is
+   * weak). Shown as a summary row under `/plugins`; drives `plugin !` via the
+   * runner, not this surface.
+   */
+  readonly loadWarnings?: () => readonly string[]
 }
 
 /** Discovered lifecycle hook, live enablement, and enough to describe what it runs. */
@@ -176,6 +188,8 @@ export type CommandSurfaceKind =
 
 const CLOSE_ID = "__close__"
 const BACK_ID = "__back__"
+/** Synthetic `/plugins` row for standing load warnings (not a plugin id). */
+const PLUGIN_LOAD_WARNINGS_ID = "__plugin_load_warnings__"
 
 export function grantRowLabel(entry: GrantEntry): string {
   const suffix = entry.providerModel !== undefined ? ` (${entry.providerModel})` : ""
@@ -186,12 +200,18 @@ function pluginMissingCredential(entry: PluginEntry): boolean {
   return entry.credentials.some((f) => (entry.credentialValues[f.key] ?? "").length === 0)
 }
 
+function pluginHasWarnings(entry: PluginEntry): boolean {
+  return (entry.warnings?.length ?? 0) > 0
+}
+
 export function pluginRowLabel(entry: PluginEntry): string {
   const state = entry.needsTrust === true ? "untrusted" : entry.enabled ? "enabled" : "disabled"
   const blocker =
     entry.needsTrust !== true && !entry.enabled && pluginMissingCredential(entry)
       ? "needs api key"
-      : entry.kind
+      : pluginHasWarnings(entry)
+        ? "has warnings"
+        : entry.kind
   return blocker ? `${entry.name} — ${state} — ${blocker}` : `${entry.name} — ${state}`
 }
 
@@ -208,6 +228,11 @@ function pluginDescription(entry: PluginEntry): ItemDescription {
   if (!entry.enabled && pluginMissingCredential(entry)) {
     return { what, impact: "Needs an API key before it can be enabled — press Alt+C." }
   }
+  if (pluginHasWarnings(entry) && entry.warnings !== undefined) {
+    const summary =
+      formatPluginWarningsSummary(entry.warnings) ?? entry.warnings.join("; ")
+    return { what, impact: summary, tone: "consequence" }
+  }
   return { what }
 }
 
@@ -749,6 +774,14 @@ export function openPluginsSurface(shell: AppShell, deps: CommandSurfaceDeps): v
     id: e.id,
     label: pluginRowLabel(e),
   }))
+  const loadWarnings = plugins.loadWarnings?.() ?? []
+  const loadSummary = formatPluginWarningsSummary(loadWarnings)
+  if (loadSummary !== undefined) {
+    rows.unshift({
+      id: PLUGIN_LOAD_WARNINGS_ID,
+      label: loadSummary.replace(/^plugins:\s*/, ""),
+    })
+  }
   if (rows.length === 0) {
     rows.push({ id: CLOSE_ID, label: "No plugins discovered" })
   }
@@ -760,12 +793,19 @@ export function openPluginsSurface(shell: AppShell, deps: CommandSurfaceDeps): v
     frameId: "overlay-plugins",
     ...payload(rows),
     describe: (id) => {
+      if (id === PLUGIN_LOAD_WARNINGS_ID) {
+        return {
+          what: loadSummary ?? "Plugin load warnings.",
+          impact: "Standing diagnostics from plugin discovery and load. Fix the named skills or plugins, then relaunch.",
+          tone: "consequence",
+        }
+      }
       const target = byId.get(id)
       return target === undefined ? null : pluginDescription(target)
     },
     onAccept: (selection) => {
       const id = selectedId(selection, rows)
-      if (id === undefined || id === CLOSE_ID) return
+      if (id === undefined || id === CLOSE_ID || id === PLUGIN_LOAD_WARNINGS_ID) return
       const target = byId.get(id)
       if (target === undefined) return
       if (target.needsTrust === true) {
@@ -788,6 +828,7 @@ export function openPluginsSurface(shell: AppShell, deps: CommandSurfaceDeps): v
       // branch returns before that handler is reached (see shell.ts's
       // top-level onKey), so exactly one of the two can ever fire.
       if (key.ctrl || !(key.meta || key.option)) return false
+      if (id === PLUGIN_LOAD_WARNINGS_ID) return false
       const target = byId.get(id)
       if (target === undefined) return false
       const name = typeof key.name === "string" ? key.name.toLowerCase() : ""

src/tui/landing.test.ts

@@ -14,6 +14,8 @@ import {
   noticeText,
   paintChrome,
   setChromeZones,
+  setPluginNeedsAttention,
+  setPromptModelLabel,
   setPromptWorkspace,
   isLanding,
   paintLanding,
@@ -626,12 +628,10 @@ describe("landing screen", () => {
     }, SIZE)
   })
 
-  test("startup plugin diagnostics keep the mountain too", async () => {
-    // CL-5718: CL-5618 routed MCP and hook notices away from the transcript
-    // but left plugin diagnostics going through the runner's own system-row
-    // helper, so any missing skill wiped the whole hero on load. The flush is
-    // a named seam now precisely so no producer of a startup diagnostic gets
-    // to decide this again.
+  test("startup plugin diagnostics keep the mountain and ride plugin !", async () => {
+    // Plugin load warnings no longer go through surfaceSystemNotice — they
+    // drive the standing `plugin !` attention mark instead. The mountain must
+    // still stay up while that mark is painted.
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
@@ -644,14 +644,18 @@ describe("landing screen", () => {
         const before = markRows(h)
         expect(before.length).toBeGreaterThan(0)
 
-        const summary = "plugins: 3 skills missing: brand-identity, style, philosophy"
-        surfaceSystemNotice(shell, summary)
+        setPromptModelLabel(shell, { profile: "xai", model: "grok" })
+        setPluginNeedsAttention(shell, true)
         await settle(h)
 
         expect(isLanding(shell)).toBe(true)
         expect(markRows(h).length).toBe(before.length)
         expect(streamRowCount(shell)).toBe(0)
-        expect(noticeText(shell)).toContain("3 skills missing")
+        expect(noticeText(shell)).toBe("")
+        expect(shell.pluginNeedsAttention).toBe(true)
+        const frame = h.captureCharFrame()
+        expect(frame).toContain("plugin !")
+        expect(frame).not.toContain("skills missing")
       } finally {
         shell.dispose()
       }
@@ -661,7 +665,8 @@ describe("landing screen", () => {
   test("a flushed startup notice never carries a plumbing gutter label", async () => {
     // The transcript must never label a row "command": a system row's text
     // already says what it is, and the meta column is the operator's, not the
-    // wiring's.
+    // wiring's. (MCP notices still use the notice strip; plugin skill-miss
+    // summaries do not.)
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {
         terminal: { columns: 80, rows: 24 },
@@ -670,13 +675,16 @@ describe("landing screen", () => {
       })
       try {
         await settle(h)
-        surfaceSystemNotice(shell, "plugins: 1 skill missing: style")
+        surfaceSystemNotice(
+          shell,
+          "mcp github did not connect (ECONNREFUSED) — its tools are unavailable; /mcp for detail",
+        )
         appendStreamRow(shell, { role: "user", text: "first prompt" })
         await settle(h)
 
         expect(isLanding(shell)).toBe(false)
         const frame = h.captureCharFrame()
-        expect(frame).toContain("1 skill missing")
+        expect(frame).toContain("mcp github did not connect")
         expect(frame).not.toContain("command")
         expect(frame).not.toContain("overlay")
       } finally {

src/tui/plugin-diagnostics-sink.test.ts

@@ -248,6 +248,22 @@ describe("interactive plugin diagnostics never hit raw stderr", () => {
   });
 });
 
+describe("plugin warnings route to plugin ! / /plugins, not startup notices", () => {
+  test("runner does not push formatPluginWarningsSummary into startupPluginNotices", async () => {
+    // Product lock: discovery / tool-plugin / profile skill-miss summaries must
+    // never become fire-and-forget surfaceSystemNotice chatter. They drive
+    // standingPluginWarnings → setPluginNeedsAttention + /plugins instead.
+    const src = await Bun.file(new URL("./runner.ts", import.meta.url)).text();
+    expect(src).toContain("standingPluginWarnings");
+    expect(src).toContain("setPluginNeedsAttention");
+    expect(src).not.toMatch(
+      /startupPluginNotices\.push\(\s*(discoveryNotice|toolPluginNotice|profileNotice)/,
+    );
+    // Unverified provider-key notice is still allowed on the startup path.
+    expect(src).toMatch(/startupPluginNotices\.push\([\s\S]*couldn't confirm your/);
+  });
+});
+
 // The interactive paths above always hand `resolveToolPlugins` a diagnostics
 // collector. Headless/standalone callers (exec's tool-plugin resolution,
 // direct unit tests) may supply neither `diagnostics` nor `onWarning` —