claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,161 +0,0 @@
-/**
- * crossProjectFeedbackRoutes.test.cjs — the HTTP hop for the project-to-project
- * conduit (lib/crossProjectFeedback.cjs's registerAdminRoute).
- *
- * Why this is its own file. crossProjectFeedback.test.cjs drives
- * openFeedbackSession() directly, and the MCP tool definitions live in
- * scripts/scheduler-mcp-server.cjs — so the ROUTE REGISTRATION between them was
- * the one layer nothing exercised. That layer has a real, silent failure mode:
- * a route registered under a path the MCP client doesn't call (or not
- * registered at all) surfaces only as `{"ok":false,"error":"not found"}` from a
- * tool that otherwise looks perfectly wired. Confirmed live 2026-08-08 against
- * a running app whose process predated the route being added.
- *
- * These tests boot the real transport (localAdminHttp.cjs) on a throwaway port
- * and speak real HTTP to it, so the method+path pair is asserted end to end
- * rather than assumed.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/crossProjectFeedbackRoutes.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const http = require('node:http');
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const config = require('../config.cjs');
-const { createAdminHttp, TOKEN_PATH } = require('../lib/localAdminHttp.cjs');
-const crossProjectFeedback = require('../lib/crossProjectFeedback.cjs');
-const { readActiveIndex } = require('../lib/epicMint.cjs');
-
-// Never let start() overwrite the RUNNING app's admin-api.json — that orphans
-// scheduler-mcp-server.cjs until an app restart (the incident documented in
-// localAdminHttp.cjs's resolveTokenPath).
-const TEST_TOKEN_PATH = path.join(path.dirname(TOKEN_PATH), `admin-api.xproj-test-${process.pid}.json`);
-process.env.SM_ADMIN_TOKEN_PATH = TEST_TOKEN_PATH;
-
-let adminHttp;
-let port;
-let token;
-
-beforeAll(async () => {
-  adminHttp = createAdminHttp();
-  crossProjectFeedback.registerAdminRoute(adminHttp);
-  ({ port, token } = await adminHttp.start());
-});
-
-afterAll(async () => {
-  if (adminHttp) await adminHttp.stop();
-  fs.rmSync(TEST_TOKEN_PATH, { force: true });
-});
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
-});
-
-async function mkProject({ managed = true } = {}) {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-xproj-route-'));
-  config.addAllowedRoot(cwd);
-  tmpDirs.push(cwd);
-  if (managed) fs.mkdirSync(path.join(cwd, 'session-manager-operations'), { recursive: true });
-  // Project-overlay fixture for the DEFAULT_FEEDBACK_AGENT ('architect') —
-  // ensureEpic's write-time persona-existence check (epicMint.cjs) now
-  // requires a real persona file to mint against; this keeps these tests
-  // hermetic instead of depending on the host's ~/.claude/agents/.
-  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 fs.realpathSync(cwd);
-}
-
-function request({ method = 'GET', path: reqPath, body, auth = true }) {
-  return new Promise((resolve, reject) => {
-    const headers = {};
-    if (auth) headers.Authorization = `Bearer ${token}`;
-    let payload;
-    if (body !== undefined) {
-      payload = typeof body === 'string' ? body : JSON.stringify(body);
-      headers['Content-Type'] = 'application/json';
-      headers['Content-Length'] = Buffer.byteLength(payload);
-    }
-    const req = http.request({ hostname: '127.0.0.1', port, method, path: reqPath, headers }, (res) => {
-      let data = '';
-      res.on('data', (c) => { data += c; });
-      res.on('end', () => {
-        let json = null;
-        try { json = JSON.parse(data); } catch { /* non-JSON body */ }
-        resolve({ status: res.statusCode, json, raw: data });
-      });
-    });
-    req.on('error', reject);
-    if (payload !== undefined) req.write(payload);
-    req.end();
-  });
-}
-
-// ---------------------------------------------------------------------------
-// The exact method+path pairs scripts/scheduler-mcp-server.cjs calls.
-// If either of these two tests fails, the MCP tool is dead in the water and
-// reports only "not found".
-// ---------------------------------------------------------------------------
-
-test('GET /admin/feedback/targets is registered and answers', async () => {
-  // Scanned against an EMPTY throwaway root, never the developer's real
-  // ~/.claude/projects/ — the transcripts tests create and delete folders
-  // there in their own afterEach, and scanning it made this test race their
-  // teardown (green alone, intermittently red under the full suite).
-  const emptyRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-xproj-scan-'));
-  tmpDirs.push(emptyRoot);
-  const res = await request({
-    method: 'GET',
-    path: `/admin/feedback/targets?projectsDir=${encodeURIComponent(emptyRoot)}`,
-  });
-  expect(res.status).toBe(200);
-  expect(res.json.ok).toBe(true);
-  expect(res.json.projects).toEqual([]);
-});
-
-test('POST /admin/feedback/open-session is registered and delivers', async () => {
-  const to = await mkProject();
-  const from = await mkProject();
-  const res = await request({
-    method: 'POST',
-    path: '/admin/feedback/open-session',
-    body: { toCwd: to, fromCwd: from, title: 'Route smoke', body: 'Delivered over real HTTP.' },
-  });
-  expect(res.status).toBe(200);
-  expect(res.json.ok).toBe(true);
-  expect(res.json.status).toBe('proposed');
-
-  // The write really landed in the receiving project, not just in the response.
-  const epic = readActiveIndex(to).sessions[res.json.epicId];
-  expect(epic.status).toBe('proposed');
-  expect(epic.source.producer).toBe('cross-project-feedback');
-});
-
-test('a refusal comes back as a 400 with the reason, not a 500 or a silent 200', async () => {
-  const p = await mkProject();
-  const res = await request({
-    method: 'POST',
-    path: '/admin/feedback/open-session',
-    body: { toCwd: p, fromCwd: p, title: 'Same project', body: 'Should be refused.' },
-  });
-  expect(res.status).toBe(400);
-  expect(res.json.ok).toBe(false);
-  expect(res.json.error).toMatch(/\/develop/);
-});
-
-test('a malformed JSON body is a 400, never an unhandled throw', async () => {
-  const res = await request({ method: 'POST', path: '/admin/feedback/open-session', body: '{not json' });
-  expect(res.status).toBe(400);
-  expect(res.json.error).toMatch(/invalid JSON body/);
-});
-
-test('both routes are behind the transport\'s bearer auth', async () => {
-  expect((await request({ method: 'GET', path: '/admin/feedback/targets', auth: false })).status).toBe(401);
-  expect((await request({ method: 'POST', path: '/admin/feedback/open-session', body: {}, auth: false })).status).toBe(401);
-});

