claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/chat-queue.test.cjs

@@ -1,97 +0,0 @@
-/**
- * chat-queue.test.cjs — unit tests for the chatRunner serial run queue (v0.34).
- * Asserts the "up to two loops at a time" guarantee: SILENT (automated probe)
- * runs execute up to the concurrency cap in FIFO order, and a queued
- * (not-yet-started) silent run can be cancelled without running. PRD 493:
- * this cap/FIFO governs silent runs only — manual runs bypass it entirely
- * (see chatRunner.spec.ts's "manual runs are uncapped" tests).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-queue.test.cjs
- */
-
-'use strict';
-
-// Force the default cap (2) regardless of the developer's shell env.
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const cr = require('../chatRunner.cjs');
-
-const tick = () => new Promise((r) => setImmediate(r));
-const job = (id) => ({ tabId: id, sessionId: id, prompt: 'x', cwd: '/', resume: true, silent: true });
-
-test('runs execute up to the concurrency cap in FIFO order', async () => {
-  const order = [];
-  let active = 0;
-  let maxActive = 0;
-  // Stub the spawn: each run resolves on the next tick, so the queue must
-  // advance via the pump's finally hook for C to ever run.
-  cr.__setExecutor((j) => {
-    active += 1;
-    maxActive = Math.max(maxActive, active);
-    order.push(j.tabId);
-    return new Promise((res) => setImmediate(() => { active -= 1; res(); }));
-  });
-
-  cr.run(job('A'));
-  cr.run(job('B'));
-  cr.run(job('C'));
-
-  // Drain the queue (each run takes one tick; allow generous headroom).
-  for (let i = 0; i < 12 && order.length < 3; i++) await tick();
-  await tick();
-
-  assert.equal(maxActive, 2, 'up to two runs active at once under the default cap');
-  assert.deepEqual(order, ['A', 'B', 'C'], 'runs execute in FIFO order');
-
-  cr.__setExecutor(null); // restore real executor
-});
-
-test('cancelling a queued run drops it without executing', async () => {
-  const order = [];
-  cr.__setExecutor((j) => {
-    order.push(j.tabId);
-    return new Promise((res) => setImmediate(res));
-  });
-
-  // X and Y each take one of the two lanes; Z queues behind them. Cancel Z
-  // before a lane frees.
-  cr.run(job('X'));
-  cr.run(job('Y'));
-  cr.run(job('Z'));
-  cr.cancel('Z'); // Z is still in the waiting list — drop it
-
-  for (let i = 0; i < 8; i++) await tick();
-
-  assert.deepEqual(order, ['X', 'Y'], 'only X and Y ran; Z was cancelled while queued');
-
-  cr.__setExecutor(null);
-});
-
-test('a queued silent run never broadcasts chat:run:queued (silent runs stay invisible to the renderer)', async () => {
-  const sent = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
-  });
-  cr.__setExecutor((j) => new Promise((res) => setImmediate(res)));
-
-  // P and Q take the two lanes under the default cap; R queues behind them —
-  // this is the only path that ever populates chatRunner's `waiting` list,
-  // and every job on it is silent (manual runs bypass the queue entirely).
-  cr.run(job('P'));
-  cr.run(job('Q'));
-  cr.run(job('R'));
-
-  for (let i = 0; i < 8; i++) await tick();
-
-  assert.equal(
-    sent.filter((s) => s.channel === 'chat:run:queued').length,
-    0,
-    'no chat:run:queued broadcast for a silent (automated probe) run',
-  );
-
-  cr.__setExecutor(null);
-  cr.attachWindow(null);
-});

package/src/main/__tests__/chat-stop-signal.test.cjs

