neoagent 2.5.2-beta.9 → 3.0.1-beta.0

package/server/services/ai/toolEvidence.js

@@ -8,6 +8,10 @@
 const { compactToolResult } = require('./toolResult');
 const { summarizeForLog } = require('./logFormat');
 const { normalizeOutgoingMessage, clampRunContext } = require('./messagingFallback');
+const {
+  isClearlyReadOnlyShellCommand,
+  isProgressToolCall,
+} = require('./loop/progress_classification');
 
 // Ordered classification rules mapping a tool name to its evidence "source"
 // bucket. First matching rule wins, so order is significant. Declared as data
@@ -20,7 +24,7 @@ const EVIDENCE_SOURCE_RULES = [
   { source: 'memory', match: (name) => name.startsWith('memory_') || name === 'session_search' },
   { source: 'search', match: (name) => name === 'web_search' },
   { source: 'http', match: (name) => name === 'http_request' },
-  { source: 'files', match: (name) => ['read_file', 'search_files', 'list_directory', 'write_file', 'edit_file', 'code_navigate', 'query_structured_data'].includes(name) },
+  { source: 'files', match: (name) => ['read_file', 'read_files', 'search_files', 'list_directory', 'write_file', 'edit_file', 'replace_file_range', 'code_navigate', 'query_structured_data'].includes(name) },
   { source: 'command', match: (name) => name === 'execute_command' },
   { source: 'skills', match: (name) => name.includes('skill') },
   { source: 'tasks', match: (name) => name === 'create_task' || name === 'update_task' || name === 'delete_task' || name === 'list_tasks' || name.includes('widget') },
@@ -42,6 +46,7 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'web_search',
     'http_request',
     'read_file',
+    'read_files',
     'search_files',
     'list_directory',
     'code_navigate',
@@ -60,6 +65,7 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'execute_command',
     'write_file',
     'edit_file',
+    'replace_file_range',
     'send_interim_update',
     'send_message',
     'make_call',
@@ -83,7 +89,13 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
 
   const evidenceRelevant = evidenceRelevantExact.has(name)
     || evidenceRelevantPrefixes.some((prefix) => name.startsWith(prefix));
-  const stateChanged = stateChangingExact.has(name)
+  const stateChanged = (
+    name === 'execute_command'
+      ? !isClearlyReadOnlyShellCommand(toolArgs?.command || '')
+      : stateChangingExact.has(name)
+  )
+    || (name.startsWith('github_') && isProgressToolCall(name, toolArgs))
+    || (name === 'http_request' && isProgressToolCall(name, toolArgs))
     || name.startsWith('android_')
     || ['browser_click', 'browser_type', 'browser_evaluate'].includes(name);
 
@@ -125,7 +137,7 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     error: normalizedError,
     evidenceSource,
     evidenceRelevant,
-    stateChanged,
+    stateChanged: stateChanged && !normalizedError,
     dependsOnOutput: true,
     summary: compactToolResult(name, toolArgs, result || { error: errorMessage || 'Tool failed' }, {
       softLimit: 500,
@@ -141,6 +153,27 @@ function summarizeToolExecutions(toolExecutions = [], maxItems = 10) {
   }).join('\n');
 }
 
+function isSubstantiveProgressToolName(toolName = '') {
+  const name = String(toolName || '').trim();
+  if (!name) return false;
+  if (name === 'send_message' || name === 'send_interim_update' || name === 'make_call') return false;
+  if (name === 'think' || name === 'activate_tools' || name === 'task_complete') return false;
+  return true;
+}
+
+function isSubstantiveProgressEvidence(item = {}) {
+  if (!isSubstantiveProgressToolName(item.toolName)) return false;
+  if (item.evidenceSource === 'messaging') return false;
+  return Boolean(item.evidenceRelevant || item.stateChanged || item.error);
+}
+
+function summarizeProgressToolExecutions(toolExecutions = [], maxItems = 10) {
+  return summarizeToolExecutions(
+    toolExecutions.filter(isSubstantiveProgressEvidence),
+    maxItems,
+  );
+}
+
 function summarizeAvailableTools(tools = [], { exclude = [] } = {}) {
   const excluded = new Set((Array.isArray(exclude) ? exclude : [exclude]).filter(Boolean));
   return tools
@@ -202,6 +235,9 @@ function buildAutonomousRecoveryContext({ err, toolExecutions = [], tools = [],
 module.exports = {
   classifyToolExecution,
   deriveEvidenceSource,
+  isSubstantiveProgressEvidence,
+  isSubstantiveProgressToolName,
+  summarizeProgressToolExecutions,
   summarizeToolExecutions,
   summarizeAvailableTools,
   inferToolFailureMessage,

package/server/services/ai/toolResult.js

@@ -91,6 +91,35 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
       });
       break;
 
+    case 'read_files':
+      envelope = trimObject({
+        tool: toolName,
+        count: toolResult?.count || 0,
+        truncated: toolResult?.truncated || false,
+        results: (toolResult?.results || []).slice(0, 6).map((item) => trimObject({
+          path: item.path || item.requestedPath,
+          requestedPath: item.requestedPath,
+          rangeShown: item.rangeShown,
+          error: item.error,
+          content: lineExcerpt(item.content || '', 10, Math.floor(softLimit * 0.22))
+        }))
+      });
+      break;
+
+    case 'replace_file_range':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
+        path: toolResult?.path || toolArgs.path,
+        startLine: toolResult?.startLine || toolArgs.start_line,
+        endLine: toolResult?.endLine || toolArgs.end_line,
+        replacedLines: toolResult?.replacedLines,
+        insertedLines: toolResult?.insertedLines,
+        totalLines: toolResult?.totalLines,
+        error: toolResult?.error
+      });
+      break;
+
     case 'search_files':
       envelope = trimObject({
         tool: toolName,

package/server/services/ai/toolRunner.js

@@ -1,9 +1,13 @@
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
 const db = require('../../db/database');
 const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 
 const SKILLS_DIR = path.join(AGENT_DATA_DIR, 'skills');
+const USER_SKILLS_DIR = path.join(SKILLS_DIR, 'users');
+const LEGACY_SKILL_USER_ID = 0;
 
 function shellEscape(value) {
   const text = String(value ?? '');
@@ -30,13 +34,56 @@ function clampText(value, maxChars) {
 }
 
 function isValidUserId(userId) {
+  return normalizeRuntimeUserId(userId) !== null;
+}
+
+function normalizeRuntimeUserId(userId) {
   if (typeof userId === 'number') {
-    return Number.isInteger(userId) && userId > 0;
+    return Number.isInteger(userId) && userId > 0 ? userId : null;
   }
   if (typeof userId === 'string') {
-    return userId.trim() !== '';
+    const trimmed = userId.trim();
+    if (!trimmed) return null;
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  return null;
+}
+
+function normalizeStoredUserId(userId) {
+  if (typeof userId === 'number' && Number.isInteger(userId)) {
+    return userId;
+  }
+  if (typeof userId === 'string') {
+    const trimmed = userId.trim();
+    if (!trimmed) return LEGACY_SKILL_USER_ID;
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isInteger(parsed) ? parsed : LEGACY_SKILL_USER_ID;
+  }
+  return LEGACY_SKILL_USER_ID;
+}
+
+function normalizeSkillName(name) {
+  return String(name || '')
+    .trim()
+    .replace(/[^a-z0-9-]/gi, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .toLowerCase();
+}
+
+function buildSkillKey(ownerType, ownerId, name) {
+  return `${ownerType}:${ownerId ?? 'global'}:${name}`;
+}
+
+function parseMetadataJson(value) {
+  if (!value || typeof value !== 'string') return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
   }
-  return false;
 }
 
 class SkillRunner {
@@ -47,47 +94,67 @@ class SkillRunner {
 
   async loadSkills() {
     this.skills.clear();
-    if (!fs.existsSync(SKILLS_DIR)) return;
+    const dbSkills = db.prepare('SELECT * FROM skills').all();
+    const dbSkillPaths = new Set(
+      dbSkills
+        .map((skill) => path.resolve(String(skill.file_path || '')))
+        .filter(Boolean),
+    );
+    const loadedPaths = new Set();
 
     const loadDir = (dir) => {
       const entries = fs.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
+        if (path.resolve(fullPath) === path.resolve(USER_SKILLS_DIR)) {
+          continue;
+        }
         if (entry.isDirectory()) {
           const skillFile = path.join(fullPath, 'SKILL.md');
-          if (fs.existsSync(skillFile)) {
-            this.loadSkillFile(skillFile);
+          if (fs.existsSync(skillFile) && !dbSkillPaths.has(path.resolve(skillFile))) {
+            this.loadSkillFile(skillFile, { ownerType: 'global' });
+            loadedPaths.add(path.resolve(skillFile));
           }
           loadDir(fullPath);
-        } else if (entry.name.endsWith('.md')) {
-          this.loadSkillFile(fullPath);
+        } else if (
+          entry.name.endsWith('.md')
+          && !loadedPaths.has(path.resolve(fullPath))
+          && !dbSkillPaths.has(path.resolve(fullPath))
+        ) {
+          this.loadSkillFile(fullPath, { ownerType: 'global' });
+          loadedPaths.add(path.resolve(fullPath));
         }
       }
     };
 
-    loadDir(SKILLS_DIR);
-
-    const dbSkills = db.prepare('SELECT * FROM skills WHERE enabled = 1').all();
+    if (fs.existsSync(SKILLS_DIR)) {
+      loadDir(SKILLS_DIR);
+    }
     for (const skill of dbSkills) {
       if (fs.existsSync(skill.file_path)) {
-        this.loadSkillFile(skill.file_path);
+        this.loadSkillFile(skill.file_path, {
+          ownerType: normalizeStoredUserId(skill.user_id) > 0 ? 'user' : 'legacy',
+          userId: normalizeStoredUserId(skill.user_id),
+          enabled: skill.enabled !== 0,
+          metadata: parseMetadataJson(skill.metadata),
+        });
       }
     }
   }
 
-  loadSkillFile(filePath) {
+  loadSkillFile(filePath, options = {}) {
     try {
       const content = fs.readFileSync(filePath, 'utf-8');
-      const skill = this.parseSkillMd(content, filePath);
+      const skill = this.parseSkillMd(content, filePath, options);
       if (skill) {
-        this.skills.set(skill.name, skill);
+        this.skills.set(skill.key, skill);
       }
     } catch (err) {
       console.error(`Failed to load skill from ${filePath}:`, err.message);
     }
   }
 
-  parseSkillMd(content, filePath) {
+  parseSkillMd(content, filePath, options = {}) {
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)/);
     if (!frontmatterMatch) return null;
 
@@ -109,15 +176,32 @@ class SkillRunner {
       }
     }
 
-    if (!metadata.name) return null;
+    const name = normalizeSkillName(metadata.name);
+    if (!name) return null;
+
+    const ownerType = options.ownerType || 'global';
+    const userId = ownerType === 'user' || ownerType === 'legacy'
+      ? normalizeStoredUserId(options.userId)
+      : null;
+    const mergedMetadata = {
+      ...metadata,
+      ...(options.metadata && typeof options.metadata === 'object' ? options.metadata : {}),
+    };
+    if (typeof options.enabled === 'boolean') {
+      mergedMetadata.enabled = options.enabled;
+    }
 
     return {
-      name: metadata.name,
+      key: buildSkillKey(ownerType, userId, name),
+      name,
       description: metadata.description || '',
-      metadata,
+      metadata: mergedMetadata,
       instructions: body.trim(),
       filePath,
-      dir: path.dirname(filePath)
+      dir: path.dirname(filePath),
+      ownerType,
+      userId,
+      readOnly: ownerType !== 'user',
     };
   }
 
@@ -125,7 +209,7 @@ class SkillRunner {
     const maxTotalChars = options.maxTotalChars || 9000;
     const maxDescriptionChars = options.maxDescriptionChars || 220;
     const maxTriggerChars = options.maxTriggerChars || 120;
-    const skills = Array.from(this.skills.values())
+    const skills = this.getAll(options.userId)
       .filter((skill) => skill.metadata.enabled !== false)
       .sort((a, b) => {
         const categoryCompare = String(a.metadata?.category || 'general')
@@ -166,9 +250,9 @@ class SkillRunner {
     return `\n${lines.join('\n')}`;
   }
 
-  getToolDefinitions() {
+  getToolDefinitions(options = {}) {
     const tools = [];
-    for (const skill of this.skills.values()) {
+    for (const skill of this.getAll(options.userId)) {
       if (skill.metadata.enabled !== false && skill.metadata.tool) {
         tools.push({
           name: skill.name,
@@ -181,7 +265,7 @@ class SkillRunner {
   }
 
   async executeTool(toolName, args, context = {}) {
-    const skill = this.skills.get(toolName);
+    const skill = this.getSkill(toolName, context.userId);
     if (!skill) return null;
     const metricContext = {
       userId: context.userId,
@@ -272,28 +356,70 @@ class SkillRunner {
     );
   }
 
-  createSkill(name, description, instructions, metadata = {}) {
-    const safeName = name.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
-    const skillDir = path.join(SKILLS_DIR, safeName);
+  createSkill(userId, name, description, instructions, metadata = {}) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    if (ownerId === null) {
+      return { error: 'Missing or invalid userId' };
+    }
+    const safeName = normalizeSkillName(name);
+    if (!safeName) {
+      return { error: 'Skill name is required' };
+    }
+    if (this._findOwnedSkill(safeName, ownerId)) {
+      return { error: `Skill '${safeName}' already exists` };
+    }
+
+    const metaToWrite = metadata && typeof metadata === 'object' ? metadata : {};
+    const skillDir = path.join(USER_SKILLS_DIR, String(ownerId), safeName);
     if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
 
-    const frontmatter = this._buildFrontmatter(safeName, description, metadata);
+    const frontmatter = this._buildFrontmatter(safeName, description, metaToWrite);
     const filePath = path.join(skillDir, 'SKILL.md');
     fs.writeFileSync(filePath, frontmatter + `\n\n${instructions}`);
 
-    db.prepare(`
-      INSERT OR REPLACE INTO skills (name, description, file_path, metadata, enabled, auto_created, updated_at)
-      VALUES (?, ?, ?, ?, ?, 1, datetime('now'))
-    `).run(safeName, description, filePath, JSON.stringify(metadata), metadata.enabled === false ? 0 : 1);
+    try {
+      db.prepare(`
+        INSERT INTO skills (user_id, name, description, file_path, metadata, enabled, auto_created, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, 1, datetime('now'))
+      `).run(
+        ownerId,
+        safeName,
+        description,
+        filePath,
+        JSON.stringify(metaToWrite),
+        metaToWrite.enabled === false ? 0 : 1,
+      );
+    } catch (err) {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {}
+      try {
+        const remaining = fs.readdirSync(skillDir);
+        if (remaining.length === 0) fs.rmdirSync(skillDir);
+      } catch {}
+      if (String(err?.message || '').includes('UNIQUE')) {
+        return { error: `Skill '${safeName}' already exists` };
+      }
+      throw err;
+    }
 
-    this.loadSkillFile(filePath);
+    this.loadSkillFile(filePath, {
+      ownerType: 'user',
+      userId: ownerId,
+      enabled: metaToWrite.enabled !== false,
+      metadata: metaToWrite,
+    });
 
     return { success: true, name: safeName, path: filePath };
   }
 
-  updateSkill(name, { description, instructions, metadata } = {}) {
-    const skill = this.skills.get(name);
+  updateSkill(userId, name, { description, instructions, metadata } = {}) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    const skill = this.getSkill(name, ownerId);
     if (!skill) return { error: `Skill '${name}' not found` };
+    if (!this._canEditSkill(skill, ownerId)) {
+      return { error: `Skill '${skill.name}' is read-only`, code: 'forbidden' };
+    }
 
     const newDesc = description !== undefined ? description : skill.description;
     const newInstructions = instructions !== undefined ? instructions : skill.instructions;
@@ -308,29 +434,57 @@ class SkillRunner {
       metaToWrite = existing;
     }
 
-    const frontmatter = this._buildFrontmatter(name, newDesc, metaToWrite);
+    const frontmatter = this._buildFrontmatter(skill.name, newDesc, metaToWrite);
     fs.writeFileSync(skill.filePath, frontmatter + `\n\n${newInstructions}`);
-    db.prepare('UPDATE skills SET description = ?, metadata = ?, enabled = ?, updated_at = datetime(\'now\') WHERE name = ?')
-      .run(newDesc, JSON.stringify(metaToWrite || {}), metaToWrite?.enabled === false ? 0 : 1, name);
-    this.loadSkillFile(skill.filePath);
-
-    return { success: true, name, path: skill.filePath };
+    db.prepare(
+      `UPDATE skills
+       SET description = ?, metadata = ?, enabled = ?, updated_at = datetime('now')
+       WHERE user_id = ? AND name = ?`
+    ).run(
+      newDesc,
+      JSON.stringify(metaToWrite || {}),
+      metaToWrite?.enabled === false ? 0 : 1,
+      ownerId,
+      skill.name,
+    );
+    this.loadSkillFile(skill.filePath, {
+      ownerType: 'user',
+      userId: ownerId,
+      enabled: metaToWrite?.enabled !== false,
+      metadata: metaToWrite,
+    });
+
+    return { success: true, name: skill.name, path: skill.filePath };
   }
 
-  getSkill(name) {
-    return this.skills.get(name) || null;
+  getSkill(name, userId = null) {
+    const skillName = normalizeSkillName(name);
+    if (!skillName) return null;
+    const ownerId = normalizeRuntimeUserId(userId);
+    if (ownerId !== null) {
+      const owned = this._findOwnedSkill(skillName, ownerId);
+      if (owned) return owned;
+    }
+    return this._findVisibleSkill(skillName, ownerId);
   }
 
-  setSkillEnabled(name, enabled) {
-    const skill = this.skills.get(name);
+  setSkillEnabled(userId, name, enabled) {
+    const skill = this.getSkill(name, userId);
     if (!skill) return { error: `Skill '${name}' not found` };
+    if (!this._canEditSkill(skill, normalizeRuntimeUserId(userId))) {
+      return { error: `Skill '${skill.name}' is read-only`, code: 'forbidden' };
+    }
     const metadata = { ...skill.metadata, enabled: !!enabled };
-    return this.updateSkill(name, { metadata });
+    return this.updateSkill(userId, skill.name, { metadata });
   }
 
-  deleteSkill(name) {
-    const skill = this.skills.get(name);
+  deleteSkill(userId, name) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    const skill = this.getSkill(name, ownerId);
     if (!skill) return { error: `Skill '${name}' not found` };
+    if (!this._canEditSkill(skill, ownerId)) {
+      return { error: `Skill '${skill.name}' is read-only`, code: 'forbidden' };
+    }
 
     try {
       fs.unlinkSync(skill.filePath);
@@ -341,10 +495,10 @@ class SkillRunner {
       }
     } catch (e) { /* ignore */ }
 
-    db.prepare('DELETE FROM skills WHERE name = ?').run(name);
-    this.skills.delete(name);
+    db.prepare('DELETE FROM skills WHERE user_id = ? AND name = ?').run(ownerId, skill.name);
+    this.skills.delete(skill.key);
 
-    return { success: true, deleted: name };
+    return { success: true, deleted: skill.name };
   }
 
   _buildFrontmatter(name, description, metadata = {}) {
@@ -361,15 +515,68 @@ class SkillRunner {
     return fm;
   }
 
-  getAll() {
-    return Array.from(this.skills.values()).map(s => ({
+  getAll(userId = null) {
+    return this._getVisibleSkills(userId).map((s) => ({
       name: s.name,
       description: s.description,
       metadata: s.metadata,
       filePath: s.filePath,
-      enabled: s.metadata.enabled !== false
+      enabled: s.metadata.enabled !== false,
+      userId: s.userId,
+      ownerType: s.ownerType,
+      readOnly: s.readOnly,
     }));
   }
+
+  findSkillByWorkflowSignature(userId, workflowSignature) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    if (ownerId === null || !workflowSignature) return null;
+    return Array.from(this.skills.values()).find(
+      (skill) => skill.ownerType === 'user'
+        && skill.userId === ownerId
+        && skill.metadata?.workflow_signature === workflowSignature,
+    ) || null;
+  }
+
+  _findOwnedSkill(name, userId) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    if (ownerId === null) return null;
+    return this.skills.get(buildSkillKey('user', ownerId, normalizeSkillName(name))) || null;
+  }
+
+  _findVisibleSkill(name, userId) {
+    const skillName = normalizeSkillName(name);
+    return this._getVisibleSkills(userId).find((skill) => skill.name === skillName) || null;
+  }
+
+  _getVisibleSkills(userId = null) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    const visible = Array.from(this.skills.values()).filter((skill) => {
+      if (ownerId === null) return true;
+      if (skill.ownerType === 'user') return skill.userId === ownerId;
+      return true;
+    });
+    if (ownerId === null) return visible;
+    const ownedNames = new Set(
+      visible
+        .filter((skill) => skill.ownerType === 'user' && skill.userId === ownerId)
+        .map((skill) => skill.name),
+    );
+    return visible.filter((skill) => {
+      if (skill.ownerType === 'user') return skill.userId === ownerId;
+      return !ownedNames.has(skill.name);
+    });
+  }
+
+  _canEditSkill(skill, userId) {
+    const ownerId = normalizeRuntimeUserId(userId);
+    return skill?.ownerType === 'user' && skill.userId === ownerId;
+  }
 }
 
-module.exports = { SkillRunner };
+module.exports = {
+  SkillRunner,
+  LEGACY_SKILL_USER_ID,
+  USER_SKILLS_DIR,
+  normalizeSkillName,
+};

package/server/services/ai/toolSelector.js

@@ -15,6 +15,22 @@ const ALWAYS_INCLUDE_BUILT_INS = [
   'send_message',
   'send_interim_update',
 ];
+const CORE_FILE_TOOLS = [
+  'read_file',
+  'read_files',
+  'list_directory',
+  'search_files',
+  'edit_file',
+  'replace_file_range',
+  'write_file',
+];
+
+function requiredToolNames(options = {}) {
+  const requiredNames = [...ALWAYS_INCLUDE_BUILT_INS];
+  if (options.widgetId) requiredNames.push('save_widget_snapshot');
+  if (options.includeCoreFileTools) requiredNames.push(...CORE_FILE_TOOLS);
+  return requiredNames;
+}
 
 function compactDescription(value, maxChars = 180) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
@@ -37,8 +53,7 @@ function buildToolCatalog(tools = []) {
 
 function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}) {
   const limit = Number(options.maxTools) || MAX_TOOLS;
-  const requiredNames = [...ALWAYS_INCLUDE_BUILT_INS];
-  if (options.widgetId) requiredNames.push('save_widget_snapshot');
+  const requiredNames = requiredToolNames(options);
   if (!requiredNames.length) return selectedTools;
 
   const selected = Array.isArray(selectedTools) ? [...selectedTools] : [];
@@ -83,6 +98,7 @@ function selectInitialTools(allTools = [], suggestedNames = [], options = {}) {
 
 function activateTools(currentTools = [], allTools = [], requestedNames = [], options = {}) {
   const knownByName = new Map(allTools.map((tool) => [tool?.name, tool]));
+  const requiredNames = requiredToolNames(options);
   let next = ensureRequiredTools(currentTools, allTools, options);
   const activated = [];
   const evicted = [];
@@ -102,7 +118,7 @@ function activateTools(currentTools = [], allTools = [], requestedNames = [], op
     if (next.some((item) => item?.name === name)) continue;
     if (next.length >= MAX_TOOLS) {
       const replaceIndex = next.findIndex((item) => (
-        !ALWAYS_INCLUDE_BUILT_INS.includes(item?.name)
+        !requiredNames.includes(item?.name)
         && !requested.includes(item?.name)
       ));
       if (replaceIndex === -1) {
@@ -136,6 +152,7 @@ function selectToolsForTask(task, builtInTools = [], mcpTools = [], _options = {
 }
 
 module.exports = {
+  CORE_FILE_TOOLS,
   MAX_TOOLS,
   activateTools,
   buildToolCatalog,