codemini-cli 0.3.8 → 0.4.0

package/src/core/tools.js

@@ -18,9 +18,17 @@ import { initializeProjectIndex, queryProjectIndex, refreshIndexedFile } from '.
 import { checkReadDedup } from './agent-loop.js';
 import { TOOL_SKIP_DIRS as SKIP_DIRS, TEXT_EXTENSIONS, CODE_WRITE_GUARD_EXTENSIONS, LANGUAGE_FILE_TYPES } from './constants.js';
 import { sha256Prefixed as sha256, sha256 as sha256Hash } from './crypto-utils.js';
-import { forgetMemory, listMemories, rememberMemory, searchMemories } from './memory-store.js';
+import { forgetMemory, listMemories, rememberMemory, searchMemories, captureToInbox } from './memory-store.js';
+import { runDreamConsolidation } from './dream-consolidate.js';
 import { normalizePlanState } from './plan-state.js';
 import { normalizeTodos } from './todo-state.js';
+import { createFffAdapter } from './fff-adapter.js';
+import {
+  getToolOutputSanitizeOptions,
+  sanitizePreviewLines,
+  sanitizeTextForModel,
+  summarizeRunOutput
+} from './tool-output.js';
 const BACKGROUND_TASK_RECENT_OUTPUT_LIMIT = 80;
 const BACKGROUND_TASK_POLL_MS = 150;
 const MAX_AST_ENCLOSING_BYTES = 300_000;
@@ -197,6 +205,199 @@ function normalizeWriteArgs(rawArgs) {
   return normalized;
 }
 
