byterover-cli 1.0.2 → 1.0.4

package/dist/infra/cipher/system-prompt/contributors/context-tree-structure-contributor.js

@@ -92,7 +92,7 @@ export class ContextTreeStructureContributor {
         if (truncatedCount.value > 0) {
             parts.push('', `[${truncatedCount.value} additional entries not shown]`);
         }
-        parts.push('', '## Structure Guide', '- Each top-level folder is a **domain** (e.g., `code_style/`, `design/`, `structure/`)', '- Inside domains are **topics** as `.md` files or subfolders with `context.md`', '- `context.md` files contain the curated knowledge content', '', '## Usage', '- **Query commands**: Search ONLY within this context tree structure', '- **Curate commands**: Check existing content here before creating new topics', '</context-tree-structure>');
+        parts.push('', '## Structure Guide', '- Each top-level folder is a **domain** (dynamically created based on content)', '- Inside domains are **topics** as `.md` files or subfolders with `context.md`', '- `context.md` files contain the curated knowledge content', '', '## Dynamic Domains', '- Domains are created dynamically based on the semantics of curated content', '- Domain names should be descriptive, use snake_case (e.g., `authentication`, `api_design`)', '- Before creating a new domain, check if existing domains could accommodate the content', '', '## Usage', '- **Query commands**: Search ONLY within this context tree structure', '- **Curate commands**: Check existing domains/topics before creating new ones', '</context-tree-structure>');
         return parts.join('\n');
     }
     /**
@@ -105,7 +105,9 @@ export class ContextTreeStructureContributor {
             '',
             'The context tree at `.brv/context-tree/` exists but contains no curated content yet.',
             '',
-            '**For curate commands**: You can create new knowledge topics in any domain.',
+            '**For curate commands**: Create new domains and topics dynamically based on content.',
+            '- Choose semantically meaningful domain names (e.g., `authentication`, `api_design`, `data_models`)',
+            '- Use snake_case format for domain names',
             '**For query commands**: No context is available to search.',
             '</context-tree-structure>',
         ].join('\n');

package/dist/infra/cipher/tools/implementations/create-knowledge-topic-tool.js

@@ -7,16 +7,16 @@ import { sanitizeFolderName } from '../../../../utils/file-helpers.js';
 const CreateKnowledgeTopicInputSchema = z.object({
     // Base path for knowledge storage
     basePath: z.string().default('.brv/context-tree'),
-    domains: z.array(z.string()).describe('Array of domain names'),
+    domains: z.array(z.string()).describe('Array of domain names (dynamically created based on content)'),
     // Manual topics (optional)
     topics: z
         .array(z.object({
-        domain: z.string().describe('Domain category name from predefined list'),
+        domain: z.string().describe('Domain category name (can be any semantically meaningful name)'),
         name: z.string().describe('Topic name'),
         relations: z
             .array(z.string())
             .optional()
-            .describe('Related topics using @domain/topic or @domain/topic/subtopic notation'),
+            .describe('Related topics using domain/topic or domain/topic/subtopic notation'),
         snippets: z.array(z.string()).describe('Code/text snippets'),
         subtopics: z
             .array(z.object({
@@ -24,7 +24,7 @@ const CreateKnowledgeTopicInputSchema = z.object({
             relations: z
                 .array(z.string())
                 .optional()
-                .describe('Related topics using @domain/topic or @domain/topic/subtopic notation'),
+                .describe('Related topics using domain/topic or domain/topic/subtopic notation'),
             snippets: z.array(z.string()).describe('Code/text snippets'),
         }))
             .describe('Array of subtopics'),
@@ -112,27 +112,34 @@ async function executeCreateKnowledgeTopic(input, _context) {
  */
 export function createCreateKnowledgeTopicTool() {
     return {
-        description: `Create organized knowledge topics within domain folders. This tool structures knowledge by creating topic and subtopic folders, each containing a context.md file with relevant snippets and optional relations.
+        description: `Create organized knowledge topics within dynamically-created domain folders. This tool structures knowledge by creating domain, topic, and subtopic folders, each containing a context.md file with relevant snippets and optional relations.
 
-Use this tool after detecting domains to organize extracted knowledge into a hierarchical structure:
-- Domain folders (e.g., .brv/context-tree/domain-name/)
-- Topic folders (e.g., .brv/context-tree/domain-name/topic-name/)
-- Topic context.md files (e.g., .brv/context-tree/domain-name/topic-name/context.md)
-- Subtopic folders (e.g., .brv/context-tree/domain-name/topic-name/subtopic-name/)
-- Subtopic context.md files (e.g., .brv/context-tree/domain-name/topic-name/subtopic-name/context.md)
+**Dynamic Domain Creation:**
+Domains are created dynamically based on the content being organized. Choose domain names that:
+- Are semantically meaningful and descriptive (e.g., "authentication", "api_design", "data_models")
+- Use snake_case format (1-3 words)
+- Group related concepts together
+- Avoid overly generic names (e.g., "misc", "other") or overly specific names
 
-Each topic should include:
+**Hierarchical Structure:**
+- Domain folders (e.g., .brv/context-tree/authentication/)
+- Topic folders (e.g., .brv/context-tree/authentication/oauth_flow/)
+- Topic context.md files (e.g., .brv/context-tree/authentication/oauth_flow/context.md)
+- Subtopic folders (e.g., .brv/context-tree/authentication/oauth_flow/token_refresh/)
+- Subtopic context.md files (e.g., .brv/context-tree/authentication/oauth_flow/token_refresh/context.md)
+
+**Each topic should include:**
 1. A clear topic name
 2. Relevant code/text snippets that demonstrate the knowledge
-3. Optional relations to other topics using @domain/topic or @domain/topic/subtopic notation
+3. Optional relations to other topics using domain/topic or domain/topic/subtopic notation
 4. Subtopics (optional) that break down the topic into smaller pieces
 
-Relations enhance knowledge discovery by linking related contexts. Example:
-- relations: ['code_style/error-handling', 'structure/api-endpoints/validation']
+**Relations** enhance knowledge discovery by linking related contexts. Example:
+- relations: ['authentication/session_management', 'api_design/endpoints/validation']
 
-The tool automatically:
+**The tool automatically:**
 - Creates the base knowledge structure if it doesn't exist
-- Creates topic and subtopic folders as needed
+- Creates domain, topic, and subtopic folders as needed
 - Generates context.md files with snippets and relations
 - Handles existing topics gracefully (updates instead of recreating)`,
         execute: executeCreateKnowledgeTopic,

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

@@ -1,20 +1,10 @@
 import * as fs from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { DEFAULT_CONTEXT_TREE_DOMAINS } from '../../../../config/context-tree-domains.js';
 import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
 import { DirectoryManager } from '../../../../core/domain/knowledge/directory-manager.js';
 import { MarkdownWriter } from '../../../../core/domain/knowledge/markdown-writer.js';
 import { toSnakeCase } from '../../../../utils/file-helpers.js';
-/**
- * Predefined domain names from configuration.
- */
-const PREDEFINED_DOMAIN_NAMES = DEFAULT_CONTEXT_TREE_DOMAINS.map((domain) => domain.name);
-/**
- * Maximum number of custom domains allowed beyond predefined domains.
- * This prevents excessive domain proliferation which degrades query quality.
- */
-const MAX_CUSTOM_DOMAINS = 3;
 /**
  * Operation types for curating knowledge topics.
  * Inspired by ACE Curator patterns.
@@ -27,7 +17,7 @@ const ContentSchema = z.object({
     relations: z
         .array(z.string())
         .optional()
-        .describe('Related topics using @domain/topic or @domain/topic/subtopic notation'),
+        .describe('Related topics using domain/topic or domain/topic/subtopic notation'),
     snippets: z.array(z.string()).optional().describe('Code/text snippets'),
 });
 /**
@@ -78,33 +68,30 @@ async function getExistingDomains(basePath) {
     }
 }
 /**
- * Check if a domain is valid (either predefined or existing in context tree).
- * Also enforces the maximum custom domains limit.
+ * Validate domain name format.
+ * Dynamic domains are allowed - no predefined list or limits.
+ * The agent is responsible for creating semantically meaningful domains.
  */
 async function validateDomain(basePath, domainName) {
     const normalizedDomain = toSnakeCase(domainName);
     const existingDomains = await getExistingDomains(basePath);
-    // Check if it's a predefined domain - always allowed
-    if (PREDEFINED_DOMAIN_NAMES.includes(normalizedDomain)) {
-        return { allowed: true, existingDomains };
-    }
-    // Check if it already exists in context tree - always allowed
-    if (existingDomains.includes(normalizedDomain)) {
-        return { allowed: true, existingDomains };
+    // Validate domain name format (must be non-empty and valid for filesystem)
+    if (!normalizedDomain || normalizedDomain.length === 0) {
+        return {
+            allowed: false,
+            existingDomains,
+            reason: 'Domain name cannot be empty.',
+        };
     }
-    // Count how many custom domains already exist
-    const customDomains = existingDomains.filter((domain) => !PREDEFINED_DOMAIN_NAMES.includes(domain));
-    // Check if we've exceeded the custom domain limit
-    if (customDomains.length >= MAX_CUSTOM_DOMAINS) {
+    // Check for invalid characters in domain name
+    if (!/^[\w-]+$/.test(normalizedDomain)) {
         return {
             allowed: false,
             existingDomains,
-            reason: `Cannot create new domain "${normalizedDomain}". Maximum of ${MAX_CUSTOM_DOMAINS} custom domains allowed. ` +
-                `Existing custom domains: ${customDomains.join(', ')}. ` +
-                `Please use one of the predefined domains (${PREDEFINED_DOMAIN_NAMES.join(', ')}) or existing domains.`,
+            reason: `Domain name "${normalizedDomain}" contains invalid characters. Use only letters, numbers, underscores, and hyphens.`,
         };
     }
-    // New custom domain within limit - allowed
+    // All valid domain names are allowed - dynamic domain creation enabled
     return { allowed: true, existingDomains };
 }
 /**
@@ -484,11 +471,19 @@ export function createCurateTool() {
 **Path format:** domain/topic or domain/topic/subtopic (uses snake_case automatically)
 **File naming:** Titles are converted to snake_case (e.g., "Best Practices" -> "best_practices.md")
 
-**Domain constraints:**
-- Predefined domains: code_style, design, structure, compliance, testing, bug_fixes
-- Up to 3 additional custom domains are allowed
-- Always prefer predefined domains when possible
-- Creating new domains beyond the limit will fail
+**Dynamic Domain Creation:**
+- Domains are created dynamically based on the context being curated
+- Choose domain names that are semantically meaningful and descriptive
+- Domain names should be concise (1-3 words), use snake_case format
+- Examples of good domain names: authentication, api_design, data_models, error_handling, ui_components
+- Before creating a new domain, check if existing domains could be reused
+- Group related topics under the same domain for better organization
+
+**Domain Naming Guidelines:**
+- Use noun-based names that describe the category (e.g., "authentication" not "how_to_authenticate")
+- Avoid overly generic names (e.g., "misc", "other", "general")
+- Avoid overly specific names that only fit one topic
+- Keep domain count reasonable by consolidating related concepts
 
 **Output:** Returns applied operations with status (success/failed), filePath (for created/modified files), and a summary of counts.`,
         execute: executeCurate,

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

@@ -6,18 +6,8 @@ import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
 const ReadFileInputSchema = z
     .object({
     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, default: 2000)'),
-    offset: z
-        .number()
-        .int()
-        .min(1)
-        .optional()
-        .describe('Starting line number (1-based, optional)'),
+    limit: z.number().int().positive().optional().describe('Maximum number of lines to read (optional, default: 2000)'),
+    offset: z.number().int().min(1).optional().describe('Starting line number (1-based, optional)'),
 })
     .strict();
 /**
@@ -56,6 +46,7 @@ export function createReadFileTool(fileSystemService) {
                 size: result.size,
                 totalLines: result.totalLines,
                 truncated: result.truncated,
+                truncatedLineCount: result.truncatedLineCount,
             };
         },
         id: ToolName.READ_FILE,

package/dist/infra/cipher/tools/implementations/spec-analyze-tool.js

@@ -1,17 +1,13 @@
 import { z } from 'zod';
-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 = DEFAULT_CONTEXT_TREE_DOMAINS.map((domain) => domain.name);
 /**
  * Domain category for knowledge classification.
+ * Domains are created dynamically based on content semantics.
  */
 const DomainCategory = z
     .string()
     .min(1)
-    .describe(`Domain category name. Prefer using predefined domains: ${PREDEFINED_DOMAIN_NAMES.join(', ')}. Custom domains are allowed but limited to 3 maximum.`);
+    .describe('Domain category name. Create semantically meaningful domain names based on content (e.g., authentication, api_design, data_models). Use snake_case format.');
 /**
  * Text segment schema - represents a portion of the input data related to a domain
  */
@@ -27,7 +23,7 @@ const DetectDomainsInputSchema = z
     /** Detected domains with metadata and related text segments */
     domains: z
         .array(z.object({
-        category: DomainCategory.describe('Domain category name from predefined list'),
+        category: DomainCategory.describe('Semantically meaningful domain category name (snake_case, e.g., authentication, api_design)'),
         textSegments: z
             .array(TextSegmentSchema)
             .min(1)
@@ -50,22 +46,29 @@ async function executeDetectDomains(input, _context) {
  * @returns Configured detect domains tool
  */
 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.
+        description: `Use this tool to analyze input data and detect which 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.
 
 This tool should be the first tool to call when you want to understand new data, unless you already know what you are looking for.
 
-Predefined domain categories:
-${domainDescriptions}
+**Dynamic Domain Creation:**
+Domains are created dynamically based on the semantics of the content. Choose domain names that:
+- Are descriptive and semantically meaningful
+- Use snake_case format (1-3 words)
+- Group related concepts together
+- Examples: \`authentication\`, \`api_design\`, \`data_models\`, \`error_handling\`, \`ui_components\`, \`testing_patterns\`
 
-For each domain you detect:
-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)
+**For each domain you detect:**
+1. Create a semantically meaningful domain category name based on the content
 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
+4. Only include domains that are actually present in the data
 
-**Important:** Always prefer predefined domains over custom ones to maintain query quality and ease of maintenance.
+**Domain Naming Guidelines:**
+- Use noun-based names that describe the category (e.g., \`authentication\` not \`how_to_authenticate\`)
+- Avoid overly generic names (e.g., \`misc\`, \`other\`, \`general\`)
+- Avoid overly specific names that only fit one topic
+- Consolidate related concepts under the same domain
 
 The text segments will be used later to create organized knowledge topics, so they should be substantial enough to provide context.`,
         execute: executeDetectDomains,

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

@@ -1,6 +1,42 @@
+import { load as loadYaml } from 'js-yaml';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 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';
+/** Cache for loaded agent prompts. */
+const agentPromptCache = new Map();
+/** Type predicate to check if parsed YAML has a prompt field. */
+function hasPromptField(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value !== undefined &&
+        'prompt' in value &&
+        typeof value.prompt === 'string');
+}
+/** Load agent prompt from YAML file with caching. */
+function loadAgentPrompt(promptFile) {
+    if (agentPromptCache.has(promptFile)) {
+        return agentPromptCache.get(promptFile);
+    }
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const promptsDir = path.join(currentDir, '../../../../resources/prompts');
+        const fullPath = path.join(promptsDir, promptFile);
+        if (!fs.existsSync(fullPath)) {
+            return '';
+        }
+        const yamlContent = fs.readFileSync(fullPath, 'utf8');
+        const parsed = loadYaml(yamlContent);
+        const prompt = hasPromptField(parsed) ? parsed.prompt : '';
+        agentPromptCache.set(promptFile, prompt);
+        return prompt;
+    }
+    catch {
+        return '';
+    }
+}
 /**
  * Tool name constant for task tool.
  */
@@ -118,13 +154,23 @@ export function createTaskTool(dependencies) {
                     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
+                // Load the agent's prompt from YAML file or use inline prompt
+                let agentPromptContent;
+                if (agent.promptFile) {
+                    // Load the actual prompt content from the YAML file
+                    agentPromptContent = loadAgentPrompt(agent.promptFile);
+                }
+                else if (agent.prompt) {
+                    // Use inline prompt if no promptFile is specified
+                    agentPromptContent = agent.prompt;
+                }
+                else {
+                    agentPromptContent = '';
+                }
+                // Construct the full message for the subagent with agent instructions
+                const agentPromptSection = agentPromptContent
+                    ? `\n\n## Agent Instructions (${agent.name})\n${agentPromptContent}`
+                    : '';
                 const fullPrompt = `${agentPromptSection}\n\n## Task\n${prompt}`;
                 // Stream progress update
                 if (context?.metadata) {

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

@@ -1,7 +1,6 @@
-import { access, mkdir, writeFile } from 'node:fs/promises';
+import { access, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { CONTEXT_TREE_DOMAINS } from '../../config/context-tree-domains.js';
-import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR } from '../../constants.js';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
 /**
  * File-based implementation of IContextTreeService.
  * Provides operations for managing the context tree structure.
@@ -27,19 +26,9 @@ export class FileContextTreeService {
         const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
         const brvDir = join(baseDir, BRV_DIR);
         const contextTreeDir = join(brvDir, CONTEXT_TREE_DIR);
-        // Create .brv/context-tree/ directory
+        // Create .brv/context-tree/ directory only
+        // Domains are created dynamically by the agent based on curated content
         await mkdir(contextTreeDir, { recursive: true });
-        // Create domain folders and context.md files in parallel
-        await Promise.all(CONTEXT_TREE_DOMAINS.map(async (domain) => {
-            const domainPath = join(contextTreeDir, domain.name);
-            await mkdir(domainPath, { recursive: true });
-            // Write context.md with domain description
-            const contextMdPath = join(domainPath, CONTEXT_FILE);
-            const contextContent = `# ${domain.name.replaceAll('_', ' ').replaceAll(/\b\w/g, (c) => c.toUpperCase())}\n\n${domain.description}\n`;
-            await writeFile(contextMdPath, contextContent, 'utf8');
-        }));
-        // Note: index.json is no longer created as it's not actively used
-        // Context tree uses filesystem-based discovery instead
         return contextTreeDir;
     }
 }

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

@@ -9,6 +9,7 @@ import type { CurateExecuteOptions, ICurateExecutor } from '../../../core/interf
  * Architecture:
  * - TaskProcessor injects the long-lived CipherAgent
  * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on curate execution
  */
 export declare class CurateExecutor implements ICurateExecutor {
@@ -16,18 +17,12 @@ 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)
+     * @param clientCwd - Client's working directory for file validation (optional, defaults to process.cwd())
      * @returns Formatted instructions for the agent to read the specified files,
      *          or undefined if validation fails
      */

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

@@ -1,6 +1,5 @@
 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.
  *
@@ -10,6 +9,7 @@ import { getAgentStorage } from '../../cipher/storage/agent-storage.js';
  * Architecture:
  * - TaskProcessor injects the long-lived CipherAgent
  * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on curate execution
  */
 export class CurateExecutor {
@@ -17,66 +17,32 @@ 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;
+        const { clientCwd, content, files, taskId } = options;
+        const fileReferenceInstructions = this.processFileReferences(files ?? [], clientCwd);
+        if (fileReferenceInstructions === undefined) {
+            throw new FileValidationError();
         }
+        // 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())
+        // Task lifecycle is managed by Transport (task:started, task:completed, task:error)
+        const response = await agent.execute(prompt, {
+            executionContext: { commandType: 'curate' },
+            taskId,
+        });
+        return response;
     }
     /**
      * Process file paths from --files flag.
      *
      * @param filePaths - Array of file paths (relative or absolute)
+     * @param clientCwd - Client's working directory for file validation (optional, defaults to process.cwd())
      * @returns Formatted instructions for the agent to read the specified files,
      *          or undefined if validation fails
      */
-    processFileReferences(filePaths) {
+    processFileReferences(filePaths, clientCwd) {
         if (!filePaths || filePaths.length === 0) {
             return '';
         }
@@ -85,8 +51,7 @@ export class CurateExecutor {
         if (filePaths.length > CurateExecutor.MAX_FILES) {
             processedPaths = filePaths.slice(0, CurateExecutor.MAX_FILES);
         }
-        // Get project root (current directory)
-        const projectRoot = process.cwd();
+        const projectRoot = clientCwd ?? process.cwd();
         // Validate each file and collect errors
         const validPaths = [];
         const errors = [];

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

@@ -9,15 +9,9 @@ import type { IQueryExecutor, QueryExecuteOptions } from '../../../core/interfac
  * Architecture:
  * - TaskProcessor injects the long-lived CipherAgent
  * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - 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

@@ -1,4 +1,3 @@
-import { getAgentStorage } from '../../cipher/storage/agent-storage.js';
 /**
  * QueryExecutor - Executes query tasks with an injected CipherAgent.
  *
@@ -8,44 +7,20 @@ import { getAgentStorage } from '../../cipher/storage/agent-storage.js';
  * Architecture:
  * - TaskProcessor injects the long-lived CipherAgent
  * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - 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;
-        }
+        // Execute with query commandType
+        // Agent uses its default session (created during start())
+        // Task lifecycle is managed by Transport (task:started, task:completed, task:error)
+        const prompt = `Search the context tree for: ${query}`;
+        const response = await agent.execute(prompt, {
+            executionContext: { commandType: 'query' },
+            taskId,
+        });
+        return response;
     }
 }

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

@@ -9,6 +9,8 @@ import type { IQueryExecutor } from '../../core/interfaces/executor/i-query-exec
 export type TaskInput = {
     /** Task content/prompt */
     content: string;
+    /** Client's working directory for file validation */
+    clientCwd?: string;
     /** Optional file paths for curate --files */
     files?: string[];
     /** Task ID */

package/dist/infra/core/task-processor.js

@@ -95,6 +95,7 @@ export class TaskProcessor {
             case 'curate': {
                 // Agent uses its default session (Single-Session pattern)
                 return this.curateExecutor.executeWithAgent(this.agent, {
+                    clientCwd: input.clientCwd,
                     content,
                     files: input.files,
                     taskId,