@tryinget/pi-activity-strip 0.5.0 → 0.6.0

package/src/common/ghostty-theme.mjs

@@ -0,0 +1,149 @@
+// ---
+// summary: "resolves the colours Ghostty is currently using into the ribbon's palette"
+// read_when:
+//   - "changing how the ribbon follows the Ghostty theme or the day/night switch"
+// ---
+
+/**
+ * Ghostty writes its palette as `key = value` lines, in its config and in each theme file. A theme
+ * setting may name one theme, or one per colour scheme as `light:Name,dark:Name`. The ribbon reads
+ * the same files the terminal does, so the two always agree without any configuration of its own.
+ */
+
+const HEX_COLOR = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+export const PALETTE_SIZE = 16;
+
+/** @typedef {{background: string; foreground: string; accent: string; thinking: string; tool: string; waiting: string; success: string; error: string}} RibbonPalette */
+
+/** Everforest-neutral defaults, used only when no theme can be read. */
+/** @type {RibbonPalette} */
+export const FALLBACK_PALETTE = Object.freeze({
+  background: "#1e2326",
+  foreground: "#d3c6aa",
+  accent: "#7fbbb3",
+  thinking: "#7fbbb3",
+  tool: "#dbbc7f",
+  waiting: "#e69875",
+  success: "#a7c080",
+  error: "#e67e80",
+});
+
+/** @param {unknown} value */
+export function normalizeHexColor(value) {
+  const raw = String(value ?? "").trim();
+  if (!HEX_COLOR.test(raw)) return "";
+  const body = raw.replace(/^#/, "").toLowerCase();
+  const full =
+    body.length === 3
+      ? body
+          .split("")
+          .map((character) => character + character)
+          .join("")
+      : body;
+  return `#${full}`;
+}
+
+/**
+ * Read every `key = value` pair, ignoring comments and blank lines. Repeated keys are kept in
+ * order, because `palette` appears once per colour index.
+ * @param {string} text
+ */
+export function parseGhosttyConfig(text) {
+  /** @type {Map<string, string[]>} */
+  const entries = new Map();
+  for (const line of String(text ?? "").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0) continue;
+    const key = trimmed.slice(0, separator).trim().toLowerCase();
+    const value = trimmed.slice(separator + 1).trim();
+    entries.set(key, [...(entries.get(key) ?? []), value]);
+  }
+  return entries;
+}
+
+/**
+ * Names of the themes a config selects. `light:A,dark:B` follows the desktop's colour scheme; a
+ * bare name is used for both.
+ * @param {string} value
+ * @returns {{light: string; dark: string}}
+ */
+export function parseThemeSetting(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) return { light: "", dark: "" };
+  if (!/(^|,)\s*(light|dark)\s*:/i.test(raw)) return { light: raw, dark: raw };
+  const themes = { light: "", dark: "" };
+  for (const part of raw.split(",")) {
+    const match = part.match(/^\s*(light|dark)\s*:\s*(.+?)\s*$/i);
+    if (match) themes[match[1].toLowerCase() === "dark" ? "dark" : "light"] = match[2];
+  }
+  return themes;
+}
+
+/**
+ * Colours from a theme file or a config that carries them inline.
+ * @param {string} text
+ */
+export function parseGhosttyTheme(text) {
+  const entries = parseGhosttyConfig(text);
+  /** @type {string[]} */
+  const palette = new Array(PALETTE_SIZE).fill("");
+  for (const value of entries.get("palette") ?? []) {
+    const match = String(value).match(/^\s*(\d+)\s*=\s*(.+?)\s*$/);
+    if (!match) continue;
+    const index = Number.parseInt(match[1], 10);
+    const color = normalizeHexColor(match[2]);
+    if (Number.isInteger(index) && index >= 0 && index < PALETTE_SIZE && color) {
+      palette[index] = color;
+    }
+  }
+  /** @param {string} key */
+  const single = (key) => normalizeHexColor((entries.get(key) ?? []).at(-1));
+  return {
+    background: single("background"),
+    foreground: single("foreground"),
+    cursor: single("cursor-color"),
+    selectionBackground: single("selection-background"),
+    palette,
+  };
+}
+
+/** @param {ReturnType<typeof parseGhosttyTheme>} theme @param {number} index @param {string} fallback */
+function paletteColor(theme, index, fallback) {
+  return theme?.palette?.[index] || fallback;
+}
+
+/**
+ * Map terminal colours onto the ribbon's roles. State colours reuse the terminal's own semantics,
+ * so a card reads the same way as output in the tab it points at: green settled, yellow working,
+ * red failed, and the cursor colour for a session that wants the operator.
+ * @param {ReturnType<typeof parseGhosttyTheme> | null} theme
+ * @returns {RibbonPalette}
+ */
+export function buildRibbonPalette(theme) {
+  if (!theme?.background || !theme?.foreground) return { ...FALLBACK_PALETTE };
+  const blue = paletteColor(theme, 4, FALLBACK_PALETTE.thinking);
+  return {
+    background: theme.background,
+    foreground: theme.foreground,
+    accent: blue,
+    thinking: blue,
+    tool: paletteColor(theme, 3, FALLBACK_PALETTE.tool),
+    waiting: theme.cursor || paletteColor(theme, 5, FALLBACK_PALETTE.waiting),
+    success: paletteColor(theme, 2, FALLBACK_PALETTE.success),
+    error: paletteColor(theme, 1, FALLBACK_PALETTE.error),
+  };
+}
+
+/**
+ * The GTK colour definitions the panel prepends to its stylesheet. Everything else the ribbon
+ * draws is derived from these in CSS, so a theme change is a handful of values.
+ * @param {RibbonPalette} palette
+ */
+export function paletteDefinitions(palette) {
+  const colors = { ...FALLBACK_PALETTE, ...(palette ?? {}) };
+  return Object.entries(colors)
+    .map(([name, value]) => `@define-color pi_${name} ${normalizeHexColor(value) || "#000000"};`)
+    .join("\n");
+}

