codemini-cli 0.3.9 → 0.4.1

package/src/core/tools.js

@@ -23,6 +23,20 @@ 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';
+import {
+  normalizePathArgs,
+  normalizePatternArgs,
+  normalizeReadArgs,
+  normalizeWebFetchArgs,
+  normalizeWebSearchArgs,
+  normalizeWriteArgs
+} from './tool-args.js';
 const BACKGROUND_TASK_RECENT_OUTPUT_LIMIT = 80;
 const BACKGROUND_TASK_POLL_MS = 150;
 const MAX_AST_ENCLOSING_BYTES = 300_000;
@@ -94,133 +108,6 @@ function splitLines(text) {
   return String(text || '').split('\n');
 }
 
-function parseInlineReadRange(value) {
-  const text = String(value || '').trim();
-  if (!text) return null;
-  const match = text.match(/^(.*?):(\d+)(?:-(\d+))?$/);
-  if (!match) return null;
-  const [, maybePath, startRaw, endRaw] = match;
-  if (!maybePath || /^(?:[A-Za-z])$/.test(maybePath)) return null;
-  const startLine = Number(startRaw);
-  const endLine = Number(endRaw || startRaw);
-  if (!Number.isFinite(startLine) || startLine <= 0) return null;
-  if (!Number.isFinite(endLine) || endLine < startLine) return null;
-  return {
-    path: maybePath,
-    start_line: startLine,
-    end_line: endLine
-  };
-}
-
-function normalizeReadArgs(rawArgs) {
-  const source =
-    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
-      ? { ...rawArgs }
-      : { path: typeof rawArgs === 'string' ? rawArgs : '' };
-
-  const normalized = { ...source };
-  const aliasPath = String(source.path || source.file_path || source.file || source.target || '').trim();
-  if (aliasPath) normalized.path = aliasPath;
-
-  if (!Number.isFinite(Number(normalized.start_line)) && Number.isFinite(Number(source.offset))) {
-    normalized.start_line = Number(source.offset);
-  }
-
-  if (!Number.isFinite(Number(normalized.end_line)) && Number.isFinite(Number(source.limit))) {
-    const startLine = Number(normalized.start_line);
-    const limit = Number(source.limit);
-    if (startLine > 0 && limit > 0) {
-      normalized.end_line = startLine + limit - 1;
-    }
-  }
-
-  const inlineRange = parseInlineReadRange(normalized.path);
-  if (inlineRange) {
-    normalized.path = inlineRange.path;
-    if (!Number.isFinite(Number(normalized.start_line))) normalized.start_line = inlineRange.start_line;
-    if (!Number.isFinite(Number(normalized.end_line))) normalized.end_line = inlineRange.end_line;
-  }
-
-  return normalized;
-}
-
-function normalizePathArgs(rawArgs, aliases = []) {
-  const source =
-    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
-      ? { ...rawArgs }
-      : { path: typeof rawArgs === 'string' ? rawArgs : '' };
-  const normalized = { ...source };
-  const keys = ['path', ...aliases];
-  for (const key of keys) {
-    const value = String(source?.[key] || '').trim();
-    if (value) {
-      normalized.path = value;
-      break;
-    }
-  }
-  return normalized;
-}
-
-function normalizePatternArgs(rawArgs, aliases = [], defaultPathAliases = []) {
-  const source =
-    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
-      ? { ...rawArgs }
-      : { pattern: typeof rawArgs === 'string' ? rawArgs : '' };
-  const normalized = { ...source };
-  for (const key of ['pattern', ...aliases]) {
-    const value = String(source?.[key] || '').trim();
-    if (value) {
-      normalized.pattern = value;
-      break;
-    }
-  }
-  for (const key of ['path', ...defaultPathAliases]) {
-    const value = String(source?.[key] || '').trim();
-    if (value) {
-      normalized.path = value;
-      break;
-    }
-  }
-  return normalized;
-}
-
-function normalizeWriteArgs(rawArgs) {
-  const source =
-    rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
-      ? { ...rawArgs }
-      : { path: typeof rawArgs === 'string' ? rawArgs : '' };
-  const normalized = { ...source };
-  const filePath = String(source.path || source.file_path || source.file || '').trim();
-  if (filePath) normalized.path = filePath;
-  if (normalized.content == null) {
-    if (source.text != null) normalized.content = source.text;
-    if (source.new_content != null) normalized.content = source.new_content;
-  }
-  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;
@@ -333,11 +220,10 @@ async function webFetchPage(args = {}) {
     const html = await page.content();
     const $ = cheerio.load(html);
     const bodyText = $('body').text() || $.root().text();
-    const text = normalizeWhitespace(bodyText);
+    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);
-    const htmlExcerpt = html.length > 4000 ? `${html.slice(0, 4000)}...` : html;
 
     return {
       url,
@@ -345,7 +231,6 @@ async function webFetchPage(args = {}) {
       title,
       description,
       text,
-      html_excerpt: htmlExcerpt,
       links,
       metadata: {
         status: response?.status?.() ?? null,
@@ -747,40 +632,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);
@@ -924,12 +775,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
   };
 }
 
@@ -1045,10 +899,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;
@@ -1499,18 +1352,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
   };
 }
 
