pi-better-subagents 0.1.17 → 0.1.19

package/finalization.ts

@@ -62,6 +62,13 @@ export function finalizeRun(
     if (outcome.incomplete) meta.failureReason = "incomplete-stream";
     meta.exitCode = code;
     meta.endedAt = Date.now();
+    const callback = meta.callback !== false;
+    if (callback
+        && meta.completionCallbackPendingAt === undefined
+        && meta.completionCallbackSentAt === undefined
+        && meta.completionCallbackSuppressedAt === undefined) {
+        meta.completionCallbackPendingAt = meta.endedAt;
+    }
     writeMeta(meta);
 
     const label = meta.name ? `${meta.name} (${id})` : id;
@@ -84,10 +91,9 @@ export function finalizeRun(
         /* ignore */
     }
 
-    const callback = meta.callback !== false; // default: trigger completion
-    // buildCompletionDelivery is the single place sendMessage content/options are
-    // assembled. resultText is accepted here so callers/tests can pass it without
-    // breaking, but it is NEVER put into content — the result lives in subagent_result.
+    // buildCompletionDelivery remains the compatibility formatter for callers and
+    // direct finalizer tests. Production callback:true delivery is coalesced by the
+    // host wrapper; callback:false never invokes a model-message hook.
     const delivery = buildCompletionDelivery({
         id,
         label,
@@ -98,10 +104,12 @@ export function finalizeRun(
         lifecycleClassification: outcome.classification,
         resultText: r.finalText || r.lastActivity || "",
     });
-    hooks.sendMessage?.(
-        { customType: "subagent-complete", content: delivery.content, display: true },
-        delivery.options,
-    );
+    if (callback) {
+        hooks.sendMessage?.(
+            { customType: "subagent-complete", content: delivery.content, display: true },
+            delivery.options,
+        );
+    }
 
     return {
         applied: true,

package/index.ts

@@ -14,6 +14,8 @@
 import { execSync } from "node:child_process";
 import { writeFileSync, mkdirSync, statSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import * as PiCodingAgent from "@earendil-works/pi-coding-agent";
+import * as PiTui from "@earendil-works/pi-tui";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { matchesKey, Key, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "@earendil-works/pi-ai";
@@ -30,7 +32,7 @@ import {
     type BackgroundWorkRow,
 } from "./shared-navigator.ts";
 import { spawnDetached, type SpawnResult } from "./spawn.ts";
-import { parseRun, resetParseRunCursor, tailLog, type Usage } from "./parse.ts";
+import { parseRun, readRunTranscript, resetParseRunCursor, type Usage } from "./parse.ts";
 import { finalizeRun as finalizeRunCore } from "./finalization.ts";
 import { loadConfig, normalizeTools, resolveExtensionPath, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS, DEFAULT_MAX_CONCURRENT } from "./config.ts";
 import { resolveExtensions, extensionArgs } from "./extensions.ts";
@@ -84,6 +86,7 @@ import {
     getSharedCapacityGate,
 } from "./capacity.mjs";
 import { buildHealthCallbackDelivery } from "./completion.ts";
+import { cancelCallbackBatch, getCallbackBatcher } from "./shared-callback-batcher.ts";
 import {
     text,
     subagentListTool,
@@ -237,12 +240,58 @@ function stopCurrentSessionSubagents(ctx: ExtensionContext): void {
 
 function markCompletionCallbackSuppressed(id: string, reason: string, now: number = Date.now()): void {
     const meta = readMeta(id);
-    if (!meta || meta.completionCallbackSuppressedAt !== undefined) return;
+    if (!meta || meta.completionCallbackSentAt !== undefined || meta.completionCallbackSuppressedAt !== undefined) return;
     meta.completionCallbackSuppressedAt = now;
     meta.completionCallbackSuppressedReason = reason;
     writeMeta(meta);
 }
 
+function markCompletionCallbackSent(id: string, now: number): void {
+    const meta = readMeta(id);
+    if (!meta || meta.completionCallbackSentAt !== undefined || meta.completionCallbackSuppressedAt !== undefined) return;
+    meta.completionCallbackSentAt = now;
+    writeMeta(meta);
+}
+
+/** Queue one durable ordinary terminal event on the host-shared batch. */
+function enqueueCompletionCallback(pi: ExtensionAPI, id: string): void {
+    const meta = readMeta(id);
+    if (!meta
+        || meta.callback === false
+        || meta.completionCallbackPendingAt === undefined
+        || meta.completionCallbackSentAt !== undefined
+        || meta.completionCallbackSuppressedAt !== undefined) return;
+    const label = meta.name ? `${meta.name} (${id})` : id;
+    getCallbackBatcher(pi).enqueue({
+        source: "subagent",
+        id,
+        label,
+        status: meta.status,
+        detailTool: "subagent_result",
+        callback: true,
+        isDelivered: () => {
+            const current = readMeta(id);
+            return current?.completionCallbackSentAt !== undefined
+                || current?.completionCallbackSuppressedAt !== undefined;
+        },
+        getSuppressionReason: () => {
+            const current = readMeta(id);
+            if (!current) return "subagent metadata is unavailable";
+            return callbackSuppressionReason(current);
+        },
+        onDelivered: (at) => markCompletionCallbackSent(id, at),
+        onSuppressed: (reason, at) => markCompletionCallbackSuppressed(id, reason, at),
+    });
+}
+
+/** Recover only records explicitly marked pending; legacy terminal runs never replay. */
+function recoverCompletionCallbacks(pi: ExtensionAPI): void {
+    for (const meta of listMetas()) {
+        if (!ownedByThisParent(meta)) continue;
+        enqueueCompletionCallback(pi, meta.id);
+    }
+}
+
 function markHealthCallbackSuppressed(meta: RunMeta, status: "orphaned" | "lost", reason: string, now: number): void {
     if (status === "orphaned") {
         if (meta.orphanedCallbackSuppressedAt !== undefined) return;
@@ -409,12 +458,6 @@ function deliverHealthCallback(pi: ExtensionAPI | undefined, meta: RunMeta, stat
     if (!pi) return;
     if (isHealthCallbackHandled(meta, status)) return;
 
-    const suppressionReason = callbackSuppressionReason(meta);
-    if (suppressionReason) {
-        markHealthCallbackSuppressed(meta, status, suppressionReason, now);
-        return;
-    }
-
     const callback = meta.callback !== false;
     const label = meta.name ? `${meta.name} (${meta.id})` : meta.id;
     const delivery = buildHealthCallbackDelivery({ id: meta.id, label, status, callback });
@@ -426,20 +469,35 @@ function deliverHealthCallback(pi: ExtensionAPI | undefined, meta: RunMeta, stat
         writeMeta(meta);
         return;
     }
-    try {
-        pi.sendMessage(
-            { customType: "subagent-health", content: delivery.content, display: true },
-            delivery.options,
-        );
-    } catch {
-        // Handoff failed — leave marker unset so a later tick/reload can retry.
-        // Never let a delivery failure break the health ticker.
-        return;
-    }
-    // Marker = successful handoff (sendMessage returned), not mere attempt.
-    if (status === "orphaned") meta.orphanedCallbackSentAt = now;
-    else meta.lostCallbackSentAt = now;
-    writeMeta(meta);
+    void getCallbackBatcher(pi).deliverUrgent({
+        source: "subagent",
+        id: meta.id,
+        label,
+        status,
+        customType: "subagent-health",
+        content: delivery.content,
+        isDelivered: () => {
+            const current = readMeta(meta.id);
+            return current ? isHealthCallbackHandled(current, status) : true;
+        },
+        getSuppressionReason: () => {
+            const current = readMeta(meta.id);
+            if (!current) return "subagent metadata is unavailable";
+            return callbackSuppressionReason(current);
+        },
+        onDelivered: (at) => {
+            const current = readMeta(meta.id);
+            if (!current || isHealthCallbackHandled(current, status)) return;
+            if (status === "orphaned") current.orphanedCallbackSentAt = at;
+            else current.lostCallbackSentAt = at;
+            writeMeta(current);
+        },
+        onSuppressed: (reason, at) => {
+            const current = readMeta(meta.id);
+            if (!current || isHealthCallbackHandled(current, status)) return;
+            markHealthCallbackSuppressed(current, status, reason, at);
+        },
+    });
 }
 
 /** One reconciliation + durable health-callback recovery pass. */
@@ -780,7 +838,8 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
 function subagentWorkDetail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null {
     const detail = navigatorDetail(id, now);
     if (!detail) return null;
-    const logTailLines = options?.logTailLines ?? 10;
+    void options;
+    const transcript = readRunTranscript(id);
     const metadata = [
         { label: "provider", value: "Subagents" },
         { label: "model", value: detail.effort ? `${detail.model} · effort ${detail.effort}` : detail.model },
@@ -798,15 +857,65 @@ function subagentWorkDetail(id: string, now: number, options?: { logTailLines?:
         statusTone: statusTone(detail.status),
         subtitle: detail.currentTool ? `current tool ${detail.currentTool}` : undefined,
         metadata,
-        // The shared navigator refreshes this provider on a coarse deadline while the
-        // detail overlay is open. Read the selected logical tail rows each
-        // time so the evidence behaves like `tail -f`, not a single parsed
-        // activity/result snapshot.
-        evidence: { label: "log tail", text: tailLog(id, logTailLines) },
+        evidence: { label: "transcript", text: detail.output || "(no transcript yet)" },
+        transcript: transcript.entries,
+        transcriptDiagnostic: transcript.diagnostic,
         footerActions: [detail.status === "running" || detail.status === "orphaned" ? "x stop" : "x dismiss"],
     };
 }
 
+function createSubagentTranscriptComponent(detail: BackgroundWorkDetail, theme: unknown) {
+    const ContainerComponent = (PiTui as any).Container;
+    const AssistantComponent = (PiCodingAgent as any).AssistantMessageComponent;
+    const ToolComponent = (PiCodingAgent as any).ToolExecutionComponent;
+    const markdownTheme = typeof (PiCodingAgent as any).getMarkdownTheme === "function"
+        ? (PiCodingAgent as any).getMarkdownTheme()
+        : {};
+    if (!ContainerComponent || !AssistantComponent || !ToolComponent) {
+        return {
+            render: () => (detail.transcript ?? []).flatMap((entry) => entry.type === "assistant"
+                ? entry.content.filter((block) => block.type === "text").flatMap((block) => String(block.text ?? "").split("\n"))
+                : [`[${entry.state}] ${entry.name}`]),
+            invalidate() {},
+        };
+    }
+    const container = new ContainerComponent();
+    const ui = { requestRender: () => { try { (uiCtx?.ui as any)?.requestRender?.(); } catch { /* ignore */ } } };
+    for (const entry of detail.transcript ?? []) {
+        if (entry.type === "assistant") {
+            const message = {
+                role: "assistant" as const,
+                content: entry.content,
+                stopReason: entry.streaming ? undefined : "stop",
+                timestamp: Date.now(),
+            };
+            const component = new AssistantComponent(message as any, true, markdownTheme, "Thinking...", 1);
+            component.updateContent(message as any, entry.streaming);
+            container.addChild(component);
+            continue;
+        }
+        const component = new ToolComponent(
+            entry.name,
+            entry.id ?? `transcript-${entry.name}`,
+            entry.args ?? {},
+            { showImages: false },
+            undefined,
+            ui as any,
+            uiCtx?.cwd ?? process.cwd(),
+        );
+        component.markExecutionStarted();
+        component.setArgsComplete();
+        if (entry.state === "completed") {
+            const result = entry.result && typeof entry.result === "object"
+                ? entry.result as any
+                : { content: entry.result == null ? [] : [{ type: "text", text: String(entry.result) }] };
+            component.updateResult({ ...result, isError: entry.isError });
+        }
+        container.addChild(component);
+    }
+    return container;
+}
+
 function ensureSubagentProvider(): void {
     if (unregisterSubagentProvider) return;
     const provider: BackgroundWorkProvider = {
@@ -814,6 +923,7 @@ function ensureSubagentProvider(): void {
         label: "Subagents",
         priority: 10,
         visibleCount: () => navigatorRunningCount(),
+        showSection: (rows) => rows.some((row) => row.status === "running"),
         parentRow: (now) => mainAgentWorkRow(now),
         listRows: (now) => subagentWorkRows(now),
         detail: (id, now, options) => subagentWorkDetail(id, now, options),
@@ -905,6 +1015,7 @@ function ensureNavigator(ctx: ExtensionContext): void {
             isOpenTrigger: (data: string) => matchesKey(data, Key.left),
             matchKey: (data: string, keyId: string) => matchesKey(data, keyId),
             truncate: truncateToWidth,
+            createTranscriptComponent: createSubagentTranscriptComponent,
         });
     } catch { /* ignore */ }
 }
@@ -935,16 +1046,7 @@ function finalizeRun(pi: ExtensionAPI, ctx: ExtensionContext, id: string, code:
         notify: (message, level) => {
             try { ctx.ui.notify(message, level); } catch { /* ignore */ }
         },
-        sendMessage: (message, options) => {
-            const meta = readMeta(id);
-            if (!meta) return;
-            const suppressionReason = callbackSuppressionReason(meta);
-            if (suppressionReason) {
-                markCompletionCallbackSuppressed(id, suppressionReason);
-                return;
-            }
-            pi.sendMessage(message, options);
-        },
+        sendMessage: () => enqueueCompletionCallback(pi, id),
     });
 }
 
@@ -1401,6 +1503,7 @@ export default function (pi: ExtensionAPI) {
         catch { mainAgentStartedAt = undefined; }
         mainAgentTools.clear();
         activeCallbackOrigin = callbackOriginFromContext(ctx);
+        recoverCompletionCallbacks(pi);
         // Reload / session switch hardening (#48):
         // - Drop any leftover overlay timers/confirm state from a prior session
         //   (defensive if the host skipped session_shutdown before re-start).
@@ -1432,6 +1535,7 @@ export default function (pi: ExtensionAPI) {
 
     pi.on("session_before_switch", () => {
         activeCallbackOrigin = undefined;
+        cancelCallbackBatch(pi);
         mainAgentStartedAt = undefined;
         mainAgentTools.clear();
         disposeBackgroundWorkNavigator();
@@ -1444,6 +1548,7 @@ export default function (pi: ExtensionAPI) {
         // cannot become live process groups with no coordinator.
         stopCurrentSessionSubagents(ctx);
         activeCallbackOrigin = undefined;
+        cancelCallbackBatch(pi);
         mainAgentStartedAt = undefined;
         mainAgentTools.clear();
         stopTicker();

package/package.json

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

package/parse.ts

@@ -30,7 +30,7 @@ import { readBoundedTail, tailTerminalDisplay } from "./shared-log-utils.ts";
 import { readAppendedLines, type LogCursor } from "./log-cursor.ts";
 import { logPathFor } from "./registry.ts";
 
-interface ContentBlock { type: string; text?: string; name?: string }
+interface ContentBlock { type: string; text?: string; thinking?: string; name?: string }
 interface Cost { total?: number }
 interface MsgUsage { input?: number; output?: number; cacheRead?: number; cost?: Cost }
 interface Msg { role?: string; content?: string | ContentBlock[]; usage?: MsgUsage }
@@ -130,6 +130,121 @@ export interface ParsedRun {
     diagnostics: string[];
 }
 
+export type TranscriptEntry =
+    | { type: "assistant"; content: ContentBlock[]; streaming: boolean }
+    | {
+        type: "tool";
+        id?: string;
+        name: string;
+        args?: unknown;
+        result?: unknown;
+        isError: boolean;
+        state: "running" | "completed";
+    };
+
+export interface RunTranscript {
+    entries: TranscriptEntry[];
+    truncated: boolean;
+    diagnostic?: string;
+}
+
+const DEFAULT_TRANSCRIPT_TAIL_BYTES = 2 * 1024 * 1024;
+const DEFAULT_TRANSCRIPT_ENTRIES = 40;
+
+function transcriptContent(msg: Msg | undefined): ContentBlock[] {
+    if (!msg) return [];
+    if (typeof msg.content === "string") {
+        return msg.content.trim() ? [{ type: "text", text: msg.content }] : [];
+    }
+    if (!Array.isArray(msg.content)) return [];
+    return msg.content.filter((block) =>
+        block && (
+            (block.type === "text" && typeof block.text === "string" && block.text.trim()) ||
+            (block.type === "thinking" && typeof (block as { thinking?: unknown }).thinking === "string")
+        ),
+    );
+}
+
+/** Bounded, display-oriented transcript fold for the subagent detail view. */
+export function readRunTranscript(
+    id: string,
+    options: { maxBytes?: number; maxEntries?: number } = {},
+): RunTranscript {
+    const maxBytes = Math.max(1024, options.maxBytes ?? DEFAULT_TRANSCRIPT_TAIL_BYTES);
+    const maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_TRANSCRIPT_ENTRIES);
+    const tail = readTail(logPathFor(id), maxBytes);
+    if (tail.error) return { entries: [], truncated: false, diagnostic: `Log unreadable: ${tail.error}` };
+
+    const lines = tail.text.split(/\r?\n/);
+    if (tail.truncated) lines.shift();
+    const entries: TranscriptEntry[] = [];
+    const tools = new Map<string, Extract<TranscriptEntry, { type: "tool" }>>();
+    let anonymousTool = 0;
+    let liveAssistant: Extract<TranscriptEntry, { type: "assistant" }> | undefined;
+
+    for (const line of lines) {
+        const event = tryParse(line.trim());
+        if (!event) continue;
+        const type = event.type;
+        if (type === "message_end") {
+            const message = event.message as Msg | undefined;
+            if (message?.role !== "assistant") continue;
+            const content = transcriptContent(message);
+            if (content.length) entries.push({ type: "assistant", content, streaming: false });
+            liveAssistant = undefined;
+            continue;
+        }
+        if (type === "message_update") {
+            const message = event.message as Msg | undefined;
+            if (message?.role !== "assistant") continue;
+            const content = transcriptContent(message);
+            if (content.length) liveAssistant = { type: "assistant", content, streaming: true };
+            continue;
+        }
+        if (type === "tool_execution_start") {
+            const idValue = typeof event.toolCallId === "string" ? event.toolCallId : undefined;
+            const key = idValue ?? `anonymous:${anonymousTool++}`;
+            const tool: Extract<TranscriptEntry, { type: "tool" }> = {
+                type: "tool",
+                id: idValue,
+                name: typeof event.toolName === "string" ? event.toolName : "unknown",
+                args: event.args,
+                isError: false,
+                state: "running",
+            };
+            entries.push(tool);
+            tools.set(key, tool);
+            continue;
+        }
+        if (type === "tool_execution_end") {
+            const idValue = typeof event.toolCallId === "string" ? event.toolCallId : undefined;
+            let tool = idValue ? tools.get(idValue) : undefined;
+            if (!tool && typeof event.toolName === "string") {
+                tool = [...tools.values()].reverse().find((candidate) => candidate.name === event.toolName && candidate.state === "running");
+            }
+            if (!tool) {
+                tool = {
+                    type: "tool",
+                    id: idValue,
+                    name: typeof event.toolName === "string" ? event.toolName : "unknown",
+                    isError: event.isError === true,
+                    state: "completed",
+                };
+                entries.push(tool);
+            }
+            tool.result = event.result;
+            tool.isError = event.isError === true;
+            tool.state = "completed";
+        }
+    }
+    if (liveAssistant) entries.push(liveAssistant);
+    return {
+        entries: entries.slice(-maxEntries),
+        truncated: tail.truncated || entries.length > maxEntries,
+        diagnostic: tail.truncated ? `Showing the latest ${fmtBytes(maxBytes)} of the transcript.` : undefined,
+    };
+}
+
 /**
  * Authoritative lifecycle evidence scanned from the complete NDJSON stream.
  * Kept separate from parseRun()'s bounded tail so large-log result parsing stays

package/registry.ts

@@ -102,6 +102,9 @@ export interface RunMeta {
     sessionId: string;
     /** Foreground session that is allowed to receive unsolicited callbacks. */
     callbackOrigin?: RunCallbackOrigin;
+    /** Durable ordinary-completion callback recovery and successful-handoff markers. */
+    completionCallbackPendingAt?: number;
+    completionCallbackSentAt?: number;
     completionCallbackSuppressedAt?: number;
     completionCallbackSuppressedReason?: string;
     orphanedCallbackSuppressedAt?: number;

package/shared-callback-batcher.ts

@@ -0,0 +1,320 @@
+// Generated from packages/callback-batcher/index.ts. Do not edit directly.
+export type CallbackSource = "subagent" | "background-task";
+export type CallbackDetailTool = "subagent_result" | "bg_task_status";
+
+export interface CallbackBatchHost {
+  sendMessage(
+    message: { customType: string; content: string; display: boolean },
+    options: Record<string, unknown>,
+  ): unknown;
+}
+
+export interface CallbackBatchEvent {
+  source: CallbackSource;
+  id: string;
+  label: string;
+  status: string;
+  detailTool: CallbackDetailTool;
+  callback?: boolean;
+  isDelivered?: () => boolean;
+  getSuppressionReason?: () => string | undefined;
+  onDelivered?: (at: number) => void;
+  onSuppressed?: (reason: string, at: number) => void;
+}
+
+export interface UrgentCallbackEvent {
+  source: CallbackSource;
+  id: string;
+  label: string;
+  status: "orphaned" | "lost" | string;
+  customType: string;
+  content: string;
+  isDelivered?: () => boolean;
+  getSuppressionReason?: () => string | undefined;
+  onDelivered?: (at: number) => void;
+  onSuppressed?: (reason: string, at: number) => void;
+}
+
+export interface CallbackBatcherOptions {
+  windowMs?: number;
+  retryMs?: number;
+}
+
+export interface CallbackBatcher {
+  enqueue(event: CallbackBatchEvent): boolean;
+  flush(): Promise<boolean>;
+  deliverUrgent(event: UrgentCallbackEvent): boolean | Promise<boolean>;
+  cancel(): void;
+  pendingCount(): number;
+}
+
+interface PendingEvent {
+  event: CallbackBatchEvent;
+  sequence: number;
+}
+
+interface SharedCallbackBatcherState {
+  byHost: WeakMap<object, CallbackBatcher>;
+}
+
+const GLOBAL_STATE_KEY = Symbol.for("@1aboveio/pi-better-harness/callback-batcher");
+const DEFAULT_WINDOW_MS = 100;
+const DEFAULT_RETRY_MS = 1_000;
+const MAX_LABEL_CHARS = 160;
+const MAX_ID_CHARS = 200;
+const MAX_STATUS_CHARS = 80;
+
+export const CALLBACK_BATCH_WINDOW_ENV = "PI_BETTER_CALLBACK_BATCH_MS";
+export const DEFAULT_CALLBACK_BATCH_WINDOW_MS = DEFAULT_WINDOW_MS;
+
+export function resolveCallbackBatchWindowMs(
+  value: unknown = process.env[CALLBACK_BATCH_WINDOW_ENV],
+): number {
+  if (value === undefined || value === null || value === "") return DEFAULT_WINDOW_MS;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return DEFAULT_WINDOW_MS;
+  return Math.max(0, Math.min(5_000, Math.floor(parsed)));
+}
+
+export function formatCallbackBatch(events: readonly CallbackBatchEvent[]): string {
+  const count = events.length;
+  const heading = `${count} background completion${count === 1 ? " is" : "s are"} ready:`;
+  const rows = events.map((event) => {
+    const source = boundedField(event.source, 40);
+    const id = boundedField(event.id, MAX_ID_CHARS);
+    const label = boundedField(event.label, MAX_LABEL_CHARS);
+    const status = boundedField(event.status, MAX_STATUS_CHARS);
+    const detail = event.detailTool === "bg_task_status"
+      ? `bg_task_status id=${id}`
+      : `subagent_result id=${JSON.stringify(id)}`;
+    return `- source=${source} | id=${id} | label=${JSON.stringify(label)} | status=${status} | inspect: ${detail}`;
+  });
+  return [
+    heading,
+    ...rows,
+    "Retrieve durable results/status with the listed tools. Full results and logs are intentionally omitted.",
+  ].join("\n");
+}
+
+export function createCallbackBatcher(
+  host: CallbackBatchHost,
+  options: CallbackBatcherOptions = {},
+): CallbackBatcher {
+  const windowMs = options.windowMs ?? resolveCallbackBatchWindowMs();
+  const retryMs = Math.max(0, options.retryMs ?? DEFAULT_RETRY_MS);
+  const pending = new Map<string, PendingEvent>();
+  const inFlight = new Set<string>();
+  const urgentInFlight = new Set<string>();
+  let sequence = 0;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let flushPromise: Promise<boolean> | undefined;
+
+  const cancelTimer = (): void => {
+    if (timer) clearTimeout(timer);
+    timer = undefined;
+  };
+
+  const schedule = (delayMs: number): void => {
+    if (timer || pending.size === 0) return;
+    timer = setTimeout(() => {
+      timer = undefined;
+      void api.flush();
+    }, Math.max(0, delayMs));
+    timer.unref?.();
+  };
+
+  const enqueue = (event: CallbackBatchEvent): boolean => {
+    if (event.callback === false) return false;
+    const key = eventKey(event);
+    if (pending.has(key) || inFlight.has(key)) return false;
+    pending.set(key, { event, sequence: sequence++ });
+    schedule(windowMs);
+    return true;
+  };
+
+  const performFlush = async (): Promise<boolean> => {
+    cancelTimer();
+    const snapshot = [...pending.entries()]
+      .sort((a, b) => a[1].sequence - b[1].sequence);
+    pending.clear();
+    for (const [key] of snapshot) inFlight.add(key);
+
+    const deliverable: Array<[string, PendingEvent]> = [];
+    for (const item of snapshot) {
+      const [key, pendingEvent] = item;
+      const disposition = eventDisposition(pendingEvent.event);
+      if (disposition.kind === "delivered") {
+        inFlight.delete(key);
+        continue;
+      }
+      if (disposition.kind === "suppressed") {
+        invokeSuppressed(pendingEvent.event, disposition.reason, Date.now());
+        inFlight.delete(key);
+        continue;
+      }
+      deliverable.push(item);
+    }
+
+    if (deliverable.length === 0) {
+      if (pending.size > 0) schedule(windowMs);
+      return true;
+    }
+
+    try {
+      await host.sendMessage(
+        {
+          customType: "background-completion-batch",
+          content: formatCallbackBatch(deliverable.map(([, item]) => item.event)),
+          display: true,
+        },
+        { deliverAs: "followUp", triggerTurn: true },
+      );
+    } catch {
+      for (const [key] of deliverable) inFlight.delete(key);
+      const retryItems = [...deliverable, ...pending.entries()]
+        .sort((a, b) => a[1].sequence - b[1].sequence);
+      pending.clear();
+      for (const [key, item] of retryItems) {
+        if (!pending.has(key)) pending.set(key, item);
+      }
+      schedule(retryMs);
+      return false;
+    }
+
+    const deliveredAt = Date.now();
+    for (const [key, item] of deliverable) {
+      invokeDelivered(item.event, deliveredAt);
+      inFlight.delete(key);
+    }
+    if (pending.size > 0) schedule(windowMs);
+    return true;
+  };
+
+  const flush = (): Promise<boolean> => {
+    if (flushPromise) return flushPromise;
+    flushPromise = performFlush().finally(() => {
+      flushPromise = undefined;
+    });
+    return flushPromise;
+  };
+
+  const deliverUrgent = (event: UrgentCallbackEvent): boolean | Promise<boolean> => {
+    const key = eventKey(event);
+    if (urgentInFlight.has(key)) return false;
+    const disposition = eventDisposition(event);
+    if (disposition.kind === "delivered") return true;
+    if (disposition.kind === "suppressed") {
+      invokeSuppressed(event, disposition.reason, Date.now());
+      return true;
+    }
+
+    urgentInFlight.add(key);
+    try {
+      const handoff = host.sendMessage(
+        { customType: event.customType, content: event.content, display: true },
+        { deliverAs: "followUp", triggerTurn: true },
+      );
+      if (isPromiseLike(handoff)) {
+        return Promise.resolve(handoff).then(
+          () => {
+            invokeDelivered(event, Date.now());
+            return true;
+          },
+          () => false,
+        ).finally(() => urgentInFlight.delete(key));
+      }
+      invokeDelivered(event, Date.now());
+      urgentInFlight.delete(key);
+      return true;
+    } catch {
+      urgentInFlight.delete(key);
+      return false;
+    }
+  };
+
+  const api: CallbackBatcher = {
+    enqueue,
+    flush,
+    deliverUrgent,
+    cancel() {
+      cancelTimer();
+      pending.clear();
+    },
+    pendingCount() {
+      return pending.size;
+    },
+  };
+  return api;
+}
+
+export function getCallbackBatcher(
+  host: CallbackBatchHost,
+  options: CallbackBatcherOptions = {},
+): CallbackBatcher {
+  const state = globalState();
+  const key = host as object;
+  const existing = state.byHost.get(key);
+  if (existing) return existing;
+  const created = createCallbackBatcher(host, options);
+  state.byHost.set(key, created);
+  return created;
+}
+
+export function cancelCallbackBatch(host: CallbackBatchHost): void {
+  globalState().byHost.get(host as object)?.cancel();
+}
+
+function globalState(): SharedCallbackBatcherState {
+  const root = globalThis as typeof globalThis & {
+    [GLOBAL_STATE_KEY]?: SharedCallbackBatcherState;
+  };
+  root[GLOBAL_STATE_KEY] ??= { byHost: new WeakMap<object, CallbackBatcher>() };
+  return root[GLOBAL_STATE_KEY];
+}
+
+function eventKey(event: Pick<CallbackBatchEvent, "source" | "id" | "status">): string {
+  return `${event.source}\u0000${event.id}\u0000${event.status}`;
+}
+
+function eventDisposition(
+  event: Pick<CallbackBatchEvent, "isDelivered" | "getSuppressionReason">,
+): { kind: "deliver" } | { kind: "delivered" } | { kind: "suppressed"; reason: string } {
+  try {
+    if (event.isDelivered?.()) return { kind: "delivered" };
+  } catch {
+    return { kind: "suppressed", reason: "durable delivery state could not be verified" };
+  }
+  try {
+    const reason = event.getSuppressionReason?.();
+    return reason ? { kind: "suppressed", reason } : { kind: "deliver" };
+  } catch {
+    return { kind: "suppressed", reason: "callback ownership could not be verified" };
+  }
+}
+
+function invokeDelivered(
+  event: Pick<CallbackBatchEvent, "onDelivered">,
+  at: number,
+): void {
+  try { event.onDelivered?.(at); } catch { /* handoff already succeeded */ }
+}
+
+function invokeSuppressed(
+  event: Pick<CallbackBatchEvent, "onSuppressed">,
+  reason: string,
+  at: number,
+): void {
+  try { event.onSuppressed?.(reason, at); } catch { /* best effort durable suppression */ }
+}
+
+function boundedField(value: unknown, maxChars: number): string {
+  const oneLine = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (oneLine.length <= maxChars) return oneLine;
+  return `${oneLine.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return (typeof value === "object" || typeof value === "function")
+    && value !== null
+    && typeof (value as PromiseLike<unknown>).then === "function";
+}

package/shared-navigator.ts

@@ -39,6 +39,11 @@ export type BackgroundWorkDetail = {
   metadata: Array<{ label: string; value: string }>;
   foldedSections?: Array<{ id: string; label: string; text: string; collapsedText?: string; expandedByDefault?: boolean }>;
   evidence: { label: string; text: string };
+  transcript?: Array<
+    | { type: "assistant"; content: Array<{ type: string; text?: string; thinking?: string }>; streaming: boolean }
+    | { type: "tool"; id?: string; name: string; args?: unknown; result?: unknown; isError: boolean; state: "running" | "completed" }
+  >;
+  transcriptDiagnostic?: string;
   footerActions?: string[];
 };
 
@@ -54,6 +59,7 @@ export type BackgroundWorkProvider = {
   label: string;
   priority: number;
   visibleCount(): number;
+  showSection?(rows: BackgroundWorkRow[], now: number): boolean;
   parentRow?(now: number): BackgroundWorkRow | null;
   listRows(now: number): BackgroundWorkRow[];
   detail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null;
@@ -67,6 +73,7 @@ type HostDeps = {
   isOpenTrigger: (data: string) => boolean;
   matchKey: (data: string, keyId: string) => boolean;
   truncate: (s: string, width: number) => string;
+  createTranscriptComponent?: (detail: BackgroundWorkDetail, theme: unknown) => Component;
 };
 
 type NavigatorState = {
@@ -83,6 +90,7 @@ type NavigatorState = {
   mainListCloseArm?: { id: string; armedAt: number };
   mainListCloseArmTimer?: ReturnType<typeof setTimeout>;
   mainListDeadlineScheduler?: RenderScheduler;
+  editorComponent?: Component;
   detailOverlayRows?: number;
   dispose?: () => void;
 };
@@ -99,8 +107,7 @@ export const CLOSE_ARM_MS = 3000;
 export const DEFAULT_LOG_TAIL_ROWS = 10;
 export const LOG_TAIL_ROW_CHOICES = [10, 25] as const;
 const MAIN_LIST_FALLBACK_WIDTH = 100;
-const DETAIL_OVERLAY_HEADER_MARGIN_ROWS = 5;
-const DETAIL_OVERLAY_FOOTER_MARGIN_ROWS = 3;
+const DETAIL_OVERLAY_FOOTER_ROWS = 3;
 const EVIDENCE_SECTION_ID = "__evidence__";
 const RUNNING_DOT_GLYPH = "●";
 const RUNNING_DOT_FRAMES = ["dim", "accent", "accent", "dim"] as const;
@@ -315,7 +322,7 @@ function renderWidth(width: number): number {
   return Number.isFinite(width) && width > 0 ? Math.floor(width) : MAIN_LIST_FALLBACK_WIDTH;
 }
 
-type InternalRow = BackgroundWorkRow & { navigatorId: string; providerLabel: string };
+type InternalRow = BackgroundWorkRow & { navigatorId: string; providerLabel: string; parentRow?: boolean };
 
 function rowKey(providerId: string, id: string): string {
   return `${providerId}:${id}`;
@@ -333,6 +340,19 @@ function listRows(now = Date.now()): InternalRow[] {
     let providerRows: BackgroundWorkRow[] = [];
     try { providerRows = provider.listRows(now) ?? []; } catch { providerRows = []; }
     const orderedProviderRows = [...providerRows].sort((a, b) => b.sortStartedAt - a.sortStartedAt || rowDisplayName(a).localeCompare(rowDisplayName(b)));
+    let showSection = orderedProviderRows.length > 0 || provider.parentRow !== undefined;
+    try { showSection = provider.showSection?.(orderedProviderRows, now) ?? showSection; } catch { showSection = false; }
+    if (!showSection) continue;
+    let parentRow: BackgroundWorkRow | null = null;
+    try { parentRow = provider.parentRow?.(now) ?? null; } catch { parentRow = null; }
+    if (parentRow) {
+      rows.push({
+        ...parentRow,
+        navigatorId: rowKey(parentRow.providerId, parentRow.id),
+        providerLabel: provider.label,
+        parentRow: true,
+      });
+    }
     for (const row of orderedProviderRows) {
       rows.push({ ...row, navigatorId: rowKey(provider.id, row.id), providerLabel: provider.label });
     }
@@ -378,7 +398,7 @@ function focusMainList(): void {
   const rows = listRows();
   if (rows.length === 0) return;
   const s = state();
-  syncMainListSelection(rows);
+  s.mainListSelectedId = rows.find((row) => row.parentRow && row.id === "main")?.navigatorId ?? rows[0]!.navigatorId;
   s.mainListFocused = true;
   refreshMainListWidget();
 }
@@ -412,16 +432,6 @@ function buildMainListLines(
     const group = grouped.get(label)!;
     if (i > 0) lines.push("");
     lines.push(providerGroupLabel(label, fg));
-    const provider = state().providers.get(group[0]!.providerId);
-    let parentRow: BackgroundWorkRow | null = null;
-    try { parentRow = provider?.parentRow?.(Date.now()) ?? null; } catch { parentRow = null; }
-    if (parentRow) {
-      lines.push(formatMainListRow({
-        ...parentRow,
-        navigatorId: rowKey(parentRow.providerId, parentRow.id),
-        providerLabel: label,
-      }, false, fg, width));
-    }
     for (const row of group) {
       const selected = options.focused && row.navigatorId === options.selectedId;
       lines.push(formatMainListRow(row, selected === true, fg, width));
@@ -433,13 +443,13 @@ function buildMainListLines(
 }
 
 function shortcutsLine(focused: boolean, fg: (color: string, value: string) => string): string {
-  const keys = focused ? "↑↓ select · Enter detail · x stop · Esc unfocus" : "← to navigate";
+  const keys = focused ? "↑↓ switch · Enter detail · x stop · Esc unfocus" : "← to navigate";
   return dim(keys, fg);
 }
 
 function providerGroupLabel(label: string, fg: (color: string, value: string) => string): string {
   const normalized = singleLine(label).toLowerCase();
-  return `${dim("▸", fg)} ${fg("warning", normalized)}`;
+  return fg("warning", normalized);
 }
 
 function formatMainListRow(row: InternalRow, selected: boolean, fg: (color: string, value: string) => string, width: number): string {
@@ -527,13 +537,14 @@ function detailFor(navigatorId: string, now = Date.now(), options?: { logTailLin
 }
 
 function closeFor(row: InternalRow): BackgroundWorkCloseOutcome {
+  if (row.parentRow) return { action: "not-closable", providerId: row.providerId, id: row.id };
   const provider = state().providers.get(row.providerId);
   if (!provider) return { action: "missing", providerId: row.providerId, id: row.id };
   try { return provider.close(row.id); } catch { return { action: "missing", providerId: row.providerId, id: row.id }; }
 }
 
 function closeHintFor(row: InternalRow | undefined): string | null {
-  if (!row) return null;
+  if (!row || row.parentRow) return null;
   const provider = state().providers.get(row.providerId);
   if (!provider) return null;
   try { return `${provider.armCloseLabel(row)} ${row.name || row.id}`; } catch { return null; }
@@ -558,6 +569,7 @@ function installNavigatorEditor(ui: any, deps: HostDeps): unknown {
 }
 
 function wrapEditor(inner: any, deps: HostDeps): unknown {
+  if (inner && typeof inner.render === "function") state().editorComponent = inner as Component;
   return new Proxy(inner, {
     get(target, prop) {
       if (prop === "handleInput") {
@@ -588,16 +600,24 @@ function handleMainListInput(data: string, deps: HostDeps): boolean {
   }
   if (deps.matchKey(data, "up")) {
     clearMainListCloseArm();
-    if (moveMainListSelection(-1)) refreshMainListWidget();
+    if (moveMainListSelection(-1)) {
+      refreshMainListWidget();
+      if (!selectedMainListRow()?.parentRow) openNavigator();
+    }
     return true;
   }
   if (deps.matchKey(data, "down")) {
     clearMainListCloseArm();
-    if (moveMainListSelection(1)) refreshMainListWidget();
+    if (moveMainListSelection(1)) {
+      refreshMainListWidget();
+      if (!selectedMainListRow()?.parentRow) openNavigator();
+    }
     return true;
   }
   if (deps.matchKey(data, "enter")) {
-    openNavigator();
+    const selected = selectedMainListRow();
+    if (selected?.parentRow) unfocusMainList();
+    else openNavigator();
     return true;
   }
   if (data === "x" || data === "X" || deps.matchKey(data, "x") || deps.matchKey(data, "X")) {
@@ -613,7 +633,7 @@ function handleMainListInput(data: string, deps: HostDeps): boolean {
 
 function handleMainListCloseKey(): void {
   const row = selectedMainListRow();
-  if (!row) return;
+  if (!row || row.parentRow) return;
   const s = state();
   const now = Date.now();
   const arm = s.mainListCloseArm;
@@ -689,6 +709,8 @@ function createOverlayComponent(
   let closeArm: { id: string; armedAt: number } | undefined;
   let closeArmTimer: ReturnType<typeof setTimeout> | undefined;
   let closed = false;
+  let transcriptDetail: BackgroundWorkDetail | null = null;
+  let transcriptComponent: Component | null = null;
 
   const fg = (color: string, value: string) => theme?.fg ? theme.fg(color, value) : value;
 
@@ -704,12 +726,24 @@ function createOverlayComponent(
   });
 
   function refreshRows(): void {
-    const selectedId = overlayState.rows[overlayState.selected]?.navigatorId;
+    const selectedId = state().mainListSelectedId ?? overlayState.rows[overlayState.selected]?.navigatorId;
     overlayState.rows = listRows();
     const nextIdx = selectedId ? overlayState.rows.findIndex((row) => row.navigatorId === selectedId) : -1;
     overlayState.selected = nextIdx >= 0 ? nextIdx : Math.min(overlayState.selected, Math.max(0, overlayState.rows.length - 1));
   }
 
+  function selectOverlayRow(next: number): void {
+    overlayState.selected = Math.min(Math.max(0, overlayState.rows.length - 1), Math.max(0, next));
+    state().mainListSelectedId = overlayState.rows[overlayState.selected]?.navigatorId;
+    clearCloseArm();
+    refreshMainListWidget();
+  }
+
+  function activateSelectedRow(): void {
+    if (selectedRow()?.parentRow) close();
+    else openDetail();
+  }
+
   function clearCloseArm(): void {
     if (closeArmTimer) clearTimeout(closeArmTimer);
     closeArmTimer = undefined;
@@ -731,13 +765,16 @@ function createOverlayComponent(
   }
 
   function selectedRow(): InternalRow | undefined {
-    if (mode === "detail" && detailId) return overlayState.rows.find((row) => row.navigatorId === detailId);
     return overlayState.rows[overlayState.selected];
   }
 
   function openDetail(): void {
     const row = selectedRow();
     if (!row) return;
+    if (row.parentRow) {
+      close();
+      return;
+    }
     clearCloseArm();
     detailId = row.navigatorId;
     expandedSections.clear();
@@ -808,10 +845,43 @@ function createOverlayComponent(
 
   return {
     render(width: number) {
-      const lines = mode === "detail"
-        ? buildDetailLines(detail, width, deps.truncate, fg, { expandedSections, logTailRows, minRows: state().detailOverlayRows })
-        : buildListLines(overlayState, width, deps.truncate, fg);
-      return lines;
+      refreshRows();
+      const railLines = mode === "detail"
+        ? buildMainListLines(overlayState.rows, width, deps.truncate, fg, {
+            selectedId: selectedRow()?.navigatorId,
+            focused: true,
+          })
+        : [];
+      const editorLines = mode === "detail" ? renderEditorLines(width) : [];
+      const bottomLines = [...railLines, ...editorLines];
+      const overlayRows = state().detailOverlayRows;
+      const detailRows = overlayRows === undefined ? undefined : Math.max(1, overlayRows - bottomLines.length);
+      let contentLines: string[];
+      if (mode === "detail" && detail?.transcript && deps.createTranscriptComponent) {
+        if (transcriptDetail !== detail || !transcriptComponent) {
+          transcriptDetail = detail;
+          transcriptComponent = deps.createTranscriptComponent(detail, theme);
+        }
+        contentLines = buildTranscriptDetailLines(
+          detail,
+          transcriptComponent.render(width),
+          width,
+          deps.truncate,
+          fg,
+          { minRows: detailRows },
+        );
+      } else {
+        transcriptDetail = null;
+        transcriptComponent = null;
+        contentLines = mode === "detail"
+          ? buildDetailLines(detail, width, deps.truncate, fg, { expandedSections, logTailRows, minRows: detailRows })
+          : buildListLines(overlayState, width, deps.truncate, fg);
+      }
+      if (mode !== "detail") return contentLines;
+      if (detailRows === undefined) return [...contentLines, ...bottomLines];
+      const fittedContent = contentLines.slice(0, detailRows);
+      while (fittedContent.length < detailRows) fittedContent.push("");
+      return [...fittedContent, ...bottomLines];
     },
     handleInput(data: string) {
       if (closed) return;
@@ -820,10 +890,25 @@ function createOverlayComponent(
         return;
       }
       if (mode === "detail") {
-        if (deps.matchKey(data, "left")) close();
+        if (deps.matchKey(data, "up")) {
+          selectOverlayRow(overlayState.selected - 1);
+          activateSelectedRow();
+        }
+        else if (deps.matchKey(data, "down")) {
+          selectOverlayRow(overlayState.selected + 1);
+          activateSelectedRow();
+        }
+        else if (deps.matchKey(data, "left")) {
+          const mainIdx = overlayState.rows.findIndex((row) => row.parentRow && row.id === "main");
+          if (mainIdx >= 0) selectOverlayRow(mainIdx);
+          close();
+        }
         else if (deps.matchKey(data, "enter")) {
-          const sectionId = firstToggleableSectionId(detail);
-          if (sectionId) {
+          const row = selectedRow();
+          if (row?.parentRow || row?.navigatorId !== detailId) openDetail();
+          else {
+            const sectionId = firstToggleableSectionId(detail);
+            if (!sectionId) return;
             if (expandedSections.has(sectionId)) expandedSections.delete(sectionId);
             else expandedSections.add(sectionId);
             requestRender();
@@ -834,7 +919,10 @@ function createOverlayComponent(
           if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
           requestRender();
         }
-        else if (deps.matchKey(data, "escape")) close();
+        else if (deps.matchKey(data, "escape")) {
+          unfocusMainList();
+          close();
+        }
         return;
       }
       if (deps.matchKey(data, "up")) {
@@ -851,7 +939,7 @@ function createOverlayComponent(
         close();
       }
     },
-    invalidate() {},
+    invalidate() { transcriptComponent?.invalidate(); },
     dispose() {
       clearCloseArm();
       detailScheduler.dispose();
@@ -859,26 +947,61 @@ function createOverlayComponent(
   };
 }
 
+function buildTranscriptDetailLines(
+  detail: BackgroundWorkDetail,
+  transcriptLines: string[],
+  width: number,
+  truncate: (s: string, width: number) => string,
+  fg: (color: string, value: string) => string,
+  options: { minRows?: number } = {},
+): string[] {
+  const actions = [...(detail.footerActions ?? ["x close"]), "Esc close"].join(" · ");
+  const lines: string[] = [
+    fg("accent", rule(detail.title, width)),
+    dim(`   ← main · ${actions}`, fg),
+    "",
+    `   status   ${fg(toneColor(detail.statusTone, detail.status), detail.status)}`,
+  ];
+  if (detail.subtitle) lines.push(`   summary  ${detail.subtitle}`);
+  for (const item of detail.metadata) lines.push(`   ${item.label.padEnd(8, " ").slice(0, 8)} ${item.value}`);
+  lines.push("", dim(section("transcript", width), fg));
+  if (detail.transcriptDiagnostic) lines.push(`   ${dim(detail.transcriptDiagnostic, fg)}`);
+  lines.push(...(transcriptLines.length ? transcriptLines : ["   (no transcript yet)"]));
+  lines.push("");
+  const footerLines = [dim(`   ← main · ${actions}`, fg), dim(rule("", width), fg)];
+  padBeforeFooter(lines, footerLines.length, options.minRows);
+  lines.push(...footerLines);
+  return lines.map((line) => safeTruncate(line, width, truncate));
+}
+
 function detailOverlayOptions() {
-  const navigatorRows = state().lastMainListLines?.length ?? 0;
-  const marginBottom = DETAIL_OVERLAY_FOOTER_MARGIN_ROWS + navigatorRows;
+  const marginBottom = DETAIL_OVERLAY_FOOTER_ROWS;
   return {
     anchor: "top-left" as const,
     width: "100%" as const,
     maxHeight: "100%" as const,
     margin: {
-      top: DETAIL_OVERLAY_HEADER_MARGIN_ROWS,
+      top: 0,
       right: 0,
       bottom: marginBottom,
       left: 0,
     },
     visible: (_termWidth: number, termHeight: number) => {
-      state().detailOverlayRows = Math.max(1, termHeight - DETAIL_OVERLAY_HEADER_MARGIN_ROWS - marginBottom);
+      state().detailOverlayRows = Math.max(1, termHeight - marginBottom);
       return true;
     },
   };
 }
 
+function renderEditorLines(width: number): string[] {
+  try {
+    const lines = state().editorComponent?.render(width);
+    if (lines?.length) return lines;
+  } catch { /* use an empty editor-shaped fallback */ }
+  const border = "─".repeat(Math.max(1, width));
+  return [border, "", border];
+}
+
 function fallbackDetail(row: InternalRow): BackgroundWorkDetail {
   return {
     providerId: row.providerId,