claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,107 +0,0 @@
-/**
- * gitWorktreeSalvage.test.cjs — PRD 1071: a job worktree's uncommitted diff
- * (tracked + untracked) is salvaged to a patch file before teardown, so a
- * job killed before its finish-protocol commit doesn't lose its work when
- * cleanupWorktree removes the checkout right after.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/gitWorktreeSalvage.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, 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 gitWorktree = require('../gitWorktree.cjs');
-
-let tmpRoot;
-let repoCwd;
-// config.cjs's writeTextAtomic (used internally by salvageWorktreeDiff)
-// restricts writes to a fixed allowlist — real prod call sites write under
-// `~/.claude/session-manager/scheduled-plans/runs/...`, which is covered by
-// config.cjs's WRITE_PREFIXES. Mirror that here instead of writing under
-// os.tmpdir() (which validateWrite would reject) — same convention as
-// coldBootPromptSessionsWrite.test.cjs.
-let outDir;
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-beforeEach(() => {
-  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-gitworktree-salvage-'));
-  repoCwd = path.join(tmpRoot, 'repo');
-  initRepo(repoCwd);
-  outDir = fs.mkdtempSync(path.join(os.homedir(), '.claude', 'sm-test-salvage-'));
-  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
-});
-
-afterEach(() => {
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-  fs.rmSync(outDir, { recursive: true, force: true });
-});
-
-test('dirty worktree (tracked edit + untracked file) produces a non-empty patch with the untracked file\'s contents', async () => {
-  const slug = 'salvage-dirty';
-  const created = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
-  expect(created.ok).toBe(true);
-
-  fs.writeFileSync(path.join(created.dir, 'README.md'), 'hello\nedited\n', 'utf8');
-  fs.writeFileSync(path.join(created.dir, 'new-file.txt'), 'brand new untracked content\n', 'utf8');
-
-  const outFile = path.join(outDir, `${slug}.uncommitted.patch`);
-  const result = await gitWorktree.salvageWorktreeDiff({ cwd: created.dir, outFile });
-
-  expect(result.ok).toBe(true);
-  expect(result.bytes).toBeGreaterThan(0);
-  expect(fs.existsSync(outFile)).toBe(true);
-  const patch = fs.readFileSync(outFile, 'utf8');
-  expect(patch).toContain('new-file.txt');
-  expect(patch).toContain('brand new untracked content');
-  expect(patch).toContain('README.md');
-  expect(patch).toContain('edited');
-
-  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: created.dir, branch: created.branch });
-});
-
-test('clean worktree produces no patch file (no 0-byte artifact)', async () => {
-  const slug = 'salvage-clean';
-  const created = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
-  expect(created.ok).toBe(true);
-
-  const outFile = path.join(outDir, `${slug}.uncommitted.patch`);
-  const result = await gitWorktree.salvageWorktreeDiff({ cwd: created.dir, outFile });
-
-  expect(result.ok).toBe(false);
-  expect(fs.existsSync(outFile)).toBe(false);
-
-  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: created.dir, branch: created.branch });
-});
-
-test('a git failure during salvage is swallowed (never throws) and cleanup still runs', async () => {
-  const notAGitRepo = path.join(tmpRoot, 'not-a-repo');
-  fs.mkdirSync(notAGitRepo, { recursive: true });
-  const outFile = path.join(outDir, 'salvage-failure.uncommitted.patch');
-
-  await expect(gitWorktree.salvageWorktreeDiff({ cwd: notAGitRepo, outFile })).resolves.toEqual({ ok: false });
-  expect(fs.existsSync(outFile)).toBe(false);
-
-  // Cleanup of an unrelated, never-created worktree is itself a no-op but
-  // must still resolve without throwing — mirrors the finally-block shape in
-  // scheduler.cjs where salvage failure must never block integration/cleanup.
-  await expect(
-    gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: path.join(tmpRoot, 'never-existed'), branch: 'sm-job/does-not-exist' }),
-  ).resolves.toBeUndefined();
-});

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

@@ -1,153 +0,0 @@
-/**
- * gitWorktreeSalvageDelta.test.cjs — PRD 1098: `salvageDirtyDelta` is the
- * shared-tree counterpart to `salvageWorktreeDiff` (gitWorktreeSalvage.test.cjs)
- * — it salvages an IN-PLACE job's uncommitted work without a throwaway
- * worktree checkout to diff and discard, so it must be strictly DELTA-scoped
- * (only the caller-supplied paths, never a whole-tree dump) and must never
- * mutate the shared tree (no add/stash/reset/checkout/clean) the way
- * `salvageWorktreeDiff`'s `git add -A --intent-to-add` deliberately can
- * against a disposable checkout.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/gitWorktreeSalvageDelta.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, 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 gitWorktree = require('../gitWorktree.cjs');
-
-let tmpRoot;
-let repoCwd;
-let outDir;
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  fs.writeFileSync(path.join(dir, 'tracked-a.txt'), 'a\n', 'utf8');
-  fs.writeFileSync(path.join(dir, 'tracked-b.txt'), 'b\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-beforeEach(() => {
-  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-gitworktree-salvage-delta-'));
-  repoCwd = path.join(tmpRoot, 'repo');
-  initRepo(repoCwd);
-  outDir = fs.mkdtempSync(path.join(os.homedir(), '.claude', 'sm-test-salvage-delta-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-  fs.rmSync(outDir, { recursive: true, force: true });
-});
-
-test('salvages only the given delta paths (tracked edit + untracked new file), never a pre-existing dirty file outside the delta', async () => {
-  // Pre-existing WIP that must NEVER appear in the patch — the whole point
-  // of delta-scoping.
-  fs.writeFileSync(path.join(repoCwd, 'tracked-b.txt'), 'b\npre-existing human WIP\n', 'utf8');
-
-  // This job's own delta: an edit to tracked-a.txt and a new untracked file.
-  fs.writeFileSync(path.join(repoCwd, 'tracked-a.txt'), 'a\nedited by job\n', 'utf8');
-  fs.writeFileSync(path.join(repoCwd, 'job-new-file.txt'), 'brand new job output\n', 'utf8');
-
-  const outFile = path.join(outDir, 'delta.uncommitted.patch');
-  const result = await gitWorktree.salvageDirtyDelta({
-    cwd: repoCwd,
-    paths: ['tracked-a.txt', 'job-new-file.txt'],
-    outFile,
-  });
-
-  expect(result.ok).toBe(true);
-  expect(result.bytes).toBeGreaterThan(0);
-  const patch = fs.readFileSync(outFile, 'utf8');
-  expect(patch).toContain('tracked-a.txt');
-  expect(patch).toContain('edited by job');
-  expect(patch).toContain('job-new-file.txt');
-  expect(patch).toContain('brand new job output');
-  // The sibling/human's pre-existing dirty file is NOT in the delta list —
-  // it must never leak into this job's patch.
-  expect(patch).not.toContain('pre-existing human WIP');
-});
-
-test('applies cleanly with git apply --check against a fresh clone of the base tree', async () => {
-  fs.writeFileSync(path.join(repoCwd, 'tracked-a.txt'), 'a\nedited\n', 'utf8');
-  fs.writeFileSync(path.join(repoCwd, 'job-new-file.txt'), 'new content\n', 'utf8');
-
-  const outFile = path.join(outDir, 'apply-check.uncommitted.patch');
-  const result = await gitWorktree.salvageDirtyDelta({
-    cwd: repoCwd,
-    paths: ['tracked-a.txt', 'job-new-file.txt'],
-    outFile,
-  });
-  expect(result.ok).toBe(true);
-
-  // Fresh clone of the same commit, clean, to prove the patch is
-  // self-sufficient and applies against the pristine base state.
-  const cleanCheckout = path.join(tmpRoot, 'clean-checkout');
-  git(['clone', '-q', repoCwd, cleanCheckout], tmpRoot);
-  expect(() => git(['apply', '--check', outFile], cleanCheckout)).not.toThrow();
-});
-
-test('never mutates the shared tree: git status and stash list are byte-identical before and after', async () => {
-  // A human's own pre-existing WIP, deliberately outside the delta.
-  fs.writeFileSync(path.join(repoCwd, 'tracked-b.txt'), 'b\nhuman wip\n', 'utf8');
-  fs.writeFileSync(path.join(repoCwd, 'tracked-a.txt'), 'a\njob edit\n', 'utf8');
-  fs.writeFileSync(path.join(repoCwd, 'job-new-file.txt'), 'job output\n', 'utf8');
-
-  const statusBefore = git(['status', '--porcelain'], repoCwd);
-  const stashBefore = git(['stash', 'list'], repoCwd);
-
-  const outFile = path.join(outDir, 'no-mutate.uncommitted.patch');
-  const result = await gitWorktree.salvageDirtyDelta({
-    cwd: repoCwd,
-    paths: ['tracked-a.txt', 'job-new-file.txt'],
-    outFile,
-  });
-  expect(result.ok).toBe(true);
-
-  const statusAfter = git(['status', '--porcelain'], repoCwd);
-  const stashAfter = git(['stash', 'list'], repoCwd);
-  expect(statusAfter).toBe(statusBefore);
-  expect(stashAfter).toBe(stashBefore);
-});
-
-test('no delta paths dirty at call time produces no patch file (no 0-byte artifact)', async () => {
-  const outFile = path.join(outDir, 'clean.uncommitted.patch');
-  const result = await gitWorktree.salvageDirtyDelta({
-    cwd: repoCwd,
-    paths: ['tracked-a.txt'],
-    outFile,
-  });
-  expect(result.ok).toBe(false);
-  expect(fs.existsSync(outFile)).toBe(false);
-});
-
-test('empty paths list is a no-op', async () => {
-  const outFile = path.join(outDir, 'empty.uncommitted.patch');
-  const result = await gitWorktree.salvageDirtyDelta({ cwd: repoCwd, paths: [], outFile });
-  expect(result.ok).toBe(false);
-  expect(fs.existsSync(outFile)).toBe(false);
-});
-
-test('a git failure (not a repo) is swallowed and never throws', async () => {
-  const notAGitRepo = path.join(tmpRoot, 'not-a-repo');
-  fs.mkdirSync(notAGitRepo, { recursive: true });
-  fs.writeFileSync(path.join(notAGitRepo, 'x.txt'), 'x\n', 'utf8');
-  const outFile = path.join(outDir, 'failure.uncommitted.patch');
-
-  await expect(
-    gitWorktree.salvageDirtyDelta({ cwd: notAGitRepo, paths: ['x.txt'], outFile }),
-  ).resolves.toEqual({ ok: false });
-  expect(fs.existsSync(outFile)).toBe(false);
-});

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

@@ -1,158 +0,0 @@
-/**
- * guardShims.test.cjs — unit tests for the stable, app-upgrade-proof guard
- * hook indirection (guardShims.cjs). Uses a temp "home" dir per test so the
- * real ~/.claude is never touched.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/guardShims.test.cjs
- */
-
-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 { execFileSync } = require('node:child_process');
-const {
-  APP_ROOT,
-  GUARD_NAMES,
-  hooksDir,
-  pointerPath,
-  shimPath,
-  writeGuardShims,
-  guardShimsExist,
-} = require('../guardShims.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkTmp(prefix) {
-  const d = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
-  tmpDirs.push(d);
-  return d;
-}
-
-/** Run a guard (by absolute path, e.g. a shim) as a child process, same
- *  pattern delegationReadiness.test.cjs uses to exercise the real guards —
- *  NEVER require() a guard/shim in-process, since its main() calls
- *  process.exit(0) as a require-time side effect. */
-function runGuard(scriptPath, { toolName = 'Write', toolInput, cwd }) {
-  return JSON.parse(execFileSync('node', [scriptPath], {
-    input: JSON.stringify({ tool_name: toolName, tool_input: toolInput, cwd }),
-    encoding: 'utf8',
-  }));
-}
-
-test('writeGuardShims: writes the pointer file and all three shims under homeDir', async () => {
-  const homeDir = await mkTmp('sm-guard-shims-home-');
-  const r = await writeGuardShims({ homeDir });
-  expect(r.ok).toBe(true);
-
-  expect(fs.existsSync(pointerPath(homeDir))).toBe(true);
-  expect(JSON.parse(fs.readFileSync(pointerPath(homeDir), 'utf8'))).toEqual({ appRoot: APP_ROOT });
-  for (const name of GUARD_NAMES) {
-    expect(fs.existsSync(shimPath(name, homeDir))).toBe(true);
-  }
-  expect(guardShimsExist(homeDir)).toBe(true);
-});
-
-test('writeGuardShims: does NOT vendor guard logic — the shim body only references the guard by name, never copies its source', async () => {
-  const homeDir = await mkTmp('sm-guard-shims-home-');
-  await writeGuardShims({ homeDir });
-
-  const realSource = fs.readFileSync(path.join(APP_ROOT, 'scripts', 'hooks', 'guard-prd-writes.cjs'), 'utf8');
-  const shimSource = fs.readFileSync(shimPath('guard-prd-writes.cjs', homeDir), 'utf8');
-  expect(shimSource).not.toContain('SCHEDULER_SEGMENT'); // a guard-prd-writes-specific symbol
-  expect(shimSource.length).toBeLessThan(realSource.length / 2);
-  expect(shimSource).toContain("require(path.join(ptr.appRoot, 'scripts', 'hooks', 'guard-prd-writes.cjs'))");
-});
-
-test('writeGuardShims: idempotent — re-running with the same appRoot produces byte-identical files', async () => {
-  const homeDir = await mkTmp('sm-guard-shims-home-');
-  const r1 = await writeGuardShims({ homeDir });
-  expect(r1.ok).toBe(true);
-  const pointerBefore = fs.readFileSync(pointerPath(homeDir), 'utf8');
-  const shimsBefore = GUARD_NAMES.map((n) => fs.readFileSync(shimPath(n, homeDir), 'utf8'));
-
-  const r2 = await writeGuardShims({ homeDir });
-  expect(r2.ok).toBe(true);
-  expect(fs.readFileSync(pointerPath(homeDir), 'utf8')).toBe(pointerBefore);
-  GUARD_NAMES.forEach((n, i) => {
-    expect(fs.readFileSync(shimPath(n, homeDir), 'utf8')).toBe(shimsBefore[i]);
-  });
-});
-
-test('writeGuardShims: the installed shim actually resolves through the pointer and runs the real guard logic', async () => {
-  const homeDir = await mkTmp('sm-guard-shims-home-');
-  const cwd = await mkTmp('sm-guard-shims-cwd-');
-  await writeGuardShims({ homeDir });
-
-  const denied = runGuard(shimPath('guard-prd-writes.cjs', homeDir), {
-    toolInput: { file_path: path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', '1234-x.md'), content: '# x' },
-    cwd,
-  });
-  expect(denied.hookSpecificOutput?.permissionDecision).toBe('deny');
-
-  const allowed = runGuard(shimPath('guard-prd-writes.cjs', homeDir), {
-    toolInput: { file_path: path.join(cwd, 'src', 'x.ts'), content: 'x' },
-    cwd,
-  });
-  expect(allowed.hookSpecificOutput?.permissionDecision).not.toBe('deny');
-});
-
-test('writeGuardShims: rewriting the pointer to a DIFFERENT app root lets an already-installed shim follow an app upgrade with no re-install', async () => {
-  const homeDir = await mkTmp('sm-guard-shims-home-');
-  const cwd = await mkTmp('sm-guard-shims-cwd-');
-  await writeGuardShims({ homeDir }); // "first install", points at the real APP_ROOT
-  const shimFile = shimPath('guard-prd-writes.cjs', homeDir);
-  const shimBytesBefore = fs.readFileSync(shimFile, 'utf8');
-
-  // Simulate an app upgrade: a second "app root" at a brand-new path, with
-  // its own copy of scripts/hooks/guard-prd-writes.cjs — the file guardShims
-  // reads through the pointer at invocation time — plus the sibling policy
-  // module it `require()`s at load time (guard-prd-writes-policy.cjs, PRD
-  // 1415); a real upgrade ships both since both are listed in package.json's
-  // "files".
-  const secondAppRoot = await mkTmp('sm-guard-shims-upgraded-app-');
-  await fsp.mkdir(path.join(secondAppRoot, 'scripts', 'hooks', 'lib'), { recursive: true });
-  await fsp.copyFile(
-    path.join(APP_ROOT, 'scripts', 'hooks', 'guard-prd-writes.cjs'),
-    path.join(secondAppRoot, 'scripts', 'hooks', 'guard-prd-writes.cjs'),
-  );
-  await fsp.copyFile(
-    path.join(APP_ROOT, 'scripts', 'hooks', 'lib', 'guard-prd-writes-policy.cjs'),
-    path.join(secondAppRoot, 'scripts', 'hooks', 'lib', 'guard-prd-writes-policy.cjs'),
-  );
-
-  const r = await writeGuardShims({ homeDir, appRoot: secondAppRoot });
-  expect(r.ok).toBe(true);
-  expect(JSON.parse(fs.readFileSync(pointerPath(homeDir), 'utf8')).appRoot).toBe(secondAppRoot);
-  // The shim FILE at the already-installed path never changed.
-  expect(fs.readFileSync(shimFile, 'utf8')).toBe(shimBytesBefore);
-
-  // A project hook that already references this exact shim path keeps working.
-  const denied = runGuard(shimFile, {
-    toolInput: { file_path: path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', '1234-x.md'), content: '# x' },
-    cwd,
-  });
-  expect(denied.hookSpecificOutput?.permissionDecision).toBe('deny');
-});
-
-test('writeGuardShims: returns { ok:false, error } without throwing when homeDir cannot be written to', async () => {
-  const base = await mkTmp('sm-guard-shims-unwritable-');
-  const blocker = path.join(base, 'blocker-file');
-  await fsp.writeFile(blocker, 'x', 'utf8');
-  // A homeDir whose parent path segment is a plain FILE can never be mkdir'd
-  // into (ENOTDIR) — reproduces "unwritable ~/.claude" without relying on
-  // permission bits, which root would bypass.
-  const homeDir = path.join(blocker, 'home');
-
-  const r = await writeGuardShims({ homeDir });
-  expect(r.ok).toBe(false);
-  expect(r.error).toBeTruthy();
-  expect(guardShimsExist(homeDir)).toBe(false);
-});

package/src/main/lib/__tests__/importReferences.spec.cjs

@@ -1,56 +0,0 @@
-/**
- * importReferences.spec.cjs — unit tests for listReferencedFiles, the IPC-facing
- * wrapper around personaImportHealth's `@path` import-chain walker.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/importReferences.spec.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { listReferencedFiles } = require('../importReferences.cjs');
-
-function mkTmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'import-refs-test-'));
-}
-
-test('listReferencedFiles: 2 valid @imports returns 2 entries with correct sizeBytes/tokenEstimate/ok', () => {
-  const dir = mkTmpDir();
-  const a = path.join(dir, 'a.md');
-  const b = path.join(dir, 'b.md');
-  const root = path.join(dir, 'root.md');
-  fs.writeFileSync(a, 'x'.repeat(40));
-  fs.writeFileSync(b, 'y'.repeat(8));
-  fs.writeFileSync(root, `@${a}\n@${b}\n`);
-
-  const result = listReferencedFiles(root);
-
-  expect(result).toHaveLength(2);
-  const byPath = Object.fromEntries(result.map((r) => [r.path, r]));
-  expect(byPath[a]).toEqual({ path: a, exists: true, sizeBytes: 40, tokenEstimate: 10, ok: true });
-  expect(byPath[b]).toEqual({ path: b, exists: true, sizeBytes: 8, tokenEstimate: 2, ok: true });
-});
-
-test('listReferencedFiles: missing import returns ok=false with sizeBytes 0', () => {
-  const dir = mkTmpDir();
-  const missing = path.join(dir, 'does-not-exist.md');
-  const root = path.join(dir, 'root.md');
-  fs.writeFileSync(root, `@${missing}\n`);
-
-  const result = listReferencedFiles(root);
-
-  expect(result).toEqual([
-    { path: missing, exists: false, sizeBytes: 0, tokenEstimate: 0, ok: false },
-  ]);
-});
-
-test('listReferencedFiles: zero @import lines returns an empty array', () => {
-  const dir = mkTmpDir();
-  const root = path.join(dir, 'root.md');
-  fs.writeFileSync(root, 'no imports here, just prose.\n');
-
-  expect(listReferencedFiles(root)).toEqual([]);
-});

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

@@ -1,173 +0,0 @@
-// PRD 834 — machine-wide scheduler-ownership lock. Secondary instances must
-// go scheduler-passive instead of running boot reconciliation / admin server
-// against the owner's queue state (live incident 2026-07-31).
-//
-// HOME is stubbed to a mkdtemp dir BEFORE requiring instanceLock.cjs (mirrors
-// scheduler-reconcile-invalid-repair.test.cjs): instanceLock.cjs pulls in
-// auditLog.cjs, whose audit log path resolves from
-// os.homedir() — so real ~/.claude/session-manager state must never be
-// touched by this suite.
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-let originalHome;
-let tmpHome;
-let instanceLock;
-let auditLogPath;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-instance-lock-home-'));
-  process.env.HOME = tmpHome;
-  instanceLock = require('../instanceLock.cjs');
-  ({ auditLogPath } = require('../auditLog.cjs'));
-  if (!auditLogPath().startsWith(tmpHome)) {
-    throw new Error(`refusing to run: auditLogPath() (${auditLogPath()}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-// Thin pass-throughs so every test body below can keep calling these as
-// bare names, resolved lazily against the module loaded in beforeAll.
-const acquireSchedulerOwnership = (...args) => instanceLock.acquireSchedulerOwnership(...args);
-const releaseSchedulerOwnership = (...args) => instanceLock.releaseSchedulerOwnership(...args);
-const pidAlive = (...args) => instanceLock.pidAlive(...args);
-const lockPath = (...args) => instanceLock.lockPath(...args);
-
-function readAuditEvents() {
-  if (!fs.existsSync(auditLogPath())) return [];
-  return fs.readFileSync(auditLogPath(), 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-}
-
-let dir;
-
-beforeEach(() => {
-  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-instance-lock-'));
-  process.env.SM_SCHEDULER_LOCK_PATH = path.join(dir, 'scheduler-owner.lock');
-});
-
-afterEach(() => {
-  delete process.env.SM_SCHEDULER_LOCK_PATH;
-  delete process.env.SM_PROC_ROOT;
-  fs.rmSync(dir, { recursive: true, force: true });
-  if (fs.existsSync(auditLogPath())) fs.rmSync(auditLogPath(), { force: true });
-});
-
-describe('instanceLock (PRD 834)', () => {
-  it('first acquirer becomes owner and writes its pid', () => {
-    const res = acquireSchedulerOwnership();
-    expect(res.owner).toBe(true);
-    const onDisk = JSON.parse(fs.readFileSync(lockPath(), 'utf8'));
-    expect(onDisk.pid).toBe(process.pid);
-  });
-
-  it('a live foreign holder makes acquisition passive with the holder pid reported', () => {
-    // Use our own live pid as the "foreign" holder — pidAlive(process.pid) is
-    // true, and acquire treats pid !== process.pid as foreign, so fake one by
-    // writing pid 1 (init — always alive, never ours).
-    fs.mkdirSync(path.dirname(lockPath()), { recursive: true });
-    fs.writeFileSync(lockPath(), JSON.stringify({ pid: 1, startedAt: 'x' }));
-    const res = acquireSchedulerOwnership();
-    expect(res.owner).toBe(false);
-    expect(res.holderPid).toBe(1);
-    // The holder's lock is untouched.
-    expect(JSON.parse(fs.readFileSync(lockPath(), 'utf8')).pid).toBe(1);
-  });
-
-  it('a stale lock (dead pid) is broken and ownership taken', () => {
-    // Find a pid that is certainly dead: spawn nothing — use a huge pid
-    // beyond pid_max defaults.
-    fs.mkdirSync(path.dirname(lockPath()), { recursive: true });
-    fs.writeFileSync(lockPath(), JSON.stringify({ pid: 2 ** 30, startedAt: 'x' }));
-    const res = acquireSchedulerOwnership();
-    expect(res.owner).toBe(true);
-    expect(JSON.parse(fs.readFileSync(lockPath(), 'utf8')).pid).toBe(process.pid);
-  });
-
-  it('re-acquiring our own lock stays owner (idempotent across re-init)', () => {
-    expect(acquireSchedulerOwnership().owner).toBe(true);
-    expect(acquireSchedulerOwnership().owner).toBe(true);
-  });
-
-  it('release removes only our own lock', () => {
-    acquireSchedulerOwnership();
-    releaseSchedulerOwnership();
-    expect(fs.existsSync(lockPath())).toBe(false);
-    // A foreign lock is never removed by release.
-    fs.writeFileSync(lockPath(), JSON.stringify({ pid: 1, startedAt: 'x' }));
-    releaseSchedulerOwnership();
-    expect(fs.existsSync(lockPath())).toBe(true);
-  });
-
-  it('a corrupt lock file is treated as stale, not fatal', () => {
-    fs.mkdirSync(path.dirname(lockPath()), { recursive: true });
-    fs.writeFileSync(lockPath(), 'not json {');
-    const res = acquireSchedulerOwnership();
-    expect(res.owner).toBe(true);
-  });
-
-  it('pidAlive: own pid alive, absurd pid dead', () => {
-    expect(pidAlive(process.pid)).toBe(true);
-    expect(pidAlive(2 ** 30)).toBe(false);
-    expect(pidAlive(-5)).toBe(false);
-    expect(pidAlive(0)).toBe(false);
-  });
-
-  it('a legacy lock ({pid, startedAt} only, no identity) is respected while its pid is alive', () => {
-    // Mirrors the on-disk shape of every lock written before this PRD.
-    fs.mkdirSync(path.dirname(lockPath()), { recursive: true });
-    fs.writeFileSync(lockPath(), JSON.stringify({ pid: 1, startedAt: 'x' }));
-    const res = acquireSchedulerOwnership();
-    expect(res.owner).toBe(false);
-    expect(res.holderPid).toBe(1);
-    expect(JSON.parse(fs.readFileSync(lockPath(), 'utf8')).pid).toBe(1);
-    // No identity information to compare, so no stale-lock-broken audit event.
-    expect(readAuditEvents().some((e) => e.kind === 'stale_lock_broken')).toBe(false);
-  });
-
-  it('a recorded identity that no longer matches the live process at that (recycled) pid is broken, and audited', () => {
-    // process.ppid is guaranteed alive for the lifetime of this test (the
-    // vitest worker's own parent) — stand-in for "a hard crash left a lock
-    // whose pid was later reused by an unrelated live process".
-    const recycledPid = process.ppid;
-    const procRoot = path.join(dir, 'proc');
-    fs.mkdirSync(path.join(procRoot, String(recycledPid)), { recursive: true });
-    fs.writeFileSync(
-      path.join(procRoot, String(recycledPid), 'stat'),
-      `${recycledPid} (bash) S 1 ${recycledPid} ${recycledPid} 0 -1 4194304 0 0 0 0 0 0 0 0 20 0 1 0 222222 0 0 0 0 0 0 0 0 0 0 0 0 0 17 0 0 0 0 0 0 0 0 0 0 0 0\n`,
-    );
-    fs.writeFileSync(path.join(procRoot, String(recycledPid), 'cmdline'), 'bash\0');
-    process.env.SM_PROC_ROOT = procRoot;
-
-    fs.mkdirSync(path.dirname(lockPath()), { recursive: true });
-    fs.writeFileSync(lockPath(), JSON.stringify({
-      pid: recycledPid,
-      startedAt: 'x',
-      // The identity the crashed scheduler instance actually recorded — a
-      // different cmdline/startTicks than the process now holding this pid.
-      identity: { pid: recycledPid, startTicks: 111111, cmdline: 'claude --session-id old', complete: true },
-    }));
-
-    const res = acquireSchedulerOwnership();
-    expect(res.owner).toBe(true);
-    expect(JSON.parse(fs.readFileSync(lockPath(), 'utf8')).pid).toBe(process.pid);
-
-    const auditEvents = readAuditEvents().filter((e) => e.kind === 'stale_lock_broken');
-    expect(auditEvents.length).toBe(1);
-    expect(auditEvents[0].recordedPid).toBe(recycledPid);
-  });
-
-  it('writeLockExclusive (via acquire) records a complete identity for this process', () => {
-    acquireSchedulerOwnership();
-    const onDisk = JSON.parse(fs.readFileSync(lockPath(), 'utf8'));
-    expect(onDisk.identity).toBeTruthy();
-    expect(onDisk.identity.pid).toBe(process.pid);
-    expect(onDisk.identity.complete).toBe(true);
-  });
-});