claude-code-session-manager 0.98.0 → 0.100.0

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

@@ -1,113 +0,0 @@
-// opsOwnership.cjs — the single-writer law over a project's ops root.
-// vitest globals (test/beforeEach) — same convention as the other .cjs tests.
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const os = require('node:os');
-const fs = require('node:fs');
-const { parseOpsPath, checkOpsWrite, assertOpsWrite, OWNERS } = require('../opsOwnership.cjs');
-
-const P = '/home/u/Projects/demo/session-manager-operations';
-
-test('parseOpsPath: splits namespace and remainder, ignores non-ops paths', () => {
-  assert.deepEqual(parseOpsPath(`${P}/prompt-sessions/active-index.json`), {
-    inOps: true, namespace: 'prompt-sessions', relative: 'active-index.json',
-  });
-  assert.deepEqual(parseOpsPath(`${P}/scheduler/epics/e1/prds/900-x.md`), {
-    inOps: true, namespace: 'scheduler', relative: 'epics/e1/prds/900-x.md',
-  });
-  assert.equal(parseOpsPath('/home/u/.claude/settings.json').inOps, false);
-  assert.equal(parseOpsPath(null).inOps, false);
-});
-
-test('paths outside any ops root are not governed by ownership', () => {
-  assert.deepEqual(checkOpsWrite('/home/u/.claude/settings.json', undefined), { ok: true, error: null });
-});
-
-test('the owner of a namespace may write it', () => {
-  assert.equal(checkOpsWrite(`${P}/prompt-sessions/active-index.json`, 'epics').ok, true);
-  assert.equal(checkOpsWrite(`${P}/scheduler/state/queue.json`, 'scheduler').ok, true);
-  assert.equal(checkOpsWrite(`${P}/project-brief/brief.json`, 'project-home').ok, true);
-  // project-pages: declared owner is 'project-home', same as project-brief —
-  // this governs only the app's own /admin/project-home/render write path
-  // (config.cjs), NOT a project-home-builder Epic's own Write-tool authoring
-  // of summary.json/picks.json, which never goes through config.cjs at all
-  // and so is unaffected by this table either way (see project-pages/README.md).
-  assert.equal(checkOpsWrite(`${P}/project-pages/output/manifest.json`, 'project-home').ok, true);
-});
-
-test('a non-owner is refused, and the error names the owner', () => {
-  const res = checkOpsWrite(`${P}/project-brief/brief.json`, 'scheduler');
-  assert.equal(res.ok, false);
-  assert.match(res.error, /owned by 'project-home'/);
-  // The exact cross-write this law exists to prevent: another surface
-  // rewriting the Epic store out from under Epics.
-  assert.equal(checkOpsWrite(`${P}/prompt-sessions/psess-1.json`, 'scheduler').ok, false);
-  assert.equal(checkOpsWrite(`${P}/project-pages/output/manifest.json`, 'scheduler').ok, false);
-});
-
-test('an undeclared writer is refused (fail-closed)', () => {
-  const res = checkOpsWrite(`${P}/scheduler/state/queue.json`, undefined);
-  assert.equal(res.ok, false);
-  assert.match(res.error, /did not declare a writer/);
-});
-
-test('a namespace with no declared owner is refused, not silently allowed', () => {
-  const res = checkOpsWrite(`${P}/brand-new-thing/state.json`, 'scheduler');
-  assert.equal(res.ok, false);
-  assert.match(res.error, /no declared owner/);
-});
-
-test('the ops root itself is unownable', () => {
-  assert.equal(checkOpsWrite(`${P}/loose-file.json`, 'epics').ok, false);
-});
-
-test('the scheduler delegation covers active-index.json and nothing else', () => {
-  assert.equal(checkOpsWrite(`${P}/prompt-sessions/active-index.json`, 'scheduler').ok, true);
-  // Not the archives, and not a lookalike nested path.
-  assert.equal(checkOpsWrite(`${P}/prompt-sessions/psess-9.json`, 'scheduler').ok, false);
-  assert.equal(checkOpsWrite(`${P}/prompt-sessions/nested/active-index.json`, 'scheduler').ok, false);
-});
-
-test('assertOpsWrite throws for a refused write and is silent for an allowed one', () => {
-  assert.throws(() => assertOpsWrite(`${P}/project-brief/brief.json`, 'epics'), /single-writer law/);
-  assert.doesNotThrow(() => assertOpsWrite(`${P}/project-brief/brief.json`, 'project-home'));
-});
-
-test('assertOpsWrite fails closed (not a raw crash) on a relative path that looks like it is inside an ops root', () => {
-  // A caller that skips opsPath/resolveProjectRoot (which already throw on a
-  // relative cwd) and builds its own path string by hand must still get a
-  // graceful, catchable refusal here — this is the last line of defense
-  // (PRD 1082). Before this guard, classifyCwd's absolute-path check (added
-  // for the worktree-relative-cwd hazard) left innermostOpsRoot null for a
-  // relative path, and path.dirname(null) threw an untagged TypeError
-  // instead of the intended `unknownCwd`-tagged Error.
-  assert.throws(
-    () => assertOpsWrite('session-manager-operations/scheduler/state/queue.json', 'scheduler'),
-    (e) => e.unknownCwd === true && /absolute/.test(e.message),
-  );
-});
-
-test('every declared owner is a non-empty string (table sanity)', () => {
-  for (const [ns, owner] of Object.entries(OWNERS)) {
-    assert.equal(typeof owner, 'string', `${ns} owner must be a string`);
-    assert.ok(owner.length > 0, `${ns} owner must be non-empty`);
-  }
-});
-
-// Integration: config.cjs must enforce the law on its real write path, not
-// just expose it — a write with the wrong writer has to actually fail.
-test('config.writeJson refuses an ops write from a non-owner', async () => {
-  const config = require('../../config.cjs');
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-law-'));
-  config.addAllowedRoot(root);
-  const target = path.join(root, 'session-manager-operations', 'project-brief', 'brief.json');
-
-  await assert.rejects(() => config.writeJson(target, { a: 1 }, { writer: 'epics' }), /single-writer law/);
-  await assert.rejects(() => config.writeJson(target, { a: 1 }), /did not declare a writer/);
-
-  const res = await config.writeJson(target, { a: 1 }, { writer: 'project-home' });
-  assert.equal(res.ok, true);
-  assert.equal(JSON.parse(fs.readFileSync(target, 'utf8')).a, 1);
-
-  fs.rmSync(root, { recursive: true, force: true });
-});

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