@@ -1767,7 +1649,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) {
@@ -1799,7 +1681,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) {
@@ -1818,20 +1700,14 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'read',
         description:
-          'Inspect code or text files. Use read(path) for normal file or line-window reads, read(ast_target=...) for a node-scoped AST read, and read(path, query=..., capture_name=...) to run an inline Tree-sitter query before returning the first matched node. Prefer the AST forms when targeting a function, class, or method and you want tighter context. Demo-style aliases like file_path, offset, and limit are accepted. Use metadata_only=true only when you want file metadata without content. Do not use run with cat, head, or tail for file reads.',
+          'Inspect code or text files. Use read(path) for normal file or line-window reads. Use start_line and end_line for ranges, or path:"src/app.ts:10-40" for inline ranges. Prefer this over run with cat, head, or tail.',
         parameters: {
           type: 'object',
           properties: {
             path: { type: 'string', description: 'File path to read. You can also include an inline range like src/app.ts:10-40.' },
-            file_path: { type: 'string', description: 'Alias for path' },
             start_line: { type: 'number', description: '1-based start line' },
             end_line: { type: 'number', description: 'Inclusive end line' },
-            offset: { type: 'number', description: 'Alias for start_line' },
-            limit: { type: 'number', description: 'Number of lines to read starting from offset/start_line' },
             max_chars: { type: 'number', description: 'Max chars to return' },
-            include_content: { type: 'boolean', description: 'Legacy compatibility flag. Content is returned by default.' },
-            read_token: { type: 'string', description: 'Legacy compatibility token. No longer required for content reads.' },
-            metadata_only: { type: 'boolean', description: 'Set true to return metadata without content.' },
             ast_target: { type: 'object', description: 'AST target from ast_query or a prior AST selection. When provided, read returns that node instead of a line window.' },
             query: { type: 'string', description: 'Optional Tree-sitter query to run inline before reading the first matched AST node. Use with path for one-shot function/class/method reads.' },
             capture_name: { type: 'string', description: 'Optional capture name to select when query is provided.' },
@@ -1846,14 +1722,12 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'grep',
         description:
-          'Search file contents. Use this for code search before read or edit. Aliases like query and directory are accepted. Do not use run with grep or rg for normal code search.',
+          'Search file contents. Use this for code search before read or edit. Do not use run with grep or rg for normal code search.',
         parameters: {
           type: 'object',
           properties: {
             pattern: { type: 'string', description: 'Search pattern' },
-            query: { type: 'string', description: 'Alias for pattern' },
             path: { type: 'string', description: 'Directory or file to search' },
-            directory: { type: 'string', description: 'Alias for path' },
             regex: { type: 'boolean', description: 'Treat pattern as regex' },
             case_sensitive: { type: 'boolean', description: 'Case-sensitive matching' },
             max_results: { type: 'number', description: 'Max matches to return' },
@@ -1868,12 +1742,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       type: 'function',
       function: {
         name: 'list',
-        description: 'List files and directories in a workspace path. Use this for quick directory discovery before deeper reads. Aliases like directory are accepted, and plain string paths are tolerated by the runtime.',
+        description: 'List files and directories in a workspace path. Use this for quick directory discovery before deeper reads.',
         parameters: {
           type: 'object',
           properties: {
             path: { type: 'string', description: 'Directory path to list' },
-            directory: { type: 'string', description: 'Alias for path' },
             include_hidden: { type: 'boolean', description: 'Include dotfiles' }
           }
         }
@@ -1884,14 +1757,12 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'glob',
         description:
-          'Find files by glob pattern. Use this when you already know a filename pattern such as src/**/*.ts. Aliases like query and directory are accepted.',
+          'Find files by glob pattern. Use this when you already know a filename pattern such as src/**/*.ts.',
         parameters: {
           type: 'object',
           properties: {
             pattern: { type: 'string', description: 'Glob pattern' },
             path: { type: 'string', description: 'Directory to search' },
-            query: { type: 'string', description: 'Alias for pattern' },
-            directory: { type: 'string', description: 'Alias for path' },
             include_hidden: { type: 'boolean', description: 'Include dotfiles' },
             max_results: { type: 'number', description: 'Max results' }
           },
@@ -1922,18 +1793,14 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'edit',
         description:
-          'Edit existing files. Prefer one of these shapes: 1) {file, old_text, new_text} for exact text replacement, 2) {file, symbol, edit:{kind:"replace_block", new_content:"..."}} for block replacement, 3) {file, anchor_text, position:"before"|"after", content:"..."} for inserts. Demo-style aliases {file_path, old_string, new_string} are also accepted. Read first unless the exact target is already known, and prefer read(ast_target=...) or read(path, query=...) before symbol- or block-level edits when you want tighter context. Prefer this over write for existing code changes.',
+          'Edit existing files. Prefer one of these shapes: 1) {path, old_text, new_text} for exact text replacement, 2) {path, symbol, edit:{kind:"replace_block", new_content:"..."}} for block replacement, 3) {path, anchor_text, position:"before"|"after", content:"..."} for inserts. Read first unless the exact target is already known. Prefer this over write for existing code changes.',
         parameters: {
           type: 'object',
           properties: {
-            file: { type: 'string', description: 'File path to edit' },
-            path: { type: 'string', description: 'Alias for file' },
-            file_path: { type: 'string', description: 'Alias for file, compatible with simpler demo-style tool calls' },
+            path: { type: 'string', description: 'File path to edit' },
             new_content: { type: 'string', description: 'Replacement content' },
             old_text: { type: 'string', description: 'Exact text to replace' },
             new_text: { type: 'string', description: 'Replacement text' },
-            old_string: { type: 'string', description: 'Alias for old_text' },
-            new_string: { type: 'string', description: 'Alias for new_text' },
             anchor_text: { type: 'string', description: 'Anchor text for inserts' },
             content: { type: 'string', description: 'Content to insert or append' },
             position: { type: 'string', description: 'before or after' },
@@ -1944,7 +1811,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
             line: { type: 'number', description: 'Line to target' },
             edit: { type: 'object', description: 'Structured edit input' }
           },
-          required: ['file']
+          required: ['path']
         }
       }
     },
@@ -1953,16 +1820,12 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'write',
         description:
-          'Create a new file or overwrite a file. Always include path and content. Aliases like file, file_path, text, and new_content are accepted. Use this for new files or explicit full rewrites only. Example: {path:"src/page.html", content:"..."} . If the file path is not decided yet, do not call write yet. Prefer edit for existing code changes.',
+          'Create a new file or overwrite a file. Always include path and content. Use this for new files or explicit full rewrites only. Example: {path:"src/page.html", content:"..."} . If the file path is not decided yet, do not call write yet. Prefer edit for existing code changes.',
         parameters: {
           type: 'object',
           properties: {
             path: { type: 'string', description: 'Required file path like src/app.js or pages/index.html. Never omit this.' },
-            file_path: { type: 'string', description: 'Alias for path, compatible with simpler demo-style tool calls' },
-            file: { type: 'string', description: 'Alias for path' },
             content: { type: 'string', description: 'Content to write' },
-            text: { type: 'string', description: 'Alias for content' },
-            new_content: { type: 'string', description: 'Alias for content' },
             append: { type: 'boolean', description: 'Append instead of overwrite' },
             full_file_rewrite: { type: 'boolean', description: 'Set true for whole-file rewrites' }
           },
@@ -1975,15 +1838,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       function: {
         name: 'delete',
         description:
-          'Delete a file or directory inside the workspace. Use path, file, or file_path to point at the target. Missing targets fail. Workspace escape attempts are rejected.',
+          'Delete a file or directory inside the workspace. Missing targets fail. Workspace escape attempts are rejected.',
         parameters: {
           type: 'object',
           properties: {
-            path: { type: 'string', description: 'File or directory path to delete' },
-            file: { type: 'string', description: 'Alias for path' },
-            file_path: { type: 'string', description: 'Alias for path' },
-            directory: { type: 'string', description: 'Alias for path' },
-            dir: { type: 'string', description: 'Alias for path' }
+            path: { type: 'string', description: 'File or directory path to delete' }
           },
           required: ['path']
         }
@@ -2210,52 +2069,23 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
       }
     },
-    remember_user: {
-      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.',
-        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' }
-          },
-          required: ['content']
-        }
-      }
-    },
-    remember_global: {
+    save_memory: {
       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.',
-        parameters: {
-          type: 'object',
-          properties: {
-            content: { type: 'string' },
-            kind: { type: 'string' },
-            summary: { type: 'string' },
-            replace_similar: { type: 'boolean' }
-          },
-          required: ['content']
-        }
-      }
-    },
-    remember_project: {
-      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']
         }
@@ -2305,26 +2135,6 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
       }
     },
