@kabmo-labs/kabmo 0.3.1 → 0.4.0

package/src/shared/lib/workspace/left-dock.ts

@@ -0,0 +1,197 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The LEFT dock: which view fills it, and which panels may live there.
+ *
+ * The left column used to be the session sidebar and nothing else. It is now a
+ * DOCK with a view on it, exactly as the right column is — the sessions list is
+ * the built-in view, and a plugin panel can be placed beside it by the user.
+ *
+ * Three decisions are encoded here rather than at a call site:
+ *
+ * - **The dock is OPTIONAL and OFF by default.** Its activity bar is a setting,
+ *   and while it is off the dock shows only its active view with no rail and no
+ *   second width to reserve. That is what makes the feature free for the many
+ *   users who never place a panel on the left: nothing renders, nothing is
+ *   measured, and no extra panel competes with the chat for the group's budget.
+ * - **Placement is the USER's, never the plugin's.** A plugin keeps registering
+ *   `app.rightPanel(...)`; where it is drawn is a per-install preference. That
+ *   is what keeps ONE id (`plugin:<id>`) meaning one panel — the id the server
+ *   gates the bundle with, the enablement set stores, the width map keys and the
+ *   stored order ranks. A second slot name would have split all four.
+ * - **The sessions view cannot be moved.** It is the reason the left column
+ *   exists, and moving it would leave a chat with no way to reach another one.
+ *
+ * Stored GLOBAL (`app_settings.omp_left_panels`), like the right panel's order:
+ * the dock lists the same panels in every session, so a per-session placement
+ * would move the user's own arrangement when they picked another chat.
+ */
+
+import { readKabmoSetting, writeSetting } from '@/shared/lib/settings/client';
+import { pluginKeyOf, pluginSlotOf, type PluginPanelSlot } from '@/shared/lib/workspace/panel-ids';
+
+/** `app_settings` key holding the dock's own state. */
+export const LEFT_DOCK_SETTING_KEY = 'omp_left_panels';
+
+/** The built-in view that owns the left column unless the user places another. */
+export const SESSIONS_VIEW_ID = 'sessions';
+
+/**
+ * Where a panel is drawn.
+ *
+ * `editor` is the third destination and it is the one that makes a two-panel
+ * plugin coherent: `session-info` registers a `rightPanel` AND a `panel`, and
+ * with per-instance placement they are independent — either may sit on the left,
+ * the other may stay right or take the editor column. Placement is per PANEL, so
+ * moving one never drags its sibling along.
+ *
+ * The left column holds ONE panel, and a plugin's second panel goes to the
+ * editor column — that is what its `panel` slot is FOR. A second left pane was
+ * built and removed: it made the left column two columns' worth of width for a
+ * plugin that already had a home for its second panel, and a pane with no
+ * switcher is a surface whose occupant nothing on screen names.
+ */
+export type PanelSide = 'left' | 'right' | 'editor';
+
+/** The destinations a PLUGIN panel may be placed on. */
+export const PLUGIN_SIDES: readonly PanelSide[] = ['left', 'right', 'editor'];
+
+/**
+ * Where a panel may go, given its SLOT.
+ *
+ * Not every slot can use every destination, and the rule is the slot's shape:
+ *
+ * - `rightPanel` is a VIEW — an activity-bar button and a body in a column — so
+ *   it may sit on the left dock or on the right, never in the editor column
+ *   (which a takeover owns whole).
+ * - `panel` is a TAKEOVER — it draws the editor column with no tab strip and no
+ *   chrome — so it may sit there and nowhere else. A takeover on a rail would be
+ *   a button that opens a column that is not the one it is on.
+ */
+export function ridesSides(slot: PluginPanelSlot | null): readonly PanelSide[] {
+  if (slot === 'panel') return ['editor'];
+  if (slot === 'rightPanel') return ['left', 'right'];
+  return [];
+}
+
+/** The dock's stored state, validated. */
+export interface LeftDockState {
+  /** Whether the dock's activity bar is drawn at all. OFF unless set. */
+  enabled: boolean;
+  /** Panel ids the user placed on the left dock, in bar order. */
+  panels: string[];
+}
+
+const EMPTY: LeftDockState = { enabled: false, panels: [] };
+
+/**
+ * The ids that may live on the left.
+ *
+ * The sessions view is the dock's own; anything else must be a plugin panel —
+ * a bare built-in id (`git`, `files`) names a view whose width slot, floor and
+ * workspace gate were all declared for the RIGHT column, and moving it is a
+ * second feature rather than a placement.
+ */
+export function isLeftDockPanelId(value: unknown): value is string {
+  if (value === SESSIONS_VIEW_ID) return true;
+  return pluginKeyOf(value) !== null;
+}
+
+/**
+ * The stored state, validated.
+ *
+ * A row this build does not recognise is DROPPED rather than kept: unlike the
+ * right panel's order, this list is also the enablement of the dock's buttons,
+ * so a stale id would draw a button that resolves to nothing.
+ */
+export function readLeftDock(): LeftDockState {
+  const stored = readKabmoSetting<unknown>(LEFT_DOCK_SETTING_KEY);
+  if (typeof stored !== 'object' || stored === null) return EMPTY;
+  const raw = stored as { enabled?: unknown; panels?: unknown };
+  const panels: string[] = [];
+  const seen = new Set<string>();
+  if (Array.isArray(raw.panels)) {
+    for (const value of raw.panels) {
+      if (!isLeftDockPanelId(value) || value === SESSIONS_VIEW_ID || seen.has(value)) continue;
+      seen.add(value);
+      panels.push(value);
+    }
+  }
+  return { enabled: raw.enabled === true, panels };
+}
+
+/** Persist one change to the dock, keeping the other half. */
+export function writeLeftDock(patch: Partial<LeftDockState>): LeftDockState {
+  const current = readLeftDock();
+  const next: LeftDockState = {
+    enabled: patch.enabled ?? current.enabled,
+    panels: patch.panels
+      ? [
+          ...new Set(
+            patch.panels.filter(
+              (id) => isLeftDockPanelId(id) && ridesSides(pluginSlotOf(id)).includes('left'),
+            ),
+          ),
+        ]
+      : current.panels,
+  };
+  writeSetting(LEFT_DOCK_SETTING_KEY, next);
+  return next;
+}
+
+/**
+ * Place a plugin panel on the left, or take it back to the right.
+ *
+ * **Placing a panel turns the rail ON.** The rail exists to reach the panels on
+ * it, so a successful placement with the rail still off is a move with no
+ * button, no view and nothing on screen to undo it — the settings row would be
+ * the only control, which is the state a user reads as broken. The switch is
+ * written in the SAME state as the placement, so no reader can observe one
+ * without the other.
+ *
+ * Moving a panel back does NOT turn the rail off: that switch is the user's, and
+ * the dock may still be worth showing without this panel on it.
+ */
+export function setPanelSide(panelId: string, side: PanelSide): LeftDockState {
+  if (!isLeftDockPanelId(panelId) || panelId === SESSIONS_VIEW_ID) return readLeftDock();
+  // A destination the slot cannot use is refused, not stored: a `panel`
+  // takeover on a rail, or a view inside the editor column, is a placement
+  // that could never be drawn.
+  if (!ridesSides(pluginSlotOf(panelId)).includes(side)) return readLeftDock();
+  const current = readLeftDock();
+  const placed = current.panels.includes(panelId);
+  if (side === 'left') {
+    if (placed && current.enabled) return current;
+    const panels = placed ? current.panels : [...current.panels, panelId];
+    return writeLeftDock({ enabled: true, panels });
+  }
+  if (!placed) return current;
+  return writeLeftDock({ panels: current.panels.filter((id) => id !== panelId) });
+}
+
+/**
+ * Which side a panel is drawn on.
+ *
+ * The sessions view is left by construction; a plugin panel is left only while
+ * the user has placed it there; a built-in view is always right.
+ */
+export function panelSideOf(panelId: string, dock: LeftDockState = readLeftDock()): PanelSide {
+  if (panelId === SESSIONS_VIEW_ID) return 'left';
+  const key = pluginKeyOf(panelId) ?? panelId;
+  if (dock.panels.includes(key)) return 'left';
+  // A takeover's home is the editor column: that is the only place its slot can
+  // be drawn, so it is where it is when the user has not moved it.
+  if (pluginSlotOf(panelId) === 'panel') return 'editor';
+  return 'right';
+}
+
+/**
+ * The left column's views in bar order: the dock's own view, then every placed
+ * plugin in the order they were placed.
+ */
+export function leftPanelIds(dock: LeftDockState = readLeftDock()): string[] {
+  return [SESSIONS_VIEW_ID, ...dock.panels];
+}

