@dieulc/pi-office-bridge 0.1.0 → 0.3.0

package/src/index.ts

@@ -21,8 +21,11 @@ import type {
   RegisteredCommand,
 } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
-import { BRIDGE_DEFAULT_PORT } from "./protocol.js";
+import { CATALOG_VERSION, BRIDGE_DEFAULT_PORT } from "./protocol.js";
 import type { AttachedPane } from "./bridge-server.js";
 import { OfficeBridgeServer } from "./bridge-server.js";
 import {
@@ -32,6 +35,10 @@ import {
   HOST_APP_LABEL,
 } from "./office-tools.js";
 import type { OfficeToolDescriptor } from "./office-tools.js";
+import {
+  reconcileOfficeToolActivation,
+  type PaneCapability,
+} from "./active-tools.js";
 
 const FLAG_PORT = "office-bridge-port";
 
@@ -46,6 +53,24 @@ function piVersion(): string | null {
   }
 }
 
+/**
+ * The bridge extension's own package version, read from the `package.json`
+ * that ships next to this module. Falls back to `"unknown"` so a bundled or
+ * relocated install never breaks the `welcome` frame.
+ */
+function serverVersion(): string {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const raw = readFileSync(resolve(here, "..", "package.json"), "utf8");
+    const pkg = JSON.parse(raw) as { version?: unknown };
+    return typeof pkg.version === "string" && pkg.version.length > 0
+      ? pkg.version
+      : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
 export default function (pi: ExtensionAPI): void {
   let server: OfficeBridgeServer | null = null;
   let currentCtx: ExtensionContext | null = null;
@@ -62,12 +87,14 @@ export default function (pi: ExtensionAPI): void {
     const raw = pi.getFlag(FLAG_PORT);
     if (typeof raw === "string" && raw.trim() !== "") {
       const parsed = Number.parseInt(raw.trim(), 10);
-      if (Number.isFinite(parsed) && parsed > 0 && parsed < 65536) return parsed;
+      if (Number.isFinite(parsed) && parsed > 0 && parsed < 65536)
+        return parsed;
     }
     const env = process.env.PI_OFFICE_BRIDGE_PORT;
     if (env) {
       const parsed = Number.parseInt(env, 10);
-      if (Number.isFinite(parsed) && parsed > 0 && parsed < 65536) return parsed;
+      if (Number.isFinite(parsed) && parsed > 0 && parsed < 65536)
+        return parsed;
     }
     return BRIDGE_DEFAULT_PORT;
   }
@@ -82,11 +109,28 @@ export default function (pi: ExtensionAPI): void {
     }
     const port = server.actualPort ?? resolvePort();
     if (panes.length === 0) {
-      ui.setStatus("office-bridge", `office bridge on :${port} — no app attached`);
+      ui.setStatus(
+        "office-bridge",
+        `office bridge on :${port} — no app attached`,
+      );
       return;
     }
     const labels = panes.map((p) => HOST_APP_LABEL[p.host]).join(", ");
-    ui.setStatus("office-bridge", `office: ${labels} attached (bridge :${port})`);
+    ui.setStatus(
+      "office-bridge",
+      `office: ${labels} attached (bridge :${port})`,
+    );
+  }
+
+  let panesChangedTimer: ReturnType<typeof setTimeout> | null = null;
+
+  /** Debounced status refresh triggered by pane attach/detach (~100 ms). */
+  function scheduleStatusUpdate(): void {
+    if (panesChangedTimer !== null) clearTimeout(panesChangedTimer);
+    panesChangedTimer = setTimeout(() => {
+      panesChangedTimer = null;
+      updateStatus();
+    }, 100);
   }
 
   /** Extract display text from an assistant message content payload. */
@@ -98,7 +142,8 @@ export default function (pi: ExtensionAPI): void {
       if (typeof part !== "object" || part === null) continue;
       const p = part as { type?: unknown; text?: unknown };
       if (p.type === "text" && typeof p.text === "string") parts.push(p.text);
-      if (p.type === "thinking" && typeof p.text === "string") parts.push(p.text);
+      if (p.type === "thinking" && typeof p.text === "string")
+        parts.push(p.text);
     }
     return parts.join("\n").trim();
   }
