byterover-cli 0.4.0 → 1.0.0

package/dist/infra/cipher/tools/implementations/list-directory-tool.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Input schema for list directory tool.
+ */
+const ListDirectoryInputSchema = z
+    .object({
+    ignore: z
+        .array(z.string())
+        .optional()
+        .describe('Additional glob patterns to ignore (e.g., ["*.log", "temp/"])'),
+    maxResults: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .default(100)
+        .describe('Maximum number of files to return (default: 100)'),
+    path: z
+        .string()
+        .optional()
+        .describe('The absolute path to the directory to list (defaults to working directory)'),
+})
+    .strict();
+/**
+ * Creates the list directory tool.
+ *
+ * Lists files and directories in a tree structure.
+ * Automatically ignores common build artifacts and caches.
+ *
+ * @param fileSystemService - File system service dependency
+ * @returns Configured list directory tool
+ */
+export function createListDirectoryTool(fileSystemService) {
+    return {
+        description: 'Lists files and directories in a tree structure. Automatically ignores common build artifacts (node_modules, dist, .git, etc.).',
+        async execute(input, _context) {
+            const { ignore, maxResults, path } = input;
+            const result = await fileSystemService.listDirectory(path ?? '.', {
+                ignore,
+                maxResults,
+            });
+            return {
+                count: result.count,
+                tree: result.tree,
+                truncated: result.truncated,
+            };
+        },
+        id: ToolName.LIST_DIRECTORY,
+        inputSchema: ListDirectoryInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/read-file-tool.d.ts

@@ -4,7 +4,14 @@ import type { IFileSystem } from '../../../../core/interfaces/cipher/i-file-syst
  * Creates the read file tool.
  *
  * Reads the contents of a file with optional pagination support.
- * Supports offset (starting line) and limit (max lines) for large files.
+ *
+ * Features:
+ * - Accepts both absolute and relative paths
+ * - Image/PDF files returned as base64 attachments for multimodal LLMs
+ * - Binary file detection with clear error messages
+ * - .env file blocking with whitelist for example files
+ * - XML-wrapped output for clearer LLM parsing
+ * - Preview metadata for UI display
  *
  * @param fileSystemService - File system service dependency
  * @returns Configured read file tool

package/dist/infra/cipher/tools/implementations/read-file-tool.js

@@ -5,13 +5,13 @@ import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
  */
 const ReadFileInputSchema = z
     .object({
-    filePath: z.string().describe('Absolute path to the file to read'),
+    filePath: z.string().describe('Path to the file to read (absolute or relative to working directory)'),
     limit: z
         .number()
         .int()
         .positive()
         .optional()
-        .describe('Maximum number of lines to read (optional)'),
+        .describe('Maximum number of lines to read (optional, default: 2000)'),
     offset: z
         .number()
         .int()
@@ -24,14 +24,21 @@ const ReadFileInputSchema = z
  * Creates the read file tool.
  *
  * Reads the contents of a file with optional pagination support.
- * Supports offset (starting line) and limit (max lines) for large files.
+ *
+ * Features:
+ * - Accepts both absolute and relative paths
+ * - Image/PDF files returned as base64 attachments for multimodal LLMs
+ * - Binary file detection with clear error messages
+ * - .env file blocking with whitelist for example files
+ * - XML-wrapped output for clearer LLM parsing
+ * - Preview metadata for UI display
  *
  * @param fileSystemService - File system service dependency
  * @returns Configured read file tool
  */
 export function createReadFileTool(fileSystemService) {
     return {
-        description: 'Read the contents of a file. Supports pagination with offset (1-based line number) and limit (max lines).',
+        description: 'Read the contents of a file. Supports relative/absolute paths, pagination, and returns images/PDFs as base64 attachments.',
         async execute(input, _context) {
             const { filePath, limit, offset } = input;
             // Call file system service
@@ -39,12 +46,15 @@ export function createReadFileTool(fileSystemService) {
                 limit,
                 offset,
             });
-            // Return formatted result
+            // Return formatted result with all metadata
             return {
-                content: result.content,
-                encoding: result.encoding,
+                attachment: result.attachment,
+                content: result.formattedContent,
                 lines: result.lines,
+                message: result.message,
+                preview: result.preview,
                 size: result.size,
+                totalLines: result.totalLines,
                 truncated: result.truncated,
             };
         },

package/dist/infra/cipher/tools/implementations/read-todos-tool.d.ts

@@ -0,0 +1,11 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { ITodoStorage } from '../../../../core/interfaces/cipher/i-todo-storage.js';
+/**
+ * Creates the read todos tool.
+ *
+ * Reads the current todo list from session storage.
+ *
+ * @param todoStorage - Storage service for retrieving todos
+ * @returns Configured read todos tool
+ */
+export declare function createReadTodosTool(todoStorage: ITodoStorage): Tool;

package/dist/infra/cipher/tools/implementations/read-todos-tool.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Input schema for read todos tool.
+ * No parameters required - reads todos for current session.
+ */
+const ReadTodosInputSchema = z.object({}).strict();
+/**
+ * Tool description for read todos.
+ */
+const TOOL_DESCRIPTION = `Read the current todo list for this session.
+
+Use this tool to check the current state of your task list before making updates.
+Returns all todo items with their id, content, activeForm, and status.`;
+/**
+ * Creates the read todos tool.
+ *
+ * Reads the current todo list from session storage.
+ *
+ * @param todoStorage - Storage service for retrieving todos
+ * @returns Configured read todos tool
+ */
+export function createReadTodosTool(todoStorage) {
+    return {
+        description: TOOL_DESCRIPTION,
+        async execute(_input, context) {
+            const sessionId = context?.sessionId ?? 'default';
+            const todos = await todoStorage.get(sessionId);
+            const incompleteCount = todos.filter((t) => t.status !== 'completed').length;
+            return {
+                content: JSON.stringify(todos, null, 2),
+                metadata: { todos },
+                title: `${incompleteCount} todos`,
+            };
+        },
+        id: ToolName.READ_TODOS,
+        inputSchema: ReadTodosInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/{detect-domains-tool.d.ts → spec-analyze-tool.d.ts}

@@ -4,4 +4,4 @@ import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
  *
  * @returns Configured detect domains tool
  */
-export declare function createDetectDomainsTool(): Tool;
+export declare function createSpecAnalyzeTool(): Tool;

package/dist/infra/cipher/tools/implementations/{detect-domains-tool.js → spec-analyze-tool.js}

@@ -1,17 +1,17 @@
 import { z } from 'zod';
-import { CONTEXT_TREE_DOMAINS } from '../../../../config/context-tree-domains.js';
+import { DEFAULT_CONTEXT_TREE_DOMAINS } from '../../../../config/context-tree-domains.js';
 import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
 /**
  * Predefined domain category names for validation reference
  */
-const PREDEFINED_DOMAIN_NAMES = CONTEXT_TREE_DOMAINS.map((domain) => domain.name);
+const PREDEFINED_DOMAIN_NAMES = DEFAULT_CONTEXT_TREE_DOMAINS.map((domain) => domain.name);
 /**
  * Domain category for knowledge classification.
  */
 const DomainCategory = z
     .string()
     .min(1)
-    .describe(`Domain category name. Must be one of the predefined categories: ${PREDEFINED_DOMAIN_NAMES.join(', ')}`);
+    .describe(`Domain category name. Prefer using predefined domains: ${PREDEFINED_DOMAIN_NAMES.join(', ')}. Custom domains are allowed but limited to 3 maximum.`);
 /**
  * Text segment schema - represents a portion of the input data related to a domain
  */
@@ -49,8 +49,8 @@ async function executeDetectDomains(input, _context) {
  *
  * @returns Configured detect domains tool
  */
-export function createDetectDomainsTool() {
-    const domainDescriptions = CONTEXT_TREE_DOMAINS.map((domain) => `  - ${domain.name}: ${domain.description}`).join('\n');
+export function createSpecAnalyzeTool() {
+    const domainDescriptions = DEFAULT_CONTEXT_TREE_DOMAINS.map((domain) => `  - ${domain.name}: ${domain.description}`).join('\n');
     return {
         description: `Use this tool to analyze input data and detect which predefined knowledge domains are present. For each detected domain, you must also extract the specific text segments from the input data that relate to that domain.
 
@@ -60,14 +60,16 @@ Predefined domain categories:
 ${domainDescriptions}
 
 For each domain you detect:
-1. Identify the domain category (must be one of the predefined categories above)
+1. Identify the domain category from the predefined list above. Only create a custom domain if the content clearly does not fit any predefined domain (max 3 custom domains allowed)
 2. Extract relevant text segments from the input data that demonstrate why this domain is relevant
 3. Each text segment should be a meaningful excerpt (not just keywords) that shows the connection to the domain
 4. Only include domains that are actually present in the data - do not include domains just because they exist in the predefined list
 
+**Important:** Always prefer predefined domains over custom ones to maintain query quality and ease of maintenance.
+
 The text segments will be used later to create organized knowledge topics, so they should be substantial enough to provide context.`,
         execute: executeDetectDomains,
-        id: ToolName.DETECT_DOMAINS,
+        id: ToolName.SPEC_ANALYZE,
         inputSchema: DetectDomainsInputSchema,
     };
 }

package/dist/infra/cipher/tools/implementations/task-tool.d.ts

@@ -0,0 +1,34 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { SessionManager } from '../../session/session-manager.js';
+/**
+ * Tool name constant for task tool.
+ */
+export declare const TASK_TOOL_NAME: "task";
+/**
+ * Lazy getter for session manager (avoids circular dependency).
+ */
+export type SessionManagerGetter = () => SessionManager | undefined;
+/**
+ * Dependencies for creating the task tool.
+ */
+export interface TaskToolDependencies {
+    /**
+     * Lazy getter for session manager.
+     * SessionManager is created after ToolProvider, so we need a getter.
+     */
+    getSessionManager: SessionManagerGetter;
+}
+/**
+ * Create task tool.
+ *
+ * Delegates work to specialized subagents for complex tasks.
+ * Each subagent runs in its own session with agent-specific prompts and tool restrictions.
+ *
+ * Available subagents:
+ * - query: Search and retrieve information from the context tree
+ * - curate: Create or update knowledge topics in the context tree
+ *
+ * @param dependencies - Session manager and system prompt manager
+ * @returns task tool instance
+ */
+export declare function createTaskTool(dependencies: TaskToolDependencies): Tool;

package/dist/infra/cipher/tools/implementations/task-tool.js

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { getAgentRegistry } from '../../../../core/domain/cipher/agent/agent-registry.js';
+import { createContextTreeFileSystem } from '../../file-system/context-tree-file-system-factory.js';
+/**
+ * Tool name constant for task tool.
+ */
+export const TASK_TOOL_NAME = 'task';
+/**
+ * Input schema for task tool.
+ */
+const TaskInputSchema = z
+    .object({
+    /**
+     * If true, restricts file operations to .brv/context-tree/ only.
+     * Use this for query commands to search only curated knowledge.
+     */
+    contextTreeOnly: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If true, restricts file operations to .brv/context-tree/ only'),
+    /**
+     * Short description of the task (3-5 words).
+     * Used for display and tracking purposes.
+     */
+    description: z.string().min(1).max(100).describe('Short description of the task (3-5 words)'),
+    /**
+     * Detailed prompt/instructions for the subagent.
+     * Should include all context needed to complete the task.
+     */
+    prompt: z.string().min(1).describe('Detailed instructions for the subagent'),
+    /**
+     * Optional session ID to continue an existing subagent session.
+     * If not provided, a new session will be created.
+     */
+    sessionId: z.string().optional().describe('Optional: continue existing subagent session'),
+    /**
+     * The type of subagent to use.
+     * Must be a registered subagent name (e.g., "query", "curate").
+     */
+    subagentType: z.string().min(1).describe('Which subagent to use (e.g., "explore", "curate")'),
+})
+    .strict();
+/**
+ * Create task tool.
+ *
+ * Delegates work to specialized subagents for complex tasks.
+ * Each subagent runs in its own session with agent-specific prompts and tool restrictions.
+ *
+ * Available subagents:
+ * - query: Search and retrieve information from the context tree
+ * - curate: Create or update knowledge topics in the context tree
+ *
+ * @param dependencies - Session manager and system prompt manager
+ * @returns task tool instance
+ */
+export function createTaskTool(dependencies) {
+    const { getSessionManager } = dependencies;
+    const registry = getAgentRegistry();
+    return {
+        description: buildTaskToolDescription(registry),
+        async execute(input, context) {
+            const params = input;
+            const { contextTreeOnly, description, prompt, sessionId, subagentType } = params;
+            // Get session manager (lazy loaded)
+            const sessionManager = getSessionManager();
+            if (!sessionManager) {
+                return {
+                    agent: subagentType,
+                    description,
+                    error: 'SessionManager is not available. Task tool requires an active agent session.',
+                    output: '',
+                    sessionId: '',
+                    success: false,
+                };
+            }
+            // Validate subagent exists
+            const agent = registry.get(subagentType);
+            if (!agent) {
+                const availableAgents = registry
+                    .listSubagents()
+                    .map((a) => a.name)
+                    .join(', ');
+                return {
+                    agent: subagentType,
+                    description,
+                    error: `Unknown subagent type '${subagentType}'. Available subagents: ${availableAgents}`,
+                    output: '',
+                    sessionId: '',
+                    success: false,
+                };
+            }
+            // Validate agent can be used as subagent
+            if (agent.mode === 'primary') {
+                return {
+                    agent: subagentType,
+                    description,
+                    error: `Agent '${subagentType}' is a primary agent and cannot be used as a subagent.`,
+                    output: '',
+                    sessionId: '',
+                    success: false,
+                };
+            }
+            // Generate session ID for the subagent
+            const subagentSessionId = sessionId ?? `${subagentType}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            try {
+                // Get or create session for the subagent
+                // If contextTreeOnly is true, create a session with restricted file system
+                let session;
+                if (contextTreeOnly) {
+                    // Create a restricted FileSystemService for context-tree only access
+                    const restrictedFs = createContextTreeFileSystem(process.cwd());
+                    await restrictedFs.initialize();
+                    // Create session with restricted file system
+                    session = await sessionManager.createChildSessionWithOverrides(context?.sessionId ?? 'parent', agent.name, subagentSessionId, { fileSystemService: restrictedFs });
+                }
+                else {
+                    session = await sessionManager.createSession(subagentSessionId);
+                }
+                // Build the system prompt for the subagent
+                // The agent's promptFile will be used by the SystemPromptManager
+                const agentPromptSection = agent.promptFile
+                    ? `\n\n[Agent: ${agent.name}]\nUsing prompt from: ${agent.promptFile}`
+                    : agent.prompt
+                        ? `\n\n[Agent: ${agent.name}]\n${agent.prompt}`
+                        : '';
+                // Construct the full message for the subagent
+                const fullPrompt = `${agentPromptSection}\n\n## Task\n${prompt}`;
+                // Stream progress update
+                if (context?.metadata) {
+                    context.metadata({
+                        description: `Running ${agent.name} subagent`,
+                        output: `Task: ${description}`,
+                        progress: 10,
+                    });
+                }
+                // Execute the subagent session with parent's taskId for billing tracking
+                const response = await session.run(fullPrompt, { taskId: context?.taskId });
+                // Stream completion update
+                if (context?.metadata) {
+                    context.metadata({
+                        description: `${agent.name} subagent completed`,
+                        output: response.slice(0, 200) + (response.length > 200 ? '...' : ''),
+                        progress: 100,
+                    });
+                }
+                return {
+                    agent: agent.name,
+                    description,
+                    output: response,
+                    sessionId: subagentSessionId,
+                    success: true,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Stream error update
+                if (context?.metadata) {
+                    context.metadata({
+                        description: `${agent.name} subagent failed`,
+                        output: errorMessage,
+                        progress: 100,
+                    });
+                }
+                return {
+                    agent: agent.name,
+                    description,
+                    error: errorMessage,
+                    output: '',
+                    sessionId: subagentSessionId,
+                    success: false,
+                };
+            }
+        },
+        id: TASK_TOOL_NAME,
+        inputSchema: TaskInputSchema,
+    };
+}
+/**
+ * Build the task tool description dynamically based on available subagents.
+ *
+ * @param registry - Agent registry to get subagent descriptions
+ * @returns Tool description string
+ */
+function buildTaskToolDescription(registry) {
+    const subagents = registry.listSubagents();
+    const subagentList = subagents.map((agent) => `- ${agent.name}: ${agent.description || 'No description'}`).join('\n');
+    return `Delegate work to a specialized subagent for complex tasks.
+
+Available subagents:
+${subagentList}
+
+Use this tool when you need to:
+- Search the context tree for existing information (use 'explore' subagent with contextTreeOnly=true)
+- Search the codebase for information (use 'explore' subagent without contextTreeOnly)
+- Create or update knowledge topics (use 'curate' subagent)
+
+Each subagent runs with its own specialized configuration and tool access.
+The subagent will execute and return its results to you.
+
+Parameters:
+- subagent_type: Which subagent to use (e.g., "explore", "curate")
+- description: Short description of the task (3-5 words)
+- prompt: Detailed instructions for the subagent
+- context_tree_only: (Optional) If true, restricts file operations to .brv/context-tree/ only. Use this for query commands.
+- session_id: (Optional) Continue an existing subagent session`;
+}

package/dist/infra/cipher/tools/implementations/write-todos-tool.d.ts

@@ -1,10 +1,13 @@
 import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { ITodoStorage } from '../../../../core/interfaces/cipher/i-todo-storage.js';
 /**
  * Creates the write todos tool.
  *
  * Manages a structured task list for planning-based execution.
  * Validates that only one task is in_progress at any time.
+ * Stores todos in session-based storage.
  *
+ * @param todoStorage - Storage service for persisting todos
  * @returns Configured write todos tool
  */
-export declare function createWriteTodosTool(): Tool;
+export declare function createWriteTodosTool(todoStorage: ITodoStorage): Tool;

package/dist/infra/cipher/tools/implementations/write-todos-tool.js

@@ -10,6 +10,7 @@ const TodoSchema = z.object({
         .min(1)
         .describe('Present continuous form shown during execution (e.g., "Running tests")'),
     content: z.string().min(1).describe('Imperative description of the task (e.g., "Run tests")'),
+    id: z.string().min(1).describe('Unique identifier for the todo item'),
     status: z
         .enum(TODO_STATUSES)
         .describe('Task status: pending, in_progress (only ONE at a time), completed, or cancelled'),
@@ -26,38 +27,7 @@ const WriteTodosInputSchema = z
  * Tool description with detailed usage guidance.
  * This helps the LLM understand when to use the tool and how.
  */
-const TOOL_DESCRIPTION = `Use this tool to create and manage a structured task list for the current session. This helps track progress, organize complex tasks, and demonstrate thoroughness to the user.
-
-## When to Use This Tool
-Use this tool proactively in these scenarios:
-
-1. **Complex multi-step tasks** - When a task requires 3 or more distinct steps
-2. **Non-trivial and complex tasks** - Tasks that require careful planning or multiple operations
-3. **User explicitly requests todo list** - When the user directly asks to use the todo list
-4. **User provides multiple tasks** - When users provide a list of things to be done
-5. **After receiving new instructions** - Immediately capture user requirements as todos
-6. **When you start working on a task** - Mark it as in_progress BEFORE beginning work
-7. **After completing a task** - Mark it as completed and add any follow-up tasks
-
-## When NOT to Use This Tool
-Skip using this tool when:
-1. There is only a single, straightforward task
-2. The task is trivial and tracking provides no organizational benefit
-3. The task can be completed in less than 3 trivial steps
-4. The task is purely conversational or informational
-
-## Task States
-- **pending**: Task not yet started
-- **in_progress**: Currently working on (limit to ONE task at a time)
-- **completed**: Task finished successfully
-- **cancelled**: Task no longer needed
-
-## Important Rules
-- ONLY ONE task can be "in_progress" at any time
-- Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-- Task descriptions need both forms:
-  - content: Imperative form (e.g., "Run tests")
-  - activeForm: Present continuous form (e.g., "Running tests")`;
+const TOOL_DESCRIPTION = `Use this tool to create and manage a structured task list for the current session.`;
 /**
  * Validates that only one todo is in_progress.
  *
@@ -73,6 +43,7 @@ function validateSingleInProgress(todos) {
 }
 /**
  * Formats the todo list for LLM response.
+ * Uses opencode-style status icons: [✓] for completed, [ ] for others.
  *
  * @param todos - Array of todos
  * @returns Formatted string representation
@@ -80,14 +51,12 @@ function validateSingleInProgress(todos) {
 function formatTodosForLLM(todos) {
     const lines = ['Todo list updated:'];
     for (const todo of todos) {
-        const statusIcon = getStatusIcon(todo.status);
-        lines.push(`${statusIcon} [${todo.status}] ${todo.content}`);
+        const checkbox = todo.status === 'completed' ? '[✓]' : '[ ]';
+        const statusLabel = todo.status === 'in_progress' ? ' (in_progress)' : '';
+        lines.push(`${checkbox} ${todo.content}${statusLabel}`);
     }
     const stats = getTodoStats(todos);
-    const progressLines = [
-        '',
-        `Progress: ${stats.completed}/${stats.total} completed`,
-    ];
+    const progressLines = ['', `Progress: ${stats.completed}/${stats.total} completed`];
     if (stats.inProgress > 0) {
         const currentTask = todos.find((t) => t.status === 'in_progress');
         if (currentTask) {
@@ -96,28 +65,6 @@ function formatTodosForLLM(todos) {
     }
     return [...lines, ...progressLines].join('\n');
 }
-/**
- * Gets icon for todo status.
- *
- * @param status - Todo status
- * @returns Status icon
- */
-function getStatusIcon(status) {
-    switch (status) {
-        case 'cancelled': {
-            return '⊘';
-        }
-        case 'completed': {
-            return '✓';
-        }
-        case 'in_progress': {
-            return '→';
-        }
-        case 'pending': {
-            return '○';
-        }
-    }
-}
 /**
  * Gets statistics about the todo list.
  *
@@ -138,25 +85,34 @@ function getTodoStats(todos) {
  *
  * Manages a structured task list for planning-based execution.
  * Validates that only one task is in_progress at any time.
+ * Stores todos in session-based storage.
  *
+ * @param todoStorage - Storage service for persisting todos
  * @returns Configured write todos tool
  */
-export function createWriteTodosTool() {
+export function createWriteTodosTool(todoStorage) {
     return {
         description: TOOL_DESCRIPTION,
-        async execute(input, _context) {
+        async execute(input, context) {
             const { todos } = input;
             // Validate only one in_progress
             const validationError = validateSingleInProgress(todos);
             if (validationError) {
                 return validationError;
             }
+            // Store todos in session storage
+            const sessionId = context?.sessionId ?? 'default';
+            await todoStorage.update(sessionId, todos);
             // Format response for LLM
             const llmContent = formatTodosForLLM(todos);
-            // Return both LLM content and display content
+            // Calculate incomplete count for smart title
+            const incompleteCount = todos.filter((t) => t.status !== 'completed').length;
+            // Return both LLM content and display content with metadata
             return {
                 llmContent,
+                metadata: { todos },
                 returnDisplay: { todos },
+                title: `${incompleteCount} todos`,
             };
         },
         id: ToolName.WRITE_TODOS,

package/dist/infra/cipher/tools/index.d.ts

@@ -4,12 +4,12 @@ export type { KnownTool } from '../../../core/domain/cipher/tools/constants.js';
 export type { JSONSchema7, Tool, ToolExecutionContext, ToolSet } from '../../../core/domain/cipher/tools/types.js';
 export type { IToolProvider } from '../../../core/interfaces/cipher/i-tool-provider.js';
 export { createCreateKnowledgeTopicTool } from './implementations/create-knowledge-topic-tool.js';
-export { createDetectDomainsTool } from './implementations/detect-domains-tool.js';
 export { createEditFileTool } from './implementations/edit-file-tool.js';
 export { createGlobFilesTool } from './implementations/glob-files-tool.js';
 export { createGrepContentTool } from './implementations/grep-content-tool.js';
 export { createReadFileTool } from './implementations/read-file-tool.js';
 export { createSearchHistoryTool } from './implementations/search-history-tool.js';
+export { createSpecAnalyzeTool } from './implementations/spec-analyze-tool.js';
 export { createWriteFileTool } from './implementations/write-file-tool.js';
 export { ToolManager } from './tool-manager.js';
 export { ToolProvider } from './tool-provider.js';

package/dist/infra/cipher/tools/index.js

@@ -4,12 +4,12 @@ export { ToolError, ToolExecutionError, ToolNotFoundError, ToolProviderNotInitia
 export { ToolName } from '../../../core/domain/cipher/tools/constants.js';
 // Tool implementations (for direct access if needed)
 export { createCreateKnowledgeTopicTool } from './implementations/create-knowledge-topic-tool.js';
-export { createDetectDomainsTool } from './implementations/detect-domains-tool.js';
 export { createEditFileTool } from './implementations/edit-file-tool.js';
 export { createGlobFilesTool } from './implementations/glob-files-tool.js';
 export { createGrepContentTool } from './implementations/grep-content-tool.js';
 export { createReadFileTool } from './implementations/read-file-tool.js';
 export { createSearchHistoryTool } from './implementations/search-history-tool.js';
+export { createSpecAnalyzeTool } from './implementations/spec-analyze-tool.js';
 export { createWriteFileTool } from './implementations/write-file-tool.js';
 // Registry and provider
 export { ToolManager } from './tool-manager.js';