package/src/common/niri-focus.mjs

@@ -6,19 +6,34 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { presentGhosttySurface } from "./ghostty-present.mjs";
 import { projectSessionCards, sessionCardId } from "./session-cards.mjs";
+import { parseTerminalTitleBinding } from "./surface-bindings.mjs";
 import {
   appIdForGhosttyFamily,
   canonicalGhosttyTerminalKey,
   normalizeGhosttySurfaceId,
   terminalTitleSegment,
 } from "./terminal-identity.mjs";
+import { resolveHiddenSurfaceWindow } from "./window-placement.mjs";
 
 const GHOSTTY_APP_IDS = new Set(["com.mitchellh.ghostty", "com.tryinget.ghosttysidequest"]);
 const PI_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const SESSION_PRESENCE_SOURCE = "@tryinget/pi-little-helpers/session-presence";
 const SESSION_TITLE_TOKEN_HEX_LENGTH = 32;
 const LEGACY_SESSION_TITLE_TOKEN_HEX_LENGTH = 8;
+const PRESENT_VERIFY_ATTEMPTS = 4;
+const PRESENT_VERIFY_DELAY_MS = 120;
+
+/** @typedef {import("./window-placement.mjs").PlacementOptions} PlacementOptions */
+/** @typedef {import("./window-placement.mjs").WindowPlacement} WindowPlacement */
+/**
+ * @typedef {PlacementOptions & {
+ *   env?: NodeJS.ProcessEnv;
+ *   readFileSync?: typeof fs.readFileSync;
+ *   existsSync?: typeof fs.existsSync;
+ * }} ResolveOptions
+ */
 
 /**
  * Read one bounded Niri JSON list. Polling callers treat command, timeout,
@@ -167,156 +182,210 @@ export function resolveExactGhosttyWindow(windows, sessionId, session = {}) {
 }
 
 /**
- * Resolve the one snapshot session whose exact Ghostty window currently owns
- * compositor focus. Missing, ambiguous, non-Ghostty, and stale identities all
- * fail closed so the renderer never highlights a guessed session.
+ * Place a session on its window. A visible title is exact proof; a bound surface whose tab is
+ * hidden behind another tab is placed through its Ghostty host process and remembered window.
  * @param {Array<Record<string, unknown>>} windows
- * @param {Array<Record<string, unknown>>} sessions
- * @param {{env?: NodeJS.ProcessEnv; readFileSync?: typeof fs.readFileSync; existsSync?: typeof fs.existsSync}} [options]
+ * @param {string} sessionId
+ * @param {Record<string, unknown>} [session]
+ * @param {PlacementOptions} [options]
+ * @returns {WindowPlacement | null}
  */
