agent-world 0.13.0 → 0.15.0

package/dist/cli/index.js

@@ -13,10 +13,15 @@
  * - Work with loaded world without importing (uses external storage path)
  *
  * Changes:
+ * - 2026-03-06: Routed runtime chat selection through explicit CLI state; removed live listener/send fallback to `world.currentChatId`.
+ * - 2026-02-27: Added active-chat event scoping in CLI listeners to prevent cross-chat message/system/SSE/tool leakage.
+ * - 2026-02-25: Added fallback shorthand attempt `@awesome-agent-world/<input>` when a provided local path does not exist.
+ * - 2026-02-25: Added GitHub shorthand world source import support (`@awesome-agent-world/<world-name>`) with safe remote staging and automatic import mode.
  * - 2026-02-20: Enforced options-only HITL handling in interactive and pipeline modes.
  * - 2026-02-14: Added interactive + pipeline HITL option response handling for generic approval requests.
  * - 2026-02-11: Fixed tool-stream timeout: extendTimeout() resets idle timeout on streaming data
  * - 2026-02-11: Pipeline mode now listens for tool-stream SSE events to extend timeout
+ * - 2026-02-21: Extended timeout-refresh detection to include shell assistant-stream SSE events (`start`/`chunk`/`end` with `toolName='shell_cmd'`) in addition to legacy `tool-stream`.
  * - 2026-01-09: Added --streaming flag for explicit streaming control (overrides TTY auto-detection)
  * - 2025-02-06: Prevented duplicate MESSAGE output when streaming already rendered agent responses
  * - 2025-11-01: Added multi-world selection in loadWorldFromFile
@@ -77,14 +82,17 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { program } from 'commander';
 import readline from 'readline';
-import { listWorlds, subscribeWorld, submitWorldHitlResponse, createCategoryLogger, LLMProvider, enableStreaming, disableStreaming } from '../core/index.js';
+import { listWorlds, deleteWorld, subscribeWorld, submitWorldHitlResponse, GitHubWorldImportError, stageGitHubWorldFromShorthand, createCategoryLogger, LLMProvider, enableStreaming, disableStreaming } from '../core/index.js';
 import { EventType } from '../core/types.js';
 import { getDefaultRootPath } from '../core/storage/storage-factory.js';
+// Opik integration: optional tracer attach for CLI world subscriptions.
+import { attachOptionalOpikTracer } from '../core/optional-tracers/opik-runtime.js';
 import { processCLIInput, displayChatMessages } from './commands.js';
 import { createStreamingState, handleWorldEventWithStreaming, handleToolEvents, } from './stream.js';
 import { configureLLMProvider } from '../core/llm-config.js';
 import { createStatusLineManager, log as statusLog, } from './display.js';