@@ -1,328 +0,0 @@
-/**
- * opsRootAbsoluteCwd.test.cjs — a project cwd must be an ABSOLUTE path, at
- * both ends of the ops-root resolution chain.
- *
- * The incident this guards (observed live 2026-08-13): five stray
- * `session-manager-operations/scheduler/state/queue.json` trees appeared under
- * source directories — `src/main/lib/`, `src/main/`, `src/renderer/state/`,
- * `src/renderer/components/epics/`, `src/renderer/testUtils/` — each holding
- * an empty `{"jobs": []}`. Cause: `path.join()` silently resolves a RELATIVE
- * first segment against `process.cwd()`, so a caller handing
- * `projectStateDir()` a repo-relative fragment like `src/main/lib` gets a
- * plausible-looking absolute path pointing at entirely the wrong place, and a
- * whole ops root is materialized there. Nothing threw; the writes "succeeded".
- *
- * This is the ops-root hazard gitWorktree.cjs's header comment describes,
- * reached from the opposite end: not a worktree dir substituted for a project
- * cwd, but a relative fragment accepted as one. A PROJECT IS A CWD and a cwd
- * is absolute (CLAUDE.md's knownProjectAggregate.ts bullet says the same
- * thing renderer-side) — so both layers fail closed rather than guessing.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/opsRootAbsoluteCwd.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const queueStore = require('../queueStore.cjs');
-const { activeProjectCwds } = require('../activeSessions.cjs');
-
-const tmpDirs = [];
-
-afterEach(async () => {
-  while (tmpDirs.length) {
-    await fsp.rm(tmpDirs.pop(), { recursive: true, force: true }).catch(() => {});
-  }
-});
-
-// ─── queueStore.projectStateDir — the write-path guard ──────────────────────
-
-test('projectStateDir refuses a relative cwd instead of resolving it against process.cwd()', () => {
-  expect(() => queueStore.projectStateDir('src/main/lib')).toThrow(/absolute path/);
-  expect(() => queueStore.projectStateDir('./somewhere')).toThrow(/absolute path/);
-  expect(() => queueStore.projectStateDir('..')).toThrow(/absolute path/);
-});
-
-test('projectStateDir names the offending value so a bad caller is findable from the log alone', () => {
-  expect(() => queueStore.projectStateDir('src/renderer/state')).toThrow(/src\/renderer\/state/);
-});
-
-test('projectStateDir still accepts an absolute cwd and appends the ops-root subpath', () => {
-  const dir = queueStore.projectStateDir('/projects/foo');
-  expect(dir).toBe(path.join('/projects/foo', 'session-manager-operations', 'scheduler', 'state'));
-});
-
-test('projectStateDir keeps rejecting a missing/non-string cwd', () => {
-  expect(() => queueStore.projectStateDir()).toThrow(/cwd is required/);
-  expect(() => queueStore.projectStateDir('')).toThrow(/cwd is required/);
-  expect(() => queueStore.projectStateDir(42)).toThrow(/cwd is required/);
-});
-
-// ─── activeSessions.addCwd — the upstream guard ─────────────────────────────
-//
-// Building a transcript fixture whose recorded `cwd` is relative is the whole
-// point: statSync('src/main/lib') SUCCEEDS whenever this process happens to
-// run from the repo root, which is exactly how such a value used to survive
-// into the project list and reach projectStateDir.
-
-async function mkProjectsDir(rows) {
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-projects-'));
-  tmpDirs.push(projectsDir);
-  for (const [slug, cwd] of Object.entries(rows)) {
-    const dir = path.join(projectsDir, slug);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
-  }
-  return projectsDir;
-}
-
-test('a transcript recording a RELATIVE cwd never enters the project list', async () => {
-  const projectsDir = await mkProjectsDir({ relative: 'src/main/lib' });
-  // Sanity: the bad value really would have passed the old existence check.
-  expect(fs.existsSync('src/main/lib')).toBe(true);
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).not.toContain('src/main/lib');
-  expect(cwds).toEqual([]);
-});
-
-test('an absolute cwd that exists is still collected', async () => {
-  const real = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-real-'));
-  tmpDirs.push(real);
-  const projectsDir = await mkProjectsDir({ good: real });
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).toContain(real);
-});
-
-test('an absolute cwd pointing at a FILE (not a directory) is rejected — a file is not a project', async () => {
-  const holder = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-file-'));
-  tmpDirs.push(holder);
-  const filePath = path.join(holder, 'not-a-dir.txt');
-  fs.writeFileSync(filePath, 'x', 'utf8');
-  const projectsDir = await mkProjectsDir({ afile: filePath });
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).not.toContain(filePath);
-});
-
-test('an absolute cwd that no longer exists on disk is rejected', async () => {
-  const projectsDir = await mkProjectsDir({ gone: path.join(os.tmpdir(), 'sm-opsroot-definitely-not-here-12345') });
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).toEqual([]);
-});
-
-test('the guards compose: no relative cwd from a transcript can reach an ops-root write', async () => {
-  const projectsDir = await mkProjectsDir({ relative: 'src/renderer/state', alsoRelative: './src/main' });
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).toEqual([]);
-  // And even if one somehow did, the write path itself refuses it.
-  expect(() => queueStore.projectStateDir('src/renderer/state')).toThrow(/absolute path/);
-});
-
-// ─── the second incident: an ABSOLUTE cwd INSIDE an ops root ────────────────
-//
-// Reported from starry-night-ships on 2026-08-30: 14 stray
-// `.../session-manager-operations/scheduler/state/queue.json` stubs, each
-// nested under another ops directory (`scheduler/prds/`, `prompt-sessions/`,
-// `scheduler/epics/<id>/prds/`), every one holding `{"jobs": []}` and mtimes
-// spanning 8 days. The 2026-08-13 absolute-path guard above could not catch
-// them: these cwds ARE absolute and DO exist. They came from transcripts
-// where an agent had `cd`'d into the artifact directory it was writing, so
-// the last transcript row recorded that subdirectory as the session cwd.
-
-test('a transcript cwd inside an ops root is normalized to the project root, not taken literally', async () => {
-  const project = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-nested-'));
-  tmpDirs.push(project);
-  const prdDir = path.join(project, 'session-manager-operations', 'scheduler', 'epics', 'e-1', 'prds');
-  fs.mkdirSync(prdDir, { recursive: true });
-  const projectsDir = await mkProjectsDir({ nested: prdDir });
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).toContain(project);
-  expect(cwds).not.toContain(prdDir);
-});
-
-test('normalization keeps the active-project signal rather than dropping the row', () => {
-  const { projectRootOf } = require('../activeSessions.cjs');
-  expect(projectRootOf('/p/session-manager-operations/prompt-sessions')).toBe('/p');
-  expect(projectRootOf('/p/session-manager-operations')).toBe('/p');
-  expect(projectRootOf('/p/session-manager-operations/scheduler/state')).toBe('/p');
-  // Already-nested strays truncate at the FIRST segment — the inner one is
-  // itself the bug, never a project.
-  expect(projectRootOf('/p/session-manager-operations/x/session-manager-operations/y')).toBe('/p');
-  // A plain project cwd is untouched.
-  expect(projectRootOf('/p/src/main')).toBe('/p/src/main');
-  // A directory that merely CONTAINS the name as a substring is not a segment.
-  expect(projectRootOf('/p/session-manager-operations-archive')).toBe('/p/session-manager-operations-archive');
-});
-
-test('projectStateDir fails closed on an ops-internal cwd, naming the offending value', () => {
-  expect(() => queueStore.projectStateDir('/p/session-manager-operations/scheduler/prds'))
-    .toThrow(/must be a project root/);
-  expect(() => queueStore.projectStateDir('/p/session-manager-operations/scheduler/prds'))
-    .toThrow(/scheduler\/prds/);
-  // The guard is segment-exact, not a substring match.
-  expect(queueStore.projectStateDir('/p/session-manager-operations-archive'))
-    .toBe(path.join('/p/session-manager-operations-archive', 'session-manager-operations', 'scheduler', 'state'));
-});
-
-// The writeSplit half of this guard lives in opsRootNestedWrite.test.cjs —
-// it must override HOME before requiring queueStore (writeSplit persists
-// machine state to a homedir path), which cannot be done from this file.
-
-// ─── the third incident: a cwd INSIDE a linked git worktree ─────────────────
-//
-// Verified live 2026-09-01 in starry-night-ships: a transcript's last `cwd`
-// row pointed at `/tmp/session-manager-epic-worktrees/<hash>/<epicId>` — an
-// absolute, existing directory, so it was accepted as a project and the real
-// project root (`/home/bilko/Projects/starry-night-ships`) never entered the
-// list at all. `worktreeMainRootOf` reverses a linked worktree's `.git` FILE
-// (`gitdir: <main>/.git/worktrees/<name>`) back to `<main>`.
-
-const { worktreeMainRootOf } = require('../activeSessions.cjs');
-const { KIND_CONFIG: WORKTREE_KIND_CONFIG } = require('../gitWorktree.cjs');
-
-// A worktree's MAIN tree root must live outside os.tmpdir() for these fixtures
-// to double as a realistic "real project" for the tmp-drop-guard tests below
-// (a real project is never itself under /tmp — only the linked worktree is).
-// `test-results/` is already gitignored in this repo.
-const NON_TMP_SCRATCH_ROOT = path.join(process.cwd(), 'test-results', 'opsroot-fixtures');
-
-async function mkNonTmpDir(prefix) {
-  fs.mkdirSync(NON_TMP_SCRATCH_ROOT, { recursive: true });
-  return fsp.mkdtemp(path.join(NON_TMP_SCRATCH_ROOT, prefix));
-}
-
-async function makeWorktreeFixture() {
-  const main = await mkNonTmpDir('sm-opsroot-main-');
-  tmpDirs.push(main);
-  fs.mkdirSync(path.join(main, '.git'), { recursive: true });
-  const worktree = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-worktree-'));
-  tmpDirs.push(worktree);
-  const worktreeName = 'sm-epic-abc123';
-  const worktreeGitFile = path.join(worktree, '.git');
-  const adminDir = path.join(main, '.git', 'worktrees', worktreeName);
-  fs.mkdirSync(adminDir, { recursive: true });
-  // Real `git worktree add` writes this back-reference (the admin dir's own
-  // `gitdir` file points at the linked worktree's `.git` FILE) — required by
-  // worktreeMainRootOf's round-trip check so a crafted `.git` file elsewhere
-  // on disk can't redirect resolution to an arbitrary directory.
-  fs.writeFileSync(path.join(adminDir, 'gitdir'), `${worktreeGitFile}\n`, 'utf8');
-  fs.writeFileSync(worktreeGitFile, `gitdir: ${adminDir}\n`, 'utf8');
-  return { main, worktree };
-}
-
-test('worktreeMainRootOf resolves a linked worktree .git FILE back to the main tree root', async () => {
-  const { main, worktree } = await makeWorktreeFixture();
-  expect(worktreeMainRootOf(worktree)).toBe(main);
-});
-
-test('worktreeMainRootOf returns the ancestor unchanged when .git is a real directory', async () => {
-  const main = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-plain-main-'));
-  tmpDirs.push(main);
-  fs.mkdirSync(path.join(main, '.git'), { recursive: true });
-  const nested = path.join(main, 'src', 'main', 'lib');
-  fs.mkdirSync(nested, { recursive: true });
-  expect(worktreeMainRootOf(nested)).toBe(main);
-});
-
-test('worktreeMainRootOf returns null on a garbled .git file instead of throwing', async () => {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-garbled-'));
-  tmpDirs.push(dir);
-  fs.writeFileSync(path.join(dir, '.git'), 'not a gitdir line at all', 'utf8');
-  expect(worktreeMainRootOf(dir)).toBeNull();
-
-  const dir2 = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-garbled2-'));
-  tmpDirs.push(dir2);
-  fs.writeFileSync(path.join(dir2, '.git'), 'gitdir: /some/path/without/the/marker\n', 'utf8');
-  expect(worktreeMainRootOf(dir2)).toBeNull();
-});
-
-test('worktreeMainRootOf refuses a crafted .git file that redirects to an arbitrary directory with no back-reference', async () => {
-  // A `.git` FILE is an ordinary file — nothing stops an untrusted repo from
-  // shipping one at a nested path pointing anywhere. Without verifying the
-  // admin dir's own `gitdir` back-reference, this would let a crafted repo
-  // redirect activeSessions' project-root resolution (and therefore
-  // queueStore's ops-root writes) to an attacker-chosen absolute directory.
-  const arbitraryTarget = await mkNonTmpDir('sm-opsroot-arbitrary-target-');
-  tmpDirs.push(arbitraryTarget);
-  const attackerDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-attacker-'));
-  tmpDirs.push(attackerDir);
-  // No admin dir/back-reference file exists under arbitraryTarget/.git/worktrees/.
-  fs.writeFileSync(
-    path.join(attackerDir, '.git'),
-    `gitdir: ${path.join(arbitraryTarget, '.git', 'worktrees', 'x')}\n`,
-    'utf8',
-  );
-  expect(worktreeMainRootOf(attackerDir)).toBeNull();
-});
-
-test('worktreeMainRootOf refuses a crafted .git file whose admin dir exists but back-references a DIFFERENT worktree', async () => {
-  const { main } = await makeWorktreeFixture();
-  const attackerDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-attacker2-'));
-  tmpDirs.push(attackerDir);
-  // Points at a REAL admin dir (main's own), but that admin dir's gitdir
-  // back-reference points at the ORIGINAL worktree, not attackerDir.
-  fs.writeFileSync(
-    path.join(attackerDir, '.git'),
-    `gitdir: ${path.join(main, '.git', 'worktrees', 'sm-epic-abc123')}\n`,
-    'utf8',
-  );
-  expect(worktreeMainRootOf(attackerDir)).toBeNull();
-});
-
-test('worktreeMainRootOf returns null for a plain non-git directory', async () => {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-nogit-'));
-  tmpDirs.push(dir);
-  expect(worktreeMainRootOf(dir)).toBeNull();
-});
-
-test('projectRootOf resolves a worktree cwd to the main tree root', async () => {
-  const { main, worktree } = await makeWorktreeFixture();
-  const { projectRootOf } = require('../activeSessions.cjs');
-  expect(projectRootOf(worktree)).toBe(main);
-});
-
-test('projectRootOf resolves a cwd nested inside a worktree\'s OWN ops tree to the main root', async () => {
-  const { main, worktree } = await makeWorktreeFixture();
-  const { projectRootOf } = require('../activeSessions.cjs');
-  const nestedOps = path.join(worktree, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(nestedOps, { recursive: true });
-  expect(projectRootOf(nestedOps)).toBe(main);
-});
-
-test('activeProjectCwds resolves a worktree cwd to the real project and drops unresolvable tmp cwds', async () => {
-  const { main, worktree } = await makeWorktreeFixture();
-  // A bare, .git-less directory directly under the managed epic-worktree
-  // root — the shape a torn-down or mid-teardown worktree leaves behind.
-  // worktreeMainRootOf can't resolve it (no .git), so only the drop-guard's
-  // prefixDropRoots check keeps it out of the project list.
-  fs.mkdirSync(WORKTREE_KIND_CONFIG.epic.root, { recursive: true });
-  const bareWorktreeRoot = await fsp.mkdtemp(path.join(WORKTREE_KIND_CONFIG.epic.root, 'sm-opsroot-bare-'));
-  tmpDirs.push(bareWorktreeRoot);
-  const projectsDir = await mkProjectsDir({
-    resolvable: worktree,
-    unresolvable: bareWorktreeRoot,
-    bareTmpdir: os.tmpdir(),
-  });
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds).toContain(main);
-  expect(cwds).not.toContain(worktree);
-  expect(cwds).not.toContain(bareWorktreeRoot);
-  expect(cwds).not.toContain(os.tmpdir());
-});
-
-test('a main-tree root resolved from a worktree dedupes against a directly-observed cwd for the same project', async () => {
-  const { main, worktree } = await makeWorktreeFixture();
-  const projectsDir = await mkProjectsDir({ direct: main, viaWorktree: worktree });
-
-  const cwds = activeProjectCwds(Infinity, { projectsDir });
-  expect(cwds.filter((c) => c === main)).toHaveLength(1);
-});

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

@@ -1,51 +0,0 @@
-/**
- * opsRootNestedWrite.test.cjs — writeSplit must never materialize a second
- * ops root beneath the first.
- *
- * Companion to opsRootAbsoluteCwd.test.cjs; separate file because HOME must
- * be overridden BEFORE requiring queueStore — MACHINE_STATE_PATH is baked
- * into a top-level const from os.homedir() at require time, and writeSplit
- * writes it on every call. (Learned the hard way: running this assertion in
- * the shared file overwrote the real ~/.claude/session-manager/
- * scheduler-machine.json, dropping the user's firePolicy and concurrencyCap.)
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/opsRootNestedWrite.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opsroot-home-'));
-process.env.HOME = tmpHome;
-
-const queueStore = require('../queueStore.cjs');
-
-const tmpDirs = [tmpHome];
-afterEach(async () => {
-  while (tmpDirs.length > 1) {
-    await fsp.rm(tmpDirs.pop(), { recursive: true, force: true }).catch(() => {});
-  }
-});
-
-test('one ops-internal cwd in a write batch is skipped without losing the other projects', async () => {
-  const good = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-good-'));
-  tmpDirs.push(good);
-  const bad = path.join(good, 'session-manager-operations', 'scheduler', 'epics', 'e-1', 'prds');
-  fs.mkdirSync(bad, { recursive: true });
-
-  await queueStore.writeSplit({
-    config: {},
-    sourceCwds: [bad, good],
-    jobs: [{ slug: 'keeper', cwd: good }, { slug: 'stray', cwd: bad }],
-  });
-
-  const written = JSON.parse(fs.readFileSync(queueStore.projectQueuePath(good), 'utf8'));
-  expect(written.jobs.map((j) => j.slug)).toEqual(['keeper']);
-  // The doubled-suffix stub the starry-night-ships report was about.
-  expect(fs.existsSync(path.join(bad, 'session-manager-operations'))).toBe(false);
-});

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

@@ -1,149 +0,0 @@
-'use strict';
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/opsRootResolve.test.cjs
-//
-// PRD 1082 — opsOwnership.cjs is THE ONE ops-root resolver. Every reader and
-// writer of `<project>/session-manager-operations/` builds its path through
-// resolveProjectRoot / resolveOpsRoot / opsPath, which normalize a worktree or
-// ops-internal cwd to the real project and refuse an ephemeral one. Before
-// this, each namespace did its own `path.join(cwd, 'session-manager-
-// operations', ...)`, so the worktree-cwd hazard had to be fixed one call site
-// at a time (2026-08-30, PRDs 1073/1074/1081).
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  resolveProjectRoot, resolveOpsRoot, opsPath, assertOpsWrite, OPS_ROOT_DIR,
-} = require('../opsOwnership.cjs');
-const { KIND_CONFIG } = require('../gitWorktree.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    await fsp.rm(tmpDirs.pop(), { recursive: true, force: true }).catch(() => {});
-  }
-});
-
-/** A fake main tree (has a real `.git` DIRECTORY) outside os.tmpdir(). */
-async function mkMainTree() {
-  const base = path.join(os.homedir(), '.cache', 'sm-opsroot-resolve-tests');
-  fs.mkdirSync(base, { recursive: true });
-  const main = await fsp.mkdtemp(path.join(base, 'main-'));
-  tmpDirs.push(main);
-  fs.mkdirSync(path.join(main, '.git'), { recursive: true });
-  return main;
-}
-
-/** A linked worktree of `main` (a `.git` FILE + the admin back-reference git writes). */
-async function mkLinkedWorktree(main) {
-  const worktree = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-opsroot-resolve-wt-'));
-  tmpDirs.push(worktree);
-  const name = 'sm-epic-test';
-  const adminDir = path.join(main, '.git', 'worktrees', name);
-  fs.mkdirSync(adminDir, { recursive: true });
-  const gitFile = path.join(worktree, '.git');
-  fs.writeFileSync(path.join(adminDir, 'gitdir'), `${gitFile}\n`);
-  fs.writeFileSync(gitFile, `gitdir: ${adminDir}\n`);
-  return worktree;
-}
-
-// ─── byte-equality regression for the common case ──────────────────────────
-
-test('a plain project root resolves to <root>/session-manager-operations, byte-identical to the old join', async () => {
-  const main = await mkMainTree();
-  assert.equal(resolveProjectRoot(main), main);
-  assert.equal(resolveOpsRoot(main), path.join(main, OPS_ROOT_DIR));
-  assert.equal(
-    opsPath(main, 'prompt-sessions', 'active-index.json'),
-    path.join(main, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
-  );
-});
-
-test('a plain directory with no enclosing .git anywhere is returned unchanged', () => {
-  const p = '/definitely/not/a/real/project';
-  assert.equal(resolveProjectRoot(p), p);
-  assert.equal(opsPath(p, 'logs'), path.join(p, OPS_ROOT_DIR, 'logs'));
-});
-
-// ─── normalization ──────────────────────────────────────────────────────────
-
-test('a linked worktree root resolves to its MAIN tree', async () => {
-  const main = await mkMainTree();
-  const wt = await mkLinkedWorktree(main);
-  assert.equal(resolveProjectRoot(wt), main);
-  assert.equal(opsPath(wt, 'scheduler', 'state'), path.join(main, OPS_ROOT_DIR, 'scheduler', 'state'));
-});
-
-test("a cwd deep inside a worktree's OWN ops tree resolves to the main tree's ops root", async () => {
-  const main = await mkMainTree();
-  const wt = await mkLinkedWorktree(main);
-  const nested = path.join(wt, OPS_ROOT_DIR, 'scheduler', 'state');
-  fs.mkdirSync(nested, { recursive: true });
-  assert.equal(resolveOpsRoot(nested), path.join(main, OPS_ROOT_DIR));
-});
-
-test('an ops-internal cwd of a plain project is truncated to the project (default normalize)', async () => {
-  const main = await mkMainTree();
-  const inside = path.join(main, OPS_ROOT_DIR, 'scheduler', 'epics', 'e1', 'prds');
-  assert.equal(resolveProjectRoot(inside), main);
-});
-
-test("a subdirectory of a git repo resolves to the repo root (the 2026-08-13 'src/main' stray-root shape)", async () => {
-  const main = await mkMainTree();
-  const sub = path.join(main, 'src', 'main', 'lib');
-  fs.mkdirSync(sub, { recursive: true });
-  assert.equal(resolveProjectRoot(sub), main);
-});
-
-test('a nested project that is its OWN git repo keeps its own root', async () => {
-  const outer = await mkMainTree();
-  const inner = path.join(outer, 'apps', 'inner');
-  fs.mkdirSync(path.join(inner, '.git'), { recursive: true });
-  assert.equal(resolveProjectRoot(inner), inner);
-});
-
-// ─── refusals ───────────────────────────────────────────────────────────────
-
-test("opsInternal:'refuse' throws on an ops-internal cwd instead of normalizing (the writer posture)", async () => {
-  const main = await mkMainTree();
-  const inside = path.join(main, OPS_ROOT_DIR, 'scheduler', 'state');
-  assert.throws(() => resolveProjectRoot(inside, { opsInternal: 'refuse' }), /not a path inside session-manager-operations/);
-});
-
-test('os.tmpdir() itself is refused with a tagged ephemeral error', () => {
-  assert.throws(() => resolveOpsRoot(os.tmpdir()), (e) => e.ephemeral === true && /ephemeral/.test(e.message));
-});
-
-test('a bare, .git-less dir under a managed worktree root is refused (cannot be normalized)', async () => {
-  fs.mkdirSync(KIND_CONFIG.epic.root, { recursive: true });
-  const bare = await fsp.mkdtemp(path.join(KIND_CONFIG.epic.root, 'sm-opsroot-resolve-bare-'));
-  tmpDirs.push(bare);
-  assert.throws(() => opsPath(bare, 'logs'), (e) => e.ephemeral === true);
-});
-
-test('relative, empty and non-string cwds throw (never resolved against process.cwd())', () => {
-  assert.throws(() => resolveProjectRoot('src/main/lib'), /absolute/);
-  assert.throws(() => resolveProjectRoot(''), /required/);
-  assert.throws(() => resolveProjectRoot(null), /required/);
-  assert.throws(() => resolveProjectRoot(42), /required/);
-});
-
-// ─── the single-writer gate is also the last line ──────────────────────────
-
-test('assertOpsWrite refuses a well-owned write whose project root is a linked worktree', async () => {
-  const main = await mkMainTree();
-  const wt = await mkLinkedWorktree(main);
-  const target = path.join(wt, OPS_ROOT_DIR, 'scheduler', 'state', 'queue.json');
-  assert.throws(() => assertOpsWrite(target, 'scheduler'), (e) => e.ephemeral === true);
-  // ...while the same write against the main tree is fine.
-  assert.doesNotThrow(() => assertOpsWrite(path.join(main, OPS_ROOT_DIR, 'scheduler', 'state', 'queue.json'), 'scheduler'));
-});
-
-test('assertOpsWrite still refuses the wrong writer before it ever looks at the root', async () => {
-  const main = await mkMainTree();
-  assert.throws(
-    () => assertOpsWrite(path.join(main, OPS_ROOT_DIR, 'scheduler', 'state', 'queue.json'), 'epics'),
-    /single-writer law/,
-  );
-});