claude-code-session-manager 0.13.1 → 0.15.0

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

@@ -0,0 +1,388 @@
+/**
+ * runVerify.test.cjs — unit tests for the post-run reconciliation verifier.
+ *
+ * Run standalone: node src/main/__tests__/runVerify.test.cjs
+ *
+ * Three fixture scenarios (matching the 2026-05-23→24 incident window):
+ *
+ *   1. Case 1 (false-PASS): M2 acceptance script prints test failures + Traceback,
+ *      then echoes "M2 acceptance: PASS". Scheduler used to stamp 'completed'.
+ *      Expected: transcript_errors → needs_review
+ *
+ *   2. Case 2 (HALT): M7 agent correctly halts because M1 soak is unmet.
+ *      Expected: halt → pending, reason embeds soak floor date
+ *
+ *   3. Case 3 (deps_unmet): PRD 56 has an unsatisfied dependsOn entry.
+ *      Expected: deps_unmet → pending
+ *
+ *   4. Truly clean: all tests pass, no error markers.
+ *      Expected: clean → null (caller may stamp 'completed')
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { verifyRun } = require('../runVerify.cjs');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+/** Create a temp directory that is cleaned up after the test. */
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'run-verify-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+/**
+ * Build a minimal stream-JSON log file.
+ * `events` is an array of raw JSON objects to serialise one-per-line.
+ * A "[scheduler] starting..." prefix line is also prepended (must be skipped).
+ */
+function writeLog(dir, slug, events) {
+  const lines = ['[scheduler] starting ' + slug + ' at 2026-05-24T00:00:00.000Z'];
+  for (const ev of events) lines.push(JSON.stringify(ev));
+  lines.push('[scheduler] exit code=0 (raw code=0 signal=null) duration=47s');
+  fs.writeFileSync(path.join(dir, `${slug}.log`), lines.join('\n') + '\n');
+}
+
+/** Write a minimal PRD .md file with frontmatter + body. */
+function writePrd(dir, slug, body) {
+  const text = `---\ntitle: Test PRD\ncwd: /tmp\nestimateMinutes: 30\n---\n${body}\n`;
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+  return path.join(dir, `${slug}.md`);
+}
+
+// ─── fixture: Case 1 — false-PASS (M2 acceptance) ─────────────────────────
+
+test('Case 1: false-PASS (Traceback + echo PASS) → transcript_errors/needs_review', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '39-signal-builder-m2-sentiment-stack';
+    const logEvents = [
+      // Assistant turn: run acceptance script
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_m2_001',
+            name: 'Bash',
+            input: {
+              command: 'bash check_m2.sh',
+              description: 'Run M2 acceptance checks',
+            },
+          }],
+        },
+      },
+      // Tool result: test failures then echo PASS (the false-positive pattern)
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_m2_001',
+            content: [
+              '=== Signal-builder side ===',
+              'ERROR tests/test_news_signals_panel.py',
+              '!!!!!!!! stopping after 1 failures !!!!!!!!',
+              '1 error in 0.03s',
+              'SB: 0',
+              '=== Sanity: SB sentiment_cache.db rows ===',
+              'rows: 0',
+              '=== contract.json panels.sentiment ===',
+              'Traceback (most recent call last):',
+              '  File "<string>", line 1, in <module>',
+              "KeyError: 'panels.sentiment'",
+              'M2 acceptance: PASS',
+            ].join('\n'),
+            is_error: false,
+          }],
+        },
+      },
+      // Result: agent declares success
+      {
+        type: 'result',
+        subtype: 'success',
+        result: 'M2 acceptance criteria verified. All checks passed.',
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const prdPath = writePrd(tmp, slug, '# M2 Sentiment Stack\n\nBuild the sentiment pipeline.');
+
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+    });
+
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+    assert.ok(verdict.reason.length > 0, 'reason should be non-empty');
+
+    // verdicts.json sidecar should have been written
+    const sidecar = JSON.parse(fs.readFileSync(path.join(tmp, `${slug}.verdicts.json`), 'utf8'));
+    assert.equal(sidecar.schemaVersion, 1);
+    assert.equal(sidecar.verdict, 'transcript_errors');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// ─── fixture: Case 2 — HALT (M7 soak unmet) ──────────────────────────────────
+
+test('Case 2: HALT in result event → halt/pending with floor date in reason', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '44-signal-builder-m7-final-cutover';
+    const haltMsg = [
+      'HALT: M7 prerequisite — M1 not yet soaked 30 days × 6 phases',
+      '  M1 commit: f91ce44  2026-05-23 (age: 0 days, need ≥ 180)',
+      '  M7 earliest eligible: ~2026-11-19',
+    ].join('\n');
+
+    const logEvents = [
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_m7_001',
+            name: 'Bash',
+            input: { command: 'git log --oneline m1-tag', description: 'Check M1 soak period' },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_m7_001',
+            content: 'f91ce44  2026-05-23 feat(m1): initial trading signals',
+            is_error: false,
+          }],
+        },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        result: haltMsg,
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const prdPath = writePrd(
+      tmp,
+      slug,
+      '# M7 Final Cutover\n\nOnly after M1–M6 have run 30+ days each.',
+    );
+
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+    });
+
+    assert.equal(verdict.verdict, 'halt', `expected halt, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'pending');
+    assert.ok(verdict.reason.includes('HALT'), 'reason should mention HALT');
+    // Floor date from the HALT message should appear in reason
+    assert.ok(
+      verdict.reason.includes('2026-11-19') || verdict.reason.length > 20,
+      `reason should embed soak floor date: ${verdict.reason}`,
+    );
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// ─── fixture: Case 3 — deps_unmet (dependsOn unsatisfied) ────────────────────
+
+test('Case 3: dependsOn pointing at pending dep → deps_unmet/pending', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '56-burrow-mcp-retire-tier3-frozen-endpoints';
+    const logEvents = [
+      {
+        type: 'result',
+        subtype: 'success',
+        result: 'Completed burrow MCP tier-3 retirement.',
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const prdPath = writePrd(
+      tmp,
+      slug,
+      '# Burrow MCP Retire Tier-3\n\nRetire frozen endpoints.',
+    );
+
+    // M7 is a predecessor that is still pending.
+    const allJobs = [
+      { slug: '44-signal-builder-m7-final-cutover', status: 'pending', finishedAt: null },
+      { slug: slug, status: 'running', finishedAt: null },
+    ];
+    const queueEntry = {
+      slug,
+      status: 'running',
+      dependsOn: ['44-signal-builder-m7-final-cutover'],
+    };
+
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry, allJobs });
+
+    assert.equal(verdict.verdict, 'deps_unmet', `expected deps_unmet, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'pending');
+    assert.ok(verdict.reason.includes('44-signal-builder-m7-final-cutover'), 'reason should name the unmet dep');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// ─── fixture: truly clean run ─────────────────────────────────────────────────
+
+test('Truly clean run (no error markers) → clean/null', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '20-clean-feature';
+    const logEvents = [
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_clean_001',
+            name: 'Bash',
+            input: { command: 'npm test', description: 'Run test suite' },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_clean_001',
+            content: '✓ 42 tests passed (1.3s)\nAll tests passed.',
+            is_error: false,
+          }],
+        },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        result: 'Feature complete. All acceptance criteria satisfied.',
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const prdPath = writePrd(tmp, slug, '# Clean Feature\n\nImplement a clean feature.');
+
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+    });
+
+    assert.equal(verdict.verdict, 'clean', `expected clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// ─── self-recovery: FAIL followed by successful retry ──────────────────────
+
+test('FAIL recovered within 30 events → clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '21-self-recovering';
+    const desc = 'Run pytest';
+    const logEvents = [
+      // First attempt: fails
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_r1',
+            name: 'Bash',
+            input: { command: 'pytest', description: desc },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_r1',
+            content: 'FAILED tests/test_foo.py::test_bar - AssertionError',
+            is_error: false,
+          }],
+        },
+      },
+      // Agent fixes and retries with same description
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_r2',
+            name: 'Bash',
+            input: { command: 'pytest', description: desc },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_r2',
+            content: '5 passed in 0.42s',
+            is_error: false,
+          }],
+        },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        result: 'Fixed the failing test and verified all pass.',
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const prdPath = writePrd(tmp, slug, '# Self-recovering test');
+
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+    });
+
+    assert.equal(verdict.verdict, 'clean', `self-recovery should yield clean, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});

