claude-code-session-manager 0.86.0 → 0.88.0

package/src/main/lib/__tests__/active-sessions.test.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+// Run: timeout 120 npx vitest run src/main/lib/__tests__/active-sessions.test.cjs
+
+import { vi } from 'vitest';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { activeProjectCwds, allProjectCwds, bustProjectCwdCache } = require('../activeSessions.cjs');
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'active-sessions-test-'));
+}
+
+function writeTranscript(projectsDir, slug, fileName, cwd, mtimeMsAgo) {
+  const projDir = path.join(projectsDir, slug);
+  fs.mkdirSync(projDir, { recursive: true });
+  const fp = path.join(projDir, fileName);
+  fs.writeFileSync(fp, JSON.stringify({ cwd }) + '\n');
+  const mtime = new Date(Date.now() - mtimeMsAgo);
+  fs.utimesSync(fp, mtime, mtime);
+  return fp;
+}
+
+test('two recent + one stale + one nonexistent → returns exactly the two recent existing cwds', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-a');
+    const cwdB = path.join(base, 'proj-b');
+    const cwdC = path.join(base, 'proj-c');       // stale — exists on disk
+    const cwdMissing = path.join(base, 'proj-missing'); // never created
+    fs.mkdirSync(cwdA);
+    fs.mkdirSync(cwdB);
+    fs.mkdirSync(cwdC);
+
+    const MAX_AGE_MIN = 90;
+    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 10 * 60 * 1000);
+    writeTranscript(projectsDir, 'slug-b', 'b.jsonl', cwdB, 10 * 60 * 1000);
+    writeTranscript(projectsDir, 'slug-c', 'c.jsonl', cwdC, 120 * 60 * 1000);
+    writeTranscript(projectsDir, 'slug-missing', 'm.jsonl', cwdMissing, 10 * 60 * 1000);
+
+    const result = activeProjectCwds(MAX_AGE_MIN, { projectsDir });
+
+    assert.equal(
+      result.length, 2,
+      `expected 2 cwds, got ${result.length}: ${JSON.stringify(result)}`,
+    );
+    assert.ok(result.includes(cwdA), `cwdA must be in result`);
+    assert.ok(result.includes(cwdB), `cwdB must be in result`);
+    assert.ok(!result.includes(cwdC),       'stale cwdC must not appear');
+    assert.ok(!result.includes(cwdMissing), 'nonexistent path must not appear');
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('duplicate cwd across two project dirs → deduped to one entry', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-a');
+    fs.mkdirSync(cwdA);
+
+    writeTranscript(projectsDir, 'slug-1', 'a.jsonl', cwdA, 5 * 60 * 1000);
+    writeTranscript(projectsDir, 'slug-2', 'b.jsonl', cwdA, 5 * 60 * 1000);
+
+    const result = activeProjectCwds(90, { projectsDir });
+    assert.equal(result.length, 1, 'duplicate cwd must be deduped');
+    assert.equal(result[0], cwdA);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('missing projects dir → empty result', () => {
+  const base = tmpDir();
+  try {
+    const result = activeProjectCwds(90, { projectsDir: path.join(base, 'no-such-dir') });
+    assert.deepEqual(result, []);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('prompts.jsonl absent → transcripts still detected (sole detection path)', () => {
+  const base = tmpDir();
+  try {
+    // No knowledge-log / prompts.jsonl anywhere in this tmp tree — the
+    // function must not need it. logPath, if passed, is a harmless no-op.
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-a');
+    fs.mkdirSync(cwdA);
+
+    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
+
+    const missingLogPath = path.join(base, 'knowledge-log', 'prompts.jsonl');
+    assert.ok(!fs.existsSync(missingLogPath), 'sanity: log path must not exist');
+
+    const result = activeProjectCwds(90, { projectsDir, logPath: missingLogPath });
+    assert.deepEqual(result, [cwdA]);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('fresh transcript mtime with no prompt log present → cwd is returned', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-fresh');
+    fs.mkdirSync(cwdA);
+
+    writeTranscript(projectsDir, 'slug-fresh', 'fresh.jsonl', cwdA, 60 * 1000); // 1 min ago
+
+    const result = activeProjectCwds(90, { projectsDir });
+    assert.equal(result.length, 1);
+    assert.equal(result[0], cwdA);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('garbage lines in transcript are skipped, cwd read from last parseable line', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-a');
+    fs.mkdirSync(cwdA);
+
+    const projDir = path.join(projectsDir, 'slug-a');
+    fs.mkdirSync(projDir, { recursive: true });
+    const fp = path.join(projDir, 'a.jsonl');
+    fs.writeFileSync(fp, [
+      JSON.stringify({ cwd: cwdA }),
+      'not json at all!!!',
+      '{ broken',
+    ].join('\n') + '\n');
+    const mtime = new Date(Date.now() - 5 * 60 * 1000);
+    fs.utimesSync(fp, mtime, mtime);
+
+    const result = activeProjectCwds(90, { projectsDir });
+    assert.equal(result.length, 1);
+    assert.equal(result[0], cwdA);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('5 consecutive allProjectCwds() calls with the same args perform ONE directory scan', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-a');
+    fs.mkdirSync(cwdA);
+    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
+
+    bustProjectCwdCache();
+    const readdirSpy = vi.spyOn(fs, 'readdirSync');
+
+    const first = allProjectCwds({ projectsDir });
+    const callsAfterFirst = readdirSpy.mock.calls.length;
+    assert.ok(callsAfterFirst > 0, 'first call must actually scan');
+
+    for (let i = 0; i < 4; i++) {
+      const again = allProjectCwds({ projectsDir });
+      assert.deepEqual(again, first);
+    }
+
+    assert.equal(
+      readdirSpy.mock.calls.length, callsAfterFirst,
+      'the 4 repeat calls must not perform any additional directory scan',
+    );
+  } finally {
+    vi.restoreAllMocks();
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('bustProjectCwdCache() forces the very next call to rescan', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdA = path.join(base, 'proj-a');
+    fs.mkdirSync(cwdA);
+    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
+
+    bustProjectCwdCache();
+    allProjectCwds({ projectsDir }); // warm the cache
+
+    const readdirSpy = vi.spyOn(fs, 'readdirSync');
+    allProjectCwds({ projectsDir });
+    assert.equal(readdirSpy.mock.calls.length, 0, 'a cache hit must not scan');
+
+    bustProjectCwdCache();
+    allProjectCwds({ projectsDir });
+    assert.ok(readdirSpy.mock.calls.length > 0, 'a bust must force a rescan on the next call');
+  } finally {
+    vi.restoreAllMocks();
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('allProjectCwds() and activeProjectCwds(90) do not share a cache entry', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    const cwdFresh = path.join(base, 'proj-fresh');
+    const cwdStale = path.join(base, 'proj-stale');
+    fs.mkdirSync(cwdFresh);
+    fs.mkdirSync(cwdStale);
+    writeTranscript(projectsDir, 'slug-fresh', 'fresh.jsonl', cwdFresh, 5 * 60 * 1000);
+    writeTranscript(projectsDir, 'slug-stale', 'stale.jsonl', cwdStale, 120 * 60 * 1000);
+
+    bustProjectCwdCache();
+    // allProjectCwds (maxAgeMin Infinity, maxCwds 500) sees both — cached
+    // first under its own key.
+    const all = allProjectCwds({ projectsDir });
+    assert.ok(all.includes(cwdFresh) && all.includes(cwdStale));
+
+    // activeProjectCwds(90) must recompute under its OWN key, not return
+    // allProjectCwds' cached (Infinity, 500) result — proving the cache key
+    // includes maxAgeMin/maxCwds, not just projectsDir.
+    const active = activeProjectCwds(90, { projectsDir });
+    assert.ok(active.includes(cwdFresh), 'fresh cwd must be present');
+    assert.ok(!active.includes(cwdStale), 'stale cwd must be excluded by the 90-min filter');
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('missing projectsDir returns [] and does not poison the cache once the dir appears', () => {
+  const base = tmpDir();
+  try {
+    const projectsDir = path.join(base, 'projects');
+    bustProjectCwdCache();
+
+    assert.deepEqual(activeProjectCwds(90, { projectsDir }), []);
+    assert.deepEqual(activeProjectCwds(90, { projectsDir }), []);
+
+    const cwdA = path.join(base, 'proj-a');
+    fs.mkdirSync(cwdA);
+    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
+
+    const result = activeProjectCwds(90, { projectsDir });
+    assert.deepEqual(result, [cwdA], 'the dir appearing later must be visible, not stuck on a cached []');
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/main/lib/__tests__/auditLog.test.cjs

@@ -0,0 +1,38 @@
+/**
+ * auditLog.test.cjs — readTail returns a bounded reverse tail of complete lines.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/auditLog.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeAll, afterAll } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { readTail } = require('../auditLog.cjs');
+
+let dir;
+beforeAll(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'auditlog-tail-')); });
+afterAll(() => { fs.rmSync(dir, { recursive: true, force: true }); });
+
+test('missing file → []', () => {
+  expect(readTail(1024, path.join(dir, 'nope.jsonl'))).toEqual([]);
+});
+
+test('window larger than file → every line', () => {
+  const f = path.join(dir, 'small.jsonl');
+  fs.writeFileSync(f, '{"n":1}\n{"n":2}\n');
+  expect(readTail(1_000_000, f)).toEqual(['{"n":1}', '{"n":2}']);
+});
+
+test('bounded window drops the partial leading line and keeps the newest', () => {
+  const f = path.join(dir, 'big.jsonl');
+  const lines = Array.from({ length: 1000 }, (_, i) => JSON.stringify({ n: i, pad: 'x'.repeat(50) }));
+  fs.writeFileSync(f, lines.join('\n') + '\n');
+  const tail = readTail(500, f);
+  expect(tail.length).toBeGreaterThan(0);
+  expect(tail.length).toBeLessThan(20);
+  expect(tail[tail.length - 1]).toBe(lines[999]);
+  for (const l of tail) expect(() => JSON.parse(l)).not.toThrow();
+  expect(readTail(0, f)).toEqual([]);
+});

package/src/main/lib/__tests__/bootSelfHeal.test.cjs

@@ -0,0 +1,107 @@
+/**
+ * bootSelfHeal.test.cjs — the epic-index self-heal scan must be SCHEDULED
+ * off app.whenReady()'s synchronous critical path, not executed inline, so
+ * the ~270ms allProjectCwds() scan can't compete with the renderer's first
+ * IPC round trips (schedule.state, billing.fetch, teams.list) for the event
+ * loop at boot.
+ *
+ * Run: timeout 300 npx vitest run src/main/lib/__tests__/bootSelfHeal.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi } from 'vitest';
+const { EventEmitter } = require('node:events');
+const { scheduleBootSelfHeal, runEpicIndexSelfHeal } = require('../bootSelfHeal.cjs');
+
+function flush(times = 2) {
+  return (async () => {
+    for (let i = 0; i < times; i++) {
+      await new Promise((resolve) => { setImmediate(resolve); });
+    }
+  })();
+}
+
+function makeDeps() {
+  return {
+    fs: { existsSync: vi.fn(() => true), readFileSync: vi.fn(() => '{}') },
+    allProjectCwds: vi.fn(() => ['/proj-a']),
+    promptSessionsActiveIndexPath: (cwd) => `${cwd}/active-index.json`,
+    rebuildActiveIndex: vi.fn(() => ({ rows: [], skipped: [] })),
+    logs: { writeLine: vi.fn() },
+  };
+}
+
+function fakeWindow() {
+  const webContents = new EventEmitter();
+  webContents.isDestroyed = () => false;
+  return { isDestroyed: () => false, webContents };
+}
+
+test('scheduleBootSelfHeal does not run the scan synchronously — only after did-finish-load', async () => {
+  const deps = makeDeps();
+  const mainWindow = fakeWindow();
+
+  scheduleBootSelfHeal(mainWindow, deps);
+  expect(deps.allProjectCwds).not.toHaveBeenCalled();
+
+  mainWindow.webContents.emit('did-finish-load');
+  expect(deps.allProjectCwds).toHaveBeenCalledTimes(1);
+  await flush();
+});
+
+test('a window destroyed before did-finish-load falls back to an unconditional setImmediate run', async () => {
+  const deps = makeDeps();
+  const mainWindow = fakeWindow();
+
+  scheduleBootSelfHeal(mainWindow, deps);
+  mainWindow.webContents.emit('destroyed');
+  expect(deps.allProjectCwds).not.toHaveBeenCalled();
+
+  await flush();
+  expect(deps.allProjectCwds).toHaveBeenCalledTimes(1);
+});
+
+test('a headless / no-window boot still self-heals via setImmediate', async () => {
+  const deps = makeDeps();
+
+  scheduleBootSelfHeal(null, deps);
+  expect(deps.allProjectCwds).not.toHaveBeenCalled();
+
+  await flush();
+  expect(deps.allProjectCwds).toHaveBeenCalledTimes(1);
+});
+
+test('runs exactly once per boot even if did-finish-load and destroyed both fire', async () => {
+  const deps = makeDeps();
+  const mainWindow = fakeWindow();
+
+  scheduleBootSelfHeal(mainWindow, deps);
+  mainWindow.webContents.emit('did-finish-load');
+  mainWindow.webContents.emit('destroyed');
+  await flush();
+
+  expect(deps.allProjectCwds).toHaveBeenCalledTimes(1);
+});
+
+test('runEpicIndexSelfHeal rebuilds only a project whose index is missing or unparseable — a clean index is never rewritten', async () => {
+  const files = {
+    '/clean-proj/active-index.json': '{"sessions":{}}',
+    '/broken-proj/active-index.json': '{ not json',
+  };
+  const fs = {
+    existsSync: (p) => Object.prototype.hasOwnProperty.call(files, p),
+    readFileSync: (p) => files[p],
+  };
+  const rebuildActiveIndex = vi.fn(() => ({ rows: [], skipped: [] }));
+  const logs = { writeLine: vi.fn() };
+  const allProjectCwds = () => ['/clean-proj', '/broken-proj', '/missing-proj'];
+  const promptSessionsActiveIndexPath = (cwd) => `${cwd}/active-index.json`;
+
+  await runEpicIndexSelfHeal({ fs, allProjectCwds, promptSessionsActiveIndexPath, rebuildActiveIndex, logs });
+
+  expect(rebuildActiveIndex).toHaveBeenCalledTimes(2);
+  expect(rebuildActiveIndex).toHaveBeenCalledWith('/broken-proj');
+  expect(rebuildActiveIndex).toHaveBeenCalledWith('/missing-proj');
+  expect(rebuildActiveIndex).not.toHaveBeenCalledWith('/clean-proj');
+});

package/src/main/lib/__tests__/buildIdentity.test.cjs

@@ -0,0 +1,121 @@
+/**
+ * buildIdentity.test.cjs — resolveBuildIdentity() resolution order:
+ * build-info.json first, git fallback only when a real .git sits AT the
+ * package root (never walking up), else null.
+ *
+ * Each test injects a distinct fixture `packageRoot` (see buildIdentity.cjs's
+ * `opts.packageRoot`), which also keeps memoization scoped per-root so the
+ * three cases don't clobber each other's cached result in one process.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/buildIdentity.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { resolveBuildIdentity } = require('../buildIdentity.cjs');
+
+const cleanupDirs = [];
+
+function mkFixtureRoot(prefix) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  cleanupDirs.push(dir);
+  fs.mkdirSync(path.join(dir, 'src', 'main'), { recursive: true });
+  return dir;
+}
+
+function writePackageJson(root, version) {
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'fixture-pkg', version }));
+}
+
+function mkRealGitRepo(root) {
+  execFileSync('git', ['-C', root, 'init', '-q']);
+  execFileSync('git', ['-C', root, 'config', 'user.email', 'test@test.com']);
+  execFileSync('git', ['-C', root, 'config', 'user.name', 'Test']);
+  fs.writeFileSync(path.join(root, 'README.md'), 'fixture\n');
+  execFileSync('git', ['-C', root, 'add', 'README.md']);
+  execFileSync('git', ['-C', root, 'commit', '-q', '-m', 'init']);
+  return execFileSync('git', ['-C', root, 'rev-parse', '--short', 'HEAD'], { encoding: 'utf8' }).trim();
+}
+
+afterEach(() => {
+  while (cleanupDirs.length) {
+    const dir = cleanupDirs.pop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('build-info.json present: its fields win over both git and package.json', () => {
+  const root = mkFixtureRoot('sm-buildid-present-');
+  writePackageJson(root, '0.1.0');
+  fs.writeFileSync(path.join(root, 'src', 'main', 'build-info.json'), JSON.stringify({
+    version: '9.9.9',
+    gitSha: 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+    gitShortSha: 'deadbee',
+    gitBranch: 'main',
+    builtAt: '2026-01-01T00:00:00.000Z',
+    dirty: false,
+  }));
+
+  const identity = resolveBuildIdentity({ packageRoot: root, bootedAt: '2026-02-02T00:00:00.000Z' });
+
+  expect(identity.version).toBe('9.9.9');
+  expect(identity.codeSha).toBe('deadbee');
+  expect(identity.builtAt).toBe('2026-01-01T00:00:00.000Z');
+  expect(identity.appPath).toBe(root);
+  expect(identity.bootedAt).toBe('2026-02-02T00:00:00.000Z');
+});
+
+test('build-info.json absent, real .git at the package root: codeSha falls back to git, builtAt stays null', () => {
+  const root = mkFixtureRoot('sm-buildid-git-');
+  writePackageJson(root, '1.2.3');
+  const sha = mkRealGitRepo(root);
+
+  const identity = resolveBuildIdentity({ packageRoot: root });
+
+  expect(identity.version).toBe('1.2.3');
+  expect(identity.codeSha).toBe(sha);
+  expect(identity.builtAt).toBeNull();
+});
+
+test('build-info.json absent, no .git at the package root: codeSha is null, never walks up to an ancestor .git', () => {
+  const ancestor = mkFixtureRoot('sm-buildid-ancestor-');
+  mkRealGitRepo(ancestor); // a real repo one level UP from the fixture root — must never be found
+  const root = path.join(ancestor, 'nested-pkg');
+  fs.mkdirSync(path.join(root, 'src', 'main'), { recursive: true });
+  writePackageJson(root, '2.0.0');
+
+  const identity = resolveBuildIdentity({ packageRoot: root });
+
+  expect(identity.version).toBe('2.0.0');
+  expect(identity.codeSha).toBeNull();
+  expect(identity.builtAt).toBeNull();
+});
+
+test('bootedAt is echoed back verbatim, never re-captured, and defaults to null', () => {
+  const root = mkFixtureRoot('sm-buildid-bootedat-');
+  writePackageJson(root, '1.0.0');
+
+  expect(resolveBuildIdentity({ packageRoot: root }).bootedAt).toBeNull();
+  expect(resolveBuildIdentity({ packageRoot: root, bootedAt: 'fixed-value' }).bootedAt).toBe('fixed-value');
+});
+
+test('installChannel is reused from machineProfile.resolveInstallChannel, keyed off appPath', () => {
+  const root = mkFixtureRoot('sm-buildid-channel-');
+  writePackageJson(root, '1.0.0');
+  const prevSmDev = process.env.SM_DEV;
+  delete process.env.SM_DEV;
+  try {
+    const identity = resolveBuildIdentity({ packageRoot: root });
+    // fixture root lives under os.tmpdir(), not an .npm/_npx cache path, and
+    // SM_DEV is unset here, so resolveInstallChannel falls through to 'unknown'.
+    expect(identity.installChannel).toBe('unknown');
+  } finally {
+    if (prevSmDev === undefined) delete process.env.SM_DEV;
+    else process.env.SM_DEV = prevSmDev;
+  }
+});

package/src/main/lib/__tests__/cwdClassify.test.cjs

@@ -0,0 +1,111 @@
+// cwdClassify.cjs — one classifier for "what project is this path", failing
+// CLOSED on the unprovable worktree case. Fixtures live under a per-run
+// mkdtemp sandbox, never the live roots.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { classifyCwd, nearestGitEntry, worktreeMainRootOf } = require('../cwdClassify.cjs');
+const { assertOpsWrite, resolveOpsRoot } = require('../opsOwnership.cjs');
+const { isEphemeralCwd } = require('../ephemeralCwd.cjs');
+const { projectRootOf } = require('../activeSessions.cjs');
+
+const OPS = 'session-manager-operations';
+let sandbox;
+const real = (p) => fs.realpathSync(p);
+
+beforeEach(() => { sandbox = real(fs.mkdtempSync(path.join(os.tmpdir(), 'sm-cwdclassify-'))); });
+afterEach(() => { fs.rmSync(sandbox, { recursive: true, force: true }); });
+
+function mkWorktree({ backRef = true } = {}) {
+  const main = path.join(sandbox, 'main');
+  const wt = path.join(sandbox, 'wt');
+  const admin = path.join(main, '.git', 'worktrees', 'wt1');
+  fs.mkdirSync(admin, { recursive: true });
+  fs.mkdirSync(wt, { recursive: true });
+  fs.writeFileSync(path.join(wt, '.git'), `gitdir: ${admin}\n`);
+  if (backRef) fs.writeFileSync(path.join(admin, 'gitdir'), `${path.join(wt, '.git')}\n`);
+  return { main, wt };
+}
+
+test('healthy worktree → worktree, projectRoot is the main tree', () => {
+  const { main, wt } = mkWorktree();
+  const c = classifyCwd(wt);
+  assert.equal(c.kind, 'worktree');
+  assert.equal(c.projectRoot, main);
+  assert.equal(projectRootOf(wt), main);
+  assert.equal(isEphemeralCwd(wt), true);
+  assert.equal(worktreeMainRootOf(wt), main);
+});
+
+test('broken back-reference → unknown; ops writes refused, resolution and dispatch stay open', () => {
+  const { wt } = mkWorktree({ backRef: false });
+  const c = classifyCwd(wt);
+  assert.equal(c.kind, 'unknown');
+  assert.equal(c.projectRoot, wt);
+  assert.match(c.reason, /back-reference/);
+  assert.equal(projectRootOf(wt), wt); // total — never throws
+  assert.equal(resolveOpsRoot(wt), path.join(wt, OPS)); // reads/dispatch unaffected
+  assert.throws(
+    () => assertOpsWrite(path.join(wt, OPS, 'scheduler', 'state', 'queue.json'), 'scheduler'),
+    (e) => e.unknownCwd === true && /back-reference/.test(e.message),
+  );
+});
+
+test('garbled .git file → unknown', () => {
+  const dir = path.join(sandbox, 'garbled');
+  fs.mkdirSync(dir);
+  fs.writeFileSync(path.join(dir, '.git'), 'not a pointer\n');
+  assert.equal(classifyCwd(dir).kind, 'unknown');
+});
+
+test('separate-git-dir → project (gitdir not under worktrees/)', () => {
+  const dir = path.join(sandbox, 'sep');
+  fs.mkdirSync(dir);
+  fs.writeFileSync(path.join(dir, '.git'), `gitdir: ${path.join(sandbox, 'elsewhere.git')}\n`);
+  const c = classifyCwd(dir);
+  assert.equal(c.kind, 'project');
+  assert.equal(c.projectRoot, dir);
+  assert.doesNotThrow(() => assertOpsWrite(path.join(dir, OPS, 'scheduler', 'state', 'queue.json'), 'scheduler'));
+});
+
+test('submodule (relative gitdir) → project rooted at the submodule', () => {
+  const sup = path.join(sandbox, 'super');
+  const sub = path.join(sup, 'libs', 'sub');
+  fs.mkdirSync(path.join(sup, '.git', 'modules', 'sub'), { recursive: true });
+  fs.mkdirSync(path.join(sub, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(sub, '.git'), 'gitdir: ../../.git/modules/sub\n');
+  const c = classifyCwd(path.join(sub, 'src'));
+  assert.equal(c.kind, 'project');
+  assert.equal(c.projectRoot, sub);
+});
+
+test('plain project (.git dir, and no git at all) → project', () => {
+  const proj = path.join(sandbox, 'proj');
+  fs.mkdirSync(path.join(proj, '.git'), { recursive: true });
+  fs.mkdirSync(path.join(proj, 'src'));
+  assert.deepEqual(
+    { k: classifyCwd(path.join(proj, 'src')).kind, r: classifyCwd(path.join(proj, 'src')).projectRoot },
+    { k: 'project', r: proj },
+  );
+  const bare = path.join(sandbox, 'nogit');
+  fs.mkdirSync(bare);
+  assert.equal(classifyCwd(bare).projectRoot, bare);
+  assert.equal(nearestGitEntry(bare), null);
+});
+
+test('nested ops root: outermost (indexOf) and innermost (lastIndexOf) are both reported, neither unified', () => {
+  const proj = path.join(sandbox, 'proj');
+  fs.mkdirSync(path.join(proj, '.git'), { recursive: true });
+  const nested = path.join(proj, OPS, 'scheduler', 'prds', OPS, 'scheduler', 'state');
+  const c = classifyCwd(nested);
+  assert.equal(c.projectRoot, proj);
+  assert.equal(c.outermostOpsRoot, path.join(proj, OPS));
+  assert.equal(c.innermostOpsRoot, path.join(proj, OPS, 'scheduler', 'prds', OPS));
+  assert.equal(classifyCwd(proj).outermostOpsRoot, null);
+});
+
+test('ephemeral: os.tmpdir() itself', () => {
+  assert.equal(classifyCwd(path.resolve(os.tmpdir())).kind, 'ephemeral');
+  assert.equal(isEphemeralCwd(os.tmpdir()), true);
+});