@link-assistant/hive-mind 1.73.5 → 1.73.6

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @link-assistant/hive-mind
 
+## 1.73.6
+
+### Patch Changes
+
+- defa8c4: fix(claude): repair corrupted thinking-block transcripts so resume preserves context (#1834)
+
+  Follow-up to the Issue #1834 recovery ("can we do even better?"). The previous
+  recovery (PR #1835) was reactive: a plain resume of a transcript poisoned by a
+  corrupted extended-thinking block (`{ "type": "thinking", "thinking": "" }` with a
+  kept signature) just repeats the `400 ... thinking blocks ... cannot be modified`
+  error, so recovery almost always fell through to a **fresh restart that discards
+  dozens of turns** of accumulated context (50 turns / $3.84 in the second
+  reproduction log).
+
+  Recovery Phase 1 now **proactively repairs the on-disk session transcript** before
+  resuming: `repairCorruptedThinkingBlocks` (new
+  `src/claude.session-transcript-repair.lib.mjs`) strips the empty-text
+  `thinking`/`redacted_thinking` blocks from the session JSONL — a workaround proven
+  upstream (the Anthropic API permits _omitting_ earlier thinking, just not
+  _modifying_ it). When repair succeeds the resume keeps all accumulated context;
+  when it can't help, recovery still falls back to a fresh restart, so there is no
+  regression.
+
+  The repair is conservative: it never throws, only removes empty-text blocks (valid
+  signed thinking is untouched), never empties an assistant message, and writes a
+  one-time `<session>.jsonl.pre-repair-backup` before rewriting. The case study under
+  `docs/case-studies/issue-1834` is updated with a second reproduction log and the
+  new repair-then-resume design.
+
 ## 1.73.5
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.73.5",
+  "version": "1.73.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.session-transcript-repair.lib.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+// Issue #1834 (PR #1836): repair a Claude Code session transcript that was poisoned by a
+// corrupted extended-thinking block, so the session can be RESUMED (context preserved) instead
+// of being discarded entirely.
+//
+// Root cause (upstream anthropics/claude-code#63147, #46843, #24662, #41992): when extended
+// thinking is combined with tool use, Claude Code can persist a thinking block to the on-disk
+// session JSONL with its `thinking` text emptied to "" while keeping the original `signature`:
+//
+//   { "type": "thinking", "thinking": "", "signature": "Eyc…" }
+//
+// On resume/continue the API replays that block and validates the signature against the now-empty
+// text, rejecting every following turn with a 400:
+//   `thinking` or `redacted_thinking` blocks in the latest assistant message cannot be modified.
+//
+// The proven community workaround (anthropics/claude-code#46843, miteshashar/claude-code-thinking-
+// blocks-fix) is to STRIP the corrupted (empty-text) thinking blocks from the transcript — the API
+// permits omitting earlier-turn thinking, so once the offending blocks are gone the session resumes
+// cleanly with all of its text/tool-use history intact. This is strictly better than throwing the
+// whole session away: when the repair succeeds we keep the accumulated context (worth many dollars
+// and dozens of turns); when it can't help we still fall back to a fresh restart.
+
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+
+/**
+ * Resolve the on-disk session transcript path for a Claude Code session. Claude Code stores each
+ * session as `~/.claude/projects/<cwd-with-slashes-as-dashes>/<sessionId>.jsonl` (mirrors the
+ * path logic already used by getModelUsageFromSession in claude.lib.mjs).
+ *
+ * @param {string} tempDir - the working directory the Claude session ran in.
+ * @param {string} sessionId - the Claude Code session id.
+ * @param {string} [homeDir] - override home dir (tests).
+ * @returns {string} absolute path to the session JSONL file.
+ */
+export const resolveSessionTranscriptPath = (tempDir, sessionId, homeDir = os.homedir()) => {
+  const projectDirName = String(tempDir).replace(/\//g, '-');
+  return path.join(homeDir, '.claude', 'projects', projectDirName, `${sessionId}.jsonl`);
+};
+
+/**
+ * True when a content block is a corrupted thinking block: an extended-thinking block whose text
+ * was emptied (the upstream corruption) — `{ type: 'thinking', thinking: '' }` (optionally with a
+ * stale `signature`) or the redacted variant `{ type: 'redacted_thinking', data: '' }`.
+ */
+const isCorruptedThinkingBlock = block => {
+  if (!block || typeof block !== 'object') return false;
+  if (block.type === 'thinking') return !block.thinking; // '' / undefined / null
+  if (block.type === 'redacted_thinking') return !block.data;
+  return false;
+};
+
+/**
+ * Strip corrupted (empty-text) thinking blocks from a Claude Code session transcript so the session
+ * can be resumed. Conservative and side-effect-safe:
+ *   - never throws (returns a result object describing what happened);
+ *   - only removes blocks whose thinking text is empty (legitimate signed thinking is untouched);
+ *   - never empties an assistant message (if removing the blocks would leave a message with no
+ *     content, that message is left exactly as-is);
+ *   - writes a one-time backup (`<file>.pre-repair-backup`) before modifying the transcript.
+ *
+ * @param {object} opts
+ * @param {string} opts.tempDir - working directory the session ran in.
+ * @param {string} opts.sessionId - Claude Code session id.
+ * @param {string} [opts.homeDir] - override home dir (tests).
+ * @param {Function} [opts.log] - async logger.
+ * @returns {Promise<{ repaired: boolean, removedBlocks: number, scannedLines: number, sessionFile: string|null, reason?: string }>}
+ */
+export const repairCorruptedThinkingBlocks = async ({ tempDir, sessionId, homeDir, log = async () => {} } = {}) => {
+  const result = { repaired: false, removedBlocks: 0, scannedLines: 0, sessionFile: null };
+  if (!tempDir || !sessionId) {
+    return { ...result, reason: 'missing tempDir or sessionId' };
+  }
+  const sessionFile = resolveSessionTranscriptPath(tempDir, sessionId, homeDir);
+  result.sessionFile = sessionFile;
+  let fileContent;
+  try {
+    fileContent = await fs.readFile(sessionFile, 'utf8');
+  } catch {
+    // No transcript on disk (e.g. fresh run never persisted, or path mismatch) — nothing to repair.
+    return { ...result, reason: 'session transcript not found' };
+  }
+
+  try {
+    const lines = fileContent.split('\n');
+    const out = [];
+    let removedBlocks = 0;
+    let scannedLines = 0;
+    for (const line of lines) {
+      if (!line.trim()) {
+        out.push(line);
+        continue;
+      }
+      scannedLines++;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        out.push(line); // preserve anything we can't parse verbatim
+        continue;
+      }
+      const content = entry?.message?.content;
+      if (Array.isArray(content)) {
+        const corrupted = content.filter(isCorruptedThinkingBlock).length;
+        if (corrupted > 0) {
+          const cleaned = content.filter(b => !isCorruptedThinkingBlock(b));
+          // Never leave an assistant message with an empty content array (invalid for the API).
+          if (cleaned.length > 0) {
+            entry.message.content = cleaned;
+            removedBlocks += corrupted;
+            out.push(JSON.stringify(entry));
+            continue;
+          }
+        }
+      }
+      out.push(line);
+    }
+
+    result.scannedLines = scannedLines;
+    if (removedBlocks === 0) {
+      return { ...result, reason: 'no corrupted thinking blocks found' };
+    }
+
+    // Back up the original transcript exactly once before rewriting it.
+    const backupFile = `${sessionFile}.pre-repair-backup`;
+    try {
+      await fs.access(backupFile);
+    } catch {
+      try {
+        await fs.copyFile(sessionFile, backupFile);
+      } catch {
+        // Best effort — a missing backup must not block the repair.
+      }
+    }
+
+    await fs.writeFile(sessionFile, out.join('\n'), 'utf8');
+    result.repaired = true;
+    result.removedBlocks = removedBlocks;
+    await log(`🩹 Repaired session transcript: stripped ${removedBlocks} corrupted thinking block(s) from ${scannedLines} message line(s) (Issue #1834). Backup: ${backupFile}`, { verbose: true });
+    return result;
+  } catch (error) {
+    // Defensive: any unexpected failure degrades gracefully to "no repair" so the caller can fall
+    // back to a fresh restart.
+    return { ...result, reason: `repair failed: ${error?.message || error}` };
+  }
+};
+
+export default { repairCorruptedThinkingBlocks, resolveSessionTranscriptPath };

package/src/claude.thinking-block-recovery.lib.mjs

@@ -12,9 +12,12 @@
 //
 // PR #1835 feedback: "in case of this specific error we should try resume first, and if not possible
 // try to restart." Recovery is therefore a two-phase escalation:
-//   Phase 1 — resume the existing session (context-preserving; occasionally the transcript is intact
-//             enough to continue).
-//   Phase 2 — resume unavailable or already failed → discard the session and start fresh (`/clear`).
+//   Phase 1 — REPAIR the on-disk transcript (strip the corrupted empty-text thinking blocks) and
+//             resume the existing session (context-preserving). Plain resume of a poisoned
+//             transcript is futile — the 400 just repeats — so we first remove the offending blocks,
+//             which the API permits omitting. When repair succeeds the resume keeps all accumulated
+//             text/tool-use history (Issue #1834 "can we do even better?").
+//   Phase 2 — repair/resume unavailable or already failed → discard the session and start fresh.
 // On every attempt we first auto-commit any uncommitted work (Issue #1834 / PR #1835 feedback:
 // "on all critical errors we auto commit uncommitted changes by default") so nothing is lost when
 // the session context resets.
@@ -22,6 +25,7 @@
 import { retryLimits, criticalErrorRecovery } from './config.lib.mjs';
 import { waitWithCountdown } from './tool-retry.lib.mjs';
 import { commitUncommittedChangesOnCriticalError } from './critical-error-commit.lib.mjs';
+import { repairCorruptedThinkingBlocks } from './claude.session-transcript-repair.lib.mjs';
 
 /**
  * Create a stateful corrupted-thinking-block recovery handler. The returned function persists its
@@ -36,11 +40,13 @@ import { commitUncommittedChangesOnCriticalError } from './critical-error-commit
  * @param {Function} ctx.$ - command-stream executor.
  * @param {Function} ctx.log - async logger.
  * @param {number} [ctx.waitMs=5000] - settle delay before re-running (overridable for tests).
+ * @param {Function} [ctx.repair=repairCorruptedThinkingBlocks] - transcript repair (injectable for tests).
+ * @param {string} [ctx.homeDir] - override home dir for transcript lookup (tests).
  * @returns {(opts: {classified: object, source: string, sessionId: string|null}) => Promise<boolean>}
  *          Resolves true when a recovery attempt was initiated (caller should re-run); false when
  *          both caps are exhausted (caller should fail).
  */
-export const createThinkingBlockRecovery = ({ argv, tempDir, branchName, $, log, waitMs = 5000 }) => {
+export const createThinkingBlockRecovery = ({ argv, tempDir, branchName, $, log, waitMs = 5000, repair = repairCorruptedThinkingBlocks, homeDir }) => {
   let resumeCount = 0;
   let restartCount = 0;
   return async ({ classified, source, sessionId }) => {
@@ -49,11 +55,22 @@ export const createThinkingBlockRecovery = ({ argv, tempDir, branchName, $, log,
         await commitUncommittedChangesOnCriticalError({ tempDir, branchName, $, log, reason: `${classified.label} (${source})` });
       }
     };
-    // Phase 1 — resume the existing session first (cheaper, keeps accumulated context).
+    // Phase 1 — repair the on-disk transcript, then resume (keeps accumulated context).
     if (sessionId && resumeCount < retryLimits.maxThinkingBlockResumes) {
       resumeCount++;
       await preserveWork();
-      await log(`\n⚠️ ${classified.label} (${source}). Resume attempt ${resumeCount}/${retryLimits.maxThinkingBlockResumes} — trying to resume the existing session first before discarding it (Issue #1834)...`, { level: 'warning' });
+      await log(`\n⚠️ ${classified.label} (${source}). Resume attempt ${resumeCount}/${retryLimits.maxThinkingBlockResumes} — repairing the corrupted transcript then resuming the existing session before discarding it (Issue #1834)...`, { level: 'warning' });
+      // Strip the corrupted (empty-text) thinking blocks so resume isn't doomed to repeat the 400.
+      try {
+        const repairResult = await repair({ tempDir, sessionId, homeDir, log });
+        if (repairResult?.repaired) {
+          await log(`   🩹 Stripped ${repairResult.removedBlocks} corrupted thinking block(s) from the transcript — resume will preserve context (Issue #1834).`, { verbose: true });
+        } else {
+          await log(`   ℹ️ Transcript repair made no change (${repairResult?.reason || 'unknown'}) — resuming as-is (Issue #1834).`, { verbose: true });
+        }
+      } catch {
+        // Repair must never block recovery — fall through to a plain resume attempt.
+      }
       argv.resume = sessionId;
       await waitWithCountdown(waitMs, log);
       await log('\n🔄 Resuming the session now...');