@blackbelt-technology/pi-agent-dashboard 0.5.2 → 0.5.4

package/packages/shared/src/platform/node-spawn.ts

@@ -99,59 +99,59 @@ export function toFileUrl(pathOrUrl: string): string {
   return pathToFileURL(absolute).href;
 }
 
+/**
+ * Detect whether a loader (file:// URL or raw path) is jiti.
+ *
+ * Mirrors `isTsxLoader`. jiti's hook ships under `jiti/lib/`. Used so
+ * `shouldUrlWrapEntry` can refuse to URL-wrap the entry when jiti is
+ * the loader on Windows — see the JITI VERSION CONTRACT below.
+ */
+export function isJitiLoader(loader: string | null | undefined): boolean {
+  if (!loader) return false;
+  const normalized = loader.replace(/\\/g, "/");
+  return /\/jiti\//i.test(normalized);
+}
+
 /**
  * Decide whether the entry-script position needs `file://` URL wrapping.
  *
  * Rule:
  *   - tsx loader: always raw path (tsx rejects file:// entries on every OS)
- *   - non-tsx (jiti / Node default) on POSIX: raw path
- *     (POSIX has no drive-letter / URL-scheme collision; jiti's resolver
- *      actively MISBEHAVES when handed `file://` URL entries — it
- *      normalises away the triple-slash and then treats `file:/...` as
- *      a relative specifier, producing `<cwd>/file:/...` ENOENT errors.)
- *   - non-tsx on Windows: file:// URL
+ *   - jiti loader: always raw path (jiti misnormalises file:// URL
+ *     entries on Windows — see the JITI VERSION CONTRACT below)
+ *   - any loader on POSIX: raw path (no drive-letter / URL-scheme collision)
+ *   - other / default Node resolver on Windows: file:// URL
  *     (Node parses drive letters like `B:` / `A:` as URL schemes in argv
  *      before loaders run, throwing ERR_UNSUPPORTED_ESM_URL_SCHEME.
- *      Wrapping with `file://` sidesteps the parse.)
+ *      Wrapping with `file://` sidesteps the parse. The drive-letter
+ *      heuristic in Node catches `C:\…` / `D:\…` etc., which is what
+ *      jiti relies on for the standalone install layout.)
  *
  * Keeps a `platform` parameter for testability so unit tests on a POSIX
  * host can exercise the Windows branch without mutating `process.platform`.
  *
  * !! JITI VERSION CONTRACT !!
- * The Windows-non-tsx arm relies on jiti's `file:///` triple-slash URL
- * handling. Verified-good baselines (must be one of these in the
- * offline cacache):
- *   • `@earendil-works/pi-coding-agent@0.74.x` (jiti `^2.7.0`)  — current
- *   • `@mariozechner/pi-coding-agent@0.70.x`  (jiti 2.x)        — legacy
- *
- * Both ship a jiti that correctly normalises `file:///` entries on
- * Windows. The contract was originally carved around 0.70.x in change
- * `fix-windows-entry-script-url` and re-anchored at 0.74.x in change
- * `migrate-pi-fork-to-earendil` (E.7).
- *
- * Known-broken (do NOT pin): `pi-coding-agent@0.71.x` shipping
- * `jiti@2.6.5`. That jiti version misnormalises triple-slash to
- * single-slash and prepends cwd as if the entry were a relative
- * specifier, producing `<cwd>/file:/...` ENOENT errors. Keep the
- * 0.71.x / 2.6.5 mention here so contributors recognise the
- * regression pattern if it recurs in a future jiti.
- *
- * The Electron Windows codepath defends against version drift by
- * resolving jiti from the managed dir's pinned `pi-coding-agent`
- * (currently `@earendil-works/pi-coding-agent@0.74.0`, pinned in
- * `packages/electron/offline-packages.json` and extracted into
- * `~/.pi-dashboard/` by `installStandalone()` on first launch — see
- * Defect 1 of change `fix-electron-windows-installer-and-server-bootstrap`).
- * Since the managed-dir tree is pinned, the contract holds regardless
- * of what jiti is on the user's PATH.
- *
- * If a future change bumps the offline-cacache `pi-coding-agent` pin to
- * a version OUTSIDE the verified baselines, RE-VERIFY this contract on
- * Windows manually (run a packaged Electron app on Win10 + Win11) and
- * either:
- *   1. Update the contract (fix the file:// URL handling expectation), OR
- *   2. Add a per-jiti-version branch here, OR
- *   3. Switch the bundled loader to tsx (which has its own contract).
+ * jiti — at every version verified on Windows so far, including the
+ * current pin `jiti@^2.7.0` shipped under
+ * `@earendil-works/pi-coding-agent@0.74.x` — MISHANDLES `file:///`
+ * triple-slash URL entries on Windows. Symptom: the entry is rewritten
+ * to single-slash `file:/C:/…` and then re-resolved relative to cwd,
+ * yielding `Cannot find module 'file:///<cwd>/file:/C:/…/cli.ts'`.
+ *
+ * This was verified live in a Windows 11 standalone install
+ * (Node 22.18.0 + jiti 2.7.0) and is the reason the Windows branch of
+ * this function now returns `false` for jiti loaders. Node's own
+ * drive-letter heuristic accepts raw `C:\…` argv entries, so the URL
+ * wrap is unnecessary for the common standalone-install layout where
+ * pi + the dashboard live under `C:\Users\<u>\.pi-dashboard\…`.
+ *
+ * Earlier baselines (`@mariozechner/pi-coding-agent@0.70.x`,
+ * `jiti@2.6.5` in `pi-coding-agent@0.71.x`) exhibited the same or
+ * worse breakage; we no longer attempt to special-case any single
+ * jiti version. If a future jiti release fixes file:/// handling and
+ * we want to URL-wrap again (e.g. to cover `B:` / `A:` drives outside
+ * Node's heuristic), narrow the rule here and add a per-version
+ * branch — re-verify on real Windows before changing.
  *
  * Locked by `node-spawn-jiti-contract.test.ts`.
  */
