Keep the landing hero when a startup diagnostic arrives

Anything the runner says before the first turn lands while the landing still
owns the screen, and a transcript row there reaches clearLandingMark and takes
the whole composition with it — the mark, the guidance beside it, and the
centred prompt box.

The previous fix routed the MCP and hook producers away from the transcript one
at a time and the plugin producer kept the defect. Routing the runner's own
notice helper through the shell's notice path instead fixes every producer at
once, including the ones nobody has written yet, and gives the constraint a
single owner rather than a rule each call site has to remember.

The gutter label goes with it. A system row's text already says what it is, so
stamping it "command" only leaked wiring into a column the operator reads.

Author: TheGreatAxios

src/tui-opentui/landing.test.ts

@@ -19,6 +19,7 @@ import {
   streamRowCount,
   surfaceStartupNotice,
 } from "./shell"
+import { flushStartupNotices } from "./startup-notices"
 import { makeOperatorQuestion, openOperatorOverlay } from "./overlays"
 import {
   LANDING_HINTS,
@@ -541,4 +542,63 @@ 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.
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        wireKeys: false,
+        run: "idle",
+      })
+      try {
+        await settle(h)
+        expect(isLanding(shell)).toBe(true)
+        const before = markRows(h)
+        expect(before.length).toBeGreaterThan(0)
+
+        const summary = "plugins: 3 skills missing: brand-identity, style, philosophy"
+        flushStartupNotices(shell, [summary])
+        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")
+      } finally {
+        shell.dispose()
+      }
+    }, SIZE)
+  })
+
+  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.
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        wireKeys: false,
+        run: "idle",
+      })
+      try {
+        await settle(h)
+        flushStartupNotices(shell, ["plugins: 1 skill missing: style"])
+        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).not.toContain("command")
+        expect(frame).not.toContain("overlay")
+      } finally {
+        shell.dispose()
+      }
+    }, SIZE)
+  })
 })

src/tui-opentui/runner-host.ts

@@ -31,12 +31,12 @@ import type { ItemDescription } from "./shell.js"
 import { mountProductHost, type ProductHost } from "./product-host.js"
 import { onTurnBoundary } from "../agent/reactor-events.js"
 import {
-  appendStreamRow,
   clearShellExitHandler,
   setPromptCostContext,
   setPromptModelLabel,
   setPromptWorkspace,
   setShellExitHandler,
+  surfaceStartupNotice,
 } from "./shell.js"
 import type { CostSummary } from "../cost/cost-summary.js"
 import { watchGitBranch, type FetchBranch } from "./workspace-watch.js"
@@ -326,8 +326,7 @@ export async function mountRunnerHost(deps: RunnerHostDeps): Promise<RunnerHost>
   const surfaceDeps: CommandSurfaceDeps = {
     ...(deps.surfaces ?? {}),
     ...(host.openModels !== undefined ? { openModels: host.openModels } : {}),
-    notify: (text) =>
-      appendStreamRow(host.shell, { role: "system", text, meta: "command" }),
+    notify: (text) => surfaceStartupNotice(host.shell, text),
   }
 
   const refreshModels = (

src/tui-opentui/startup-notices.ts

@@ -0,0 +1,28 @@
+/**
+ * Startup diagnostics on their way to the operator.
+ *
+ * These are produced before the first turn, which is exactly when the landing
+ * hero owns the screen. Delivered as transcript rows they reach
+ * `clearLandingMark` and take the whole composition with them — the mark, the
+ * guidance beside it, and the centred prompt box — not merely the mountain.
+ *
+ * This is a named seam rather than a loop at each call site because the
+ * constraint is "a startup diagnostic is never a transcript row", and that
+ * belongs in one place. CL-5618 fixed the MCP and hook producers individually
+ * and the plugin producer kept the defect; a second producer getting it wrong
+ * is what a per-call-site rule buys you.
+ */
+
+import { surfaceStartupNotice, type AppShell } from "./shell.js"
+
+/**
+ * Hand a batch of load-time diagnostics to the shell. Each rides the notice
+ * strip while the landing is up and becomes a durable transcript row once a
+ * real session row ends it; after that they are ordinary system rows.
+ */
+export function flushStartupNotices(
+  shell: AppShell,
+  notices: readonly string[],
+): void {
+  for (const notice of notices) surfaceStartupNotice(shell, notice)
+}

src/tui/runner.ts

@@ -144,13 +144,14 @@ import { consumeStream } from "../session/stream-consumer.js";
 import { createCycleTextRecorder } from "../session/stream-journal.js";
 import { mountRunnerHost } from "../tui-opentui/runner-host.js";
 import {
-  appendStreamRow,
   attachClipboardImage,
   setMentionSuggestionSource,
   setPromptRecognitionSource,
   setSentMessageHistory,
   setShellRunState,
+  surfaceStartupNotice,
 } from "../tui-opentui/shell.js";
+import { flushStartupNotices } from "../tui-opentui/startup-notices.js";
 import {
   classifyAgentSendFailure,
   shouldSettleUiAfterSendFailure,
@@ -434,8 +435,8 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   // Fire-and-forget startup diagnostics (this + tool-plugin resolution below)
   // have no result channel back to an operator action, unlike verify/add-path/
   // trust-grant. A log-only summary is invisible — nobody watches
-  // ~/.corbits/logs/corbits.log — so these are also queued as transcript rows
-  // once the shell mounts (see `systemRow` calls after `mountRunnerHost`).
+  // ~/.corbits/logs/corbits.log — so these are queued and handed to
+  // `flushStartupNotices` once the shell mounts.
   const startupPluginNotices: string[] = [];
   const discoveryNotice = formatPluginWarningsSummary(pluginLoadDiag.warnings);
   if (discoveryNotice !== undefined) startupPluginNotices.push(discoveryNotice);
@@ -1840,8 +1841,13 @@ export async function runTUI(initialConfig: Config): Promise<number> {
     },
   };
 
-  const systemRow = (text: string): void => {
-    appendStreamRow(host.shell, { role: "system", text, meta: "command" });
+  // Routed through the shell's notice path rather than straight into the
+  // transcript: anything the runner says before the first turn arrives while
+  // the landing hero still owns the screen, and a transcript row there wipes
+  // the whole composition. Once a session row has ended the landing this is an
+  // ordinary system row, so there is no second behaviour to reason about.
+  const systemNotice = (text: string): void => {
+    surfaceStartupNotice(host.shell, text);
   };
 
   /** Settle the shell after a rejected send so the run does not look live. */
@@ -1854,7 +1860,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
     );
     if (!shouldSettleUiAfterSendFailure(kind)) return;
     recordRunError(err);
-    systemRow(err instanceof Error ? err.message : String(err));
+    systemNotice(err instanceof Error ? err.message : String(err));
     setShellRunState(host.shell, "idle");
   };
 
