claude-code-session-manager 0.36.0 → 0.37.0

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

@@ -0,0 +1,259 @@
+/**
+ * rcaFeedbackHook.test.cjs — unit tests for src/main/lib/rcaFeedbackHook.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/rcaFeedbackHook.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let realHome;
+let rcaFeedbackHook;
+
+// config.cjs and rcaFeedbackHook.cjs both bake os.homedir() into top-level
+// consts at first require (allowedRoots/WRITE_PREFIXES, PRDS_DIR/SM_REPO_ROOT).
+// Node's require cache must be purged per test so each test's tmpHome takes
+// effect — vi.resetModules() only resets vitest's ESM graph, not require().
+const MODULES_TO_RELOAD = ['../lib/rcaFeedbackHook.cjs', '../config.cjs'];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'rca-feedback-hook-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_RCA_DISABLE;
+  purgeRequireCache();
+  rcaFeedbackHook = require('../lib/rcaFeedbackHook.cjs');
+  // The session-manager-repo fallback destination must exist as a real dir.
+  fs.mkdirSync(path.join(tmpHome, 'Projects', 'session-manager', 'session-manager-operations', 'feedback'), { recursive: true });
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_RCA_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeProjectWithInbox(name = 'proj') {
+  const cwd = path.join(tmpHome, name);
+  fs.mkdirSync(path.join(cwd, 'session-manager-operations', 'feedback'), { recursive: true });
+  return cwd;
+}
+
+function makeProjectWithoutInbox(name = 'bare-proj') {
+  const cwd = path.join(tmpHome, name);
+  fs.mkdirSync(cwd, { recursive: true });
+  return cwd;
+}
+
+function writeRun(runDir, slug, { logLines = ['line1', 'line2'], exitCode = 1, durationMs = 1234 } = {}) {
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, `${slug}.log`), logLines.join('\n') + '\n');
+  fs.writeFileSync(path.join(runDir, `${slug}.meta.json`), JSON.stringify({ exitCode, durationMs }));
+}
+
+function writePrd(slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
+  const prdsDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  const body = ['---', `title: ${slug}`, '---', '', '# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', acBody, '', '# Out of scope', '', '- N/A'].join('\n');
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
+}
+
+function baseJob(overrides = {}) {
+  return { slug: 'testslug', runId: '2026-07-24T00-00-00-000Z', exitCode: 1, error: 'something broke', ...overrides };
+}
+
+// ─── dedupe / new-runId ───────────────────────────────────────────────────────
+
+test('fileRcaFeedback: second call with same (slug, runId) is a no-op', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(first.filed).toBe(true);
+
+  const second = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(second.filed).toBe(false);
+  expect(second.reason).toBe('duplicate');
+
+  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(files.length).toBe(1);
+});
+
+test('fileRcaFeedback: new runId for the same slug files a new RCA', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir1 = path.join(tmpHome, 'run1');
+  const runDir2 = path.join(tmpHome, 'run2');
+  writeRun(runDir1, 'testslug');
+  writeRun(runDir2, 'testslug');
+  writePrd('testslug');
+
+  const r1 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-aaa' }), runDir: runDir1, verdict: 'transcript_errors' });
+  const r2 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-bbb' }), runDir: runDir2, verdict: 'transcript_errors' });
+
+  expect(r1.filed).toBe(true);
+  expect(r2.filed).toBe(true);
+  expect(r1.path).not.toBe(r2.path);
+
+  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(files.length).toBe(2);
+});
+
+// ─── failure-class matching ───────────────────────────────────────────────────
+
+test('classifyFailure: detects stuck-loop from an until/while-true/sleep tail', () => {
+  const logTail = ['doing work', 'until curl -s http://x | jq .uptime; do sleep 5; done', 'still waiting'].join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('stuck-loop');
+});
+
+test('classifyFailure: detects post-ac-overrun when work continues well past the last AC checkbox with no PASS', () => {
+  const lines = ['- [x] first AC item done', '- [x] last AC item done'];
+  for (let i = 0; i < 30; i++) lines.push(`extra post-AC work line ${i}`);
+  const logTail = lines.join('\n');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('post-ac-overrun');
+});
+
+test('classifyFailure: falls back to uncommitted-changes for that verdict', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'uncommitted_changes', logTail: 'no special markers here' })).toBe('uncommitted-changes');
+});
+
+test('classifyFailure: falls back to no-sentinel for no_verdict_sentinel/pass_no_commit', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail: 'clean tail, no loops' })).toBe('no-sentinel');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail: 'clean tail, no loops' })).toBe('no-sentinel');
+});
+
+test('classifyFailure: falls back to transcript-errors for transcript_errors/verify_unavailable', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'transcript_errors', logTail: 'Traceback (most recent call last)' })).toBe('transcript-errors');
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'verify_unavailable', logTail: 'verifier threw' })).toBe('transcript-errors');
+});
+
+test('classifyFailure: unknown verdict with no matching markers falls back to unknown', () => {
+  expect(rcaFeedbackHook.classifyFailure({ verdict: 'halt', logTail: 'nothing special' })).toBe('unknown');
+});
+
+// ─── AC extraction ─────────────────────────────────────────────────────────────
+
+test('extractAcceptanceCriteria: pulls the section body between the heading and the next heading', () => {
+  const body = ['# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', '- [ ] one', '- [ ] two', '', '# Out of scope', '', '- N/A'].join('\n');
+  expect(rcaFeedbackHook.extractAcceptanceCriteria(body)).toBe('- [ ] one\n- [ ] two');
+});
+
+test('extractAcceptanceCriteria: returns null when no such heading exists', () => {
+  const body = ['# Goal', '', 'Do the thing.'].join('\n');
+  expect(rcaFeedbackHook.extractAcceptanceCriteria(body)).toBeNull();
+});
+
+// ─── investigation <RCA> block extraction ──────────────────────────────────────
+
+test('extractRcaBlock: pulls plain-text block content', () => {
+  const log = 'preamble\n<RCA>\nForgot to bound the poll loop.\n</RCA>\npostamble';
+  expect(rcaFeedbackHook.extractRcaBlock(log)).toBe('Forgot to bound the poll loop.');
+});
+
+test('extractRcaBlock: unescapes JSON-escaped newlines from a stream-json transcript', () => {
+  const log = '{"text":"<RCA>\\nForgot to bound the poll loop.\\nSee scheduler.cjs:1509.\\n</RCA>"}';
+  expect(rcaFeedbackHook.extractRcaBlock(log)).toBe('Forgot to bound the poll loop.\nSee scheduler.cjs:1509.');
+});
+
+test('extractRcaBlock: returns null when no block is present', () => {
+  expect(rcaFeedbackHook.extractRcaBlock('no block here')).toBeNull();
+});
+
+// ─── destination resolution ────────────────────────────────────────────────────
+
+test('resolveDestination: uses the job cwd inbox when it exists', () => {
+  const cwd = makeProjectWithInbox();
+  const dest = rcaFeedbackHook.resolveDestination({ cwd });
+  expect(dest.dir).toBe(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(dest.targetProjectNote).toBeNull();
+});
+
+test('resolveDestination: falls back to the session-manager repo inbox when the target has none', () => {
+  const cwd = makeProjectWithoutInbox();
+  const dest = rcaFeedbackHook.resolveDestination({ cwd });
+  expect(dest.dir).toBe(rcaFeedbackHook.SM_REPO_FEEDBACK_DIR);
+  expect(dest.targetProjectNote).toContain(cwd);
+});
+
+test('fileRcaFeedback: actually writes into the fallback dir when the target inbox is missing', async () => {
+  const cwd = makeProjectWithoutInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(true);
+  expect(res.path.startsWith(rcaFeedbackHook.SM_REPO_FEEDBACK_DIR)).toBe(true);
+  const content = fs.readFileSync(res.path, 'utf8');
+  expect(content).toContain(cwd);
+});
+
+test('fileRcaFeedback: rejects a slug containing path-traversal segments', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  fs.mkdirSync(runDir, { recursive: true });
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, slug: '../../etc/passwd' }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('unsafe-slug');
+});
+
+// ─── kill-switch ────────────────────────────────────────────────────────────────
+
+test('fileRcaFeedback: SM_RCA_DISABLE=1 skips without writing', async () => {
+  process.env.SM_RCA_DISABLE = '1';
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('disabled');
+  expect(fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback')).length).toBe(0);
+});
+
+// ─── investigation-text enrichment ──────────────────────────────────────────────
+
+test('fileRcaFeedback: investigationText updates the existing RCA instead of duplicating it', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd('testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
+  expect(first.filed).toBe(true);
+  const before = fs.readFileSync(first.path, 'utf8');
+  expect(before).not.toContain('## Investigation analysis');
+
+  const second = await rcaFeedbackHook.fileRcaFeedback({
+    job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
+  });
+  expect(second.filed).toBe(true);
+  expect(second.updated).toBe(true);
+  expect(second.path).toBe(first.path);
+
+  const after = fs.readFileSync(second.path, 'utf8');
+  expect(after).toContain('## Investigation analysis');
+  expect(after).toContain('forgot to bound the poll loop');
+
+  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
+  expect(files.length).toBe(1);
+});

package/src/main/__tests__/scheduler-effective-concurrency.test.cjs

@@ -0,0 +1,51 @@
+/**
+ * scheduler-effective-concurrency.test.cjs — unit tests for the
+ * effectiveConcurrency field on buildScheduleStatePayload.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-effective-concurrency.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const { buildScheduleStatePayload } = require('../scheduler.cjs');
+
+const ENV_KEY = 'SM_SCHEDULER_MAX_CONCURRENCY';
+let savedEnv;
+
+beforeEach(() => {
+  savedEnv = process.env[ENV_KEY];
+  delete process.env[ENV_KEY];
+});
+
+afterEach(() => {
+  if (savedEnv === undefined) delete process.env[ENV_KEY];
+  else process.env[ENV_KEY] = savedEnv;
+});
+
+function fakeState(concurrencyCap) {
+  return {
+    config: { concurrencyCap },
+    jobs: [],
+    scheduledFor: null,
+    lastRunAt: null,
+    paused: null,
+  };
+}
+
+test('effectiveConcurrency is config-sourced when env var is unset', () => {
+  const payload = buildScheduleStatePayload(fakeState(5));
+  expect(payload.effectiveConcurrency).toEqual({ cap: 5, source: 'config' });
+});
+
+test('effectiveConcurrency is env-sourced and wins over config when env var is set', () => {
+  process.env[ENV_KEY] = '7';
+  const payload = buildScheduleStatePayload(fakeState(5));
+  expect(payload.effectiveConcurrency).toEqual({ cap: 7, source: 'env' });
+});
+
+test('effectiveConcurrency clamps env var into [1, 20]', () => {
+  process.env[ENV_KEY] = '999';
+  const payload = buildScheduleStatePayload(fakeState(5));
+  expect(payload.effectiveConcurrency).toEqual({ cap: 20, source: 'env' });
+});

package/src/main/chatRunner.cjs

@@ -54,30 +54,49 @@ const { extractJson } = require('./lib/extractJson.cjs');
 const STOP_SENTINEL = '<<<SM_NEEDS_INPUT>>>';
 
 /**
- * Parse the final assistant text for the stop-signal protocol.
+ * Split the final assistant text at the stop-signal sentinel.
  *
- * Returns `{ questions: string[] }` when the sentinel is present and a
- * balanced JSON object with a `questions` array can be found anywhere in the
- * text after it — tolerant of leading blank lines, code-fence wrapping,
- * multi-line pretty-printing, and trailing prose after the closing `}`.
+ * Returns `{ answerBody: string, questions: string[] }` when the sentinel is
+ * present and a balanced JSON object with a `questions` array can be found
+ * anywhere in the text after it (tolerant of leading blank lines, code-fence
+ * wrapping, multi-line pretty-printing, and trailing prose after the closing
+ * `}`). `answerBody` is everything before the LAST sentinel occurrence, with
+ * the trailing sentinel line and JSON line removed and whitespace trimmed —
+ * an earlier literal sentinel string embedded in the agent's own answer text
+ * is preserved as part of `answerBody` (lastIndexOf semantics).
  * Returns `null` when the sentinel is absent OR when no such JSON object is
- * found — both cases are treated as a completed run with no crash.
+ * found after it — both cases are treated as a completed run with no crash.
  *
  * @param {string} finalText
- * @returns {{ questions: string[] } | null}
+ * @returns {{ answerBody: string, questions: string[] } | null}
  */