-    capture_memory: {
-      type: 'function',
-      function: {
-        name: 'capture_memory',
-        description:
-          'Capture a high-signal observation into the dream loop inbox during active work. Use this when you notice a reusable pattern, a user correction, a repeated failure with stable fix, a stable preference, or a workflow win. Do NOT use for casual chatter, trivial typos, or one-off noise. This is lightweight — entries land in inbox and are consolidated later.',
-        parameters: {
-          type: 'object',
-          properties: {
-            summary: { type: 'string', description: 'Short high-signal summary of the observation' },
-            details: { type: 'string', description: 'Detailed explanation of the observation' },
-            scope: { type: 'string', description: 'Scope: global, repo, or thread. Default: global' },
-            type: { type: 'string', description: 'Observation type: correction, failure, preference, pattern, win, gap, decision. Default: observation' },
-            tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags for categorization' },
-            suggested_action: { type: 'string', description: 'Optional suggested follow-up action' }
-          },
-          required: ['summary']
-        }
-      }
-    },
     dream_consolidate: {
       type: 'function',
       function: {
@@ -2584,42 +2394,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 || ''),
@@ -2634,18 +2434,6 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       ok: true,
       ...(await forgetMemory({ scope: args.scope, id: args.id, workspaceRoot }))
     }),
-    capture_memory: async (args = {}) => {
-      const entry = await captureToInbox({
-        scope: args.scope,
-        type: args.type,
-        summary: args.summary,
-        details: args.details,
-        suggestedAction: args.suggested_action,
-        tags: args.tags,
-        source: 'tool'
-      });
-      return { ok: true, captured: entry };
-    },
     dream_consolidate: async (args = {}) => {
       return runDreamConsolidation({
         dryRun: args.dry_run === true,
@@ -2681,7 +2469,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);
@@ -2880,9 +2668,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}`);
@@ -2903,6 +2693,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.`;
@@ -2938,8 +2733,7 @@ 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) {
@@ -2951,7 +2745,9 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       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(trimPreview(result.text, 1200));
+      if (result.text) {
+        lines.push(result.text);
+      }
       return lines.join('\n');
     },
 
@@ -2992,6 +2788,13 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
     }
   };
 
+  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 {