+function normalizeWebFetchArgs(rawArgs) {
+  const source =
+    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+      ? { ...rawArgs }
+      : { url: typeof rawArgs === 'string' ? rawArgs : '' };
+  const normalized = { ...source };
+  const url = String(source.url || source.href || source.link || source.target || '').trim();
+  if (url) normalized.url = url;
+  return normalized;
+}
+
+function normalizeWebSearchArgs(rawArgs) {
+  const source =
+    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+      ? { ...rawArgs }
+      : { query: typeof rawArgs === 'string' ? rawArgs : '' };
+  const normalized = { ...source };
+  const query = String(source.query || source.q || source.keyword || '').trim();
+  if (query) normalized.query = query;
+  return normalized;
+}
+
+function clampNumber(value, min, max, fallback) {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return fallback;
+  return Math.min(max, Math.max(min, num));
+}
+
+function normalizeWhitespace(value) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function trimPreview(value, maxLen = 300) {
+  const text = normalizeWhitespace(value);
+  if (text.length <= maxLen) return text;
+  return `${text.slice(0, Math.max(0, maxLen - 3))}...`;
+}
+
+function normalizeWebUrl(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  let parsed;
+  try {
+    parsed = new URL(text);
+  } catch {
+    throw new Error(`Invalid URL: ${text}`);
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol)) {
+    throw new Error(`Unsupported URL protocol: ${parsed.protocol}`);
+  }
+  return parsed.toString();
+}
+
+function extractHtmlMeta($, name, attribute = 'content') {
+  return String(
+    $(`meta[name="${name}"]`).attr(attribute) ||
+      $(`meta[property="${name}"]`).attr(attribute) ||
+      ''
+  ).trim();
+}
+
+function collectPageLinks($, pageUrl, maxLinks = 20) {
+  const links = [];
+  const seen = new Set();
+  $('a[href]').each((_, element) => {
+    if (links.length >= maxLinks) return false;
+    const hrefRaw = String($(element).attr('href') || '').trim();
+    if (!hrefRaw) return undefined;
+    try {
+      const href = new URL(hrefRaw, pageUrl).toString();
+      if (seen.has(href)) return undefined;
+      seen.add(href);
+      links.push({
+        href,
+        text: trimPreview($(element).text(), 160)
+      });
+    } catch {
+      return undefined;
+    }
+    return undefined;
+  });
+  return links;
+}
+
+async function buildPlaywrightLaunchEnv() {
+  const localLibDir = path.join(
+    process.env.HOME || '',
+    '.cache',
+    'codemini',
+    'playwright-libs',
+    'usr',
+    'lib',
+    'x86_64-linux-gnu'
+  );
+  try {
+    await fs.access(localLibDir);
+  } catch {
+    return process.env;
+  }
+
+  const existing = String(process.env.LD_LIBRARY_PATH || '').trim();
+  return {
+    ...process.env,
+    LD_LIBRARY_PATH: existing ? `${localLibDir}:${existing}` : localLibDir
+  };
+}
+
+async function webFetchPage(args = {}) {
+  const normalizedArgs = normalizeWebFetchArgs(args);
+  const url = normalizeWebUrl(normalizedArgs.url);
+  const timeoutMs = clampNumber(normalizedArgs.timeout_ms, 1_000, 120_000, 20_000);
+  const maxLinks = clampNumber(normalizedArgs.max_links, 0, 100, 20);
+  const waitUntil = ['domcontentloaded', 'load', 'networkidle'].includes(String(normalizedArgs.wait_until || '').trim())
+    ? String(normalizedArgs.wait_until).trim()
+    : 'domcontentloaded';
+
+  const [{ chromium }, cheerio] = await Promise.all([import('playwright'), import('cheerio')]);
+
+  // Crawlee is intentionally disabled for now so single-page reads stay lightweight.
+  // If we later need multi-URL crawl orchestration, retries, or request queues, we can re-enable it here.
+
+  const browser = await chromium.launch({
+    headless: true,
+    env: await buildPlaywrightLaunchEnv()
+  });
+  try {
+    const page = await browser.newPage();
+    const response = await page.goto(url, { waitUntil, timeout: timeoutMs });
+    const finalUrl = page.url();
+    const html = await page.content();
+    const $ = cheerio.load(html);
+    const bodyText = $('body').text() || $.root().text();
+    const text = String(bodyText || '').replace(/[^\S\n]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+    const title = trimPreview($('title').first().text() || (await page.title()), 240);
+    const description = extractHtmlMeta($, 'description') || extractHtmlMeta($, 'og:description');
+    const links = collectPageLinks($, finalUrl, maxLinks);
+
+    return {
+      url,
+      final_url: finalUrl,
+      title,
+      description,
+      text,
+      links,
+      metadata: {
+        status: response?.status?.() ?? null,
+        fetched_at: new Date().toISOString(),
+        content_type: response?.headers?.()['content-type'] || '',
+        wait_until: waitUntil,
+        lang: String($('html').attr('lang') || '').trim()
+      }
+    };
+  } finally {
+    await browser.close();
+  }
+}
+
+async function webSearchQuery(config, args = {}) {
+  if (config?.web?.search_enabled === false) {
+    throw new Error('web_search is disabled by config. Set web.search_enabled=true to enable network search.');
+  }
+
+  const normalizedArgs = normalizeWebSearchArgs(args);
+  const query = String(normalizedArgs.query || '').trim();
+  if (!query) throw new Error('web_search requires query');
+
+  const maxResults = clampNumber(normalizedArgs.max_results, 1, 20, 8);
+  const [{ search, SafeSearchType }] = await Promise.all([import('duck-duck-scrape')]);
+  const response = await search(query, {
+    safeSearch: SafeSearchType.MODERATE,
+    locale: String(normalizedArgs.locale || 'en-us').trim() || 'en-us',
+    region: String(normalizedArgs.region || 'wt-wt').trim() || 'wt-wt'
+  });
+
+  return {
+    query,
+    no_results: response?.noResults === true,
+    results: Array.isArray(response?.results)
+      ? response.results.slice(0, maxResults).map((item) => ({
+          title: String(item?.title || '').trim(),
+          url: String(item?.url || '').trim(),
+          description: normalizeWhitespace(item?.description || item?.rawDescription || ''),
+          hostname: String(item?.hostname || '').trim()
+        }))
+      : [],
+    related: Array.isArray(response?.related)
+      ? response.related.slice(0, 8).map((item) => String(item?.text || item?.raw || '').trim()).filter(Boolean)
+      : []
+  };
+}
+
 function findUniqueLineBlock(lines, blockContent) {
   const probeLines = splitLines(blockContent);
   if (probeLines.length === 0 || (probeLines.length === 1 && probeLines[0] === '')) return null;
@@ -550,40 +751,6 @@ function findEnclosingSymbolLine(lines, anchorLine) {
   return 0;
 }
 
-function buildUnifiedDiff(oldContent, newContent, filePath = 'file') {
-  const oldLines = splitLines(oldContent);
-  const newLines = splitLines(newContent);
-  let prefix = 0;
-  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
-    prefix += 1;
-  }
-
-  let suffix = 0;
-  while (
-    suffix < oldLines.length - prefix &&
-    suffix < newLines.length - prefix &&
-    oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]
-  ) {
-    suffix += 1;
-  }
-
-  const oldChanged = oldLines.slice(prefix, oldLines.length - suffix);
-  const newChanged = newLines.slice(prefix, newLines.length - suffix);
-  const oldStart = prefix + 1;
-  const newStart = prefix + 1;
-  const oldCount = Math.max(1, oldChanged.length);
-  const newCount = Math.max(1, newChanged.length);
-
-  const body = [
-    `--- ${filePath}`,
-    `+++ ${filePath}`,
-    `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`,
-    ...oldChanged.map((line) => `-${line}`),
-    ...newChanged.map((line) => `+${line}`)
-  ];
-  return body.join('\n');
-}
-
 async function getFileState(root, relativePath) {
   const target = await resolveInWorkspace(root, relativePath);
   const stat = await fs.stat(target);
@@ -727,12 +894,15 @@ async function writeFile(root, args) {
   }
   const previewStart = Math.max(0, (changeLine || 1) - 1);
   const previewLines = afterLines.slice(previewStart, previewStart + 6);
+  const changed = countChangedLines(before, after);
   return {
     ok: true,
     path: rawPath,
     action: normalizedArgs?.append ? 'append' : existed ? 'overwrite' : 'create',
     changed_line: changeLine || Math.max(1, afterLines.length),
-    diff_preview: previewLines.map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n')
+    diff_preview: previewLines.map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n'),
+    lines_added: changed.added,
+    lines_removed: changed.removed
   };
 }
 
