ompchamber 3.5.0 → 3.6.0

package/src/server/lib/db/compact-chat-overlay.test.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The overlay repair. Its whole risk is asymmetric: narrowing a row it should
+ * not touch DESTROYS a conversation (for a chamber-created session the DB is the
+ * only copy there is), while leaving a row it should narrow merely wastes disk.
+ * So the file-existence gate is the behaviour under test, and it is exercised
+ * against a real temp tree rather than a stub — `findSessionFileById` is the
+ * thing being trusted.
+ *
+ * The pass has no marker on purpose (see the module): the per-row "did the
+ * filter shrink it?" guard is what makes it self-limiting, so a second run must
+ * find nothing left to do.
+ */
+
+import { afterAll, describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createDb, type DbClient } from '@/server/lib/db/client';
+import { initSchema } from '@/server/lib/db/schema';
+import { compactChatOverlayRows } from '@/server/lib/db/compact-chat-overlay';
+
+const WITH_FILE = '01a0dddd-1111-7222-8333-444455556666';
+const CHAMBER_ONLY = 'new-1700000000000';
+const NOTICE = 'Context window: 1000000 tokens (1% used)';
+
+/** Mirrored shape: the user turn plus assistant rows no reader ever touches. */
+const MIRRORED = [
+  { id: 'msg-1-user', role: 'user', content: 'hello' },
+  { id: 'omp-a1', role: 'ai', content: 'hi there' },
+  { id: 'cmdout-1', role: 'ai', content: '', notice: NOTICE },
+  { id: 'omp-a2', role: 'ai', content: 'more' },
+];
+/** A chamber-created conversation: no session file exists for it. */
+const CHAMBER = [
+  { id: 'msg-9-user', role: 'user', content: 'ask' },
+  { id: 'local-ai', role: 'ai', content: 'answer' },
+];
+
+const cleanup: string[] = [];
+afterAll(() => {
+  for (const target of cleanup) rmSync(target, { recursive: true, force: true });
+});
+
+function tempDir(label: string): string {
+  const dir = join(tmpdir(), `overlay-${label}-${crypto.randomUUID()}`);
+  cleanup.push(dir);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** A sessions root holding exactly one session file, named the way omp names it. */
+function sessionsRoot(): string {
+  const root = tempDir('root');
+  const project = join(root, '--proj--');
+  mkdirSync(project, { recursive: true });
+  writeFileSync(
+    join(project, `2026-01-01T00-00-00-000Z_${WITH_FILE}.jsonl`),
+    `${JSON.stringify({ type: 'session', id: WITH_FILE, timestamp: '2026-01-01T00:00:00.000Z', cwd: '/' })}\n`,
+  );
+  return root;
+}
+
+async function seededDb() {
+  const db = createDb(join(tempDir('db'), 'db.sqlite'));
+  await initSchema(db);
+  const put = (sessionId: string, messages: unknown[]) =>
+    db.run('INSERT OR REPLACE INTO chat_sessions (session_id, title, messages) VALUES (?, ?, ?)', [
+      sessionId,
+      't',
+      JSON.stringify(messages),
+    ]);
+  await put(WITH_FILE, MIRRORED);
+  await put(CHAMBER_ONLY, CHAMBER);
+  return db;
+}
+
+async function storedMessages(db: DbClient, sessionId: string) {
+  const row = (await db.get('SELECT messages FROM chat_sessions WHERE session_id = ?', [sessionId])) as {
+    messages: string;
+  };
+  return JSON.parse(row.messages) as { id: string; role: string }[];
+}
+
+describe('compactChatOverlayRows', () => {
+  test('narrows a mirrored row whose session file exists', async () => {
+    const db = await seededDb();
+    await compactChatOverlayRows(db, sessionsRoot());
+
+    const kept = await storedMessages(db, WITH_FILE);
+    expect(kept.map((m) => m.id)).toEqual(['msg-1-user', 'cmdout-1']);
+  });
+
+  test('leaves a chamber-created row untouched — the DB is its only copy', async () => {
+    const db = await seededDb();
+    await compactChatOverlayRows(db, sessionsRoot());
+
+    expect(await storedMessages(db, CHAMBER_ONLY)).toEqual(CHAMBER);
+  });
+
+  test('finds nothing left to do on a second run', async () => {
+    const db = await seededDb();
+    const root = sessionsRoot();
+    await compactChatOverlayRows(db, root);
+    const once = JSON.stringify({
+      mirrored: await storedMessages(db, WITH_FILE),
+      chamber: await storedMessages(db, CHAMBER_ONLY),
+    });
+
+    await compactChatOverlayRows(db, root);
+
+    expect(
+      JSON.stringify({
+        mirrored: await storedMessages(db, WITH_FILE),
+        chamber: await storedMessages(db, CHAMBER_ONLY),
+      }),
+    ).toBe(once);
+  });
+});

package/src/server/lib/db/compact-chat-overlay.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Boot-time repair of the `chat_sessions` overlay.
+ *
+ * The overlay used to be a full mirror of every conversation: the chat timeline
+ * posted its whole rendered message list on every `message_end`, so each stored
+ * row carried a copy of the transcript omp already owns in the session JSONL.
+ * `overlayRowsForOmpSession` narrows what is written from now on, and this pass
+ * applies the same rule to rows written before it existed — measured on the
+ * author's install, 165.6 MB of 167.9 MB of mirrored rows were assistant
+ * messages no reader ever touches.
+ *
+ * It has NO marker, deliberately, and that is the difference from the
+ * `queue_fk_removed` migration: the guard here is per-row ("does the filter
+ * actually shrink this row?"), which makes the pass self-limiting rather than
+ * once-only. A marker would be set after the first clean pass and then leave
+ * every row written by an older build uncompacted for good — a live server has
+ * to be restarted for the narrowed writer to take effect, and it keeps writing
+ * mirrors until it is.
+ *
+ * Two properties keep it safe on an existing database:
+ *
+ * - It only rewrites a row whose session file EXISTS. For a chamber-created
+ *   session the DB is the only copy, so those rows are left exactly as they are.
+ * - It only rewrites a row it actually shrinks, so the cost is proportional to
+ *   what is left to fix: 762 ms for a 173 MB overlay on first run, and one
+ *   parse-and-skip of the remaining ~5 MB on every later start.
+ *
+ * A failure is logged rather than thrown: it must never be able to stop the
+ * server from starting. It is called from the server bootstrap right after the
+ * "listening" banner and deliberately NOT from `getDb()` — the test suite and
+ * the CLI reach that in real mode, so a database HANDLE would be able to launch
+ * the rewrite (verified the hard way: a `bun test` run compacted a live
+ * database).
+ */
+
+import type { DbClient } from '@/server/lib/db/client';
+import { findSessionFileById } from '@/server/lib/omp/session/locator';
+import { overlayRowsForOmpSession } from '@/server/lib/omp/session/merge-stored';
+
+/**
+ * Rewrite every over-full `chat_sessions` row whose transcript omp owns.
+ *
+ * `sessionsRoot` is the locator's own seam, forwarded so a test can point the
+ * file lookup at its own tree instead of the real agent directory.
+ */
+export async function compactChatOverlayRows(db: DbClient, sessionsRoot?: string): Promise<void> {
+  try {
+    const rows = (await db.all('SELECT session_id, messages FROM chat_sessions')) as {
+      session_id: string;
+      messages: string;
+    }[];
+
+    let compacted = 0;
+    let reclaimed = 0;
+    for (const row of rows) {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(row.messages);
+      } catch {
+        // Unparseable is not ours to fix: the readers already treat it as empty.
+        continue;
+      }
+      if (!Array.isArray(parsed) || parsed.length === 0) continue;
+
+      const reduced = overlayRowsForOmpSession(parsed);
+      // The filter only ever removes, so an unchanged length means nothing to do
+      // — and the file lookup below is the expensive half, so it comes second.
+      if (reduced.length === parsed.length) continue;
+      if (!(await findSessionFileById(row.session_id, sessionsRoot))) continue;
+
+      const next = JSON.stringify(reduced);
+      await db.run('UPDATE chat_sessions SET messages = ? WHERE session_id = ?', [next, row.session_id]);
+      compacted += 1;
+      reclaimed += row.messages.length - next.length;
+    }
+
+    if (compacted > 0) {
+      console.log(
+        `[chat-overlay] compacted ${compacted} mirrored session row(s), reclaimed ${(reclaimed / 1e6).toFixed(1)} MB`,
+      );
+    }
+  } catch (error) {
+    console.warn('[chat-overlay] compaction failed; will retry on next start:', error);
+  }
+}

package/src/server/lib/lifecycle/fd-pressure.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'bun:test';
+import fs from 'node:fs';
+import { SPAWN_CLIFF, countOpenFileDescriptors, describeSpawnFailure } from '@/server/lib/lifecycle/fd-pressure';
+
+describe('countOpenFileDescriptors', () => {
+  test('sweeps this process own descriptors on a POSIX host', () => {
+    const pressure = countOpenFileDescriptors();
+    if (process.platform === 'win32') {
+      expect(pressure).toBeNull();
+      return;
+    }
+    expect(pressure).not.toBeNull();
+    // Stdio is always open, and the sweep never walks past Darwin's OPEN_MAX —
+    // a descriptor above it cannot be opened, which is the whole point.
+    expect(pressure?.open).toBeGreaterThanOrEqual(3);
+    expect(pressure?.highest).toBeGreaterThanOrEqual(2);
+    expect(pressure?.limit).toBeLessThanOrEqual(SPAWN_CLIFF);
+    expect(pressure?.nearCliff).toBe(false);
+  });
+
+  test('counts descriptors opened and closed around it', () => {
+    const before = countOpenFileDescriptors();
+    if (!before) return; // Host cannot answer; nothing to assert.
+    const opened = [0, 1, 2, 3, 4].map(() => fs.openSync('/dev/null', 'r'));
+    try {
+      const during = countOpenFileDescriptors();
+      expect(during!.open - before.open).toBeGreaterThanOrEqual(opened.length);
+      expect(during!.highest).toBeGreaterThanOrEqual(Math.max(...opened));
+    } finally {
+      for (const fd of opened) fs.closeSync(fd);
+    }
+  });
+});
+
+describe('describeSpawnFailure', () => {
+  test('passes an unrelated failure through untouched', () => {
+    // The helper must not relabel a genuine bad-descriptor or ENOENT bug as
+    // resource pressure; only an observable full table earns the extra text.
+    expect(describeSpawnFailure(new Error('spawn ENOENT'))).toBe('spawn ENOENT');
+    expect(describeSpawnFailure('boom')).toBe('boom');
+  });
+
+  test('names exhaustion only when the table really is full', () => {
+    const opened: number[] = [];
+    try {
+      while (opened.length < SPAWN_CLIFF + 16) {
+        try {
+          opened.push(fs.openSync('/dev/null', 'r'));
+        } catch {
+          break; // Host limit is lower than the cliff; the gate is untestable here.
+        }
+      }
+      if (!countOpenFileDescriptors()?.nearCliff) return;
+
+      const raw = "EBADF: bad file descriptor, posix_spawn '/bin/sh'";
+      const described = describeSpawnFailure(new Error(raw));
+      expect(described.startsWith(raw)).toBe(true);
+      expect(described).toContain('out of file descriptors');
+      // The symptom gate still holds under pressure: an unrelated failure keeps
+      // its own message instead of being blamed on the descriptor table.
+      expect(describeSpawnFailure(new Error('spawn ENOENT'))).toBe('spawn ENOENT');
+    } finally {
+      for (const fd of opened) fs.closeSync(fd);
+    }
+  });
+});

package/src/server/lib/lifecycle/fd-pressure.ts

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * File-descriptor pressure, and the honest name for a spawn that dies from it.
+ *
+ * On macOS `posix_spawn` fails with `EBADF: bad file descriptor` the moment it
+ * must hand the child a descriptor numbered at or above `OPEN_MAX` (10240). The
+ * error names the shim it tried to exec — `posix_spawn '/bin/sh'` — and says
+ * nothing about the cause, so a terminal panel reads "Failed to start /bin/zsh:
+ * EBADF: bad file descriptor, posix_spawn '/bin/sh'" while the real condition is
+ * that the whole server process has run out of descriptors. Measured A/B on Bun
+ * 1.4.2 / macOS 26: 10230 open descriptors spawn fine, 10240 fails with exactly
+ * that message.
+ *
+ * A dev server reaches that state on its own, without a leak in this codebase:
+ * `Bun.serve({ development: true })` keeps the client module graph open
+ * (measured: 3545 descriptors for this app, against 17 in production), and a
+ * macOS reload never closes the previous generation's (bun#40706, bun#40907 —
+ * the pre-exec sweep exists only on Linux). The count therefore grows with
+ * every rebuild, and past the cliff every spawn in the process fails at once:
+ * the PTY shell, the `omp` child, `git`, `rg`.
+ *
+ * `countOpenFileDescriptors()` answers "how close?" with `fcntl(F_GETFD)` over
+ * the descriptor table — the same `bun:ffi` route `flock.ts` takes. The sweep
+ * stops at the cliff, because a descriptor above it cannot be opened anyway and
+ * that bound keeps the probe near 1 ms. It returns null where the symbols are
+ * unavailable (and on Windows), and every caller must read null as "unknown",
+ * never as "fine": `describeSpawnFailure` only names exhaustion when it can see
+ * the pressure, so a genuine bad-descriptor bug still reports itself plainly.
+ */
+
+import { dlopen, FFIType } from 'bun:ffi';
+import type { FFIFunction, Library } from 'bun:ffi';
+
+/**
+ * Darwin's `OPEN_MAX`: the first descriptor number a process cannot hold, and
+ * therefore the point where `posix_spawn` starts answering `EBADF`. Verified on
+ * Bun 1.4.2 (10230 ok, 10240 fails).
+ */
+export const SPAWN_CLIFF = 10_240;
+
+/**
+ * Pressure is reported as "near" from 90% of the swept range. The remaining
+ * 1024 descriptors are what a burst of spawns needs (an omp child takes
+ * several), and the failure arrives without a warning of its own: once the
+ * table is full there is room for neither a retry nor a log line.
+ */
+const NEAR_CLIFF_RATIO = 0.9;
+
+const FD_SYMBOLS = {
+  fcntl: { args: [FFIType.i32, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+  getdtablesize: { args: [], returns: FFIType.i32 },
+} satisfies Record<string, FFIFunction>;
+
+/** Library names to try, in the order each platform resolves them. */
+const LIBC_NAMES = ['libc.dylib', 'libSystem.B.dylib', 'libc.so.6'] as const;
+
+/** `F_GETFD` — the cheapest question that distinguishes open from closed. */
+const F_GETFD = 1;
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberFdLib: Library<typeof FD_SYMBOLS> | null | undefined;
+}
+
+/** libc with `fcntl`/`getdtablesize`, or null where this host has neither. */
+function libc(): Library<typeof FD_SYMBOLS> | null {
+  if (globalThis.__ompChamberFdLib !== undefined) return globalThis.__ompChamberFdLib;
+  globalThis.__ompChamberFdLib = null;
+  if (process.platform === 'win32') return null;
+  for (const name of LIBC_NAMES) {
+    try {
+      globalThis.__ompChamberFdLib = dlopen(name, FD_SYMBOLS);
+      return globalThis.__ompChamberFdLib;
+    } catch {
+      // Try the next name; a host with none of them keeps the null answer.
+    }
+  }
+  return null;
+}
+
+export interface FdPressure {
+  /** Descriptors open below `limit`. */
+  open: number;
+  /** Highest descriptor number seen, or -1 when the table looked empty. */
+  highest: number;
+  /** Where the sweep stopped: `getdtablesize()`, capped at the cliff. */
+  limit: number;
+  /** Whether the next spawn is at risk. See `NEAR_CLIFF_RATIO`. */
+  nearCliff: boolean;
+}
+
+/**
+ * Sweep the descriptor table, or null when this host cannot answer.
+ *
+ * Descriptors are allocated lowest-first, so the number of open descriptors and
+ * the highest one agree on a saturated table — which is the only state that
+ * matters here, and the state a dev server reaches by degrees.
+ *
+ * Never throws: `GET /api/health` is the CLI's readiness probe and the client's
+ * liveness check, so a host where the symbol resolves but the call does not
+ * must degrade to "unknown" rather than take those down. `open` saturates at
+ * `limit`, since the sweep stops there by design.
+ */
+export function countOpenFileDescriptors(): FdPressure | null {
+  const symbols = libc();
+  if (!symbols) return null;
+
+  try {
+    const reported = symbols.symbols.getdtablesize();
+    const table = Number.isFinite(reported) && reported > 0 ? reported : SPAWN_CLIFF;
+    const limit = Math.min(table, SPAWN_CLIFF);
+
+    let open = 0;
+    let highest = -1;
+    for (let fd = 0; fd < limit; fd++) {
+      if (symbols.symbols.fcntl(fd, F_GETFD, 0) !== -1) {
+        open += 1;
+        highest = fd;
+      }
+    }
+    return { open, highest, limit, nearCliff: highest >= limit * NEAR_CLIFF_RATIO };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * What descriptor exhaustion looks like in Bun's own words. macOS names the
+ * failing syscall (`EBADF … posix_spawn '/bin/sh'`), Linux the errno
+ * (`EMFILE: too many open files, socketpair`) — measured on both.
+ */
+const EXHAUSTION_SYMPTOM = /\bEBADF\b|\bEMFILE\b|too many open files/i;
+
+/**
+ * The message to surface for a failed spawn: Bun's own, plus what it takes to
+ * act on it when the cause is descriptor exhaustion.
+ *
+ * Two conditions, both required. The message must carry the symptom, and the
+ * sweep must see real pressure — a truncated table is not the only way `EBADF`
+ * reaches here, and appending "out of descriptors" to a genuine bad-descriptor
+ * bug (or to an unrelated `ENOENT` that failed while the table happened to be
+ * full) sends the next reader down the wrong path.
+ */
+export function describeSpawnFailure(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  if (!EXHAUSTION_SYMPTOM.test(raw)) return raw;
+  const pressure = countOpenFileDescriptors();
+  if (!pressure || !pressure.nearCliff) return raw;
+  return (
+    `${raw} — the chamber server is out of file descriptors ` +
+    `(${pressure.open} of ${pressure.limit} open, highest #${pressure.highest}); restart the instance. ` +
+    `A dev server holds the whole client module graph open and a macOS reload never releases ` +
+    `the previous generation (bun#40706), so the count only climbs.`
+  );
+}

package/src/server/lib/omp/config/commands.test.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Command-file location and authoring.
+ *
+ * `get_available_commands` reports a command's name, description and hint but
+ * never the file behind it, so the pane's read-only/editable decision and the
+ * delete's safety both rest on this lookup. The rules worth locking are the
+ * ones a user cannot see: which root a duplicate name resolves to (omp runs the
+ * PROJECT file), which roots the chamber may write to (only the two
+ * `omp`-native ones), and the `.prompt.md` suffix VS Code prompt files carry.
+ *
+ * Everything runs inside a temp workspace and a temp `$HOME`, so the real
+ * `~/.omp/agent/commands` is never read or written.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import {
+  deleteCommandFile,
+  locateCommandFile,
+  readCommandFile,
+  writeCommandFile,
+} from '@/server/lib/omp/config/commands';
+
+let projectDir = '';
+let homeDir = '';
+let realHome: string | undefined;
+
+const write = (filePath: string, body = 'body') => {
+  fs.mkdirSync(join(filePath, '..'), { recursive: true });
+  fs.writeFileSync(filePath, body);
+};
+
+beforeAll(() => {
+  projectDir = fs.mkdtempSync(join(tmpdir(), 'ompchamber-cmd-project-'));
+  homeDir = fs.mkdtempSync(join(tmpdir(), 'ompchamber-cmd-home-'));
+  realHome = Bun.env.HOME;
+  // `userCommandDirs()` reads `$HOME` for the `.claude`/`.codex`/`.agents`/
+  // `.config/opencode` roots, so redirecting it keeps the test off the real one.
+  Bun.env.HOME = homeDir;
+});
+
+afterAll(() => {
+  if (realHome === undefined) delete Bun.env.HOME;
+  else Bun.env.HOME = realHome;
+  fs.rmSync(projectDir, { recursive: true, force: true });
+  fs.rmSync(homeDir, { recursive: true, force: true });
+});
+
+describe('locateCommandFile', () => {
+  test('a workspace .omp/commands file is the managed project root', async () => {
+    write(join(projectDir, '.omp', 'commands', 'proj.md'));
+    expect(await locateCommandFile('proj', projectDir)).toEqual({
+      filePath: join(projectDir, '.omp', 'commands', 'proj.md'),
+      scope: 'project',
+      managed: true,
+    });
+  });
+
+  test("another tool's file is found but never managed", async () => {
+    write(join(projectDir, '.claude', 'commands', 'claude-cmd.md'));
+    expect(await locateCommandFile('claude-cmd', projectDir)).toEqual({
+      filePath: join(projectDir, '.claude', 'commands', 'claude-cmd.md'),
+      scope: 'project',
+      managed: false,
+    });
+  });
+
+  test('a prompt file is found under its .prompt.md suffix', async () => {
+    write(join(projectDir, '.github', 'prompts', 'copilot.prompt.md'));
+    expect((await locateCommandFile('copilot', projectDir))?.filePath)
+      .toBe(join(projectDir, '.github', 'prompts', 'copilot.prompt.md'));
+  });
+
+  test('a duplicate name resolves to the project file', async () => {
+    write(join(homeDir, '.claude', 'commands', 'dupe.md'));
+    write(join(projectDir, '.omp', 'commands', 'dupe.md'));
+    expect((await locateCommandFile('dupe', projectDir))?.filePath)
+      .toBe(join(projectDir, '.omp', 'commands', 'dupe.md'));
+    // With no workspace the same name is the user-level file, which the
+    // chamber does not own.
+    expect(await locateCommandFile('dupe')).toEqual({
+      filePath: join(homeDir, '.claude', 'commands', 'dupe.md'),
+      scope: 'user',
+      managed: false,
+    });
+  });
+
+  test('a name that is not a plain file name is refused', async () => {
+    expect(await locateCommandFile('../escape', projectDir)).toBeNull();
+    expect(await locateCommandFile('nested/name', projectDir)).toBeNull();
+    expect(await locateCommandFile('   ', projectDir)).toBeNull();
+  });
+
+  test('a builtin has no file at all', async () => {
+    expect(await locateCommandFile('model', projectDir)).toBeNull();
+  });
+});
+
+describe('writeCommandFile / deleteCommandFile', () => {
+  test('round-trips a project command through the file', async () => {
+    const { filePath } = await writeCommandFile({
+      scope: 'project',
+      projectDir,
+      name: 'round',
+      description: 'round trip',
+      argumentHint: '[a|b]',
+      body: 'do $ARGUMENTS',
+    });
+    expect(filePath).toBe(join(projectDir, '.omp', 'commands', 'round.md'));
+    // The parsed body carries the trailing newline the serializer emits, and
+    // the leading blank line that separates it from the frontmatter is dropped.
+    expect(await readCommandFile(filePath)).toEqual({
+      description: 'round trip',
+      argumentHint: '[a|b]',
+      body: 'do $ARGUMENTS\n',
+    });
+    // Saving what was read must not grow the file: the pane posts exactly this.
+    const first = fs.readFileSync(filePath, 'utf8');
+    const parsed = await readCommandFile(filePath);
+    await writeCommandFile({
+      scope: 'project',
+      projectDir,
+      name: 'round',
+      description: parsed!.description,
+      argumentHint: parsed!.argumentHint,
+      body: parsed!.body,
+    });
+    expect(fs.readFileSync(filePath, 'utf8')).toBe(first);
+    expect(await deleteCommandFile('round', projectDir)).toBe(true);
+    expect(await locateCommandFile('round', projectDir)).toBeNull();
+  });
+
+  test('a rename moves the file instead of leaving two', async () => {
+    await writeCommandFile({ scope: 'project', projectDir, name: 'before', description: 'd', argumentHint: '', body: 'b' });
+    await writeCommandFile({
+      scope: 'project',
+      projectDir,
+      previousName: 'before',
+      name: 'after',
+      description: 'd',
+      argumentHint: '',
+      body: 'b',
+    });
+    expect(await locateCommandFile('before', projectDir)).toBeNull();
+    expect(await locateCommandFile('after', projectDir)).not.toBeNull();
+    await deleteCommandFile('after', projectDir);
+  });
+
+  test('a project write with no workspace is refused', async () => {
+    expect(writeCommandFile({ scope: 'project', name: 'lost', description: 'd', argumentHint: '', body: 'b' }))
+      .rejects.toThrow('workspace root is required');
+  });
+
+  test("a delete cannot reach a file another tool installed", async () => {
+    write(join(projectDir, '.claude', 'commands', 'notours.md'));
+    expect(deleteCommandFile('notours', projectDir)).rejects.toThrow('cannot delete');
+    expect(fs.existsSync(join(projectDir, '.claude', 'commands', 'notours.md'))).toBe(true);
+  });
+});