@link-assistant/hive-mind 2.15.2 → 2.17.0

package/src/agent.lib.mjs

@@ -349,32 +349,14 @@ export const mapModelToId = model => {
   return agentModels[model] || model;
 };
 
-export const MIN_AGENT_LIVE_INPUT_VERSION = '0.24.1';
+// The Agent CLI version floors live in their own module (issue #2198: this
+// file crossed the 1350-line warning threshold). `validateAgentConnection`
+// below reads them directly, and they are re-exported so importers of
+// `agent.lib.mjs` -- tests/test-codex-support.mjs and
+// tests/test-issue-2186-agent-snapshot-leak.mjs among them -- do not move.
+import { MIN_AGENT_LIVE_INPUT_VERSION, MIN_AGENT_FORMAL_AI_VERSION, MIN_AGENT_SNAPSHOT_HYGIENE_VERSION, getAgentCliVersion } from './agent.version-gates.lib.mjs';
 
-export const getAgentCliVersion = versionOutput => {
-  return semver.clean(versionOutput) || semver.coerce(versionOutput)?.version || null;
-};
-
-export const agentCliSupportsLiveInput = versionOutput => {
-  const version = getAgentCliVersion(versionOutput);
-  return !!version && semver.gte(version, MIN_AGENT_LIVE_INPUT_VERSION);
-};
-
-/**
- * Agent only fails closed on a `--model` argv it cannot parse from js-0.25.8
- * onwards (link-assistant/agent#293, fixed by PR #294): earlier releases logged
- * a CRITICAL record and then answered with their *default* model. Issue #2146
- * requires Formal AI to be the only model a task can reach, and a guard that
- * reads the CRITICAL record can only stop the run after Agent has already
- * decided, so a Formal AI task refuses to start below this release.
- */
-export const MIN_AGENT_FORMAL_AI_VERSION = '0.25.8';
-
-/** True when this Agent CLI aborts instead of silently picking another model. */
-export const agentCliFailsClosedOnModelMismatch = versionOutput => {
-  const version = getAgentCliVersion(versionOutput);
-  return !!version && semver.gte(version, MIN_AGENT_FORMAL_AI_VERSION);
-};
+export { MIN_AGENT_LIVE_INPUT_VERSION, MIN_AGENT_FORMAL_AI_VERSION, MIN_AGENT_SNAPSHOT_HYGIENE_VERSION, getAgentCliVersion, agentCliSupportsLiveInput, agentCliFailsClosedOnModelMismatch, agentCliPrunesOrphanSnapshots } from './agent.version-gates.lib.mjs';
 
 // Function to validate Agent connection
 export const validateAgentConnection = async (model = defaultModels.agent, options = {}) => {
@@ -411,6 +393,24 @@ export const validateAgentConnection = async (model = defaultModels.agent, optio
         }
       }
 
