codemini-cli 0.4.1 → 0.4.3

package/src/commands/skill.js

@@ -3,7 +3,9 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { copyRecursive } from '../core/fs-utils.js';
-import { getSkillsDir } from '../core/paths.js';
+import { loadConfig, saveConfig } from '../core/config-store.js';
+import { loadCommandsAndSkills } from '../core/command-loader.js';
+import { getProjectSkillsDir, getSkillsDir } from '../core/paths.js';
 import {
   computeFileSha256,
   readSkillRegistry,
@@ -11,17 +13,85 @@ import {
   writeSkillRegistry
 } from '../core/skill-registry.js';
 
-async function listSkillEntries() {
-  const registry = await readSkillRegistry();
-  const byName = new Map((registry.skills || []).map((s) => [s.name, s]));
-  await fs.mkdir(getSkillsDir(), { recursive: true });
-  const entries = await fs.readdir(getSkillsDir(), { withFileTypes: true });
-  const names = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
-  return names.map((name) => byName.get(name) || { name, version: 'unknown', enabled: true });
+function parseScopeArgs(args = [], { defaultScope = 'project', allowAll = false } = {}) {
+  let scope = defaultScope;
+  const rest = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || '');
+    if (arg === '--global') {
+      scope = 'global';
+      continue;
+    }
+    if (arg === '--project') {
+      scope = 'project';
+      continue;
+    }
+    if (arg === '--scope') {
+      const next = String(args[index + 1] || '').toLowerCase();
+      if (['project', 'global', ...(allowAll ? ['all', 'builtin'] : [])].includes(next)) {
+        scope = next;
+        index += 1;
+        continue;
+      }
+    }
+    if (arg.startsWith('--scope=')) {
+      const value = arg.slice('--scope='.length).toLowerCase();
+      if (['project', 'global', ...(allowAll ? ['all', 'builtin'] : [])].includes(value)) {
+        scope = value;
+        continue;
+      }
+    }
+    rest.push(arg);
+  }
+  return { scope, rest };
+}
+
+function baseDirForScope(scope, cwd = process.cwd()) {
+  return scope === 'global' ? getSkillsDir() : getProjectSkillsDir(cwd);
+}
+
+function scopeFromSource(source = '') {
+  if (source === 'bundled-skill') return 'builtin';
+  if (source === 'project-skill') return 'project';
+  if (source === 'global-skill' || source === 'registry-skill') return 'global';
+  return source || 'unknown';
+}
+
+async function setSkillEnabledConfig(name, enabled) {
+  const config = await loadConfig();
+  config.skills = config.skills || {};
+  config.skills.enabled = config.skills.enabled || {};
+  config.skills.enabled[name] = enabled;
+  await saveConfig(config);
 }
 