package/src/main/config.cjs

@@ -22,6 +22,7 @@ const os = require('node:os');
 const chokidar = require('chokidar');
 const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
+const { expandHome } = require('./lib/expandHome.cjs');
 
 /** Map<absPath, {watcher, refCount}> — one chokidar watcher per path. */
 const watchers = new Map();
@@ -31,13 +32,6 @@ function attachWindow(w) {
   window = w;
 }
 
-function expandHome(p) {
-  if (!p) return p;
-  if (p === '~') return os.homedir();
-  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
-  return p;
-}
-
 /**
  * Resolve a path to its realpath, handling non-existent files by resolving
  * the parent directory instead. Prevents symlink traversal attacks.

package/src/main/files.cjs

@@ -14,42 +14,13 @@
  */
 
 const { ipcMain, shell } = require('electron');
-const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
 
 const { z } = require('zod');
-
-function expandHome(p) {
-  if (!p) return p;
-  if (p === '~') return os.homedir();
-  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
-  return p;
-}
-
-/**
- * Resolve to realpath; on ENOENT resolve the parent then re-append basename so
- * we can still validate create destinations. Mirrors config.cjs.
- */
-function realResolve(abs) {
-  const lex = path.resolve(expandHome(abs));
-  try {
-    return fs.realpathSync(lex);
-  } catch (e) {
-    if (e.code === 'ENOENT') {
-      const parent = path.dirname(lex);
-      try {
-        return path.join(fs.realpathSync(parent), path.basename(lex));
-      } catch {
-        return lex;
-      }
-    }
-    throw e;
-  }
-}
-
-const HOME = os.homedir();
+const { assertInsideHome } = require('./lib/insideHome.cjs');
+const { expandHome } = require('./lib/expandHome.cjs');
 
 /**
  * Validates that the path is under the home directory. Returns the realpath
@@ -58,11 +29,7 @@ const HOME = os.homedir();
  * ~ — but never escapes the home tree.
  */
 function validateHomePath(abs) {
-  const real = realResolve(abs);
-  let realHome;
-  try { realHome = fs.realpathSync(HOME); } catch { realHome = HOME; }
-  if (real === realHome || real.startsWith(realHome + path.sep)) return real;
-  throw new Error(`Path outside home directory: ${real}`);
+  return assertInsideHome(expandHome(abs)).realPath;
 }
 
 /** Reject .credentials.json writes regardless of where they sit. */