@@ -848,10 +1018,9 @@ function shellCommandForBackgroundTask(command, shellSpec) {
 }
 
 function appendRecentOutput(task, chunk) {
-  const lines = String(chunk || '')
-    .split(/\r?\n/)
-    .map((line) => trimLinePreview(line, 220))
-    .filter(Boolean);
+  const lines = sanitizePreviewLines(chunk, { maxLineLength: 220 }).map((line) =>
+    trimLinePreview(line, 220)
+  );
   if (lines.length === 0) return;
   for (const line of lines) {
     backgroundTaskLogCursorCounter += 1;
@@ -1133,7 +1302,7 @@ async function stopBackgroundTask(_root, args) {
   return { ...snapshotBackgroundTask(task), stopped: true };
 }
 
-async function grep(root, args) {
+async function builtinGrep(root, args) {
   const normalizedArgs = normalizePatternArgs(args, ['query', 'symbol', 'q'], ['directory', 'dir', 'cwd']);
   const pattern = String(normalizedArgs?.pattern || '').trim();
   if (!pattern) throw new Error('grep requires pattern');
@@ -1168,7 +1337,7 @@ async function grep(root, args) {
   return { pattern, matches, truncated: false };
 }
 
-async function glob(root, args) {
+async function builtinGlob(root, args) {
   const normalizedArgs = normalizePatternArgs(args, ['glob', 'query'], ['directory', 'dir', 'cwd']);
   const pattern = String(normalizedArgs?.pattern || '').trim();
   if (!pattern) throw new Error('glob requires pattern');
@@ -1188,7 +1357,7 @@ async function glob(root, args) {
   };
 }
 
-async function list(root, args) {
+async function builtinList(root, args) {
   const normalizedArgs = normalizePathArgs(args, ['dir', 'directory', 'target']);
   const relativePath = String(normalizedArgs?.path || '.').trim() || '.';
   const target = await resolveInWorkspace(root, relativePath);
@@ -1302,18 +1471,47 @@ async function validateEdit(root, args) {
   throw new Error(`validate_edit does not support kind: ${kind}`);
 }
 
+function countChangedLines(beforeContent, afterContent) {
+  const before = splitLines(beforeContent);
+  const after = splitLines(afterContent);
+  const m = before.length;
+  const n = after.length;
+  // LCS via rolling DP — O(m*n) time, O(min(m,n)) space
+  const short = m <= n ? before : after;
+  const long = m <= n ? after : before;
+  const shortLen = short.length;
+  const longLen = long.length;
+  let prev = new Array(longLen + 1).fill(0);
+  let curr = new Array(longLen + 1).fill(0);
+  for (let i = 1; i <= shortLen; i++) {
+    for (let j = 1; j <= longLen; j++) {
+      if (short[i - 1] === long[j - 1]) {
+        curr[j] = prev[j - 1] + 1;
+      } else {
+        curr[j] = Math.max(prev[j], curr[j - 1]);
+      }
+    }
+    [prev, curr] = [curr, prev];
+    curr.fill(0);
+  }
+  const lcsLen = prev[longLen];
+  return { added: n - lcsLen, removed: m - lcsLen };
+}
+
 function editResult(pathText, action, beforeContent, afterContent, changedLine = 1) {
   const afterLines = splitLines(afterContent);
   const previewStart = Math.max(0, changedLine - 1);
   const diffPreview = afterLines.slice(previewStart, previewStart + 6).map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n');
+  const changed = countChangedLines(beforeContent, afterContent);
   return {
     ok: true,
     path: pathText,
     action,
     changed_line: changedLine,
     diff_preview: diffPreview,
-    diff: buildUnifiedDiff(beforeContent, afterContent, pathText),
-    new_hash: sha256(afterContent)
+    new_hash: sha256(afterContent),
+    lines_added: changed.added,
+    lines_removed: changed.removed
   };
 }
 
@@ -1535,7 +1733,7 @@ async function editTarget(root, args) {
   throw new Error(`edit does not support kind: ${kind}`);
 }
 
-export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSystemEvent, getTodos, onTodosUpdate, getPlanState, onPlanStateUpdate }) {
+export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSystemEvent, getTodos, onTodosUpdate, getPlanState, onPlanStateUpdate, fffAdapter }) {
   const emitSystemTool = (event) => {
     if (typeof onSystemEvent === 'function' && event) onSystemEvent(event);
   };
@@ -1570,7 +1768,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
   };
   const ensureProjectIndex = async () => {
     const eventId = `project-index:${Date.now()}`;
-    const name = 'project_index(.codemini-project/project-map.json,.codemini-project/file-index.json)';
+    const name = 'project_index(.codemini/project-map.json,.codemini/file-index.json)';
     try {
       const result = await initializeProjectIndex(workspaceRoot);
       if (result?.skipped || !result?.summary) {
@@ -1602,7 +1800,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         type: 'system_tool:end',
         id: eventId,
         name,
-        summary: result?.summary || `updated .codemini-project for ${relativePath}`
+        summary: result?.summary || `updated .codemini for ${relativePath}`
       });
       return result;
     } catch (error) {
@@ -1975,52 +2173,61 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
       }
     },
-    remember_user: {
+    web_fetch: {
       type: 'function',
       function: {
-        name: 'remember_user',
-        description: 'Store a durable user preference, communication habit, or long-term instruction for future sessions. Use this for things like reply style, language, explanation depth, or stable guardrails. Never store secrets, tokens, passwords, or one-off task details.',
+        name: 'web_fetch',
+        description:
+          'Fetch and read a live web page. Uses Playwright to render the page, Cheerio to extract structured content, and Crawlee request handling to normalize the fetch flow. Use this for direct URL reads, not for keyword search.',
         parameters: {
           type: 'object',
           properties: {
-            content: { type: 'string', description: 'Stable preference or instruction to remember' },
-            kind: { type: 'string', description: 'preference, workflow, constraint, or warning' },
-            summary: { type: 'string', description: 'Short summary for the memory index' },
-            replace_similar: { type: 'boolean', description: 'Replace an existing similar memory when true' }
+            url: { type: 'string', description: 'Absolute http or https URL to fetch' },
+            href: { type: 'string', description: 'Alias for url' },
+            timeout_ms: { type: 'number', description: 'Navigation timeout in milliseconds' },
+            wait_until: { type: 'string', description: 'domcontentloaded, load, or networkidle' },
+            max_links: { type: 'number', description: 'Max number of links to extract from the page' }
           },
-          required: ['content']
+          required: ['url']
         }
       }
     },
-    remember_global: {
+    web_search: {
       type: 'function',
       function: {
-        name: 'remember_global',
-        description: 'Store a durable cross-project workflow, environment fact, or generally reusable lesson that can help across many repositories. Use this for stable habits like preferred search tools or repeatable debugging workflow. Never store secrets.',
+        name: 'web_search',
+        description:
+          'Run a live web search through DuckDuckGo. Use this for keyword-based internet search. This tool respects config.web.search_enabled and will fail when network search is disabled.',
         parameters: {
           type: 'object',
           properties: {
-            content: { type: 'string' },
-            kind: { type: 'string' },
-            summary: { type: 'string' },
-            replace_similar: { type: 'boolean' }
+            query: { type: 'string', description: 'Search query' },
+            q: { type: 'string', description: 'Alias for query' },
+            max_results: { type: 'number', description: 'Max results to return' },
+            locale: { type: 'string', description: 'DuckDuckGo locale such as en-us' },
+            region: { type: 'string', description: 'DuckDuckGo region such as wt-wt' }
           },
-          required: ['content']
+          required: ['query']
         }
       }
     },
-    remember_project: {
+    save_memory: {
       type: 'function',
       function: {
-        name: 'remember_project',
-        description: 'Store a durable project-specific convention, architecture note, key module warning, or local workflow expectation. Use this for repository-specific rules, important files, testing conventions, or architectural boundaries. Never store secrets or transient task state.',
+        name: 'save_memory',
+        description:
+          'Save a durable observation or knowledge to persistent memory. Use this when you notice a reusable pattern, a user correction, a stable preference, a project convention, or a workflow insight. Do NOT use for casual chatter, trivial typos, one-off noise, or secrets. The memory is saved immediately and available in future sessions.',
         parameters: {
           type: 'object',
           properties: {
-            content: { type: 'string' },
-            kind: { type: 'string' },
-            summary: { type: 'string' },
-            replace_similar: { type: 'boolean' }
+            content: { type: 'string', description: 'The knowledge or observation to remember' },
+            summary: { type: 'string', description: 'Short summary for the memory index (under 80 chars)' },
+            scope: {
+              type: 'string',
+              description: 'Where to store this memory. "user" = personal preferences (language, style, interaction habits). "global" = cross-project knowledge useful in ANY repository (environment quirks, general workflows, tool tips). "project" = specific to THIS repository only (architecture conventions, local config, test commands, file locations). Default: "global".'
+            },
+            kind: { type: 'string', description: 'Memory kind: preference, pattern, correction, observation, decision, failure, win, gap, convention. Default: observation' },
+            replace_similar: { type: 'boolean', description: 'Replace an existing similar memory when true. Default: true.' }
           },
           required: ['content']
         }
@@ -2070,6 +2277,21 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
       }
     },
+    dream_consolidate: {
+      type: 'function',
+      function: {
+        name: 'dream_consolidate',
+        description:
+          'Run a dream loop consolidation pass over inbox entries. Reads recent inbox items, deduplicates, evaluates lifecycle progression (observed → candidate → operational/longterm), promotes stable patterns into persistent memory, archives expired items, and writes an audit report. Use during off-hours or explicit maintenance.',
+        parameters: {
+          type: 'object',
+          properties: {
+            scope: { type: 'string', description: 'Optional scope filter: global, repo, or thread' },
+            dry_run: { type: 'boolean', description: 'If true, only preview what would change without making changes' }
+          }
+        }
+      }
+    },
     list_background_tasks: {
       type: 'function',
       function: {
@@ -2113,6 +2335,47 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
   };
 
   const definitions = [...primaryDefinitions];
+  const activeFffAdapter = fffAdapter || createFffAdapter({ workspaceRoot, config });
+  let fffConnected = false;
+
+  async function ensureFffConnected() {
+    if (!activeFffAdapter?.connect || fffConnected) return;
+    await activeFffAdapter.connect();
+    fffConnected = true;
+  }
+
+  async function grep(args) {
+    if (activeFffAdapter?.grep) {
+      try {
+        await ensureFffConnected();
+        const result = await activeFffAdapter.grep(args);
+        if (result && Array.isArray(result.matches)) return result;
+      } catch {}
+    }
+    return builtinGrep(workspaceRoot, args);
+  }
+
+  async function glob(args) {
+    if (activeFffAdapter?.glob) {
+      try {
+        await ensureFffConnected();
+        const result = await activeFffAdapter.glob(args);
+        if (result && Array.isArray(result.matches)) return result;
+      } catch {}
+    }
+    return builtinGlob(workspaceRoot, args);
+  }
+
+  async function list(args) {
+    if (activeFffAdapter?.list) {
+      try {
+        await ensureFffConnected();
+        const result = await activeFffAdapter.list(args);
+        if (result && Array.isArray(result.items)) return result;
+      } catch {}
+    }
+    return builtinList(workspaceRoot, args);
+  }
 
   const handlers = {
     read: async (args) => {
@@ -2176,9 +2439,9 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       await ensureProjectIndex();
       return queryProjectIndex(workspaceRoot, args);
     },
-    grep: (args) => grep(workspaceRoot, args),
-    glob: (args) => glob(workspaceRoot, args),
-    list: (args) => list(workspaceRoot, args),
+    grep,
+    glob,
+    list,
     ast_query: async (args) => {
       const result = await queryAst(workspaceRoot, args);
       const firstTarget = result?.matches?.[0]?.ast_target;
@@ -2191,6 +2454,8 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       if (astTarget.path) rememberAstSelection(astTarget.path, astTarget);
       return readAstNode(workspaceRoot, { ...args, ast_target: astTarget });
     },
+    web_fetch: (args) => webFetchPage(args),
+    web_search: (args) => webSearchQuery(config, args),
     edit: async (args) => {
       await ensureProjectIndex();
       const normalizedKind = String(args?.edit?.kind || args?.kind || '').trim();
@@ -2271,42 +2536,32 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         hasPendingApproval: nextPlan?.status === 'pending_approval'
       };
     },
-    run: (args) => runCommand(workspaceRoot, config, args),
-    remember_user: async (args = {}) => {
-      const saved = await rememberMemory({
-        scope: 'user',
-        content: args.content,
-        kind: args.kind,
-        summary: args.summary,
-        replaceSimilar: args.replace_similar !== false,
-        workspaceRoot,
-        config
-      });
-      return { ok: true, scope: 'user', memory: saved };
-    },
-    remember_global: async (args = {}) => {
-      const saved = await rememberMemory({
-        scope: 'global',
-        content: args.content,
-        kind: args.kind,
-        summary: args.summary,
-        replaceSimilar: args.replace_similar !== false,
-        workspaceRoot,
-        config
-      });
-      return { ok: true, scope: 'global', memory: saved };
-    },
-    remember_project: async (args = {}) => {
+    run: Object.assign(
+      (args) => runCommand(workspaceRoot, config, args),
+      {
+        prepareApproval: async (args) => ({
+          command: args?.command || '',
+          risk: args?._risk || 'high',
+          evaluation: args?._evaluation || null
+        })
+      }
+    ),
+    save_memory: async (args = {}) => {
+      const rawScope = String(args.scope || 'global').toLowerCase();
+      const memoryScope = rawScope === 'repo' || rawScope === 'project' ? 'project'
+        : rawScope === 'user' ? 'user'
+        : 'global';
       const saved = await rememberMemory({
-        scope: 'project',
+        scope: memoryScope,
         content: args.content,
-        kind: args.kind,
-        summary: args.summary,
+        kind: args.kind || 'observation',
+        summary: args.summary || String(args.content || '').slice(0, 80),
+        source: 'tool',
         replaceSimilar: args.replace_similar !== false,
         workspaceRoot,
         config
       });
-      return { ok: true, scope: 'project', memory: saved };
+      return { ok: true, scope: memoryScope, memory: saved };
     },
     list_memory: async (args = {}) => ({
       scope: String(args.scope || ''),
@@ -2321,6 +2576,15 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       ok: true,
       ...(await forgetMemory({ scope: args.scope, id: args.id, workspaceRoot }))
     }),
+    dream_consolidate: async (args = {}) => {
+      return runDreamConsolidation({
+        dryRun: args.dry_run === true,
+        scope: args.scope || null,
+        workspaceRoot,
+        config,
+        writeAudit: true
+      });
+    },
     list_background_tasks: () => listBackgroundTasks(workspaceRoot),
     get_background_task: (args) => getBackgroundTask(workspaceRoot, args),
     stop_background_task: (args) => stopBackgroundTask(workspaceRoot, args),
@@ -2347,7 +2611,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
     }
   };
 
-  const formatters = {
+  const rawFormatters = {
     read(result) {
       if (typeof result === 'string') return result;
       if (!result || typeof result !== 'object') return String(result);
@@ -2546,9 +2810,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
         return parts.join('\n');
       }
+      const runSummary = summarizeRunOutput(result);
+      if (runSummary) return runSummary;
       const command = String(result.command || '').slice(0, 200);
-      const stdout = String(result.stdout || '').slice(0, 500);
-      const stderr = String(result.stderr || '').slice(0, 500);
+      const stdout = String(result.stdout || '');
+      const stderr = String(result.stderr || '');
       const code = result.code ?? 0;
       const parts = [`[exit: ${code}]`];
       if (command) parts.push(`command: ${command}`);
@@ -2569,6 +2835,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       return result?.memory?.content ? `stored project memory: ${result.memory.content}` : JSON.stringify(result);
     },
 
+    save_memory(result) {
+      const scope = result?.scope || 'global';
+      return result?.memory?.content ? `stored ${scope} memory: ${result.memory.content}` : JSON.stringify(result);
+    },
+
     list_memory(result) {
       if (!result || typeof result !== 'object' || !Array.isArray(result.items)) return JSON.stringify(result);
       if (result.items.length === 0) return `No ${result.scope || ''} memories found.`;
@@ -2604,8 +2875,37 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       const kind = result.kind || '';
       const content = result.content || result.source || '';
       const header = `${kind} ${name}`;
-      if (typeof content !== 'string' || content.length <= 2000) return `${header}\n${content}`;
-      return `${header}\n${content.slice(0, 1200)}\n... [omitted ${content.length - 1600} chars] ...\n${content.slice(-400)}`;
+      return `${header}\n${content}`;
+    },
+
+    web_fetch(result) {
+      if (!result || typeof result !== 'object') return String(result);
+      const lines = [`[web_fetch: ${result.final_url || result.url || '?'}]`];
+      if (result.title) lines.push(`title: ${result.title}`);
+      if (result.description) lines.push(`description: ${trimPreview(result.description, 200)}`);
+      if (result.metadata?.status) lines.push(`status: ${result.metadata.status}`);
+      if (Array.isArray(result.links) && result.links.length > 0) {
+        lines.push(`links: ${result.links.slice(0, 5).map((item) => item.href).join(', ')}`);
+      }
+      if (result.text) {
+        lines.push(result.text);
+      }
+      return lines.join('\n');
+    },
+
+    web_search(result) {
+      if (!result || typeof result !== 'object') return String(result);
+      const lines = [result.query ? `[web_search: "${result.query}"]` : '[web_search]'];
+      if (!Array.isArray(result.results) || result.results.length === 0) {
+        lines.push(result.no_results ? 'No results found.' : 'No search results returned.');
+        return lines.join('\n');
+      }
+      for (const item of result.results.slice(0, 8)) {
+        lines.push(`- ${item.title || item.url}`);
+        if (item.url) lines.push(`  ${item.url}`);
+        if (item.description) lines.push(`  ${trimPreview(item.description, 180)}`);
+      }
+      return lines.join('\n');
     },
 
     list_background_tasks(result) {
@@ -2630,5 +2930,20 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
     }
   };
 
-  return { definitions, handlers, formatters, deferredDefinitions };
+  const formatters = Object.fromEntries(
+    Object.entries(rawFormatters).map(([name, formatter]) => [
+      name,
+      (result, args) => sanitizeTextForModel(formatter(result, args), getToolOutputSanitizeOptions(name))
+    ])
+  );
+
+  async function dispose() {
+    if (activeFffAdapter?.dispose) {
+      try {
+        await activeFffAdapter.dispose();
+      } catch {}
+    }
+  }
+
+  return { definitions, handlers, formatters, deferredDefinitions, dispose };
 }