package/src/main/__tests__/dep-orphan-archive-health.test.cjs

@@ -1,77 +0,0 @@
-/**
- * PRD 1286 — archiving a row must never orphan its dependents, and a fully
- * blocked queue must never read healthy.
- *
- * Option (b): the depends-gate (computeDepHistorySatisfaction) treats a dep
- * whose PRD file was archived — including the manual-archive layout
- * prds-archived/<ISO-ts>/<slug>.md — as satisfied. A dep with no row, no
- * history and no archived file still HOLDS.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/dep-orphan-archive-health.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1286-home-'));
-process.env.HOME = tmpHome;
-
-const scheduler = require('../scheduler.cjs');
-const { pickNextBatch } = require('../lib/schedulerBatch.cjs');
-const { evaluateUnresolvableDepHealth } = require('../health.cjs');
-
-function projectWithDependent(dep) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1286-proj-'));
-  const jobs = [{ slug: '902-next', status: 'pending', cwd, dependsOn: [dep] }];
-  return { cwd, jobs };
-}
-
-async function eligible(jobs) {
-  const satisfiedSlugsByCwd = await scheduler.computeDepHistorySatisfaction({ jobs });
-  const { batch: picked } = pickNextBatch(jobs, new Set(), 3, { satisfiedSlugsByCwd });
-  return { batch: picked.map((j) => j.slug ?? j.job?.slug ?? j), satisfiedSlugsByCwd };
-}
-
-test('a dep archived via the manual-archive layout (prds-archived/<ts>/) leaves its dependent eligible', async () => {
-  const { cwd, jobs } = projectWithDependent('fo-01-base'); // bare slug, as authored
-  const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'e1', 'prds-archived', '2026-09-18T01-00-00-000Z');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, '900-fo-01-base.md'), '# Goal\n');
-  const { batch } = await eligible(jobs);
-  expect(batch).toContain('902-next');
-});
-
-test('a dep that never ran (no row, history or archived file) keeps its dependent held', async () => {
-  const { jobs } = projectWithDependent('fo-01-base');
-  const { batch } = await eligible(jobs);
-  expect(batch).not.toContain('902-next');
-});
-
-test('health: every pending row held behind one unresolvable root is non-GREEN and names the root', async () => {
-  const { cwd } = projectWithDependent('fo-01-base');
-  const jobs = [
-    { slug: '902-a', status: 'pending', cwd, dependsOn: ['fo-01-base'] },
-    { slug: '903-b', status: 'pending', cwd, dependsOn: ['a'] }, // transitive, bare
-  ];
-  const satisfied = await scheduler.computeDepHistorySatisfaction({ jobs });
-  const res = evaluateUnresolvableDepHealth(jobs, satisfied);
-  expect(res.ok).toBe(false);
-  expect(res.projects[0].roots).toEqual(['fo-01-base']);
-  expect(res.message).toContain('fo-01-base');
-});
-
-test('health: a project with any dispatchable pending row, or a satisfied root, stays GREEN', async () => {
-  const { cwd } = projectWithDependent('x');
-  const mixed = [
-    { slug: '902-a', status: 'pending', cwd, dependsOn: ['fo-01-base'] },
-    { slug: '903-free', status: 'pending', cwd, dependsOn: [] },
-  ];
-  const satisfied = await scheduler.computeDepHistorySatisfaction({ jobs: mixed });
-  expect(evaluateUnresolvableDepHealth(mixed, satisfied).ok).toBe(true);
-  const satisfiedRoot = new Map([[cwd, new Set(['900-fo-01-base'])]]);
-  expect(evaluateUnresolvableDepHealth([mixed[0]], satisfiedRoot).ok).toBe(true);
-});

package/src/main/__tests__/develop-skill-failure-modes.test.cjs

@@ -1,70 +0,0 @@
-/**
- * develop-skill-failure-modes.test.cjs — drift guard for the two
- * scheduler_create_prd failure-mode branches in the /develop skill.
- *
- * PRD 1024-1030 incident (2026-08-08): social-signals-trader's session
- * hand-wrote 7 PRDs because scheduler_create_prd was ABSENT from its tool
- * list (the project's .mcp.json didn't register the server yet) — not
- * because the tool errored as unreachable. The old wording only named the
- * "tool errors ... unreachable" case, which an absent tool never matches,
- * so an agent in that situation had no documented path except hand-writing.
- * This test asserts the fix (two named failure modes, with the absent-tool
- * case explicitly forbidding hand-writing) is present and doesn't silently
- * regress back to the single-case wording.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/develop-skill-failure-modes.test.cjs
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-import { test, expect } from 'vitest';
-
-const SKILL_MD = path.resolve(
-  __dirname,
-  '..',
-  '..',
-  '..',
-  'plugins',
-  'session-manager-dev',
-  'skills',
-  'develop',
-  'SKILL.md'
-);
-
-function readSkill() {
-  return fs.readFileSync(SKILL_MD, 'utf8');
-}
-
-test('SKILL.md names both failure modes explicitly', () => {
-  const text = readSkill();
-  expect(text).toMatch(/tool PRESENT but ERRORS/i);
-  expect(text).toMatch(/tool ABSENT from your tool list/i);
-});
-
-test('the absent-tool branch explicitly forbids hand-writing and says STOP', () => {
-  const text = readSkill();
-  const absentIdx = text.search(/tool ABSENT from your tool list/i);
-  expect(absentIdx).toBeGreaterThan(-1);
-  const nearby = text.slice(absentIdx, absentIdx + 1200);
-  expect(nearby).toMatch(/STOP/);
-  expect(nearby).toMatch(/[Dd]o not write any PRD file/);
-  expect(nearby).toMatch(/misconfiguration/i);
-});
-
-test('the present-but-erroring branch is the only one pointed at the manual-write fallback', () => {
-  const text = readSkill();
-  expect(text).toMatch(/Fallback for case \(a\) only/);
-});
-
-test('the standalone preflight check appears before PRD composition begins', () => {
-  const text = readSkill();
-  expect(text).toMatch(/Preflight — confirm the tool is even in your tool list/);
-});
-
-test('a preflight-tool-registration fix is named for the human (user-scope claude mcp add)', () => {
-  const text = readSkill();
-  expect(text).toMatch(/claude mcp add session-manager-scheduler --scope\s*\n?\s*user/);
-});

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

@@ -1,244 +0,0 @@
-/**
- * docEdit.test.cjs — unit tests for docEdit.cjs's pure helpers (PRD 638).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/docEdit.test.cjs
- */
-
-'use strict';
-
-import { test, expect, describe, beforeEach, vi } from 'vitest';
-
-// docEdit.cjs requires chatRunner.cjs at module scope and calls `chatRunner.run(...)`
-// as a property access, so patching `run` on the already-required (cached) module
-// object — before docEdit.cjs's own require resolves to the same singleton — is
-// enough to intercept it, mirroring the exchanges.cjs patch pattern in chatRunner.spec.ts.
-const chatRunnerModule = require('../chatRunner.cjs');
-const runCalls = [];
-beforeEach(() => { runCalls.length = 0; });
-chatRunnerModule.run = (opts) => { runCalls.push(opts); };
-
-const { parseDocEdit, editPrompt, truncateDocumentText, MAX_DOC_CONTEXT, docEditViaSession, attachWindow } = require('../docEdit.cjs');
-const { duplicateNameFor } = require('../files.cjs');
-
-const broadcasts = [];
-attachWindow({
-  isDestroyed: () => false,
-  webContents: { isDestroyed: () => false, send: (channel, payload) => broadcasts.push({ channel, payload }) },
-});
-beforeEach(() => { broadcasts.length = 0; });
-
-describe('parseDocEdit', () => {
-  test('valid JSON', () => {
-    const result = parseDocEdit('{"after":"rewritten text"}');
-    expect(result).toEqual({ ok: true, after: 'rewritten text' });
-  });
-
-  test('JSON embedded in prose', () => {
-    const result = parseDocEdit('Sure, here you go:\n{"after":"rewritten text"}\nHope that helps!');
-    expect(result).toEqual({ ok: true, after: 'rewritten text' });
-  });
-
-  test('missing after', () => {
-    const result = parseDocEdit('{"other":"value"}');
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeTruthy();
-  });
-
-  test('empty after', () => {
-    const result = parseDocEdit('{"after":""}');
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeTruthy();
-  });
-
-  test('non-string after', () => {
-    const result = parseDocEdit('{"after":42}');
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeTruthy();
-  });
-
-  test('over-length after', () => {
-    const result = parseDocEdit(JSON.stringify({ after: 'x'.repeat(16001) }));
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeTruthy();
-  });
-
-  test('no JSON object in output at all', () => {
-    const result = parseDocEdit('not json at all, just prose garbage');
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeTruthy();
-  });
-
-  test('empty/null input', () => {
-    expect(parseDocEdit('').ok).toBe(false);
-    expect(parseDocEdit(null).ok).toBe(false);
-  });
-});
-
-describe('editPrompt', () => {
-  test('omits the document block when documentText is absent', () => {
-    const prompt = editPrompt('selected text', 'make it concise');
-    expect(prompt).not.toMatch(/<document_/);
-  });
-
-  test('includes a nonce-tagged document block when documentText is provided', () => {
-    const prompt = editPrompt('selected text', 'make it concise', 'the whole document');
-    expect(prompt).toMatch(/<document_[0-9a-f]+>/);
-    expect(prompt).toContain('the whole document');
-  });
-
-  test('truncates an oversized documentText before embedding it', () => {
-    const huge = 'x'.repeat(MAX_DOC_CONTEXT + 5000);
-    const prompt = editPrompt('selected text', 'make it concise', huge);
-    expect(prompt).toContain('[...document truncated for length...]');
-    expect(prompt.length).toBeLessThan(huge.length + 2000);
-  });
-});
-
-describe('truncateDocumentText', () => {
-  test('passes short text through unchanged', () => {
-    expect(truncateDocumentText('short')).toBe('short');
-  });
-
-  test('truncates to the documented head+tail scheme rather than dropping or erroring', () => {
-    const head = 'H'.repeat(40000);
-    const tail = 'T'.repeat(20000);
-    const middle = 'M'.repeat(10000);
-    const result = truncateDocumentText(head + middle + tail);
-    expect(result).toBe(`${head}\n\n[...document truncated for length...]\n\n${tail}`);
-    expect(result).not.toContain('M');
-  });
-});
-
-describe('docEditViaSession', () => {
-  test('builds its prompt via the shared editPrompt and calls chatRunner.run with resume+silent', () => {
-    docEditViaSession({
-      tabId: 'tab-1',
-      sessionId: 'chat-session-1',
-      cwd: '/home/user/project',
-      before: 'old text',
-      instruction: 'make it punchier',
-      documentText: 'the whole document',
-      requestId: 'req-1',
-    });
-
-    expect(runCalls).toHaveLength(1);
-    const call = runCalls[0];
-    expect(call.tabId).toBe('tab-1');
-    expect(call.sessionId).toBe('chat-session-1');
-    expect(call.cwd).toBe('/home/user/project');
-    expect(call.resume).toBe(true);
-    expect(call.silent).toBe(true);
-    expect(typeof call.onSilentResult).toBe('function');
-
-    // The prompt is the shared editPrompt's output (nonce-tagged, so compare
-    // structurally rather than byte-for-byte) prefixed with the anti-injection
-    // system framing — not a second, forked prompt builder.
-    expect(call.prompt).toContain('Rewrite the SELECTION below per the INSTRUCTION');
-    expect(call.prompt).toMatch(/<selection_[0-9a-f]+>\nold text\n<\/selection_[0-9a-f]+>/);
-    expect(call.prompt).toContain('deterministic document-rewrite assistant');
-  });
-
-  test('onSilentResult parses the reply and broadcasts docedit:session-result', () => {
-    docEditViaSession({
-      tabId: 'tab-2',
-      sessionId: 'chat-session-2',
-      cwd: '/home/user/project',
-      before: 'old text',
-      instruction: 'shorten it',
-      requestId: 'req-2',
-    });
-
-    const { onSilentResult } = runCalls[runCalls.length - 1];
-    onSilentResult('{"after":"new text"}');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0]).toEqual({
-      channel: 'docedit:session-result',
-      payload: { tabId: 'tab-2', requestId: 'req-2', ok: true, after: 'new text' },
-    });
-  });
-
-  test('onSilentResult reports a parse failure as ok:false', () => {
-    docEditViaSession({
-      tabId: 'tab-3',
-      sessionId: 'chat-session-3',
-      cwd: '/home/user/project',
-      before: 'old text',
-      instruction: 'shorten it',
-      requestId: 'req-3',
-    });
-
-    const { onSilentResult } = runCalls[runCalls.length - 1];
-    onSilentResult('not json at all');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0].payload.ok).toBe(false);
-    expect(broadcasts[0].payload.error).toBeTruthy();
-  });
-
-  test('splits off the stop-signal protocol and reports it as a clarification request', () => {
-    docEditViaSession({
-      tabId: 'tab-4',
-      sessionId: 'chat-session-4',
-      cwd: '/home/user/project',
-      before: 'old text',
-      instruction: 'shorten it',
-      requestId: 'req-4',
-    });
-
-    const { onSilentResult } = runCalls[runCalls.length - 1];
-    onSilentResult('<<<SM_NEEDS_INPUT>>>\n{"questions":["which section?"]}');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0].payload.ok).toBe(false);
-    expect(broadcasts[0].payload.error).toContain('which section?');
-  });
-
-  test('times out and broadcasts a failure if chatRunner never calls onSilentResult (error/timeout/cancel/collision on the silent lane)', () => {
-    vi.useFakeTimers();
-    try {
-      docEditViaSession({
-        tabId: 'tab-5',
-        sessionId: 'chat-session-5',
-        cwd: '/home/user/project',
-        before: 'old text',
-        instruction: 'shorten it',
-        requestId: 'req-5',
-      });
-
-      // chatRunner.run() is a no-op stub in this test (never invokes
-      // onSilentResult) — nothing should broadcast until the bound elapses.
-      expect(broadcasts).toHaveLength(0);
-
-      vi.advanceTimersByTime(120_000);
-      expect(broadcasts).toHaveLength(1);
-      expect(broadcasts[0]).toEqual({
-        channel: 'docedit:session-result',
-        payload: { tabId: 'tab-5', requestId: 'req-5', ok: false, error: 'timed out waiting on the background session' },
-      });
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});
-
-describe('duplicateNameFor', () => {
-  test('fresh name — no collision', () => {
-    const result = duplicateNameFor('/tmp/dir', 'notes.txt', () => false);
-    expect(result).toEqual({ ok: true, name: 'notes-copy.txt' });
-  });
-
-  test('collision on the first candidate falls through to -copy-2', () => {
-    const taken = new Set(['/tmp/dir/notes-copy.txt']);
-    const result = duplicateNameFor('/tmp/dir', 'notes.txt', (full) => taken.has(full));
-    expect(result).toEqual({ ok: true, name: 'notes-copy-2.txt' });
-  });
-
-  test('preserves extension-less basenames', () => {
-    const result = duplicateNameFor('/tmp/dir', 'README', () => false);
-    expect(result).toEqual({ ok: true, name: 'README-copy' });
-  });
-
-  test('cap exhausted after 20 attempts returns an error', () => {
-    const result = duplicateNameFor('/tmp/dir', 'notes.txt', () => true);
-    expect(result.ok).toBe(false);
-    expect(result.error).toBeTruthy();
-  });
-});