@cueloop/client 0.1.0-alpha.10 → 0.1.0-alpha.101

package/src/config.test.ts

@@ -1,116 +0,0 @@
-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 { DARK } from "./theme";
-
-describe("loadConfig", () => {
-  test("defaults when no file exists", () => {
-    const c = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
-    expect(c.keys["comment"]).toEqual(["c"]);
-    expect(c.theme.accent).toBe(DARK.accent);
-  });
-
-  test("user config rebinds actions and overrides theme tokens", () => {
-    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 {
-      const c = loadConfig({ userConfigPath: path });
-      expect(c.keys["comment"]).toEqual(["a"]);
-      expect(c.keys["submit"]).toEqual(["return", "S"]);
-      expect(c.keys["cut"]).toEqual(["x"]); // untouched defaults survive
-      expect(c.theme.accent).toBe("#ff0000");
-      expect(c.theme.green).toBe(DARK.green);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("repo config layers over user config", () => {
-    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 {
-      const c = loadConfig({ userConfigPath: user, repoRoot });
-      expect(c.keys["comment"]).toEqual(["z"]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("broken config never blocks a review", () => {
-    const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg3-"));
-    const path = join(dir, "config.toml");
-    writeFileSync(path, "not [valid toml");
-    try {
-      const c = loadConfig({ userConfigPath: path });
-      expect(c.keys["comment"]).toEqual(["c"]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("integrations.obsidian config", () => {
-  test("defaults when the section is absent", () => {
-    const c = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
-    expect(c.integrations.obsidian.vault).toBeUndefined();
-    expect(c.integrations.obsidian.folder).toBe("cueloop");
-    expect(c.integrations.obsidian.filenameFormat).toBe("{YYYY}-{MM}-{DD} - {title}");
-    expect(c.integrations.obsidian.separator).toBe("space");
-    expect(c.integrations.obsidian.exportOn).toBe("manual");
-  });
-
-  test("user config sets the section; invalid enum values are ignored", () => {
-    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 {
-      const c = loadConfig({ userConfigPath: path });
-      expect(c.integrations.obsidian.vault).toBe("/notes/vault");
-      expect(c.integrations.obsidian.folder).toBe("plans");
-      expect(c.integrations.obsidian.exportOn).toBe("approve");
-      expect(c.integrations.obsidian.separator).toBe("space"); // invalid value falls back
-      expect(c.keys["comment"]).toEqual(["c"]); // other sections untouched
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("repo config layers over user config for the section", () => {
-    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 {
-      const c = loadConfig({ userConfigPath: user, repoRoot });
-      expect(c.integrations.obsidian.vault).toBe("/user/vault"); // user layer survives
-      expect(c.integrations.obsidian.exportOn).toBe("resolve");
-      expect(c.integrations.obsidian.folder).toBe("repo-plans"); // repo layer wins
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("actionFor", () => {
-  test("resolves keys and shifted keys to actions", () => {
-    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");
-    expect(actionFor(DEFAULT_KEYS, "zz", false)).toBeUndefined();
-  });
-});

package/src/config.ts

@@ -1,150 +0,0 @@
-/**
- * Layered TOML config (#20): 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.
- */
-
-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";
-
-export interface KeymapConfig {
-  [action: string]: string | string[];
-}
-
-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: { autoClose: AutoClose };
-  integrations: IntegrationsConfig;
-}
-
-/** Every action in the grammar, with its default binding(s). */
-export const DEFAULT_KEYS: Record<string, string[]> = {
-  down: ["j", "down"],
-  up: ["k", "up"],
-  top: ["g"],
-  bottom: ["G"],
-  span: ["v"],
-  comment: ["c"],
-  suggest: ["s"],
-  cut: ["x"],
-  edit: ["e"],
-  next_annotation: ["n"],
-  prev_annotation: ["p"],
-  delete_annotation: ["backspace"],
-  submit: ["return", "enter"],
-  quit: ["q"],
-};
-
-function parseToml(text: string): Record<string, unknown> {
-  // Bun ships a native TOML parser
-  return Bun.TOML.parse(text) as Record<string, unknown>;
-}
-
-function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig {
-  const out: CueloopConfig = {
-    keys: { ...base.keys },
-    theme: { ...base.theme },
-    ui: { ...base.ui },
-    integrations: { obsidian: { ...base.integrations.obsidian } },
-  };
-  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 } | 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;
-  }
-  const theme = raw["theme"] as Partial<Record<keyof Theme, string>> | undefined;
-  if (theme) {
-    for (const [token, value] of Object.entries(theme)) {
-      if (token in out.theme && typeof value === "string") {
-        (out.theme as unknown as Record<string, string>)[token] = value;
-      }
-    }
-  }
-  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;
-  }
-  return out;
-}
-
-export function loadConfig(opts: { repoRoot?: string; userConfigPath?: string } = {}): CueloopConfig {
-  let config: CueloopConfig = {
-    keys: { ...DEFAULT_KEYS },
-    theme: { ...DARK },
-    ui: { autoClose: "off" },
-    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]) {
-    if (!path || !existsSync(path)) continue;
-    try {
-      config = layer(config, parseToml(readFileSync(path, "utf8")));
-    } catch {
-      // a broken config never blocks a review; defaults win
-    }
-  }
-  return config;
-}
-
-/** Reverse lookup: key name (+shift) → action, per the loaded keymap. */
-export function actionFor(keys: Record<string, string[]>, name: string, shift: boolean): string | undefined {
-  const wanted = shift && name.length === 1 ? name.toUpperCase() : name;
-  for (const [action, combos] of Object.entries(keys)) {
-    if (combos.includes(wanted)) return action;
-  }
-  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 =
-    userConfigPath ??
-    process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
-  const rendered = value === "off" ? '"off"' : String(value);
-  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}`);
-  } else if (/^\[ui\]/m.test(text)) {
-    text = text.replace(/^\[ui\]\s*$/m, `[ui]\nauto_close = ${rendered}`);
-  } else {
-    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[ui]\nauto_close = ${rendered}\n`;
-  }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, text);
-}

package/src/editor.ts

@@ -1,34 +0,0 @@
-/**
- * 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.
- */
-
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export interface EditResult {
-  content: string;
-  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)");
-  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");
-    return { content: next, changed: next !== content };
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}

package/src/herdr.test.ts

@@ -1,68 +0,0 @@
-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, returnPaneFor } from "./herdr";
-
-let dir: string;
-const savedEnv: Record<string, string | undefined> = {};
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-"));
-  for (const k of ["HERDR_ENV", "HERDR_PANE_ID", "HERDR_BIN_PATH", "CUELOOP_RETURN_PANE"]) {
-    savedEnv[k] = process.env[k];
-    delete process.env[k];
-  }
-});
-afterEach(() => {
-  for (const [k, v] of Object.entries(savedEnv)) {
-    if (v === undefined) delete process.env[k];
-    else process.env[k] = v;
-  }
-  rmSync(dir, { recursive: true, force: true });
-});
-
-describe("returnPaneFor", () => {
-  test("outside herdr there is never a return target", () => {
-    expect(returnPaneFor("w1:p1")).toBeUndefined();
-  });
-
-  test("env override wins, session meta is the fallback", () => {
-    process.env.HERDR_ENV = "1";
-    process.env.HERDR_PANE_ID = "w1:p9";
-    expect(returnPaneFor("w1:p1")).toBe("w1:p1");
-    process.env.CUELOOP_RETURN_PANE = "w1:p2";
-    expect(returnPaneFor("w1:p1")).toBe("w1:p2");
-  });
-
-  test("returning to our own pane is a no-op", () => {
-    process.env.HERDR_ENV = "1";
-    process.env.HERDR_PANE_ID = "w1:p1";
-    expect(returnPaneFor("w1:p1")).toBeUndefined();
-  });
-});
-
-describe("focusHerdrPane", () => {
-  test("resolves the pane's tab and focuses it", () => {
-    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]);
-    process.env.HERDR_BIN_PATH = stub;
-    expect(focusHerdrPane("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", () => {
-    process.env.HERDR_BIN_PATH = join(dir, "nope");
-    expect(focusHerdrPane("w1:p1")).toBe(false);
-  });
-});

package/src/herdr.ts

@@ -1,34 +0,0 @@
-/**
- * First-class herdr return (#23): a review opened beside an agent should hand
- * focus back to the agent's pane when it closes, not leave the reviewer on a
- * dead tab. Detection is the ambient env contract; the return target comes
- * from CUELOOP_RETURN_PANE (set by whoever opened this pane) or the session's
- * recorded herdrPane (set by the adapter hook). Everything here is
- * best-effort: focus failures never block closing the review.
- */
-
-export function insideHerdr(): boolean {
-  return process.env.HERDR_ENV === "1";
-}
-
-export function returnPaneFor(sessionHerdrPane?: string): string | undefined {
-  if (!insideHerdr()) return undefined;
-  const pane = process.env.CUELOOP_RETURN_PANE ?? sessionHerdrPane;
-  // returning to our own pane would be a no-op at best
-  return pane && pane !== process.env.HERDR_PANE_ID ? pane : undefined;
-}
-
-/** Focus the tab holding the target pane. Synchronous: runs just before exit. */
-export function focusHerdrPane(paneId: string): boolean {
-  const bin = process.env.HERDR_BIN_PATH ?? "herdr";
-  try {
-    const got = Bun.spawnSync([bin, "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([bin, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" }).exitCode === 0;
-  } catch {
-    return false;
-  }
-}

package/src/keymap.test.ts

@@ -1,270 +0,0 @@
-/**
- * The keyboard grammar as data: every mode x key produces a known intent
- * list, the read-only rule is one gate, and plan and diff reviews share one
- * path for annotation navigation, deletion, and submit.
- */
-
-import { describe, expect, test } from "bun:test";
-import { DEFAULT_KEYS } from "./config";
-import { reduceKey, type Intent, type KeyState } from "./keymap";
-
-function state(patch: Partial<KeyState> = {}): KeyState {
-  return {
-    keys: DEFAULT_KEYS,
-    readOnly: false,
-    overlay: "none",
-    view: "plan",
-    spanMode: false,
-    resolved: false,
-    hasInboxItems: true,
-    annotationCount: 1,
-    hasFocusedAnnotation: true,
-    cursorAnnotatable: true,
-    ...patch,
-  };
-}
-
-function key(name: string, shift = false): { name: string; shift: boolean } {
-  return { name, shift };
-}
-
-describe("compose overlay", () => {
-  const s = state({ overlay: "compose" });
-  const table: [string, Intent[]][] = [
-    ["escape", [{ t: "closeOverlay" }]],
-    ["return", [{ t: "saveCompose" }]],
-    ["enter", [{ t: "saveCompose" }]],
-    ["left", []],
-    ["right", []],
-    ["j", []],
-    ["q", []],
-  ];
-  for (const [name, expected] of table) {
-    test(`${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name))).toEqual(expected);
-    });
-  }
-});
-
-describe("submit overlay", () => {
-  const s = state({ overlay: "submit" });
-  const table: [string, Intent[]][] = [
-    ["escape", [{ t: "closeOverlay" }]],
-    ["return", [{ t: "submitVerdict" }]],
-    ["enter", [{ t: "submitVerdict" }]],
-    ["left", [{ t: "cycleVerdict", dir: -1 }]],
-    ["right", [{ t: "cycleVerdict", dir: 1 }]],
-    ["j", []],
-    ["q", []],
-  ];
-  for (const [name, expected] of table) {
-    test(`${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name))).toEqual(expected);
-    });
-  }
-});
-
-describe("completion overlay", () => {
-  const prompt = state({ overlay: "completion-prompt" });
-  const counting = state({ overlay: "completion-counting" });
-  const table: [KeyState, string, Intent[]][] = [
-    [prompt, "return", [{ t: "finishReview" }]],
-    [prompt, "enter", [{ t: "finishReview" }]],
-    [prompt, "q", [{ t: "finishReview" }]],
-    [prompt, "a", [{ t: "optInAutoClose" }]],
-    [prompt, "escape", [{ t: "dismissCompletion" }]],
-    [prompt, "j", []],
-    [counting, "return", [{ t: "finishReview" }]],
-    [counting, "q", [{ t: "finishReview" }]],
-    [counting, "a", []],
-    [counting, "escape", [{ t: "dismissCompletion" }]],
-  ];
-  for (const [s, name, expected] of table) {
-    test(`${s.overlay} ${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name))).toEqual(expected);
-    });
-  }
-});
-
-describe("inbox mode", () => {
-  const s = state({ view: "inbox" });
-  const table: [string, Intent[]][] = [
-    ["j", [{ t: "inboxMove", to: "down" }]],
-    ["down", [{ t: "inboxMove", to: "down" }]],
-    ["k", [{ t: "inboxMove", to: "up" }]],
-    ["up", [{ t: "inboxMove", to: "up" }]],
-    ["return", [{ t: "openSession" }]],
-    ["enter", [{ t: "openSession" }]],
-    ["q", [{ t: "exit" }]],
-    ["c", []],
-    ["escape", []],
-  ];
-  for (const [name, expected] of table) {
-    test(`${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name))).toEqual(expected);
-    });
-  }
-
-  test("an empty inbox swallows every non-quit key", () => {
-    const empty = state({ view: "inbox", hasInboxItems: false });
-    for (const name of ["j", "k", "down", "up", "return", "enter"]) {
-      expect(reduceKey(empty, key(name))).toEqual([]);
-    }
-    expect(reduceKey(empty, key("q"))).toEqual([{ t: "exit" }]);
-  });
-});
-
-describe("plan normal mode", () => {
-  const s = state();
-  const table: [string, boolean, Intent[]][] = [
-    ["j", false, [{ t: "move", to: "down" }]],
-    ["down", false, [{ t: "move", to: "down" }]],
-    ["k", false, [{ t: "move", to: "up" }]],
-    ["up", false, [{ t: "move", to: "up" }]],
-    ["g", false, [{ t: "move", to: "top" }]],
-    ["g", true, [{ t: "move", to: "bottom" }]],
-    ["v", false, [{ t: "startSpan" }]],
-    ["c", false, [{ t: "openCompose", kind: "comment", from: "cursor" }]],
-    ["s", false, [{ t: "openCompose", kind: "suggestion", from: "cursor" }]],
-    // the default state has a selected card, so Cut and edit act on the card
-    ["x", false, [{ t: "removeAnnotation" }]],
-    ["e", false, [{ t: "editCard" }]],
-    ["n", false, [{ t: "nextAnn" }]],
-    ["p", false, [{ t: "prevAnn" }]],
-    ["backspace", false, [{ t: "removeAnnotation" }]],
-    ["return", false, [{ t: "openSubmit" }]],
-    ["q", false, [{ t: "exit" }]],
-    ["escape", false, [{ t: "deselect" }]],
-    ["z", false, []],
-  ];
-  for (const [name, shift, expected] of table) {
-    test(`${shift ? "shift+" : ""}${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name, shift))).toEqual(expected);
-    });
-  }
-
-  test("resolved sessions guard the mutating verbs", () => {
-    const r = state({ resolved: true });
-    for (const name of ["c", "s", "x", "e"]) {
-      expect(reduceKey(r, key(name))).toEqual([{ t: "status", msg: "review submitted - read-only" }]);
-    }
-    expect(reduceKey(r, key("return"))).toEqual([]);
-    expect(reduceKey(r, key("backspace"))).toEqual([]);
-  });
-
-  test("cut text cannot host a comment or a span", () => {
-    const cut = state({ cursorAnnotatable: false });
-    expect(reduceKey(cut, key("c"))).toEqual([{ t: "status", msg: "text is cut - restore it first" }]);
-    expect(reduceKey(cut, key("s"))).toEqual([{ t: "status", msg: "text is cut - restore it first" }]);
-    expect(reduceKey(cut, key("v"))).toEqual([]);
-  });
-
-  test("annotation navigation without annotations reports, delete without focus is silent", () => {
-    const none = state({ annotationCount: 0, hasFocusedAnnotation: false });
-    expect(reduceKey(none, key("n"))).toEqual([{ t: "status", msg: "no annotations" }]);
-    expect(reduceKey(none, key("p"))).toEqual([{ t: "status", msg: "no annotations" }]);
-    expect(reduceKey(none, key("backspace"))).toEqual([]);
-  });
-
-  test("without a selected card x cuts the block and e opens the editor", () => {
-    const unfocused = state({ hasFocusedAnnotation: false });
-    expect(reduceKey(unfocused, key("x"))).toEqual([{ t: "cut" }]);
-    expect(reduceKey(unfocused, key("e"))).toEqual([{ t: "edit" }]);
-  });
-});
-
-describe("span mode", () => {
-  const s = state({ spanMode: true });
-  const table: [string, Intent[]][] = [
-    ["l", [{ t: "spanKey", name: "l" }]],
-    ["h", [{ t: "spanKey", name: "h" }]],
-    ["w", [{ t: "spanKey", name: "w" }]],
-    ["b", [{ t: "spanKey", name: "b" }]],
-    ["$", [{ t: "spanKey", name: "$" }]],
-    ["0", [{ t: "spanKey", name: "0" }]],
-    ["c", [{ t: "openCompose", kind: "comment", from: "span" }]],
-    ["s", [{ t: "openCompose", kind: "suggestion", from: "span" }]],
-    ["escape", [{ t: "closeOverlay" }]],
-    ["q", [{ t: "exit" }]],
-    ["j", []],
-  ];
-  for (const [name, expected] of table) {
-    test(`${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name))).toEqual(expected);
-    });
-  }
-});
-
-describe("diff mode", () => {
-  const s = state({ view: "diff" });
-  const table: [string, Intent[]][] = [
-    ["j", [{ t: "move", to: "down" }]],
-    ["k", [{ t: "move", to: "up" }]],
-    ["g", [{ t: "move", to: "top" }]],
-    ["c", [{ t: "openCompose", kind: "comment", from: "cursor" }]],
-    ["n", [{ t: "nextAnn" }]],
-    ["p", [{ t: "prevAnn" }]],
-    ["backspace", [{ t: "removeAnnotation" }]],
-    ["return", [{ t: "openSubmit" }]],
-    ["v", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
-    ["x", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
-    ["e", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
-    ["s", [{ t: "status", msg: "plan-only verb - diff review uses c on a line" }]],
-    ["q", [{ t: "exit" }]],
-  ];
-  for (const [name, expected] of table) {
-    test(`${name} -> ${JSON.stringify(expected)}`, () => {
-      expect(reduceKey(s, key(name))).toEqual(expected);
-    });
-  }
-
-  test("comment guards: resolved first, then non-code rows", () => {
-    expect(reduceKey(state({ view: "diff", resolved: true }), key("c"))).toEqual([
-      { t: "status", msg: "review submitted - read-only" },
-    ]);
-    expect(reduceKey(state({ view: "diff", cursorAnnotatable: false }), key("c"))).toEqual([
-      { t: "status", msg: "move to a code line to comment" },
-    ]);
-  });
-});
-
-describe("duplicated-branch collapse", () => {
-  test("plan and diff produce the same intents for annotation nav, delete, and submit", () => {
-    for (const patch of [
-      {},
-      { annotationCount: 0, hasFocusedAnnotation: false },
-      { resolved: true },
-    ] as Partial<KeyState>[]) {
-      for (const name of ["n", "p", "backspace", "return"]) {
-        const plan = reduceKey(state(patch), key(name));
-        const diff = reduceKey(state({ ...patch, view: "diff" }), key(name));
-        expect(diff).toEqual(plan);
-      }
-    }
-  });
-});
-
-describe("read-only filter", () => {
-  test("every mutating key answers observer - read-only, in plan and diff", () => {
-    for (const view of ["plan", "diff"] as const) {
-      const s = state({ view, readOnly: true });
-      for (const name of ["c", "s", "x", "e", "backspace", "return", "enter"]) {
-        expect(reduceKey(s, key(name))).toEqual([{ t: "status", msg: "observer - read-only" }]);
-      }
-    }
-  });
-
-  test("navigation and annotation focus still work for observers", () => {
-    const s = state({ readOnly: true });
-    expect(reduceKey(s, key("j"))).toEqual([{ t: "move", to: "down" }]);
-    expect(reduceKey(s, key("n"))).toEqual([{ t: "nextAnn" }]);
-    expect(reduceKey(s, key("q"))).toEqual([{ t: "exit" }]);
-  });
-
-  test("span-mode c/s are gated by key name even under a rebound keymap", () => {
-    const rebound = { ...DEFAULT_KEYS, comment: ["m"], suggest: ["t"] };
-    const s = state({ spanMode: true, readOnly: true, keys: rebound });
-    expect(reduceKey(s, key("c"))).toEqual([{ t: "status", msg: "observer - read-only" }]);
-    expect(reduceKey(s, key("s"))).toEqual([{ t: "status", msg: "observer - read-only" }]);
-  });
-});