claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/promptSessionsCreateEpicHandler.test.cjs

@@ -1,159 +0,0 @@
-/**
- * promptSessionsCreateEpicHandler.test.cjs — unit tests for the
- * 'promptSessions:create-epic' IPC handler (lib/promptSessionsCreateEpic.cjs),
- * PRD 953: an additive-only IPC channel letting the renderer mint an Epic
- * through main's own ensureEpic() instead of hand-constructing the
- * PromptSession record itself. Nothing in the app calls this yet.
- *
- * Exercises the handler the same way index.cjs wires it — schema validation
- * (ipcSchemas.cjs's `validated` wrapper) in front of the business logic —
- * without touching Electron's `ipcMain`, mirroring activeIndexMerge.test.cjs's
- * pattern of testing the underlying function directly.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/promptSessionsCreateEpicHandler.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 { schemas, validated } = require('../ipcSchemas.cjs');
-const { createEpicViaIpc } = require('../lib/promptSessionsCreateEpic.cjs');
-const { readActiveIndex } = require('../lib/epicMint.cjs');
-const { PromptSessionSchema } = require('../lib/promptSessionSchema.cjs');
-const config = require('../config.cjs');
-
-const handler = validated(schemas.promptSessionsCreateEpic, ({ cwd, goalText, tag, agentType, source }) =>
-  createEpicViaIpc(cwd, { goalText, tag, agentType, source }));
-
-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-promptsessions-create-epic-'));
-  config.addAllowedRoot(cwd);
-  tmpDirs.push(cwd);
-  // Project-overlay fixture so the 'architect' agentType used below resolves
-  // via ensureEpic's write-time persona-existence check without depending on
-  // the host's ~/.claude/agents/ (epicMint.cjs).
-  const agentsDir = path.join(cwd, '.claude', 'agents');
-  fs.mkdirSync(agentsDir, { recursive: true });
-  fs.writeFileSync(path.join(agentsDir, 'architect.md'), '---\nname: architect\n---\nFixture persona for tests.\n');
-  return cwd;
-}
-
-test('a valid request mints a new proposed Epic and returns a schema-valid session read back from disk', async () => {
-  const cwd = await mkCwd();
-  const result = await handler(null, {
-    cwd,
-    goalText: 'Ship the widget',
-    tag: 'feature',
-    agentType: 'architect',
-    source: { producer: 'scheduler-dispatch' },
-  });
-
-  expect(result.epicId).toBeTruthy();
-  expect(result.session.id).toBe(result.epicId);
-  expect(result.session.status).toBe('proposed');
-  expect(result.session.goalText).toBe('Ship the widget');
-  expect(result.session.tag).toBe('feature');
-  expect(result.session.agentType).toBe('architect');
-  expect(result.session.source).toEqual({ producer: 'scheduler-dispatch' });
-
-  // Response is the just-written record read back from disk, not a second
-  // independently re-derived copy.
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[result.epicId]).toEqual(result.session);
-
-  const parsed = PromptSessionSchema.safeParse(result.session);
-  expect(parsed.success).toBe(true);
-});
-
-test('a request with no tag/agentType/source still mints and validates cleanly', async () => {
-  const cwd = await mkCwd();
-  const result = await handler(null, { cwd, goalText: 'Minimal request' });
-
-  expect(result.session.goalText).toBe('Minimal request');
-  expect(PromptSessionSchema.safeParse(result.session).success).toBe(true);
-});
-
-// ipcSchemas.cjs's `validated` wrapper calls schema.parse synchronously
-// before invoking the handler — a ZodError throws synchronously from the
-// call itself (not a rejected promise), which is exactly the "rejected
-// before ensureEpic ever runs" guarantee this test asserts.
-test('a request missing cwd is rejected by ipcSchemas validation before ensureEpic ever runs', () => {
-  expect(() => handler(null, { goalText: 'No cwd here' })).toThrow();
-});
-
-test('a request missing goalText is rejected by ipcSchemas validation before ensureEpic ever runs', async () => {
-  const cwd = await mkCwd();
-  expect(() => handler(null, { cwd })).toThrow();
-
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(0);
-});
-
-test('an unknown tag value is rejected by ipcSchemas validation', () => {
-  expect(() => handler(null, { cwd: '/tmp/whatever', goalText: 'x', tag: 'not-a-real-tag' })).toThrow();
-});
-
-test('an unknown source.producer value is rejected by ipcSchemas validation', () => {
-  expect(() => handler(null, {
-    cwd: '/tmp/whatever',
-    goalText: 'x',
-    source: { producer: 'bogus-producer' },
-  })).toThrow();
-});
-
-// createEpicViaIpc's whole point is forceNewEpic: true — it must never join
-// an existing Epic via ensureEpic's goalText-similarity join branch, even
-// when called twice with the identical goalText for the same cwd.
-test('two requests with identical goalText for the same cwd mint two distinct Epics, never joining', async () => {
-  const cwd = await mkCwd();
-  const first = await handler(null, { cwd, goalText: 'Same title both times' });
-  const second = await handler(null, { cwd, goalText: 'Same title both times' });
-
-  expect(first.epicId).not.toBe(second.epicId);
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[first.epicId]).toBeDefined();
-  expect(index.sessions[second.epicId]).toBeDefined();
-});
-
-// The renderer can send an arbitrary `cwd` string over IPC — config.cjs's
-// validatePath (allowedRoots = home dir + every cwd a TAB has opened) is the
-// boundary every other renderer-facing path IPC already passes through
-// (config:read-json/write-json, lib/activeIndexMerge.cjs's own merge); this
-// handler must be gated by the same boundary rather than handing an
-// unvalidated path straight to epicMint.cjs's raw `fs` writes.
-test('a cwd outside every allowed root is rejected before anything is minted', async () => {
-  const unregistered = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-promptsessions-create-epic-unregistered-'));
-  tmpDirs.push(unregistered);
-
-  await expect(handler(null, { cwd: unregistered, goalText: 'Should never mint' })).rejects.toThrow(
-    /outside allowed boundaries/,
-  );
-
-  const index = readActiveIndex(unregistered);
-  expect(Object.keys(index.sessions)).toHaveLength(0);
-});
-
-test('model/effort overrides persist on the minted Epic; without them the record gains no such keys', async () => {
-  const cwd = await mkCwd();
-  const payload = schemas.promptSessionsCreateEpic.parse({ cwd, goalText: 'Override run', agentType: 'architect', model: 'claude-opus-5', effort: 'max' });
-  const withOverride = await createEpicViaIpc(cwd, payload);
-  expect(withOverride.session).toMatchObject({ model: 'claude-opus-5', effort: 'max' });
-  expect(readActiveIndex(cwd).sessions[withOverride.epicId]).toEqual(withOverride.session);
-  expect(PromptSessionSchema.safeParse(withOverride.session).success).toBe(true);
-
-  const plain = await createEpicViaIpc(cwd, schemas.promptSessionsCreateEpic.parse({ cwd, goalText: 'Plain run', agentType: 'architect' }));
-  expect('model' in plain.session).toBe(false);
-  expect('effort' in plain.session).toBe(false);
-});

package/src/main/__tests__/pty-epic-worktree-spawn-cwd.test.cjs

@@ -1,282 +0,0 @@
-/**
- * pty-epic-worktree-spawn-cwd.test.cjs — PRD 1033, LOAD-BEARING acceptance
- * criterion: an Epic-attached Terminal tab's PTY must actually launch its
- * shell in the Epic's isolated worktree dir when one is recorded, while
- * `cwd` itself (home-boundary validation, opsErrorLog attribution, the
- * returned/tracked cwd) stays the real project cwd — see epicSpawnCwd.cjs's
- * "ops-root hazard" header comment.
- *
- * Monkey-patches node-pty's own `spawn` export (a plain mutable property on
- * its shared, cached module object) to capture the real spawn options
- * without launching an actual shell — no existing test in this repo mocks a
- * module import, so this stays a direct property override rather than
- * introducing a new vi.mock pattern.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/pty-epic-worktree-spawn-cwd.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let manager;
-let nodePty;
-let originalSpawn;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-execcwd-home-'));
-  process.env.HOME = tmpHome;
-  ({ manager } = require('../pty.cjs'));
-  nodePty = require('node-pty');
-  originalSpawn = nodePty.spawn;
-});
-
-afterAll(() => {
-  nodePty.spawn = originalSpawn;
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  nodePty.spawn = originalSpawn;
-  manager.sessions.clear();
-  manager.buffers.clear();
-  manager.killed.clear();
-});
-
-function fakeProc() {
-  return {
-    pid: 4242,
-    exitCode: null,
-    onData: () => {},
-    onExit: () => {},
-    resize: () => {},
-    kill: () => {},
-    write: () => {},
-  };
-}
-
-function writeActiveIndexWithWorktree(cwd, { epicId, claudeSessionId, worktreeDir }) {
-  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(dir, { recursive: true });
-  const session = {
-    id: epicId,
-    cwd,
-    goalText: 'test epic',
-    claudeSessionId,
-    status: 'active',
-    createdAt: new Date(0).toISOString(),
-    completedAt: null,
-    worktree: { dir: worktreeDir, branch: `sm-epic/${epicId}`, baseCwd: cwd, status: 'active' },
-  };
-  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions: { [epicId]: session }, events: {} }));
-}
-
-test('spawn() launches the shell at the Epic worktree dir when one is recorded, while cwd itself stays the project cwd', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-main-'));
-  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-worktree-'));
-  const sessionId = 'epic-session-1';
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-1', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
-
-  let capturedOpts = null;
-  nodePty.spawn = (shell, args, opts) => {
-    capturedOpts = opts;
-    return fakeProc();
-  };
-
-  const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-
-  expect(capturedOpts).not.toBeNull();
-  // The ACTUAL spawn cwd is the worktree dir.
-  expect(capturedOpts.cwd).toBe(worktreeCwd);
-  // CRITICAL invariant: cwd used for the home-boundary check, tracked
-  // session bookkeeping, and the value handed back to the renderer is the
-  // real project cwd, never the worktree dir.
-  expect(result.cwd).toBe(mainCwd);
-  expect(manager.sessions.get(sessionId).cwd).toBe(mainCwd);
-
-  manager.kill(sessionId);
-});
-
-test('spawn() falls back to cwd unchanged when the tab has no matching Epic worktree', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-plain-'));
-  const tabId = 'plain-tab-1';
-
-  let capturedOpts = null;
-  nodePty.spawn = (shell, args, opts) => {
-    capturedOpts = opts;
-    return fakeProc();
-  };
-
-  manager.spawn({ tabId, cwd: mainCwd, cols: 80, rows: 24 });
-
-  expect(capturedOpts.cwd).toBe(mainCwd);
-  manager.kill(tabId);
-});
-
-test("spawn() falls back to cwd unchanged when the Epic's worktree field is absent from the index", () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-noworktree-'));
-  const sessionId = 'epic-session-2';
-  const dir = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(
-    path.join(dir, 'active-index.json'),
-    JSON.stringify({
-      sessions: {
-        'epic-2': {
-          id: 'epic-2',
-          cwd: mainCwd,
-          goalText: 'x',
-          claudeSessionId: sessionId,
-          status: 'active',
-          createdAt: new Date(0).toISOString(),
-          completedAt: null,
-        },
-      },
-      events: {},
-    }),
-  );
-
-  let capturedOpts = null;
-  nodePty.spawn = (shell, args, opts) => {
-    capturedOpts = opts;
-    return fakeProc();
-  };
-
-  manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-
-  expect(capturedOpts.cwd).toBe(mainCwd);
-  manager.kill(sessionId);
-});
-
-test('spawn() opens a merged-worktree Epic in the project cwd (dead worktree dir is never used)', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-merged-'));
-  const sessionId = 'epic-session-merged';
-  const deadDir = path.join(os.tmpdir(), 'sm-pty-dead-worktree-does-not-exist');
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-m', claudeSessionId: sessionId, worktreeDir: deadDir });
-  const idxPath = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
-  const idx = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
-  idx.sessions['epic-m'].worktree.status = 'merged';
-  fs.writeFileSync(idxPath, JSON.stringify(idx));
-
-  let capturedOpts = null;
-  nodePty.spawn = (shell, args, opts) => {
-    capturedOpts = opts;
-    return fakeProc();
-  };
-  manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-  expect(capturedOpts.cwd).toBe(mainCwd);
-  manager.kill(sessionId);
-});
-
-function setEpic(mainCwd, epicId, patch) {
-  const idxPath = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
-  const idx = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
-  const rec = idx.sessions[epicId];
-  if (patch.status) rec.status = patch.status;
-  if (patch.worktreeStatus) rec.worktree.status = patch.worktreeStatus;
-  fs.writeFileSync(idxPath, JSON.stringify(idx));
-}
-
-function captureSpawn() {
-  const out = { opts: null, count: 0 };
-  nodePty.spawn = (shell, args, opts) => {
-    out.opts = opts;
-    out.count += 1;
-    return fakeProc();
-  };
-  return out;
-}
-
-function fakeWindow(sent) {
-  return {
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, isCrashed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
-  };
-}
-
-test('spawn() opens a completed Epic (merged worktree) as a shell in the project cwd with an informational line', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-'));
-  const sessionId = 'epic-session-closed';
-  const deadDir = path.join(os.tmpdir(), 'sm-pty-closed-dead-worktree');
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-c', claudeSessionId: sessionId, worktreeDir: deadDir });
-  setEpic(mainCwd, 'epic-c', { status: 'completed', worktreeStatus: 'merged' });
-
-  const cap = captureSpawn();
-  const sent = [];
-  manager.window = fakeWindow(sent);
-  try {
-    const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-    expect(cap.count).toBe(1);
-    expect(cap.opts.cwd).toBe(mainCwd);
-    expect(result.pid).toBe(4242);
-    expect(result.error).toBeUndefined();
-    const info = sent.find((m) => m.channel === `pty:data:${sessionId}`);
-    expect(info.payload).toMatch(/Epic is completed/);
-    expect(info.payload).toContain(mainCwd);
-  } finally {
-    manager.window = null;
-    manager.kill(sessionId);
-  }
-});
-
-test('spawn() opens a completed Epic whose worktree dir still exists in that worktree dir', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-live-'));
-  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-closed-live-wt-'));
-  const sessionId = 'epic-session-closed-live';
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-cl', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
-  setEpic(mainCwd, 'epic-cl', { status: 'completed' });
-
-  const cap = captureSpawn();
-  manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-  expect(cap.count).toBe(1);
-  expect(cap.opts.cwd).toBe(worktreeCwd);
-  manager.kill(sessionId);
-  fs.rmSync(worktreeCwd, { recursive: true, force: true });
-});
-
-test('spawn() still refuses session_unreachable without any node-pty spawn', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-unreachable-'));
-  const sessionId = 'epic-session-unreachable';
-  const deadDir = path.join(os.tmpdir(), 'sm-pty-unreachable-dead-worktree');
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-u', claudeSessionId: sessionId, worktreeDir: deadDir });
-  setEpic(mainCwd, 'epic-u', { worktreeStatus: 'merged' });
-  // Transcript exists only under the dead worktree's encoded project dir.
-  const enc = deadDir.replace(/[^a-zA-Z0-9]/g, '-');
-  const tdir = path.join(tmpHome, '.claude', 'projects', enc);
-  fs.mkdirSync(tdir, { recursive: true });
-  fs.writeFileSync(path.join(tdir, `${sessionId}.jsonl`), '{"type":"user"}\n');
-
-  const cap = captureSpawn();
-  const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-  expect(cap.count).toBe(0);
-  expect(result.pid).toBeNull();
-  expect(result.error).toMatch(/cannot be resumed/);
-});
-
-test('planEpicSpawn with a REAL on-disk index: project-root caller resumes, vanished-worktree caller is refused spawn_cwd_missing', () => {
-  const { planEpicSpawn, __resetForTests } = require('../lib/epicSpawnPlan.cjs');
-  __resetForTests();
-  const projectRoot = fs.mkdtempSync(path.join(tmpHome, 'sm-plan-root-'));
-  const deadWt = path.join(os.tmpdir(), 'sm-plan-dead-worktree-xyz');
-  const sessionId = 'epic-session-root-probe';
-  writeActiveIndexWithWorktree(projectRoot, { epicId: 'epic-rp', claudeSessionId: sessionId, worktreeDir: deadWt });
-  const tdir = path.join(tmpHome, '.claude', 'projects', projectRoot.replace(/[^a-zA-Z0-9]/g, '-'));
-  fs.mkdirSync(tdir, { recursive: true });
-  fs.writeFileSync(path.join(tdir, `${sessionId}.jsonl`), '{"type":"user"}\n');
-  const deps = { homeDir: tmpHome, restoreWorktree: () => null };
-
-  expect(planEpicSpawn({ cwd: projectRoot, claudeSessionId: sessionId, deps }))
-    .toMatchObject({ ok: true, execCwd: projectRoot, useResume: true });
-  __resetForTests();
-  const refused = planEpicSpawn({ cwd: deadWt, claudeSessionId: sessionId, deps });
-  expect(refused).toMatchObject({ ok: false, code: 'spawn_cwd_missing' });
-  expect(refused.message).toContain(deadWt);
-  expect(refused.message).toMatch(/project cwd/);
-});

package/src/main/__tests__/pty-session-open-telemetry.test.cjs

@@ -1,96 +0,0 @@
-/**
- * pty-session-open-telemetry.test.cjs — proves the `session.open` counter tap
- * (telemetryCounters.trackSessionOpen(), wired at pty.cjs's spawn() call
- * site) actually fires on a real fresh PTY spawn, and documents/locks in the
- * deliberate choice that a reattach (same tabId already registered in this
- * process — a renderer HMR reload, or switching back to an Epic's Terminal
- * pane that's already running) does NOT fire it a second time, since it's
- * the same underlying session, not a new one (see pty.cjs's spawn() comment
- * above the reattach branch, and telemetry.md).
- *
- * Same monkey-patch-node-pty pattern as pty-epic-worktree-spawn-cwd.test.cjs
- * — no existing test in this repo mocks a module import.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/pty-session-open-telemetry.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let manager;
-let nodePty;
-let originalSpawn;
-let telemetryCounters;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-sessionopen-home-'));
-  process.env.HOME = tmpHome;
-  ({ manager } = require('../pty.cjs'));
-  nodePty = require('node-pty');
-  originalSpawn = nodePty.spawn;
-  telemetryCounters = require('../lib/telemetryCounters.cjs');
-});
-
-afterAll(() => {
-  nodePty.spawn = originalSpawn;
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  nodePty.spawn = originalSpawn;
-  manager.sessions.clear();
-  manager.buffers.clear();
-  manager.killed.clear();
-  vi.restoreAllMocks();
-});
-
-function fakeProc() {
-  return {
-    pid: 4242,
-    exitCode: null,
-    onData: () => {},
-    onExit: () => {},
-    resize: () => {},
-    kill: () => {},
-    write: () => {},
-  };
-}
-
-test('a fresh spawn() fires trackSessionOpen exactly once', () => {
-  const spy = vi.spyOn(telemetryCounters, 'trackSessionOpen').mockImplementation(() => {});
-  const cwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-fresh-'));
-  const tabId = 'fresh-tab-1';
-  nodePty.spawn = () => fakeProc();
-
-  manager.spawn({ tabId, cwd, cols: 80, rows: 24 });
-
-  expect(spy).toHaveBeenCalledTimes(1);
-  manager.kill(tabId);
-});
-
-test('a reattach to an already-registered tabId does NOT fire trackSessionOpen again', () => {
-  const spy = vi.spyOn(telemetryCounters, 'trackSessionOpen').mockImplementation(() => {});
-  const cwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-reattach-'));
-  const tabId = 'reattach-tab-1';
-  nodePty.spawn = () => fakeProc();
-
-  const first = manager.spawn({ tabId, cwd, cols: 80, rows: 24 });
-  expect(first.reattached).toBe(false);
-  expect(spy).toHaveBeenCalledTimes(1);
-
-  const second = manager.spawn({ tabId, cwd, cols: 80, rows: 24 });
-  expect(second.reattached).toBe(true);
-  // Still exactly one call — the reattach path returns before the counter
-  // tap, by design (same session, not a new one).
-  expect(spy).toHaveBeenCalledTimes(1);
-
-  manager.kill(tabId);
-});

package/src/main/__tests__/pty-write-result.test.cjs

@@ -1,46 +0,0 @@
-/**
- * pty-write-result.test.cjs — unit tests for PtyManager.write()'s return contract.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/pty-write-result.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { manager } = require('../pty.cjs');
-
-test('write to an existing session succeeds', () => {
-  const tabId = 'tab-existing';
-  const proc = { write: () => {} };
-  manager.sessions.set(tabId, { proc, cwd: '/tmp', created: 0 });
-  try {
-    const result = manager.write({ tabId, data: 'hello' });
-    expect(result).toEqual({ ok: true });
-  } finally {
-    manager.sessions.delete(tabId);
-  }
-});
-
-test('write to a nonexistent tabId returns no-pty', () => {
-  const result = manager.write({ tabId: 'tab-does-not-exist', data: 'hello' });
-  expect(result).toEqual({ ok: false, reason: 'no-pty' });
-});
-
-test('write where proc.write throws returns the error reason without throwing', () => {
-  const tabId = 'tab-throws';
-  const proc = {
-    write: () => {
-      throw new Error('EPIPE: write after end');
-    },
-  };
-  manager.sessions.set(tabId, { proc, cwd: '/tmp', created: 0 });
-  try {
-    let result;
-    expect(() => {
-      result = manager.write({ tabId, data: 'hello' });
-    }).not.toThrow();
-    expect(result).toEqual({ ok: false, reason: 'EPIPE: write after end' });
-  } finally {
-    manager.sessions.delete(tabId);
-  }
-});