claude-code-session-manager 0.21.3 → 0.21.4

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-DO3ROR11.js"></script>
+    <script type="module" crossorigin src="./assets/index-BUrrcj7x.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-DeQI4oVI.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.21.3",
+  "version": "0.21.4",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

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

@@ -487,3 +487,40 @@ test('feedback 01: quoted "Traceback..." line (leading quote) → clean', async
     assert.equal(verdict.verdict, 'clean', `quoted traceback prose must not flag, got ${verdict.verdict}: ${verdict.reason}`);
   } finally { rmdir(tmp); }
 });
+
+// ─── harness tool errors (feedback follow-up 2026-06-10) ─────────────────────
+
+test('harness tool error (<tool_use_error>) in final 20% → clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '58-harness-tool-error';
+    // Pad with benign events so the error lands in the final 20%, then a
+    // successful result — mirrors the real 58-web-remote-correctness-batch run.
+    const events = [];
+    for (let k = 0; k < 8; k++) {
+      events.push({ type: 'assistant', message: { role: 'assistant', content: [
+        { type: 'tool_use', id: `t${k}`, name: 'Read', input: { description: `read ${k}` } }] } });
+      events.push({ type: 'user', message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: `t${k}`, content: 'ok', is_error: false }] } });
+    }
+    events.push({ type: 'assistant', message: { role: 'assistant', content: [
+      { type: 'tool_use', id: 'tbad', name: 'bash', input: { description: 'run tests' } }] } });
+    events.push({ type: 'user', message: { role: 'user', content: [
+      { type: 'tool_result', tool_use_id: 'tbad',
+        content: '<tool_use_error>Error: No such tool available: bash</tool_use_error>', is_error: true }] } });
+    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.' });
+
+    writeLog(tmp, slug, events);
+    const prdPath = writePrd(tmp, slug, '# Correctness batch');
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    assert.equal(verdict.verdict, 'clean', `harness tool error must not flag, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally { rmdir(tmp); }
+});
+
+test('isHarnessToolError detects wrapper and "No such tool available"', () => {
+  const { isHarnessToolError } = require('../runVerify.cjs');
+  assert.equal(isHarnessToolError('<tool_use_error>Error: No such tool available: bash</tool_use_error>'), true);
+  assert.equal(isHarnessToolError('No such tool available: Foo'), true);
+  assert.equal(isHarnessToolError('ModuleNotFoundError: No module named x'), false);
+  assert.equal(isHarnessToolError(''), false);
+});

package/src/main/runVerify.cjs

@@ -50,6 +50,19 @@ const VERDICTS_SCHEMA_VERSION = 1;
  *   2. Traceback + Error within 10 lines (Python exception)
  *   3. ModuleNotFoundError / ImportError (missing venv / broken deps)
  */
+/**
+ * True when a tool_result content is a Claude Code harness tool error rather
+ * than task output — emitted when the model calls a tool that doesn't exist or
+ * isn't allowed (e.g. `<tool_use_error>Error: No such tool available: bash`).
+ * The harness rejects the call; the model recovers by retrying with a valid
+ * tool. Never a task failure, so the verifier must not downgrade on it.
+ */
+function isHarnessToolError(content) {
+  if (typeof content !== 'string' || !content) return false;
+  return content.includes('<tool_use_error>')
+    || /\bNo such tool available\b/.test(content);
+}
+
 function detectPattern(content) {
   if (typeof content !== 'string' || !content) return null;
 
@@ -472,6 +485,15 @@ async function verifyRun({ runDir, prdPath, queueEntry, allJobs = [] }) {
       const ev = events[i];
       if (ev.kind !== 'tool_result') continue;
 
+      // Harness tool errors (`<tool_use_error>…`) are emitted when the model
+      // requests a tool that isn't available — e.g. a wrong-case name like
+      // "bash" instead of "Bash", or a tool outside the allowlist. The harness
+      // rejects the call and the model retries with a valid tool; the task is
+      // unaffected. These are never task failures, so they are exempt from both
+      // the is_error scan and the content pattern scan (false-positive class
+      // seen in 58-web-remote-correctness-batch, 2026-06-10).
+      if (isHarnessToolError(ev.content)) continue;
+
       // is_error:true in the final 20% of the transcript.
       if (ev.isError && i >= last20pctStart) {
         const desc = toolUseDesc(events, ev.toolUseId);
@@ -542,6 +564,7 @@ module.exports = {
   verifyRun,
   // Exposed for unit tests.
   detectPattern,
+  isHarnessToolError,
   toolUseName,
   extractSoakFromBody,
   parsePrdBodyDepFragments,

package/src/main/scheduler.cjs

@@ -1629,6 +1629,66 @@ function selectHistoryJobs(jobs, limit) {
     .slice(0, cap);
 }
 
+// Transcript-scan verdicts that re-running verifyRun can re-evaluate. NOT
+// 'uncommitted_changes' — that comes from the git commit-guard, which verifyRun
+// does not inspect, so re-scanning it would always return 'clean' and wrongly
+// heal a genuinely-unfinished job.
+const RESCANNABLE_VERDICTS = new Set(['transcript_errors', 'verify_unavailable']);
+
+/**
+ * Pure predicate: is this job eligible for the boot re-verify self-heal? Only
+ * needs_review jobs with a run log AND a transcript-scan verdict. Crucially
+ * EXCLUDES 'uncommitted_changes' (git commit-guard) — verifyRun can't see git,
+ * so re-scanning it would falsely heal an unfinished job. Exported for tests.
+ */
+function isRescanCandidate(job) {
+  return !!job
+    && job.status === 'needs_review'
+    && !!job.runId
+    && RESCANNABLE_VERDICTS.has(job.verifierVerdict);
+}
+
+/**
+ * Self-healing pass over needs_review jobs. The verifier runs in-process, so a
+ * fix to runVerify.cjs only takes effect for jobs verified AFTER an app
+ * restart — jobs flagged by the old (buggy) verifier stay stuck in needs_review
+ * forever. On boot we re-run the CURRENT verifier over every transcript-scan
+ * needs_review job and auto-complete the ones that now pass clean, so verifier
+ * improvements retroactively clear their own false positives (2026-06-10:
+ * anchored ImportError detectors + harness-tool-error exemption healed 8 jobs).
+ *
+ * @returns {Promise<{rescanned:number, healed:string[]}>}
+ */
+async function reverifyNeedsReview() {
+  const snap = await readQueue();
+  const candidates = snap.jobs.filter(isRescanCandidate);
+  const healed = [];
+  for (const job of candidates) {
+    const runDir = path.join(RUNS_DIR, job.runId);
+    const prdPath = path.join(PRDS_DIR, `${job.slug}.md`);
+    let v = null;
+    try {
+      v = await verifyRun({ runDir, prdPath, queueEntry: job, allJobs: snap.jobs });
+    } catch { continue; } // unreadable log etc. — leave for human review
+    if (v && v.verdict === 'clean') healed.push(job.slug);
+  }
+  if (healed.length) {
+    const healSet = new Set(healed);
+    await mutate((s) => {
+      for (const j of s.jobs) {
+        if (j.status === 'needs_review' && healSet.has(j.slug)) {
+          j.status = 'completed';
+          j.error = null;
+          delete j.verifierVerdict;
+        }
+      }
+    });
+    console.log(`[scheduler] boot reverify: healed ${healed.length} stale needs_review → completed (${healed.join(', ')})`);
+    await broadcast();
+  }
+  return { rescanned: candidates.length, healed };
+}
+
 function registerScheduleHandlers() {
   ensureDirs();
   supervisor.registerHandlers();
@@ -1666,6 +1726,13 @@ function registerScheduleHandlers() {
     };
   });
 
+  ipcMain.handle('schedule:reverify-needs-review', async () => {
+    // Manual trigger for the boot self-heal pass — re-scan needs_review jobs
+    // with the current verifier and auto-complete the ones that now pass clean.
+    const result = await reverifyNeedsReview();
+    return { ok: true, ...result };
+  });
+
   ipcMain.handle('schedule:force-tick', async () => {
     // Bypass the billing-poll gate entirely — fire pending jobs immediately regardless of meter state.
     // Clears any existing pause first (same semantics as run-now).
@@ -1921,6 +1988,13 @@ async function init() {
     await setPaused(boot.paused.reason, boot.paused.resumeAt);
   }
 
+  // Self-heal stale needs_review flags using the current verifier (see
+  // reverifyNeedsReview). Runs once on boot so a shipped verifier fix clears
+  // its own historical false positives without manual retagging.
+  await reverifyNeedsReview().catch((e) => {
+    console.error(`[scheduler] boot reverify failed: ${e?.message ?? e}`);
+  });
+
   await rescheduleTimer();
   // Refresh next-reset every 10 minutes — billing window can shift if usage
   // resets early or the auth token rotates. Tracked so re-init doesn't leak.
@@ -2089,4 +2163,4 @@ const remote = {
   },
 };
 
-module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize };
+module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, reverifyNeedsReview, isRescanCandidate };

package/src/main/webRemote.cjs

@@ -589,9 +589,13 @@ async function tailLines(filePath, fromOffset) {
     const len = stat.size - start;
     const buf = Buffer.alloc(len);
     await fd.read(buf, 0, len, start);
-    const parts = buf.toString('utf8').split('\n').filter(Boolean);
+    // Shift before filter: the fragment may be an empty string (when the
+    // buffer starts with '\n', completing the previous partial line). If we
+    // filter(Boolean) first, the empty fragment disappears and shift() would
+    // remove the first valid line instead.
+    const parts = buf.toString('utf8').split('\n');
     if (dropFirst && parts.length) parts.shift();
-    return { lines: parts, size: stat.size, inode: stat.ino };
+    return { lines: parts.filter(Boolean), size: stat.size, inode: stat.ino };
   } finally {
     await fd.close();
   }