claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,179 +0,0 @@
-/**
- * activeIndexRebuild.test.cjs — rebuildActiveIndex reconstructs
- * active-index.json's `sessions` map from the per-Epic status mirrors
- * epicStatusMirror.cjs writes, honoring tombstones and archivedAt exactly
- * the way the domain model requires (never resurrecting either).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/activeIndexRebuild.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 { rebuildActiveIndex } = require('../activeIndexRebuild.cjs');
-const { activeIndexPath, readActiveIndex } = require('../epicMint.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkCwd() {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-rebuild-cwd-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-function promptSessionsDir(cwd) {
-  return path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-}
-
-function writeMirrorFile(cwd, id, data) {
-  const dir = promptSessionsDir(cwd);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(data, null, 2));
-}
-
-function writeIndex(cwd, index) {
-  const dir = promptSessionsDir(cwd);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify(index, null, 2));
-}
-
-function liveMirror(id, cwd, overrides = {}) {
-  return {
-    id,
-    cwd,
-    goalText: `goal for ${id}`,
-    claudeSessionId: `sess-${id}`,
-    status: 'proposed',
-    createdAt: '2026-01-01T00:00:00.000Z',
-    completedAt: null,
-    archivedAt: null,
-    indexedAt: '2026-01-01T00:00:01.000Z',
-    ...overrides,
-  };
-}
-
-test('restores a row for every mirrored file with a live status', async () => {
-  const cwd = await mkCwd();
-  writeMirrorFile(cwd, 'e-1', liveMirror('e-1', cwd, { status: 'proposed' }));
-  writeMirrorFile(cwd, 'e-2', liveMirror('e-2', cwd, { status: 'active' }));
-
-  const { rows, skipped, reasons } = await rebuildActiveIndex(cwd);
-
-  expect(rows.map((r) => r.id).sort()).toEqual(['e-1', 'e-2']);
-  expect(skipped).toEqual([]);
-  expect(reasons).toEqual({});
-
-  const onDisk = readActiveIndex(cwd);
-  expect(onDisk.sessions['e-1'].status).toBe('proposed');
-  expect(onDisk.sessions['e-2'].status).toBe('active');
-});
-
-test('respects tombstones — a tombstoned id is never resurrected even if its file says active', async () => {
-  const cwd = await mkCwd();
-  writeIndex(cwd, { sessions: {}, events: {}, tombstones: { 'e-dead': '2026-01-02T00:00:00.000Z' } });
-  writeMirrorFile(cwd, 'e-dead', liveMirror('e-dead', cwd, { status: 'active' }));
-  writeMirrorFile(cwd, 'e-alive', liveMirror('e-alive', cwd, { status: 'proposed' }));
-
-  const { rows, skipped, reasons } = await rebuildActiveIndex(cwd);
-
-  expect(rows.map((r) => r.id)).toEqual(['e-alive']);
-  expect(skipped).toContain('e-dead.json');
-  expect(reasons['e-dead.json']).toMatch(/tombstoned/);
-
-  const onDisk = readActiveIndex(cwd);
-  expect(onDisk.sessions['e-dead']).toBeUndefined();
-  expect(onDisk.tombstones['e-dead']).toBe('2026-01-02T00:00:00.000Z');
-});
-
-test('respects archivedAt — a completed Epic file is never restored as a live row', async () => {
-  const cwd = await mkCwd();
-  writeMirrorFile(cwd, 'e-done', {
-    ...liveMirror('e-done', cwd, { status: 'completed' }),
-    archivedAt: '2026-01-03T00:00:00.000Z',
-  });
-  writeMirrorFile(cwd, 'e-open', liveMirror('e-open', cwd, { status: 'active' }));
-
-  const { rows, skipped, reasons } = await rebuildActiveIndex(cwd);
-
-  expect(rows.map((r) => r.id)).toEqual(['e-open']);
-  expect(skipped).toContain('e-done.json');
-  expect(reasons['e-done.json']).toMatch(/archivedAt/);
-});
-
-test('is idempotent — running it twice on a clean project yields a byte-identical index', async () => {
-  const cwd = await mkCwd();
-  writeMirrorFile(cwd, 'e-1', liveMirror('e-1', cwd));
-  writeMirrorFile(cwd, 'e-2', liveMirror('e-2', cwd, { status: 'active' }));
-
-  await rebuildActiveIndex(cwd);
-  const first = fs.readFileSync(activeIndexPath(cwd), 'utf8');
-
-  await rebuildActiveIndex(cwd);
-  const second = fs.readFileSync(activeIndexPath(cwd), 'utf8');
-
-  expect(second).toBe(first);
-});
-
-test('skips an unreadable Epic file, naming it in reasons, without aborting the rebuild', async () => {
-  const cwd = await mkCwd();
-  const dir = promptSessionsDir(cwd);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'e-corrupt.json'), '{ this is not json');
-  writeMirrorFile(cwd, 'e-good', liveMirror('e-good', cwd));
-
-  const { rows, skipped, reasons } = await rebuildActiveIndex(cwd);
-
-  expect(rows.map((r) => r.id)).toEqual(['e-good']);
-  expect(skipped).toContain('e-corrupt.json');
-  expect(reasons['e-corrupt.json']).toMatch(/unreadable/);
-});
-
-test('a file with no mirrored status is skipped and listed with a reason, never guessed at', async () => {
-  const cwd = await mkCwd();
-  const dir = promptSessionsDir(cwd);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'e-legacy.json'), JSON.stringify({ id: 'e-legacy', cwd }));
-
-  const { rows, skipped, reasons } = await rebuildActiveIndex(cwd);
-
-  expect(rows).toEqual([]);
-  expect(skipped).toContain('e-legacy.json');
-  expect(reasons['e-legacy.json']).toMatch(/no status mirror/);
-});
-
-test('preserves the existing events and tombstones maps untouched', async () => {
-  const cwd = await mkCwd();
-  const events = { 'e-1': [{ id: 'evt-1', promptSessionId: 'e-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z', text: 'go' }] };
-  const tombstones = { 'e-old': '2026-01-01T00:00:00.000Z' };
-  writeIndex(cwd, { sessions: {}, events, tombstones });
-  writeMirrorFile(cwd, 'e-1', liveMirror('e-1', cwd));
-
-  await rebuildActiveIndex(cwd);
-
-  const onDisk = readActiveIndex(cwd);
-  expect(onDisk.events).toEqual(events);
-  expect(onDisk.tombstones).toEqual(tombstones);
-});
-
-test('dryRun previews without writing anything to disk', async () => {
-  const cwd = await mkCwd();
-  writeIndex(cwd, { sessions: {}, events: {}, tombstones: {} });
-  writeMirrorFile(cwd, 'e-1', liveMirror('e-1', cwd));
-
-  const before = fs.readFileSync(activeIndexPath(cwd), 'utf8');
-  const { rows } = await rebuildActiveIndex(cwd, { dryRun: true });
-  const after = fs.readFileSync(activeIndexPath(cwd), 'utf8');
-
-  expect(rows.map((r) => r.id)).toEqual(['e-1']);
-  expect(after).toBe(before);
-});

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

@@ -1,67 +0,0 @@
-/**
- * agentPersonaSchema.test.cjs — unit tests for the canonical Agent persona
- * WRITE-path zod schema and its assertValidAgentPersonaSave fail-closed
- * helper.
- *
- * Agent is the third entity in the Agent/WorkType/Epic/PRD/Job ERD to get a
- * boundary schema — Epic (promptSessionSchema.cjs) and Job
- * (scheduleJobSchema.cjs) each got theirs only after a production incident;
- * this one closes the gap proactively before Agent has had its own.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/agentPersonaSchema.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  AgentPersonaSaveSchema,
-  assertValidAgentPersonaSave,
-} = require('../agentPersonaSchema.cjs');
-
-function validPersona(overrides = {}) {
-  return {
-    name: 'code-reviewer',
-    description: 'Reviews diffs for correctness and style.',
-    tools: ['Read', 'Grep', 'Glob'],
-    model: 'inherit',
-    color: 'blue',
-    tags: ['feature', 'bug'],
-    projects: ['*'],
-    action: '/develop\n\nReview the current diff.',
-    actionLabel: 'Review',
-    title: 'Engineering — Code Reviewer',
-    body: 'You are a meticulous code reviewer.',
-    ...overrides,
-  };
-}
-
-test('a valid full persona parses', () => {
-  const full = validPersona();
-  expect(() => assertValidAgentPersonaSave(full)).not.toThrow();
-  expect(AgentPersonaSaveSchema.safeParse(full).success).toBe(true);
-});
-
-test('a persona with an unknown tag is rejected', () => {
-  const badTag = validPersona({ tags: ['feature', 'not-a-real-worktype'] });
-  expect(() => assertValidAgentPersonaSave(badTag)).toThrow(/tags/);
-});
-
-test('a persona with an uppercase/spaced name is rejected', () => {
-  const badName = validPersona({ name: 'Code Reviewer' });
-  expect(() => assertValidAgentPersonaSave(badName)).toThrow(/name/);
-});
-
-test('a persona with only the required fields parses', () => {
-  const minimal = {
-    name: 'minimal-agent',
-    description: '',
-    tools: [],
-    model: 'inherit',
-    color: '',
-    tags: [],
-    body: '',
-  };
-  expect(() => assertValidAgentPersonaSave(minimal)).not.toThrow();
-  expect(AgentPersonaSaveSchema.safeParse(minimal).success).toBe(true);
-});

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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,107 +0,0 @@
-/**
- * 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__/branchSweep.test.cjs

@@ -1,164 +0,0 @@
-/**
- * branchSweep.test.cjs — PRD 1135: recovering `sm-job/<slug>` branches left
- * stranded (unmerged, owning job row terminal or gone) never gets swept away
- * by hand months later.
- *
- * Exercises the real `git` plumbing against throwaway repos under
- * os.tmpdir() (fast — no network, no Electron).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/branchSweep.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 { sweepStrandedJobBranches } = require('../branchSweep.cjs');
-
-let tmpRoot;
-let repoCwd;
-let worktreeDir;
-
-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-branchsweep-'));
-  repoCwd = path.join(tmpRoot, 'repo');
-  initRepo(repoCwd);
-  delete process.env.SM_BRANCH_SWEEP_DISABLE;
-});
-
-afterEach(() => {
-  if (worktreeDir && fs.existsSync(worktreeDir)) {
-    try { git(['worktree', 'remove', '--force', worktreeDir], repoCwd); } catch { /* best effort */ }
-  }
-  worktreeDir = undefined;
-  delete process.env.SM_BRANCH_SWEEP_DISABLE;
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-/** Create an `sm-job/<slug>` branch with one commit beyond HEAD, without checking it out. */
-function makeStrandedBranch(cwd, slug, fileContents = 'stranded work\n') {
-  const branch = `sm-job/${slug}`;
-  git(['branch', branch], cwd);
-  const tmpCheckout = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-checkout-'));
-  git(['worktree', 'add', '-q', tmpCheckout, branch], cwd);
-  fs.writeFileSync(path.join(tmpCheckout, `${slug}.txt`), fileContents, 'utf8');
-  git(['add', '-A'], tmpCheckout);
-  git(['commit', '-q', '-m', `job ${slug} work`], tmpCheckout);
-  git(['worktree', 'remove', '--force', tmpCheckout], cwd);
-  return branch;
-}
-
-test('stranded branch with a terminal job row is integrated', async () => {
-  const branch = makeStrandedBranch(repoCwd, 'alpha');
-  const jobs = [{ slug: 'alpha', status: 'completed' }];
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
-  const r = results.find((x) => x.branch === branch);
-  expect(r.action).toBe('integrated');
-  expect(fs.existsSync(path.join(repoCwd, 'alpha.txt'))).toBe(true);
-});
-
-test('stranded branch with NO job row at all is also integrated', async () => {
-  const branch = makeStrandedBranch(repoCwd, 'ghost');
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs: [], attemptedBranches: new Set() });
-  const r = results.find((x) => x.branch === branch);
-  expect(r.action).toBe('integrated');
-});
-
-test('branch already merged into HEAD is a silent no-op', async () => {
-  const branch = makeStrandedBranch(repoCwd, 'bravo');
-  git(['merge', '--no-ff', '--no-edit', branch], repoCwd);
-  const jobs = [{ slug: 'bravo', status: 'completed' }];
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
-  const r = results.find((x) => x.branch === branch);
-  expect(r.action).toBe('no-op-merged');
-});
-
-test('branch checked out in a live worktree is skipped entirely', async () => {
-  const branch = makeStrandedBranch(repoCwd, 'charlie');
-  worktreeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-live-'));
-  git(['worktree', 'add', '-q', worktreeDir, branch], repoCwd);
-  const jobs = [{ slug: 'charlie', status: 'running' }];
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
-  const r = results.find((x) => x.branch === branch);
-  expect(r.action).toBe('skip-checked-out');
-});
-
-test('branch owned by a NON-terminal job row is left alone, never integrated', async () => {
-  const branch = makeStrandedBranch(repoCwd, 'delta');
-  const jobs = [{ slug: 'delta', status: 'needs_review' }];
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
-  const r = results.find((x) => x.branch === branch);
-  expect(r.action).toBe('skip-active-row');
-  expect(fs.existsSync(path.join(repoCwd, 'delta.txt'))).toBe(false);
-});
-
-test('conflicting branch is flagged, never forced, and the branch is never deleted', async () => {
-  // Same path committed differently on both HEAD and the branch → real conflict.
-  fs.writeFileSync(path.join(repoCwd, 'shared.txt'), 'main tree version\n', 'utf8');
-  git(['add', '-A'], repoCwd);
-  git(['commit', '-q', '-m', 'main tree edits shared.txt'], repoCwd);
-
-  const branch = 'sm-job/echo';
-  git(['branch', branch, 'HEAD~1'], repoCwd);
-  const tmpCheckout = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-conflict-'));
-  git(['worktree', 'add', '-q', tmpCheckout, branch], repoCwd);
-  fs.writeFileSync(path.join(tmpCheckout, 'shared.txt'), 'branch version — conflicts\n', 'utf8');
-  git(['add', '-A'], tmpCheckout);
-  git(['commit', '-q', '-m', 'job echo edits shared.txt'], tmpCheckout);
-  git(['worktree', 'remove', '--force', tmpCheckout], repoCwd);
-
-  const jobs = [{ slug: 'echo', status: 'failed' }];
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
-  const r = results.find((x) => x.branch === branch);
-  expect(r.action).toBe('conflict');
-  expect(r.integration.ok).toBe(false);
-  // Branch itself must survive a conflict, untouched.
-  const stillExists = git(['rev-parse', '--verify', branch], repoCwd).trim();
-  expect(stillExists.length).toBe(40);
-});
-
-test('a branch is retried at most once per process lifetime via the shared attempted set', async () => {
-  fs.writeFileSync(path.join(repoCwd, 'shared2.txt'), 'main\n', 'utf8');
-  git(['add', '-A'], repoCwd);
-  git(['commit', '-q', '-m', 'main edits shared2'], repoCwd);
-  const branch = 'sm-job/foxtrot';
-  git(['branch', branch, 'HEAD~1'], repoCwd);
-  const tmpCheckout = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-retry-'));
-  git(['worktree', 'add', '-q', tmpCheckout, branch], repoCwd);
-  fs.writeFileSync(path.join(tmpCheckout, 'shared2.txt'), 'branch — conflicts\n', 'utf8');
-  git(['add', '-A'], tmpCheckout);
-  git(['commit', '-q', '-m', 'job foxtrot edits shared2'], tmpCheckout);
-  git(['worktree', 'remove', '--force', tmpCheckout], repoCwd);
-
-  const jobs = [{ slug: 'foxtrot', status: 'failed' }];
-  const attemptedBranches = new Set();
-  const first = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches });
-  expect(first.results.find((x) => x.branch === branch).action).toBe('conflict');
-  const second = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches });
-  expect(second.results.find((x) => x.branch === branch).action).toBe('skip-already-attempted');
-});
-
-test('SM_BRANCH_SWEEP_DISABLE=1 restores today\'s behaviour exactly — no scan, no integration', async () => {
-  makeStrandedBranch(repoCwd, 'golf');
-  process.env.SM_BRANCH_SWEEP_DISABLE = '1';
-  const jobs = [{ slug: 'golf', status: 'completed' }];
-  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
-  expect(results).toEqual([]);
-  expect(fs.existsSync(path.join(repoCwd, 'golf.txt'))).toBe(false);
-});

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

@@ -1,121 +0,0 @@
-/**
- * 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;
-  }
-});