@@ -160,6 +160,7 @@ export function shouldUrlWrapEntry(
   platform: NodeJS.Platform = process.platform,
 ): boolean {
   if (isTsxLoader(loader)) return false;
+  if (isJitiLoader(loader)) return false;
   return platform === "win32";
 }
 

package/packages/shared/src/plugin-bridge-register.ts

@@ -2,26 +2,47 @@
  * Plugin bridge entry management in pi's settings.json.
  *
  * Manages `dashboard-<plugin-id>` keys in a dedicated
- * `dashboardPluginBridges` object inside settings.json.
+ * `dashboardPluginBridges` object inside settings.json AND mirrors each
+ * managed bridge path into the top-level `packages[]` array so
+ * pi-coding-agent (which only reads `packages[]`) actually loads the
+ * bridge as an extension.
+ *
+ * See change: fix-pi-flows-end-to-end (Group 1).
+ *
+ * Ownership tracking:
+ * - `dashboardPluginBridges["dashboard-<id>"] = "<absPath>"`  — managed key
+ * - `_dashboardManagedPackages["<absPath>"] = "<id>"`         — ownership map
+ * - `packages[]` gains a plain string entry `"<absPath>"`     — readable by pi
  *
  * Rules:
- * - Only touches entries under the `dashboardPluginBridges` key.
- * - NEVER modifies user-owned `packages[]` entries.
+ * - Only touches entries under managed keys / paths.
+ * - NEVER modifies user-owned `packages[]` entries (those without an entry
+ *   in `_dashboardManagedPackages`).
  * - Uses atomic write (tmp + rename) for all updates.
  * - Detects path conflicts (existing entry with mismatched path).
+ *
+ * Escape hatch: setting `PI_DASHBOARD_DISABLE_PLUGIN_BRIDGE_PACKAGES_WRITE=1`
+ * skips the `packages[]` write (rollback parity with pre-change behavior).
  */
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import type { BridgeLoadSource } from "./dashboard-plugin/plugin-status.js";
 
 export interface PluginBridgeRegisterOptions {
   homedir?: string;
+  /** Override env-driven escape hatch for tests. */
+  skipPackagesWrite?: boolean;
 }
 
 export type PluginBridgeConflict =
   | { type: "ok" }
   | { type: "conflict"; existingPath: string; newPath: string };
 
