byterover-cli 2.0.0 → 2.1.0

package/dist/agent/infra/tools/implementations/memory-symbol-tree.js

@@ -9,12 +9,14 @@ export var MemorySymbolKind;
     MemorySymbolKind[MemorySymbolKind["Context"] = 4] = "Context";
     MemorySymbolKind[MemorySymbolKind["Domain"] = 1] = "Domain";
     MemorySymbolKind[MemorySymbolKind["Subtopic"] = 3] = "Subtopic";
+    MemorySymbolKind[MemorySymbolKind["Summary"] = 5] = "Summary";
     MemorySymbolKind[MemorySymbolKind["Topic"] = 2] = "Topic";
 })(MemorySymbolKind || (MemorySymbolKind = {}));
 const SYMBOL_KIND_LABELS = {
     [MemorySymbolKind.Context]: 'context',
     [MemorySymbolKind.Domain]: 'domain',
     [MemorySymbolKind.Subtopic]: 'subtopic',
+    [MemorySymbolKind.Summary]: 'summary',
     [MemorySymbolKind.Topic]: 'topic',
 };
 const DEFAULT_METADATA = {
@@ -93,8 +95,11 @@ function getOrCreateFolderNode(symbolMap, root, folderPath, folderSegments) {
  *
  * context.md files are absorbed into their parent folder node (enriching its metadata)
  * rather than being treated as leaf Context nodes.
+ *
+ * @param documentMap - Indexed documents (excludes _index.md, includes stubs)
+ * @param summaryMap - Optional map of _index.md summary documents for folder annotation
  */
-export function buildSymbolTree(documentMap) {
+export function buildSymbolTree(documentMap, summaryMap) {
     const root = [];
     const symbolMap = new Map();
     // First pass: collect all documents, create folder nodes, identify context.md files
@@ -155,6 +160,20 @@ export function buildSymbolTree(documentMap) {
             parentNode.children.push(contextNode);
         }
     }
+    // Fifth pass: attach summary info from _index.md files to their parent folder nodes
+    if (summaryMap) {
+        for (const summary of summaryMap.values()) {
+            const segments = summary.path.split('/');
+            const folderPath = segments.slice(0, -1).join('/');
+            const folderNode = symbolMap.get(folderPath);
+            if (folderNode) {
+                folderNode.summaryInfo = {
+                    condensationOrder: summary.condensationOrder,
+                    tokenCount: summary.tokenCount,
+                };
+            }
+        }
+    }
     // Sort root domains and all children alphabetically
     sortSymbolChildren(root);
     return { root, symbolMap };
@@ -189,14 +208,19 @@ export function getSymbolOverview(tree, path, depth = 2) {
     }
     function traverse(symbols, currentDepth) {
         for (const symbol of symbols) {
-            entries.push({
+            const entry = {
                 childCount: symbol.children.length,
                 importance: symbol.metadata.importance,
                 kind: SYMBOL_KIND_LABELS[symbol.kind] ?? 'unknown',
                 maturity: symbol.metadata.maturity,
                 name: symbol.name,
                 path: symbol.path,
-            });
+            };
+            if (symbol.summaryInfo) {
+                entry.condensationOrder = symbol.summaryInfo.condensationOrder;
+                entry.tokenCount = symbol.summaryInfo.tokenCount;
+            }
+            entries.push(entry);
             if (currentDepth < depth && symbol.children.length > 0) {
                 traverse(symbol.children, currentDepth + 1);
             }

package/dist/agent/infra/tools/implementations/search-knowledge-service.d.ts

@@ -61,6 +61,7 @@ export declare class SearchKnowledgeService implements ISearchKnowledgeService {
     private buildOverviewResult;
     /**
      * Enrich a search result with symbolic metadata and backlink info.
+     * For archive stubs, extracts points_to path into archiveFullPath.
      */
     private enrichResult;
     /**

package/dist/agent/infra/tools/implementations/search-knowledge-service.js

@@ -1,9 +1,11 @@
 import MiniSearch from 'minisearch';
 import { join } from 'node:path';
 import { removeStopwords } from 'stopword';
-import { BRV_DIR, CONTEXT_FILE_EXTENSION, CONTEXT_TREE_DIR } from '../../../../server/constants.js';
+import { BRV_DIR, CONTEXT_FILE_EXTENSION, CONTEXT_TREE_DIR, SUMMARY_INDEX_FILE } from '../../../../server/constants.js';
 import { parseFrontmatterScoring, updateScoringInContent, } from '../../../../server/core/domain/knowledge/markdown-writer.js';
 import { applyDecay, applyDefaultScoring, compoundScore, determineTier, recordAccessHits, } from '../../../../server/core/domain/knowledge/memory-scoring.js';
+import { isArchiveStub, isDerivedArtifact } from '../../../../server/infra/context-tree/derived-artifact.js';
+import { parseArchiveStubFrontmatter, parseSummaryFrontmatter } from '../../../../server/infra/context-tree/summary-frontmatter.js';
 import { isPathLikeQuery, matchMemoryPath, parseSymbolicQuery } from './memory-path-matcher.js';
 import { buildReferenceIndex, buildSymbolTree, getSubtreeDocumentIds, getSymbolKindLabel, getSymbolOverview, MemorySymbolKind, } from './memory-symbol-tree.js';
 const MAX_CONTEXT_TREE_FILES = 10_000;
@@ -207,10 +209,26 @@ async function buildFreshIndex(fileSystem, contextTreePath, filesWithMtime) {
             lastValidatedAt: now,
             referenceIndex: { backlinks: new Map(), forwardLinks: new Map() },
             schemaVersion: INDEX_SCHEMA_VERSION,
+            summaryMap: new Map(),
             symbolTree: { root: [], symbolMap: new Map() },
         };
     }
-    const documentPromises = filesWithMtime.map(async ({ mtime, path: filePath }) => {
+    // Partition files: _index.md → summaryFiles, derived artifacts → skip, rest → indexable
+    const summaryFiles = [];
+    const indexableFiles = [];
+    for (const file of filesWithMtime) {
+        const fileName = file.path.split('/').at(-1) ?? '';
+        if (fileName === SUMMARY_INDEX_FILE) {
+            summaryFiles.push(file);
+        }
+        else if (!isDerivedArtifact(file.path)) {
+            // Includes regular .md files AND .stub.md files (stubs are searchable)
+            indexableFiles.push(file);
+        }
+        // .full.md and _manifest.json are skipped (isDerivedArtifact returns true)
+    }
+    // Read indexable documents for BM25 index
+    const documentPromises = indexableFiles.map(async ({ mtime, path: filePath }) => {
         try {
             const fullPath = join(contextTreePath, filePath);
             const { content } = await fileSystem.readFile(fullPath);
@@ -229,18 +247,49 @@ async function buildFreshIndex(fileSystem, contextTreePath, filesWithMtime) {
             return null;
         }
     });
-    const results = await Promise.all(documentPromises);
-    const documents = results.filter((doc) => doc !== null);
+    // Read _index.md files separately for summaryMap (not indexed in BM25)
+    const summaryPromises = summaryFiles.map(async ({ path: filePath }) => {
+        try {
+            const fullPath = join(contextTreePath, filePath);
+            const { content } = await fileSystem.readFile(fullPath);
+            const fm = parseSummaryFrontmatter(content);
+            if (!fm)
+                return null;
+            return {
+                condensationOrder: fm.condensation_order,
+                path: filePath,
+                tokenCount: fm.token_count,
+            };
+        }
+        catch {
+            return null;
+        }
+    });
+    const [docResults, summaryResults] = await Promise.all([
+        Promise.all(documentPromises),
+        Promise.all(summaryPromises),
+    ]);
+    const documents = docResults.filter((doc) => doc !== null);
     const documentMap = new Map();
     const fileMtimes = new Map();
     for (const doc of documents) {
         documentMap.set(doc.id, doc);
         fileMtimes.set(doc.path, doc.mtime);
     }
+    // Also track summary file mtimes for cache invalidation
+    for (const sf of summaryFiles) {
+        fileMtimes.set(sf.path, sf.mtime);
+    }
+    const summaryMap = new Map();
+    for (const summary of summaryResults) {
+        if (summary) {
+            summaryMap.set(summary.path, summary);
+        }
+    }
     const index = new MiniSearch(MINISEARCH_OPTIONS);
     index.addAll(documents);
-    // Build symbolic structures from the document map
-    const symbolTree = buildSymbolTree(documentMap);
+    // Build symbolic structures from the document map, with summary annotations
+    const symbolTree = buildSymbolTree(documentMap, summaryMap);
     const referenceIndex = buildReferenceIndex(documentMap);
     return {
         contextTreePath,
@@ -250,6 +299,7 @@ async function buildFreshIndex(fileSystem, contextTreePath, filesWithMtime) {
         lastValidatedAt: now,
         referenceIndex,
         schemaVersion: INDEX_SCHEMA_VERSION,
+        summaryMap,
         symbolTree,
     };
 }
@@ -290,11 +340,17 @@ async function acquireIndex(state, fileSystem, contextTreePath, ttlMs, onBeforeB
                     lastValidatedAt: 0,
                     referenceIndex: { backlinks: new Map(), forwardLinks: new Map() },
                     schemaVersion: INDEX_SCHEMA_VERSION,
+                    summaryMap: new Map(),
                     symbolTree: { root: [], symbolMap: new Map() },
                 };
             }
         }
-        const currentFiles = await findMarkdownFilesWithMtime(fileSystem, contextTreePath);
+        const allFiles = await findMarkdownFilesWithMtime(fileSystem, contextTreePath);
+        // Exclude non-indexable derived artifacts (.full.md) so that currentFiles
+        // matches what buildFreshIndex tracks in fileMtimes. Without this filter,
+        // isCacheValid() sees a size mismatch once archives exist, causing cache thrash.
+        // _index.md is kept (tracked for summary staleness), .stub.md is kept (BM25 indexed).
+        const currentFiles = allFiles.filter((f) => !isDerivedArtifact(f.path) || f.path.split('/').at(-1) === SUMMARY_INDEX_FILE);
         // Re-check cache validity after getting file list (another call may have finished)
         if (state.cachedIndex &&
             state.cachedIndex.contextTreePath === contextTreePath &&
@@ -462,15 +518,30 @@ export class SearchKnowledgeService {
     }
     /**
      * Enrich a search result with symbolic metadata and backlink info.
+     * For archive stubs, extracts points_to path into archiveFullPath.
      */
-    enrichResult(result, symbolTree, referenceIndex) {
+    enrichResult(result, symbolTree, referenceIndex, documentMap) {
         const symbol = symbolTree.symbolMap.get(result.path);
         const backlinks = referenceIndex.backlinks.get(result.path);
+        // Detect archive stubs and extract points_to for drill-down
+        let archiveFullPath;
+        let symbolKind = symbol ? getSymbolKindLabel(symbol.kind) : undefined;
+        if (isArchiveStub(result.path)) {
+            symbolKind = 'archive_stub';
+            const doc = documentMap.get(result.path);
+            if (doc) {
+                const stubFm = parseArchiveStubFrontmatter(doc.content);
+                if (stubFm) {
+                    archiveFullPath = stubFm.points_to;
+                }
+            }
+        }
         return {
             ...result,
+            ...(archiveFullPath && { archiveFullPath }),
             backlinkCount: backlinks?.length ?? 0,
             relatedPaths: backlinks?.slice(0, 3),
-            symbolKind: symbol ? getSymbolKindLabel(symbol.kind) : undefined,
+            symbolKind,
             symbolPath: symbol?.path,
         };
     }
@@ -558,7 +629,7 @@ export class SearchKnowledgeService {
                         path: document.path,
                         score: Math.round(result.score * 100) / 100,
                         title: document.title,
-                    }, symbolTree, referenceIndex);
+                    }, symbolTree, referenceIndex, documentMap);
                     // Apply kind/maturity filters if specified
                     if (options?.includeKinds && enriched.symbolKind && !options.includeKinds.includes(enriched.symbolKind)) {
                         continue;
@@ -606,7 +677,7 @@ export class SearchKnowledgeService {
             if (!doc) {
                 return null;
             }
-            const result = this.enrichResult({ excerpt: extractExcerpt(doc.content, query), path: doc.path, score: 1, title: doc.title }, symbolTree, referenceIndex);
+            const result = this.enrichResult({ excerpt: extractExcerpt(doc.content, query), path: doc.path, score: 1, title: doc.title }, symbolTree, referenceIndex, documentMap);
             this.accumulateAccessHits([doc.path]);
             return {
                 message: `Found exact match: ${topMatch.path}`,
@@ -631,7 +702,7 @@ export class SearchKnowledgeService {
             const doc = documentMap.get(docId);
             if (!doc)
                 continue;
-            results.push(this.enrichResult({ excerpt: extractExcerpt(doc.content, query), path: doc.path, score: 0.9, title: doc.title }, symbolTree, referenceIndex));
+            results.push(this.enrichResult({ excerpt: extractExcerpt(doc.content, query), path: doc.path, score: 0.9, title: doc.title }, symbolTree, referenceIndex, documentMap));
         }
         if (results.length > 0) {
             this.accumulateAccessHits(results.map((r) => r.path));

package/dist/agent/infra/tools/implementations/search-knowledge-tool.js

@@ -4,11 +4,11 @@ import { SearchKnowledgeService } from './search-knowledge-service.js';
 const SearchKnowledgeInputSchema = z
     .object({
     excludeKinds: z
-        .array(z.enum(['context', 'domain', 'subtopic', 'topic']))
+        .array(z.enum(['archive_stub', 'context', 'domain', 'subtopic', 'topic']))
         .optional()
         .describe('Symbol kinds to exclude from results'),
     includeKinds: z
-        .array(z.enum(['context', 'domain', 'subtopic', 'topic']))
+        .array(z.enum(['archive_stub', 'context', 'domain', 'subtopic', 'topic']))
         .optional()
         .describe('Symbol kinds to include in results (filters out others)'),
     limit: z

package/dist/agent/infra/tools/tool-manager.js

@@ -29,7 +29,10 @@ export class ToolManager {
      * Uses code_exec only - curate operations available via tools.curate() in sandbox.
      */
     static CURATE_TOOL_NAMES = [
+        'agentic_map',
         'code_exec',
+        'expand_knowledge',
+        'llm_map',
     ];
     /**
      * Tools allowed for query operations - only code_exec for programmatic search
@@ -38,6 +41,7 @@ export class ToolManager {
      */
     static QUERY_TOOL_NAMES = [
         'code_exec',
+        'expand_knowledge',
     ];
     cacheValid = false;
     callIdCounter = 0;
@@ -113,6 +117,8 @@ export class ToolManager {
             // Execute tool via scheduler (with policy check) or directly via provider
             const result = this.scheduler
                 ? await this.scheduler.execute(toolName, effectiveArgs, {
+                    commandType: effectiveContext.commandType,
+                    metadata: effectiveContext.metadata,
                     sessionId: sessionId ?? 'default',
                     taskId: effectiveContext.taskId,
                 })

package/dist/agent/infra/tools/tool-provider.d.ts

@@ -13,6 +13,12 @@ import { ToolMarker } from './tool-markers.js';
  * 2. Execution phase (via invocation)
  */
 export declare class ToolProvider implements IToolProvider {
+    /**
+     * Known keys of ToolServices — used for runtime validation of Record<string, unknown> input.
+     * Derived from ToolServices type to prevent drift.
+     * TypeScript ensures this object matches ToolServices keys at compile time.
+     */
+    private static readonly VALID_SERVICE_KEYS;
     private readonly descriptionLoader?;
     private initialized;
     private invocationBuilder?;
@@ -74,6 +80,12 @@ export declare class ToolProvider implements IToolProvider {
      * If a description loader is provided, tool descriptions are loaded from external files.
      */
     initialize(): Promise<void>;
+    /**
+     * Atomically replace specific tools with new service dependencies.
+     * Build-then-swap pattern: builds new tool instances first, only swaps if all succeed.
+     * Throws if any requested tool cannot be rebuilt (no partial swap).
+     */
+    replaceTools(toolNames: string[], newServices: Record<string, unknown>): void;
     /**
      * Update services and re-register tools that depend on newly available services.
      * This is used to inject services that are created after ToolProvider initialization

package/dist/agent/infra/tools/tool-provider.js

@@ -12,6 +12,25 @@ import { convertZodToJsonSchema } from './utils/schema-converter.js';
  * 2. Execution phase (via invocation)
  */
 export class ToolProvider {
+    /**
+     * Known keys of ToolServices — used for runtime validation of Record<string, unknown> input.
+     * Derived from ToolServices type to prevent drift.
+     * TypeScript ensures this object matches ToolServices keys at compile time.
+     */
+    static VALID_SERVICE_KEYS = new Set(Object.keys({
+        agentInstance: 0,
+        contentGenerator: 0,
+        environmentContext: 0,
+        fileSystemService: 0,
+        getToolProvider: 0,
+        logger: 0,
+        maxContextTokens: 0,
+        memoryManager: 0,
+        processService: 0,
+        sandboxService: 0,
+        todoStorage: 0,
+        tokenizer: 0,
+    }));
     descriptionLoader;
     initialized = false;
     invocationBuilder;
@@ -178,6 +197,65 @@ export class ToolProvider {
         this.invocationBuilder = new ToolInvocationBuilder(this.tools);
         this.initialized = true;
     }
+    /**
+     * Atomically replace specific tools with new service dependencies.
+     * Build-then-swap pattern: builds new tool instances first, only swaps if all succeed.
+     * Throws if any requested tool cannot be rebuilt (no partial swap).
+     */
+    replaceTools(toolNames, newServices) {
+        // 0. Runtime key validation — catch typos in Record<string, unknown> early
+        for (const key of Object.keys(newServices)) {
+            if (!ToolProvider.VALID_SERVICE_KEYS.has(key)) {
+                throw new Error(`replaceTools: unknown service key "${key}" — valid keys: ${[...ToolProvider.VALID_SERVICE_KEYS].join(', ')}`);
+            }
+        }
+        // 1. Merge new services into existing (cast from Record to ToolServices)
+        const mergedServices = {
+            ...this.services,
+            ...newServices,
+        };
+        // 2. Deduplicate input tool names
+        const uniqueToolNames = [...new Set(toolNames)];
+        // 3. Stage new tool instances — fail hard if any tool cannot be built
+        const stagedTools = new Map();
+        for (const toolName of uniqueToolNames) {
+            const entry = TOOL_REGISTRY[toolName];
+            if (!entry) {
+                throw new Error(`replaceTools: unknown tool "${toolName}" not in TOOL_REGISTRY`);
+            }
+            // Check required services
+            const allServicesAvailable = entry.requiredServices.every((serviceName) => mergedServices[serviceName] !== undefined);
+            if (!allServicesAvailable) {
+                throw new Error(`replaceTools: missing required services for "${toolName}": ${entry.requiredServices.join(', ')}`);
+            }
+            // Build tool (throws on factory failure — old tools remain intact)
+            const tool = entry.factory(mergedServices);
+            // Apply description loader overrides
+            const fileDescription = this.loadExternalDescription(entry.descriptionFile);
+            if (fileDescription) {
+                tool.description = fileDescription;
+            }
+            stagedTools.set(toolName, tool);
+        }
+        // 4. Swap atomically — only reached if ALL builds succeeded
+        this.services = mergedServices;
+        for (const [name, tool] of stagedTools) {
+            this.tools.set(name, tool);
+        }
+        // 5. Recompute markers from all registered tools
+        this.toolMarkers.clear();
+        for (const [toolName, entry] of Object.entries(TOOL_REGISTRY)) {
+            if (this.tools.has(toolName)) {
+                for (const marker of entry.markers) {
+                    this.toolMarkers.add(marker);
+                }
+            }
+        }
+        // 6. Rebuild invocationBuilder
+        if (this.initialized && this.invocationBuilder) {
+            this.invocationBuilder = new ToolInvocationBuilder(this.tools);
+        }
+    }
     /**
      * Update services and re-register tools that depend on newly available services.
      * This is used to inject services that are created after ToolProvider initialization

package/dist/agent/infra/tools/tool-registry.d.ts

@@ -1,10 +1,14 @@
 import type { EnvironmentContext } from '../../core/domain/environment/types.js';
 import type { KnownTool } from '../../core/domain/tools/constants.js';
 import type { Tool } from '../../core/domain/tools/types.js';
+import type { ICipherAgent } from '../../core/interfaces/i-cipher-agent.js';
+import type { IContentGenerator } from '../../core/interfaces/i-content-generator.js';
 import type { IFileSystem } from '../../core/interfaces/i-file-system.js';
+import type { ILogger } from '../../core/interfaces/i-logger.js';
 import type { IProcessService } from '../../core/interfaces/i-process-service.js';
 import type { ISandboxService } from '../../core/interfaces/i-sandbox-service.js';
 import type { ITodoStorage } from '../../core/interfaces/i-todo-storage.js';
+import type { ITokenizer } from '../../core/interfaces/i-tokenizer.js';
 import type { MemoryManager } from '../memory/memory-manager.js';
 import type { ToolProviderGetter } from './tool-provider-getter.js';
 import { ToolMarker } from './tool-markers.js';
@@ -13,6 +17,10 @@ import { ToolMarker } from './tool-markers.js';
  * Tools declare which services they need via requiredServices.
  */
 export interface ToolServices {
+    /** Agent instance for creating sub-sessions (used by agentic_map) */
+    agentInstance?: ICipherAgent;
+    /** Content generator for stateless LLM calls (used by llm_map) */
+    contentGenerator?: IContentGenerator;
     /** Environment context for sandbox injection */
     environmentContext?: EnvironmentContext;
     /** File system service for file operations */
@@ -22,6 +30,10 @@ export interface ToolServices {
      * Used by batch tool to execute other tools.
      */
     getToolProvider?: ToolProviderGetter;
+    /** Logger for fail-open warnings in map tools */
+    logger?: ILogger;
+    /** Max context tokens for ContextTreeStore τ_hard computation */
+    maxContextTokens?: number;
     /** Memory manager for agent memory operations */
     memoryManager?: MemoryManager;
     /** Process service for command execution */
@@ -30,6 +42,8 @@ export interface ToolServices {
     sandboxService?: ISandboxService;
     /** Todo storage service for session-based todo persistence */
     todoStorage?: ITodoStorage;
+    /** Tokenizer for ContextTreeStore token counting */
+    tokenizer?: ITokenizer;
 }
 /**
  * Tool factory function type.

package/dist/agent/infra/tools/tool-registry.js

@@ -1,10 +1,13 @@
 import { ToolName } from '../../core/domain/tools/constants.js';
 import { createCurateService } from '../sandbox/curate-service.js';
+import { createAgenticMapTool } from './implementations/agentic-map-tool.js';
 import { createCodeExecTool } from './implementations/code-exec-tool.js';
 import { createCurateTool } from './implementations/curate-tool.js';
+import { createExpandKnowledgeTool } from './implementations/expand-knowledge-tool.js';
 import { createGlobFilesTool } from './implementations/glob-files-tool.js';
 import { createGrepContentTool } from './implementations/grep-content-tool.js';
 import { createListDirectoryTool } from './implementations/list-directory-tool.js';
+import { createLlmMapTool } from './implementations/llm-map-tool.js';
 import { createReadFileTool } from './implementations/read-file-tool.js';
 import { createSearchKnowledgeService } from './implementations/search-knowledge-service.js';
 import { createSearchKnowledgeTool } from './implementations/search-knowledge-tool.js';
@@ -35,6 +38,20 @@ function getRequiredService(service, serviceName) {
  * 3. Add entry to this registry
  */
 export const TOOL_REGISTRY = {
+    [ToolName.AGENTIC_MAP]: {
+        factory({ agentInstance, contentGenerator, environmentContext, logger, maxContextTokens, tokenizer }) {
+            const agent = getRequiredService(agentInstance, 'agentInstance');
+            const workingDirectory = environmentContext?.workingDirectory ?? process.cwd();
+            return createAgenticMapTool(agent, workingDirectory, {
+                generator: contentGenerator,
+                logger,
+                maxContextTokens,
+                tokenizer,
+            });
+        },
+        markers: [ToolMarker.Execution],
+        requiredServices: ['agentInstance'],
+    },
     [ToolName.CODE_EXEC]: {
         descriptionFile: 'code_exec',
         factory({ environmentContext, fileSystemService, sandboxService }) {
@@ -69,6 +86,12 @@ export const TOOL_REGISTRY = {
         outputGuidance: 'curate',
         requiredServices: [], // Uses DirectoryManager and MarkdownWriter for file operations
     },
+    [ToolName.EXPAND_KNOWLEDGE]: {
+        descriptionFile: 'expand_knowledge',
+        factory: ({ environmentContext }) => createExpandKnowledgeTool({ baseDirectory: environmentContext?.workingDirectory }),
+        markers: [ToolMarker.Discovery],
+        requiredServices: [],
+    },
     [ToolName.GLOB_FILES]: {
         descriptionFile: 'glob_files',
         factory: (services) => createGlobFilesTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
@@ -87,6 +110,15 @@ export const TOOL_REGISTRY = {
         markers: [ToolMarker.Discovery],
         requiredServices: ['fileSystemService'],
     },
+    [ToolName.LLM_MAP]: {
+        factory({ contentGenerator, environmentContext, logger, maxContextTokens, tokenizer }) {
+            const generator = getRequiredService(contentGenerator, 'contentGenerator');
+            const workingDirectory = environmentContext?.workingDirectory ?? process.cwd();
+            return createLlmMapTool(generator, workingDirectory, { logger, maxContextTokens, tokenizer });
+        },
+        markers: [ToolMarker.Execution],
+        requiredServices: ['contentGenerator'],
+    },
     [ToolName.READ_FILE]: {
         descriptionFile: 'read_file',
         factory: (services) => createReadFileTool(getRequiredService(services.fileSystemService, 'fileSystemService')),