claude-mem-lite 2.5.4 → 2.9.2

package/hook-update.mjs

@@ -0,0 +1,262 @@
+// claude-mem-lite: Auto-update via GitHub Releases
+// Checks for new versions on SessionStart, downloads and installs automatically.
+// Skips in dev mode (symlinked installs). Silent on network failure.
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, copyFileSync, readdirSync, existsSync, lstatSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { DB_DIR } from './schema.mjs';
+import { debugCatch, debugLog } from './utils.mjs';
+
+// ── Configuration ──────────────────────────────────────────
+const GITHUB_REPO = 'sdsrss/claude-mem-lite';
+const INSTALL_DIR = DB_DIR;  // ~/.claude-mem-lite/
+const STATE_FILE = join(INSTALL_DIR, 'runtime', 'update-state.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;       // 24 hours
+const FETCH_TIMEOUT_MS = 3000;                         // 3s network timeout
+const RATE_LIMIT_INTERVAL_MS = 6 * 60 * 60 * 1000;   // 6h if rate-limited
+
+// ── Main Entry ─────────────────────────────────────────────
+export async function checkForUpdate() {
+  try {
+    if (isDevMode() || process.env.CLAUDE_MEM_SKIP_UPDATE) return null;
+
+    const state = readState();
+    if (!shouldCheck(state)) {
+      // Return cached update info if previously detected
+      if (state.updateAvailable && state.latestVersion) {
+        return { updateAvailable: true, from: state.installedVersion, to: state.latestVersion };
+      }
+      return null;
+    }
+
+    const latest = await fetchLatestRelease();
+    if (!latest) {
+      saveState({ ...state, lastCheck: new Date().toISOString() });
+      return null;
+    }
+
+    const currentVersion = getCurrentVersion();
+    const hasUpdate = compareVersions(latest.version, currentVersion) > 0;
+
+    if (hasUpdate) {
+      debugLog('DEBUG', 'hook-update', `Update available: ${currentVersion} → ${latest.version}`);
+      const success = await downloadAndInstall(latest.tarballUrl);
+      const newState = {
+        lastCheck: new Date().toISOString(),
+        installedVersion: success ? latest.version : currentVersion,
+        latestVersion: latest.version,
+        updateAvailable: !success,
+        lastUpdate: success ? new Date().toISOString() : (state.lastUpdate || null),
+        rateLimited: false,
+      };
+      saveState(newState);
+
+      return {
+        updateAvailable: !success,
+        updated: success,
+        from: currentVersion,
+        to: latest.version,
+      };
+    }
+
+    // No update needed
+    saveState({
+      ...state,
+      lastCheck: new Date().toISOString(),
+      latestVersion: latest.version,
+      updateAvailable: false,
+      rateLimited: false,
+    });
+    return null;
+  } catch (err) {
+    debugCatch(err, 'checkForUpdate');
+    return null;
+  }
+}
+
+// ── Dev Mode Detection ─────────────────────────────────────
+function isDevMode() {
+  try {
+    const serverPath = join(INSTALL_DIR, 'server.mjs');
+    return existsSync(serverPath) && lstatSync(serverPath).isSymbolicLink();
+  } catch { return false; }
+}
+
+// ── Throttle ───────────────────────────────────────────────
+function shouldCheck(state) {
+  if (!state.lastCheck) return true;
+  const elapsed = Date.now() - new Date(state.lastCheck).getTime();
+  const interval = state.rateLimited ? RATE_LIMIT_INTERVAL_MS : CHECK_INTERVAL_MS;
+  return elapsed >= interval;
+}
+
+// ── GitHub API ─────────────────────────────────────────────
+// Try releases/latest first, fallback to tags (some repos only use tags)
+async function fetchLatestRelease() {
+  const headers = {
+    'Accept': 'application/vnd.github+json',
+    'User-Agent': 'claude-mem-lite-updater/1.0',
+  };
+
+  // Attempt 1: GitHub Releases API
+  const result = await fetchWithTimeout(
+    `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`,
+    headers,
+  );
+  if (result === 'rate-limited') return null;
+  if (result) {
+    return {
+      version: result.tag_name.replace(/^v/, ''),
+      tarballUrl: result.tarball_url,
+      releaseUrl: result.html_url,
+    };
+  }
+
+  // Attempt 2: Tags API fallback (for repos without formal releases)
+  const tags = await fetchWithTimeout(
+    `https://api.github.com/repos/${GITHUB_REPO}/tags?per_page=1`,
+    headers,
+  );
+  if (tags === 'rate-limited') return null;
+  if (Array.isArray(tags) && tags.length > 0) {
+    const tag = tags[0];
+    return {
+      version: tag.name.replace(/^v/, ''),
+      tarballUrl: `https://api.github.com/repos/${GITHUB_REPO}/tarball/${tag.name}`,
+      releaseUrl: `https://github.com/${GITHUB_REPO}/releases/tag/${tag.name}`,
+    };
+  }
+
+  return null;
+}
+
+async function fetchWithTimeout(url, headers) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { signal: controller.signal, headers });
+    if (res.status === 403) {
+      const state = readState();
+      saveState({ ...state, rateLimited: true });
+      debugLog('DEBUG', 'hook-update', 'GitHub API rate limited, extending interval');
+      return 'rate-limited';
+    }
+    if (!res.ok) return null;
+    return await res.json();
+  } catch { return null; }
+  finally { clearTimeout(timeout); }
+}
+
+// ── Version Comparison (semver) ────────────────────────────
+export function compareVersions(a, b) {
+  const pa = String(a).replace(/^v/, '').split('.').map(Number);
+  const pb = String(b).replace(/^v/, '').split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+export function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(INSTALL_DIR, 'package.json'), 'utf8'));
+    return pkg.version;
+  } catch { return '0.0.0'; }
+}
+
+// ── Source files to copy (must match install.mjs SOURCE_FILES) ──
+const SOURCE_FILES = [
+  'server.mjs', 'server-internals.mjs', 'tool-schemas.mjs',
+  'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs',
+  'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs', 'hook-handoff.mjs', 'hook-update.mjs',
+  'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'skill.md',
+  'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
+  'registry-retriever.mjs', 'resource-discovery.mjs',
+  'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-workflow.mjs',
+  'install.mjs',
+];
+
+// ── Download & Install ─────────────────────────────────────
+// Direct file copy instead of running old install.mjs (avoids symlink overwrite in dev)
+async function downloadAndInstall(tarballUrl) {
+  const tmpDir = join(tmpdir(), `claude-mem-lite-update-${Date.now()}`);
+  try {
+    mkdirSync(tmpDir, { recursive: true });
+
+    // Download tarball via curl (available on all supported platforms)
+    // Validate URL to prevent command injection via crafted tarball URLs
+    if (!/^https:\/\/[a-zA-Z0-9./-]+$/.test(tarballUrl)) {
+      debugLog('WARN', 'hook-update', `Rejected suspicious tarball URL: ${tarballUrl}`);
+      return false;
+    }
+    execSync(
+      `curl -sL -H "Accept: application/vnd.github+json" "${tarballUrl}" | tar xz -C "${tmpDir}" --strip-components=1`,
+      { timeout: 30000, stdio: 'pipe' }
+    );
+
+    // Direct copy: overwrite source files in INSTALL_DIR
+    // Safer than running old install.mjs which may not respect CLAUDE_MEM_DIR
+    let copied = 0;
+    for (const f of SOURCE_FILES) {
+      const src = join(tmpDir, f);
+      const dest = join(INSTALL_DIR, f);
+      if (existsSync(src)) {
+        copyFileSync(src, dest);
+        copied++;
+      }
+    }
+
+    // Copy scripts/ directory if present
+    const srcScripts = join(tmpDir, 'scripts');
+    if (existsSync(srcScripts)) {
+      const destScripts = join(INSTALL_DIR, 'scripts');
+      mkdirSync(destScripts, { recursive: true });
+      for (const f of readdirSync(srcScripts)) {
+        copyFileSync(join(srcScripts, f), join(destScripts, f));
+      }
+    }
+
+    // Run npm install for dependencies (skip if node_modules is a symlink = dev mode)
+    const nmPath = join(INSTALL_DIR, 'node_modules');
+    if (!existsSync(nmPath) || !lstatSync(nmPath).isSymbolicLink()) {
+      try {
+        execSync('npm install --omit=dev', {
+          cwd: INSTALL_DIR,
+          timeout: 60000,
+          stdio: 'pipe',
+        });
+      } catch (err) {
+        debugCatch(err, 'downloadAndInstall-npm');
+        // Non-fatal: old node_modules may still work
+      }
+    }
+
+    debugLog('DEBUG', 'hook-update', `Auto-update: ${copied} files copied`);
+    return true;
+  } catch (err) {
+    debugCatch(err, 'downloadAndInstall');
+    return false;
+  } finally {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+// ── State Persistence ──────────────────────────────────────
+function readState() {
+  try {
+    return JSON.parse(readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveState(state) {
+  try {
+    const dir = join(INSTALL_DIR, 'runtime');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch {}
+}

package/hook.mjs

@@ -11,7 +11,7 @@ import {
   truncate, typeIcon, inferProject, detectBashSignificance,
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
   makeEntryDesc, scrubSecrets, EDIT_TOOLS, debugCatch, debugLog, fmtTime,
-  COMPRESSED_AUTO,
+  COMPRESSED_AUTO, COMPRESSED_PENDING_PURGE, isoWeekKey,
 } from './utils.mjs';
 import {
   readEpisodeRaw, episodeFile,
@@ -20,7 +20,7 @@ import {
   writePendingEntry, mergePendingEntries, episodeHasSignificantContent,
 } from './hook-episode.mjs';
 import { selectWithTokenBudget, updateClaudeMd, buildSummaryLines } from './hook-context.mjs';
-import { dispatchOnSessionStart, dispatchOnPreToolUse, dispatchOnUserPrompt } from './dispatch.mjs';
+import { dispatchOnPreToolUse, dispatchOnUserPrompt } from './dispatch.mjs';
 import { collectFeedback } from './dispatch-feedback.mjs';
 import {
   RUNTIME_DIR, EPISODE_BUFFER_SIZE, EPISODE_TIME_GAP_MS,
@@ -29,10 +29,12 @@ import {
   sessionFile, getSessionId, createSessionId, openDb, getRegistryDb,
   closeRegistryDb, spawnBackground, appendToolEvent, readAndClearToolEvents,
   resetInjectionBudget, hasInjectionBudget, incrementInjection,
+  cachePrevContext, readAndClearPrevContext,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
 import { searchRelevantMemories, recallForFile } from './hook-memory.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, extractUnfinishedSummary } from './hook-handoff.mjs';
+import { checkForUpdate } from './hook-update.mjs';
 
 // Prevent recursive hooks from background claude -p calls
 // Background workers (llm-episode, llm-summary, resource-scan) are exempt — they're ours
@@ -150,7 +152,7 @@ async function handlePostToolUse() {
   if (tool_name.startsWith('mem_') || tool_name.startsWith('mcp__mem__') || tool_name.startsWith('mcp__plugin_claude-mem-lite')) return;
   if (tool_name.startsWith('mcp__sequential') || tool_name.startsWith('mcp__plugin_context7')) return;
 
-  const resp = typeof tool_response === 'string' ? tool_response : JSON.stringify(tool_response || '');
+  const resp = normalizeToolResponse(tool_response);
   if (!resp || resp.length < 10) return;
 
   const toolInput = typeof tool_input === 'string' ? tryParseJson(tool_input) : (tool_input || {});
@@ -354,6 +356,30 @@ async function handleStop() {
       // Save handoff snapshot for cross-session continuity
       try { buildAndSaveHandoff(db, sessionId, project, 'exit', episodeSnapshot); }
       catch (e) { debugCatch(e, 'handleStop-handoff'); }
+
+      // Fast summary baseline — ensures summary exists even if background LLM fails
+      try {
+        const firstPrompt = db.prepare(`
+          SELECT prompt_text FROM user_prompts
+          WHERE content_session_id = ?
+          ORDER BY prompt_number ASC LIMIT 1
+        `).get(sessionId);
+        const recentObs = db.prepare(`
+          SELECT title FROM observations
+          WHERE memory_session_id = ? AND COALESCE(compressed_into, 0) = 0
+          ORDER BY created_at_epoch DESC LIMIT 5
+        `).all(sessionId);
+        const fastRequest = truncate(firstPrompt?.prompt_text || '', 200);
+        const fastCompleted = recentObs.map(o => o.title).filter(Boolean).join('; ');
+        if (fastRequest || fastCompleted) {
+          const now = new Date();
+          db.prepare(`
+            INSERT INTO session_summaries
+            (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
+            VALUES (?, ?, ?, '', '', ?, '', '', '[]', '[]', 'fast', ?, ?)
+          `).run(sessionId, project, fastRequest, truncate(fastCompleted, 300), now.toISOString(), now.getTime());
+        }
+      } catch (e) { debugCatch(e, 'handleStop-fast-summary'); }
     } finally {
       db.close();
     }
@@ -365,12 +391,9 @@ async function handleStop() {
   // Always clear event file to prevent stale events accumulating if registry DB is unavailable.
   try {
     const sessionEvents = readAndClearToolEvents();
-    // Skip feedback for zero-interaction sessions (no tool events = no meaningful signal)
-    if (sessionEvents.length > 0) {
-      const rdb = getRegistryDb();
-      if (rdb) {
-        await collectFeedback(rdb, sessionId, sessionEvents);
-      }
+    const rdb = getRegistryDb();
+    if (rdb) {
+      await collectFeedback(rdb, sessionId, sessionEvents);
     }
   } catch (e) { debugCatch(e, 'handleStop-feedback'); }
 
@@ -464,6 +487,80 @@ async function handleSessionStart() {
       }
     })();
 
+    // Auto-purge: delete stale observations daily (COMPRESSED_PENDING_PURGE, 7-day retention)
+    const maintainFile = join(RUNTIME_DIR, 'last-auto-maintain.json');
+    let shouldMaintain = true;
+    try {
+      const last = JSON.parse(readFileSync(maintainFile, 'utf8'));
+      if (Date.now() - last.epoch < 24 * 3600000) shouldMaintain = false;
+    } catch {}
+    if (shouldMaintain) {
+      try {
+        const purged = db.prepare(`
+          DELETE FROM observations WHERE compressed_into = ${COMPRESSED_PENDING_PURGE}
+            AND created_at_epoch < ?
+        `).run(Date.now() - 7 * 86400000);
+        if (purged.changes > 0) {
+          debugLog('DEBUG', 'session-start', `auto-purged ${purged.changes} stale observations`);
+        }
+        // Auto-compress: group old marked observations into weekly summaries
+        const compressCutoff = Date.now() - 60 * 86400000; // 60 days
+        const compressCandidates = db.prepare(`
+          SELECT id, project, type, title, created_at_epoch
+          FROM observations
+          WHERE COALESCE(importance, 1) = 1 AND COALESCE(access_count, 0) = 0
+            AND created_at_epoch < ?
+            AND (compressed_into IS NULL OR compressed_into = ${COMPRESSED_AUTO})
+          ORDER BY project, created_at_epoch
+        `).all(compressCutoff);
+        if (compressCandidates.length >= 3) {
+          const groups = new Map();
+          for (const c of compressCandidates) {
+            const key = `${c.project}::${isoWeekKey(c.created_at_epoch)}`;
+            if (!groups.has(key)) groups.set(key, []);
+            groups.get(key).push(c);
+          }
+          // Transact each group to prevent orphan summaries on crash
+          const compressGroup = db.transaction((proj, obs) => {
+            const types = {};
+            for (const o of obs) types[o.type] = (types[o.type] || 0) + 1;
+            const dominantType = Object.entries(types).sort((a, b) => b[1] - a[1])[0][0];
+            const title = `Weekly summary: ${obs.length} ${dominantType} observations`;
+            const narrative = obs.map(o => `- ${o.title || '(untitled)'}`).join('\n');
+            const sortedEpochs = obs.map(o => o.created_at_epoch).sort((a, b) => a - b);
+            const medianEpoch = sortedEpochs[Math.floor(sortedEpochs.length / 2)];
+            const sessionId = `compress-${proj}`;
+            const now = new Date();
+            db.prepare(`INSERT OR IGNORE INTO sdk_sessions
+              (content_session_id, memory_session_id, project, started_at, started_at_epoch, status)
+              VALUES (?,?,?,?,?,'active')`
+            ).run(sessionId, sessionId, proj, now.toISOString(), now.getTime());
+            const summaryResult = db.prepare(`INSERT INTO observations
+              (memory_session_id, project, text, type, title, subtitle, narrative, concepts, facts,
+               files_read, files_modified, importance, created_at, created_at_epoch)
+              VALUES (?,?,?,?,?,'',?,'','','[]','[]',2,?,?)`
+            ).run(sessionId, proj, narrative, dominantType, title, narrative, new Date(medianEpoch).toISOString(), medianEpoch);
+            const summaryId = Number(summaryResult.lastInsertRowid);
+            const obsIds = obs.map(o => o.id);
+            db.prepare(`UPDATE observations SET compressed_into = ? WHERE id IN (${obsIds.map(() => '?').join(',')})`)
+              .run(summaryId, ...obsIds);
+            return obs.length;
+          });
+          let totalCompressed = 0;
+          for (const [key, obs] of groups) {
+            if (obs.length < 3) continue;
+            const [proj] = key.split('::');
+            totalCompressed += compressGroup(proj, obs);
+          }
+          if (totalCompressed > 0) {
+            debugLog('DEBUG', 'session-start', `auto-compressed ${totalCompressed} observations into weekly summaries`);
+          }
+        }
+
+        writeFileSync(maintainFile, JSON.stringify({ epoch: Date.now() }));
+      } catch (e) { debugCatch(e, 'auto-maintain'); }
+    }
+
     // ── Non-transactional operations (side effects, background work) ──
 
     // Shared clear handoff reference — queried once, used by fast summary + working state
@@ -668,7 +765,8 @@ async function handleSessionStart() {
       handoffLines.push('### Working State (from /clear)');
       if (prevClearHandoff.working_on) handoffLines.push(`- Working on: ${truncate(prevClearHandoff.working_on, 200)}`);
       if (prevClearHandoff.unfinished) {
-        handoffLines.push(`- Unfinished: ${truncate(extractUnfinishedSummary(prevClearHandoff.unfinished), 200)}`);
+        const pendingSummary = extractUnfinishedSummary(prevClearHandoff.unfinished);
+        if (pendingSummary) handoffLines.push(`- Unfinished: ${truncate(pendingSummary, 200)}`);
       }
       if (prevClearHandoff.key_files) {
         try {
@@ -701,20 +799,13 @@ async function handleSessionStart() {
     // CLAUDE.md: slim (summary + handoff state — observations already in stdout)
     updateClaudeMd([...summaryLines, ...handoffLines].join('\n'));
 
-    // Dispatch: recommend skill/agent based on session context
-    try {
-      const rdb = getRegistryDb();
-      if (rdb && hasInjectionBudget()) {
-        // Build prompt context with fallbacks: next_steps → request → completed (empty = no dispatch)
-        const promptCtx = latestSummary?.next_steps || latestSummary?.request || latestSummary?.completed || '';
-        const hasHandoff = !!prevSessionId;  // prevSessionId set when /clear or rapid restart detected
-        const dispatchResult = await dispatchOnSessionStart(rdb, promptCtx, sessionId, { hasHandoff });
-        if (dispatchResult) {
-          process.stdout.write(dispatchResult + '\n');
-          incrementInjection();
-        }
-      }
-    } catch (e) { debugCatch(e, 'handleSessionStart-dispatch'); }
+    // Cache previous session context for user-prompt dispatch enrichment.
+    // Session-start has project history but zero user intent — dispatching here
+    // produced 0/119 adoption. Instead, cache next_steps and combine with
+    // the first user-prompt for richer signal (see handleUserPrompt).
+    if (latestSummary?.next_steps) {
+      cachePrevContext(latestSummary.next_steps);
+    }
 
     // Background rescan: detect changed/new managed resources since last scan.
     // TTL-based (1h) — avoids redundant filesystem scans on every session.
@@ -723,6 +814,16 @@ async function handleSessionStart() {
       spawnBackground('resource-scan');
     }
 
+    // Auto-update check (24h throttle, 3s timeout, silent on failure)
+    try {
+      const updateResult = await checkForUpdate();
+      if (updateResult?.updated) {
+        process.stdout.write(`\n🔄 claude-mem-lite: v${updateResult.from} → v${updateResult.to} updated\n`);
+      } else if (updateResult?.updateAvailable) {
+        process.stdout.write(`\n📦 claude-mem-lite: v${updateResult.to} available (current: v${updateResult.from})\n`);
+      }
+    } catch (e) { debugCatch(e, 'session-start-update'); }
+
   } finally {
     db.close();
   }
@@ -860,13 +961,13 @@ async function handleUserPrompt() {
 
   // Dispatch: recommend skill/agent based on user's actual prompt.
   // This is the ideal dispatch point — fires when the user submits their prompt,
-  // before Claude starts working. SessionStart uses stale next_steps from previous session;
-  // PreToolUse fires too late (after Claude committed to an approach via read-only tools).
-  // Cooldown + session dedup (invocations table) prevents double-recommending with SessionStart.
+  // before Claude starts working. Previous session's next_steps (cached at session-start)
+  // enriches the signal when available, combining project history with user intent.
   try {
     const rdb = getRegistryDb();
     if (rdb && hasInjectionBudget()) {
-      const result = await dispatchOnUserPrompt(rdb, promptText, sessionId);
+      const prevContext = readAndClearPrevContext();
+      const result = await dispatchOnUserPrompt(rdb, promptText, sessionId, { prevContext });
       if (result) {
         process.stdout.write(result + '\n');
         incrementInjection();
@@ -971,6 +1072,42 @@ function tryParseJson(str) {
   try { return JSON.parse(str); } catch { return {}; }
 }
 
+// Strip ANSI escape codes and extract readable text from tool responses.
+// Bash responses come as {stdout, stderr} objects or JSON strings — extract the text content
+// instead of producing noisy `{"stdout":"\u001b[1m..."}` in episode descriptions.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\u001b\[[0-9;]*[a-zA-Z]/g;
+function extractStdio(obj) {
+  if (!obj || typeof obj !== 'object') return null;
+  const { stdout, stderr } = obj;
+  if (typeof stdout === 'string' || typeof stderr === 'string') {
+    const parts = [];
+    if (stdout) parts.push(stdout);
+    if (stderr) parts.push(stderr);
+    return parts.join('\n');
+  }
+  return null;
+}
+function normalizeToolResponse(toolResponse) {
+  if (typeof toolResponse === 'string') {
+    // Try to parse JSON strings like '{"stdout":"...","stderr":"..."}'
+    if (toolResponse.startsWith('{"stdout"') || toolResponse.startsWith('{"stderr"')) {
+      try {
+        const parsed = JSON.parse(toolResponse);
+        const extracted = extractStdio(parsed);
+        if (extracted) return extracted.replace(ANSI_RE, '');
+      } catch {}
+    }
+    return toolResponse.replace(ANSI_RE, '');
+  }
+  if (toolResponse && typeof toolResponse === 'object') {
+    const extracted = extractStdio(toolResponse);
+    if (extracted) return extracted.replace(ANSI_RE, '');
+    return JSON.stringify(toolResponse).replace(ANSI_RE, '');
+  }
+  return '';
+}
+
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 try {