package/src/shared/lib/workspace/panel-ids.test.ts

@@ -13,24 +13,48 @@
  */
 
 import { test, expect, describe } from 'bun:test';
-import { isPanelId, pluginIdOf, pluginKeyOf, pluginPanelKey } from '@/shared/lib/workspace/panel-ids';
+import {
+  isPanelId,
+  migrateLegacyPanelId,
+  pluginEnablementKey,
+  pluginIdOf,
+  pluginKeyOf,
+  pluginPanelKey,
+  pluginSlotOf,
+} from '@/shared/lib/workspace/panel-ids';
 
 describe('pluginPanelKey', () => {
-  test('builds the id from the plugin id', () => {
-    expect(pluginPanelKey('hello')).toBe('plugin:hello');
+  test('names ONE panel: the plugin id AND the slot', () => {
+    expect(pluginPanelKey('hello', 'rightPanel')).toBe('plugin:hello:rightPanel');
+    expect(pluginPanelKey('hello', 'panel')).toBe('plugin:hello:panel');
+    // Two panels of one plugin are two keys, which is what lets a placement and
+    // a width follow one of them without dragging the other along.
+    expect(pluginPanelKey('hello', 'panel')).not.toBe(pluginPanelKey('hello', 'rightPanel'));
+  });
+});
+
+describe('pluginEnablementKey', () => {
+  test('names the PLUGIN, whatever it contributes', () => {
+    // Enablement is per plugin: the switch says "Disable <plugin>" and the
+    // server gates that plugin's bundle on this key, so one switch is one id.
+    expect(pluginEnablementKey('hello')).toBe('plugin:hello');
   });
 });
 
 describe('pluginKeyOf', () => {
-  test('accepts a well-formed plugin key', () => {
-    expect(pluginKeyOf('plugin:hello')).toBe('plugin:hello');
+  test('accepts both forms, normalizing the retired one to rightPanel', () => {
+    expect(pluginKeyOf('plugin:hello:rightPanel')).toBe('plugin:hello:rightPanel');
+    expect(pluginKeyOf('plugin:hello:panel')).toBe('plugin:hello:panel');
+    // The form that shipped, before the slot segment: the only reachable slot
+    // then was the right panel, so that is where such a row still points.
+    expect(pluginKeyOf('plugin:hello')).toBe('plugin:hello:rightPanel');
   });
 
-  test('rejects a bare prefix and an extra segment', () => {
+  test('rejects a bare prefix, a slash, a third segment and an unknown slot', () => {
     expect(pluginKeyOf('plugin:')).toBeNull();
-    // The id used to carry a panel segment; a blob written then must not be
-    // adopted as a plugin id that no registry can report.
     expect(pluginKeyOf('plugin:hello/greeter')).toBeNull();
+    expect(pluginKeyOf('plugin:a:b:c')).toBeNull();
+    expect(pluginKeyOf('plugin:hello:headerPanel')).toBeNull();
   });
 
   test('rejects a built-in view id and a non-string', () => {
@@ -40,9 +64,33 @@ describe('pluginKeyOf', () => {
   });
 });
 
+describe('migrateLegacyPanelId', () => {
+  test('reports the retired form and what it becomes', () => {
+    expect(migrateLegacyPanelId('plugin:hello')).toEqual({
+      from: 'plugin:hello',
+      to: 'plugin:hello:rightPanel',
+    });
+  });
+
+  test('says nothing for a value that is already current or not a panel id', () => {
+    expect(migrateLegacyPanelId('plugin:hello:panel')).toBeNull();
+    expect(migrateLegacyPanelId('files')).toBeNull();
+    expect(migrateLegacyPanelId(null)).toBeNull();
+  });
+});
+
+describe('pluginSlotOf', () => {
+  test('names the slot, so a placement can be per panel', () => {
+    expect(pluginSlotOf('plugin:hello:panel')).toBe('panel');
+    expect(pluginSlotOf('plugin:hello')).toBe('rightPanel');
+    expect(pluginSlotOf('files')).toBeNull();
+  });
+});
+
 describe('pluginIdOf', () => {
-  test('unwraps the plugin id', () => {
+  test('unwraps the plugin id, from either form', () => {
     expect(pluginIdOf('plugin:hello')).toBe('hello');
+    expect(pluginIdOf('plugin:hello:panel')).toBe('hello');
     expect(pluginIdOf('files')).toBeNull();
   });
 });
@@ -54,8 +102,9 @@ describe('isPanelId', () => {
     expect(isPanelId('plan')).toBe(true);
   });
 
-  test('accepts a plugin key', () => {
+  test('accepts a plugin panel key, in both forms', () => {
     expect(isPanelId('plugin:hello')).toBe(true);
+    expect(isPanelId('plugin:hello:panel')).toBe(true);
   });
 
   test('rejects an unknown view and a malformed plugin key', () => {

package/src/shared/lib/workspace/panel-ids.ts

@@ -1,15 +1,26 @@
 /**
- * Panel ids: the built-in right-panel views plus the panels plugin code
- * contributes.
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Panel ids: the built-in views plus the panels plugin code contributes.
  *
- * A plugin panel's id is `plugin:<pluginId>` — one string the layout stores,
- * keys widths by, and resolves a component from. Keeping it a plain string
- * rather than a second union member is what lets the activity bar, the mobile
- * tab bar and the width map handle a plugin without each learning about it.
+ * A plugin panel's id is `plugin:<pluginId>:<slot>` — one string the layout
+ * stores, keys widths by, and resolves a component from. One plugin contributes
+ * at most one panel PER SLOT (`rightPanel`, `panel`), and a plugin may register
+ * both: `marketplace/plugins/session-info` ships a `rightPanel` and a `panel`.
+ * The slot segment is what keeps those two apart.
  *
- * There is no panel-id segment because a plugin contributes AT MOST ONE panel
- * per slot: the layout gives it one activity-bar button and one editor tab, so
- * a second id could never be reached.
+ * It was not always. The id used to carry a panel segment, then dropped it on the
+ * claim that a plugin contributes at most one panel — true per slot, false per
+ * plugin. With the editor column's slot reachable again, one id for both would
+ * make them one entry in the enablement set, one width and one placement, so
+ * moving a plugin's right panel would move its editor panel with it.
+ *
+ * The BARE form is the one that shipped and is still accepted, resolving to the
+ * `rightPanel` slot — see {@link migrateLegacyPanelId}. Writers emit the
+ * segmented form; readers accept both.
  */
 
 import { RIGHT_PANEL_TYPES, type RightPanelType } from '@/shared/lib/workspace/right-panels';
@@ -17,43 +28,120 @@ import { RIGHT_PANEL_TYPES, type RightPanelType } from '@/shared/lib/workspace/r
 /** Prefix every plugin-contributed panel id carries. */
 export const PLUGIN_PANEL_PREFIX = 'plugin:';
 
-/** `plugin:<pluginId>` for a plugin's contributed panel. */
-export function pluginPanelKey(pluginId: string): string {
+/**
+ * The slots a plugin can contribute a panel to.
+ *
+ * NOT `headerPanel`/`settingsSection`: those are not panels — one is a navbar
+ * entry, the other a settings block — and neither keys a width or a placement.
+ */
+export const PLUGIN_PANEL_SLOTS = ['rightPanel', 'panel'] as const;
+
+export type PluginPanelSlot = (typeof PLUGIN_PANEL_SLOTS)[number];
+
+/** The slot a bare `plugin:<id>` names: the form that shipped. */
+/** The slot a bare `plugin:<id>` names, where an INSTANCE key is expected. */
+export const LEGACY_PLUGIN_SLOT: PluginPanelSlot = 'rightPanel';
+
+/**
+ * `plugin:<pluginId>:<slot>` — ONE PANEL of a plugin.
+ *
+ * The key every panel-shaped store uses: the width map, the dock placement, the
+ * stored order and the active selection. Two panels of one plugin are two panels
+ * here, which is the whole point.
+ */
+export function pluginPanelKey(pluginId: string, slot: PluginPanelSlot): string {
+  return `${PLUGIN_PANEL_PREFIX}${pluginId}:${slot}`;
+}
+
+/**
+ * `plugin:<pluginId>` — the PLUGIN, not a panel.
+ *
+ * Separate from {@link pluginPanelKey} on purpose. Enablement is per PLUGIN: the
+ * Settings switch says "Disable <plugin>" and the server gates that plugin's
+ * BUNDLE on this key, so one switch has to be one id no matter how many panels
+ * the plugin contributes. Making enablement per panel would leave a plugin whose
+ * bundle is still served while half its panels are "off".
+ *
+ * This is also the form that shipped, so every stored disabled row still names a
+ * plugin and needs no migration.
+ */
+export function pluginEnablementKey(pluginId: string): string {
   return `${PLUGIN_PANEL_PREFIX}${pluginId}`;
 }
 
+function isSlot(value: string): value is PluginPanelSlot {
+  return (PLUGIN_PANEL_SLOTS as readonly string[]).includes(value);
+}
+
 /**
- * The plugin id a panel id names, or null when `value` is not one.
+ * The parts of a plugin panel id, or null.
+ *
+ * Two shapes are accepted, and the second is DELIBERATELY the one that shipped:
  *
- * The segment must be non-empty: `plugin:` is the shape a truncated write or a
- * half-typed value produces, and accepting it would key a width map and a
- * component lookup on an id no registry can ever report.
+ * - `plugin:<id>:<slot>` — the current form;
+ * - `plugin:<id>` — a stored blob, an enablement row or an order entry written
+ *   before the slot segment existed. It resolves to `rightPanel`, because that
+ *   was the only reachable slot when it was written.
+ *
+ * The plugin id is validated as ONE segment: an empty id, a slash or a third
+ * colon is a truncated write or a hand-edited blob, and accepting it would key a
+ * width map and a component lookup on an id no registry can report.
  */
-export function pluginKeyOf(value: unknown): string | null {
+export function pluginPanelParts(value: unknown): { pluginId: string; slot: PluginPanelSlot } | null {
   if (typeof value !== 'string' || !value.startsWith(PLUGIN_PANEL_PREFIX)) return null;
   const rest = value.slice(PLUGIN_PANEL_PREFIX.length);
-  if (!rest || rest.includes('/')) return null;
-  return value;
+  const pieces = rest.split(':');
+  if (pieces.length > 2) return null;
+  const [pluginId, slot] = pieces;
+  if (!pluginId || pluginId.includes('/')) return null;
+  if (slot === undefined) return { pluginId, slot: LEGACY_PLUGIN_SLOT };
+  if (!isSlot(slot)) return null;
+  return { pluginId, slot };
+}
+
+/**
+ * The PANEL INSTANCE key a stored value names, or null.
+ *
+ * A bare `plugin:<id>` normalizes to the `rightPanel` instance, because that was
+ * the only reachable slot when such a row was written — the width map, the dock
+ * placement and the stored order all read through here, so a row from an older
+ * build keeps pointing at the panel it pointed at before.
+ */
+export function pluginKeyOf(value: unknown): string | null {
+  const parts = pluginPanelParts(value);
+  return parts ? pluginPanelKey(parts.pluginId, parts.slot) : null;
+}
+
+/** Whether a stored value is the retired bare form, and what it resolves to. */
+export function migrateLegacyPanelId(value: unknown): { from: string; to: string } | null {
+  const parts = pluginPanelParts(value);
+  if (!parts || typeof value !== 'string') return null;
+  const to = pluginPanelKey(parts.pluginId, parts.slot);
+  return value === to ? null : { from: value, to };
 }
 
 /** The plugin id inside a panel id, or null. */
 export function pluginIdOf(value: unknown): string | null {
-  const key = pluginKeyOf(value);
-  return key ? key.slice(PLUGIN_PANEL_PREFIX.length) : null;
+  return pluginPanelParts(value)?.pluginId ?? null;
+}
+
+/** The slot a panel id names, or null when `value` is not a plugin panel id. */
+export function pluginSlotOf(value: unknown): PluginPanelSlot | null {
+  return pluginPanelParts(value)?.slot ?? null;
 }
 
 /**
- * Whether a stored `layout.activeRightPanel` may be adopted on load.
+ * Whether a stored `layout.activeRightPanel` / width key may be adopted on load.
  *
  * A plugin panel is accepted on the shape of its id alone: the registry is a
  * network read and the slots exist only after a bundle has been imported, so
- * requiring the panel to be present would drop a perfectly valid selection
- * every time the server is slower than the first paint. A panel whose plugin
- * has since been uninstalled renders its own "not installed" notice rather than
- * falling back silently to Files.
+ * requiring the panel to be present would drop a perfectly valid selection every
+ * time the server is slower than the first paint. A panel whose plugin has since
+ * been uninstalled renders its own "not installed" notice rather than falling
+ * back silently to Files.
  */
 export function isPanelId(value: unknown): value is string {
-  return (RIGHT_PANEL_TYPES as readonly string[]).includes(value as string) || pluginKeyOf(value) !== null;
+  return (RIGHT_PANEL_TYPES as readonly string[]).includes(value as string) || pluginPanelParts(value) !== null;
 }
 
 export type { RightPanelType };

package/src/shared/lib/workspace/sidebar-width.ts

@@ -43,6 +43,10 @@ export const DEFAULT_LEFT_PANEL_WIDTH = 280;
  * `MIN_CHAT_PANEL_WIDTH` in `panel-widths.ts`: the sidebar cannot open past 500
  * and still leave the editor (320) and a browser view (320) room on a 1440px
  * display.
+ *
+ * It was raised to 720 for a second left pane and put back when that pane was
+ * removed: the dock holds ONE panel beside the list, and a wider ceiling would
+ * only invite a column nothing else in the layout budgets for.
  */
 export const MIN_LEFT_PANEL_WIDTH = 264;
 export const MAX_LEFT_PANEL_WIDTH = 500;

package/src/shared/types/index.ts

@@ -4,6 +4,7 @@ export * from '@/shared/types/fs';
 export * from '@/shared/types/git';
 export * from '@/shared/types/chat';
 export * from '@/shared/types/schedule';
+export * from '@/shared/types/waiting';
 export * from '@/shared/types/btw';
 export * from '@/shared/types/models';
 export * from '@/shared/types/terminal';

package/src/shared/types/waiting.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A prompt held until another session finishes.
+ *
+ * The row is Kabmo's own (SQLite `waiting_prompts`): omp has no notion of a
+ * prompt that has not been sent yet, so the wait has to live somewhere that
+ * outlives the tab. Its `dependsOn` session is a SESSION ID, never a snapshot of
+ * its state — the state is re-read at each sweep, because a session that looks
+ * finished can pick up a queued follow-up a moment later.
+ */
+
+import type { Attachment, QueuedMessageModel } from '@/shared/types/chat';
+
+export type WaitingPromptStatus = 'waiting' | 'dispatched' | 'cancelled' | 'error';
+
+/** Plan/goal flags the spawn must carry (a new session has no JSONL to read). */
+export interface WaitingPromptModes {
+  plan: boolean;
+  goal: boolean;
+}
+
+export interface WaitingPrompt {
+  id: string;
+  /**
+   * The client's pending id (`new-…`) this prompt belongs to. The dispatch
+   * answers with omp's real session id, and the client moves the sidebar row
+   * across by this pairing — the same adoption the local send path performs.
+   */
+  pendingId: string | null;
+  /** The session whose completion releases this prompt. */
+  dependsOn: string;
+  /** Title of `dependsOn` at creation time, for the waiting row's own label. */
+  dependsOnTitle: string | null;
+  /** Composer text as the user typed it. */
+  prompt: string;
+  attachments: Attachment[];
+  /** Model/thinking/access snapshot, replayed at dispatch. */
+  model: QueuedMessageModel | null;
+  modes: WaitingPromptModes | null;
+  /** Absolute directory the new session spawns in, resolved at creation. */
+  cwd: string;
+  folderId: number | null;
+  status: WaitingPromptStatus;
+  /** omp's real session id, once the prompt was dispatched. */
+  sessionId: string | null;
+  /** Why the dispatch failed (status `error`). */
+  error: string | null;
+  createdAt: number;
+  updatedAt: number;
+}

package/src/shared/types/workspace.ts

@@ -30,6 +30,14 @@ export interface SessionItemData {
    *  provider/model in every tab and Kabmo instances. Absent for a session
    *  with no run row; callers fall back to the transcript's model entry. */
   runModel?: { provider: string; modelId: string };
+  /**
+   * Set on a PENDING row whose prompt is held until another session finishes.
+   *
+   * The row has no transcript and no omp id yet — it exists because the user
+   * sent a prompt that is deferred, and the cue is the only thing on screen
+   * saying so. Absent means the row is not waiting (the normal case).
+   */
+  waitingFor?: { waitId: string; sessionId: string; title: string | null };
 }
 
 /**

package/src/test-support/isolated-db.ts

@@ -23,14 +23,14 @@ import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
+import { closeDb } from '@/server/db.server';
 import { removeDir } from '@/test-support/remove-dir';
 
 let dir: string | null = null;
 
 /** Point the process at a fresh database. Call from `beforeEach`. */
 export function isolateDb(): string {
-  globalThis.__kabmoDb?.resolved?.raw.close();
-  globalThis.__kabmoDb = undefined;
+  closeDb();
 
   dir = mkdtempSync(join(tmpdir(), 'omc-db-'));
   const path = join(dir, 'db.sqlite');
@@ -40,8 +40,7 @@ export function isolateDb(): string {
 
 /** Close the handle and drop the temp directory. Call from `afterEach`. */
 export function releaseDb(): void {
-  globalThis.__kabmoDb?.resolved?.raw.close();
-  globalThis.__kabmoDb = undefined;
+  closeDb();
   delete Bun.env.KABMO_DB_PATH;
   // `removeDir`, not a bare `rmSync`: a closed SQLite handle is released by the
   // OS asynchronously on Windows, so the delete races it and fails with EBUSY —