@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

package/src/server/lib/omp/core/registry.ts

@@ -0,0 +1,140 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-only port of omp-web's managed-project registry
+ * (omp-web/lib/project-registry.ts) — enough to reproduce how the omp-web
+ * sidebar composes its workspace list:
+ *
+ *   1. read ~/.omp/agent/projects.json (registered projects with alias /
+ *      sortOrder / hidden presentation state),
+ *   2. discover every project that has sessions on disk
+ *      (session-discovered projects, e.g. before omp-web registered them),
+ *   3. merge: registered first (sortOrder, then most-recently-added), hidden
+ *      entries excluded, discovered extras follow sorted by path.
+ *
+ * Kabmo only READS this file — it never writes the agent's registry.
+ */
+
+import { canonicalize, getProjectsRegistryPath } from '@/server/lib/omp/core/paths';
+import type { OmpProject } from '@/shared/types/omp/session';
+
+/** Error carrying a stable code (errors.* key) for client localization. */
+export class ProjectPathError extends Error {
+  code: string;
+  constructor(code: string, message: string) {
+    super(message);
+    this.name = 'ProjectPathError';
+    this.code = code;
+  }
+}
+
+export interface OmpProjectRegistryEntry {
+  /** Canonical project path (worktrees resolve to their main repo root). */
+  path: string;
+  /** ISO timestamp of the most recent explicit add. */
+  addedAt?: string;
+  /** True when the user removed the project from the sidebar. Hidden entries
+   *  suppress session re-discovery until the project is added again. */
+  hidden?: boolean;
+  /** Optional display-only workspace name. */
+  alias?: string;
+  /** Explicit sidebar position; lower values appear first. */
+  sortOrder?: number;
+}
+
+export interface OmpProjectRegistryFile {
+  version: 1;
+  projects: OmpProjectRegistryEntry[];
+}
+
+const EMPTY_REGISTRY: OmpProjectRegistryFile = { version: 1, projects: [] };
+
+function comparableProjectPath(value: string): string {
+  let normalized = value.replace(/\\/g, '/');
+  const windowsForm = /^[a-zA-Z]:[\\/]/.test(normalized) || /^\/\//.test(normalized);
+  normalized = normalized.replace(/\/{2,}/g, '/').replace(/\/+$/, '');
+  return windowsForm ? normalized.toLowerCase() : normalized;
+}
+
+/** Parse registry JSON; missing, corrupt, or foreign-shaped input yields an
+ *  empty registry rather than failing the whole sidebar. */
+export function parseProjectRegistry(raw: string): OmpProjectRegistryFile {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return EMPTY_REGISTRY;
+    if (!('projects' in parsed) || !Array.isArray(parsed.projects)) return EMPTY_REGISTRY;
+    const entries: OmpProjectRegistryEntry[] = [];
+    for (const item of parsed.projects) {
+      if (!item || typeof item !== 'object' || Array.isArray(item)) continue;
+      if (!('path' in item) || typeof item.path !== 'string' || !item.path.trim()) continue;
+      const record = item as Record<string, unknown>;
+      entries.push({
+        path: canonicalize(record.path as string),
+        addedAt: typeof record.addedAt === 'string' ? record.addedAt : undefined,
+        hidden: record.hidden === true,
+        alias: typeof record.alias === 'string' && record.alias.trim() ? record.alias.trim() : undefined,
+        sortOrder:
+          typeof record.sortOrder === 'number' && Number.isFinite(record.sortOrder) ? record.sortOrder : undefined,
+      });
+    }
+    return { version: 1, projects: entries };
+  } catch {
+    return EMPTY_REGISTRY;
+  }
+}
+
+/** Load ~/.omp/agent/projects.json (missing/corrupt → empty registry). */
+export async function loadProjectRegistry(registryPath: string = getProjectsRegistryPath()): Promise<OmpProjectRegistryFile> {
+  if (!(await Bun.file(registryPath).exists())) return EMPTY_REGISTRY;
+  try {
+    return parseProjectRegistry(await Bun.file(registryPath).text());
+  } catch {
+    return EMPTY_REGISTRY;
+  }
+}
+
+/**
+ * Merge registered projects with session-discovered ones, excluding hidden
+ * entries. Registered projects come first in most-recently-added order (or
+ * explicit sortOrder); discovered projects follow sorted by path.
+ */
+export function mergeProjects(registry: OmpProjectRegistryFile, discovered: Iterable<string>): OmpProject[] {
+  const hidden = new Set(
+    registry.projects.filter((p) => p.hidden).map((p) => comparableProjectPath(p.path)),
+  );
+  const registered: OmpProject[] = [];
+  const registeredSeen = new Set<string>();
+  for (const p of registry.projects
+    .filter((entry) => !entry.hidden)
+    .sort((a, b) => {
+      const aOrder = a.sortOrder ?? Number.POSITIVE_INFINITY;
+      const bOrder = b.sortOrder ?? Number.POSITIVE_INFINITY;
+      if (aOrder !== bOrder) return aOrder - bOrder;
+      return (b.addedAt ?? '').localeCompare(a.addedAt ?? '');
+    })) {
+    const key = comparableProjectPath(p.path);
+    if (registeredSeen.has(key)) continue; // tolerate hand-edited duplicates
+    registeredSeen.add(key);
+    registered.push({
+      path: p.path,
+      addedAt: p.addedAt,
+      alias: p.alias,
+      sortOrder: p.sortOrder,
+      discovered: false,
+    });
+  }
+
+  const extra: OmpProject[] = [];
+  const extraSeen = new Set<string>();
+  for (const raw of new Set([...discovered].filter(Boolean).map(canonicalize))) {
+    const key = comparableProjectPath(raw);
+    if (hidden.has(key) || registeredSeen.has(key) || extraSeen.has(key)) continue;
+    extraSeen.add(key);
+    extra.push({ path: raw, discovered: true });
+  }
+  extra.sort((a, b) => a.path.localeCompare(b.path));
+  return [...registered, ...extra];
+}

