byterover-cli 0.4.0 → 1.0.0

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

@@ -1,20 +1,24 @@
 import { ToolName } from '../../../core/domain/cipher/tools/constants.js';
 import { createBashExecTool } from './implementations/bash-exec-tool.js';
 import { createBashOutputTool } from './implementations/bash-output-tool.js';
+import { createBatchTool } from './implementations/batch-tool.js';
 import { createCreateKnowledgeTopicTool } from './implementations/create-knowledge-topic-tool.js';
 import { createCurateTool } from './implementations/curate-tool.js';
 import { createDeleteMemoryTool } from './implementations/delete-memory-tool.js';
-import { createDetectDomainsTool } from './implementations/detect-domains-tool.js';
 import { createEditFileTool } from './implementations/edit-file-tool.js';
 import { createEditMemoryTool } from './implementations/edit-memory-tool.js';
-import { createFindKnowledgeTopicsTool } from './implementations/find-knowledge-topics-tool.js';
+// import {createFindKnowledgeTopicsTool} from './implementations/find-knowledge-topics-tool.js'
 import { createGlobFilesTool } from './implementations/glob-files-tool.js';
 import { createGrepContentTool } from './implementations/grep-content-tool.js';
 import { createKillProcessTool } from './implementations/kill-process-tool.js';
+import { createListDirectoryTool } from './implementations/list-directory-tool.js';
 import { createListMemoriesTool } from './implementations/list-memories-tool.js';
 import { createReadFileTool } from './implementations/read-file-tool.js';
 import { createReadMemoryTool } from './implementations/read-memory-tool.js';
+import { createReadTodosTool } from './implementations/read-todos-tool.js';
 import { createSearchHistoryTool } from './implementations/search-history-tool.js';
+import { createSpecAnalyzeTool } from './implementations/spec-analyze-tool.js';
+import { createTaskTool } from './implementations/task-tool.js';
 import { createWriteFileTool } from './implementations/write-file-tool.js';
 import { createWriteMemoryTool } from './implementations/write-memory-tool.js';
 import { createWriteTodosTool } from './implementations/write-todos-tool.js';
