byterover-cli 1.8.0 → 2.1.0

package/dist/agent/infra/sandbox/sandbox-service.d.ts

@@ -1,26 +1,36 @@
 import type { EnvironmentContext } from '../../core/domain/environment/types.js';
 import type { REPLResult, SandboxConfig } from '../../core/domain/sandbox/types.js';
+import type { IContentGenerator } from '../../core/interfaces/i-content-generator.js';
 import type { ICurateService } from '../../core/interfaces/i-curate-service.js';
 import type { IFileSystem } from '../../core/interfaces/i-file-system.js';
 import type { ISandboxService } from '../../core/interfaces/i-sandbox-service.js';
+import type { SessionManager } from '../session/session-manager.js';
 import type { ISearchKnowledgeService } from './tools-sdk.js';
 /**
  * Sandbox service implementation.
  * Manages sandbox instances tied to agent sessions.
  */
 export declare class SandboxService implements ISandboxService {
+    /** Collector wrapping curateService — captures curate() results per executeCode() call */
+    private collector?;
+    /** Content generator for parallel LLM operations (mapExtract) */
+    private contentGenerator?;
     /** Curate service for Tools SDK */
     private curateService?;
     /** Environment context for sandbox injection */
     private environmentContext?;
     /** File system service for Tools SDK */
     private fileSystem?;
+    /** Variables buffered before sandbox creation, keyed by sessionId */
+    private pendingVariables;
+    /** Command type used to build each sandbox's ToolsSDK, keyed by sessionId */
+    private sandboxCommandTypes;
     /** Map of agent sessionId to LocalSandbox instance */
     private sandboxes;
     /** Search knowledge service for Tools SDK */
     private searchKnowledgeService?;
-    /** Cached Tools SDK instance (created when fileSystem is set) */
-    private toolsSDK?;
+    /** Session manager for sub-agent delegation via tools.agentQuery() */
+    private sessionManager?;
     /**
      * Clean up all resources (called on agent shutdown).
      */
@@ -31,6 +41,14 @@ export declare class SandboxService implements ISandboxService {
      * @param sessionId - Session identifier
      */
     clearSession(sessionId: string): Promise<void>;
+    /**
+     * Delete a variable from a session's sandbox.
+     * If the sandbox doesn't exist yet, cleans up any pending variable with that key.
+     *
+     * @param sessionId - Session identifier
+     * @param key - Variable name to delete
+     */
+    deleteSandboxVariable(sessionId: string, key: string): void;
     /**
      * Execute JavaScript/TypeScript code in a sandbox.
      *
@@ -40,6 +58,13 @@ export declare class SandboxService implements ISandboxService {
      * @returns Execution result
      */
     executeCode(code: string, sessionId: string, config?: SandboxConfig): Promise<REPLResult>;
+    /**
+     * Set the content generator for parallel LLM operations (mapExtract).
+     * When set, new sandboxes will have access to `tools.curation.mapExtract()`.
+     *
+     * @param contentGenerator - Content generator instance
+     */
+    setContentGenerator(contentGenerator: IContentGenerator): void;
     /**
      * Set the curate service for Tools SDK injection.
      * When set, new sandboxes will have access to curate operations via `tools.curate()`.
@@ -61,6 +86,16 @@ export declare class SandboxService implements ISandboxService {
      * @param fileSystem - File system service instance
      */
     setFileSystem(fileSystem: IFileSystem): void;
+    /**
+     * Set a variable in a session's sandbox.
+     * If the sandbox doesn't exist yet, the variable is buffered and injected
+     * when the sandbox is created on the first executeCode() call.
+     *
+     * @param sessionId - Session identifier
+     * @param key - Variable name
+     * @param value - Variable value
+     */
+    setSandboxVariable(sessionId: string, key: string, value: unknown): void;
     /**
      * Set the search knowledge service for Tools SDK injection.
      * When set, new sandboxes will have access to knowledge search via `tools.searchKnowledge()`.
@@ -69,8 +104,20 @@ export declare class SandboxService implements ISandboxService {
      */
     setSearchKnowledgeService(searchKnowledgeService: ISearchKnowledgeService): void;
     /**
-     * Rebuild the Tools SDK instance when services change.
-     * Clears existing sandboxes so new ones get the updated SDK.
+     * Set the session manager for sub-agent delegation.
+     * When set, new sandboxes will have access to `tools.agentQuery()`.
+     *
+     * @param sessionManager - Session manager instance
+     */
+    setSessionManager(sessionManager: SessionManager): void;
+    /**
+     * Build a Tools SDK instance for a specific session.
+     * Includes `agentQuery` bound to the session's ID for sub-agent delegation.
+     */
+    private buildToolsSDK;
+    /**
+     * Clear existing sandboxes so new ones get updated services.
+     * Called when file system, curate, or search services change.
      */
-    private rebuildToolsSDK;
+    private invalidateSandboxes;
 }

package/dist/agent/infra/sandbox/sandbox-service.js

@@ -1,3 +1,4 @@
+import { CurateResultCollector } from './curate-result-collector.js';
 import { LocalSandbox } from './local-sandbox.js';
 import { createToolsSDK } from './tools-sdk.js';
 /**
@@ -5,23 +6,33 @@ import { createToolsSDK } from './tools-sdk.js';
  * Manages sandbox instances tied to agent sessions.
  */
 export class SandboxService {
+    /** Collector wrapping curateService — captures curate() results per executeCode() call */
+    collector;
+    /** Content generator for parallel LLM operations (mapExtract) */
+    contentGenerator;
     /** Curate service for Tools SDK */
     curateService;
     /** Environment context for sandbox injection */
     environmentContext;
     /** File system service for Tools SDK */
     fileSystem;
+    /** Variables buffered before sandbox creation, keyed by sessionId */
+    pendingVariables = new Map();
+    /** Command type used to build each sandbox's ToolsSDK, keyed by sessionId */
+    sandboxCommandTypes = new Map();
     /** Map of agent sessionId to LocalSandbox instance */
     sandboxes = new Map();
     /** Search knowledge service for Tools SDK */
     searchKnowledgeService;
-    /** Cached Tools SDK instance (created when fileSystem is set) */
-    toolsSDK;
+    /** Session manager for sub-agent delegation via tools.agentQuery() */
+    sessionManager;
     /**
      * Clean up all resources (called on agent shutdown).
      */
     async cleanup() {
         this.sandboxes.clear();
+        this.sandboxCommandTypes.clear();
+        this.pendingVariables.clear();
     }
     /**
      * Clear sandbox state for a session.
@@ -30,6 +41,25 @@ export class SandboxService {
      */
     async clearSession(sessionId) {
         this.sandboxes.delete(sessionId);
+        this.sandboxCommandTypes.delete(sessionId);
+        this.pendingVariables.delete(sessionId);
+    }
+    /**
+     * Delete a variable from a session's sandbox.
+     * If the sandbox doesn't exist yet, cleans up any pending variable with that key.
+     *
+     * @param sessionId - Session identifier
+     * @param key - Variable name to delete
+     */
+    deleteSandboxVariable(sessionId, key) {
+        const sandbox = this.sandboxes.get(sessionId);
+        if (sandbox) {
+            sandbox.updateContext({ [key]: undefined });
+        }
+        const pending = this.pendingVariables.get(sessionId);
+        if (pending) {
+            delete pending[key];
+        }
     }
     /**
      * Execute JavaScript/TypeScript code in a sandbox.
@@ -42,25 +72,59 @@ export class SandboxService {
     async executeCode(code, sessionId, config) {
         // Get or create sandbox for this agent session
         let sandbox = this.sandboxes.get(sessionId);
-        if (!sandbox) {
+        if (sandbox) {
+            // Hot-swap ToolsSDK if commandType changed (security: enforce read-only on transition)
+            const previousCommandType = this.sandboxCommandTypes.get(sessionId);
+            if (config?.commandType !== previousCommandType) {
+                const newToolsSDK = this.buildToolsSDK(sessionId, config?.commandType);
+                if (newToolsSDK) {
+                    sandbox.updateContext({ tools: newToolsSDK });
+                }
+                this.sandboxCommandTypes.set(sessionId, config?.commandType);
+            }
+            // Update context if provided
+            if (config?.contextPayload) {
+                sandbox.updateContext({ context: config.contextPayload });
+            }
+        }
+        else {
             // First execution for this session - create new sandbox
             const initialContext = {};
             if (config?.contextPayload) {
                 initialContext.context = config.contextPayload;
             }
+            // Inject any pending variables set before sandbox creation
+            const pending = this.pendingVariables.get(sessionId);
+            if (pending) {
+                Object.assign(initialContext, pending);
+                this.pendingVariables.delete(sessionId);
+            }
+            // Build per-session ToolsSDK (includes agentQuery bound to this sessionId)
+            const sessionToolsSDK = this.buildToolsSDK(sessionId, config?.commandType);
             sandbox = new LocalSandbox({
                 environmentContext: this.environmentContext,
                 initialContext,
-                toolsSDK: this.toolsSDK,
+                toolsSDK: sessionToolsSDK,
             });
             this.sandboxes.set(sessionId, sandbox);
+            this.sandboxCommandTypes.set(sessionId, config?.commandType);
         }
-        else if (config?.contextPayload) {
-            // Update context if provided
-            sandbox.updateContext({ context: config.contextPayload });
+        if (this.collector) {
+            const { curateResults, result } = await this.collector.collect(() => sandbox.execute(code, config));
+            return curateResults.length > 0 ? { ...result, curateResults } : result;
         }
         return sandbox.execute(code, config);
     }
+    /**
+     * Set the content generator for parallel LLM operations (mapExtract).
+     * When set, new sandboxes will have access to `tools.curation.mapExtract()`.
+     *
+     * @param contentGenerator - Content generator instance
+     */
+    setContentGenerator(contentGenerator) {
+        this.contentGenerator = contentGenerator;
+        this.invalidateSandboxes();
+    }
     /**
      * Set the curate service for Tools SDK injection.
      * When set, new sandboxes will have access to curate operations via `tools.curate()`.
@@ -68,8 +132,9 @@ export class SandboxService {
      * @param curateService - Curate service instance
      */
     setCurateService(curateService) {
-        this.curateService = curateService;
-        this.rebuildToolsSDK();
+        this.collector = new CurateResultCollector(curateService);
+        this.curateService = this.collector;
+        this.invalidateSandboxes();
     }
     /**
      * Set the environment context for sandbox injection.
@@ -81,6 +146,7 @@ export class SandboxService {
         this.environmentContext = environmentContext;
         // Clear existing sandboxes so new ones get the updated environment
         this.sandboxes.clear();
+        this.sandboxCommandTypes.clear();
     }
     /**
      * Set the file system service for Tools SDK injection.
@@ -90,7 +156,31 @@ export class SandboxService {
      */
     setFileSystem(fileSystem) {
         this.fileSystem = fileSystem;
-        this.rebuildToolsSDK();
+        this.invalidateSandboxes();
+    }
+    /**
+     * Set a variable in a session's sandbox.
+     * If the sandbox doesn't exist yet, the variable is buffered and injected
+     * when the sandbox is created on the first executeCode() call.
+     *
+     * @param sessionId - Session identifier
+     * @param key - Variable name
+     * @param value - Variable value
+     */
+    setSandboxVariable(sessionId, key, value) {
+        const sandbox = this.sandboxes.get(sessionId);
+        if (sandbox) {
+            sandbox.updateContext({ [key]: value });
+        }
+        else {
+            // Buffer — will be injected when sandbox is created in executeCode()
+            let pending = this.pendingVariables.get(sessionId);
+            if (!pending) {
+                pending = {};
+                this.pendingVariables.set(sessionId, pending);
+            }
+            pending[key] = value;
+        }
     }
     /**
      * Set the search knowledge service for Tools SDK injection.
@@ -100,19 +190,44 @@ export class SandboxService {
      */
     setSearchKnowledgeService(searchKnowledgeService) {
         this.searchKnowledgeService = searchKnowledgeService;
-        this.rebuildToolsSDK();
+        this.invalidateSandboxes();
+    }
+    /**
+     * Set the session manager for sub-agent delegation.
+     * When set, new sandboxes will have access to `tools.agentQuery()`.
+     *
+     * @param sessionManager - Session manager instance
+     */
+    setSessionManager(sessionManager) {
+        this.sessionManager = sessionManager;
+    }
+    /**
+     * Build a Tools SDK instance for a specific session.
+     * Includes `agentQuery` bound to the session's ID for sub-agent delegation.
+     */
+    buildToolsSDK(sessionId, commandType) {
+        if (!this.fileSystem) {
+            return undefined;
+        }
+        return createToolsSDK({
+            commandType,
+            contentGenerator: this.contentGenerator,
+            curateService: this.curateService,
+            fileSystem: this.fileSystem,
+            parentSessionId: sessionId,
+            sandboxService: this,
+            searchKnowledgeService: this.searchKnowledgeService,
+            sessionManager: this.sessionManager,
+        });
     }
     /**
-     * Rebuild the Tools SDK instance when services change.
-     * Clears existing sandboxes so new ones get the updated SDK.
+     * Clear existing sandboxes so new ones get updated services.
+     * Called when file system, curate, or search services change.
      */
-    rebuildToolsSDK() {
+    invalidateSandboxes() {
         if (this.fileSystem) {
-            this.toolsSDK = createToolsSDK(this.fileSystem, this.searchKnowledgeService, this.curateService);
-            // Clear existing sandboxes so new ones get the updated tools SDK
-            // Note: This means existing sessions lose their state when services are updated
-            // This is acceptable since services are typically set once at startup
             this.sandboxes.clear();
+            this.sandboxCommandTypes.clear();
         }
     }
 }

package/dist/agent/infra/sandbox/tools-sdk.d.ts

@@ -1,6 +1,10 @@
 import type { FileContent, GlobResult, ListDirectoryResult, SearchResult, WriteResult } from '../../core/domain/file-system/types.js';
+import type { IContentGenerator } from '../../core/interfaces/i-content-generator.js';
 import type { CurateOperation, CurateOptions, CurateResult, DetectDomainsInput, DetectDomainsResult, ICurateService } from '../../core/interfaces/i-curate-service.js';
 import type { IFileSystem } from '../../core/interfaces/i-file-system.js';
+import type { ISandboxService } from '../../core/interfaces/i-sandbox-service.js';
+import type { SessionManager } from '../session/session-manager.js';
+import { type ChunkResult, type CurationFact, type MessageBoundary, type ReconResult } from './curation-helpers.js';
 /**
  * Options for glob operation in ToolsSDK.
  */
@@ -65,9 +69,19 @@ export interface SearchKnowledgeOptions {
 export interface SearchKnowledgeResult {
     message: string;
     results: Array<{
+        /** For archive stubs: path to full content (for expand_knowledge tool) */
+        archiveFullPath?: string;
+        /** Number of other memories that reference this one */
+        backlinkCount?: number;
         excerpt: string;
         path: string;
+        /** Top backlink source paths (max 3) */
+        relatedPaths?: string[];
         score: number;
+        /** Symbol kind: 'domain' | 'topic' | 'subtopic' | 'context' | 'archive_stub' */
+        symbolKind?: string;
+        /** Resolved hierarchical path in the symbol tree */
+        symbolPath?: string;
         title: string;
     }>;
     totalFound: number;
@@ -84,6 +98,20 @@ export interface ISearchKnowledgeService {
  * Provides async file system operations for programmatic access.
  */
 export interface ToolsSDK {
+    /**
+     * Spawn a sub-agent to process a prompt with full code_exec access.
+     * The sub-agent runs in an isolated context (does not pollute parent).
+     * Only the final response string flows back.
+     * @param prompt - Prompt for the sub-agent
+     * @param options - Optional limits
+     * @param options.contextData - Optional key/value context injected into child session sandbox
+     * @param options.maxIterations - Maximum agentic iterations (default: 5)
+     * @returns Promise resolving to the sub-agent's final response
+     */
+    agentQuery(prompt: string, options?: {
+        contextData?: Record<string, unknown>;
+        maxIterations?: number;
+    }): Promise<string>;
     /**
      * Execute curate operations on knowledge topics.
      * Operations: ADD, UPDATE, MERGE, DELETE
@@ -92,6 +120,44 @@ export interface ToolsSDK {
      * @returns Promise resolving to curate result with applied operations and summary
      */
     curate(operations: CurateOperation[], options?: CurateOptions): Promise<CurateResult>;
+    /**
+     * Pre-built curation helpers — reduces LLM iteration overhead.
+     * Stateless functions except recordProgress (intentionally mutating).
+     */
+    readonly curation: {
+        /** Intelligent boundary-aware text splitting */
+        chunk(context: string, options?: {
+            overlap?: number;
+            size?: number;
+        }): ChunkResult;
+        /** Remove near-duplicate facts using Jaccard word-overlap similarity */
+        dedup(facts: CurationFact[], threshold?: number): CurationFact[];
+        /** Find [USER]: and [ASSISTANT]: markers with offsets */
+        detectMessageBoundaries(context: string): MessageBoundary[];
+        /** Group facts by subject, with fallback to category */
+        groupBySubject(facts: CurationFact[]): Record<string, CurationFact[]>;
+        /** Parallel LLM extraction over chunked context. Curate mode only. */
+        mapExtract(context: string, options: {
+            chunkSize?: number;
+            concurrency?: number;
+            maxContextTokens?: number;
+            prompt: string;
+            taskId?: string;
+        }): Promise<{
+            facts: CurationFact[];
+            failed: number;
+            succeeded: number;
+            total: number;
+        }>;
+        /** Combine Steps 0-2 into one call: metadata + history + preview + mode recommendation */
+        recon(context: string, meta: Record<string, unknown>, history: Record<string, unknown>): ReconResult;
+        /** Push entry into history and increment totalProcessed (intentionally mutating) */
+        recordProgress(history: Record<string, unknown>, entry: {
+            domain: string;
+            keyFacts: string[];
+            title: string;
+        }): void;
+    };
     /**
      * Detect and validate domains from input data.
      * Use this to analyze text and categorize it into knowledge domains.
@@ -143,15 +209,34 @@ export interface ToolsSDK {
      */
     writeFile(filePath: string, content: string, options?: WriteFileOptions): Promise<WriteResult>;
 }
+/**
+ * Options for creating a Tools SDK instance.
+ */
+export interface CreateToolsSDKOptions {
+    /** Command type — when 'query', mutating APIs (curate, writeFile) are disabled */
+    commandType?: string;
+    /** Content generator for parallel LLM operations (mapExtract) */
+    contentGenerator?: IContentGenerator;
+    /** Curate service for knowledge curation */
+    curateService?: ICurateService;
+    /** File system service for file operations */
+    fileSystem: IFileSystem;
+    /** Parent session ID for creating child sessions (required for agentQuery) */
+    parentSessionId?: string;
+    /** Sandbox service for variable injection into child sessions (optional, enables contextData in agentQuery) */
+    sandboxService?: ISandboxService;
+    /** Search knowledge service */
+    searchKnowledgeService?: ISearchKnowledgeService;
+    /** Session manager for sub-agent delegation (required for agentQuery) */
+    sessionManager?: SessionManager;
+}
 /**
  * Creates a Tools SDK instance for sandbox code execution.
  *
  * The SDK provides async wrapper functions around file system operations,
  * allowing code executed in the sandbox to access file system tools programmatically.
  *
- * @param fileSystem - File system service for file operations
- * @param searchKnowledgeService - Optional search knowledge service
- * @param curateService - Optional curate service for knowledge curation
+ * @param options - Configuration options for the Tools SDK
  * @returns ToolsSDK instance ready to be injected into sandbox context
  */
-export declare function createToolsSDK(fileSystem: IFileSystem, searchKnowledgeService?: ISearchKnowledgeService, curateService?: ICurateService): ToolsSDK;
+export declare function createToolsSDK(options: CreateToolsSDKOptions): ToolsSDK;

package/dist/agent/infra/sandbox/tools-sdk.js

@@ -1,17 +1,49 @@
+import { ContextTreeStore } from '../map/context-tree-store.js';
+import { executeLlmMapMemory } from '../map/llm-map-memory.js';
+import { chunk, dedup, detectMessageBoundaries, groupBySubject, recon, recordProgress, } from './curation-helpers.js';
 /**
  * Creates a Tools SDK instance for sandbox code execution.
  *
  * The SDK provides async wrapper functions around file system operations,
  * allowing code executed in the sandbox to access file system tools programmatically.
  *
- * @param fileSystem - File system service for file operations
- * @param searchKnowledgeService - Optional search knowledge service
- * @param curateService - Optional curate service for knowledge curation
+ * @param options - Configuration options for the Tools SDK
  * @returns ToolsSDK instance ready to be injected into sandbox context
  */
-export function createToolsSDK(fileSystem, searchKnowledgeService, curateService) {
+export function createToolsSDK(options) {
+    const { commandType, contentGenerator, curateService, fileSystem, parentSessionId, sandboxService, searchKnowledgeService, sessionManager } = options;
+    const isReadOnly = commandType === 'query';
     return {
+        async agentQuery(prompt, options) {
+            if (!sessionManager || !parentSessionId) {
+                throw new Error('agentQuery not available — no session manager configured');
+            }
+            const childSession = await sessionManager.createChildSession(parentSessionId, 'sub-query');
+            try {
+                // Inject context data as sandbox variables in child session (RLM pattern).
+                // This avoids embedding large data directly in the prompt string.
+                if (options?.contextData && sandboxService) {
+                    for (const [key, value] of Object.entries(options.contextData)) {
+                        sandboxService.setSandboxVariable(childSession.id, key, value);
+                    }
+                }
+                const response = await childSession.run(prompt, {
+                    emitTaskId: false,
+                    executionContext: {
+                        commandType: 'query',
+                        maxIterations: options?.maxIterations ?? 5,
+                    },
+                });
+                return response;
+            }
+            finally {
+                await sessionManager.deleteSession(childSession.id);
+            }
+        },
         async curate(operations, options) {
+            if (isReadOnly) {
+                throw new Error('curate() is disabled in read-only (query) mode');
+            }
             if (!curateService) {
                 return {
                     applied: [{
@@ -31,6 +63,47 @@ export function createToolsSDK(fileSystem, searchKnowledgeService, curateService
             }
             return curateService.curate(operations, options);
         },
+        curation: {
+            chunk,
+            dedup,
+            detectMessageBoundaries,
+            groupBySubject,
+            async mapExtract(context, options) {
+                if (commandType !== 'curate') {
+                    throw new Error('mapExtract only available in curate mode');
+                }
+                if (!contentGenerator) {
+                    throw new Error('mapExtract not available — no content generator configured');
+                }
+                const chunks = chunk(context, { size: options.chunkSize ?? 8000 });
+                const items = chunks.chunks.map((c, i) => ({ chunk: c, index: i, totalChunks: chunks.totalChunks }));
+                // Construct ContextTreeStore with adapter tokenizer (zero-divergence)
+                const tauHard = Math.floor((options.maxContextTokens ?? 100_000) * 0.5);
+                const contextTreeStore = new ContextTreeStore({
+                    generator: contentGenerator,
+                    tauHard,
+                    tokenizer: { countTokens: (text) => contentGenerator.estimateTokensSync(text) },
+                });
+                const result = await executeLlmMapMemory({
+                    concurrency: options.concurrency ?? 8,
+                    contextTreeStore,
+                    generator: contentGenerator,
+                    items,
+                    prompt: options.prompt,
+                    taskId: options.taskId,
+                });
+                // Throw when all chunks fail — no facts to work with
+                if (result.succeeded === 0 && result.total > 0) {
+                    throw new Error(`mapExtract failed: all ${result.total} chunks failed extraction`);
+                }
+                const facts = result.results
+                    .filter((r) => r !== null)
+                    .flat();
+                return { facts, failed: result.failed, succeeded: result.succeeded, total: result.total };
+            },
+            recon,
+            recordProgress,
+        },
         async detectDomains(domains) {
             if (!curateService) {
                 return {
@@ -80,6 +153,9 @@ export function createToolsSDK(fileSystem, searchKnowledgeService, curateService
             return searchKnowledgeService.search(query, options);
         },
         async writeFile(filePath, content, options) {
+            if (isReadOnly) {
+                throw new Error('writeFile() is disabled in read-only (query) mode');
+            }
             return fileSystem.writeFile(filePath, content, {
                 createDirs: options?.createDirs ?? false,
             });

package/dist/agent/infra/session/chat-session.d.ts

@@ -77,7 +77,7 @@ export declare class ChatSession implements IChatSession {
     /**
      * Reset the conversation history.
      */
-    reset(): void;
+    reset(): Promise<void>;
     /**
      * Send a message and get a response.
      * Delegates to the LLM service which handles the agentic loop.

package/dist/agent/infra/session/chat-session.js

@@ -154,9 +154,9 @@ export class ChatSession {
     /**
      * Reset the conversation history.
      */
-    reset() {
+    async reset() {
         const contextManager = this.llmService.getContextManager();
-        contextManager.clearHistory();
+        await contextManager.clearHistory();
         // Emit conversation reset event
         this.sharedServices.agentEventBus.emit('cipher:conversationReset', {
             sessionId: this.id,

package/dist/agent/infra/session/session-event-forwarder.js

@@ -34,9 +34,12 @@
  * @param sessionId - Unique session identifier to add to forwarded events
  */
 export function setupEventForwarding(sessionEventBus, agentEventBus, sessionId) {
-    // Forward llmservice:thinking (void payload)
-    sessionEventBus.on('llmservice:thinking', () => {
-        agentEventBus.emit('llmservice:thinking', { sessionId });
+    // Forward llmservice:thinking (may carry taskId from AgentLLMService)
+    sessionEventBus.on('llmservice:thinking', (payload) => {
+        agentEventBus.emit('llmservice:thinking', {
+            ...(typeof payload === 'object' && payload !== null ? payload : {}),
+            sessionId,
+        });
     });
     // Forward llmservice:chunk
     sessionEventBus.on('llmservice:chunk', (payload) => {