-import { parseHitlPromptRequest, resolveHitlOptionSelectionInput, } from './hitl.js';
+import { getSystemEventDisplayText } from './system-events.js';
+import { markHitlRequestHandled, parseHitlPromptFromToolEvent, resolveHitlOptionSelectionInput, } from './hitl.js';
 // Create CLI category logger after logger auto-initialization
 const logger = createCategoryLogger('cli');
 function createGlobalState() {
@@ -395,11 +403,87 @@ function printCLIResult(result) {
  * @param rl - Readline interface for interactive mode (undefined for pipeline mode)
  * @returns Map of event types to listener functions for cleanup
  */
-function attachCLIListeners(world, streaming, globalState, activityMonitor, statusLine, rl) {
+function attachCLIListeners(world, streaming, globalState, activityMonitor, statusLine, getSelectedChatId, rl) {
     const listeners = new Map();
     let hitlPromptChain = Promise.resolve();
+    const handledHitlRequestIds = new Set();
+    const isChatEventInScope = (eventChatId, includeUnscopedWhenScoped = false) => {
+        const activeChatId = getSelectedChatId();
+        if (!activeChatId) {
+            return true;
+        }
+        if (eventChatId === undefined || eventChatId === null) {
+            return includeUnscopedWhenScoped;
+        }
+        const normalizedEventChatId = String(eventChatId).trim();
+        if (!normalizedEventChatId) {
+            return includeUnscopedWhenScoped;
+        }
+        return normalizedEventChatId === activeChatId;
+    };
+    const shouldHandleWorldEvent = (eventData) => {
+        const eventType = String(eventData?.type || '').trim().toLowerCase();
+        if (eventType === 'response-start' || eventType === 'response-end' || eventType === 'idle' || eventType === 'info') {
+            return isChatEventInScope(eventData?.chatId, true);
+        }
+        if (eventType.startsWith('tool-')) {
+            return isChatEventInScope(eventData?.chatId, false);
+        }
+        return isChatEventInScope(eventData?.chatId, true);
+    };
     // World activity events
     const worldListener = (eventData) => {
+        if (!shouldHandleWorldEvent(eventData)) {
+            return;
+        }
+        const hitlRequest = parseHitlPromptFromToolEvent(eventData);
+        if (hitlRequest) {
+            if (!markHitlRequestHandled(handledHitlRequestIds, hitlRequest.requestId)) {
+                return;
+            }
+            hitlPromptChain = hitlPromptChain
+                .then(async () => {
+                if (streaming && globalState && rl && statusLine) {
+                    globalState.hitlPromptActive = true;
+                    try {
+                        const result = submitWorldHitlResponse({
+                            worldId: world.id,
+                            requestId: hitlRequest.requestId,
+                            optionId: await promptHitlOptionSelection(hitlRequest, statusLine, rl),
+                            chatId: hitlRequest.chatId,
+                        });
+                        if (!result.accepted) {
+                            statusLine.pause();
+                            console.log(boldRed(`Failed to submit approval response: ${result.reason || 'unknown error'}`));
+                            statusLine.resume();
+                            return;
+                        }
+                        statusLine.pause();
+                        console.log(green('Submitted HITL option response.'));
+                        statusLine.resume();
+                        return;
+                    }
+                    finally {
+                        globalState.hitlPromptActive = false;
+                    }
+                }
+                const result = submitWorldHitlResponse({
+                    worldId: world.id,
+                    requestId: hitlRequest.requestId,
+                    optionId: hitlRequest.defaultOptionId,
+                    chatId: hitlRequest.chatId,
+                });
+                if (!result.accepted) {
+                    console.error(boldRed(`Failed to auto-respond HITL request: ${result.reason || 'unknown error'}`));
+                    return;
+                }
+                console.log(`${gray('● system:')} Auto-selected HITL option "${hitlRequest.defaultOptionId}"`);
+            })
+                .catch((error) => {
+                console.error(boldRed(`Error handling HITL request: ${error instanceof Error ? error.message : String(error)}`));
+            });
+            return;
+        }
         activityMonitor.handle(eventData);
         // Only render activity progress in interactive mode
         if (streaming && globalState && rl && statusLine) {
@@ -412,6 +496,9 @@ function attachCLIListeners(world, streaming, globalState, activityMonitor, stat
     listeners.set(EventType.WORLD, worldListener);
     // Message events
     const messageListener = (eventData) => {
+        if (!isChatEventInScope(eventData?.chatId, false)) {
+            return;
+        }
         if (eventData.content &&
             typeof eventData.content === 'string' &&
             eventData.content.includes('Success message sent'))
@@ -435,8 +522,14 @@ function attachCLIListeners(world, streaming, globalState, activityMonitor, stat
     // SSE events (interactive mode only - pipeline mode uses non-streaming LLM calls)
     if (streaming && globalState && rl && statusLine) {
         const sseListener = (eventData) => {
-            // Extend timeout when tool-stream data arrives (keeps long-running tools alive)
-            if (eventData.type === 'tool-stream') {
+            if (!isChatEventInScope(eventData?.chatId, false)) {
+                return;
+            }
+            // Extend timeout when long-running shell stream activity arrives.
+            const isLegacyToolStream = eventData.type === 'tool-stream';
+            const isShellAssistantStream = eventData.toolName === 'shell_cmd' &&
+                (eventData.type === 'start' || eventData.type === 'chunk' || eventData.type === 'end');
+            if (isLegacyToolStream || isShellAssistantStream) {
                 activityMonitor.extendTimeout();
             }
             handleWorldEvent(EventType.SSE, eventData, streaming, globalState, activityMonitor, statusLine, rl)
@@ -446,9 +539,15 @@ function attachCLIListeners(world, streaming, globalState, activityMonitor, stat
         listeners.set(EventType.SSE, sseListener);
     }
     else {
-        // Pipeline mode: listen for tool-stream events to extend timeout on long-running commands
+        // Pipeline mode: listen for shell stream events to extend timeout on long-running commands.
         const sseTimeoutListener = (eventData) => {
-            if (eventData.type === 'tool-stream') {
+            if (!isChatEventInScope(eventData?.chatId, false)) {
+                return;
+            }
+            const isLegacyToolStream = eventData.type === 'tool-stream';
+            const isShellAssistantStream = eventData.toolName === 'shell_cmd' &&
+                (eventData.type === 'start' || eventData.type === 'chunk' || eventData.type === 'end');
+            if (isLegacyToolStream || isShellAssistantStream) {
                 activityMonitor.extendTimeout();
             }
         };
@@ -457,50 +556,7 @@ function attachCLIListeners(world, streaming, globalState, activityMonitor, stat
     }
     // System events
     const systemListener = (eventData) => {
-        const hitlRequest = parseHitlPromptRequest(eventData);
-        if (hitlRequest) {
-            hitlPromptChain = hitlPromptChain
-                .then(async () => {
-                if (streaming && globalState && rl && statusLine) {
-                    globalState.hitlPromptActive = true;
-                    try {
-                        const result = submitWorldHitlResponse({
-                            worldId: world.id,
-                            requestId: hitlRequest.requestId,
-                            optionId: await promptHitlOptionSelection(hitlRequest, statusLine, rl),
-                            chatId: hitlRequest.chatId,
-                        });
-                        if (!result.accepted) {
-                            statusLine.pause();
-                            console.log(boldRed(`Failed to submit approval response: ${result.reason || 'unknown error'}`));
-                            statusLine.resume();
-                            return;
-                        }
-                        statusLine.pause();
-                        console.log(green('Submitted HITL option response.'));
-                        statusLine.resume();
-                        return;
-                    }
-                    finally {
-                        globalState.hitlPromptActive = false;
-                    }
-                }
-                // Pipeline/non-interactive mode: auto-respond with default option to avoid blocking.
-                const result = submitWorldHitlResponse({
-                    worldId: world.id,
-                    requestId: hitlRequest.requestId,
-                    optionId: hitlRequest.defaultOptionId,
-                    chatId: hitlRequest.chatId,
-                });
-                if (!result.accepted) {
-                    console.error(boldRed(`Failed to auto-respond HITL request: ${result.reason || 'unknown error'}`));
-                    return;
-                }
-                console.log(`${gray('● system:')} Auto-selected HITL option "${hitlRequest.defaultOptionId}"`);
-            })
-                .catch((error) => {
-                console.error(boldRed(`Error handling HITL request: ${error instanceof Error ? error.message : String(error)}`));
-            });
+        if (!isChatEventInScope(eventData?.chatId, false)) {
             return;
         }
         if (eventData.content &&
@@ -511,8 +567,11 @@ function attachCLIListeners(world, streaming, globalState, activityMonitor, stat
             handleWorldEvent(EventType.SYSTEM, eventData, streaming, globalState, activityMonitor, statusLine, rl)
                 .catch(err => console.error('Error handling system event:', err));
         }
-        else if (eventData.message || eventData.content) {
-            // Pipeline mode: system messages are handled by message listener
+        else {
+            const systemText = getSystemEventDisplayText(eventData);
+            if (systemText) {
+                console.log(`${boldRed('● system:')} ${systemText}`);
+            }
         }
     };
     world.eventEmitter.on(EventType.SYSTEM, systemListener);
@@ -537,6 +596,7 @@ async function runPipelineMode(options, messageFromArgs) {
     let worldSubscription = null;
     let cliListeners = null;
     const activityMonitor = new WorldActivityMonitor();
+    const opikEnabledOverride = parseOptionalBoolean(options.opikEnabled);
     try {
         if (options.world) {
             // Subscribe to world lifecycle but do not request forwarding callbacks
@@ -546,9 +606,11 @@ async function runPipelineMode(options, messageFromArgs) {
                 process.exit(1);
             }
             world = worldSubscription.world;
+            await attachOptionalOpikTracer(world, { source: 'cli', enabledOverride: opikEnabledOverride });
             // Attach direct listeners to the world.eventEmitter for pipeline handling
             // Note: Pipeline mode uses non-streaming LLM calls, so SSE events are not needed
-            cliListeners = attachCLIListeners(world, null, null, activityMonitor, null);
+            const selectedChatId = String(world?.currentChatId || '').trim() || null;
+            cliListeners = attachCLIListeners(world, null, null, activityMonitor, null, () => selectedChatId);
         }
         // Execute command from --command option
         if (options.command) {
@@ -557,7 +619,7 @@ async function runPipelineMode(options, messageFromArgs) {
                 process.exit(1);
             }
             const snapshot = activityMonitor.captureSnapshot();
-            const result = await processCLIInput(options.command, world, 'human');
+            const result = await processCLIInput(options.command, world, 'human', String(world?.currentChatId || '').trim() || null);
             printCLIResult(result);
             if (!options.command.startsWith('/') && world) {
                 try {
@@ -590,7 +652,7 @@ async function runPipelineMode(options, messageFromArgs) {
                 process.exit(1);
             }
             const snapshot = activityMonitor.captureSnapshot();
-            const result = await processCLIInput(messageFromArgs, world, 'human');
+            const result = await processCLIInput(messageFromArgs, world, 'human', String(world?.currentChatId || '').trim() || null);
             printCLIResult(result);
             try {
                 // Event-driven completion: wait for world idle state
@@ -621,7 +683,7 @@ async function runPipelineMode(options, messageFromArgs) {
                     process.exit(1);
                 }
                 const snapshot = activityMonitor.captureSnapshot();
-                const result = await processCLIInput(input.trim(), world, 'HUMAN');
+                const result = await processCLIInput(input.trim(), world, 'HUMAN', String(world?.currentChatId || '').trim() || null);
                 printCLIResult(result);
                 try {
                     // Event-driven completion: wait for world idle state
@@ -681,20 +743,26 @@ function cleanupWorldSubscription(worldState) {
  * @param rl - Readline interface for interactive input
  * @returns WorldState with subscription and world instance
  */
-async function handleSubscribe(rootPath, worldName, streaming, globalState, activityMonitor, statusLine, rl) {
+async function handleSubscribe(rootPath, worldName, streaming, globalState, activityMonitor, statusLine, opikEnabledOverride, rl) {
     // Subscribe to world lifecycle but do not request forwarding callbacks
     const subscription = await subscribeWorld(worldName, { isOpen: true });
     if (!subscription)
         throw new Error('Failed to load world');
     const world = subscription.world;
+    await attachOptionalOpikTracer(world, { source: 'cli', enabledOverride: opikEnabledOverride });
     // Store world in globalState for access in interactive event handlers.
     if (globalState) {
         globalState.world = world;
     }
     // Attach direct listeners to the world.eventEmitter for CLI handling
     // Interactive mode needs all event types including SSE for streaming responses
-    attachCLIListeners(world, streaming, globalState, activityMonitor, statusLine, rl);
-    return { subscription, world };
+    const worldState = {
+        subscription,
+        world,
+        selectedChatId: String(world.currentChatId || '').trim() || null,
+    };
+    attachCLIListeners(world, streaming, globalState, activityMonitor, statusLine, () => worldState.selectedChatId, rl);
+    return worldState;
 }
 // Handle world events with streaming support
 async function handleWorldEvent(eventType, eventData, streaming, globalState, activityMonitor, statusLine, rl) {
@@ -812,8 +880,18 @@ async function handleWorldEvent(eventType, eventData, streaming, globalState, ac
         }
         return;
     }
-    if ((eventType === 'system' || eventType === 'world') && (eventData.message || eventData.content)) {
-        // existing logic
+    if (eventType === 'system') {
+        const systemText = getSystemEventDisplayText(eventData);
+        if (systemText) {
+            statusLog(statusLine, `${boldRed('● system:')} ${systemText}`);
+        }
+        return;
+    }
+    if (eventType === 'world' && (eventData.message || eventData.content)) {
+        const worldText = getSystemEventDisplayText(eventData);
+        if (worldText) {
+            statusLog(statusLine, `${gray('[World]')} ${worldText}`);
+        }
     }
 }
 // World discovery and selection
@@ -878,9 +956,13 @@ async function selectWorld(rootPath, rl) {
 // Load world from external file folder
 async function loadWorldFromFile(currentRootPath, rl) {
     const fs = await import('fs');
+    void currentRootPath;
+    let stagedGitHubWorld = null;
+    let resolvedSourcePath = '';
+    let importIsRequired = false;
     // Get world folder path
-    const folderPath = await new Promise((resolve) => {
-        rl.question(`\n${boldMagenta('Enter path to world folder:')} `, (answer) => {
+    const sourceInput = await new Promise((resolve) => {
+        rl.question(`\n${boldMagenta('Enter path to world folder (or @awesome-agent-world/<world-name>):')} `, (answer) => {
             const trimmed = answer.trim();
             if (trimmed === '') {
                 resolve(null);
@@ -890,28 +972,57 @@ async function loadWorldFromFile(currentRootPath, rl) {
             }
         });
     });
-    if (!folderPath) {
+    if (!sourceInput) {
         console.log(boldRed('Load cancelled.'));
         return null;
     }
-    // Validate folder exists
-    if (!fs.existsSync(folderPath)) {
-        console.log(boldRed(`Folder does not exist: ${folderPath}`));
-        return null;
-    }
     try {
+        if (sourceInput.startsWith('@')) {
+            stagedGitHubWorld = await stageGitHubWorldFromShorthand(sourceInput);
+            resolvedSourcePath = stagedGitHubWorld.stagingRootPath;
+            importIsRequired = true;
+            console.log(green(`Fetched world source from GitHub: ${sourceInput}`));
+            if (stagedGitHubWorld.source.commitSha) {
+                console.log(`  ${yellow('Source commit:')} ${stagedGitHubWorld.source.commitSha}`);
+            }
+        }
+        else {
+            resolvedSourcePath = sourceInput;
+            if (!fs.existsSync(resolvedSourcePath)) {
+                const fallbackShorthand = `@awesome-agent-world/${sourceInput}`;
+                try {
+                    stagedGitHubWorld = await stageGitHubWorldFromShorthand(fallbackShorthand);
+                    resolvedSourcePath = stagedGitHubWorld.stagingRootPath;
+                    importIsRequired = true;
+                    console.log(yellow(`Folder does not exist locally: ${sourceInput}`));
+                    console.log(green(`Trying GitHub shorthand: ${fallbackShorthand}`));
+                    if (stagedGitHubWorld.source.commitSha) {
+                        console.log(`  ${yellow('Source commit:')} ${stagedGitHubWorld.source.commitSha}`);
+                    }
+                }
+                catch (fallbackError) {
+                    if (!(fallbackError instanceof GitHubWorldImportError)) {
+                        throw fallbackError;
+                    }
+                }
+            }
+        }
+        if (!fs.existsSync(resolvedSourcePath)) {
+            console.log(boldRed(`Folder does not exist: ${resolvedSourcePath}`));
+            return null;
+        }
         // Import necessary functions
         const { createStorage } = await import('../core/storage/storage-factory.js');
-        const { checkTargetExists, deleteExistingData } = await import('./commands.js');
+        const { createStorageFromEnv } = await import('../core/storage/storage-factory.js');
         // Create storage instance for source folder
         const sourceStorage = await createStorage({
             type: 'file',
-            rootPath: folderPath
+            rootPath: resolvedSourcePath
         });
         // List worlds in the source folder
         const worldsInFolder = await sourceStorage.listWorlds();
         if (worldsInFolder.length === 0) {
-            console.log(boldRed(`No worlds found in: ${folderPath}`));
+            console.log(boldRed(`No worlds found in: ${resolvedSourcePath}`));
             return null;
         }
         // Select world if multiple
@@ -959,20 +1070,25 @@ async function loadWorldFromFile(currentRootPath, rl) {
         const chats = await sourceStorage.listChats(worldData.id);
         console.log(`  ${yellow('Chats:')} ${chats.length}`);
         // Ask if user wants to import
-        const shouldImport = await new Promise((resolve) => {
-            rl.question(`\n${boldMagenta('Import this world to current storage?')} ${boldMagenta('(yes/no):')} `, (answer) => {
-                const trimmed = answer.trim().toLowerCase();
-                resolve(trimmed === 'yes' || trimmed === 'y');
+        const shouldImport = importIsRequired
+            ? true
+            : await new Promise((resolve) => {
+                rl.question(`\n${boldMagenta('Import this world to current storage?')} ${boldMagenta('(yes/no):')} `, (answer) => {
+                    const trimmed = answer.trim().toLowerCase();
+                    resolve(trimmed === 'yes' || trimmed === 'y');
+                });
             });
-        });
         if (!shouldImport) {
             console.log(yellow('World loaded from external storage (not imported).'));
             // Return world name with external path to use that storage
-            return { worldName: worldData.name, externalPath: folderPath };
+            return { worldName: worldData.id, externalPath: resolvedSourcePath };
         }
-        // Check if world already exists in current storage
-        const checkResult = await checkTargetExists(currentRootPath, 'file', worldData.id);
-        if (checkResult.exists) {
+        // Check if world already exists in active runtime storage
+        const existingWorlds = await listWorlds();
+        const idConflict = existingWorlds.find((world) => String(world?.id || '') === String(worldData?.id || ''));
+        const nameConflict = existingWorlds.find((world) => String(world?.name || '').trim().toLowerCase() === String(worldData?.name || '').trim().toLowerCase());
+        const existingWorld = idConflict || nameConflict;
+        if (existingWorld) {
             // Confirm overwrite
             const shouldOverwrite = await new Promise((resolve) => {
                 rl.question(`\n${boldYellow(`World '${worldData.name}' already exists. Overwrite?`)} ${boldMagenta('(yes/no):')} `, (answer) => {
@@ -983,17 +1099,18 @@ async function loadWorldFromFile(currentRootPath, rl) {
             if (!shouldOverwrite) {
                 console.log(yellow('Import cancelled. Loading from external storage instead.'));
                 // Return world name with external path to use that storage
-                return { worldName: worldData.name, externalPath: folderPath };
+                return { worldName: worldData.id, externalPath: resolvedSourcePath };
             }
             // Delete existing world
-            await deleteExistingData(currentRootPath, 'file', worldData.id);
-            console.log(green(`Deleted existing world '${worldData.name}'`));
+            const deleted = await deleteWorld(String(existingWorld.id));
+            if (!deleted) {
+                console.log(boldRed(`Failed to delete existing world '${existingWorld.id}' before import.`));
+                return null;
+            }
+            console.log(green(`Deleted existing world '${existingWorld.name || existingWorld.id}'`));
         }
-        // Create storage instance for target
-        const targetStorage = await createStorage({
-            type: 'file',
-            rootPath: currentRootPath
-        });
+        // Create storage instance for active runtime target
+        const targetStorage = await createStorageFromEnv();
         // Save world
         await targetStorage.saveWorld(worldData);
         // Save all agents
@@ -1033,12 +1150,29 @@ async function loadWorldFromFile(currentRootPath, rl) {
         console.log(`  ${yellow('Agents:')} ${agents.length}`);
         console.log(`  ${yellow('Chats:')} ${chats.length}`);
         console.log(`  ${yellow('Events:')} ${eventCount}`);
-        return { worldName: worldData.name };
+        return { worldName: worldData.id };
     }
     catch (error) {
+        if (error instanceof GitHubWorldImportError) {
+            console.log(boldRed(`Error loading world: ${error.message}`));
+            const details = error.details || {};
+            const owner = String(details.owner || '');
+            const repo = String(details.repo || '');
+            const branch = String(details.branch || '');
+            const worldPath = String(details.worldPath || '');
+            if (owner && repo && branch && worldPath) {
+                console.log(`  ${yellow('Resolved source:')} ${owner}/${repo}@${branch}:${worldPath}`);
+            }
+            return null;
+        }
         console.log(boldRed(`Error loading world: ${error instanceof Error ? error.message : String(error)}`));
         return null;
     }
+    finally {
+        if (stagedGitHubWorld) {
+            await stagedGitHubWorld.cleanup();
+        }
+    }
 }
 // Chat discovery and selection
 async function selectChat(world, chats, currentChatId, rl) {
@@ -1143,6 +1277,7 @@ async function confirmOverwrite(message, rl) {
 // Interactive mode: console-based interface
 async function runInteractiveMode(options) {
     const rootPath = options.root || DEFAULT_ROOT_PATH;
+    const opikEnabledOverride = parseOptionalBoolean(options.opikEnabled);
     const globalState = createGlobalState();
     const streaming = createStreamingState();
     const activityMonitor = new WorldActivityMonitor();
@@ -1164,7 +1299,7 @@ async function runInteractiveMode(options) {
             try {
                 activityMonitor.reset();
                 statusLine.reset();
-                worldState = await handleSubscribe(rootPath, options.world, streaming, globalState, activityMonitor, statusLine, rl);
+                worldState = await handleSubscribe(rootPath, options.world, streaming, globalState, activityMonitor, statusLine, opikEnabledOverride, rl);
                 currentWorldName = options.world;
                 console.log(success(`Connected to world: ${currentWorldName}`));
                 if (worldState?.world) {
@@ -1190,7 +1325,7 @@ async function runInteractiveMode(options) {
             try {
                 activityMonitor.reset();
                 statusLine.reset();
-                worldState = await handleSubscribe(effectiveRootPath, selectedWorld.worldName, streaming, globalState, activityMonitor, statusLine, rl);
+                worldState = await handleSubscribe(effectiveRootPath, selectedWorld.worldName, streaming, globalState, activityMonitor, statusLine, opikEnabledOverride, rl);
                 currentWorldName = selectedWorld.worldName;
                 console.log(success(`Connected to world: ${currentWorldName}`));
                 if (selectedWorld.externalPath) {
@@ -1218,7 +1353,7 @@ async function runInteractiveMode(options) {
         console.log('');
         // Display current chat messages after Quick Start tips
         if (worldState?.world) {
-            await displayChatMessages(worldState.world.id, worldState.world.currentChatId);
+            await displayChatMessages(worldState.world.id, worldState.selectedChatId);
         }
         console.log(); // Empty line before prompt
         rl.prompt();
@@ -1252,7 +1387,7 @@ async function runInteractiveMode(options) {
                 snapshot = activityMonitor.captureSnapshot();
             }
             try {
-                const result = await processCLIInput(trimmedInput, worldState?.world || null, 'HUMAN');
+                const result = await processCLIInput(trimmedInput, worldState?.world || null, 'HUMAN', worldState?.selectedChatId || null);
                 // Handle exit commands from result (redundant, but keep for safety)
                 if (result.data?.exit) {
                     if (isExiting)
@@ -1290,7 +1425,7 @@ async function runInteractiveMode(options) {
                         logger.debug(`Subscribing to world: ${selectedWorld.worldName}...`);
                         activityMonitor.reset();
                         statusLine.reset();
-                        worldState = await handleSubscribe(effectiveRootPath, selectedWorld.worldName, streaming, globalState, activityMonitor, statusLine, rl);
+                        worldState = await handleSubscribe(effectiveRootPath, selectedWorld.worldName, streaming, globalState, activityMonitor, statusLine, opikEnabledOverride, rl);
                         currentWorldName = selectedWorld.worldName;
                         console.log(success(`Connected to world: ${currentWorldName}`));
                         if (selectedWorld.externalPath) {
@@ -1299,7 +1434,7 @@ async function runInteractiveMode(options) {
                         if (worldState?.world) {
                             console.log(`${gray('Agents:')} ${yellow(String(worldState.world.agents?.size || 0))} ${gray('| Turn Limit:')} ${yellow(String(worldState.world.turnLimit || 'N/A'))}`);
                             // Display current chat messages
-                            await displayChatMessages(worldState.world.id, worldState.world.currentChatId);
+                            await displayChatMessages(worldState.world.id, worldState.selectedChatId);
                         }
                     }
                     catch (err) {
@@ -1337,6 +1472,7 @@ async function runInteractiveMode(options) {
                             // console.log(boldBlue('Refreshing world state...'));
                             const refreshedWorld = await worldState.subscription.refresh(rootPath);
                             worldState.world = refreshedWorld;
+                            worldState.selectedChatId = selectedChatId;
                             console.log(success('World state refreshed'));
                         }
                     }
@@ -1449,6 +1585,8 @@ async function runInteractiveMode(options) {
                         // Use the subscription's refresh method to properly destroy old world and create new
                         const refreshedWorld = await worldState.subscription.refresh(rootPath);
                         worldState.world = refreshedWorld;
+                        const refreshedChatId = String(result.data?.currentChatId || refreshedWorld?.currentChatId || '').trim();
+                        worldState.selectedChatId = refreshedChatId || worldState.selectedChatId;
                         console.log(success('World state refreshed'));
                     }
                     catch (err) {
@@ -1539,6 +1677,19 @@ function determineStreamingMode(streamingFlag, isTTY) {
     // Auto-detect: enable streaming for interactive (TTY), disable for pipeline
     return isTTY;
 }
+function parseOptionalBoolean(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (['true', '1', 'yes', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['false', '0', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    return undefined;
+}
 // Main CLI entry point
 async function main() {
     // Configure LLM providers from environment variables at startup
@@ -1555,6 +1706,7 @@ async function main() {
         .option('-c, --command <cmd>', 'Command to execute in pipeline mode')
         .option('-l, --logLevel <level>', 'Set log level (trace, debug, info, warn, error)', 'error')
         .option('--streaming', 'Enable streaming responses (default: auto-detected from TTY)')
+        .option('--opik-enabled <true|false>', 'Override OPIK_ENABLED for this CLI run')
         .option('-s, --server', 'Launch the server before running CLI')
         .allowUnknownOption()
         .allowExcessArguments()

package/dist/cli/system-events.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CLI System Event Formatting Helpers
+ *
+ * Purpose:
+ * - Convert runtime `system` event payloads into readable CLI output text.
+ *
+ * Key Features:
+ * - Supports plain-string and structured-object system payloads.
+ * - Preserves important status families such as title updates and queue failures.
+ * - Keeps formatting pure so both interactive and pipeline paths share the same logic.
+ *
+ * Notes on Implementation:
+ * - Leaf helper with no terminal side effects.
+ * - Unknown payloads return `null` so callers can skip empty/noise events.
+ *
+ * Summary of Recent Changes:
+ * - 2026-03-12: Created for cross-client system-status parity.
+ */
+export interface CliSystemEventPayload {
+    message?: unknown;
+    content?: unknown;
+    eventType?: unknown;
+    type?: unknown;
+    title?: unknown;
+    [key: string]: unknown;
+}
+export declare function getSystemEventDisplayText(eventData: CliSystemEventPayload | null | undefined): string | null;