-export function resolveFocusedSnapshotSessionId(windows, sessions, options = {}) {
-  const focusedWindows = windows.filter((window) => window?.is_focused === true);
-  if (focusedWindows.length !== 1) return null;
-  const focusedWindow = focusedWindows[0];
-  const matches = sessions.filter((session) => {
-    const sessionId = resolvePiSessionIdentity(session, options);
-    if (!sessionId) return false;
-    return resolveExactGhosttyWindow(windows, sessionId, session)?.id === focusedWindow.id;
+export function resolveSessionWindow(windows, sessionId, session = {}, options = {}) {
+  const exact = resolveExactGhosttyWindow(windows, sessionId, session);
+  if (exact) return { window: exact, placement: "title" };
+  return resolveHiddenSurfaceWindow(windows, session, {
+    ...options,
+    sessionToken: shortSessionId(sessionId),
   });
-  return matches.length === 1 ? String(matches[0]?.sessionId ?? "") || null : null;
 }
 
 /**
- * Project the global broker snapshot onto one exact Niri workspace. Membership
- * requires an exact Ghostty window. Multiple publisher streams bound to the same terminal are
- * aggregated into one stable card; ambiguity between distinct windows still fails closed.
+ * A tab occupied by a coding agent other than Pi carries no Pi identity, so it is placed by the
+ * exact title the agent put on its own terminal, and otherwise by host containment and window
+ * memory. A title claimed by more than one window is ambiguous and places nothing.
  * @param {Array<Record<string, unknown>>} windows
- * @param {Record<string, unknown>} workspace
- * @param {Array<Record<string, unknown>>} sessions
- * @param {{env?: NodeJS.ProcessEnv; readFileSync?: typeof fs.readFileSync; existsSync?: typeof fs.existsSync}} [options]
+ * @param {Record<string, unknown>} session
+ * @param {PlacementOptions} [options]
+ * @returns {WindowPlacement | null}
  */
-export function resolveWorkspaceView(windows, workspace, sessions, options = {}) {
-  if (!Number.isInteger(workspace?.id)) return null;
-  /** @type {Array<{cardId: string; session: Record<string, unknown>; window: Record<string, unknown>}>} */
-  const candidates = [];
-  for (const session of sessions) {
-    const sessionIdentity = resolvePiSessionIdentity(session, options);
-    if (!sessionIdentity) continue;
-    const window = resolveExactGhosttyWindow(windows, sessionIdentity, session);
-    if (!window || window.workspace_id !== workspace.id) continue;
-    const cardId = sessionCardId(session);
-    if (!cardId) continue;
-    candidates.push({ cardId, session: { ...session, cardId }, window });
-  }
-
-  const cardIdsByWindow = new Map();
-  for (const candidate of candidates) {
-    const ids = cardIdsByWindow.get(candidate.window.id) ?? new Set();
-    ids.add(candidate.cardId);
-    cardIdsByWindow.set(candidate.window.id, ids);
-  }
-  const allowedCardByWindow = new Map();
-  for (const [windowId, ids] of cardIdsByWindow) {
-    const terminalIds = [...ids].filter((cardId) => cardId.startsWith("terminal:"));
-    if (terminalIds.length === 1) allowedCardByWindow.set(windowId, terminalIds[0]);
-    else if (ids.size === 1) allowedCardByWindow.set(windowId, [...ids][0]);
+export function resolveAgentSessionWindow(windows, session, options = {}) {
+  const titleSuffix = String(session.titleSuffix ?? "").trim();
+  if (titleSuffix) {
+    const expectedAppId = appIdForGhosttyFamily(String(session.terminalFamily ?? ""));
+    const matches = windows.filter(
+      (window) =>
+        Number.isInteger(window?.id) &&
+        String(window?.app_id ?? "") === expectedAppId &&
+        String(window?.title ?? "").endsWith(titleSuffix),
+    );
+    if (matches.length === 1) return { window: matches[0], placement: "title" };
+    if (matches.length > 1) return null;
   }
+  return resolveHiddenSurfaceWindow(windows, session, options);
+}
 
-  /** @type {Map<string, Array<{session: Record<string, unknown>; window: Record<string, unknown>}>>} */
-  const groups = new Map();
-  for (const candidate of candidates) {
-    if (allowedCardByWindow.get(candidate.window.id) !== candidate.cardId) continue;
-    const group = groups.get(candidate.cardId) ?? [];
-    group.push(candidate);
-    groups.set(candidate.cardId, group);
-  }
+/**
+ * Whether a session could ever be placed by a title. Activation can only confirm that a presented
+ * tab became visible for these; for anything else the compositor offers no readable proof.
+ * @param {Record<string, unknown>} session
+ * @param {ResolveOptions} [options]
+ */
+export function canVerifyTabVisibility(session, options = {}) {
+  if (resolvePiSessionIdentity(session, options)) return true;
+  return String(session?.titleSuffix ?? "").trim().length > 0;
+}
 
-  const projectedSessions = [];
-  for (const [cardId, group] of groups) {
-    const windowIds = new Set(group.map((candidate) => candidate.window.id));
-    if (windowIds.size !== 1) continue;
-    const [card] = projectSessionCards(group.map((candidate) => candidate.session));
-    if (!card) continue;
-    const window = group[0]?.window;
-    projectedSessions.push({ ...card, cardId, windowId: window?.id });
-  }
-  const focusedCard = projectedSessions.find((session) =>
-    windows.some((window) => window?.id === session.windowId && window?.is_focused === true),
-  );
-  return {
-    workspace,
-    sessions: projectedSessions,
-    focusedSessionId: focusedCard ? String(focusedCard.sessionId ?? "") || null : null,
-    focusedCardId: focusedCard ? String(focusedCard.cardId ?? "") || null : null,
-  };
+/**
+ * Place any tracked session: a Pi session by its exact Pi identity, an agent tab by its own title.
+ * @param {Array<Record<string, unknown>>} windows
+ * @param {Record<string, unknown>} session
+ * @param {ResolveOptions} [options]
+ * @returns {WindowPlacement | null}
+ */
+export function placeSessionWindow(windows, session, options = {}) {
+  const piSessionId = resolvePiSessionIdentity(session, options);
+  if (piSessionId) return resolveSessionWindow(windows, piSessionId, session, options);
+  return canonicalGhosttyTerminalKey(session)
+    ? resolveAgentSessionWindow(windows, session, options)
+    : null;
 }
 
 /**
- * Project the global broker snapshot onto the one focused Niri workspace.
+ * Resolve the one snapshot session whose exact Ghostty window currently owns
+ * compositor focus. Missing, ambiguous, non-Ghostty, and stale identities all
+ * fail closed so the renderer never highlights a guessed session.
  * @param {Array<Record<string, unknown>>} windows
- * @param {Array<Record<string, unknown>>} workspaces
  * @param {Array<Record<string, unknown>>} sessions
  * @param {{env?: NodeJS.ProcessEnv; readFileSync?: typeof fs.readFileSync; existsSync?: typeof fs.existsSync}} [options]
  */
-export function resolveFocusedWorkspaceView(windows, workspaces, sessions, options = {}) {
-  const workspace = resolveFocusedNiriWorkspace(workspaces);
-  return workspace ? resolveWorkspaceView(windows, workspace, sessions, options) : null;
-}
-
-/** @param {Array<Record<string, unknown>>} workspaces */
-export function resolveFocusedNiriWorkspace(workspaces) {
-  const matches = workspaces.filter(
-    (workspace) =>
-      workspace?.is_focused === true &&
-      Number.isInteger(workspace?.id) &&
-      (typeof workspace?.name === "string" || Number.isInteger(workspace?.idx)),
-  );
-  return matches.length === 1 ? matches[0] : null;
+export function resolveFocusedSnapshotSessionId(windows, sessions, options = {}) {
+  const focusedWindows = windows.filter((window) => window?.is_focused === true);
+  if (focusedWindows.length !== 1) return null;
+  const focusedWindow = focusedWindows[0];
+  const matches = sessions.filter((session) => {
+    const sessionId = resolvePiSessionIdentity(session, options);
+    if (!sessionId) return false;
+    return resolveExactGhosttyWindow(windows, sessionId, session)?.id === focusedWindow.id;
+  });
+  return matches.length === 1 ? String(matches[0]?.sessionId ?? "") || null : null;
 }
 
 /**
+ * Focus the exact terminal behind a card. A visible tab needs only compositor focus. A hidden tab
+ * is first presented inside its proven Ghostty host process, then its window is focused, and the
+ * result counts as success only once the window title proves the tab became visible.
  * @param {string | Record<string, unknown>} session
  * @param {(file: string, args: string[], options: object) => Promise<{stdout?: string}>} execFileAsync
  * @param {NodeJS.ProcessEnv} [env]
- * @param {{readFileSync?: typeof fs.readFileSync; existsSync?: typeof fs.existsSync}} [options]
+ * @param {PlacementOptions & {
+ *   readFileSync?: typeof fs.readFileSync;
+ *   existsSync?: typeof fs.existsSync;
+ *   presentSurface?: typeof presentGhosttySurface;
+ *   sleep?: (milliseconds: number) => Promise<void>;
+ * }} [options]
+ * @returns {Promise<{ok: boolean; error?: string; windowId?: number; presented?: boolean; verified?: boolean}>}
  */
 export async function focusNiriSession(session, execFileAsync, env = process.env, options = {}) {
   if (!env.NIRI_SOCKET) return { ok: false, error: "Niri is not available; focus did nothing." };
-  const sessionId = resolvePiSessionIdentity(session, {
-    env,
-    readFileSync: options.readFileSync,
-    existsSync: options.existsSync,
-  });
-  if (!sessionId) {
+  const record =
+    session && typeof session === "object" ? session : { sessionId: String(session ?? "") };
+  const placementOptions = { ...options, env };
+  if (!resolvePiSessionIdentity(record, placementOptions) && !canonicalGhosttyTerminalKey(record)) {
     return {
       ok: false,
       error: "Exact Pi identity is unavailable; reload that Pi tab and try again.",
     };
   }
+  const readWindows = async () => {
+    const result = await execFileAsync("niri", ["msg", "-j", "windows"], { env });
+    const windows = JSON.parse(String(result.stdout ?? "[]"));
+    if (!Array.isArray(windows)) throw new Error("Unexpected Niri window data");
+    return windows;
+  };
   let windows;
   try {
-    const result = await execFileAsync("niri", ["msg", "-j", "windows"], { env });
-    windows = JSON.parse(String(result.stdout ?? "[]"));
-  } catch {
-    return { ok: false, error: "Could not inspect Niri windows; focus did nothing." };
-  }
-  if (!Array.isArray(windows)) {
-    return { ok: false, error: "Unexpected Niri window data; focus did nothing." };
+    windows = await readWindows();
+  } catch (error) {
+    return {
+      ok: false,
+      error:
+        error instanceof Error && error.message === "Unexpected Niri window data"
+          ? "Unexpected Niri window data; focus did nothing."
+          : "Could not inspect Niri windows; focus did nothing.",
+    };
   }
-  const record = session && typeof session === "object" ? session : {};
-  const target = resolveExactGhosttyWindow(windows, sessionId, record);
-  if (!target) {
+  const placed = placeSessionWindow(windows, record, placementOptions);
+  if (!placed) {
     return {
       ok: false,
-      error: "Pi identity did not resolve to exactly one Ghostty window; focus did nothing.",
+      error: "That session did not resolve to exactly one Ghostty window; focus did nothing.",
     };
   }
+  const target = placed.window;
+  const targetId = Number(target.id);
+  const focusWindow = () =>
+    execFileAsync("niri", ["msg", "action", "focus-window", "--id", String(targetId)], { env });
+  if (placed.placement === "title") {
+    try {
+      await focusWindow();
+      return { ok: true, windowId: targetId };
+    } catch {
+      return { ok: false, error: "Niri rejected the exact focus request; focus did nothing." };
+    }
+  }
+
+  const presented = await (options.presentSurface ?? presentGhosttySurface)({
+    execFileAsync,
+    env,
+    hostPid: Number(target.pid),
+    terminalFamily: record.terminalFamily,
+    surfaceId: record.terminalSurfaceId,
+  });
   try {
-    await execFileAsync("niri", ["msg", "action", "focus-window", "--id", String(target.id)], {
-      env,
-    });
-    return { ok: true, windowId: target.id };
+    await focusWindow();
   } catch {
-    return { ok: false, error: "Niri rejected the exact focus request; focus did nothing." };
+    return {
+      ok: false,
+      windowId: targetId,
+      presented: false,
+      error: presented.ok
+        ? "Presented the hidden tab, but Niri rejected the window focus request."
+        : "Niri rejected the exact focus request; focus did nothing.",
+    };
+  }
+  if (!presented.ok) {
+    return {
+      ok: false,
+      windowId: targetId,
+      presented: false,
+      error: `Focused the Ghostty window, but could not present the hidden tab (${presented.error}); select it manually.`,
+    };
+  }
+  if (!canVerifyTabVisibility(record, placementOptions)) {
+    // Nothing this session writes is readable from the compositor, so the presented tab cannot be
+    // confirmed. The action succeeded; the outcome is reported without claiming proof.
+    return { ok: true, windowId: targetId, presented: true, verified: false };
+  }
+  const sleep =
+    options.sleep ??
+    ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  for (let attempt = 0; attempt < PRESENT_VERIFY_ATTEMPTS; attempt += 1) {
+    if (attempt > 0) await sleep(PRESENT_VERIFY_DELAY_MS);
+    try {
+      const current = await readWindows();
+      const confirmed = placeSessionWindow(current, record, placementOptions);
+      if (confirmed?.placement === "title" && Number(confirmed.window.id) === targetId) {
+        return { ok: true, windowId: targetId, presented: true, verified: true };
+      }
+    } catch {
+      break;
+    }
   }
+  return {
+    ok: false,
+    windowId: targetId,
+    presented: false,
+    error:
+      "Focused the Ghostty window, but the hidden tab did not become visible; select it manually.",
+  };
 }

package/src/common/session-cards.mjs

@@ -54,7 +54,7 @@ export function comparePublisherRepresentatives(left, right) {
 /**
  * @param {SessionLike[]} [sessions]
  * @param {Set<string> | null} [allowedCardIds]
- * @returns {Array<SessionLike & {cardId: string; publisherCount: number; publisherIds: string[]; publisherRecordKeys: string[]}>}
+ * @returns {Array<SessionLike & {cardId: string; publisherCount: number; publisherIds: string[]; publisherRecordKeys: string[]; publisherSessionIds: string[]}>}
  */
 export function projectSessionCards(sessions = [], allowedCardIds = null) {
   /** @type {Map<string, SessionLike[]>} */
@@ -67,7 +67,7 @@ export function projectSessionCards(sessions = [], allowedCardIds = null) {
     groups.set(cardId, group);
   }
 
-  /** @type {Array<SessionLike & {cardId: string; publisherCount: number; publisherIds: string[]; publisherRecordKeys: string[]}>} */
+  /** @type {Array<SessionLike & {cardId: string; publisherCount: number; publisherIds: string[]; publisherRecordKeys: string[]; publisherSessionIds: string[]}>} */
   const cards = [];
   for (const [cardId, group] of groups) {
     const ordered = [...group].sort(comparePublisherRepresentatives);
@@ -79,6 +79,9 @@ export function projectSessionCards(sessions = [], allowedCardIds = null) {
       publisherCount: group.length,
       publisherIds: group.map((session) => String(session.publisherId ?? "")).filter(Boolean),
       publisherRecordKeys: group.map(sessionRecordKey),
+      publisherSessionIds: [
+        ...new Set(group.map((session) => String(session.sessionId ?? "")).filter(Boolean)),
+      ],
     });
   }
   return cards;

package/src/common/status-report.mjs

@@ -26,6 +26,57 @@ export function formatBrokerRuntimeStatus(result) {
   if (typeof runtime.windowVisible === "boolean") {
     lines.push(`surface visible: ${runtime.windowVisible ? "yes" : "no"}`);
   }
+  if (typeof runtime.rendererCardCount === "number") {
+    const hidden =
+      typeof runtime.rendererHiddenTabCardCount === "number"
+        ? ` (${runtime.rendererHiddenTabCardCount} hidden tabs)`
+        : "";
+    lines.push(`cards on focused workspace: ${runtime.rendererCardCount}${hidden}`);
+  }
+  if (typeof runtime.surfaceBindingCount === "number") {
+    lines.push(`remembered tab windows: ${runtime.surfaceBindingCount}`);
+  }
+  if (typeof runtime.agentTabCount === "number") {
+    lines.push(`agent tabs discovered: ${runtime.agentTabCount}`);
+  }
+  if (runtime.themeName) {
+    lines.push(`theme: ${runtime.themeName} (${runtime.themeScheme ?? "unknown"})`);
+  }
+  if (runtime.agentScanError) {
+    lines.push(`agent discovery error: ${runtime.agentScanError}`);
+  }
+  if (typeof runtime.heightRepairState === "string") {
+    const repaired = Number(runtime.heightRepairCount ?? 0);
+    lines.push(
+      `window height repair: ${runtime.heightRepairState}${repaired > 0 ? ` (${repaired} restored to automatic)` : ""}`,
+    );
+  }
+  if (typeof runtime.tabInventoryState === "string") {
+    const detail =
+      runtime.tabInventoryState === "ready"
+        ? ` (${runtime.tabInventoryFrameCount ?? 0} Ghostty windows, ${runtime.tabInventoryTabCount ?? 0} tabs)`
+        : runtime.tabInventoryDetail
+          ? ` (${runtime.tabInventoryDetail})`
+          : "";
+    lines.push(`tab inventory: ${runtime.tabInventoryState}${detail}`);
+  }
+  if (typeof runtime.akTaskState === "string") {
+    if (runtime.akTaskState === "ok") {
+      const orphaned = Number(runtime.akTaskOrphanCount ?? 0);
+      lines.push(
+        `AK task refs: ok (${runtime.akTaskClaimCount ?? 0} live claims, ${runtime.akTaskDeferredCount ?? 0} deferred${orphaned > 0 ? `, ${orphaned} orphaned claims` : ""})`,
+      );
+    } else if (runtime.akTaskState !== "disabled") {
+      lines.push(
+        `AK task refs: ${runtime.akTaskState}${runtime.akTaskError ? ` (${runtime.akTaskError})` : ""}`,
+      );
+    }
+  }
+  if (typeof runtime.unplacedSurfaceCount === "number" && runtime.unplacedSurfaceCount > 0) {
+    lines.push(
+      `unplaced hidden tabs: ${runtime.unplacedSurfaceCount} (placed once the tab inventory or a visible title reveals their window)`,
+    );
+  }
   if (runtime.error) {
     lines.push(`error: ${runtime.error}`);
   }