@@ -110,6 +155,7 @@ export default function (pi: ExtensionAPI): void {
       name: descriptor.name,
       label: descriptor.label,
       description: descriptor.description,
+      promptSnippet: descriptor.promptSnippet,
       promptGuidelines: descriptor.promptGuidelines,
       parameters: descriptor.parameters,
       executionMode: "sequential",
@@ -120,6 +166,9 @@ export default function (pi: ExtensionAPI): void {
         _onUpdate,
         _ctx,
       ): Promise<AgentToolResult<unknown>> {
+        // SAFETY: `Params` is the TypeBox-derived shape of
+        // `descriptor.parameters` (always an object); the bridge forwards it
+        // verbatim as the Office.js args record, so this widening is sound.
         const args = params as unknown as Record<string, unknown>;
         const active = server;
         if (!active?.isRunning) {
@@ -127,8 +176,16 @@ export default function (pi: ExtensionAPI): void {
             `office-bridge: server is not running. Check the Pi extension loaded, then open the add-in.`,
           );
         }
-        const result = await active.callOfficeTool(descriptor.host, descriptor.op, args, signal);
-        return { content: [{ type: "text", text: result.text }], details: result.details };
+        const result = await active.callOfficeTool(
+          descriptor.host,
+          descriptor.op,
+          args,
+          signal,
+        );
+        return {
+          content: [{ type: "text", text: result.text }],
+          details: result.details,
+        };
       },
     });
   }
@@ -139,6 +196,46 @@ export default function (pi: ExtensionAPI): void {
     }
   }
 