package/src/server/lib/omp/core/startup.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Startup gate: Kabmo must not run without a resolvable `omp` binary.
+ *
+ * Every live capability — RPC agent sessions, config get/set, session state,
+ * model lists, updates — shells out to that binary (see ./cli.ts), so a missing
+ * install is not a degraded mode to browse into: the UI would open onto an
+ * empty shell whose every action fails. Both entry points call this before
+ * binding a port (src/server/index.ts) or spawning a detached server
+ * (src/cli/lib/commands/serve.js), turning the failure into one actionable line
+ * instead of a health check that never passes.
+ *
+ * `MOCK=true` is exempt by definition — demo mode exists to run on presets
+ * without a real omp install.
+ */
+
+import { resolveOmpBin } from '@/server/lib/omp/core/cli';
+import { getAgentDir, getConfigRoot } from '@/server/lib/omp/core/paths';
+import { isMockMode } from '@/server/mock.server';
+
+/** Null when the app may start; otherwise the message to print before exiting. */
+export function ompStartupError(): string | null {
+  if (isMockMode()) return null;
+  if (resolveOmpBin()) return null;
+  return [
+    'omp binary not found — Kabmo cannot start.',
+    'Agent sessions, omp config, session state and updates all run through the `omp` CLI,',
+    'so the binary must be resolvable before the server starts.',
+    'Install AI Oh-My-Pi and put `omp` on your PATH, or set KABMO_OMP_BIN=/path/to/omp.',
+    'To run on demo data without an omp install, start with MOCK=true.',
+  ].join('\n');
+}
+
+interface OmpStartupPaths {
+  /** Resolved `omp` executable, or null when unresolved (mock mode). */
+  bin: string | null;
+  /** `~/.omp` — PI_CONFIG_DIR rename applied. */
+  configDir: string;
+  /** `~/.omp/agent` — PI_CODING_AGENT_DIR override applied. */
+  agentDir: string;
+}
+
+/** Startup banner lines. The caller owns the prefix.
+ *
+ *  These are the locations the running process actually uses: the executable it
+ *  spawns and the agent tree it reads. Printing them makes a misdirected install
+ *  (two omps on PATH, a stray PI_CODING_AGENT_DIR) visible in the log instead of
+ *  inferred from empty session lists. */
+export function ompStartupLogLines(): string[] {
+  const paths: OmpStartupPaths = {
+    bin: resolveOmpBin(),
+    configDir: getConfigRoot(),
+    agentDir: getAgentDir(),
+  };
+  return [
+    `omp binary:     ${paths.bin ?? 'not found (MOCK mode — presets only)'}`,
+    `omp config dir: ${paths.configDir}`,
+    `omp agent dir:  ${paths.agentDir}`,
+  ];
+}