@@ -1,89 +0,0 @@
-/**
- * chat-stop-signal.test.cjs — unit tests for chatRunner.parseStopSignal, the
- * single source of truth for the terminal-chat stop-signal protocol (PRD 318).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-stop-signal.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { parseStopSignal, STOP_SENTINEL } = require('../chatRunner.cjs');
-
-test('sentinel present with valid JSON → questions array', () => {
-  const text =
-    'I did some work but need to know which target.\n' +
-    `${STOP_SENTINEL}\n` +
-    '{"questions":["Which environment?","Overwrite existing config?"]}';
-  const out = parseStopSignal(text);
-  assert.deepEqual(out, {
-    questions: ['Which environment?', 'Overwrite existing config?'],
-  });
-});
-
-test('sentinel absent → null (run is complete)', () => {
-  const text = 'All done. I created the file and the tests pass.';
-  assert.equal(parseStopSignal(text), null);
-});
-
-test('sentinel present but malformed JSON → null (treated as complete, no crash)', () => {
-  const text = `Here is a summary.\n${STOP_SENTINEL}\n{questions: [oops not json}`;
-  assert.equal(parseStopSignal(text), null);
-});
-
-test('sentinel present but JSON lacks questions array → null', () => {
-  const text = `${STOP_SENTINEL}\n{"foo":"bar"}`;
-  assert.equal(parseStopSignal(text), null);
-});
-
-test('non-string input → null (no crash)', () => {
-  assert.equal(parseStopSignal(undefined), null);
-  assert.equal(parseStopSignal(null), null);
-  assert.equal(parseStopSignal(42), null);
-});
-
-test('only the LAST sentinel occurrence is parsed', () => {
-  const text =
-    `${STOP_SENTINEL}\n{"questions":["stale earlier block"]}\n` +
-    'then the agent kept working...\n' +
-    `${STOP_SENTINEL}\n{"questions":["the real question"]}`;
-  assert.deepEqual(parseStopSignal(text), { questions: ['the real question'] });
-});
-
-test('blank lines between sentinel and JSON → questions array', () => {
-  const text = `${STOP_SENTINEL}\n\n\n{"questions":["Which environment?"]}`;
-  assert.deepEqual(parseStopSignal(text), { questions: ['Which environment?'] });
-});
-
-test('JSON wrapped in a ```json code fence → questions array', () => {
-  const text =
-    `${STOP_SENTINEL}\n` +
-    '```json\n' +
-    '{"questions":["Overwrite existing config?"]}\n' +
-    '```';
-  assert.deepEqual(parseStopSignal(text), { questions: ['Overwrite existing config?'] });
-});
-
-test('pretty-printed multi-line JSON → questions array', () => {
-  const text =
-    `${STOP_SENTINEL}\n` +
-    '{\n' +
-    '  "questions": [\n' +
-    '    "Which environment?",\n' +
-    '    "Overwrite existing config?"\n' +
-    '  ]\n' +
-    '}';
-  assert.deepEqual(parseStopSignal(text), {
-    questions: ['Which environment?', 'Overwrite existing config?'],
-  });
-});
-
-test('trailing prose after the closing brace → questions array', () => {
-  const text =
-    `${STOP_SENTINEL}\n` +
-    '{"questions":["Which environment?"]}\n' +
-    '\n' +
-    'Let me know and I will continue.';
-  assert.deepEqual(parseStopSignal(text), { questions: ['Which environment?'] });
-});

package/src/main/__tests__/chatRunner-epic-worktree-execcwd.test.cjs

@@ -1,125 +0,0 @@
-/**
- * chatRunner-epic-worktree-execcwd.test.cjs — PRD 1033, LOAD-BEARING
- * acceptance criterion: an Epic-backed headless `claude -p` run must spawn
- * with its `cwd` spawn option pointed at the Epic's isolated worktree dir
- * when one is recorded, while `session-manager-operations/` for that Epic's
- * project — the ops root — is never touched under the worktree dir. Mirrors
- * scheduler-worktree-exec-cwd.test.cjs's stub-`claude`-binary pattern
- * (SM_CLAUDE_BIN), which chatRunner.cjs's resolveClaudeBin also honors.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/chatRunner-epic-worktree-execcwd.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 cr;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-execcwd-home-'));
-  process.env.HOME = tmpHome;
-  cr = require('../chatRunner.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  cr.__resetQueueForTests();
-  cr.attachWindow(null);
-});
-
-// Writes a stub `claude` binary that records ITS OWN process.cwd() to a
-// marker file (proving where it actually ran), then emits a minimal
-// stream-json success result and exits 0 — same pattern as
-// scheduler-worktree-exec-cwd.test.cjs's writeClaudeStub.
-function writeClaudeStub() {
-  const stubPath = path.join(os.tmpdir(), `sm-chatrunner-claude-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'ran-here.marker'), 'yes', 'utf8');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
-}
-
-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: {} }));
-}
-
-async function waitForFile(filePath, timeoutMs = 5000) {
-  const start = Date.now();
-  while (!fs.existsSync(filePath)) {
-    if (Date.now() - start > timeoutMs) throw new Error(`timed out waiting for ${filePath}`);
-    await new Promise((r) => setTimeout(r, 25));
-  }
-}
-
-test('executeRun spawns the claude child in the Epic worktree dir, while the project ops-root is never touched under it', async () => {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-main-'));
-  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-worktree-'));
-  const sessionId = `epic-sess-${process.pid}`;
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-1', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  try {
-    cr.run({ tabId: 'tab-1', sessionId, prompt: 'hello', cwd: mainCwd, resume: false });
-    await waitForFile(path.join(worktreeCwd, 'ran-here.marker'));
-
-    // 1. The child process really ran with cwd = the Epic's worktree dir.
-    expect(fs.existsSync(path.join(worktreeCwd, 'ran-here.marker'))).toBe(true);
-    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(false);
-
-    // 2. CRITICAL invariant: session-manager-operations/ for this Epic's
-    // project must never be touched under the worktree dir — only the real
-    // project cwd, which still holds exactly the active-index.json this
-    // test wrote.
-    expect(fs.existsSync(path.join(worktreeCwd, 'session-manager-operations'))).toBe(false);
-    const index = JSON.parse(
-      fs.readFileSync(path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'), 'utf8'),
-    );
-    expect(index.sessions['epic-1'].claudeSessionId).toBe(sessionId);
-  } finally {
-    fs.rmSync(mainCwd, { recursive: true, force: true });
-    fs.rmSync(worktreeCwd, { recursive: true, force: true });
-  }
-});
-
-test('executeRun falls back to cwd unchanged when the Epic has no worktree recorded (unchanged behaviour)', async () => {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-plain-'));
-  const sessionId = `plain-sess-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  try {
-    cr.run({ tabId: 'tab-2', sessionId, prompt: 'hello', cwd: mainCwd, resume: false });
-    await waitForFile(path.join(mainCwd, 'ran-here.marker'));
-    expect(fs.existsSync(path.join(mainCwd, 'ran-here.marker'))).toBe(true);
-  } finally {
-    fs.rmSync(mainCwd, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/chatRunner-session-flag-retry.test.cjs

@@ -1,252 +0,0 @@
-/**
- * chatRunner-session-flag-retry.test.cjs — main is authoritative about
- * --session-id vs --resume, and a CLI flag rejection is retried exactly once
- * with the other flag without losing the turn.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chatRunner-session-flag-retry.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 cr;
-let sent;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chatrunner-flagretry-home-'));
-  process.env.HOME = tmpHome;
-  cr = require('../chatRunner.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  cr.__resetQueueForTests();
-  cr.attachWindow(null);
-});
-
-function attachRecorder() {
-  sent = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
-  });
-}
-
-// Stub claude: logs its argv (one JSON line per spawn) to logFile. Invocation 1
-// fails with `firstStderr` (optionally after emitting assistant text); later
-// invocations succeed.
-function writeStub(logFile, { firstStderr, textFirst, alwaysFail }) {
-  const stubPath = path.join(os.tmpdir(), `sm-flagretry-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
-    const fs = require('fs');
-    const log = ${JSON.stringify(logFile)};
-    fs.appendFileSync(log, JSON.stringify(process.argv.slice(2)) + '\\n');
-    const n = fs.readFileSync(log, 'utf8').trim().split('\\n').length;
-    if (n === 1 || ${alwaysFail ? 'true' : 'false'}) {
-      ${textFirst ? "process.stdout.write(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'partial' }] } }) + '\\n');" : ''}
-      process.stderr.write(${JSON.stringify(firstStderr)});
-      process.exit(1);
-    }
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
-}
-
-async function waitFor(pred, timeoutMs = 8000) {
-  const start = Date.now();
-  while (!pred()) {
-    if (Date.now() - start > timeoutMs) throw new Error('timed out');
-    await new Promise((r) => setTimeout(r, 25));
-  }
-}
-
-const TERMINAL = ['chat:run:complete', 'chat:run:needs-input', 'chat:run:error'];
-let curTab;
-const terminals = () => sent.filter((e) => TERMINAL.includes(e.channel) && e.payload.tabId === curTab);
-const spawns = (logFile) => fs.readFileSync(logFile, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
-
-test('in-use error on --session-id retries once with --resume; one terminal event; lane freed', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: `Error: Session ID ${sessionId} is already in use.\n` });
-  try {
-    curTab = 'tab-a';
-    cr.run({ tabId: 'tab-a', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    await new Promise((r) => setTimeout(r, 100));
-
-    const argvs = spawns(logFile);
-    expect(argvs).toHaveLength(2);
-    expect(argvs[0]).toContain('--session-id');
-    expect(argvs[1]).toContain('--resume');
-    expect(argvs[1]).not.toContain('--session-id');
-    expect(argvs[1][argvs[1].indexOf('--model') + 1]).toBe(argvs[0][argvs[0].indexOf('--model') + 1]);
-    expect(argvs[1][1]).toBe(argvs[0][1]);
-
-    expect(terminals()).toHaveLength(1);
-    expect(terminals()[0].channel).toBe('chat:run:complete');
-    expect(sent.some((e) => e.channel === 'chat:run:notice')).toBe(true);
-
-    // Lane freed: the same tab accepts a new run immediately (not queued).
-    const again = cr.run({ tabId: 'tab-a', sessionId, prompt: 'again', cwd, resume: true });
-    expect(again.queued).toBe(false);
-    await cr.cancel('tab-a');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('no retry when the failed attempt already streamed assistant text', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess2-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, {
-    firstStderr: `Error: Session ID ${sessionId} is already in use.\n`,
-    textFirst: true,
-  });
-  try {
-    curTab = 'tab-b';
-    cr.run({ tabId: 'tab-b', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    await new Promise((r) => setTimeout(r, 100));
-
-    expect(spawns(logFile)).toHaveLength(1);
-    expect(terminals()).toHaveLength(1);
-    expect(terminals()[0].channel).toBe('chat:run:error');
-    expect(terminals()[0].payload.code).toBe('session_flag_exhausted');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('"No conversation found" on --resume retries once with --session-id (main overrides a wrong renderer flag only via transcript)', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess3-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: `No conversation found with session ID: ${sessionId}\n` });
-  try {
-    // No transcript exists anywhere → main computes resume=false even though
-    // the renderer said true, so the first attempt is --session-id and the
-    // stub's failure is the wrong-direction message: no retry, error surfaces.
-    curTab = 'tab-c';
-    cr.run({ tabId: 'tab-c', sessionId, prompt: 'hello', cwd, resume: true });
-    await waitFor(() => terminals().length > 0);
-    const argvs = spawns(logFile);
-    expect(argvs).toHaveLength(1);
-    expect(argvs[0]).toContain('--session-id');
-    expect(terminals()[0].channel).toBe('chat:run:error');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('spent swap retry (both flags rejected) emits actionable session_flag_exhausted error', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess4-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, {
-    firstStderr: `Error: Session ID ${sessionId} is already in use.\n`,
-    alwaysFail: true,
-  });
-  try {
-    curTab = 'tab-d';
-    cr.run({ tabId: 'tab-d', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    await new Promise((r) => setTimeout(r, 100));
-
-    expect(spawns(logFile)).toHaveLength(2);
-    expect(terminals()).toHaveLength(1);
-    const { channel, payload } = terminals()[0];
-    expect(channel).toBe('chat:run:error');
-    expect(payload.code).toBe('session_flag_exhausted');
-    expect(payload.message).toContain(cwd);
-    expect(payload.message).toContain(`${sessionId}.jsonl`);
-    expect(payload.message).toContain('--resume');
-    expect(payload.message).toMatch(/App version: /);
-    expect(payload.message).toMatch(/update the app first/);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('non-zero exit with unrelated stderr keeps the generic fallback message', async () => {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flagretry-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `flag-sess5-${process.pid}`;
-  process.env.SM_CLAUDE_BIN = writeStub(logFile, { firstStderr: 'boom: something else broke\n' });
-  try {
-    curTab = 'tab-e';
-    cr.run({ tabId: 'tab-e', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length > 0);
-    const { channel, payload } = terminals()[0];
-    expect(channel).toBe('chat:run:error');
-    expect(payload.code).toBeUndefined();
-    expect(payload.message).toMatch(/^process exited without a result event/);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-// ---------- persona effort → --effort (agentEffortResolve.cjs) ----------
-
-async function chatArgvForPersona(effortLine) {
-  attachRecorder();
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-effort-cwd-'));
-  const logFile = path.join(cwd, 'argv.log');
-  const sessionId = `effort-sess-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'agents'), { recursive: true });
-  fs.writeFileSync(
-    path.join(tmpHome, '.claude', 'agents', 'effort-persona.md'),
-    ['---', 'name: effort-persona', 'model: opus', ...(effortLine ? [effortLine] : []), '---', 'body'].join('\n'),
-  );
-  const opsDir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(opsDir, { recursive: true });
-  fs.writeFileSync(path.join(opsDir, 'active-index.json'), JSON.stringify({
-    sessions: { e1: { id: 'e1', claudeSessionId: sessionId, agentType: 'effort-persona' } }, events: {},
-  }));
-  // First call succeeds outright: firstStderr unused because alwaysFail/n===1 → use a passing stub.
-  const stubPath = path.join(os.tmpdir(), `sm-effort-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  fs.writeFileSync(stubPath, `#!${process.execPath}\nrequire('fs').appendFileSync(${JSON.stringify(logFile)}, JSON.stringify(process.argv.slice(2)) + '\\n');\nprocess.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');\n`, { mode: 0o755 });
-  process.env.SM_CLAUDE_BIN = stubPath;
-  try {
-    curTab = 'tab-effort';
-    cr.run({ tabId: 'tab-effort', sessionId, prompt: 'hello', cwd, resume: false });
-    await waitFor(() => terminals().length >= 1 && fs.existsSync(logFile));
-    return spawns(logFile)[0];
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-    fs.rmSync(stubPath, { force: true });
-  }
-}
-
-test('chat spawn: persona effort adds --effort <level> beside --model and --session-id', async () => {
-  const argv = await chatArgvForPersona('effort: xhigh');
-  expect(argv[argv.indexOf('--effort') + 1]).toBe('xhigh');
-  expect(argv[argv.indexOf('--model') + 1]).toBe('opus');
-  expect(argv).toContain('--session-id');
-});
-
-test('chat spawn: effort inherit / absent adds no --effort token', async () => {
-  expect(await chatArgvForPersona('effort: inherit')).not.toContain('--effort');
-  expect(await chatArgvForPersona(null)).not.toContain('--effort');
-});

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

@@ -1,101 +0,0 @@
-/**
- * classifyPromptTicket.test.cjs — unit tests for the PromptTicket
- * inline-vs-develop classifier (PRD 749).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/classifyPromptTicket.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach } from 'vitest';
-const { EventEmitter } = require('node:events');
-const {
-  classifyPromptTicket,
-  parseVerdict,
-  __setSpawnForTest,
-} = require('../lib/classifyPromptTicket.cjs');
-
-beforeEach(() => {
-  __setSpawnForTest(null); // restore real spawn between tests
-});
-
-test('parseVerdict returns "develop" only when the raw text contains the word develop', () => {
-  expect(parseVerdict('develop')).toBe('develop');
-  expect(parseVerdict('  Develop  ')).toBe('develop');
-  expect(parseVerdict('inline')).toBe('inline');
-  expect(parseVerdict('')).toBe('inline');
-  expect(parseVerdict(undefined)).toBe('inline');
-});
-
-function fakeChild() {
-  const child = new EventEmitter();
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  child.kill = () => {};
-  return child;
-}
-
-test('classifyPromptTicket resolves "develop" for a complex sample prompt (stubbed spawn)', async () => {
-  __setSpawnForTest(() => {
-    const child = fakeChild();
-    setTimeout(() => {
-      child.stdout.emit('data', Buffer.from('develop'));
-      child.emit('close', 0);
-    }, 0);
-    return child;
-  });
-
-  const verdict = await classifyPromptTicket('Build a full multi-tab prompt-queue feature with PRD decomposition');
-  expect(verdict).toBe('develop');
-});
-
-test('classifyPromptTicket resolves "inline" for a quick sample prompt (stubbed spawn)', async () => {
-  __setSpawnForTest(() => {
-    const child = fakeChild();
-    setTimeout(() => {
-      child.stdout.emit('data', Buffer.from('inline'));
-      child.emit('close', 0);
-    }, 0);
-    return child;
-  });
-
-  const verdict = await classifyPromptTicket('what time is it');
-  expect(verdict).toBe('inline');
-});
-
-test('classifyPromptTicket fails safe to "inline" when the child process errors', async () => {
-  __setSpawnForTest(() => {
-    const child = fakeChild();
-    setTimeout(() => child.emit('error', new Error('spawn failed')), 0);
-    return child;
-  });
-
-  const verdict = await classifyPromptTicket('anything');
-  expect(verdict).toBe('inline');
-});
-
-test('classifyPromptTicket spawns with a pinned model, argv array (no shell string), and closed stdin', async () => {
-  let capturedBin;
-  let capturedArgs;
-  let capturedOpts;
-  __setSpawnForTest((bin, args, opts) => {
-    capturedBin = bin;
-    capturedArgs = args;
-    capturedOpts = opts;
-    const child = fakeChild();
-    setTimeout(() => {
-      child.stdout.emit('data', Buffer.from('inline'));
-      child.emit('close', 0);
-    }, 0);
-    return child;
-  });
-
-  await classifyPromptTicket('hello');
-
-  expect(typeof capturedBin).toBe('string');
-  expect(Array.isArray(capturedArgs)).toBe(true);
-  expect(capturedArgs).toContain('--model');
-  expect(capturedArgs[capturedArgs.indexOf('--model') + 1]).toBe('sonnet');
-  expect(capturedOpts.stdio[0]).toBe('ignore');
-  expect(capturedOpts.shell).toBeFalsy();
-});