-function parseStopSignal(finalText) {
+function splitStopSignal(finalText) {
   if (typeof finalText !== 'string') return null;
   const idx = finalText.lastIndexOf(STOP_SENTINEL);
   if (idx === -1) return null;
   const after = finalText.slice(idx + STOP_SENTINEL.length);
   const parsed = extractJson(after);
   if (parsed && Array.isArray(parsed.questions)) {
-    return { questions: parsed.questions };
+    const answerBody = finalText.slice(0, idx).trim();
+    return { answerBody, questions: parsed.questions };
   }
   return null;
 }
 
+/**
+ * Parse the final assistant text for the stop-signal protocol.
+ *
+ * Thin wrapper over `splitStopSignal` — kept for existing callers that only
+ * need the questions, not the pre-sentinel answer body.
+ *
+ * @param {string} finalText
+ * @returns {{ questions: string[] } | null}
+ */
+function parseStopSignal(finalText) {
+  const split = splitStopSignal(finalText);
+  return split ? { questions: split.questions } : null;
+}
+
 // ─── `/context` probe (PRD 470) ────────────────────────────────────────────
 // `claude -p "/context"` is answered entirely locally by the CLI (zero-cost,
 // no real API call) with markdown containing a summary line and a per-category
@@ -220,10 +239,14 @@ function hasMcpConsentDenial(text) {
 // Instruction prepended to every prompt. Tells the agent how to signal that
 // it needs clarification vs. having completed the task.
 const STOP_SIGNAL_INSTRUCTION =
-  `IMPORTANT: If you need clarification from the user before you can continue, ` +
-  `do NOT guess — finish your turn by emitting, as the very last line, exactly:\n` +
+  `IMPORTANT: First deliver everything you CAN answer or produce right now — findings, ` +
+  `the requested content, work already completed — as normal output. Only THEN, if ` +
+  `something still blocks you from finishing, end your turn by emitting, as the very ` +
+  `last line, exactly:\n` +
   `${STOP_SENTINEL}\n` +
   `followed on the next line by a single-line JSON object {"questions":["..."]}. ` +
+  `Never make the question your entire reply when the user asked for content — do NOT ` +
+  `guess on what's genuinely blocked, but always answer what you can first. ` +
   `Otherwise complete the task and end with a concise summary of what you did.\n\n`;
 
 // ─── Serial run queue (v0.34) ───────────────────────────────────────────────
@@ -507,14 +530,24 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
             emitTerminal('chat:run:complete', { tabId, sessionId, finalMessage: text });
             if (typeof onSilentResult === 'function') onSilentResult(text);
           } else {
-            const signal = parseStopSignal(text);
+            const signal = splitStopSignal(text);
             if (signal) {
               emitTerminal('chat:run:needs-input', {
                 tabId,
                 sessionId,
                 questions: signal.questions,
+                answerBody: signal.answerBody,
                 raw: text,
               });
+              // Record durable exchange off the hot path — UI must not wait on Haiku
+              recordExchange({
+                sessionId,
+                cwd,
+                prompt,
+                result: `${signal.answerBody}\n\n[asked: ${signal.questions.join(' | ')}]`,
+              }).catch((err) => {
+                console.error('[chatRunner] recordExchange failed:', err?.message ?? err);
+              });
             } else {
               emitTerminal('chat:run:complete', { tabId, sessionId, finalMessage: text });
               // Record durable exchange off the hot path — UI must not wait on Haiku
@@ -640,6 +673,7 @@ module.exports = {
   attachWindow,
   registerChatHandlers,
   parseStopSignal,
+  splitStopSignal,
   parseContextUsageMarkdown,
   probeContextUsage,
   STOP_SENTINEL,

package/src/main/config.cjs

@@ -134,6 +134,14 @@ function validateWrite(realAbs) {
       if (realAbs === browserSub || realAbs.startsWith(browserSub + path.sep)) {
         return;
       }
+      // Feedback inbox writes (scheduler RCA hook — rcaFeedbackHook.cjs — and
+      // any interactive feedback filing): narrowly scoped to
+      // session-manager-operations/feedback/, this repo's existing
+      // per-project intake convention.
+      const feedbackSub = path.join(realRoot, 'session-manager-operations', 'feedback');
+      if (realAbs === feedbackSub || realAbs.startsWith(feedbackSub + path.sep)) {
+        return;
+      }
     }
   }
   throw new Error(`Write outside allowed write boundaries: ${realAbs}`);