package/src/server/lib/omp/core/worktree.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Read-only port of omp-web/lib/worktree.ts — resolves a session's cwd to the
+ * main repository root so sessions from git worktrees group under one project.
+ *
+ * A linked worktree's `git rev-parse --git-common-dir` points at the *main*
+ * repo's .git directory, so its parent is the project root shared by all
+ * worktrees. Non-git directories resolve to themselves. Results are cached on
+ * globalThis with a short TTL (this layer never mutates repos, so no eager
+ * invalidation is needed).
+ */
+
+import { promises as fsp } from 'fs';
+import { dirname, join } from 'path';
+import { pathExists } from '@/server/lib/omp/core/paths';
+import { GIT_ENV } from '@/server/lib/fs/git-run';
+
+declare global {
+  var __kabmoProjectCache: Map<string, { root: string; expiresAt: number }> | undefined;
+}
+
+const PROJECT_CACHE_TTL_MS = 60_000;
+
+async function realPathOrSelf(filePath: string): Promise<string> {
+  try {
+    return await fsp.realpath(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
+function getProjectCache(): Map<string, { root: string; expiresAt: number }> {
+  if (!globalThis.__kabmoProjectCache) globalThis.__kabmoProjectCache = new Map();
+  return globalThis.__kabmoProjectCache;
+}
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  const proc = Bun.spawn({
+    cmd: ['git', '-C', cwd, ...args],
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: 10_000,
+    maxBuffer: 1024 * 1024,
+    env: { ...Bun.env, LC_ALL: 'C', ...GIT_ENV },
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) throw new Error(`git ${args[0]} failed with exit code ${exitCode}`);
+  return stdout.trim();
+}
+
+function samePath(a: string, b: string): boolean {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return normalizeForComparison(a) === normalizeForComparison(b);
+}
+
+/** Case-insensitive comparison on win32, case-sensitive elsewhere. */
+function normalizeForComparison(value: string): string {
+  if (!value) return value;
+  const normalized = value.replace(/\\/g, '/').replace(/\/{2,}/g, '/').replace(/\/+$/, '');
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+/**
+ * Resolve a cwd to its repository root. Returns the cwd itself when it is not
+ * inside a git repository (or the directory does not exist). Cached per-cwd
+ * with a short TTL.
+ */
+export async function resolveProjectRoot(cwd: string): Promise<string> {
+  const cache = getProjectCache();
+  const cached = cache.get(cwd);
+  if (cached && cached.expiresAt > Date.now()) return cached.root;
+
+  let root: string;
+  try {
+    const dotGit = join(cwd, '.git');
+    if (!(await pathExists(cwd)) || !(await pathExists(dotGit))) {
+      root = await realPathOrSelf(cwd);
+    } else {
+      const out = await git(cwd, [
+        'rev-parse',
+        '--path-format=absolute',
+        '--git-common-dir',
+        '--show-toplevel',
+      ]);
+      const [commonDirRaw, toplevelRaw] = out.split('\n').map((l) => l.trim());
+      const commonDir = await realPathOrSelf(commonDirRaw || '');
+      const toplevel = await realPathOrSelf(toplevelRaw || '');
+      const realCwd = await realPathOrSelf(cwd);
+      const isTopLevel = samePath(toplevel, realCwd);
+      // For a linked worktree, --git-common-dir differs from the toplevel's
+      // .git: its parent is the MAIN repo root shared by all worktrees.
+      const isWorktreeTopLevel = isTopLevel && !samePath(dirname(commonDir), dirname(toplevel));
+      root = isWorktreeTopLevel ? await realPathOrSelf(dirname(commonDir)) : toplevel || realCwd;
+    }
+  } catch {
+    root = await realPathOrSelf(cwd);
+  }
+
+  cache.set(cwd, { root, expiresAt: Date.now() + PROJECT_CACHE_TTL_MS });
+  return root;
+}

package/src/server/lib/omp/extensions/locator.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The extension locator and its spawn environment.
+ *
+ * Two failure modes are pinned here, both silent in production:
+ *
+ *  - a locator that resolves nothing would spawn a child with NO mode extension,
+ *    so the composer's toggles would report success and change nothing;
+ *  - a mode-selection env value that omits the auto-continue flag would restore
+ *    goal mode but never let it continue past the first turn.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { kabmoExtensionArgs, kabmoExtensionEntry, kabmoModeEnv } from '@/server/lib/omp/extensions/locator';
+
+describe('kabmoExtensionEntry', () => {
+  test('resolves to a real file in this checkout', () => {
+    const entry = kabmoExtensionEntry();
+    expect(entry).not.toBeNull();
+    expect(existsSync(entry as string)).toBe(true);
+    // `join`, not a `/`-spelled tail: the host's separator can be `\`.
+    expect(entry?.endsWith(join('kabmo-modes', 'index.ts'))).toBe(true);
+  });
+
+  test('a checkout that still has the pre-rename folder resolves it', () => {
+    // The probe order is `kabmo-modes` then `chamber-modes`, and BOTH are real
+    // directory names on disk. Pinned here because the fallback is invisible:
+    // removing it makes an in-place upgrade spawn a child with no extension,
+    // and the composer's toggles then report success while changing nothing.
+    const entry = kabmoExtensionEntry();
+    expect(entry === null || /(kabmo|chamber)-modes/.test(entry)).toBe(true);
+  });
+
+  test('the spawn args load it with -e', () => {
+    const args = kabmoExtensionArgs();
+    expect(args[0]).toBe('-e');
+    expect(existsSync(args[1])).toBe(true);
+  });
+});
+
+describe('kabmoModeEnv', () => {
+  // Both spellings travel together: the extension file on disk may still be the
+  // one that reads `CHAMBER_MODES`, and the child reads whichever it knows. The
+  // values must be IDENTICAL — two spellings of one selection, not two sources.
+  test('names only the modes that are on, under both spellings', () => {
+    expect(kabmoModeEnv({ plan: true, goal: false })).toEqual({ KABMO_MODES: 'plan', CHAMBER_MODES: 'plan' });
+    expect(kabmoModeEnv({ plan: false, goal: false })).toEqual({ KABMO_MODES: '', CHAMBER_MODES: '' });
+  });
+
+  test('goal mode rides the selection, and nothing else', () => {
+    // The loop is Kabmo's now, so the child gets no continuation flag: it
+    // opens a turn only when Kabmo's auditor asks for one.
+    expect(kabmoModeEnv({ plan: false, goal: true })).toEqual({ KABMO_MODES: 'goal', CHAMBER_MODES: 'goal' });
+    expect(kabmoModeEnv({ plan: true, goal: true })).toEqual({ KABMO_MODES: 'plan,goal', CHAMBER_MODES: 'plan,goal' });
+  });
+
+  test('the legacy spelling carries the same value, never a second one', () => {
+    const env = kabmoModeEnv({ plan: true, goal: true });
+    expect(env.KABMO_MODES).toBe(env.CHAMBER_MODES);
+  });
+});

package/src/server/lib/omp/extensions/locator.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Where Kabmo's mode extension lives, and the spawn arguments that load
+ * it.
+ *
+ * `extensions/kabmo-modes/` is the extension's own folder, mirroring the
+ * repo's component convention (kebab-case folder, `index.ts` entry, suffix-only
+ * child names) — and that is also what makes the RELATIVE imports inside it
+ * legal: `-e <dir>/index.ts` resolves `./session` from the extension's own
+ * directory, so nothing there may use Kabmo's `@/` alias (the child
+ * process has no tsconfig for it).
+ *
+ * The extension ships WITH Kabmo (`extensions/`, next to `src/`) and is
+ * passed to the child as `-e <abs path>`. It is deliberately not installed into
+ * `~/.omp/agent/extensions/`:
+ *
+ *  - that directory is the USER's; writing there mutates their config,
+ *  - its entries are toggleable from Settings → Extensions, so a stray click
+ *    would silently disable the composer's mode toggles,
+ *  - and an upgrade would leave the old copy behind, with the child loading
+ *    whichever file the name happened to resolve to.
+ *
+ * An explicit `-e` is still honoured under `--no-extensions` (omp's own
+ * documented behaviour), so a user who disables ambient extension discovery
+ * keeps a working Plan/Goal toggle.
+ *
+ * Resolution walks up from this file, the same way `lib/assets/fonts.server.ts`
+ * does, because the running layout differs between a checkout (cwd = repo root)
+ * and the published bundle (`dist/client` as cwd, package root above it).
+ */
+
+import { existsSync } from 'node:fs';
+import { dirname, join, parse, resolve } from 'node:path';
+
+/** Absolute path of the extension entry, or null when the directory is absent
+ *  (a pruned install). A null makes the spawn path skip `-e` entirely rather
+ *  than pass a path omp would fail to load. */
+import { CHAMBER_MODES_ENV, KABMO_MODES_ENV } from '@/shared/lib/omp/mode/types';
+
+export function kabmoExtensionEntry(): string | null {
+  // `kabmo-modes` is the folder this build ships; `chamber-modes` is the
+  // pre-rename name, still probed so a checkout that upgraded in place (or a
+  // package tree an older release left behind) keeps a working toggle rather
+  // than silently spawning a child with no extension.
+  const dirs = ['kabmo-modes', 'chamber-modes'];
+  let dir = import.meta.dir;
+  const { root } = parse(dir);
+  for (;;) {
+    for (const name of dirs) {
+      const candidate = join(dir, 'extensions', name, 'index.ts');
+      if (existsSync(candidate)) return candidate;
+    }
+    if (dir === root) break;
+    dir = dirname(dir);
+  }
+  const cwd = resolve(process.cwd());
+  for (const name of dirs) {
+    const candidate = join(cwd, 'extensions', name, 'index.ts');
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/** Spawn arguments that load the mode extension. Empty when it cannot be
+ *  found, so a pruned install still spawns a working (if toggle-less) child. */
+export function kabmoExtensionArgs(): string[] {
+  const entry = kabmoExtensionEntry();
+  return entry ? ['-e', entry] : [];
+}
+
+/** Environment variables the extension reads at session start.
+ *
+ *  `KABMO_MODES` carries the persisted per-session selection. The pre-rename
+ *  `CHAMBER_MODES` is ALSO exported, because the extension file on disk may
+ *  still be the one that reads it — the two are written together for exactly one
+ *  release's worth of installs, and the extension reads the new name first.
+ *
+ *  There used to be a second flag here (`CHAMBER_GOAL_AUTO_CONTINUE`) because
+ *  the child armed its own loop; the loop belongs to Kabmo now, so the child has
+ *  nothing to arm and the flag is gone. */
+export function kabmoModeEnv(modes: { plan: boolean; goal: boolean }): Record<string, string> {
+  const list = [modes.plan ? 'plan' : '', modes.goal ? 'goal' : ''].filter(Boolean);
+  const value = list.join(',');
+  return { [KABMO_MODES_ENV]: value, [CHAMBER_MODES_ENV]: value };
+}
+
+/** @deprecated Use `kabmoExtensionEntry`. */
+export const chamberExtensionEntry = kabmoExtensionEntry;
+
+/** @deprecated Use `kabmoExtensionArgs`. */
+export const chamberExtensionArgs = kabmoExtensionArgs;
+
+/** @deprecated Use `kabmoModeEnv`. */
+export const chamberModeEnv = kabmoModeEnv;

package/src/server/lib/omp/mode/command-type.test.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The mode command's wire type, under both spellings.
+ *
+ * `kabmo_mode` is what this build's client posts and `chamber_mode` is the
+ * pre-rename spelling. The route has to accept BOTH: a tab that loaded before a
+ * server restart keeps posting the old token until it reloads, and a rejected
+ * request there reads as a dead Plan/Goal button — the toggle reports nothing
+ * and the mode never moves.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  LEGACY_MODE_COMMAND_TYPE,
+  MODE_COMMAND_TYPE,
+  isModeCommandType,
+  modeCommandPrompt,
+} from '@/server/lib/omp/mode/request';
+
+describe('mode command type', () => {
+  test('the current spelling is what this build sends', () => {
+    expect(MODE_COMMAND_TYPE).toBe('kabmo_mode');
+  });
+
+  test('both spellings are accepted, and nothing else is', () => {
+    expect(isModeCommandType(MODE_COMMAND_TYPE)).toBe(true);
+    expect(isModeCommandType(LEGACY_MODE_COMMAND_TYPE)).toBe(true);
+    expect(isModeCommandType('prompt')).toBe(false);
+    expect(isModeCommandType(undefined)).toBe(false);
+  });
+
+  test('the prompt carries the current command name, whichever type arrived', () => {
+    // The wire type and the slash command are separate names: the type decides
+    // which branch the route takes, the command decides what the child runs.
+    expect(modeCommandPrompt({ scope: 'plan', action: 'on' })).toBe('/kabmo-mode plan on');
+  });
+});

package/src/server/lib/omp/mode/live-selection.test.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The live-child mode read, and the rule that decides when it speaks.
+ *
+ * This exists because a new chat is ALIVE before it has a transcript: omp
+ * writes the JSONL at the first assistant message (measured: 40 s after the id
+ * was adopted), and the file-based read answered 404 in the meantime — which the
+ * composer treats as "no modes" and uses to reset the toggles the user just
+ * pressed. The child's own mirror and its spawn environment are the only two
+ * sources that describe it in that window, and the mirror wins where it has
+ * spoken because a toggle moves the child without re-spawning it.
+ *
+ * A wrapper that has said nothing returns null, so the route keeps its own
+ * answer instead of inventing an empty selection.
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { liveModeSelection } from '@/server/lib/omp/mode/live-selection';
+import { ModeMirror } from '@/server/lib/omp/rpc/mode-mirror';
+import { recordSpawnProvenance } from '@/server/lib/omp/rpc/spawn-provenance';
+
+const SESSION = 'sess-1';
+
+interface FakeWrapper {
+  modeMirror: ModeMirror;
+  isAlive(): boolean;
+}
+
+/** Register a fake wrapper the way the registry holds a real one: the mode read
+ *  goes through `getRpcSession` and the spawn env through the provenance map,
+ *  both keyed by the wrapper object itself. */
+function register(wrapper: FakeWrapper): FakeWrapper {
+  globalThis.__ompSessions ??= new Map();
+  globalThis.__ompSessions.set(SESSION, wrapper as never);
+  return wrapper;
+}
+
+function makeWrapper(alive = true): FakeWrapper {
+  return { modeMirror: new ModeMirror(), isAlive: () => alive };
+}
+
+afterEach(() => {
+  globalThis.__ompSessions?.delete(SESSION);
+  delete globalThis.__ompSessions;
+});
+
+describe('liveModeSelection', () => {
+  test('no live child is null, so the caller keeps its own answer', () => {
+    expect(liveModeSelection(SESSION)).toBeNull();
+    register(makeWrapper(false));
+    expect(liveModeSelection(SESSION)).toBeNull();
+  });
+
+  test('a child that has reported nothing is described by its spawn environment', () => {
+    const wrapper = register(makeWrapper());
+    recordSpawnProvenance(wrapper as never, 'yolo', { CHAMBER_MODES: 'plan' });
+
+    const live = liveModeSelection(SESSION);
+    expect(live?.spoken).toBe(false);
+    expect(live?.modes.plan).toBe(true);
+    expect(live?.modes.goal).toBe(false);
+    expect(live?.modes.goalRecord).toBeNull();
+  });
+
+  test('a marker makes the child speak, and overrides the spawn environment', () => {
+    const wrapper = register(makeWrapper());
+    recordSpawnProvenance(wrapper as never, 'yolo', { CHAMBER_MODES: 'plan' });
+    wrapper.modeMirror.observeMarker({ marker: 'CHAMBER_PLAN_STATE:' as never, payload: { enabled: false } });
+
+    const live = liveModeSelection(SESSION);
+    expect(live?.spoken).toBe(true);
+    expect(live?.modes.plan).toBe(false);
+  });
+
+  test('a goal marker alone counts as the child having spoken', () => {
+    const wrapper = register(makeWrapper());
+    wrapper.modeMirror.observeMarker({
+      marker: 'CHAMBER_GOAL_STATE:' as never,
+      payload: {
+        enabled: true,
+        goal: { id: 'g1', objective: 'ship it', status: 'active', tokensUsed: 0, timeUsedSeconds: 0, createdAt: 0, updatedAt: 0 },
+        continuation: { turn: 2, maxTurns: 25 },
+        maxTurns: 25,
+      },
+    });
+
+    const live = liveModeSelection(SESSION);
+    expect(live?.spoken).toBe(true);
+    expect(live?.modes.goal).toBe(true);
+    expect(live?.modes.goalLive).toBe(true);
+    expect(live?.modes.goalRecord?.objective).toBe('ship it');
+    expect(live?.modes.goalContinuation).toEqual({ turn: 2, maxTurns: 25 });
+    expect(live?.modes.goalMaxTurns).toBe(25);
+  });
+
+  test('a paused goal stays open but is not live', () => {
+    const wrapper = register(makeWrapper());
+    wrapper.modeMirror.observeMarker({
+      marker: 'CHAMBER_GOAL_STATE:' as never,
+      payload: {
+        enabled: false,
+        goal: { id: 'g1', objective: 'x', status: 'paused', tokensUsed: 0, timeUsedSeconds: 0, createdAt: 0, updatedAt: 0 },
+      },
+    });
+
+    const live = liveModeSelection(SESSION);
+    expect(live?.modes.goal).toBe(true);
+    expect(live?.modes.goalLive).toBe(false);
+  });
+
+  // A goal the chat no longer owns keeps its record (the timeline's card shows
+  // it) but must not re-open the composer's strip and button.
+  test('a complete or dropped goal is off while its record still travels', () => {
+    for (const status of ['complete', 'dropped'] as const) {
+      const wrapper = register(makeWrapper());
+      wrapper.modeMirror.observeMarker({
+        marker: 'CHAMBER_GOAL_STATE:' as never,
+        payload: {
+          enabled: false,
+          goal: { id: 'g1', objective: 'x', status, tokensUsed: 0, timeUsedSeconds: 0, createdAt: 0, updatedAt: 0 },
+        },
+      });
+
+      const live = liveModeSelection(SESSION);
+      expect(live?.modes.goal).toBe(false);
+      expect(live?.modes.goalRecord?.status).toBe(status);
+    }
+  });
+});