@@ -228,7 +195,7 @@ async function renameEntry(oldPath, newName) {
   }
 }
 
-const CRITICAL_PATHS = new Set([HOME, '/', '/usr', '/bin', '/etc', '/var', '/System', '/Applications']);
+const CRITICAL_PATHS = new Set([os.homedir(), '/', '/usr', '/bin', '/etc', '/var', '/System', '/Applications']);
 
 async function deleteEntry(filePath) {
   let resolved;

package/src/main/historyAggregator.cjs

@@ -14,10 +14,20 @@ function decodeCwd(encoded) {
   return '/' + encoded.replace(/-+/g, '/');
 }
 
+// All date strings in this module are LOCAL-TZ YYYY-MM-DD. A previous version
+// used UTC (toISOString().slice(0,10)) which silently shifted late-evening
+// sessions a day forward for Pacific-time users, then the >= effectiveTo
+// filter dropped them entirely. en-CA locale yields ISO-format dates in the
+// JS environment's TZ. Parse with 'T12:00:00' (local noon) so DST boundaries
+// don't shift the date by a day.
+function localDate(d) {
+  return d.toLocaleDateString('en-CA');
+}
+
 function subtractDays(dateStr, days) {
-  const d = new Date(dateStr + 'T00:00:00Z');
-  d.setUTCDate(d.getUTCDate() - days);
-  return d.toISOString().slice(0, 10);
+  const d = new Date(dateStr + 'T12:00:00');
+  d.setDate(d.getDate() - days);
+  return localDate(d);
 }
 
 async function parseJSONL(filePath, stat) {
@@ -69,10 +79,18 @@ async function parseJSONL(filePath, stat) {
 
     const usage = obj.usage ?? obj.message?.usage;
     if (usage && typeof usage === 'object') {
-      if (typeof usage.inputTokens === 'number') acc.inputTokens += usage.inputTokens;
-      if (typeof usage.outputTokens === 'number') acc.outputTokens += usage.outputTokens;
-      if (typeof usage.cacheReadInputTokens === 'number') acc.cacheReadTokens += usage.cacheReadInputTokens;
-      if (typeof usage.cacheCreationInputTokens === 'number') acc.cacheCreationTokens += usage.cacheCreationInputTokens;
+      // Claude Code JSONLs use snake_case (matching the Anthropic API). The
+      // previous camelCase-only check meant every token count read as 0.
+      // Accept both shapes for forward-compat with any future renderer-side
+      // emitter (live.ts already normalizes both).
+      const inT = usage.input_tokens ?? usage.inputTokens;
+      const outT = usage.output_tokens ?? usage.outputTokens;
+      const cacheR = usage.cache_read_input_tokens ?? usage.cacheReadInputTokens;
+      const cacheC = usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens;
+      if (typeof inT === 'number') acc.inputTokens += inT;
+      if (typeof outT === 'number') acc.outputTokens += outT;
+      if (typeof cacheR === 'number') acc.cacheReadTokens += cacheR;
+      if (typeof cacheC === 'number') acc.cacheCreationTokens += cacheC;
     }
 
     const content = obj.message?.content ?? obj.content;
@@ -96,10 +114,10 @@ async function parseJSONL(filePath, stat) {
 
   try {
     acc.sessionDate = firstTs
-      ? new Date(firstTs).toISOString().slice(0, 10)
-      : new Date(stat.mtimeMs).toISOString().slice(0, 10);
+      ? localDate(new Date(firstTs))
+      : localDate(new Date(stat.mtimeMs));
   } catch {
-    acc.sessionDate = new Date(stat.mtimeMs).toISOString().slice(0, 10);
+    acc.sessionDate = localDate(new Date(stat.mtimeMs));
   }
 
   return acc;
@@ -126,8 +144,10 @@ async function parseConversationMeta(filePath, stat) {
     }
     const usage = obj.usage ?? obj.message?.usage;
     if (usage && typeof usage === 'object') {
-      if (typeof usage.inputTokens === 'number') meta.inputTokens += usage.inputTokens;
-      if (typeof usage.outputTokens === 'number') meta.outputTokens += usage.outputTokens;
+      const inT = usage.input_tokens ?? usage.inputTokens;
+      const outT = usage.output_tokens ?? usage.outputTokens;
+      if (typeof inT === 'number') meta.inputTokens += inT;
+      if (typeof outT === 'number') meta.outputTokens += outT;
     }
   }
   return meta;
@@ -142,7 +162,7 @@ function registerHistoryAggregatorHandlers() {
     const parsed = schemas.historyAggregate.safeParse(rawReq);
     const req = parsed.success ? (parsed.data ?? {}) : {};
     const t0 = Date.now();
-    const today = new Date().toISOString().slice(0, 10);
+    const today = localDate(new Date());
     let effectiveTo = req?.toDate ? req.toDate : today;
     if (effectiveTo > today) effectiveTo = today;
     const effectiveFrom = req?.fromDate ? req.fromDate : subtractDays(today, 30);
@@ -185,7 +205,10 @@ function registerHistoryAggregatorHandlers() {
         if (parsed.skipped) { skippedLargeFiles++; continue; }
 
         const { sessionDate } = parsed;
-        if (!sessionDate || sessionDate < effectiveFrom || sessionDate >= effectiveTo) continue;
+        // Inclusive upper bound — `>=` here previously meant "today's data is
+        // always dropped", which combined with the (then-UTC) date bucket to
+        // hide a Pacific-time user's most recent activity entirely.
+        if (!sessionDate || sessionDate < effectiveFrom || sessionDate > effectiveTo) continue;
 
         const key = `${sessionDate}|${encodedCwd}`;
         if (!buckets.has(key)) {