-async function readSkillMeta(name) {
-  const dir = path.join(getSkillsDir(), name);
+async function listSkillEntries({ scope = 'all', cwd = process.cwd() } = {}) {
+  const commands = await loadCommandsAndSkills(cwd);
+  const config = await loadConfig();
+  const entries = [];
+  for (const command of commands.values()) {
+    if (command.metadata?.type !== 'skill') continue;
+    const itemScope = scopeFromSource(command.source);
+    if (scope !== 'all' && itemScope !== scope) continue;
+    entries.push({
+      name: command.name,
+      version: command.metadata?.version || '0.0.0',
+      description: command.metadata?.description || '',
+      scope: itemScope,
+      path: command.path,
+      enabled: itemScope === 'builtin' ? true : config.skills?.enabled?.[command.name] !== false
+    });
+  }
+  return entries.sort((a, b) => `${a.scope}:${a.name}`.localeCompare(`${b.scope}:${b.name}`));
+}
+
+async function readSkillMeta(name, { scope = 'all', cwd = process.cwd() } = {}) {
+  const entries = await listSkillEntries({ scope, cwd });
+  const found = entries.find((item) => item.name === name);
+  if (!found) {
+    return { exists: false, path: '', preview: '', manifest: null };
+  }
+  const dir = path.dirname(found.path);
   const manifestPath = path.join(dir, 'manifest.json');
   let manifest = null;
   try {
@@ -30,13 +100,13 @@ async function readSkillMeta(name) {
     manifest = null;
   }
   const entryFile = manifest?.entry || 'SKILL.md';
-  const skillPath = path.join(dir, entryFile);
+  const skillPath = found.path || path.join(dir, entryFile);
   try {
     const content = await fs.readFile(skillPath, 'utf8');
     const firstLines = content.split('\n').slice(0, 20).join('\n');
-    return { exists: true, path: skillPath, preview: firstLines, manifest };
+    return { exists: true, path: skillPath, preview: firstLines, manifest, scope: found.scope };
   } catch {
-    return { exists: false, path: skillPath, preview: '', manifest };
+    return { exists: false, path: skillPath, preview: '', manifest, scope: found.scope };
   }
 }
 
@@ -104,11 +174,15 @@ async function resolveSkillSourceDir(sourcePath) {
   throw new Error('skill install supports <skill-dir>, <SKILL.md>, or <skill.tgz>');
 }
 
-async function installSkill(sourcePath) {
+async function installSkill(sourcePath, { scope = 'project', cwd = process.cwd() } = {}) {
   const resolved = await resolveSkillSourceDir(sourcePath);
   const manifest = await readManifestSafe(resolved.dir);
   const folderName = manifest?.name || path.basename(resolved.dir);
-  const targetDir = path.join(getSkillsDir(), folderName);
+  const bundled = (await listSkillEntries({ scope: 'builtin', cwd })).find((item) => item.name === folderName);
+  if (bundled) {
+    throw new Error(`cannot install over builtin skill: ${folderName}`);
+  }
+  const targetDir = path.join(baseDirForScope(scope, cwd), folderName);
   await fs.rm(targetDir, { recursive: true, force: true });
   await copyRecursive(resolved.dir, targetDir);
 
@@ -117,16 +191,19 @@ async function installSkill(sourcePath) {
   await fs.access(entryPath);
 
   const hash = await computeFileSha256(entryPath);
-  await upsertSkillRegistryEntry(undefined, {
-    name: folderName,
-    version: manifest?.version || '0.0.0',
-    description: manifest?.description || '',
-    enabled: true,
-    source: sourcePath,
-    entryFile,
-    sha256: hash,
-    installedAt: new Date().toISOString()
-  });
+  if (scope === 'global') {
+    await upsertSkillRegistryEntry(undefined, {
+      name: folderName,
+      version: manifest?.version || '0.0.0',
+      description: manifest?.description || '',
+      enabled: true,
+      source: sourcePath,
+      entryFile,
+      sha256: hash,
+      installedAt: new Date().toISOString()
+    });
+  }
+  await setSkillEnabledConfig(folderName, true);
 
   if (resolved.cleanupDir) {
     await fs.rm(resolved.cleanupDir, { recursive: true, force: true });
@@ -135,19 +212,28 @@ async function installSkill(sourcePath) {
   return folderName;
 }
 
-async function setEnabled(name, enabled) {
+async function setEnabled(name, enabled, { cwd = process.cwd() } = {}) {
+  const entries = await listSkillEntries({ scope: 'all', cwd });
+  const found = entries.find((item) => item.name === name);
+  if (!found) {
+    throw new Error(`skill not found: ${name}`);
+  }
+  if (found.scope === 'builtin') {
+    throw new Error(`builtin skill cannot be ${enabled ? 'enabled' : 'disabled'}: ${name}`);
+  }
+  await setSkillEnabledConfig(name, enabled);
   const registry = await readSkillRegistry();
   const idx = registry.skills.findIndex((s) => s.name === name);
-  if (idx === -1) {
-    throw new Error(`skill not found: ${name}`);
+  if (idx !== -1) {
+    registry.skills[idx].enabled = enabled;
+    await writeSkillRegistry(undefined, registry);
   }
-  registry.skills[idx].enabled = enabled;
-  await writeSkillRegistry(undefined, registry);
 }
 
-async function reindexSkills() {
-  await fs.mkdir(getSkillsDir(), { recursive: true });
-  const entries = await fs.readdir(getSkillsDir(), { withFileTypes: true });
+async function reindexSkills({ scope = 'global', cwd = process.cwd() } = {}) {
+  const baseDir = baseDirForScope(scope, cwd);
+  await fs.mkdir(baseDir, { recursive: true });
+  const entries = await fs.readdir(baseDir, { withFileTypes: true });
   const registry = await readSkillRegistry();
   const byName = new Map((registry.skills || []).map((s) => [s.name, s]));
   const rebuilt = [];
@@ -155,7 +241,7 @@ async function reindexSkills() {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const name = entry.name;
-    const dir = path.join(getSkillsDir(), name);
+    const dir = path.join(baseDir, name);
     const manifest = await readManifestSafe(dir);
     const entryFile = manifest?.entry || 'SKILL.md';
     const entryPath = path.join(dir, entryFile);
@@ -178,22 +264,24 @@ async function reindexSkills() {
     });
   }
 
-  await writeSkillRegistry(undefined, {
-    version: 1,
-    skills: rebuilt
-  });
+  if (scope === 'global') {
+    await writeSkillRegistry(undefined, {
+      version: 1,
+      skills: rebuilt
+    });
+  }
 
   return rebuilt.length;
 }
 
 function usage() {
   console.log(`Usage:
-  codemini skill list
-  codemini skill install <path>
+  codemini skill list [--scope=all|project|global|builtin]
+  codemini skill install [--scope=project|global] <path>
   codemini skill enable <name>
   codemini skill disable <name>
-  codemini skill inspect <name>
-  codemini skill reindex`);
+  codemini skill inspect [--scope=all|project|global|builtin] <name>
+  codemini skill reindex [--scope=project|global]`);
 }
 
 export async function handleSkill(args) {
@@ -204,26 +292,27 @@ export async function handleSkill(args) {
   }
 
   if (sub === 'list') {
-    const entries = await listSkillEntries();
+    const { scope } = parseScopeArgs(rest, { defaultScope: 'all', allowAll: true });
+    const entries = await listSkillEntries({ scope });
     if (entries.length === 0) {
       console.log('No installed skills');
       return;
     }
     for (const item of entries) {
-      const state = item.enabled !== false ? 'enabled' : 'disabled';
-      console.log(`${item.name}@${item.version || '0.0.0'} (${state})`);
+      const state = item.scope === 'builtin' ? 'builtin/default' : (item.enabled !== false ? 'enabled' : 'disabled');
+      console.log(`${item.name}@${item.version || '0.0.0'} [${item.scope}] (${state})`);
     }
     return;
   }
 
   if (sub === 'install') {
-    const sourcePath = rest[0];
+    const { scope, rest: positional } = parseScopeArgs(rest, { defaultScope: 'project' });
+    const sourcePath = positional[0];
     if (!sourcePath) {
       throw new Error('skill install requires <path>');
     }
-    const installedName = await installSkill(sourcePath);
-    await setEnabled(installedName, true);
-    console.log(`Installed skill: ${installedName}`);
+    const installedName = await installSkill(sourcePath, { scope });
+    console.log(`Installed skill: ${installedName} (${scope})`);
     return;
   }
 
@@ -238,25 +327,28 @@ export async function handleSkill(args) {
   }
 
   if (sub === 'inspect') {
-    const name = rest[0];
+    const { scope, rest: positional } = parseScopeArgs(rest, { defaultScope: 'all', allowAll: true });
+    const name = positional[0];
     if (!name) {
       throw new Error('skill inspect requires <name>');
     }
-    const meta = await readSkillMeta(name);
+    const meta = await readSkillMeta(name, { scope });
     if (!meta.exists) {
       throw new Error(`skill not found: ${name}`);
     }
     if (meta.manifest) {
       console.log(`Manifest: ${JSON.stringify(meta.manifest, null, 2)}\n`);
     }
+    console.log(`Scope: ${meta.scope}\n`);
     console.log(`Path: ${meta.path}\n`);
     console.log(meta.preview);
     return;
   }
 
   if (sub === 'reindex') {
-    const count = await reindexSkills();
-    console.log(`Reindexed skills: ${count}`);
+    const { scope } = parseScopeArgs(rest, { defaultScope: 'global' });
+    const count = await reindexSkills({ scope });
+    console.log(`Reindexed skills: ${count} (${scope})`);
     return;
   }
 

package/src/core/agent-loop.js

@@ -1,12 +1,10 @@
-import os from 'node:os';
 import path from 'node:path';
-import fs from 'node:fs/promises';
-import { BoundedCache } from './bounded-cache.js';
 import { trimInline as _trimInline, normalizePath } from './string-utils.js';
 import { captureToInbox, listInbox } from './memory-store.js';
 import { requiresApprovalEvaluation } from './command-risk.js';
 import { getToolOutputSanitizeOptions, sanitizeTextForModel } from './tool-output.js';
 import { normalizeToolArguments } from './tool-args.js';
+import { storeResultIfNeeded, summarizeToolResult } from './tool-result-store.js';
 
 /**
  * 安全解析 JSON 字符串。
@@ -162,107 +160,6 @@ function compactToolResult(result, toolName, args, maxChars = 12000) {
   return clipToolResult(obj, Math.min(maxChars, 4000));
 }
 
-// ─── P0: Large result disk store ─────────────────────────────────────
-
-const TOOL_RESULT_DISK_THRESHOLD = 6000;
-const PREVIEW_SIZE_BYTES = 2000;
-const TOOL_RESULTS_SUBDIR = 'tool-results';
-
-let currentResultDir = null;
-let resultDirReady = false;
-const storedResults = new BoundedCache({
-  maxSize: 64,
-  ttlMs: 30 * 60 * 1000,
-  onEvict(key, value) {
-    if (value?.filePath) {
-      fs.unlink(value.filePath).catch(() => {});
-    }
-  }
-}); // callId -> { filePath, summary }
-const readCache = new BoundedCache({ maxSize: 128, ttlMs: 10 * 60 * 1000 });   // "path:startLine:endLine:mtimeMs" -> true
-
-function generatePreview(content) {
-  if (content.length <= PREVIEW_SIZE_BYTES) {
-    return { preview: content, hasMore: false };
-  }
-  const truncated = content.slice(0, PREVIEW_SIZE_BYTES);
-  const lastNewline = truncated.lastIndexOf('\n');
-  const cutPoint = lastNewline > PREVIEW_SIZE_BYTES * 0.5 ? lastNewline : PREVIEW_SIZE_BYTES;
-  return { preview: content.slice(0, cutPoint), hasMore: true };
-}
-
-function formatFileSize(chars) {
-  if (chars < 1024) return `${chars} B`;
-  return `${(chars / 1024).toFixed(1)} KB`;
-}
-
-export function setResultDir(dir) {
-  currentResultDir = dir ? path.join(dir, TOOL_RESULTS_SUBDIR) : null;
-  resultDirReady = false;
-}
-
-async function ensureResultDir() {
-  if (!currentResultDir) return false;
-  if (!resultDirReady) {
-    await fs.mkdir(currentResultDir, { recursive: true });
-    resultDirReady = true;
-  }
-  return true;
-}
-
-async function storeResultIfNeeded(callId, formattedContent, rawResult) {
-  if (formattedContent.length <= TOOL_RESULT_DISK_THRESHOLD) {
-    return formattedContent;
-  }
-  try {
-    const ready = await ensureResultDir();
-    const dir = ready ? currentResultDir : path.join(os.tmpdir(), 'codemini-results');
-    if (!resultDirReady && dir === currentResultDir) {
-      await fs.mkdir(dir, { recursive: true });
-    } else if (!resultDirReady) {
-      await fs.mkdir(dir, { recursive: true });
-    }
-    const filePath = path.join(dir, `${callId}.txt`);
-    const payload = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult, null, 2);
-    await fs.writeFile(filePath, payload, 'utf-8');
-    const summary = summarizeToolResult(rawResult);
-    const { preview, hasMore } = generatePreview(payload);
-    storedResults.set(callId, { filePath, summary });
-
-    return `<persisted-output>
-Output too large (${formatFileSize(payload.length)}). Full output saved to: ${filePath}
-
-Preview (first ${formatFileSize(PREVIEW_SIZE_BYTES)}):
-${preview}${hasMore ? '\n...' : ''}
-
-Summary: ${summary}
-</persisted-output>`;
-  } catch {
-    return formattedContent;
-  }
-}
-
-export function clearResultStore() {
-  const files = [];
-  for (const [, val] of storedResults.entries()) {
-    files.push(val.filePath);
-  }
-  storedResults.clear();
-  readCache.clear();
-  return Promise.allSettled(files.map((f) => fs.unlink(f).catch(() => {})));
-}
-
-// ─── Read deduplication ─────────────────────────────────────────────
-
-export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
-  const key = `${filePath}:${startLine || 0}:${endLine || 0}:${mtimeMs}`;
-  if (readCache.has(key)) {
-    return true;
-  }
-  readCache.set(key, true);
-  return false;
-}
-
 // ─── P1a: Read-only tool classification ──────────────────────────────
 
 const READ_ONLY_TOOLS = new Set([
@@ -282,6 +179,10 @@ const DREAM_AUTO_CAPTURE_TOOLS = new Set([
 const DREAM_AUTO_CAPTURE_COOLDOWN_MS = 60_000;
 const lastAutoCaptureByTool = new Map();
 
+function isAutoCaptureEnabled(config = {}) {
+  return config?.memory?.enabled !== false && config?.memory?.auto_capture !== false;
+}
+
 function shouldAutoCaptureError(toolName, message) {
   if (!DREAM_AUTO_CAPTURE_TOOLS.has(toolName)) return false;
   const now = Date.now();
@@ -299,10 +200,6 @@ function shouldAutoCaptureError(toolName, message) {
     /command not found/i,
     /permission denied/i,
     /args\?\s/i,
-    /Raw tool arguments/i,
-    /edit requires/i,
-    /write requires/i,
-    /requires file/i,
     /path.*outside workspace/i,
     /escapes workspace/i
   ];
@@ -312,7 +209,7 @@ function shouldAutoCaptureError(toolName, message) {
 }
 
 async function captureToolFailure(toolName, message, args, config = {}) {
-  if (config?.memory?.enabled === false || config?.memory?.auto_capture === false) return;
+  if (!isAutoCaptureEnabled(config)) return;
   const summary = `[${toolName}] ${String(message).slice(0, 120)}`;
   const details = args
     ? `Tool: ${toolName}\nError: ${message}\nArgs: ${JSON.stringify(args).slice(0, 300)}`
@@ -366,108 +263,6 @@ function extractFileChange(toolName, result) {
   return null;
 }
 
-export function summarizeToolResult(result) {
-  if (result === null || result === undefined) return 'no output';
-  if (typeof result === 'string') {
-    const oneLine = result.replace(/\s+/g, ' ').trim();
-    return oneLine.length > 90 ? `${oneLine.slice(0, 87)}...` : oneLine || 'empty string';
-  }
-  if (typeof result === 'object') {
-    const obj = result;
-    if (Array.isArray(obj)) return `array(${obj.length})`;
-    if ('deleted' in obj && 'path' in obj) {
-      const kind = trimInline(obj.type || 'item', 16);
-      const target = trimInline(obj.path || '', 96);
-      if (obj.deleted) return target ? `deleted ${kind} ${target}` : `deleted ${kind}`;
-      if (obj.cancelled) return target ? `cancelled delete ${target}` : 'cancelled delete';
-    }
-    if ('path' in obj && 'action' in obj) {
-      const p = String(obj.path || '');
-      const action = String(obj.action || 'write');
-      const line = Number(obj.changed_line || 1);
-      const suffix =
-        action === 'delete'
-          ? 'deleted'
-          : action === 'create'
-            ? 'created'
-            : action === 'patch'
-              ? 'patched'
-              : action === 'replace_block' || action === 'replace_text'
-                ? 'edited'
-                : action === 'append'
-                  ? 'appended'
-                  : 'updated';
-      return p ? `${suffix} ${p}${line > 0 ? ` @L${line}` : ''}` : suffix;
-    }
-    if ('path' in obj && 'phase' in obj) {
-      const phase = String(obj.phase || '');
-      const p = String(obj.path || '');
-      const total = Number(obj.total_lines);
-      const start =
-        Number(obj.suggested_start_line || obj.start_line) > 0
-          ? Number(obj.suggested_start_line || obj.start_line)
-          : 1;
-      const end =
-        Number(obj.suggested_end_line || obj.end_line) >= start
-          ? Number(obj.suggested_end_line || obj.end_line)
-          : start;
-      const rangeText = start > 0 && end >= start ? ` lines ${start}-${end}` : '';
-      const totalText = total > 0 ? ` of ${total}` : '';
-      const enclosingText = obj.enclosing_symbol ? ` in ${obj.enclosing_symbol}` : '';
-      const errorText = obj.error ? ` (${trimInline(obj.error, 64)})` : '';
-      const truncatedText = obj.truncated ? ' [truncated]' : '';
-      return phase === 'metadata'
-        ? `metadata for ${p}${rangeText}${totalText}${errorText}`
-        : `content from ${p}${rangeText}${totalText}${enclosingText}${truncatedText}`;
-    }
-    if ('stdout' in obj || 'stderr' in obj || 'code' in obj) {
-      const stdout = trimInline(obj.stdout || '', 96);
-      const stderr = trimInline(obj.stderr || '', 96);
-      const command = trimInline(obj.command || '', 72);
-      const lead = command ? `${command} -> ` : '';
-      if (stdout) return `${lead}exit ${obj.code ?? 0}\nstdout: ${stdout}`;
-      if (stderr) return `${lead}exit ${obj.code ?? 0}\nstderr: ${stderr}`;
-      return `${lead}exit ${obj.code ?? 0}`;
-    }
-    if ('task_id' in obj && 'startup_confirmed' in obj) {
-      const status = trimInline(obj.status || 'unknown', 32);
-      const taskId = trimInline(obj.task_id || '', 24);
-      const source = trimInline(obj.startup_source || '', 24);
-      const outputFile = trimInline(obj.output_file || '', 72);
-      const output = Array.isArray(obj.recent_output) ? trimInline(obj.recent_output.slice(-1)[0] || '', 96) : '';
-      return `${taskId || 'task'} ${status}${source ? ` (${source})` : ''}${outputFile ? ` -> ${outputFile}` : ''}${output ? `\n${output}` : ''}`;
-    }
-    if ('tasks' in obj && Array.isArray(obj.tasks)) {
-      const count = obj.tasks.length;
-      const first = obj.tasks[0];
-      const lead = first?.task_id ? `${trimInline(first.task_id, 24)} ${trimInline(first.status || 'unknown', 24)}` : '';
-      return `tasks(${count})${lead ? `\n${lead}` : ''}`;
-    }
-    if ('files' in obj && Array.isArray(obj.files)) {
-      return `patched ${obj.files.length} file(s)`;
-    }
-    if ('diff' in obj && 'new_hash' in obj && 'path' in obj) {
-      const p = String(obj.path || '');
-      return p ? `diff preview for ${p}` : 'diff preview';
-    }
-    if ('created' in obj && Array.isArray(obj.created)) {
-      return `created ${obj.created.length} task(s)`;
-    }
-    if ('tasks' in obj && Array.isArray(obj.tasks)) {
-      return `${obj.tasks.length} task(s)`;
-    }
-    if ('newTodos' in obj && Array.isArray(obj.newTodos)) {
-      return obj.newTodos.length > 0 ? `updated ${obj.newTodos.length} todo item(s)` : 'cleared todo list';
-    }
-    if ('newPlan' in obj) {
-      return obj.newPlan ? `updated plan state (${String(obj.newPlan.status || 'draft')})` : 'cleared plan state';
-    }
-    const keys = Object.keys(obj);
-    return keys.length > 0 ? `keys: ${keys.slice(0, 5).join(',')}` : 'object';
-  }
-  return String(result);
-}
-
 export const trimInline = _trimInline;
 
 function normalizeAssistantText(value) {
@@ -1010,7 +805,7 @@ export async function runAgentLoop({
         if (onEvent) {
           onEvent({ type: 'tool:error', name: displayName, id: call.id, arguments: effectiveArgs, durationMs, summary: trimInline(message, 120) });
         }
-        if (shouldAutoCaptureError(toolName, message)) {
+        if (isAutoCaptureEnabled(config) && shouldAutoCaptureError(toolName, message)) {
           await captureToolFailure(toolName, message, effectiveArgs, config).catch(() => {});
         }
         return {
@@ -1033,13 +828,13 @@ export async function runAgentLoop({
         const stderr = String(toolResult.stderr || '');
         if (typeof exitCode === 'number' && exitCode !== 0 && stderr) {
           const failMsg = `exit ${exitCode}: ${stderr.slice(0, 120)}`;
-          if (shouldAutoCaptureError(toolName, failMsg)) {
+          if (isAutoCaptureEnabled(config) && shouldAutoCaptureError(toolName, failMsg)) {
             await captureToolFailure(toolName, failMsg, effectiveArgs, config).catch(() => {});
           }
         }
         if (toolResult.error) {
           const errMsg = String(toolResult.error).slice(0, 120);
-          if (shouldAutoCaptureError(toolName, errMsg)) {
+          if (isAutoCaptureEnabled(config) && shouldAutoCaptureError(toolName, errMsg)) {
             await captureToolFailure(toolName, errMsg, effectiveArgs, config).catch(() => {});
           }
         }