@cueloop/client 0.1.0-alpha.20 → 0.1.0-alpha.22

package/src/components/primitives/Dialog.tsx

@@ -7,6 +7,7 @@
 import React from "react";
 import type { Theme } from "../../theme";
 import { useComponentTheme } from "../theme-context";
+import { FRAME_BORDER_STYLE } from "./frame";
 
 export interface DialogProps {
   isOpen: boolean;
@@ -38,7 +39,7 @@ export function Dialog({ isOpen, title, width, height, theme, children }: Dialog
           width,
           height,
           border: true,
-          borderStyle: "rounded",
+          borderStyle: FRAME_BORDER_STYLE,
           borderColor: tokens.accent,
           backgroundColor: tokens.panel,
           flexDirection: "column",

package/src/components/primitives/frame.test.ts

@@ -0,0 +1,12 @@
+/**
+ * Locks the single frame border rule: every bordered frame reads this token,
+ * so a regression to square corners (or any other style) fails here first,
+ * before the slower VRT snapshots catch it. Decision: rounded (issue #116).
+ */
+
+import { expect, test } from "bun:test";
+import { FRAME_BORDER_STYLE } from "./frame";
+
+test("frames use the rounded border style", () => {
+  expect(FRAME_BORDER_STYLE).toBe("rounded");
+});

package/src/components/primitives/frame.ts

@@ -0,0 +1,14 @@
+/**
+ * The one frame border rule for the design system. Every bordered frame -
+ * cards, dialogs, and the stories gallery chrome - reads its corner style
+ * from FRAME_BORDER_STYLE, so the rounded-corner decision lives in a single
+ * place and can never drift between frames. Buttons stay text-first and
+ * borderless: the frame they sit in carries the border, not the button.
+ *
+ * Decision: rounded on the frames, not on the buttons (issue #116).
+ */
+
+import type { BorderStyle } from "@opentui/core";
+
+/** Corner style shared by every bordered frame in the app. */
+export const FRAME_BORDER_STYLE: BorderStyle = "rounded";

package/src/components/stories-app.tsx

@@ -11,6 +11,7 @@ import { createRoot, useKeyboard } from "@opentui/react";
 import { DARK } from "../theme";
 import { ThemeProvider } from "./theme-context";
 import { loadStories, type LoadedStory } from "./story";
+import { FRAME_BORDER_STYLE } from "./primitives/frame";
 
 function StoriesApp({ stories, onExit }: { stories: LoadedStory[]; onExit: () => void }): React.ReactNode {
   const moduleTitles = useMemo(() => [...new Set(stories.map((story) => story.moduleTitle))], [stories]);
@@ -60,7 +61,7 @@ function StoriesApp({ stories, onExit }: { stories: LoadedStory[]; onExit: () =>
               flexGrow: 1,
               flexDirection: "column",
               border: true,
-              borderStyle: "rounded",
+              borderStyle: FRAME_BORDER_STYLE,
               borderColor: DARK.border,
             }}
             title={` ${current.storyName} (${moduleStories.indexOf(current) + 1}/${moduleStories.length}) `}

package/src/components/stories.test.tsx

@@ -28,10 +28,15 @@ describe("stories catalog", () => {
 
   for (const { moduleTitle, storyName, story } of stories) {
     test(`${moduleTitle}/${storyName} renders, snapshots, and carries its colors`, async () => {
+      // Arrange
       const size = story.size ?? { width: 80, height: 24 };
+
+      // Act
       const setup = await testRender(story.render(), size);
       await setup.waitForVisualIdle();
       const frame = setup.captureCharFrame();
+
+      // Assert
       expect(frame).toMatchSnapshot(`${moduleTitle}/${storyName}`);
       if (story.expectedColors?.length) {
         const seenColors = new Set<string>();

package/src/config.test.ts

@@ -2,25 +2,34 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { DEFAULT_KEYS, actionFor, loadConfig } from "./config";
+import { DEFAULT_KEYS, actionFor, loadConfig, persistReviewState, persistReviewWidth } from "./config";
+import { REVIEW_DEFAULT_WIDTH, REVIEW_MAX_WIDTH } from "./review-panel";
 import { DARK } from "./theme";
 
 describe("loadConfig", () => {
   test("defaults when no file exists", () => {
+    // Act
     const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+
+    // Assert
     expect(config.keys["comment"]).toEqual(["c"]);
     expect(config.theme.accent).toBe(DARK.accent);
   });
 
   test("user config rebinds actions and overrides theme tokens", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-"));
     const path = join(dir, "config.toml");
     writeFileSync(
       path,
       `[keys]\ncomment = "a"\nsubmit = ["return", "S"]\n\n[theme]\naccent = "#ff0000"\n`,
     );
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.keys["comment"]).toEqual(["a"]);
       expect(config.keys["submit"]).toEqual(["return", "S"]);
       expect(config.keys["cut"]).toEqual(["x"]); // untouched defaults survive
@@ -32,14 +41,19 @@ describe("loadConfig", () => {
   });
 
   test("repo config layers over user config", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg2-"));
     const user = join(dir, "user.toml");
     const repoRoot = join(dir, "repo");
     writeFileSync(user, `[keys]\ncomment = "a"\n`);
     Bun.spawnSync(["mkdir", "-p", join(repoRoot, ".cueloop")]);
     writeFileSync(join(repoRoot, ".cueloop", "config.toml"), `[keys]\ncomment = "z"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: user, repoRoot });
+
+      // Assert
       expect(config.keys["comment"]).toEqual(["z"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
@@ -47,11 +61,16 @@ describe("loadConfig", () => {
   });
 
   test("broken config never blocks a review", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg3-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, "not [valid toml");
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.keys["comment"]).toEqual(["c"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
@@ -59,11 +78,16 @@ describe("loadConfig", () => {
   });
 
   test("[ui] parses auto_close and the editor override", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg4-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, `[ui]\nauto_close = 3\neditor = "code --wait"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.ui.autoClose).toBe(3);
       expect(config.ui.editor).toBe("code --wait");
     } finally {
@@ -72,21 +96,98 @@ describe("loadConfig", () => {
   });
 
   test("[ui] editor defaults to undefined and ignores a blank value", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg5-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, `[ui]\neditor = "   "\n`);
+
     try {
+      // Assert
       expect(loadConfig({ userConfigPath: "/nonexistent/config.toml" }).ui.editor).toBeUndefined();
       expect(loadConfig({ userConfigPath: path }).ui.editor).toBeUndefined();
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
+
+  test("[ui] review panel defaults to an expanded rail at the default width", () => {
+    // Act
+    const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+
+    // Assert
+    expect(config.ui.reviewState).toBe("expanded");
+    expect(config.ui.reviewWidth).toBe(REVIEW_DEFAULT_WIDTH);
+  });
+
+  test("[ui] parses review_width (clamped) and review_state", () => {
+    // Arrange
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg6-"));
+    const path = join(dir, "config.toml");
+    writeFileSync(path, `[ui]\nreview_width = 999\nreview_state = "compact"\n`);
+
+    try {
+      // Act
+      const config = loadConfig({ userConfigPath: path });
+
+      // Assert
+      expect(config.ui.reviewWidth).toBe(REVIEW_MAX_WIDTH); // out-of-range width clamps
+      expect(config.ui.reviewState).toBe("compact");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("[ui] ignores an unknown review_state and a non-numeric width", () => {
+    // Arrange
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg7-"));
+    const path = join(dir, "config.toml");
+    writeFileSync(path, `[ui]\nreview_width = "wide"\nreview_state = "sideways"\n`);
+
+    try {
+      // Act
+      const config = loadConfig({ userConfigPath: path });
+
+      // Assert
+      expect(config.ui.reviewWidth).toBe(REVIEW_DEFAULT_WIDTH);
+      expect(config.ui.reviewState).toBe("expanded");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("persistReviewWidth and persistReviewState round-trip through the config file", () => {
+    // Arrange
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg8-"));
+    const path = join(dir, "config.toml");
+
+    try {
+      // Act
+      persistReviewWidth(42, path);
+      persistReviewState("hidden", path);
+
+      // Assert
+      const config = loadConfig({ userConfigPath: path });
+      expect(config.ui.reviewWidth).toBe(42);
+      expect(config.ui.reviewState).toBe("hidden");
+
+      // a second write replaces the key in place rather than appending a duplicate
+      // Act
+      persistReviewWidth(30, path);
+
+      // Assert
+      expect(loadConfig({ userConfigPath: path }).ui.reviewWidth).toBe(30);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("integrations.obsidian config", () => {
   test("defaults when the section is absent", () => {
+    // Act
     const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+
+    // Assert
     expect(config.integrations.obsidian.vault).toBeUndefined();
     expect(config.integrations.obsidian.folder).toBe("cueloop");
     expect(config.integrations.obsidian.filenameFormat).toBe("{YYYY}-{MM}-{DD} - {title}");
@@ -95,14 +196,19 @@ describe("integrations.obsidian config", () => {
   });
 
   test("user config sets the section; invalid enum values are ignored", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-obs-"));
     const path = join(dir, "config.toml");
     writeFileSync(
       path,
       `[integrations.obsidian]\nvault = "/notes/vault"\nfolder = "plans"\nexportOn = "approve"\nseparator = "comma"\n`,
     );
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.integrations.obsidian.vault).toBe("/notes/vault");
       expect(config.integrations.obsidian.folder).toBe("plans");
       expect(config.integrations.obsidian.exportOn).toBe("approve");
@@ -114,14 +220,19 @@ describe("integrations.obsidian config", () => {
   });
 
   test("repo config layers over user config for the section", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-obs2-"));
     const user = join(dir, "user.toml");
     const repoRoot = join(dir, "repo");
     writeFileSync(user, `[integrations.obsidian]\nvault = "/user/vault"\nexportOn = "resolve"\n`);
     Bun.spawnSync(["mkdir", "-p", join(repoRoot, ".cueloop")]);
     writeFileSync(join(repoRoot, ".cueloop", "config.toml"), `[integrations.obsidian]\nfolder = "repo-plans"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: user, repoRoot });
+
+      // Assert
       expect(config.integrations.obsidian.vault).toBe("/user/vault"); // user layer survives
       expect(config.integrations.obsidian.exportOn).toBe("resolve");
       expect(config.integrations.obsidian.folder).toBe("repo-plans"); // repo layer wins
@@ -133,6 +244,7 @@ describe("integrations.obsidian config", () => {
 
 describe("actionFor", () => {
   test("resolves keys and shifted keys to actions", () => {
+    // Assert
     expect(actionFor(DEFAULT_KEYS, "j", false)).toBe("down");
     expect(actionFor(DEFAULT_KEYS, "g", true)).toBe("bottom"); // G
     expect(actionFor(DEFAULT_KEYS, "return", false)).toBe("submit");

package/src/config.ts

@@ -1,8 +1,9 @@
 /**
  * Layered TOML config: built-in defaults → user config → trusted repo
  * config → env. Sections: [keys] action = "combo" (every action rebindable),
- * [theme] per-token overrides, [ui] auto_close + editor, [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";
@@ -12,6 +13,7 @@ import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obs
 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[];
@@ -27,7 +29,11 @@ export type AutoClose = "off" | number;
 export interface CueloopConfig {
   keys: Record<string, string[]>;
   theme: Theme;
-  ui: { autoClose: AutoClose; editor?: string };
+  /**
+   * 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 };
   integrations: IntegrationsConfig;
 }
 
@@ -46,8 +52,12 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   prev_annotation: ["p"],
   delete_annotation: ["backspace"],
   submit: ["return", "enter"],
+  share: ["S"],
   quit: ["q"],
   walk: ["w"],
+  review_cycle: ["b"],
+  review_wider: ["]"],
+  review_narrower: ["["],
 };
 
 function parseToml(text: string): Record<string, unknown> {
@@ -68,12 +78,20 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
       out.keys[action] = Array.isArray(combo) ? combo : [combo];
     }
   }
-  const ui = raw["ui"] as { auto_close?: unknown; editor?: unknown } | undefined;
+  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)) {
@@ -101,13 +119,10 @@ export function loadConfig(options: { repoRoot?: string; userConfigPath?: string
   let config: CueloopConfig = {
     keys: { ...DEFAULT_KEYS },
     theme: { ...DARK },
-    ui: { autoClose: "off" },
+    ui: { autoClose: "off", reviewState: "expanded", reviewWidth: REVIEW_DEFAULT_WIDTH },
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
   };
-  const userPath =
-    options.userConfigPath ??
-    process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
+  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 {
@@ -128,26 +143,47 @@ export function actionFor(keys: Record<string, string[]>, name: string, shift: b
   return undefined;
 }
 
-/**
- * Persist the auto-close choice into the user config file. Line-level TOML
- * surgery on the one key we own: replace an existing `auto_close`, or append
- * an `[ui]` section - a full TOML writer is not worth its weight here.
- */
-export function persistAutoClose(value: AutoClose, userConfigPath?: string): void {
-  const path =
+function userConfigPathFrom(userConfigPath?: string): string {
+  return (
     userConfigPath ??
     process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
-  const rendered = value === "off" ? '"off"' : String(value);
+    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");
-  if (/^\s*auto_close\s*=/m.test(text)) {
-    text = text.replace(/^(\s*)auto_close\s*=.*$/m, `$1auto_close = ${rendered}`);
+  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]\nauto_close = ${rendered}`);
+    text = text.replace(/^\[ui\]\s*$/m, `[ui]\n${key} = ${rendered}`);
   } else {
-    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[ui]\nauto_close = ${rendered}\n`;
+    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);
+}

package/src/editor.test.ts

@@ -6,35 +6,42 @@ 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 });
   });
 });
@@ -62,12 +69,18 @@ describe("editInEditor", () => {
   };
 
   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(),
@@ -77,21 +90,29 @@ describe("editInEditor", () => {
         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(),
@@ -100,11 +121,14 @@ describe("editInEditor", () => {
         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/herdr.test.ts

@@ -15,6 +15,7 @@ afterEach(() => {
 
 describe("focusHerdrPane", () => {
   test("resolves the pane's tab and focuses it", () => {
+    // Arrange
     const log = join(dir, "calls.log");
     const stub = join(dir, "herdr");
     writeFileSync(
@@ -25,6 +26,8 @@ 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");
@@ -32,6 +35,7 @@ if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
   });
 
   test("a missing binary never throws", () => {
+    // Assert
     expect(focusHerdrPane(join(dir, "nope"), "w1:p1")).toBe(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 { publishShare, type ShareResult, type ShareTarget } from "./share";

package/src/integrations.test.ts

@@ -9,20 +9,32 @@ function integrations(overrides: Partial<typeof OBSIDIAN_DEFAULTS> = {}): Integr
 
 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();
   });