@@ -45,107 +49,145 @@ function getRequiredService(service, serviceName) {
  */
 export const TOOL_REGISTRY = {
     [ToolName.BASH_EXEC]: {
+        descriptionFile: 'bash_exec',
         factory: (services) => createBashExecTool(getRequiredService(services.processService, 'processService')),
         markers: [ToolMarker.Execution],
         requiredServices: ['processService'],
     },
     [ToolName.BASH_OUTPUT]: {
+        descriptionFile: 'bash_output',
         factory: (services) => createBashOutputTool(getRequiredService(services.processService, 'processService')),
         markers: [ToolMarker.Execution, ToolMarker.Optional],
         requiredServices: ['processService'],
     },
+    [ToolName.BATCH]: {
+        descriptionFile: 'batch',
+        factory: (services) => createBatchTool(getRequiredService(services.getToolProvider, 'getToolProvider')),
+        markers: [ToolMarker.Execution, ToolMarker.Core],
+        requiredServices: ['getToolProvider'],
+    },
     [ToolName.CREATE_KNOWLEDGE_TOPIC]: {
+        descriptionFile: 'create_knowledge_topic',
         factory: () => createCreateKnowledgeTopicTool(),
         markers: [ToolMarker.ContextBuilding],
         outputGuidance: 'create_knowledge_topic',
         requiredServices: [], // Uses DirectoryManager for file operations
     },
     [ToolName.CURATE]: {
+        descriptionFile: 'curate',
         factory: () => createCurateTool(),
         markers: [ToolMarker.ContextBuilding, ToolMarker.Modification],
         outputGuidance: 'curate',
         requiredServices: [], // Uses DirectoryManager and MarkdownWriter for file operations
     },
     [ToolName.DELETE_MEMORY]: {
+        descriptionFile: 'delete_memory',
         factory: (services) => createDeleteMemoryTool(getRequiredService(services.memoryManager, 'memoryManager')),
         markers: [ToolMarker.ContextBuilding],
         outputGuidance: 'delete_memory',
         requiredServices: ['memoryManager'],
     },
-    [ToolName.DETECT_DOMAINS]: {
-        factory: () => createDetectDomainsTool(),
-        markers: [ToolMarker.ContextBuilding],
-        outputGuidance: 'detect_domains',
-        requiredServices: [], // No services required (validates LLM-detected domains)
-    },
     [ToolName.EDIT_FILE]: {
+        descriptionFile: 'edit_file',
         factory: (services) => createEditFileTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
         markers: [ToolMarker.Modification],
         requiredServices: ['fileSystemService'],
     },
     [ToolName.EDIT_MEMORY]: {
+        descriptionFile: 'edit_memory',
         factory: (services) => createEditMemoryTool(getRequiredService(services.memoryManager, 'memoryManager')),
         markers: [ToolMarker.ContextBuilding],
         outputGuidance: 'edit_memory',
         requiredServices: ['memoryManager'],
     },
-    [ToolName.FIND_KNOWLEDGE_TOPICS]: {
-        factory: () => createFindKnowledgeTopicsTool(),
-        markers: [ToolMarker.ContextBuilding, ToolMarker.Discovery],
-        outputGuidance: 'find_knowledge_topics',
-        requiredServices: [], // Uses DirectoryManager for file operations
-    },
     [ToolName.GLOB_FILES]: {
+        descriptionFile: 'glob_files',
         factory: (services) => createGlobFilesTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
         markers: [ToolMarker.Core, ToolMarker.Discovery],
         requiredServices: ['fileSystemService'],
     },
     [ToolName.GREP_CONTENT]: {
+        descriptionFile: 'grep_content',
         factory: (services) => createGrepContentTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
         markers: [ToolMarker.Core, ToolMarker.Discovery],
         requiredServices: ['fileSystemService'],
     },
     [ToolName.KILL_PROCESS]: {
+        descriptionFile: 'kill_process',
         factory: (services) => createKillProcessTool(getRequiredService(services.processService, 'processService')),
         markers: [ToolMarker.Execution, ToolMarker.Optional],
         requiredServices: ['processService'],
     },
+    [ToolName.LIST_DIRECTORY]: {
+        descriptionFile: 'list_directory',
+        factory: (services) => createListDirectoryTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
+        markers: [ToolMarker.Discovery],
+        requiredServices: ['fileSystemService'],
+    },
     [ToolName.LIST_MEMORIES]: {
+        descriptionFile: 'list_memories',
         factory: (services) => createListMemoriesTool(getRequiredService(services.memoryManager, 'memoryManager')),
         markers: [ToolMarker.ContextBuilding, ToolMarker.Discovery],
         outputGuidance: 'list_memories',
         requiredServices: ['memoryManager'],
     },
     [ToolName.READ_FILE]: {
+        descriptionFile: 'read_file',
         factory: (services) => createReadFileTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
         markers: [ToolMarker.Core, ToolMarker.Discovery],
         requiredServices: ['fileSystemService'],
     },
     [ToolName.READ_MEMORY]: {
+        descriptionFile: 'read_memory',
         factory: (services) => createReadMemoryTool(getRequiredService(services.memoryManager, 'memoryManager')),
         markers: [ToolMarker.ContextBuilding, ToolMarker.Discovery],
         outputGuidance: 'read_memory',
         requiredServices: ['memoryManager'],
     },
+    [ToolName.READ_TODOS]: {
+        descriptionFile: 'read_todos',
+        factory: (services) => createReadTodosTool(getRequiredService(services.todoStorage, 'todoStorage')),
+        markers: [ToolMarker.Planning, ToolMarker.Core],
+        requiredServices: ['todoStorage'],
+    },
     [ToolName.SEARCH_HISTORY]: {
+        descriptionFile: 'search_history',
         factory: (_services) => createSearchHistoryTool(),
         markers: [ToolMarker.ContextBuilding, ToolMarker.Discovery],
         requiredServices: [], // No services required yet (stub implementation)
     },
+    [ToolName.SPEC_ANALYZE]: {
+        descriptionFile: 'spec_analyze',
+        factory: () => createSpecAnalyzeTool(),
+        markers: [ToolMarker.ContextBuilding],
+        outputGuidance: 'spec_analyze',
+        requiredServices: [], // No services required (validates LLM-detected domains)
+    },
+    [ToolName.TASK]: {
+        descriptionFile: 'task',
+        factory: (services) => createTaskTool({
+            getSessionManager: getRequiredService(services.getSessionManager, 'getSessionManager'),
+        }),
+        markers: [ToolMarker.Execution, ToolMarker.Planning],
+        requiredServices: ['getSessionManager'],
+    },
     [ToolName.WRITE_FILE]: {
+        descriptionFile: 'write_file',
         factory: (services) => createWriteFileTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
         markers: [ToolMarker.Modification],
         requiredServices: ['fileSystemService'],
     },
     [ToolName.WRITE_MEMORY]: {
+        descriptionFile: 'write_memory',
         factory: (services) => createWriteMemoryTool(getRequiredService(services.memoryManager, 'memoryManager')),
         markers: [ToolMarker.ContextBuilding],
         outputGuidance: 'write_memory',
         requiredServices: ['memoryManager'],
     },
     [ToolName.WRITE_TODOS]: {
-        factory: () => createWriteTodosTool(),
+        descriptionFile: 'write_todos',
+        factory: (services) => createWriteTodosTool(getRequiredService(services.todoStorage, 'todoStorage')),
         markers: [ToolMarker.Planning, ToolMarker.Core],
-        requiredServices: [], // No services required (stateless tool)
+        requiredServices: ['todoStorage'],
     },
 };

package/dist/infra/context-tree/file-context-tree-snapshot-service.js

@@ -1,8 +1,9 @@
 import { createHash } from 'node:crypto';
 import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
-import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR, SNAPSHOT_FILE } from '../../constants.js';
+import { BRV_DIR, CONTEXT_FILE_EXTENSION, CONTEXT_TREE_DIR, README_FILE, SNAPSHOT_FILE } from '../../constants.js';
 import { ContextTreeSnapshot, } from '../../core/domain/entities/context-tree-snapshot.js';