+      if (!agentVersion || !semver.gte(agentVersion, MIN_AGENT_SNAPSHOT_HYGIENE_VERSION)) {
+        await log(`❌ Hive Mind requires @link-assistant/agent >= ${MIN_AGENT_SNAPSHOT_HYGIENE_VERSION}`, { level: 'error' });
+        await log('   Older releases write a full, standalone copy of the repository into', { level: 'error' });
+        await log('   ~/.local/share/link-assistant-agent/snapshot/ per project and never reclaim it', { level: 'error' });
+        await log('   (link-assistant/agent#298): issue #2186 lost 31 GB to 115 orphaned stores in one task.', { level: 'error' });
+        if (agentVersion) {
+          await log(`   Installed Agent CLI version: ${agentVersion}`, { level: 'error' });
+        } else {
+          await log('   Could not determine the installed Agent CLI version.', { level: 'error' });
+        }
+        await log('   Update with: bun install -g @link-assistant/agent@latest', { level: 'error' });
+        return false;
+      }
+
+      // The two capability gates below are subsumed by the floor above while it
+      // stays the highest of the three. They are kept because each states an
+      // independent contract with its own diagnosis, and any one of the floors
+      // can move on its own.
       if (requireLiveInput && (!agentVersion || !semver.gte(agentVersion, MIN_AGENT_LIVE_INPUT_VERSION))) {
         await log(`❌ Agent live stream-json input requires @link-assistant/agent >= ${MIN_AGENT_LIVE_INPUT_VERSION}`, { level: 'error' });
         if (agentVersion) {

package/src/agent.version-gates.lib.mjs

@@ -0,0 +1,73 @@
+/**
+ * Version floors for the Agent CLI, and the predicates that read them.
+ *
+ * Each floor is the first Agent release in which a behaviour Hive Mind depends
+ * on actually holds; below it the CLI does something subtly wrong rather than
+ * failing, so the caller refuses to start instead of trusting the result. The
+ * comments on each constant record which upstream issue moved the floor.
+ *
+ * Extracted from `src/agent.lib.mjs` when issue #2186 pushed that file past the
+ * 1350-line warning threshold enforced by `scripts/check-file-line-limits.sh`.
+ * `agent.lib.mjs` re-exports every name here, so importers are unaffected.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2198
+ */
+
+import semver from 'semver';
+
+export const MIN_AGENT_LIVE_INPUT_VERSION = '0.24.1';
+
+export const getAgentCliVersion = versionOutput => {
+  // `agent --version` can come back as `undefined` when the probe times out or
+  // the binary writes nothing to stdout, and `semver.clean(undefined)` throws.
+  // The floors below must answer "unknown", not blow up, so the caller reports
+  // the missing version instead of a `TypeError`.
+  const text = versionOutput == null ? '' : String(versionOutput);
+  return semver.clean(text) || semver.coerce(text)?.version || null;
+};
+
+export const agentCliSupportsLiveInput = versionOutput => {
+  const version = getAgentCliVersion(versionOutput);
+  return !!version && semver.gte(version, MIN_AGENT_LIVE_INPUT_VERSION);
+};
+
+/**
+ * Agent only fails closed on a `--model` argv it cannot parse from js-0.25.8
+ * onwards (link-assistant/agent#293, fixed by PR #294): earlier releases logged
+ * a CRITICAL record and then answered with their *default* model. Issue #2146
+ * requires Formal AI to be the only model a task can reach, and a guard that
+ * reads the CRITICAL record can only stop the run after Agent has already
+ * decided, so a Formal AI task refuses to start below this release.
+ */
+export const MIN_AGENT_FORMAL_AI_VERSION = '0.25.8';
+
+/** True when this Agent CLI aborts instead of silently picking another model. */
+export const agentCliFailsClosedOnModelMismatch = versionOutput => {
+  const version = getAgentCliVersion(versionOutput);
+  return !!version && semver.gte(version, MIN_AGENT_FORMAL_AI_VERSION);
+};
+
+/**
+ * Agent keeps a rollback snapshot per project under
+ * `$XDG_DATA_HOME/link-assistant-agent/snapshot/<project id>`, and that project
+ * id is the worktree's *root commit*. Before js-0.26.1 the store was a
+ * standalone object database — no `objects/info/alternates` — and nothing ever
+ * removed it, so any harness that runs the agent inside a throwaway `git init`
+ * checkout minted a brand-new full copy of the repository per invocation and
+ * never reclaimed one. Issue #2186 measured 115 orphaned stores / 31 GB in a
+ * single 9.5 h task (~5 GB/h, every recorded worktree already deleted) while
+ * every Hive Mind disk check — the 10 GB pre-flight gate, `disk-guard`,
+ * `hive-cleanup` — reported a healthy workspace, because all of them only look
+ * at `/tmp`. link-assistant/agent#298 (PR #300, shipped in 0.26.1) shares the
+ * repository's objects through `objects/info/alternates` and prunes projects
+ * whose recorded worktree no longer exists, which is what makes an unattended
+ * multi-hour run bounded. Older releases are refused rather than left to fill
+ * the disk.
+ */
+export const MIN_AGENT_SNAPSHOT_HYGIENE_VERSION = '0.26.1';
+
+/** True when this Agent CLI shares snapshot objects and prunes dead projects. */
+export const agentCliPrunesOrphanSnapshots = versionOutput => {
+  const version = getAgentCliVersion(versionOutput);
+  return !!version && semver.gte(version, MIN_AGENT_SNAPSHOT_HYGIENE_VERSION);
+};

package/src/bot-lifecycle.lib.mjs

@@ -12,7 +12,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1927
  */
 
-import { RESOURCE_PHASE_BOT_HEARTBEAT, captureResourceSnapshot, summarizeResourceSnapshot } from './solve.resource-diagnostics.lib.mjs';
+import { RESOURCE_PHASE_BOT_HEARTBEAT, captureResourceSnapshot, formatHeapUsage, isHeapUnderPressure, summarizeResourceSnapshot } from './solve.resource-diagnostics.lib.mjs';
 
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 60 * 1000;
 
@@ -51,6 +51,13 @@ export function createHeartbeat({ logger, getActiveSessionCount, intervalMs = DE
         uptimeSec: Math.floor(processImpl.uptime()),
         resources,
       });
+      // Issue #2189: the bot walked from 1.78 GB to 1.84 GB of RSS against its
+      // own ~2 GB heap cap while re-reporting one dead session, and nothing in
+      // the log said so until it died (#733). The heartbeat is the one place
+      // that samples the bot itself, so it is where the warning belongs.
+      if (isHeapUnderPressure(resources?.memory) && typeof logger.warn === 'function') {
+        logger.warn(`Bot V8 heap is under pressure: ${formatHeapUsage(resources.memory)} — the process will abort with "JavaScript heap out of memory" if it keeps growing`, { heap: resources.memory });
+      }
     } catch {
       /* heartbeat must never crash the bot */
     }
@@ -76,6 +83,52 @@ export function createHeartbeat({ logger, getActiveSessionCount, intervalMs = DE
   };
 }
 
+/**
+ * Reconcile the isolation backend's own view of still-running executions.
+ *
+ * Issue #2189: the detached-docker completion watchers are children of the
+ * process that launched them, so a bot restart leaves every running container
+ * unsupervised — its exit is never written to the log footer, which is one of
+ * the ways the reported session stayed in limbo. `$ --resume-all`
+ * (start-command >= 0.33.0) re-attaches a watcher to what is still alive and
+ * finalizes what died meanwhile; it starts no work on its own.
+ *
+ * Run *before* the durable store is replayed so the first monitor tick reads
+ * settled state rather than racing upstream's reconciliation. An older `$`
+ * without the verb, or no isolation at all, is a no-op — never an error.
+ *
+ * @returns {Promise<{attempted: boolean, reconciled: number, reattached: number, running: number, unsupported: boolean, error: string|null}>}
+ */
+async function reconcileIsolationExecutions({ reconcileIsolationSessions, verbose, logger, consoleImpl }) {
+  const idle = { attempted: false, reconciled: 0, reattached: 0, running: 0, unsupported: false, error: null };
+  if (typeof reconcileIsolationSessions !== 'function') return idle;
+  try {
+    const result = await reconcileIsolationSessions({ verbose });
+    const executions = Array.isArray(result?.executions) ? result.executions : [];
+    const count = action => executions.filter(entry => entry?.action === action).length;
+    const summary = {
+      attempted: true,
+      reconciled: count('reconciled'),
+      reattached: count('reattached'),
+      running: count('running'),
+      unsupported: result?.unsupported === true,
+      error: result?.success === false && result?.unsupported !== true ? result?.error || 'unknown error' : null,
+    };
+    if (summary.reconciled > 0 || summary.reattached > 0) {
+      consoleImpl.log(`♻️  Reconciled ${executions.length} isolated execution(s) with the isolation backend (${summary.reattached} re-attached, ${summary.reconciled} finalized after running unsupervised)`);
+    } else if (verbose) {
+      consoleImpl.log(`[VERBOSE] resume-all: ${summary.unsupported ? 'this `$` build has no --resume-all; skipped' : `${executions.length} execution(s), nothing to re-attach`}`);
+    }
+    logger?.event?.('isolation_executions_reconciled', summary);
+    return summary;
+  } catch (error) {
+    // Startup reconciliation is best effort by construction: it must never be
+    // able to stop the bot from coming up.
+    consoleImpl.error(`[telegram-bot] Could not reconcile isolated executions: ${error?.message || error}`);
+    return { ...idle, attempted: true, error: error?.message || String(error) };
+  }
+}
+
 /**
  * Resume sessions left tracked by a previous run (requirements #2/#4).
  *
@@ -85,9 +138,14 @@ export function createHeartbeat({ logger, getActiveSessionCount, intervalMs = DE
  * `sessions_resumed` event either way and never throws: a resume failure must
  * not stop the bot from coming up.
  *
- * @returns {Promise<{ resumed: any[], skipped: any[], error?: Error }>}
+ * Issue #2189 added the step before it: `reconcileIsolationSessions`
+ * (`$ --resume-all`) settles the isolation backend's own record of what is
+ * still running, so the replayed sessions are matched against the truth.
+ *
+ * @returns {Promise<{ resumed: any[], skipped: any[], reconciliation: object, error?: Error }>}
  */
-export async function resumeSessionsOnLaunch({ resumeTrackedSessions, botStartTime, verbose = false, logger, consoleImpl = console } = {}) {
+export async function resumeSessionsOnLaunch({ resumeTrackedSessions, reconcileIsolationSessions = null, botStartTime, verbose = false, logger, consoleImpl = console } = {}) {
+  const reconciliation = await reconcileIsolationExecutions({ reconcileIsolationSessions, verbose, logger, consoleImpl });
   try {
     const { resumed, skipped } = await resumeTrackedSessions({ botStartTime, verbose });
     if (resumed.length > 0) {
@@ -98,11 +156,11 @@ export async function resumeSessionsOnLaunch({ resumeTrackedSessions, botStartTi
       skipped: skipped.length,
       sessions: resumed.map(r => r.sessionName),
     });
-    return { resumed, skipped };
+    return { resumed, skipped, reconciliation };
   } catch (error) {
     consoleImpl.error(`[telegram-bot] Failed to resume tracked sessions: ${error.message}`);
     logger.error('Failed to resume tracked sessions', { error: error.message });
-    return { resumed: [], skipped: [], error };
+    return { resumed: [], skipped: [], reconciliation, error };
   }
 }
 

package/src/child-exit.lib.mjs

@@ -74,6 +74,58 @@ export const describeChildExit = ({ command, code = null, signal = null }) => {
  */
 export const isLikelyOutOfMemoryExit = ({ code = null, signal = null }) => signal === 'SIGABRT' || signal === 'SIGKILL' || (signal === null && code === 134);
 
+/**
+ * Fatal lines a runtime prints when it exhausts its *own* heap.
+ *
+ * Issue #2189: a session died of `FATAL ERROR: Reached heap limit Allocation
+ * failed - JavaScript heap out of memory` and was reported to the user as a
+ * "forced kill … memory (10.3 GB of 11.7 GB RAM available)". Both statements
+ * were individually true: V8 stopped at its own ~2 GB old-space cap long before
+ * the machine or the container cgroup felt any pressure, so `docker inspect`
+ * said `OOMKilled=false` and `/sys/fs/cgroup/memory.events` said `oom_kill=0`.
+ * Nothing outside the process can observe a runtime self-abort — the only
+ * evidence is the text the runtime printed on its way out, which was sitting in
+ * the log the diagnostics were already reading.
+ *
+ * The patterns are deliberately specific (a bare "out of memory" also appears in
+ * Hive Mind's own diagnostic wording, which ends up in the same logs). Hive Mind
+ * spawns more than Node, so the other runtimes it drives are covered too.
+ */
+export const FATAL_MEMORY_PATTERNS = [
+  { id: 'v8-heap-limit', runtime: 'Node.js/V8', pattern: /FATAL ERROR:[^\n]*Reached heap limit/ },
+  { id: 'v8-ineffective-mark-compacts', runtime: 'Node.js/V8', pattern: /FATAL ERROR:[^\n]*Ineffective mark-compacts near heap limit/ },
+  { id: 'v8-heap-out-of-memory', runtime: 'Node.js/V8', pattern: /JavaScript heap out of memory/ },
+  { id: 'v8-last-few-gcs', runtime: 'Node.js/V8', pattern: /<--- Last few GCs --->/ },
+  { id: 'v8-array-buffer-allocation', runtime: 'Node.js/V8', pattern: /Array buffer allocation failed/ },
+  { id: 'rust-allocation-failed', runtime: 'Rust', pattern: /memory allocation of \d+ bytes failed/ },
+  { id: 'go-runtime-out-of-memory', runtime: 'Go', pattern: /fatal error: runtime: out of memory/ },
+  { id: 'cpp-bad-alloc', runtime: 'C/C++', pattern: /std::bad_alloc/ },
+];
+
+/**
+ * Find the first runtime self-abort marker in a piece of log text.
+ *
+ * Callers must only treat a hit as a cause when the process actually ended
+ * abnormally — the marker upgrades an existing kill to "out of memory", it never
+ * invents one, so an unrelated log that merely quotes the string cannot turn a
+ * healthy run into a reported crash.
+ *
+ * @param {string|null} text - Log text (a tail is enough; the marker is printed last)
+ * @returns {{id: string, runtime: string, line: string}|null}
+ */
+export const findFatalMemoryMarker = text => {
+  if (!text || typeof text !== 'string') return null;
+  for (const { id, runtime, pattern } of FATAL_MEMORY_PATTERNS) {
+    const match = pattern.exec(text);
+    if (!match) continue;
+    const lineStart = text.lastIndexOf('\n', match.index) + 1;
+    const lineEndIndex = text.indexOf('\n', match.index);
+    const line = text.slice(lineStart, lineEndIndex < 0 ? undefined : lineEndIndex).trim();
+    return { id, runtime, line: line.length > 300 ? `${line.slice(0, 300)}…` : line };
+  }
+  return null;
+};
+
 /**
  * Wire `close`/`error` handlers that never lose a signal.
  *
@@ -104,4 +156,4 @@ export const attachChildExitHandlers = ({ child, command, label, errorLabel = la
   });
 };
 
-export default { describeChildExit, isLikelyOutOfMemoryExit, attachChildExitHandlers };
+export default { describeChildExit, isLikelyOutOfMemoryExit, findFatalMemoryMarker, attachChildExitHandlers };

package/src/claude.session-tokens.lib.mjs

@@ -22,6 +22,7 @@ import Decimal from 'decimal.js-light';
 import { accumulateModelUsage, createEmptySubSessionUsage, getRawRequestInputTokens, mergeResultModelUsage } from './claude.budget-stats.lib.mjs';
 import { calculateModelCost } from './claude.cost.lib.mjs';
 import { fetchModelInfo } from './model-info.lib.mjs';
+import { forEachLogLine } from './log-bounded-read.lib.mjs';
 
 export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsage = null, options = {}) => {
   const homeDir = options.homeDir || os.homedir();
@@ -43,10 +44,12 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
   let currentSubSession = createEmptySubSessionUsage();
   const compactifications = [];
   try {
-    const fileContent = await fs.readFile(sessionFile, 'utf8');
-    const lines = fileContent.trim().split('\n');
-    for (const line of lines) {
-      if (!line.trim()) continue;
+    // Issue #2189: read the transcript one record at a time. A long Claude
+    // session produces a JSONL of unbounded size, and `readFile(...).split('\n')`
+    // held the whole file *and* the array of its lines before the first entry
+    // was priced — a full-file allocation just to sum token counters.
+    await forEachLogLine(sessionFile, line => {
+      if (!line.trim()) return;
       try {
         const entry = JSON.parse(line);
         if (entry.type === 'system' && entry.subtype === 'compact_boundary') {
@@ -59,7 +62,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
             trigger: entry.compactMetadata?.trigger || 'unknown',
           });
           currentSubSession = createEmptySubSessionUsage();
-          continue;
+          return;
         }
         if (entry.message && entry.message.usage && entry.message.model) {
           // Issue #1501: Skip duplicate JSONL entries (same message ID = same API response)
@@ -67,7 +70,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
           if (msgId) {
             if (seenMessageIds.has(msgId)) {
               duplicateCount++;
-              continue;
+              return;
             }
             seenMessageIds.add(msgId);
           }
@@ -100,9 +103,8 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
         }
       } catch {
         // Skip lines that aren't valid JSON
-        continue;
       }
-    }
+    });
     if (currentSubSession.messageCount > 0) {
       subSessions.push(currentSubSession);
     }

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

@@ -25,6 +25,8 @@ import { promises as fs } from 'fs';
 import os from 'os';
 import path from 'path';
 
+import { fileEndsWithNewline, forEachLogLine } from './log-bounded-read.lib.mjs';
+
 /**
  * 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
@@ -52,6 +54,36 @@ const isCorruptedThinkingBlock = block => {
   return false;
 };
 
+/**
+ * Repair one transcript record.
+ *
+ * Returns the line to write back (unchanged unless a corrupted block was
+ * dropped), how many corrupted blocks it dropped, and whether the line counted
+ * as a scanned message line. Keeping the decision in one pure function lets the
+ * repair stream the file twice — count, then rewrite — with identical results.
+ *
+ * @param {string} line - One raw JSONL record
+ * @returns {{text: string, removed: number, scanned: number}}
+ */
+const repairTranscriptLine = line => {
+  if (!line.trim()) return { text: line, removed: 0, scanned: 0 };
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return { text: line, removed: 0, scanned: 1 }; // preserve anything we can't parse verbatim
+  }
+  const content = entry?.message?.content;
+  if (!Array.isArray(content)) return { text: line, removed: 0, scanned: 1 };
+  const corrupted = content.filter(isCorruptedThinkingBlock).length;
+  if (corrupted === 0) return { text: line, removed: 0, scanned: 1 };
+  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) return { text: line, removed: 0, scanned: 1 };
+  entry.message.content = cleaned;
+  return { text: JSON.stringify(entry), removed: corrupted, scanned: 1 };
+};
+
 /**
  * Strip corrupted (empty-text) thinking blocks from a Claude Code session transcript so the session
  * can be resumed. Conservative and side-effect-safe:
@@ -75,48 +107,27 @@ export const repairCorruptedThinkingBlocks = async ({ tempDir, sessionId, homeDi
   }
   const sessionFile = resolveSessionTranscriptPath(tempDir, sessionId, homeDir);
   result.sessionFile = sessionFile;
-  let fileContent;
+  let sessionStat;
   try {
-    fileContent = await fs.readFile(sessionFile, 'utf8');
+    sessionStat = await fs.stat(sessionFile);
   } 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 = [];
+    // Issue #2189: a session transcript grows with the session — the captured
+    // incident's was 134 MB — so this is done in two streaming passes instead of
+    // holding the file, its array of lines and the rebuilt output in the heap at
+    // once. Pass 1 only counts: a transcript with nothing to repair (the common
+    // case) is never rewritten and never copied.
     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);
-    }
+    await forEachLogLine(sessionFile, line => {
+      const repaired = repairTranscriptLine(line);
+      scannedLines += repaired.scanned;
+      removedBlocks += repaired.removed;
+    });
 
     result.scannedLines = scannedLines;
     if (removedBlocks === 0) {
@@ -135,7 +146,27 @@ export const repairCorruptedThinkingBlocks = async ({ tempDir, sessionId, homeDi
       }
     }
 
-    await fs.writeFile(sessionFile, out.join('\n'), 'utf8');
+    // Pass 2: rewrite through a sibling temp file and rename over the original,
+    // so an interrupted repair can never leave a half-written transcript (which
+    // would be worse than the corruption being repaired).
+    const keepTrailingNewline = await fileEndsWithNewline(sessionFile);
+    const tempFile = `${sessionFile}.repair-${process.pid}`;
+    await fs.rm(tempFile, { force: true });
+    const handle = await fs.open(tempFile, 'wx', sessionStat.mode & 0o777);
+    try {
+      let pendingSeparator = '';
+      await forEachLogLine(sessionFile, line => {
+        const repaired = repairTranscriptLine(line);
+        return handle.write(`${pendingSeparator}${repaired.text}`, null, 'utf8').then(() => {
+          pendingSeparator = '\n';
+        });
+      });
+      if (keepTrailingNewline) await handle.write('\n', null, 'utf8');
+    } finally {
+      await handle.close();
+    }
+    await fs.rename(tempFile, sessionFile);
+
     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 });

package/src/cleanup.mjs

@@ -39,6 +39,7 @@ import { isConfirmationYes, readConfirmationLine } from './confirmation.lib.mjs'
 import { classifyEntries, summarize, formatBytes, describeReason, buildActiveMatchers, DEFAULT_PROTECTED_NAMES, formatEntryContext, formatTaskSummary, DEFAULT_DOCKER_ISOLATION_CLEANUP_MODE, describeDockerIsolationReason, formatDockerIsolationContainerSummary, normalizeDockerIsolationCleanupMode, planDockerIsolationCleanup } from './cleanup.lib.mjs';
 import { getTempRoot, listTempEntries, getPathSize, readFolderGitInfo, listProcessHeldPaths, getActiveTasks, listSessionTasks, removePath, runSystemCleanup, collectProcessDebugReport, signalOrphanedAgentTrees, listDockerIsolationContainers, removeDockerContainer } from './cleanup.os.lib.mjs';
 import { formatProcessDebugReport } from './process-debug.lib.mjs';
+import { classifyAgentSnapshotStores, describeAgentSnapshotReason, getAgentDataHome } from './agent-snapshot-store.lib.mjs';
 import { setupStdioLogInterceptor } from './lib.mjs';
 import { sanitizeCredentialText } from './credential-sanitization-core.lib.mjs';
 
@@ -138,6 +139,11 @@ System / Ubuntu cleanup (opt-in):
   --system                    Shorthand for --apt --journal --npm
   --sudo                      Prefix package-manager commands with sudo
 
+Agent state cleanup (issue #2186):
+  --no-agent-snapshots        Do not reclaim orphaned @link-assistant/agent
+                              snapshot stores under
+                              $XDG_DATA_HOME/link-assistant-agent/snapshot/
+
 Docker isolation cleanup:
   --docker-isolation[=<mode>] Clean task containers named by session UUID
                               [default: ${DEFAULT_DOCKER_ISOLATION_CLEANUP_MODE}]
@@ -173,6 +179,7 @@ const options = {
   journal: hasFlag('--journal', '--system'),
   docker: hasFlag('--docker'),
   dockerIsolationMode: parseDockerIsolationMode(),
+  agentSnapshots: !hasFlag('--no-agent-snapshots'),
   npm: hasFlag('--npm', '--system'),
   sudo: hasFlag('--sudo'),
 };
@@ -371,18 +378,48 @@ async function main() {
     }
   }
 
-  await log(`\n📊 Summary: keep ${totals.keepCount} (${formatBytes(totals.keepBytes)}), remove ${totals.removeCount} (${formatBytes(totals.removeBytes)}), docker keep ${dockerIsolationPlan.keep.length}, docker remove ${dockerIsolationPlan.remove.length}`);
+  // Issue #2186: agent's snapshot stores live in the home directory, outside the
+  // tmp root everything above scans, and each one is a full copy of a
+  // repository. A store is only listed for removal when the worktree its project
+  // record points at is gone, so this can never disturb a live checkout.
+  let agentSnapshotPlan = { orphaned: [], keep: [] };
+  if (!options.agentSnapshots) {
+    await log('\n🗄️  Agent snapshot stores: disabled (--no-agent-snapshots)');
+  } else {
+    const agentDataHome = getAgentDataHome();
+    agentSnapshotPlan = await classifyAgentSnapshotStores({ dataHome: agentDataHome });
+    for (const item of [...agentSnapshotPlan.keep, ...agentSnapshotPlan.orphaned]) item.size = getPathSize(item.path);
+    const orphanBytes = agentSnapshotPlan.orphaned.reduce((total, item) => total + (item.size || 0), 0);
+    await log(`\n🗄️  Agent snapshot stores (${path.join(agentDataHome, 'snapshot')}):`);
+    if (agentSnapshotPlan.keep.length === 0 && agentSnapshotPlan.orphaned.length === 0) {
+      await log('   (none)');
+    } else {
+      await log('   KEPT:');
+      if (agentSnapshotPlan.keep.length === 0) await log('      (none)');
+      for (const item of agentSnapshotPlan.keep.sort((a, b) => (b.size || 0) - (a.size || 0))) {
+        await log(`      ${formatBytes(item.size).padStart(7)}  ${item.path}  — ${describeAgentSnapshotReason(item.reason)}${item.worktree ? ` (${item.worktree})` : ''}`);
+      }
+      await log(`   ${options.dryRun ? 'WOULD REMOVE' : 'TO REMOVE'} (${formatBytes(orphanBytes)}):`);
+      if (agentSnapshotPlan.orphaned.length === 0) await log('      (none)');
+      for (const item of agentSnapshotPlan.orphaned.sort((a, b) => (b.size || 0) - (a.size || 0))) {
+        await log(`      ${formatBytes(item.size).padStart(7)}  ${item.path}  — ${describeAgentSnapshotReason(item.reason)}${item.worktree ? ` (${item.worktree})` : ''}`);
+      }
+    }
+  }
+
+  await log(`\n📊 Summary: keep ${totals.keepCount} (${formatBytes(totals.keepBytes)}), remove ${totals.removeCount} (${formatBytes(totals.removeBytes)}), docker keep ${dockerIsolationPlan.keep.length}, docker remove ${dockerIsolationPlan.remove.length}, agent snapshots remove ${agentSnapshotPlan.orphaned.length}`);
 
   // 7. Execute deletion (unless dry-run).
   const hasTempRemovals = classified.remove.length > 0;
   const hasDockerRemovals = dockerIsolationPlan.remove.length > 0;
+  const hasAgentSnapshotRemovals = agentSnapshotPlan.orphaned.length > 0;
   if (options.dryRun) {
     await log('\n✅ Dry run complete. Re-run without --dry-run to delete.');
-  } else if (!hasTempRemovals && !hasDockerRemovals) {
+  } else if (!hasTempRemovals && !hasDockerRemovals && !hasAgentSnapshotRemovals) {
     await log('\n✅ Nothing to delete.');
   } else {
     if (!options.force) {
-      console.log(`\n⚠️  This will permanently delete ${classified.remove.length} entries (${formatBytes(totals.removeBytes)}) and remove ${dockerIsolationPlan.remove.length} Docker isolation containers.`);
+      console.log(`\n⚠️  This will permanently delete ${classified.remove.length} entries (${formatBytes(totals.removeBytes)}), ${agentSnapshotPlan.orphaned.length} orphaned agent snapshot stores and remove ${dockerIsolationPlan.remove.length} Docker isolation containers.`);
       console.log('Type "yes" to confirm, or Ctrl+C to cancel:');
       let answer;
       try {
@@ -414,6 +451,23 @@ async function main() {
       await log(`\n✅ Deleted ${deleted} entries${failed ? `, ${failed} failed` : ''}.`);
     }
 
+    if (hasAgentSnapshotRemovals) {
+      await log('\n🗄️  Removing orphaned agent snapshot stores...');
+      let deleted = 0;
+      let failed = 0;
+      for (const item of agentSnapshotPlan.orphaned) {
+        const ok = removePath(item.path);
+        if (ok) {
+          deleted++;
+          await vlog(`   removed ${item.path}`);
+        } else {
+          failed++;
+          await log(`   ⚠️  failed to remove ${item.path}`, { level: 'warn' });
+        }
+      }
+      await log(`\n✅ Deleted ${deleted} orphaned agent snapshot stores${failed ? `, ${failed} failed` : ''}.`);
+    }
+
     if (hasDockerRemovals) {
       await log('\n🐳 Removing Docker isolation containers...');
       let removed = 0;

package/src/codex.lib.mjs

@@ -49,10 +49,15 @@ import Decimal from 'decimal.js-light';
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 import { CODEX_CACHE_READ_USAGE_PATHS, CODEX_CACHE_WRITE_USAGE_PATHS, CODEX_MODEL_DIAGNOSTIC_PATHS, CODEX_REASONING_USAGE_PATHS, CODEX_USAGE_FIELD_NAMES, createCodexTokenFieldAvailability, getFirstObservedNumber, hasAnyObservedPath, hasOwnPath } from './codex.usage-fields.lib.mjs';
 const CODEX_LONG_CONTEXT_PRICE_THRESHOLD = 272000;
+// Issue #2189: ceiling for reading Codex's `--output-last-message` artifact. A
+// final assistant message is a few hundred kilobytes at most; anything larger is
+// a malfunction and must not be turned into an unbounded string.
+const CODEX_LAST_MESSAGE_MAX_BYTES = 1024 * 1024;
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
 // Issue #2175: diagnostic-line parsing lives in its own module to keep this file
 // under the 1350-line warning threshold.
 import { parseCodexDiagnosticLine, rebuildCodexSubSessionsFromCompactifications } from './codex.diagnostics.lib.mjs';
+import { readLogHeadText } from './log-bounded-read.lib.mjs'; // Issue #2189
 export const createCodexTokenUsage = requestedModelId => ({
   inputTokens: 0,
   outputTokens: 0,
@@ -891,7 +896,12 @@ export const executeCodexCommand = async params => {
       let lastMessageFromFile = null;
       let lastMessageReadError = null;
       try {
-        lastMessageFromFile = (await fs.readFile(lastMessageFile, 'utf8')).trim();
+        // Issue #2189: this file holds Codex's final assistant message, but its
+        // size is decided by the tool, not by us. Size it first so a runaway or
+        // corrupted artifact cannot become an unbounded string in a process that
+        // has just finished a long run.
+        const { size } = await fs.stat(lastMessageFile);
+        lastMessageFromFile = size > CODEX_LAST_MESSAGE_MAX_BYTES ? `${(await readLogHeadText(lastMessageFile, { maxBytes: CODEX_LAST_MESSAGE_MAX_BYTES })).trim()}\n…[last message truncated: ${size} bytes on disk, see ${lastMessageFile}]` : (await fs.readFile(lastMessageFile, 'utf8')).trim();
       } catch (readError) {
         lastMessageReadError = readError;
       }