@cueloop/client 0.1.0-alpha.3 → 0.1.0-alpha.31

package/src/config.ts

@@ -1,14 +1,19 @@
 /**
- * Layered TOML config (#20): built-in defaults → user config → trusted repo
+ * Layered TOML config: built-in defaults → user config → trusted repo
  * config → env. Sections: [keys] action = "combo" (every action rebindable),
- * [theme] per-token overrides, [integrations.obsidian] notes-vault export.
+ * [theme] per-token overrides, [ui] auto_close + editor + the review-panel
+ * layout (review_width + review_state), [integrations.obsidian] notes-vault
+ * export.
  */
 
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
 import { DARK, type Theme } from "./theme";
+import { REVIEW_DEFAULT_WIDTH, clampWidth, type ReviewPanelMode } from "./review-panel";
 
 export interface KeymapConfig {
   [action: string]: string | string[];
@@ -18,9 +23,19 @@ export interface IntegrationsConfig {
   obsidian: ObsidianConfig;
 }
 
+/** Post-submit behavior: "off" prompts, 0 closes instantly, N counts down. */
+export type AutoClose = "off" | number;
+
 export interface CueloopConfig {
   keys: Record<string, string[]>;
   theme: Theme;
+  /**
+   * ui.reviewState / ui.reviewWidth are CLIENT VIEW STATE: the review panel's
+   * collapse mode and expanded-rail width, persisted so they survive restarts.
+   */
+  ui: { autoClose: AutoClose; editor?: string; reviewState: ReviewPanelMode; reviewWidth: number };
+  /** Planner-local author renames: identity id → display name ([authors] table). */
+  authors: Record<string, string>;
   integrations: IntegrationsConfig;
 }
 
@@ -38,8 +53,14 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   next_annotation: ["n"],
   prev_annotation: ["p"],
   delete_annotation: ["backspace"],
+  rename: ["r"],
   submit: ["return", "enter"],
+  share: ["S"],
   quit: ["q"],
+  walk: ["w"],
+  review_cycle: ["b"],
+  review_wider: ["]"],
+  review_narrower: ["["],
 };
 
 function parseToml(text: string): Record<string, unknown> {
@@ -51,14 +72,36 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
   const out: CueloopConfig = {
     keys: { ...base.keys },
     theme: { ...base.theme },
+    ui: { ...base.ui },
+    authors: { ...base.authors },
     integrations: { obsidian: { ...base.integrations.obsidian } },
   };
+  const authors = raw["authors"] as Record<string, unknown> | undefined;
+  if (authors) {
+    for (const [id, value] of Object.entries(authors)) {
+      if (typeof value === "string") out.authors[id] = value;
+    }
+  }
   const keys = raw["keys"] as KeymapConfig | undefined;
   if (keys) {
     for (const [action, combo] of Object.entries(keys)) {
       out.keys[action] = Array.isArray(combo) ? combo : [combo];
     }
   }
+  const ui = raw["ui"] as
+    | { auto_close?: unknown; editor?: unknown; review_width?: unknown; review_state?: unknown }
+    | undefined;
+  if (ui && ui.auto_close !== undefined) {
+    if (ui.auto_close === "off") out.ui.autoClose = "off";
+    else if (typeof ui.auto_close === "number" && ui.auto_close >= 0) out.ui.autoClose = ui.auto_close;
+  }
+  if (ui && typeof ui.editor === "string" && ui.editor.trim()) out.ui.editor = ui.editor.trim();
+  if (ui && typeof ui.review_width === "number" && Number.isFinite(ui.review_width)) {
+    out.ui.reviewWidth = clampWidth(ui.review_width);
+  }
+  if (ui && (ui.review_state === "expanded" || ui.review_state === "compact" || ui.review_state === "hidden")) {
+    out.ui.reviewState = ui.review_state;
+  }
   const theme = raw["theme"] as Partial<Record<keyof Theme, string>> | undefined;
   if (theme) {
     for (const [token, value] of Object.entries(theme)) {
@@ -70,29 +113,28 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
   const integrations = raw["integrations"] as Record<string, unknown> | undefined;
   const obsidian = integrations?.["obsidian"] as Record<string, unknown> | undefined;
   if (obsidian) {
-    const o = out.integrations.obsidian;
-    if (typeof obsidian["vault"] === "string") o.vault = obsidian["vault"];
-    if (typeof obsidian["folder"] === "string") o.folder = obsidian["folder"];
-    if (typeof obsidian["filenameFormat"] === "string") o.filenameFormat = obsidian["filenameFormat"];
-    const sep = obsidian["separator"];
-    if (sep === "space" || sep === "dash" || sep === "underscore") o.separator = sep;
-    const on = obsidian["exportOn"];
-    if (on === "approve" || on === "resolve" || on === "manual") o.exportOn = on;
+    const obsidianConfig = out.integrations.obsidian;
+    if (typeof obsidian["vault"] === "string") obsidianConfig.vault = obsidian["vault"];
+    if (typeof obsidian["folder"] === "string") obsidianConfig.folder = obsidian["folder"];
+    if (typeof obsidian["filenameFormat"] === "string") obsidianConfig.filenameFormat = obsidian["filenameFormat"];
+    const separator = obsidian["separator"];
+    if (separator === "space" || separator === "dash" || separator === "underscore") obsidianConfig.separator = separator;
+    const exportOn = obsidian["exportOn"];
+    if (exportOn === "approve" || exportOn === "resolve" || exportOn === "manual") obsidianConfig.exportOn = exportOn;
   }
   return out;
 }
 
-export function loadConfig(opts: { repoRoot?: string; userConfigPath?: string } = {}): CueloopConfig {
+export function loadConfig(options: { repoRoot?: string; userConfigPath?: string } = {}): CueloopConfig {
   let config: CueloopConfig = {
     keys: { ...DEFAULT_KEYS },
     theme: { ...DARK },
+    ui: { autoClose: "off", reviewState: "expanded", reviewWidth: REVIEW_DEFAULT_WIDTH },
+    authors: {},
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
   };
-  const userPath =
-    opts.userConfigPath ??
-    process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
-  for (const path of [userPath, opts.repoRoot ? join(opts.repoRoot, ".cueloop", "config.toml") : undefined]) {
+  const userPath = userConfigPathFrom(options.userConfigPath);
+  for (const path of [userPath, options.repoRoot ? join(options.repoRoot, ".cueloop", "config.toml") : undefined]) {
     if (!path || !existsSync(path)) continue;
     try {
       config = layer(config, parseToml(readFileSync(path, "utf8")));
@@ -111,3 +153,73 @@ export function actionFor(keys: Record<string, string[]>, name: string, shift: b
   }
   return undefined;
 }
+
+function userConfigPathFrom(userConfigPath?: string): string {
+  return (
+    userConfigPath ??
+    process.env.CUELOOP_CONFIG ??
+    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml")
+  );
+}
+
+/**
+ * Persist one `[ui]` key into the user config file. Line-level TOML surgery on
+ * the keys we own: replace the existing assignment, or drop it under an `[ui]`
+ * section (appending the section when absent) - a full TOML writer is not worth
+ * its weight here.
+ */
+function persistUiSetting(key: string, rendered: string, userConfigPath?: string): void {
+  const path = userConfigPathFrom(userConfigPath);
+  let text = "";
+  if (existsSync(path)) text = readFileSync(path, "utf8");
+  const assignment = new RegExp(`^(\\s*)${key}\\s*=.*$`, "m");
+  if (assignment.test(text)) {
+    text = text.replace(assignment, `$1${key} = ${rendered}`);
+  } else if (/^\[ui\]/m.test(text)) {
+    text = text.replace(/^\[ui\]\s*$/m, `[ui]\n${key} = ${rendered}`);
+  } else {
+    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[ui]\n${key} = ${rendered}\n`;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}
+
+/** Persist the auto-close choice (`[ui] auto_close`) into the user config. */
+export function persistAutoClose(value: AutoClose, userConfigPath?: string): void {
+  persistUiSetting("auto_close", value === "off" ? '"off"' : String(value), userConfigPath);
+}
+
+/** Persist the expanded-rail width (`[ui] review_width`) into the user config. */
+export function persistReviewWidth(width: number, userConfigPath?: string): void {
+  persistUiSetting("review_width", String(clampWidth(width)), userConfigPath);
+}
+
+/** Persist the review-panel collapse mode (`[ui] review_state`) into the config. */
+export function persistReviewState(state: ReviewPanelMode, userConfigPath?: string): void {
+  persistUiSetting("review_state", `"${state}"`, userConfigPath);
+}
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Persist an author rename into the `[authors]` table. The identity id (an SSH
+ * fingerprint) is not a bare TOML key, so it is written quoted.
+ */
+export function persistAuthorName(id: string, name: string, userConfigPath?: string): void {
+  const path = userConfigPathFrom(userConfigPath);
+  let text = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const key = `"${id.replace(/"/g, '\\"')}"`;
+  const value = `"${name.replace(/"/g, '\\"')}"`;
+  const assignment = new RegExp(`^(\\s*)${escapeRegExp(key)}\\s*=.*$`, "m");
+  if (assignment.test(text)) {
+    text = text.replace(assignment, `$1${key} = ${value}`);
+  } else if (/^\[authors\]/m.test(text)) {
+    text = text.replace(/^\[authors\]\s*$/m, `[authors]\n${key} = ${value}`);
+  } else {
+    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[authors]\n${key} = ${value}\n`;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}

package/src/editor.test.ts

@@ -0,0 +1,134 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { editInEditor, resolveEditor, resolveEditorCommand } from "./editor";
+
+describe("resolveEditor", () => {
+  test("a clean environment falls back to nano so editing always works", () => {
+    // Assert
+    expect(resolveEditor(undefined, {})).toBe("nano");
+  });
+
+  test("the environment chain wins in order: CUELOOP_EDITOR, VISUAL, EDITOR", () => {
+    // Assert
+    expect(resolveEditor(undefined, { EDITOR: "vim", VISUAL: "code", CUELOOP_EDITOR: "hx" })).toBe("hx");
+    expect(resolveEditor(undefined, { EDITOR: "vim", VISUAL: "code" })).toBe("code");
+    expect(resolveEditor(undefined, { EDITOR: "vim" })).toBe("vim");
+  });
+
+  test("the [ui] editor config overrides the environment", () => {
+    // Assert
+    expect(resolveEditor("code --wait", { EDITOR: "vim" })).toBe("code --wait");
+  });
+});
+
+describe("resolveEditorCommand", () => {
+  test("a known GUI editor gets its wait flag appended and is trusted to wait", () => {
+    // Assert
+    expect(resolveEditorCommand("code")).toEqual({ argv: ["code", "--wait"], waits: true });
+    expect(resolveEditorCommand("subl")).toEqual({ argv: ["subl", "--new-window", "--wait"], waits: true });
+  });
+
+  test("an existing wait flag is not duplicated", () => {
+    // Assert
+    expect(resolveEditorCommand("code --wait").argv).toEqual(["code", "--wait"]);
+  });
+
+  test("a terminal editor is left alone and trusted to hold the tty", () => {
+    // Assert
+    expect(resolveEditorCommand("vim")).toEqual({ argv: ["vim"], waits: true });
+  });
+
+  test("an unknown editor is neither flagged nor trusted to wait", () => {
+    // Assert
+    expect(resolveEditorCommand("my-editor")).toEqual({ argv: ["my-editor"], waits: false });
+  });
+});
+
+describe("editInEditor", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "cueloop-edit-test-"));
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  /** A runnable editor stub with a chosen base name and body. */
+  function stubEditor(name: string, body: string): string {
+    const script = join(dir, name);
+    writeFileSync(script, `#!/bin/sh\n${body}\n`);
+    chmodSync(script, 0o755);
+    return script;
+  }
+
+  const instant = (): (() => number) => {
+    let value = 0;
+    return () => (value += 5);
+  };
+
+  test("an editor that changes the file reports the new content", () => {
+    // Act
+    const result = editInEditor("old", "plan.md", { editor: stubEditor("writer.sh", `printf 'new' > "$1"`) });
+
+    // Assert
+    expect(result).toEqual({ content: "new", changed: true });
+  });
+
+  test("a fast, unchanged return opens the gate; confirming re-reads the saved file", () => {
+    // Arrange
+    let askedLabel = "";
+
+    // Act
+    const result = editInEditor("keep", "plan.md", {
+      editor: stubEditor("gui-like.sh", "exit 0"),
+      now: instant(),
+      confirmSaved: (label, path) => {
+        askedLabel = label;
+        writeFileSync(path, "saved in the GUI");
+        return true;
+      },
+    });
+
+    // Assert
+    expect(askedLabel).toContain("gui-like.sh");
+    expect(result).toEqual({ content: "saved in the GUI", changed: true });
+  });
+
+  test("declining the gate keeps the original content", () => {
+    // Act
+    const result = editInEditor("keep", "plan.md", {
+      editor: stubEditor("gui-like.sh", "exit 0"),
+      now: instant(),
+      confirmSaved: () => false,
+    });
+
+    // Assert
+    expect(result).toEqual({ content: "keep", changed: false });
+  });
+
+  test("a terminal editor that makes no change never opens the gate", () => {
+    // Arrange
+    let asked = false;
+
+    // Act
+    const result = editInEditor("keep", "plan.md", {
+      editor: stubEditor("vi", "exit 0"),
+      now: instant(),
+      confirmSaved: () => {
+        asked = true;
+        return true;
+      },
+    });
+
+    // Assert
+    expect(asked).toBeFalse();
+    expect(result).toEqual({ content: "keep", changed: false });
+  });
+
+  test("a nonzero editor exit throws", () => {
+    // Assert
+    expect(() => editInEditor("x", "plan.md", { editor: stubEditor("fail.sh", "exit 3") })).toThrow("editor exited 3");
+  });
+});

package/src/editor.ts

@@ -1,7 +1,11 @@
 /**
- * File-level edit mode = the $EDITOR hand-off (#22, #11): write the working
- * copy to a temp file, run the user's editor on it, read the result back.
- * Tests point CUELOOP_EDITOR at a non-interactive command.
+ * File-level edit mode = the editor hand-off: write the working copy to a temp
+ * file, run the reviewer's editor on it, read the result back. Editing must
+ * work with zero configuration, so the resolution chain ends in a terminal
+ * fallback that is always present. A GUI editor launched without a wait flag
+ * forks and returns instantly, losing the edit silently; known GUI editors get
+ * their wait flag applied, and any editor that still returns right away with an
+ * untouched file drops to a confirm gate rather than discarding the work.
  */
 
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -13,20 +17,104 @@ export interface EditResult {
   changed: boolean;
 }
 
-export function editInEditor(content: string, filename = "plan.md"): EditResult {
-  const editor = process.env.CUELOOP_EDITOR ?? process.env.VISUAL ?? process.env.EDITOR;
-  if (!editor) throw new Error("no editor: set $EDITOR (or $CUELOOP_EDITOR)");
+/** Present on every POSIX system, so a clean shell can still edit. */
+const DEFAULT_EDITOR = "nano";
+
+/** GUI editors fork and return immediately unless given their wait flag. */
+const GUI_WAIT_FLAGS: Record<string, string[]> = {
+  code: ["--wait"],
+  "code-insiders": ["--wait"],
+  codium: ["--wait"],
+  cursor: ["--wait"],
+  windsurf: ["--wait"],
+  subl: ["--new-window", "--wait"],
+  sublime_text: ["--new-window", "--wait"],
+  zed: ["--wait"],
+  bbedit: ["--wait"],
+  mate: ["--wait"],
+  gedit: ["--wait"],
+  kate: ["--block"],
+  idea: ["--wait"],
+  webstorm: ["--wait"],
+};
+
+/** Editors that hold the terminal themselves - never GUI, never a wait gate. */
+const TERMINAL_EDITORS = new Set([
+  "vi", "vim", "nvim", "nano", "pico", "emacs", "emacsclient", "micro", "hx", "helix", "kak", "ed", "joe", "mcedit",
+]);
+
+export interface ResolvedEditor {
+  argv: string[];
+  /** True when this editor blocks the hand-off until the file is closed - a
+   * terminal editor, or a known GUI editor with its wait flag applied. */
+  waits: boolean;
+}
+
+/** The editor to run: [ui] editor, then the environment chain, then nano. */
+export function resolveEditor(configuredEditor: string | undefined, env: Record<string, string | undefined> = process.env): string {
+  const candidates = [configuredEditor, env.CUELOOP_EDITOR, env.VISUAL, env.EDITOR];
+  return candidates.find((candidate) => candidate && candidate.trim())?.trim() ?? DEFAULT_EDITOR;
+}
+
+function editorBaseName(command: string): string {
+  return (command.split(/[\\/]/).pop() ?? command).toLowerCase();
+}
+
+/** Split the editor string and apply a GUI wait flag when we know one. */
+export function resolveEditorCommand(rawEditor: string): ResolvedEditor {
+  const parts = rawEditor.trim().split(/\s+/);
+  const base = editorBaseName(parts[0] ?? "");
+  if (TERMINAL_EDITORS.has(base)) return { argv: parts, waits: true };
+  const waitFlags = GUI_WAIT_FLAGS[base];
+  if (waitFlags) {
+    const alreadyWaits = parts.some((part) => part === "--wait" || part === "-w" || part === "--block");
+    return { argv: alreadyWaits ? parts : [...parts, ...waitFlags], waits: true };
+  }
+  return { argv: parts, waits: false };
+}
+
+/** A fast return with an untouched file means the editor probably did not wait. */
+const NO_WAIT_THRESHOLD_MS = 1000;
+
+function suspectsNoWait(resolved: ResolvedEditor, elapsedMs: number, unchanged: boolean): boolean {
+  if (resolved.waits) return false; // holds the terminal or has a wait flag - trust the exit
+  if (!unchanged) return false; // edits landed, so it waited after all
+  return elapsedMs < NO_WAIT_THRESHOLD_MS;
+}
+
+export interface EditHandOff {
+  /** Editor from [ui] editor config; overrides the environment. */
+  editor?: string;
+  env?: Record<string, string | undefined>;
+  /** Confirm gate for a suspected no-wait return; true re-reads the file. */
+  confirmSaved?: (editorLabel: string, path: string) => boolean;
+  now?: () => number;
+}
+
+/** Prompt on the released terminal during the suspend window. */
+function promptSaved(editorLabel: string, path: string): boolean {
+  const answer = prompt(
+    `${editorLabel} returned immediately and the plan is unchanged - a GUI editor needs its wait flag. Save and close ${path}, then press Enter to load your edits (or type n to skip):`,
+  );
+  return answer !== null && answer.trim().toLowerCase() !== "n";
+}
+
+export function editInEditor(content: string, filename = "plan.md", handOff: EditHandOff = {}): EditResult {
+  const env = handOff.env ?? process.env;
+  const now = handOff.now ?? Date.now;
+  const resolved = resolveEditorCommand(resolveEditor(handOff.editor, env));
   const dir = mkdtempSync(join(tmpdir(), "cueloop-edit-"));
   const path = join(dir, filename);
   writeFileSync(path, content);
   try {
-    const proc = Bun.spawnSync([...editor.split(" "), path], {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    if (proc.exitCode !== 0) throw new Error(`editor exited ${proc.exitCode}`);
-    const next = readFileSync(path, "utf8");
+    const startedAt = now();
+    const editorProcess = Bun.spawnSync([...resolved.argv, path], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+    if (editorProcess.exitCode !== 0) throw new Error(`editor exited ${editorProcess.exitCode}`);
+    let next = readFileSync(path, "utf8");
+    if (suspectsNoWait(resolved, now() - startedAt, next === content)) {
+      const confirm = handOff.confirmSaved ?? promptSaved;
+      if (confirm(resolved.argv[0] ?? "the editor", path)) next = readFileSync(path, "utf8");
+    }
     return { content: next, changed: next !== content };
   } finally {
     rmSync(dir, { recursive: true, force: true });

package/src/herdr.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { focusHerdrPane } from "./herdr";
+
+let dir: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-"));
+});
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("focusHerdrPane", () => {
+  test("resolves the pane's tab and focuses it", () => {
+    // Arrange
+    const log = join(dir, "calls.log");
+    const stub = join(dir, "herdr");
+    writeFileSync(
+      stub,
+      `#!/bin/sh
+echo "$@" >> "${log}"
+if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
+`,
+    );
+    Bun.spawnSync(["chmod", "+x", stub]);
+
+    // Assert
+    expect(focusHerdrPane(stub, "w1:p1")).toBe(true);
+    const calls = readFileSync(log, "utf8").trim().split("\n");
+    expect(calls[0]).toBe("pane get w1:p1");
+    expect(calls[1]).toBe("tab focus w1:t3");
+  });
+
+  test("a missing binary never throws", () => {
+    // Assert
+    expect(focusHerdrPane(join(dir, "nope"), "w1:p1")).toBe(false);
+  });
+});

package/src/herdr.ts

@@ -0,0 +1,21 @@
+/**
+ * First-class herdr return: a review opened beside an agent hands focus back
+ * to the agent's pane when it closes, not leaving the reviewer on a dead tab.
+ * The env contract and the return-target rule live in @cueloop/schema; this
+ * module owns the one reviewer-side action that spawns the herdr CLI. Focus
+ * is best-effort - a failure never blocks closing the review.
+ */
+
+/** Focus the tab holding the target pane. Synchronous: runs just before exit. */
+export function focusHerdrPane(binPath: string, paneId: string): boolean {
+  try {
+    const got = Bun.spawnSync([binPath, "pane", "get", paneId], { stdout: "pipe", stderr: "ignore" });
+    if (got.exitCode !== 0) return false;
+    const parsed = JSON.parse(got.stdout.toString()) as { result?: { pane?: { tab_id?: string } } };
+    const tab = parsed.result?.pane?.tab_id;
+    if (!tab) return false;
+    return Bun.spawnSync([binPath, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" }).exitCode === 0;
+  } catch {
+    return false;
+  }
+}

package/src/index.ts

@@ -1,2 +1,4 @@
 export { runClient, type RunClientOptions } from "./run";
 export { serveClient, type ServeHandle, type ServeOptions } from "./serve";
+export { App, type AppProps } from "./App";
+export { collaboratorAnnotations, publishShare, pullShare, pushShare, shareIdFromLine, type ShareResult, type ShareTarget } from "./share";

package/src/integrations.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import { OBSIDIAN_DEFAULTS } from "@cueloop/integration-obsidian";
+import { loadBundledExporters } from "./integrations";
+import type { IntegrationsConfig } from "./config";
+
+function integrations(overrides: Partial<typeof OBSIDIAN_DEFAULTS> = {}): IntegrationsConfig {
+  return { obsidian: { ...OBSIDIAN_DEFAULTS, ...overrides } };
+}
+
+describe("loadBundledExporters", () => {
+  test("composes the obsidian integration into one named exporter", async () => {
+    // Act
+    const exporters = await loadBundledExporters(integrations());
+
+    // Assert
+    expect(exporters.map((exporter) => exporter.name)).toEqual(["obsidian"]);
+  });
+
+  test("runsOn mirrors the configured export policy", async () => {
+    // Arrange
+    const onApprove = (await loadBundledExporters(integrations({ exportOn: "approve" })))[0]!;
+
+    // Assert
+    expect(onApprove.runsOn("approve")).toBeTrue();
+    expect(onApprove.runsOn("request_changes")).toBeFalse();
+
+    // Arrange
+    const onResolve = (await loadBundledExporters(integrations({ exportOn: "resolve" })))[0]!;
+
+    // Assert
+    expect(onResolve.runsOn("approve")).toBeTrue();
+    expect(onResolve.runsOn("request_changes")).toBeTrue();
+
+    // Arrange
+    const manual = (await loadBundledExporters(integrations({ exportOn: "manual" })))[0]!;
+
+    // Assert
+    expect(manual.runsOn("approve")).toBeFalse();
+    expect(manual.runsOn("request_changes")).toBeFalse();
+  });
+});

package/src/integrations.ts

@@ -0,0 +1,28 @@
+/**
+ * Bundled integration wiring: composes the configured integrations into
+ * generic exporters plus their run policy, so the session controller depends
+ * only on the extension seam, never on an integration's own config type. This
+ * and config.ts are the only client modules that name a concrete integration.
+ */
+
+import { Registry, type Exporter } from "@cueloop/extension-api";
+import { createObsidianExtension, shouldExport } from "@cueloop/integration-obsidian";
+import type { VerdictKind } from "@cueloop/schema";
+import type { IntegrationsConfig } from "./config";
+
+/** An exporter plus the policy deciding which verdicts trigger it. */
+export interface BundledExporter {
+  name: string;
+  run: Exporter;
+  runsOn(verdict: VerdictKind): boolean;
+}
+
+/** Load the bundled integrations from config as generic exporters. */
+export async function loadBundledExporters(integrations: IntegrationsConfig): Promise<BundledExporter[]> {
+  const registry = new Registry();
+  const obsidian = integrations.obsidian;
+  const record = await registry.load("obsidian", createObsidianExtension(obsidian));
+  const run = record.exporters.get("obsidian");
+  if (!run) return [];
+  return [{ name: "obsidian", run, runsOn: (verdict) => shouldExport(obsidian.exportOn, verdict) }];
+}