+import { toUnixPath } from './path-utils.js';
 /**
  * File-based implementation of IContextTreeSnapshotService.
  * Tracks context tree changes using content hashing.
@@ -86,7 +87,7 @@ export class FileContextTreeSnapshotService {
      * Processes a single file and adds it to the files map.
      */
     async processFile(fullPath, rootDir, files) {
-        const relativePath = relative(rootDir, fullPath);
+        const relativePath = toUnixPath(relative(rootDir, fullPath));
         const [content, fileStat] = await Promise.all([readFile(fullPath), stat(fullPath)]);
         files.set(relativePath, {
             hash: this.computeHash(content),
@@ -108,8 +109,13 @@ export class FileContextTreeSnapshotService {
             if (entry.isDirectory()) {
                 tasks.push(this.scanDirectory(fullPath, rootDir, files));
             }
-            else if (entry.isFile() && entry.name === CONTEXT_FILE) {
-                tasks.push(this.processFile(fullPath, rootDir, files));
+            else if (entry.isFile() && entry.name.endsWith(CONTEXT_FILE_EXTENSION)) {
+                // Only ignore README.md at root level, track it in subdirectories
+                const isRoot = currentDir === rootDir;
+                const isReadmeAtRoot = entry.name === README_FILE && isRoot;
+                if (!isReadmeAtRoot) {
+                    tasks.push(this.processFile(fullPath, rootDir, files));
+                }
             }
         }
         await Promise.all(tasks);

package/dist/infra/context-tree/file-context-tree-writer-service.d.ts

@@ -16,9 +16,10 @@ export declare class FileContextTreeWriterService implements IContextTreeWriterS
     constructor(dependencies: ContextTreeWriterServiceDependencies, config?: ContextTreeWriterServiceConfig);
     sync(params: SyncParams): Promise<SyncResult>;
     /**
-     * Normalizes a file path by removing leading slashes.
-     * Retained for backwards compatibility with legacy API responses
-     * that may still include leading slashes in paths.
+     * Normalizes a file path by converting backslashes to forward slashes
+     * and removing leading slashes.
+     * Ensures cross-platform compatibility and handles legacy API responses
+     * that may include leading slashes or Windows-style backslashes.
      */
     private normalizePath;
 }

package/dist/infra/context-tree/file-context-tree-writer-service.js

@@ -2,6 +2,7 @@
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
+import { toUnixPath } from './path-utils.js';
 /**
  * File-based implementation of IContextTreeWriterService.
  * Synchronizes context tree files based on CoGit snapshot data.
@@ -53,11 +54,12 @@ export class FileContextTreeWriterService {
         return { added, deleted, edited };
     }
     /**
-     * Normalizes a file path by removing leading slashes.
-     * Retained for backwards compatibility with legacy API responses
-     * that may still include leading slashes in paths.
+     * Normalizes a file path by converting backslashes to forward slashes
+     * and removing leading slashes.
+     * Ensures cross-platform compatibility and handles legacy API responses
+     * that may include leading slashes or Windows-style backslashes.
      */
     normalizePath(path) {
-        return path.replace(/^\/+/, '');
+        return toUnixPath(path).replace(/^\/+/, '');
     }
 }

package/dist/infra/context-tree/path-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Path utilities for context tree operations.
+ *
+ * Provides cross-platform path normalization to ensure all context tree paths
+ * use forward slashes regardless of the operating system.
+ */
+export { normalizeForComparison as toUnixPath } from '../cipher/process/path-utils.js';

package/dist/infra/context-tree/path-utils.js

@@ -0,0 +1,7 @@
+/**
+ * Path utilities for context tree operations.
+ *
+ * Provides cross-platform path normalization to ensure all context tree paths
+ * use forward slashes regardless of the operating system.
+ */
+export { normalizeForComparison as toUnixPath } from '../cipher/process/path-utils.js';

package/dist/infra/core/executors/curate-executor.d.ts

@@ -0,0 +1,35 @@
+import type { ICipherAgent } from '../../../core/interfaces/cipher/i-cipher-agent.js';
+import type { CurateExecuteOptions, ICurateExecutor } from '../../../core/interfaces/executor/i-curate-executor.js';
+/**
+ * CurateExecutor - Executes curate tasks with an injected CipherAgent.
+ *
+ * This is NOT a UseCase (which orchestrates business logic).
+ * It's an Executor that wraps agent.execute() with curate-specific options.
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on curate execution
+ */
+export declare class CurateExecutor implements ICurateExecutor {
+    /**
+     * Maximum number of files allowed in --files flag
+     */
+    private static readonly MAX_FILES;
+    /**
+     * Execute curate with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (content, file references)
+     * @returns Result string from agent execution
+     */
+    executeWithAgent(agent: ICipherAgent, options: CurateExecuteOptions): Promise<string>;
+    /**
+     * Process file paths from --files flag.
+     *
+     * @param filePaths - Array of file paths (relative or absolute)
+     * @returns Formatted instructions for the agent to read the specified files,
+     *          or undefined if validation fails
+     */
+    private processFileReferences;
+}

package/dist/infra/core/executors/curate-executor.js

@@ -0,0 +1,123 @@
+import { FileValidationError } from '../../../core/domain/errors/task-error.js';
+import { validateFileForCurate } from '../../../utils/file-validator.js';
+import { getAgentStorage } from '../../cipher/storage/agent-storage.js';
+/**
+ * CurateExecutor - Executes curate tasks with an injected CipherAgent.
+ *
+ * This is NOT a UseCase (which orchestrates business logic).
+ * It's an Executor that wraps agent.execute() with curate-specific options.
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on curate execution
+ */
+export class CurateExecutor {
+    /**
+     * Maximum number of files allowed in --files flag
+     */
+    static MAX_FILES = 5;
+    /**
+     * Execute curate with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (content, file references)
+     * @returns Result string from agent execution
+     */
+    async executeWithAgent(agent, options) {
+        const { content, files, taskId } = options;
+        // Initialize storage for execution tracking
+        const storage = await getAgentStorage();
+        let executionId = null;
+        try {
+            // Process file references if provided (validation + instructions)
+            const fileReferenceInstructions = this.processFileReferences(files ?? []);
+            if (fileReferenceInstructions === undefined) {
+                throw new FileValidationError();
+            }
+            // Create execution with status='running'
+            // Save in JSON format with all fields for tracking:
+            // - content: the context to curate
+            // - files: original file paths (if provided)
+            // - fileReferenceInstructions: generated instructions (if files provided and valid)
+            const executionInput = JSON.stringify({
+                content,
+                ...(fileReferenceInstructions ? { fileReferenceInstructions } : {}),
+                ...(files && files.length > 0 ? { files } : {}),
+            });
+            executionId = storage.createExecution('curate', executionInput);
+            // Build prompt with optional file reference instructions
+            const prompt = fileReferenceInstructions ? `${content}\n${fileReferenceInstructions}` : content;
+            // Execute with curate commandType
+            // Agent uses its default session (created during start())
+            const response = await agent.execute(prompt, {
+                executionContext: { commandType: 'curate' },
+                taskId,
+            });
+            // Mark execution as completed
+            storage.updateExecutionStatus(executionId, 'completed', response);
+            // Cleanup old executions
+            storage.cleanupOldExecutions(100);
+            return response;
+        }
+        catch (error) {
+            // Mark execution as failed
+            if (executionId) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                storage.updateExecutionStatus(executionId, 'failed', undefined, errorMessage);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Process file paths from --files flag.
+     *
+     * @param filePaths - Array of file paths (relative or absolute)
+     * @returns Formatted instructions for the agent to read the specified files,
+     *          or undefined if validation fails
+     */
+    processFileReferences(filePaths) {
+        if (!filePaths || filePaths.length === 0) {
+            return '';
+        }
+        // Truncate if exceeds max files
+        let processedPaths = filePaths;
+        if (filePaths.length > CurateExecutor.MAX_FILES) {
+            processedPaths = filePaths.slice(0, CurateExecutor.MAX_FILES);
+        }
+        // Get project root (current directory)
+        const projectRoot = process.cwd();
+        // Validate each file and collect errors
+        const validPaths = [];
+        const errors = [];
+        for (const filePath of processedPaths) {
+            const result = validateFileForCurate(filePath, projectRoot);
+            if (result.valid && result.normalizedPath) {
+                validPaths.push(result.normalizedPath);
+            }
+            else {
+                errors.push(result.error ?? `Invalid file: ${filePath}`);
+            }
+        }
+        // If there are any validation errors, return undefined
+        if (errors.length > 0) {
+            return undefined;
+        }
+        // Format instructions for the agent
+        const instructions = [
+            '\n## IMPORTANT: Critical Files to Read (--files flag)',
+            '',
+            'The user has explicitly specified these files as critical context that MUST be read before creating knowledge topics:',
+            '',
+            ...validPaths.map((p) => `- ${p}`),
+            '',
+            '**MANDATORY INSTRUCTIONS:**',
+            '- You MUST use the `read_file` tool to read ALL of these files IN PARALLEL (in a single iteration) before proceeding to create knowledge topics',
+            '- These files contain essential context that will help you create comprehensive and accurate knowledge topics',
+            '- Read them in parallel to maximize efficiency - they do not depend on each other',
+            '- After reading all files, proceed with the normal workflow: detect domains, find existing knowledge, and create/update topics',
+            '',
+        ];
+        return instructions.join('\n');
+    }
+}

package/dist/infra/core/executors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './curate-executor.js';
+export * from './query-executor.js';

package/dist/infra/core/executors/index.js

@@ -0,0 +1,2 @@
+export * from './curate-executor.js';
+export * from './query-executor.js';

package/dist/infra/core/executors/query-executor.d.ts

@@ -0,0 +1,23 @@
+import type { ICipherAgent } from '../../../core/interfaces/cipher/i-cipher-agent.js';
+import type { IQueryExecutor, QueryExecuteOptions } from '../../../core/interfaces/executor/i-query-executor.js';
+/**
+ * QueryExecutor - Executes query tasks with an injected CipherAgent.
+ *
+ * This is NOT a UseCase (which orchestrates business logic).
+ * It's an Executor that wraps agent.execute() with query-specific options.
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on query execution
+ */
+export declare class QueryExecutor implements IQueryExecutor {
+    /**
+     * Execute query with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (query)
+     * @returns Result string from agent execution
+     */
+    executeWithAgent(agent: ICipherAgent, options: QueryExecuteOptions): Promise<string>;
+}

package/dist/infra/core/executors/query-executor.js

@@ -0,0 +1,51 @@
+import { getAgentStorage } from '../../cipher/storage/agent-storage.js';
+/**
+ * QueryExecutor - Executes query tasks with an injected CipherAgent.
+ *
+ * This is NOT a UseCase (which orchestrates business logic).
+ * It's an Executor that wraps agent.execute() with query-specific options.
+ *
+ * Architecture:
+ * - TaskProcessor injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Executor focuses solely on query execution
+ */
+export class QueryExecutor {
+    /**
+     * Execute query with an injected agent.
+     *
+     * @param agent - Long-lived CipherAgent (managed by caller)
+     * @param options - Execution options (query)
+     * @returns Result string from agent execution
+     */
+    async executeWithAgent(agent, options) {
+        const { query, taskId } = options;
+        // Initialize storage for execution tracking
+        const storage = await getAgentStorage();
+        let executionId = null;
+        try {
+            // Create execution with status='running'
+            executionId = storage.createExecution('query', query);
+            // Execute with query commandType
+            // Agent uses its default session (created during start())
+            const prompt = `Search the context tree for: ${query}`;
+            const response = await agent.execute(prompt, {
+                executionContext: { commandType: 'query' },
+                taskId,
+            });
+            // Mark execution as completed
+            storage.updateExecutionStatus(executionId, 'completed', response);
+            // Cleanup old executions
+            storage.cleanupOldExecutions(100);
+            return response;
+        }
+        catch (error) {
+            // Mark execution as failed
+            if (executionId) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                storage.updateExecutionStatus(executionId, 'failed', undefined, errorMessage);
+            }
+            throw error;
+        }
+    }
+}

package/dist/infra/core/task-processor.d.ts

@@ -0,0 +1,81 @@
+import type { ICipherAgent } from '../../core/interfaces/cipher/i-cipher-agent.js';
+import type { ILogger } from '../../core/interfaces/cipher/i-logger.js';
+import type { ICurateExecutor } from '../../core/interfaces/executor/i-curate-executor.js';
+import type { IQueryExecutor } from '../../core/interfaces/executor/i-query-executor.js';
+/**
+ * Task input for processing.
+ * Agent uses its default session (Single-Session pattern).
+ */
+export type TaskInput = {
+    /** Task content/prompt */
+    content: string;
+    /** Optional file paths for curate --files */
+    files?: string[];
+    /** Task ID */
+    taskId: string;
+    /** Task type */
+    type: 'curate' | 'query';
+};
+/**
+ * Configuration for TaskProcessor.
+ */
+export type TaskProcessorConfig = {
+    /** Curate executor instance (injected by agent-worker) */
+    curateExecutor: ICurateExecutor;
+    /** Logger instance */
+    logger?: ILogger;
+    /** Query executor instance (injected by agent-worker) */
+    queryExecutor: IQueryExecutor;
+};
+/**
+ * TaskProcessor - Coordinates task execution with injected executors.
+ *
+ * Architecture:
+ * - TaskProcessor receives single agent reference via setAgent()
+ * - TaskProcessor passes agent to Executor.executeWithAgent()
+ * - Executor handles execution (validation, prompt building)
+ * - Event streaming handled by agent-worker (subscribes to agentEventBus)
+ *
+ * Flow: agent-worker → TaskProcessor.process() → Executor.executeWithAgent()
+ */
+export declare class TaskProcessor {
+    /**
+     * Single CipherAgent reference from agent-worker.
+     */
+    private agent;
+    private readonly curateExecutor;
+    private readonly logger;
+    private readonly queryExecutor;
+    /** Track running tasks for cancellation */
+    private readonly runningTasks;
+    constructor(config: TaskProcessorConfig);
+    /**
+     * Cancel a running task.
+     */
+    cancel(taskId: string): boolean;
+    /**
+     * Check if a task is running.
+     */
+    isRunning(taskId: string): boolean;
+    /**
+     * Process a task and return the result.
+     *
+     * Architecture:
+     * - Calls Executor.executeWithAgent() with long-lived agent
+     * - Returns result string
+     * - Event streaming handled by agent-worker (agentEventBus)
+     */
+    process(input: TaskInput): Promise<string>;
+    /**
+     * Set agent reference from agent-worker.
+     */
+    setAgent(agent: ICipherAgent): void;
+    /**
+     * Execute task with the injected agent.
+     */
+    private executeWithAgent;
+}
+/**
+ * Create a new TaskProcessor instance.
+ */
+export declare function createTaskProcessor(config: TaskProcessorConfig): TaskProcessor;