@@ -1899,29 +1905,29 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   const applyCommandResult = (result: CommandResult): void => {
     switch (result.type) {
       case "message":
-        systemRow(result.text);
+        systemNotice(result.text);
         return;
       case "send":
         void agentProxy.send(result.text).catch(handleSendFailure);
         return;
       case "workflow":
-        systemRow(workflowController.start(result.name));
+        systemNotice(workflowController.start(result.name));
         return;
       case "noop":
         return;
       case "overlay":
         if (!host.openSurface(result.overlay)) {
-          systemRow(`No surface for /${result.overlay}.`);
+          systemNotice(`No surface for /${result.overlay}.`);
         }
         return;
       case "modal":
         // /model is the only modal reachable from a command; provider login is
         // reached from the picker itself.
         if (result.modal === "agent" && host.openSurface("models")) return;
-        systemRow(`${result.modal} is not available in this renderer yet`);
+        systemNotice(`${result.modal} is not available in this renderer yet`);
         return;
       case "view":
-        systemRow(`${result.view} is not available in this renderer yet`);
+        systemNotice(`${result.view} is not available in this renderer yet`);
         return;
       case "paste-image":
         void attachClipboardImage(host.shell);
@@ -1958,7 +1964,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
   const dispatchCommand = (name: string, args: string): void => {
     const command = getCommand(name);
     if (command === undefined) {
-      systemRow(`Unknown command: ${name}`);
+      systemNotice(`Unknown command: ${name}`);
       return;
     }
     applyCommandResult(command.handler(args, commandContext));
@@ -2015,7 +2021,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
             existing: config.settings ?? null,
           });
         } catch (err) {
-          systemRow(
+          systemNotice(
             `Connecting ${providerName} failed: ${err instanceof Error ? err.message : String(err)}`,
           );
           return;
@@ -2040,7 +2046,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
           providers,
           computeUnconnectedProviders(providers),
         );
-        systemRow(`Connected ${result.providerName ?? providerName}. Open /model to pick a model.`);
+        systemNotice(`Connected ${result.providerName ?? providerName}. Open /model to pick a model.`);
       })().catch((err: unknown) => {
         tuiLogger.debug("provider connect failed: {error}", {
           error: err instanceof Error ? err.message : String(err),
@@ -2370,9 +2376,9 @@ export async function runTUI(initialConfig: Config): Promise<number> {
       });
     });
 
-  // Surface fire-and-forget startup plugin diagnostics now that the shell has
-  // a transcript to write into (queued above, before `host` existed).
-  for (const notice of startupPluginNotices) systemRow(notice);
+  // Surface fire-and-forget startup plugin diagnostics now that there is a
+  // shell to say them to (queued above, before `host` existed).
+  flushStartupNotices(host.shell, startupPluginNotices);
 
   await host.waitUntilExit();
   // Quitting mid-stream is an abnormal end for the in-flight cycle: nothing