+  /**
+   * Reconcile the Pi active tool set with the currently attached panes: only
+   * the office ops the attached panes advertise stay active; everything else
+   * (user/other-extension tools) is preserved. Called on attach/detach.
+   */
+  function reconcileActiveTools(panes: readonly AttachedPane[]): void {
+    const capabilities: PaneCapability[] = panes.map((pane) => ({
+      host: pane.host,
+      ops: pane.ops,
+    }));
+    const next = reconcileOfficeToolActivation(
+      pi.getActiveTools(),
+      capabilities,
+    );
+    pi.setActiveTools(next);
+  }
+
+  /** Stable per-turn pane-awareness block appended to the system prompt. */
+  function paneContextBlock(): string | null {
+    const active = server;
+    if (!active?.isRunning) return null;
+    const panes = active.attachedPanes();
+    if (panes.length === 0) return null;
+
+    const lines = panes.map((p) => {
+      const legacy =
+        p.ops === null
+          ? " (legacy client: only v1 ops — update the add-in for newer tools)"
+          : "";
+      return `- ${HOST_APP_LABEL[p.host]} is attached via the office bridge${legacy}. The open document is live: the office_${p.host}_* tools edit it directly.`;
+    });
+    return (
+      "\n\n## Attached Office documents\n" +
+      lines.join("\n") +
+      "\n\nEditing these documents with the office_* tools is fully supported, including formatting and " +
+      "structured documents (titles, headings, lists, tables, alignment, indents). Never claim formatting is " +
+      "unavailable, and never emit HTML for Word — use the office_word_* tools."
+    );
+  }
+
   /* ── lifecycle ─────────────────────────────────────────────────────── */
 
   pi.on("session_start", async (_event, ctx) => {
@@ -154,6 +251,7 @@ export default function (pi: ExtensionAPI): void {
     const bridge = new OfficeBridgeServer({
       port,
       serverName: "pi-office-bridge",
+      serverVersion: serverVersion(),
       piVersion: piVersion(),
       handlers: {
         onUserMessage: (text, pane) => {
@@ -163,16 +261,36 @@ export default function (pi: ExtensionAPI): void {
           // triggers a turn; if a turn is running it is queued until it settles.
           pi.sendUserMessage(text, { deliverAs: "followUp" });
         },
+        // Keep the TUI status line live and the active tool set in sync:
+        // opening an app activates that host's office tools; closing it
+        // deactivates them.
+        onPanesChanged: (panes) => {
+          scheduleStatusUpdate();
+          reconcileActiveTools(panes);
+        },
       },
     });
 
     try {
       await bridge.start();
       server = bridge;
-      ctx.ui.notify(`Office bridge listening on ws://127.0.0.1:${port}`, "info");
+      ctx.ui.notify(
+        `Office bridge listening on ws://127.0.0.1:${port}`,
+        "info",
+      );
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      ctx.ui.notify(`Office bridge failed to start: ${message}`, "error");
+      const code = (error as NodeJS.ErrnoException | null)?.code;
+      if (code === "EADDRINUSE") {
+        ctx.ui.notify(
+          `Office bridge: port ${port} is already in use — another Pi process ` +
+            `is running the bridge. Start this one on a free port with ` +
+            `--${FLAG_PORT} <port> or PI_OFFICE_BRIDGE_PORT=<port>.`,
+          "error",
+        );
+      } else {
+        ctx.ui.notify(`Office bridge failed to start: ${message}`, "error");
+      }
       console.error(`[office-bridge] start failed: ${message}`);
     }
     updateStatus();
@@ -181,6 +299,10 @@ export default function (pi: ExtensionAPI): void {
   pi.on("session_shutdown", async () => {
     currentCtx = null;
     pendingReplyTargets.length = 0;
+    if (panesChangedTimer !== null) {
+      clearTimeout(panesChangedTimer);
+      panesChangedTimer = null;
+    }
     const active = server;
     server = null;
     if (active) {
@@ -190,6 +312,14 @@ export default function (pi: ExtensionAPI): void {
 
   /* ── agent → pane forwarding ───────────────────────────────────────── */
 
+  // Tell the agent which Office apps are attached before each turn so it uses
+  // the office_* tools directly instead of claiming capabilities are missing.
+  pi.on("before_agent_start", (event, _ctx) => {
+    const block = paneContextBlock();
+    if (block === null) return undefined;
+    return { systemPrompt: event.systemPrompt + block };
+  });
+
   // Forward the final assistant reply to the pane that prompted it.
   pi.on("message_end", async (event, _ctx) => {
     if (event.message.role !== "assistant") return;
@@ -199,6 +329,8 @@ export default function (pi: ExtensionAPI): void {
 
     const text = flattenAssistantText(event.message.content);
     if (!text) return;
+    // SAFETY: assistant messages may carry an id that the Pi event type does
+    // not surface; read it through a narrow shape check before using it.
     const maybeId = (event.message as unknown as { id?: unknown }).id;
     server.broadcast({
       type: "agent_message",
@@ -230,7 +362,9 @@ export default function (pi: ExtensionAPI): void {
       type: "tool_activity",
       tool: event.toolName,
       status: event.isError ? "error" : "end",
-      summary: event.isError ? String(event.result ?? "tool failed") : undefined,
+      summary: event.isError
+        ? String(event.result ?? "tool failed")
+        : undefined,
     });
   });
 
@@ -248,16 +382,30 @@ export default function (pi: ExtensionAPI): void {
       const port = active.actualPort ?? resolvePort();
       const panes = active.attachedPanes();
       if (panes.length === 0) {
-        ctx.ui.notify(`Office bridge is listening on :${port} — no app attached yet.`, "info");
+        ctx.ui.notify(
+          `Office bridge is listening on :${port} — no app attached yet.`,
+          "info",
+        );
         return;
       }
       const lines = panes.map((p) => {
         const model = p.model ? `, model=${p.model}` : "";
         const provider = p.provider ? `, provider=${p.provider}` : "";
         const ago = Math.max(0, Math.round((Date.now() - p.lastSeen) / 1000));
-        return `- ${HOST_APP_LABEL[p.host]} (${p.clientName}, pane ${p.paneId.slice(0, 8)})${model}${provider}, seen ${ago}s ago`;
+        const ops =
+          p.ops !== null
+            ? `${p.ops.length} ops${p.catalogVersion ? ` (catalog v${p.catalogVersion})` : ""}`
+            : "legacy client (v1 ops)";
+        const ignored =
+          p.opsIgnoredCount > 0
+            ? `, ${p.opsIgnoredCount} advertised op(s) ignored (unknown to this server)`
+            : "";
+        return `- ${HOST_APP_LABEL[p.host]} (${p.clientName}, pane ${p.paneId.slice(0, 8)})${model}${provider}, seen ${ago}s ago — ${ops}${ignored}`;
       });
-      ctx.ui.notify(`Office bridge on :${port}\n${lines.join("\n")}`, "info");
+      ctx.ui.notify(
+        `Office bridge on :${port} (catalog v${CATALOG_VERSION})\n${lines.join("\n")}`,
+        "info",
+      );
     },
   };
 
@@ -265,10 +413,11 @@ export default function (pi: ExtensionAPI): void {
 
   // Also list every office tool we exposed so users can confirm them:
   pi.registerCommand("office-tools", {
-    description: "List the office tools registered by the pi-office bridge extension.",
+    description:
+      "List the office tools registered by the pi-office bridge extension.",
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
       ctx.ui.notify(
-        `Office tools (${OFFICE_TOOL_NAMES.length}):\n${OFFICE_TOOL_NAMES.join("\n")}`,
+        `Office tools (${OFFICE_TOOL_NAMES.length}, catalog v${CATALOG_VERSION}):\n${OFFICE_TOOL_NAMES.join("\n")}`,
         "info",
       );
     },

package/src/office-tools.ts

@@ -1,18 +1,19 @@
 /**
- * Office tool catalog — the Office.js operations the Pi agent can drive
- * through the bridge.
+ * Office tool catalog adapter — thin wrapper over the shared catalog.
  *
- * Each descriptor is host-scoped (excel / word / powerpoint). The task-pane
- * add-in executes the actual Office.js call; this extension only describes the
- * tool to the LLM and routes the call over the bridge.
- *
- * Keep `op` values in sync with the add-in's `bridge/tool-registry.ts` (same
- * repository, `packages/add-in`). The pane validates args again at runtime, so
- * this file is the *contract*, not the enforcement point.
+ * The authoritative op definitions (names, schemas, descriptions) live in
+ * `@dieulc/pi-office-protocol` (`office-catalog.ts`). This module only maps
+ * catalog entries to the descriptors this extension registers with Pi, so the
+ * Pi side can never drift from the add-in's pane-side registry.
  */
 
-import { Type, type TSchema } from "typebox";
-import { StringEnum } from "@earendil-works/pi-ai";
+import type { TSchema } from "typebox";
+import {
+  CATALOG_VERSION,
+  HOST_APP_LABEL,
+  OFFICE_CATALOG,
+  hostForToolName,
+} from "./protocol.js";
 import type { OfficeHostApp } from "./protocol.js";
 
 export interface OfficeToolDescriptor {
@@ -24,239 +25,39 @@ export interface OfficeToolDescriptor {
   name: string;
   label: string;
   description: string;
+  promptSnippet?: string;
   promptGuidelines?: string[];
   parameters: TSchema;
 }
 
-/** Office apps we currently expose tools for (map host → tool prefix). */
-export const HOST_APP_LABEL: Record<OfficeHostApp, string> = {
-  excel: "Excel",
-  word: "Word",
-  powerpoint: "PowerPoint",
-};
-
-function officeToolName(host: OfficeHostApp, op: string): string {
-  return `office_${host}_${op}`;
-}
-
-/* ── Excel ───────────────────────────────────────────────────────────── */
-
-const EXCEL_READ_RANGE_SCHEMA = Type.Object({
-  range: Type.String({
-    description:
-      'Cell range in A1 notation, e.g. "A1:D10" or "Sheet2!A1:B5". ' +
-      "Uses the active sheet when no sheet is specified.",
-  }),
-  mode: Type.Optional(
-    StringEnum(["compact", "csv", "detailed"], {
-      description:
-        '"compact" (default): markdown table. "csv": raw values. "detailed": with formulas/formats.',
-    }),
-  ),
-});
-
-/* ── Word ────────────────────────────────────────────────────────────── */
-
-const WORD_READ_SCOPE = StringEnum(["all", "selection"], {
-  description: '"all": whole document. "selection": currently selected text only.',
-});
-
-/* ── PowerPoint ──────────────────────────────────────────────────────── */
-
-const PPT_SLIDE_INDEX = Type.Integer({
-  minimum: 1,
-  description: "1-based slide index.",
-});
-
-/* ── Catalog ─────────────────────────────────────────────────────────── */
-
-export const OFFICE_TOOL_DESCRIPTORS: OfficeToolDescriptor[] = [
-  /* Excel */
-  {
-    host: "excel",
-    op: "get_overview",
-    name: officeToolName("excel", "get_overview"),
-    label: "Excel Workbook Overview",
-    description:
-      "Read a compact overview of the attached Excel workbook: sheet names, used ranges, " +
-      "table names, and named ranges. Call this first before any range operation.",
-    promptGuidelines: [
-      "Call office_excel_get_overview before office_excel_read_range to learn the workbook structure.",
-    ],
-    parameters: Type.Object({}),
-  },
-  {
-    host: "excel",
-    op: "read_range",
-    name: officeToolName("excel", "read_range"),
-    label: "Excel Read Range",
-    description:
-      "Read cell values (and optionally formulas/formatting) from a range in the attached Excel workbook.",
-    parameters: EXCEL_READ_RANGE_SCHEMA,
-  },
-  {
-    host: "excel",
-    op: "write_cells",
-    name: officeToolName("excel", "write_cells"),
-    label: "Excel Write Cells",
-    description:
-      "Write a 2D array of values into the attached Excel workbook, starting at a top-left cell. " +
-      "values[row][col]; the array is written down and to the right from start_cell.",
-    promptGuidelines: [
-      "Prefer office_excel_write_cells in a single batched call instead of many small edits.",
-      "Always verify with office_excel_read_range after office_excel_write_cells when the change is user-visible.",
-    ],
-    parameters: Type.Object({
-      start_cell: Type.String({
-        description: 'Top-left cell to write from, e.g. "A1" or "Sheet2!B3".',
-      }),
-      values: Type.Array(Type.Array(Type.Any()), {
-        description: "2D array of cell values (rows × cols).",
-      }),
-    }),
-  },
-  {
-    host: "excel",
-    op: "fill_formula",
-    name: officeToolName("excel", "fill_formula"),
-    label: "Excel Fill Formula",
-    description:
-      "Write a formula into a single contiguous range of the attached Excel workbook. " +
-      "Relative references adjust as the formula fills.",
-    parameters: Type.Object({
-      range: Type.String({ description: 'Target range, e.g. "B2:B20" or "Sheet1!C3:F20".' }),
-      formula: Type.String({
-        description: 'Formula starting with "=", e.g. "=SUM(B2:B10)".',
-      }),
-    }),
-  },
-
-  /* Word */
-  {
-    host: "word",
-    op: "get_overview",
-    name: officeToolName("word", "get_overview"),
-    label: "Word Document Overview",
-    description:
-      "Read a compact overview of the attached Word document: heading outline, paragraph count, " +
-      "table count, and word count. Call this first before editing.",
-    promptGuidelines: [
-      "Call office_word_get_overview before office_word_insert_text or office_word_replace_text.",
-    ],
-    parameters: Type.Object({}),
-  },
-  {
-    host: "word",
-    op: "read_document",
-    name: officeToolName("word", "read_document"),
-    label: "Word Read Document",
-    description:
-      "Read text from the attached Word document: the whole body or the current selection.",
-    parameters: Type.Object({
-      scope: Type.Optional(WORD_READ_SCOPE),
-      maxChars: Type.Optional(
-        Type.Integer({
-          minimum: 100,
-          maximum: 200000,
-          description: "Cap on characters returned (default 20000).",
-        }),
-      ),
-    }),
-  },
-  {
-    host: "word",
-    op: "insert_text",
-    name: officeToolName("word", "insert_text"),
-    label: "Word Insert Text",
-    description:
-      "Insert text at the start or end of the attached Word document, or replace the current selection.",
-    parameters: Type.Object({
-      text: Type.String({ description: "Text to insert." }),
-      location: Type.Optional(
-        StringEnum(["start", "end", "replace_selection"], {
-          description: '"end" (default) appends to the document. "replace_selection" overwrites the selection.',
-        }),
-      ),
-    }),
-  },
-  {
-    host: "word",
-    op: "replace_text",
-    name: officeToolName("word", "replace_text"),
-    label: "Word Replace Text",
-    description:
-      "Find and replace literal text in the attached Word document. Returns how many occurrences were replaced.",
-    parameters: Type.Object({
-      find: Type.String({ description: "Literal text to find." }),
-      replace: Type.String({ description: "Replacement text." }),
-      matchCase: Type.Optional(Type.Boolean({ description: "Case-sensitive match (default false)." })),
-    }),
-  },
-
-  /* PowerPoint */
-  {
-    host: "powerpoint",
-    op: "get_overview",
-    name: officeToolName("powerpoint", "get_overview"),
-    label: "PowerPoint Overview",
-    description:
-      "Read a compact overview of the attached presentation: slide count, each slide's title and " +
-      "shape count. Call this first before any slide operation.",
-    promptGuidelines: [
-      "Call office_powerpoint_get_overview before office_powerpoint_read_slide or office_powerpoint_add_slide.",
-    ],
-    parameters: Type.Object({}),
-  },
-  {
-    host: "powerpoint",
-    op: "read_slide",
-    name: officeToolName("powerpoint", "read_slide"),
-    label: "PowerPoint Read Slide",
-    description:
-      "Read all text content of one slide in the attached presentation (shapes, text frames, notes).",
-    parameters: Type.Object({
-      slideIndex: PPT_SLIDE_INDEX,
-    }),
-  },
-  {
-    host: "powerpoint",
-    op: "add_slide",
-    name: officeToolName("powerpoint", "add_slide"),
-    label: "PowerPoint Add Slide",
-    description:
-      "Append a new slide to the attached presentation and navigate to it. Uses the default layout.",
-    parameters: Type.Object({}),
-  },
-  {
-    host: "powerpoint",
-    op: "add_text_box",
-    name: officeToolName("powerpoint", "add_text_box"),
-    label: "PowerPoint Add Text Box",
-    description:
-      "Add a text box with the given text to a slide. Coordinates/geometry are in points.",
-    parameters: Type.Object({
-      slideIndex: PPT_SLIDE_INDEX,
-      text: Type.String({ description: "Text box content." }),
-      x: Type.Optional(Type.Number({ description: "Left edge in points (default centered)." })),
-      y: Type.Optional(Type.Number({ description: "Top edge in points (default centered)." })),
-      width: Type.Optional(Type.Number({ description: "Width in points (default 400)." })),
-      height: Type.Optional(Type.Number({ description: "Height in points (default 60)." })),
-    }),
-  },
-];
+/** The catalog version this extension's tool surface was built from. */
+export const TOOL_CATALOG_VERSION = CATALOG_VERSION;
+
+/** All descriptors built from the shared catalog (deterministic order). */
+export const OFFICE_TOOL_DESCRIPTORS: readonly OfficeToolDescriptor[] =
+  OFFICE_CATALOG.map((entry) => ({
+    host: entry.host,
+    op: entry.op,
+    name: entry.name,
+    label: entry.label,
+    description: entry.description,
+    ...(entry.promptSnippet === undefined
+      ? null
+      : { promptSnippet: entry.promptSnippet }),
+    ...(entry.promptGuidelines === undefined
+      ? null
+      : { promptGuidelines: entry.promptGuidelines }),
+    parameters: entry.parameters,
+  }));
 
 /** Index by op id for fast lookup. */
-export const OFFICE_TOOL_BY_OP: ReadonlyMap<string, OfficeToolDescriptor> = new Map(
-  OFFICE_TOOL_DESCRIPTORS.map((d) => [`${d.host}.${d.op}`, d]),
-);
+export const OFFICE_TOOL_BY_OP: ReadonlyMap<string, OfficeToolDescriptor> =
+  new Map(OFFICE_TOOL_DESCRIPTORS.map((d) => [`${d.host}.${d.op}`, d]));
 
 /** All tool names registered by this extension. */
-export const OFFICE_TOOL_NAMES: readonly string[] = OFFICE_TOOL_DESCRIPTORS.map((d) => d.name);
+export const OFFICE_TOOL_NAMES: readonly string[] = OFFICE_TOOL_DESCRIPTORS.map(
+  (d) => d.name,
+);
 
-/** The office host this tool name drives, or null when unknown. */
-export function hostForToolName(name: string): OfficeHostApp | null {
-  for (const d of OFFICE_TOOL_DESCRIPTORS) {
-    if (d.name === name) return d.host;
-  }
-  return null;
-}
+/** The office host this tool name drives, or null when unknown. (from catalog) */
+export { HOST_APP_LABEL, hostForToolName };

package/src/protocol.ts

@@ -1,7 +1,10 @@
 /**
- * Re-export of the shared bridge protocol.
+ * Re-export of the shared bridge protocol + office op catalog.
  *
  * The single source of truth lives in `@dieulc/pi-office-protocol` so the Pi
- * extension (server) and the add-in task pane (client) stay in lockstep.
+ * extension (server) and the add-in task pane (client) stay in lockstep. The
+ * catalog is re-exported from its subpath (the main entry keeps Node-loadable
+ * raw TS without a `.js`→`.ts` rewrite).
  */
 export * from "@dieulc/pi-office-protocol";
+export * from "@dieulc/pi-office-protocol/office-catalog";