pi-better-subagents 0.10.0 → 0.11.0

package/README.md

@@ -38,7 +38,10 @@ Linux confinement requires a usable `bubblewrap` backend and Pi SDK 0.82.1 or ne
 `config.json` sets `delegationMode` to `manual`, `adaptive` (default), or
 `coordinator`. `/subagents` displays the active mode, and
 `/subagents mode manual|adaptive|coordinator` changes it for the current
-session without changing config. Manual delegates only on explicit user or workflow request, even with a
+session without changing config. `/subagents save` writes the current mode as
+the next session's default. The navigator's `main` row opens the same control:
+`m` cycles the session mode, `ctrl+s` saves that default, and `x`
+does not stop it. Manual delegates only on explicit user or workflow request, even with a
 plan. Adaptive delegates substantial independent work when useful. Coordinator
 uses `agents_catalog` to discover current role descriptions and delegates every
 nontrivial role-owned task, while the foreground coordinates, integrates, and

package/agent-commands.ts

@@ -123,7 +123,7 @@ interface ParsedArgs {
 
 export function registerAgentCommands(pi: Pick<ExtensionAPI, "registerCommand">, deps: AgentCommandDeps = {}): void {
     pi.registerCommand("agents", {
-        description: "List, inspect, create, reload, or import Codex agent definitions",
+        description: "[list|show|create|reload|import-codex] — List, inspect, create, reload, or import agent definitions",
         getArgumentCompletions(prefix: string) {
             const commands = ["list", "inspect", "show", "create", "reload", "import-codex", "help"];
             const first = prefix.trim().split(/\s+/)[0] ?? "";

package/config.ts

@@ -8,12 +8,12 @@
  * `defaultTools` absent → the built-in SAFE_DEFAULT_TOOLS.
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { SELF_SPEC } from "./extensions.ts";
-import type { DelegationMode } from "./delegation.ts";
+import { isDelegationMode, type DelegationMode } from "./delegation.ts";
 import type { TimingSettings } from "./timing.ts";
 
 export interface SubagentConfig extends TimingSettings {
@@ -80,24 +80,49 @@ export const SAFE_DEFAULT_TOOLS = "read, bash, edit, write, web_search, web_fetc
 export const SAFE_CLEAN_TOOLS = "read, bash";
 
 let cached: SubagentConfig | undefined;
+let configPathForTests: string | undefined;
 
 /** Test seam. Pass undefined to reload config.json on the next loadConfig call. */
 export function setConfigForTests(next: SubagentConfig | undefined): void {
     cached = next;
 }
 
+/** Test seam. Save and load use this file instead of the package config.json. */
+export function setConfigPathForTests(path: string | undefined): void {
+    configPathForTests = path;
+    cached = undefined;
+}
+
+export function configPath(): string {
+    return configPathForTests ?? join(dirname(fileURLToPath(import.meta.url)), "config.json");
+}
+
 /** Load config.json from the extension directory. Missing/invalid → {}. */
 export function loadConfig(): SubagentConfig {
     if (cached) return cached;
     try {
-        const dir = dirname(fileURLToPath(import.meta.url));
-        cached = JSON.parse(readFileSync(join(dir, "config.json"), "utf-8")) as SubagentConfig;
+        cached = JSON.parse(readFileSync(configPath(), "utf-8")) as SubagentConfig;
     } catch {
         cached = {};
     }
     return cached;
 }
 
+/** Write delegationMode into config.json, preserving every other key. */
+export function writeDelegationMode(mode: DelegationMode, path = configPath()): void {
+    if (!isDelegationMode(mode)) throw new Error(`Invalid delegation mode: ${String(mode)}`);
+    let current: SubagentConfig = {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) current = parsed as SubagentConfig;
+    } catch { /* missing file starts as an empty config */ }
+    current.delegationMode = mode;
+    const pending = `${path}.${process.pid}.tmp`;
+    writeFileSync(pending, `${JSON.stringify(current, null, 2)}\n`);
+    renameSync(pending, path);
+    if (path === configPath()) cached = current;
+}
+
 /** Normalize a comma/space tool list to pi's bare comma form: "a, b" → "a,b". */
 export function normalizeTools(list: string): string {
     return list.split(",").map((t) => t.trim()).filter(Boolean).join(",");

package/docs/usage.md

@@ -18,9 +18,12 @@ Set `delegationMode` in this package's `config.json` to `manual`, `adaptive`, or
 `coordinator` (default `adaptive`). This controls foreground delegation guidance,
 not child permissions or catalog definitions. `/subagents` reports the active
 mode; `/subagents mode manual|adaptive|coordinator` overrides it for the current
-session without editing config. Other arguments show usage. `/reload` retains
-this override; new sessions use config, while resuming a session restores that
-session's override.
+session without editing config. `/subagents save` writes the current mode into
+`config.json` after confirmation when a UI is available, and clears the session
+override so the next session starts there. On the navigator `main` sheet, `m`
+cycles the session mode and `ctrl+s` saves that default.
+Other arguments show usage. `/reload` retains a session override; new sessions
+use config, while resuming a session restores that session's override.
 
 - **Manual:** no proactive delegation, including in plan mode. A user request or
   explicit workflow requirement may still delegate.
@@ -380,6 +383,7 @@ top.
   foreground model).
 - `delegationMode` — foreground policy (`manual`, `adaptive`, or `coordinator`;
   default `adaptive`). `/subagents mode ...` changes only the current session.
+  `/subagents save` writes that mode as the config default.
 - `maxConcurrent` — how many subagents may run at once (**default 4**). A spawn
   past the cap is rejected until a running one finishes.
 
@@ -517,9 +521,11 @@ is unchanged in every mode.
 - While the main-window list is focused, the title hint changes to
   `Enter to view · x to stop`; the selected row is marked with `›`. Press
   `↓` from the bottom row to return to the input line.
-- The Subagents lane pins an informational `main` row above child runs. It
-  shows the foreground model, effort, active tool, context tokens, and active
-  elapsed time. It is not selectable and can never become an `x` stop target.
+- The Subagents lane pins a `main` row above child runs. It shows the
+  foreground model, effort, active tool, context tokens, elapsed time, and
+  delegation mode. Enter opens its detail sheet. `m` cycles the session mode.
+  `ctrl+s` saves that mode as the config default. `x` still stops
+  a child run; it never stops main.
 - `↑` moves to the previous row when multiple running rows are shown. `↓`
   moves toward the input line, returning to normal input from the bottom row.
 - `Enter` opens the selected run's live detail view. `x` stops the selected
@@ -637,6 +643,10 @@ health model:
   orphaned, lost, and degraded running runs; #65 orphaned/lost result bodies kept.
 - **Passive live widget** — healthy/quiet unchanged; degraded (and orphaned) may
   show a short suffix. Still `setWidget` only — never focusable.
+- **Navigator** — lifecycle status and operational health facts remain visible;
+  child tool/model incident summaries and history are omitted from rows and detail
+  chrome. Tool labels show just their name (for example, `bash`). The original
+  transcript, including error results, and transcript-read diagnostics remain available.
 - **`callback:false`** suppresses coordinator follow-up only; human `ui.notify` and
   TUI/passive visibility remain.
 

package/health-surface.mjs

@@ -162,6 +162,7 @@ export function formatNavigatorHealthFacts(obs) {
     if (!obs || !isActionableHealth(obs)) return [];
     const facts = [];
     for (const f of surfaceableCompactFacts(obs)) {
+        if (obs.model?.state === "error" && f === obs.model.listWarning) continue;
         if (f && f !== obs.status && !facts.includes(f)) facts.push(f);
     }
     if (obs.activity === "stale" && !facts.some((f) => /\bstale\b/i.test(f))) {

package/index.ts

@@ -35,7 +35,7 @@ import {
 import { spawnDetached, type SpawnResult } from "./spawn.ts";
 import { parseRun, readRunTranscript, resetParseRunCursor, type Usage } from "./parse.ts";
 import { finalizeRun as finalizeRunCore } from "./finalization.ts";
-import { loadConfig, normalizeTools, resolveExtensionPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS, DEFAULT_MAX_CONCURRENT } from "./config.ts";
+import { loadConfig, writeDelegationMode, normalizeTools, resolveExtensionPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS, DEFAULT_MAX_CONCURRENT } from "./config.ts";
 import { STEER_FILE_ENV, readSteerReceipt } from "./child-steer.ts";
 import {
     decideTiming,
@@ -117,7 +117,7 @@ import {
 import { buildHealthCallbackDelivery } from "./completion.ts";
 import { cancelCallbackBatch, getCallbackBatcher } from "./shared-callback-batcher.ts";
 import { completionCallbackFields, failureAttentionFields, healthCallbackFields } from "./callback-fields.ts";
-import { collectRunFailures, failurePath, failureView, markFailureAttentionDelivered, pendingFailureAttention, prependFailureSummary } from "./failures.ts";
+import { collectRunFailures, failurePath, markFailureAttentionDelivered, pendingFailureAttention } from "./failures.ts";
 import { failureAttentionHandled, observeFailures } from "./shared-failure-observations.ts";
 import {
     text,
@@ -165,6 +165,7 @@ const SUBAGENT_MODE_ACTIONS: readonly AutocompleteItem[] = [
     { value: "mode manual", label: "mode manual", description: "Delegate only when explicitly requested" },
     { value: "mode adaptive", label: "mode adaptive", description: "Delegate substantial independent work" },
     { value: "mode coordinator", label: "mode coordinator", description: "Delegate role-owned work by default" },
+    { value: "save", label: "save", description: "Write the current mode as the next session's default" },
 ];
 
 export function subagentsArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
@@ -1149,9 +1150,6 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
         if (row.model) bits.push(row.effort ? `${row.model} ${row.effort}` : row.model);
         if (row.tool) bits.push(row.tool);
         if (row.spend) bits.push(row.spend);
-        const failure = failureView(row.id, metaById.get(row.id)?.cwd ?? "", row.status !== "running" && row.status !== "orphaned");
-        // Only a failure that needs action replaces the row's columns; history stays in the detail view.
-        const firstFailure = failure.actionable ? failure.text.split("\n")[0] || "" : "";
         return {
             providerId: "subagents",
             id: row.id,
@@ -1164,9 +1162,8 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
             statusTone: statusTone(row.status),
             kind: "subagent",
             elapsed: row.elapsed,
-            primary: firstFailure || bits.join(" · ") || "subagent run",
-            secondary: firstFailure ? bits.join(" · ") : undefined,
-            facts: [firstFailure, ...row.healthFacts].filter(Boolean).slice(0, 2),
+            primary: bits.join(" · ") || "subagent run",
+            facts: row.healthFacts,
             sortStartedAt: metaById.get(row.id)?.startedAt ?? now,
             expiresAt: (() => {
                 const meta = metaById.get(row.id);
@@ -1179,6 +1176,16 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
     });
 }
 
+const DELEGATION_MODES = ["manual", "adaptive", "coordinator"] as const;
+const DELEGATION_BLURB: Record<DelegationMode, string> = {
+    manual: "only when you or a workflow asks",
+    adaptive: "substantial independent work",
+    coordinator: "every role-owned task",
+};
+let readDelegation = (): { mode: DelegationMode; source: "session" | "config" } => ({ mode: "adaptive", source: "config" });
+let cycleDelegation = (): void => {};
+let saveDelegationDefault: (mode: DelegationMode) => { ok: boolean; message: string } = () => ({ ok: false, message: "Saving the delegation default is unavailable." });
+
 function mainAgentWorkRow(now: number): BackgroundWorkRow {
     let running = mainAgentStartedAt !== undefined;
     try { running ||= uiCtx?.isIdle() === false; } catch { /* use event state */ }
@@ -1188,10 +1195,12 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
     let contextTokens: number | null | undefined;
     try { contextTokens = uiCtx?.getContextUsage()?.tokens; } catch { contextTokens = undefined; }
     const tokens = typeof contextTokens === "number" ? `${fmtTokens(contextTokens)} tok` : undefined;
+    const delegation = readDelegation();
     const bits = [
         effort ? `${model} ${effort}` : model,
-        tool ? `tool ${tool}` : undefined,
+        tool,
         tokens,
+        delegation.source === "session" ? `${delegation.mode} · session` : delegation.mode,
     ].filter((bit): bit is string => Boolean(bit));
     return {
         providerId: "subagents",
@@ -1210,15 +1219,43 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
     };
 }
 
+function mainAgentWorkDetail(now: number): BackgroundWorkDetail {
+    const row = mainAgentWorkRow(now);
+    const delegation = readDelegation();
+    return {
+        providerId: "subagents",
+        id: "main",
+        title: "main",
+        status: row.status,
+        statusTone: row.statusTone,
+        subtitle: row.primary,
+        metadata: [
+            { label: "kind", value: "main agent" },
+            { label: "model", value: row.effort ? `${row.model} · effort ${row.effort}` : (row.model || "-") },
+            { label: "tool", value: row.tool || "-" },
+            { label: "context", value: row.tokens || "-" },
+            { label: "elapsed", value: row.elapsed },
+            { label: "mode", value: `${delegation.mode} · ${delegation.source}` },
+        ],
+        evidence: {
+            label: "delegation",
+            text: [
+                `${delegation.mode}: ${DELEGATION_BLURB[delegation.mode]}.`,
+                "m cycles this session. ctrl+s saves that mode as the next session's default.",
+                "x does not stop the main agent.",
+            ].filter(Boolean).join(" "),
+        },
+        footerActions: ["m mode", "ctrl+s save"],
+    };
+}
+
 function subagentWorkDetail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null {
+    if (id === "main") return mainAgentWorkDetail(now);
     const detail = navigatorDetail(id, now);
     if (!detail) return null;
     void options;
     const transcript = readRunTranscript(id);
-    const view = failureView(id, readMeta(id)?.cwd ?? "", detail.status !== "running" && detail.status !== "orphaned");
-    const failure = view.text;
     const metadata = [
-        ...(failure ? [{ label: "failure", value: failure.split("\n")[0]! }] : []),
         { label: "provider", value: "Subagents" },
         { label: "id", value: detail.id },
         ...(detail.role ? [{ label: "role", value: String(detail.role) }] : []),
@@ -1235,11 +1272,11 @@ function subagentWorkDetail(id: string, now: number, options?: { logTailLines?:
         title: detail.name || detail.id,
         status: detail.status,
         statusTone: statusTone(detail.status),
-        subtitle: (view.actionable && failure.split("\n")[0]) || (detail.currentTool ? `current tool ${detail.currentTool}` : undefined),
+        subtitle: detail.currentTool || undefined,
         metadata,
-        evidence: { label: "transcript", text: prependFailureSummary(detail.output || "(no transcript yet)", failure) },
+        evidence: { label: "transcript", text: detail.output || "(no transcript yet)" },
         transcript: transcript.entries,
-        transcriptDiagnostic: failure ? prependFailureSummary(transcript.diagnostic ?? "", failure) : transcript.diagnostic,
+        transcriptDiagnostic: transcript.diagnostic,
         footerActions: [detail.status === "running" || detail.status === "orphaned" ? "x stop" : "x dismiss"],
     };
 }
@@ -1307,6 +1344,16 @@ function ensureSubagentProvider(): void {
         parentRow: (now) => mainAgentWorkRow(now),
         listRows: (now) => subagentWorkRows(now),
         detail: (id, now, options) => subagentWorkDetail(id, now, options),
+        handleDetailInput: (id, data) => {
+            if (id !== "main") return false;
+            if (data === "m") {
+                cycleDelegation();
+                return true;
+            }
+            if (data !== "ctrl+s") return false;
+            saveDelegationDefault(readDelegation().mode);
+            return true;
+        },
         armCloseLabel: (row) => row.status === "running" || row.status === "orphaned" ? "x again to stop" : "x again to dismiss",
         close: (id) => {
             const outcome = navigatorCloseRun(id) as { action: string; id: string; status?: string };
@@ -1450,6 +1497,26 @@ function catalogRoleSchema(purpose: string) {
 export default function (pi: ExtensionAPI) {
     let delegationOverride: DelegationMode | undefined;
     const activeDelegationMode = (): DelegationMode => delegationOverride ?? normalizeDelegationMode(loadConfig().delegationMode);
+    readDelegation = () => ({
+        mode: activeDelegationMode(),
+        source: delegationOverride ? "session" : "config",
+    });
+    cycleDelegation = () => {
+        const current = activeDelegationMode();
+        const next = DELEGATION_MODES[(DELEGATION_MODES.indexOf(current) + 1) % DELEGATION_MODES.length]!;
+        delegationOverride = next;
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: next });
+    };
+    saveDelegationDefault = (mode) => {
+        try {
+            writeDelegationMode(mode);
+        } catch (error) {
+            return { ok: false, message: `Could not save the delegation default: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        delegationOverride = undefined;
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: null });
+        return { ok: true, message: `Delegation default saved: ${mode}.` };
+    };
     const restoreDelegationMode = (ctx: ExtensionContext): void => {
         delegationOverride = undefined;
         const branch = ctx.sessionManager?.getBranch?.();
@@ -1457,7 +1524,9 @@ export default function (pi: ExtensionAPI) {
         for (const entry of branch) {
             if (entry.type !== "custom" || entry.customType !== "pi-better-subagents-delegation") continue;
             const data = entry.data as { version?: unknown; mode?: unknown } | null;
-            if (data?.version === 1 && isDelegationMode(data.mode)) delegationOverride = data.mode;
+            if (data?.version !== 1) continue;
+            if (data.mode === null) delegationOverride = undefined;
+            else if (isDelegationMode(data.mode)) delegationOverride = data.mode;
         }
     };
     const unsubscribeDelegationRequest = pi.events?.on?.(DELEGATION_MODE_REQUEST, (data: unknown) => {
@@ -2166,7 +2235,7 @@ export default function (pi: ExtensionAPI) {
     if (typeof pi.registerCommand === "function") {
         agentOperations.registerCommands(pi);
         pi.registerCommand("subagents", {
-            description: "Show or change the current-session delegation mode",
+            description: "[mode manual|adaptive|coordinator|save] — Session mode, or save it as the next session's default",
             getArgumentCompletions: subagentsArgumentCompletions,
             async handler(args, ctx) {
                 const tokens = args.trim().split(/\s+/).filter(Boolean);
@@ -2175,12 +2244,20 @@ export default function (pi: ExtensionAPI) {
                     return;
                 }
                 const requested = tokens[1];
-                if (tokens.length === 2 && tokens[0] === "mode" && isDelegationMode(requested)) {
+                if (tokens.length === 1 && tokens[0] === "save") {
+                    const mode = activeDelegationMode();
+                    if (ctx.hasUI && !(await ctx.ui.confirm("Save delegation default?", `Future sessions will start in ${mode}.`))) {
+                        ctx.ui.notify("Delegation default unchanged.", "info");
+                        return;
+                    }
+                    const saved = saveDelegationDefault(mode);
+                    ctx.ui.notify(saved.message, saved.ok ? "info" : "warning");
+                } else if (tokens.length === 2 && tokens[0] === "mode" && isDelegationMode(requested)) {
                     delegationOverride = requested;
                     pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: delegationOverride });
                     ctx.ui.notify(`Delegation mode: ${delegationOverride} (current session).`, "info");
                 } else {
-                    ctx.ui.notify("Usage: /subagents [mode manual|adaptive|coordinator]", "warning");
+                    ctx.ui.notify("Usage: /subagents [mode manual|adaptive|coordinator|save]", "warning");
                 }
             },
         });

package/navigator.mjs

@@ -543,7 +543,6 @@ export function buildDetailLines(detail, opts = {}) {
             const bits = [];
             if (c.last.reason) bits.push(c.last.reason);
             if (c.last.aborted) bits.push("aborted");
-            if (c.last.errorMessage) bits.push(c.last.errorMessage);
             if (bits.length) lines.push(`   last ${bits.join(" · ")}`);
         }
     } else {
@@ -566,28 +565,17 @@ export function buildDetailLines(detail, opts = {}) {
         lines.push("   idle");
     }
 
-    // Model call / error, separate from tool state.
+    // Model activity only; incident summaries stay in result tools and logs.
     lines.push(sectionRule("model", width));
     if (h?.model) {
         const m = h.model;
-        lines.push(`   state ${m.state}`);
-        if (m.listWarning) lines.push(`   warning ${m.listWarning}`);
+        if (m.state !== "error") lines.push(`   state ${m.state}`);
+        if (m.state !== "error" && m.listWarning) lines.push(`   warning ${m.listWarning}`);
         if (m.retry) {
             const a = m.retry.attempt != null ? String(m.retry.attempt) : "?";
             const max = m.retry.maxAttempts != null ? String(m.retry.maxAttempts) : "?";
             lines.push(`   retry ${a}/${max}`);
         }
-        if (m.lastError) {
-            const age = m.lastError.at != null ? ` · ${fmtDetailTs(m.lastError.at, now)}` : "";
-            lines.push(`   last error ${m.lastError.message}${age}`);
-        }
-        if (Array.isArray(m.errorHistory) && m.errorHistory.length > 0) {
-            const recent = m.errorHistory.slice(-3);
-            for (const e of recent) {
-                const age = e.at != null ? ` · ${fmtDetailTs(e.at, now)}` : "";
-                lines.push(`   history ${e.message}${age}`);
-            }
-        }
         if (m.longModelCall) {
             const age = m.longModelCall.ageMs != null ? ` · ${fmtDetailAge(m.longModelCall.ageMs)}` : "";
             lines.push(`   long call${age}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/shared-navigator.ts

@@ -66,6 +66,8 @@ export type BackgroundWorkProvider = {
   detail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null;
   armCloseLabel(row: BackgroundWorkRow): string;
   close(id: string): BackgroundWorkCloseOutcome;
+  /** Return true when this detail handled the key. The navigator refreshes the sheet. */
+  handleDetailInput?(id: string, data: string): boolean;
   onVisibleChanged?(notify: () => void): () => void;
 };
 
@@ -559,7 +561,7 @@ function rowSummary(row: InternalRow): string {
     const parts: string[] = [];
     if (row.statusTone !== "running" && row.kind !== "main agent") parts.push(singleLine(row.status));
     if (row.model) parts.push(row.effort ? `${singleLine(row.model)} ${singleLine(row.effort)}` : singleLine(row.model));
-    if (row.tool) parts.push(`tool ${singleLine(row.tool)}`);
+    if (row.tool) parts.push(singleLine(row.tool));
     if (row.tokens) parts.push(singleLine(row.tokens));
     else if (row.primary) parts.push(singleLine(row.primary));
     if (parts.length) return parts.join(" · ");
@@ -703,12 +705,7 @@ function handleMainListInput(data: string, deps: HostDeps): boolean {
     return true;
   }
   if (deps.matchKey(data, "enter")) {
-    const selected = selectedMainListRow();
-    if (selected?.parentRow) {
-      unfocusMainList();
-      dismissOverlay();
-    }
-    else openNavigator();
+    openNavigator();
     return true;
   }
   if (data === "x" || data === "X" || deps.matchKey(data, "x") || deps.matchKey(data, "X")) {
@@ -851,7 +848,8 @@ function createOverlayComponent(
   let logTailRows: number = DEFAULT_LOG_TAIL_ROWS;
   const expandedSections = new Set<string>();
   let detailId: string = initialDetailId;
-  let detail: BackgroundWorkDetail | null = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? null;
+  const initialRow = initialRows.find((row) => row.navigatorId === detailId);
+  let detail: BackgroundWorkDetail | null = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? (initialRow ? fallbackDetail(initialRow) : null);
   applyDefaultExpandedSections(detail, expandedSections);
   {
     const idx = overlayState.rows.findIndex((row) => row.navigatorId === detailId);
@@ -891,8 +889,7 @@ function createOverlayComponent(
   }
 
   function activateSelectedRow(): void {
-    if (selectedRow()?.parentRow) close();
-    else openDetail();
+    openDetail();
   }
 
   function clearCloseArm(): void {
@@ -922,10 +919,6 @@ function createOverlayComponent(
   function openDetail(): void {
     const row = selectedRow();
     if (!row) return;
-    if (row.parentRow) {
-      close();
-      return;
-    }
     clearCloseArm();
     detailId = row.navigatorId;
     expandedSections.clear();
@@ -1073,6 +1066,15 @@ function createOverlayComponent(
           requestRender();
         }
       }
+      else if (data === "m" || data === "M" || data === "\x13" || deps.matchKey(data, "ctrl+s")) {
+        const row = selectedRow();
+        const provider = row ? state().providers.get(row.providerId) : undefined;
+        const key = data === "m" || data === "M" ? "m" : "ctrl+s";
+        if (!row || !provider?.handleDetailInput?.(row.id, key)) return;
+        detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
+        refreshMainListWidget();
+        requestRender();
+      }
       else if (data === "l" || data === "L") {
         logTailRows = cycleLogTailRows(logTailRows);
         if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
@@ -1091,8 +1093,7 @@ function createOverlayComponent(
       if (idx < 0) return;
       overlayState.selected = idx;
       state().mainListSelectedId = navigatorId;
-      if (overlayState.rows[idx]!.parentRow) close();
-      else openDetail();
+      openDetail();
     },
     /** Close the overlay (done), e.g. when the navigator is disposed. */
     dismiss() { close(); },
@@ -1150,7 +1151,11 @@ function buildTranscriptDetailLines(
     ...detail.metadata.map((item) => `   ${item.label.padEnd(8, " ").slice(0, 8)} ${item.value}`),
   ];
   const transcriptHeader = ["", dim(section(`transcript · latest ${tailRows} rows`, width), fg)];
-  if (detail.transcriptDiagnostic) transcriptHeader.push(`   ${dim(detail.transcriptDiagnostic, fg)}`);
+  if (detail.transcriptDiagnostic) {
+    for (const diagnosticRow of detail.transcriptDiagnostic.split(/\r\n|\r|\n/)) {
+      transcriptHeader.push(`   ${dim(diagnosticRow, fg)}`);
+    }
+  }
   // Metadata always renders; the transcript tail takes only the rows left over (the tail size is a cap, not a guarantee).
   lines.push(...optionalMetadata);
   if (options.maxRows !== undefined) {