+const MANAGED_PREFIX = "dashboard-";
+const OWNERSHIP_KEY = "_dashboardManagedPackages";
+const ENV_SKIP = "PI_DASHBOARD_DISABLE_PLUGIN_BRIDGE_PACKAGES_WRITE";
+
 function getSettingsPath(homedir?: string): string {
   const home = homedir ?? process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
   return path.join(home, ".pi", "agent", "settings.json");
@@ -55,11 +76,95 @@ function getManagedBridges(
   return {};
 }
 
-const MANAGED_PREFIX = "dashboard-";
+function getOwnershipMap(
+  settings: Record<string, unknown>,
+): Record<string, string> {
+  const val = settings[OWNERSHIP_KEY];
+  if (val && typeof val === "object" && !Array.isArray(val)) {
+    return val as Record<string, string>;
+  }
+  return {};
+}
+
+function getPackages(settings: Record<string, unknown>): unknown[] {
+  const val = settings.packages;
+  return Array.isArray(val) ? val : [];
+}
+
+function packageEntryPath(entry: unknown): string | null {
+  if (typeof entry === "string") return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const src = (entry as Record<string, unknown>).source;
+    if (typeof src === "string") return src;
+  }
+  return null;
+}
+
+function shouldSkipPackagesWrite(opts: PluginBridgeRegisterOptions): boolean {
+  if (opts.skipPackagesWrite === true) return true;
+  if (opts.skipPackagesWrite === false) return false;
+  return process.env[ENV_SKIP] === "1";
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Pure helpers (Task 1.1)
+// ─────────────────────────────────────────────────────────────────────────
+
+/**
+ * Ensure `packages[]` contains `bridgePath` and record ownership.
+ * No-op when entry already present. Mutates `packages` and `ownership` in place.
+ * Returns `true` if a new entry was added.
+ */
+export function ensurePackageEntry(
+  packages: unknown[],
+  ownership: Record<string, string>,
+  bridgePath: string,
+  ownerMarker: string,
+): boolean {
+  const already = packages.some((e) => packageEntryPath(e) === bridgePath);
+  ownership[bridgePath] = ownerMarker; // record ownership regardless
+  if (already) return false;
+  packages.push(bridgePath);
+  return true;
+}
+
+/**
+ * Remove a managed `packages[]` entry whose ownership matches `ownerMarker`.
+ * Leaves user-added entries (no matching ownership record) untouched.
+ * Mutates `packages` and `ownership` in place. Returns `true` if removed.
+ */
+export function removePackageEntry(
+  packages: unknown[],
+  ownership: Record<string, string>,
+  ownerMarker: string,
+): boolean {
+  const owned = Object.entries(ownership)
+    .filter(([, owner]) => owner === ownerMarker)
+    .map(([p]) => p);
+  if (owned.length === 0) return false;
+  let removed = false;
+  for (const p of owned) {
+    const idx = packages.findIndex((e) => packageEntryPath(e) === p);
+    if (idx >= 0) {
+      packages.splice(idx, 1);
+      removed = true;
+    }
+    delete ownership[p];
+  }
+  return removed;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Public API (Tasks 1.2, 1.3, 1.4)
+// ─────────────────────────────────────────────────────────────────────────
 
 /**
  * Register a plugin's bridge entry in pi's settings.json.
  *
+ * Writes to BOTH:
+ *  - `dashboardPluginBridges["dashboard-<pluginId>"]` (forward-compat)
+ *  - `packages[]` + ownership record (so pi-coding-agent loads the bridge)
+ *
  * Returns { type: "conflict", existingPath, newPath } if a
  * `dashboard-<pluginId>` key already exists but points to a different path.
  * In that case the settings.json is NOT modified.
@@ -74,25 +179,64 @@ export function registerPluginBridge(
   const settingsPath = getSettingsPath(opts.homedir);
   const settings = readSettings(settingsPath);
   const managed = getManagedBridges(settings);
+  const ownership = getOwnershipMap(settings);
+  const packages = getPackages(settings);
   const key = MANAGED_PREFIX + pluginId;
+  const ownerMarker = key;
 
   const existing = managed[key];
-  if (existing) {
-    if (existing === bridgePath) return { type: "ok" }; // already registered
-    return { type: "conflict", existingPath: existing, newPath: bridgePath };
+  if (existing && existing !== bridgePath) {
+    // Self-heal: if the existing path no longer resolves on disk (typical
+    // after a dev-monorepo → deployed-bundle path change), silently replace.
+    // This avoids cosmetic "Bridge path conflict" errors on every restart
+    // when the user switches between dev and production launch sources.
+    // See change: add-plugin-activation-ui (deployment-fix follow-up).
+    let existingStillOnDisk = true;
+    try {
+      existingStillOnDisk = fs.existsSync(existing);
+    } catch {
+      existingStillOnDisk = false;
+    }
+    if (existingStillOnDisk) {
+      return { type: "conflict", existingPath: existing, newPath: bridgePath };
+    }
+    // Strip the stale entry and matching ownership/packages mirrors so the
+    // subsequent register block below installs the new path cleanly.
+    delete managed[key];
+    if (ownership[existing] === ownerMarker) delete ownership[existing];
+    const idx = packages.indexOf(existing);
+    if (idx >= 0) packages.splice(idx, 1);
+  }
+
+  let mutated = false;
+  if (!managed[key]) {
+    managed[key] = bridgePath;
+    settings.dashboardPluginBridges = managed;
+    mutated = true;
   }
 
-  managed[key] = bridgePath;
-  settings.dashboardPluginBridges = managed;
-  writeSettings(settingsPath, settings);
-  console.info(`[plugin-bridge] Registered bridge for plugin "${pluginId}": ${bridgePath}`);
+  if (!shouldSkipPackagesWrite(opts)) {
+    const ownershipBefore = ownership[bridgePath];
+    const added = ensurePackageEntry(packages, ownership, bridgePath, ownerMarker);
+    if (added || ownershipBefore !== ownerMarker) {
+      mutated = true;
+      settings.packages = packages;
+      settings[OWNERSHIP_KEY] = ownership;
+    }
+  }
+
+  if (mutated) {
+    writeSettings(settingsPath, settings);
+    console.info(`[plugin-bridge] Registered bridge for plugin "${pluginId}": ${bridgePath}`);
+  }
   return { type: "ok" };
 }
 
 /**
  * Remove a plugin's bridge entry from pi's settings.json.
- * No-op if the entry does not exist.
- * NEVER touches entries without the `dashboard-` prefix.
+ * Removes BOTH the `dashboardPluginBridges` key AND the matching ownership-marked
+ * `packages[]` entry. No-op if neither exists.
+ * NEVER touches entries without matching ownership.
  */
 export function deregisterPluginBridge(
   pluginId: string,
@@ -101,14 +245,29 @@ export function deregisterPluginBridge(
   const settingsPath = getSettingsPath(opts.homedir);
   const settings = readSettings(settingsPath);
   const managed = getManagedBridges(settings);
+  const ownership = getOwnershipMap(settings);
+  const packages = getPackages(settings);
   const key = MANAGED_PREFIX + pluginId;
+  const ownerMarker = key;
+
+  let mutated = false;
 
-  if (!(key in managed)) return; // nothing to remove
+  if (key in managed) {
+    delete managed[key];
+    settings.dashboardPluginBridges = managed;
+    mutated = true;
+  }
+
+  if (removePackageEntry(packages, ownership, ownerMarker)) {
+    settings.packages = packages;
+    settings[OWNERSHIP_KEY] = ownership;
+    mutated = true;
+  }
 
-  delete managed[key];
-  settings.dashboardPluginBridges = managed;
-  writeSettings(settingsPath, settings);
-  console.info(`[plugin-bridge] Deregistered bridge for plugin "${pluginId}"`);
+  if (mutated) {
+    writeSettings(settingsPath, settings);
+    console.info(`[plugin-bridge] Deregistered bridge for plugin "${pluginId}"`);
+  }
 }
 
 /**
@@ -127,6 +286,57 @@ export function registerAllPluginBridges(
   return results;
 }
 
+/**
+ * One-shot reconciliation (Task 1.4): for each entry in
+ * `dashboardPluginBridges`, ensure a matching `packages[]` entry exists with
+ * the same ownership marker. Heals installs that pre-date the dual-write.
+ *
+ * Returns a list of `{ pluginId, bridgePath, action }` summaries — `"added"`
+ * when a new packages[] entry was inserted, `"already"` when no change needed.
+ */
+export function reconcilePluginBridgePackages(
+  opts: PluginBridgeRegisterOptions = {},
+): Array<{ pluginId: string; bridgePath: string; action: "added" | "already" }> {
+  if (shouldSkipPackagesWrite(opts)) return [];
+  const settingsPath = getSettingsPath(opts.homedir);
+  const settings = readSettings(settingsPath);
+  const managed = getManagedBridges(settings);
+  const ownership = getOwnershipMap(settings);
+  const packages = getPackages(settings);
+
+  const summary: Array<{ pluginId: string; bridgePath: string; action: "added" | "already" }> = [];
+  let mutated = false;
+
+  for (const [key, bridgePath] of Object.entries(managed)) {
+    if (!key.startsWith(MANAGED_PREFIX)) continue;
+    const pluginId = key.slice(MANAGED_PREFIX.length);
+    const ownershipBefore = ownership[bridgePath];
+    const added = ensurePackageEntry(packages, ownership, bridgePath, key);
+    summary.push({ pluginId, bridgePath, action: added ? "added" : "already" });
+    if (added) mutated = true;
+    // `ensurePackageEntry` already wrote `ownership[bridgePath] = key`
+    // unconditionally. Compare the previous value (`ownershipBefore`) to
+    // detect whether persistence is needed for the ownership marker. This
+    // fixes a bug where the marker was set in memory but the file write
+    // was skipped because the *current* ownership equalled `key`.
+    if (ownershipBefore !== key) mutated = true;
+  }
+
+  if (mutated) {
+    settings.packages = packages;
+    settings[OWNERSHIP_KEY] = ownership;
+    writeSettings(settingsPath, settings);
+    for (const { pluginId, bridgePath, action } of summary) {
+      if (action === "added") {
+        console.info(
+          `[plugin-bridge] Reconciled packages[] entry for plugin "${pluginId}": ${bridgePath}`,
+        );
+      }
+    }
+  }
+  return summary;
+}
+
 /**
  * List all currently managed plugin bridge entries.
  */
@@ -137,3 +347,50 @@ export function listManagedBridges(
   const settings = readSettings(settingsPath);
   return getManagedBridges(settings);
 }
+
+/**
+ * Inspect ownership map (for diagnostics / health).
+ */
+export function listManagedPackageOwnership(
+  opts: PluginBridgeRegisterOptions = {},
+): Record<string, string> {
+  const settingsPath = getSettingsPath(opts.homedir);
+  const settings = readSettings(settingsPath);
+  return getOwnershipMap(settings);
+}
+
+/**
+ * Classify where a bridge path is registered in pi's settings.
+ *
+ * Precedence (intentional — packages[] is what pi actually loads, so it wins
+ * even when both keys point at the same path):
+ *   1. matching entry in `packages[]` → `"packages[]"`
+ *   2. matching value in `dashboardPluginBridges` → `"dashboardPluginBridges"`
+ *   3. no match → `"none"`
+ *
+ * Used by `/api/health.plugins[].bridgeLoadedFrom`. See change:
+ * fix-pi-flows-end-to-end (Group 2, task 2.2).
+ */
+export function classifyBridgeSource(
+  settings: unknown,
+  bridgePath: string,
+): BridgeLoadSource {
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    return "none";
+  }
+  const s = settings as Record<string, unknown>;
+
+  const packages = Array.isArray(s.packages) ? s.packages : [];
+  for (const entry of packages) {
+    if (packageEntryPath(entry) === bridgePath) return "packages[]";
+  }
+
+  const bridges = s.dashboardPluginBridges;
+  if (bridges && typeof bridges === "object" && !Array.isArray(bridges)) {
+    for (const value of Object.values(bridges as Record<string, unknown>)) {
+      if (value === bridgePath) return "dashboardPluginBridges";
+    }
+  }
+
+  return "none";
+}

package/packages/shared/src/protocol.ts

@@ -3,6 +3,19 @@
  */
 import type { DashboardEvent, CommandInfo, FlowInfo, SessionSource, ImageContent, FileEntry, TurnUsage, ContextUsage, ModelInfo, ProviderInfo, PiSessionInfo, OpenSpecPhase, RoleInfo, ExtensionUiModule, DecoratorDescriptor } from "./types.js";
 
+/**
+ * Bridge -> server: mirror of pi's native steering + follow-up queues, forwarded
+ * from pi's `queue_update` event. Server caches the latest snapshot per session
+ * in `SessionUiState.pendingQueues` and broadcasts via `session_updated`.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+export interface QueueUpdateToServerMessage {
+  type: "queue_update";
+  sessionId: string;
+  steering: string[];
+  followUp: string[];
+}
+
 // ── Extension → Server ──────────────────────────────────────────────
 
 export interface SessionRegisterMessage {
@@ -372,7 +385,8 @@ export type ExtensionToServerMessage =
   | UiDataListMessage
   | ExtUiDecoratorMessage
   | AssetRegisterMessage
-  | DispatchExtensionCommandMessage;
+  | DispatchExtensionCommandMessage
+  | QueueUpdateToServerMessage;
 
 // ── Server → Extension ──────────────────────────────────────────────
 
@@ -381,6 +395,8 @@ export interface SendPromptToExtensionMessage {
   sessionId: string;
   text: string;
   images?: ImageContent[];
+  /** Delivery mode: "steer" (after current turn) or "followUp" (after agent finishes). Defaults to "followUp" when absent. See change: add-steering-message. */
+  delivery?: "steer" | "followUp";
 }
 
 export interface AbortToExtensionMessage {
@@ -574,6 +590,76 @@ export interface ServerRestartingExtensionMessage {
   quiesceMs: number;
 }
 
+/**
+ * Server -> bridge: clear pi's steering queue for the named session.
+ * Bridge calls `pi.clearSteeringQueue()`. Idempotent on empty queue.
+ * Pi emits a fresh `queue_update` reflecting the empty array.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+export interface ClearSteeringQueueToExtensionMessage {
+  type: "clear_steering_queue";
+  sessionId: string;
+}
+
+/**
+ * Server -> bridge: clear pi's follow-up queue for the named session.
+ * Bridge calls `pi.clearFollowUpQueue()` and wipes its shadow `bridgeFollowUp[]`.
+ * Idempotent on empty queue.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+export interface ClearFollowupSlotToExtensionMessage {
+  type: "clear_followup_slot";
+  sessionId: string;
+}
+
+/**
+ * Server -> bridge (v1, deprecated): atomic replace of pi's follow-up slot.
+ * v2 prefers `edit_followup_entry { index: 0 }`. Bridge accepts both.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+export interface EditFollowupSlotToExtensionMessage {
+  type: "edit_followup_slot";
+  sessionId: string;
+  text: string;
+  images?: ImageContent[];
+}
+
+/**
+ * Server -> bridge (v2): move the follow-up entry at `index` to position 0
+ * (head of the queue). Bridge rewrites its shadow + replays via
+ * `clearFollowUpQueue` then `sendUserMessage` for each entry in the new
+ * order. See change: add-followup-edit-and-steer-cancel.
+ */
+export interface PromoteFollowupEntryToExtensionMessage {
+  type: "promote_followup_entry";
+  sessionId: string;
+  index: number;
+}
+
+/**
+ * Server -> bridge (v2): remove the follow-up entry at `index`. Bridge
+ * rewrites its shadow + replays the surviving entries.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+export interface RemoveFollowupEntryToExtensionMessage {
+  type: "remove_followup_entry";
+  sessionId: string;
+  index: number;
+}
+
+/**
+ * Server -> bridge (v2): replace the follow-up entry at `index` with new text.
+ * Bridge rewrites its shadow + replays.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+export interface EditFollowupEntryToExtensionMessage {
+  type: "edit_followup_entry";
+  sessionId: string;
+  index: number;
+  text: string;
+  images?: ImageContent[];
+}
+
 export type ServerToExtensionMessage =
   | SendPromptToExtensionMessage
   | AbortToExtensionMessage
@@ -602,4 +688,10 @@ export type ServerToExtensionMessage =
   | RequestRolesMessage
   | UiManagementMessage
   | KillProcessMessage
-  | ServerRestartingExtensionMessage;
+  | ServerRestartingExtensionMessage
+  | ClearSteeringQueueToExtensionMessage
+  | ClearFollowupSlotToExtensionMessage
+  | EditFollowupSlotToExtensionMessage
+  | PromoteFollowupEntryToExtensionMessage
+  | RemoveFollowupEntryToExtensionMessage
+  | EditFollowupEntryToExtensionMessage;