@calliopelabs/cli 3.1.0 → 3.2.0

package/dist/ui/commands.js

@@ -9,10 +9,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as config from '../config.js';
-import { selectProvider, getAvailableProviders } from '../providers/index.js';
 import { MODE_CONFIG } from '../types.js';
 import { getSystemPromptForProvider } from '../local-model.js';
-import { getAvailableModels, getModelContextLimit } from '../model-detection.js';
 import * as storage from '../storage.js';
 import * as mcp from '../mcp.js';
 import * as skills from '../skills.js';
@@ -41,10 +39,30 @@ export const COMMAND_NAMES = [
     '/quit',
     '/model',
     '/provider',
+    '/doctor',
+    '/permissions',
+    '/auto',
+    '/tools',
+    '/run',
+    '/orchestrate',
+    '/brain',
+    '/kg',
+    '/improve',
+    '/agents',
+    '/tasks',
+    '/defaults',
+    '/once',
     '/mode',
     '/undo',
     '/export',
+    '/import',
+    '/branch',
+    '/checkout',
+    '/diff',
+    '/replay',
     '/resume',
+    '/new',
+    '/sessions',
     '/compact',
     '/scope',
     '/memory',
@@ -70,6 +88,19 @@ function buildFullSystemPrompt(dir, provider) {
 function getActiveProjectDir(ctx) {
     return ctx.sessionRef.current?.projectPath ?? process.cwd();
 }
+/** Refresh the active prompt; a failed reload must not retain revoked context. */
+function refreshProjectContext(ctx) {
+    ctx.reloadDefaults?.(getActiveProjectDir(ctx));
+    let content = getSystemPromptForProvider(ctx.actualProvider);
+    try {
+        content = buildFullSystemPrompt(getActiveProjectDir(ctx), ctx.actualProvider);
+    }
+    finally {
+        const messages = ctx.llmMessages.current;
+        ctx.llmMessages.current = [{ role: 'system', content }, ...messages.filter(message => message.role !== 'system')];
+        ctx.setContextTokens(ctx.estimateContextTokens());
+    }
+}
 function formatSessionLogLimit(limit) {
     return limit > 0 ? String(limit) : 'unlimited';
 }
@@ -110,12 +141,47 @@ export async function handleCommand(cmd, ctx) {
 Model & Mode
   /model [name|list]          Switch model, or list/pick available models
   /provider [name|list]       Switch provider, or list providers
-  /mode [plan|hybrid|work]    Switch mode (Shift+Tab to cycle)
+  /doctor [providers|provider <name>]   Provider health; --probe checks discovery
+  /defaults [save|reset]     Inspect or persist project model defaults
+  /once --provider <name> -- <prompt>   Override one turn (also --model)
+  /mode [plan|hybrid|work|auto]  Switch execution mode (Shift+Tab cycles safe modes)
 
 Conversation
   /undo                       Undo the last change (up to 10 steps)
-  /export [file.md]           Export conversation to markdown
-  /resume [sessionId]         Resume a saved session (restores full context)
+  /branch [name]             Branch and switch conversation with current tool state
+  /checkout <id|name>         Switch conversation; workspace files stay in place
+  /diff <id|name>             Compare another conversation with the current one
+  /replay [revision]          Read recorded conversation without executing tools
+  /auto [on|off]              Run without prompts for this REPL session
+  /permissions [off|on|list|reset|revoke <id>]  Control prompts and saved approvals
+  /brain init|status|ingest|search|entity|neighbors|path  Project knowledge
+  /kg search|graph           Knowledge graph
+  /improve history|propose|run|rollback [--run <id>]  Bounded improvement cycles
+  /orchestrate <goal>        Plan, review and run within one goal budget
+  /orchestrate <goal> --worker-provider NAME --worker-model ID --reviewer-provider NAME --reviewer-model ID --attempts 1..4
+  /orchestrate <goal> --supervise --isolation-image sha256:ID --principle robustness
+    --controller-provider NAME --controller-model ID [--supervision-reviewer-provider NAME --supervision-reviewer-model ID]
+  /orchestrate status|proposal|replay|resume|cancel <id>  Inspect or control a goal
+  /orchestrate approve <id> <hash>  Review and approve the exact proposal
+  /orchestrate revise <id> <plan>   Correct a proposal before execution
+  /run <plan> --dry-run       Validate a task plan without starting agents
+  /run prepare <plan>         Record an inactive orchestration run
+  /run <plan>                 Execute a reviewed task graph with tool approvals
+  /run execute|resume <id>     Start or resume bounded workers
+  /run retry|accept <id> <task> Retry work or accept recorded evidence
+  /run status|approve|cancel <id>  Inspect or review a prepared run
+  /agents hud agents|workflows|off  Choose compact live progress
+  /agents [tree] [run-id]      Inspect declared agents
+  /agents stop|retry <agent> --run <id>  Control a bounded agent
+  /agents spawn <children.json> --run <id>  Review and execute bounded children
+  /agents spawn --resume <hash> --run <id>  Recover an approved child admission
+  /tasks [graph] [run-id]      Inspect task dependencies
+  /tools [list|last|output-id] Inspect retained tool output; expand/collapse and page
+  /export [file.json|file.md]  Save private history JSON or readable markdown
+  /import <file.json>         Validate and import into a separate inactive session
+  /new                       Start a separate session
+  /sessions                  List saved sessions
+  /resume [sessionId]         Resume validated conversation and tool context
   /compact [status]           Compress conversation context; status shows a summary
 
 Workspace
@@ -146,79 +212,110 @@ File references: @filename, ./path, /absolute/path`;
             ctx.addMessage('system', help);
             break;
         }
-        case '/provider':
-            if (parts[1] && parts[1] !== 'list') {
-                const requested = parts[1].toLowerCase();
-                const available = getAvailableProviders();
-                if (!available.includes(requested)) {
-                    ctx.addMessage('error', `Provider "${requested}" is not configured. Run /provider (no args) for an interactive picker with setup.`);
-                    break;
+        case '/brain':
+        case '/kg': {
+            const { runBrainCommand } = await import('../brain/index.js');
+            const { parseOrchestrationArgs } = await import('../orchestration/index.js');
+            await runBrainCommand(parseOrchestrationArgs(cmd.slice(parts[0].length)), { kg: parts[0] === '/kg', cwd: getActiveProjectDir(ctx), signal: ctx.signal, mode: ctx.mode, confirmation: ctx.confirmMode ? 'mutating' : 'none', approve: ctx.approve ? (decision) => ctx.approve(decision, ctx.signal) : undefined, write: text => ctx.addMessage('system', text.trimEnd()) });
+            break;
+        }
+        case '/improve': {
+            const { runImprovementCommand } = await import('../improvement/index.js');
+            const { parseOrchestrationArgs } = await import('../orchestration/index.js');
+            await runImprovementCommand(parseOrchestrationArgs(cmd.slice(parts[0].length)), { onProgress: ctx.onWorkflowProgress, cwd: getActiveProjectDir(ctx), signal: ctx.signal, mode: ctx.mode, source: 'repl', approvals: ctx.approvals, confirmation: ctx.confirmMode ? 'mutating' : 'none', approve: ctx.approve ? (decision, signal) => ctx.approve(decision, signal ?? ctx.signal) : undefined, write: text => ctx.addMessage('system', text.trimEnd()) });
+            break;
+        }
+        case '/orchestrate': {
+            const { runGoalCommand } = await import('../goals/index.js');
+            const { parseOrchestrationArgs } = await import('../orchestration/index.js');
+            await runGoalCommand(parseOrchestrationArgs(cmd.slice(parts[0].length)), { onProgress: ctx.onWorkflowProgress, cwd: getActiveProjectDir(ctx), signal: ctx.signal, mode: ctx.mode, source: 'repl', ...(ctx.provider ? { preference: { provider: ctx.provider, ...(ctx.model ? { model: ctx.model } : {}) } } : {}), approvals: ctx.approvals, confirmation: ctx.confirmMode ? 'mutating' : 'none', approve: ctx.approve ? (decision, signal) => ctx.approve(decision, signal ?? ctx.signal) : undefined, write: text => ctx.addMessage('system', text.trimEnd()) });
+            break;
+        }
+        case '/run':
+        case '/agents':
+        case '/tasks': {
+            const { runOrchestrationCommand, parseOrchestrationArgs } = await import('../orchestration/index.js');
+            if (command === '/agents' && parts[1] === 'hud') {
+                const mode = parts[2] ?? 'agents';
+                if (parts.length > 3 || !['agents', 'workflows', 'off'].includes(mode)) {
+                    ctx.addMessage('error', 'Usage: /agents hud agents|workflows|off');
+                    return;
                 }
-                ctx.setProvider(requested);
-                // Explicit switches persist as the new defaults; a stale model from
-                // the previous provider must not leak into this one (#233).
-                config.set('defaultProvider', requested);
-                config.unset('defaultModel');
-                ctx.addMessage('system', `Provider: ${selectProvider(requested)} (saved as default)`);
-            }
-            else if (parts[1] === 'list') {
-                ctx.addMessage('system', `Provider: ${ctx.actualProvider} | Available: ${getAvailableProviders().join(', ')}`);
+                ctx.setWorkflowHudMode?.(mode);
+                ctx.addMessage('system', `Workflow HUD: ${mode}.`);
+                return;
             }
-            else if (ctx.openProviderPicker) {
-                ctx.openProviderPicker();
+            await runOrchestrationCommand(command.slice(1), parseOrchestrationArgs(cmd.slice(parts[0].length)), { onProgress: ctx.onWorkflowProgress, cwd: getActiveProjectDir(ctx), signal: ctx.signal, mode: ctx.mode, source: 'repl', approvals: ctx.approvals, confirmation: ctx.confirmMode ? 'mutating' : 'none', approve: ctx.approve ? (decision, signal) => ctx.approve(decision, signal ?? ctx.signal) : undefined, write: text => ctx.addMessage('system', text.trimEnd()) });
+            break;
+        }
+        case '/tools': {
+            const { handleToolOutputCommand } = await import('./tool-output-commands.js');
+            handleToolOutputCommand(parts, ctx);
+            break;
+        }
+        case '/auto':
+        case '/permissions': {
+            const setting = parts[1]?.toLowerCase();
+            const enableAuto = command === '/auto' && setting === 'on'
+                || command === '/permissions' && ['off', 'auto'].includes(setting ?? '');
+            const disableAuto = command === '/auto' && setting === 'off'
+                || command === '/permissions' && ['on', 'ask'].includes(setting ?? '');
+            if (enableAuto || disableAuto) {
+                if (enableAuto)
+                    ctx.setMode('work');
+                ctx.setConfirmMode(disableAuto);
+                ctx.addMessage('system', enableAuto
+                    ? 'Auto mode ON — tool confirmation prompts are disabled for this REPL session. Project policy, scope, sandbox and orchestration authority still apply.'
+                    : 'Auto mode OFF — tool confirmation prompts are enabled.');
+                break;
             }
-            else {
-                ctx.addMessage('system', `Provider: ${ctx.actualProvider} | Available: ${getAvailableProviders().join(', ')}`);
+            if (command === '/auto') {
+                ctx.addMessage('system', `Auto mode ${ctx.confirmMode ? 'OFF' : 'ON'}. Use /auto on or /auto off.`);
+                break;
             }
+            const { runPermissions } = await import('../approvals/index.js');
+            await runPermissions(parts.slice(1), { cwd: getActiveProjectDir(ctx), sessionId: ctx.sessionRef.current?.id,
+                store: ctx.approvals, signal: ctx.signal, write: text => ctx.addMessage('system', text.trimEnd()) });
             break;
+        }
+        case '/doctor': {
+            const { diagnoseProviders, formatDoctor } = await import('../doctor.js');
+            const { report, exitCode } = await diagnoseProviders(parts.slice(1), {
+                signal: ctx.signal,
+                onProgress: provider => ctx.addMessage('system', `Checking ${provider} model discovery...`),
+            });
+            ctx.addMessage(exitCode ? 'error' : 'system', parts.includes('--json') ? JSON.stringify(report) : formatDoctor(report));
+            break;
+        }
+        case '/provider':
         case '/model':
-            if (parts[1] && parts[1] !== 'list') {
-                const newModel = parts[1];
-                const oldModel = ctx.model || ctx.actualModel;
-                // Check context compatibility before switching (#26)
-                const oldLimit = getModelContextLimit(ctx.actualProvider, oldModel);
-                const newLimit = getModelContextLimit(ctx.actualProvider, newModel);
-                const currentTokens = ctx.estimateContextTokens();
-                const newPct = Math.round((currentTokens / newLimit) * 100);
-                ctx.setModel(newModel);
-                config.set('defaultModel', newModel);
-                ctx.setContextTokens(currentTokens);
-                let switchWarning = '';
-                if (newPct > 80) {
-                    switchWarning = `\n⚠️  Context at ${newPct}% of new model limit (${Math.round(currentTokens / 1000)}K/${Math.round(newLimit / 1000)}K). Consider /compact.`;
-                }
-                else if (newLimit < oldLimit) {
-                    switchWarning = `\n📉 Context window: ${Math.round(oldLimit / 1000)}K → ${Math.round(newLimit / 1000)}K (${newPct}% used)`;
-                }
-                ctx.addMessage('system', `Model: ${oldModel} → ${newModel} (saved as default)${switchWarning}`);
-            }
-            else {
-                // No arg or `list`: open the model picker (absorbs the old /models listing)
-                ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
-                try {
-                    const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
-                    if (models.length > 0) {
-                        ctx.setAvailableModels(models);
-                        ctx.setModalMode('model');
-                    }
-                    else {
-                        ctx.addMessage('error', `No models found for ${ctx.actualProvider} — API key may be invalid`);
-                    }
-                }
-                catch (e) {
-                    ctx.addMessage('error', `Failed to fetch models for ${ctx.actualProvider}: ${e instanceof Error ? e.message : String(e)}. Check your API key.`);
-                }
-            }
+        case '/defaults': {
+            const { handleModelCommand } = await import('./model-commands.js');
+            await handleModelCommand(cmd, ctx);
+            break;
+        }
+        case '/once': {
+            if (ctx.submitOnce)
+                await ctx.submitOnce(cmd);
+            else
+                ctx.addMessage('error', 'Usage: /once [--provider <name>] [--model <id>] -- <prompt>');
             break;
+        }
         case '/mode':
-            if (parts[1] && ['plan', 'hybrid', 'work'].includes(parts[1])) {
+            if (parts[1] === 'auto') {
+                ctx.setMode('work');
+                ctx.setConfirmMode(false);
+                ctx.addMessage('system', 'Mode: ⚡ Auto — work mode with tool confirmation prompts disabled for this REPL session. Project policy, scope, sandbox and orchestration authority still apply.');
+            }
+            else if (parts[1] && ['plan', 'hybrid', 'work'].includes(parts[1])) {
                 const m = parts[1];
                 ctx.setMode(m);
+                ctx.setConfirmMode(true);
                 ctx.addMessage('system', `Mode: ${MODE_CONFIG[m].icon} ${MODE_CONFIG[m].label} - ${MODE_CONFIG[m].description}`);
             }
             else {
                 const currentConfig = MODE_CONFIG[ctx.mode];
-                ctx.addMessage('system', `Mode: ${currentConfig.icon} ${currentConfig.label}\nOptions: plan (\u{1F4CB}), hybrid (\u{1F504}), work (\u{1F527})\nUse Shift+Tab to cycle`);
+                ctx.addMessage('system', `Mode: ${ctx.confirmMode ? `${currentConfig.icon} ${currentConfig.label}` : '⚡ Auto'}\nOptions: plan (\u{1F4CB}), hybrid (\u{1F504}), work (\u{1F527}), auto (⚡)\nUse Shift+Tab to cycle safe modes`);
             }
             break;
         case '/clear':
@@ -228,37 +325,6 @@ File references: @filename, ./path, /absolute/path`;
             ctx.setStats({ inputTokens: 0, outputTokens: 0, cost: 0, messageCount: 0 });
             resetContextWarnings(); // Reset context warning state
             break;
-        case '/export': {
-            // Export conversation to markdown
-            const filename = parts[1] || `calliope-export-${Date.now()}.md`;
-            const fsModule = await import('fs');
-            const path = await import('path');
-            let markdown = `# Calliope Conversation Export\n\n`;
-            markdown += `**Date:** ${new Date().toLocaleString()}\n`;
-            markdown += `**Provider:** ${ctx.actualProvider}\n`;
-            markdown += `**Model:** ${ctx.actualModel}\n\n---\n\n`;
-            for (const msg of ctx.messages) {
-                if (msg.type === 'user') {
-                    markdown += `## \u{1F464} User\n\n${msg.content}\n\n`;
-                }
-                else if (msg.type === 'assistant') {
-                    markdown += `## \u{1F916} Assistant\n\n${msg.content}\n\n`;
-                }
-                else if (msg.type === 'tool') {
-                    markdown += `> \u{1F527} Tool: ${msg.content}\n\n`;
-                }
-                else if (msg.type === 'system') {
-                    markdown += `> \u{2139}\u{FE0F} ${msg.content}\n\n`;
-                }
-                else if (msg.type === 'error') {
-                    markdown += `> \u{26A0}\u{FE0F} Error: ${msg.content}\n\n`;
-                }
-            }
-            const filepath = path.resolve(process.cwd(), filename);
-            fsModule.writeFileSync(filepath, markdown);
-            ctx.addMessage('system', `✓ Exported to ${filename}`);
-            break;
-        }
         case '/undo': {
             if (ctx.undoStack.current.length === 0) {
                 ctx.addMessage('system', 'Nothing to undo.');
@@ -280,7 +346,7 @@ File references: @filename, ./path, /absolute/path`;
         }
         case '/status': {
             const imgInfo = getTerminalImageInfo();
-            let statusMsg = `${ctx.actualProvider}:${ctx.actualModel} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`;
+            let statusMsg = `${ctx.actualProvider}:${ctx.actualModel} | mode: ${ctx.confirmMode ? ctx.mode : 'auto'} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`;
             // Add fleet status if active
             const fleetSt = fleetStatus();
             if (fleetSt) {
@@ -509,6 +575,7 @@ Available keys:
             if (parts[1] === 'stop') {
                 if (ctx.loopActive) {
                     ctx.loopCancelledRef.current = true;
+                    ctx.cancelActiveTurn?.();
                     ctx.setLoopActive(false);
                     ctx.addMessage('system', '\u{1F6D1} Loop cancelled');
                 }
@@ -522,6 +589,10 @@ Available keys:
                 ctx.addMessage('system', 'Loop already running. Use /loop stop to stop it first.');
                 break;
             }
+            if (ctx.isProcessing) {
+                ctx.addMessage('system', 'A turn is already running. Cancel it before starting a loop.');
+                break;
+            }
             const loopArgs = parts.slice(1).join(' ');
             const maxIterMatch = loopArgs.match(/--max-iterations\s+(\d+)/);
             const completionMatch = loopArgs.match(/--completion-promise\s+"([^"]+)"/);
@@ -717,8 +788,24 @@ Stop a running loop with /loop stop`);
         case '/memory': {
             const memoryModule = await import('../memory.js');
             const subCmd = parts[1];
-            const cwd = process.cwd();
-            if (subCmd === 'init') {
+            const cwd = getActiveProjectDir(ctx);
+            if (subCmd === 'sources' || subCmd === 'reload') {
+                try {
+                    if (subCmd === 'reload')
+                        refreshProjectContext(ctx);
+                    const { loadRepositoryInstructions } = await import('../instructions.js');
+                    const sources = loadRepositoryInstructions(cwd);
+                    ctx.addMessage('system', [
+                        subCmd === 'reload' ? 'Project context reloaded for subsequent turns.' : 'Applicable AGENTS.md files on disk (use /memory reload after edits):',
+                        ...sources.map(source => `${source.path}\n  Scope: ${source.scope} (${Buffer.byteLength(source.content)} bytes)`),
+                        ...(sources.length ? [] : ['No trusted AGENTS.md files apply. Use /trust status to inspect project trust.']),
+                    ].join('\n'));
+                }
+                catch (error) {
+                    ctx.addMessage('error', error instanceof Error ? error.message : String(error));
+                }
+            }
+            else if (subCmd === 'init') {
                 const memPath = memoryModule.initProjectMemory(cwd);
                 ctx.addMessage('system', `Created: ${memPath}\nEdit the file to add context and preferences.`);
             }
@@ -779,7 +866,7 @@ Stop a running loop with /loop stop`);
                 ctx.addMessage('system', info || 'No global memories yet.');
             }
             else {
-                ctx.addMessage('system', 'Usage: /memory [init|show|add <type> <text>|remove <type> <text>|global]');
+                ctx.addMessage('system', 'Usage: /memory [init|show|sources|reload|add <type> <text>|remove <type> <text>|global]');
             }
             break;
         }
@@ -833,17 +920,17 @@ Stop a running loop with /loop stop`);
             const { checkTrust, trustProject, untrustProject, listTrustedProjects, removeFromRegistry } = await import('../trust.js');
             const trustSubCmd = parts[1] || 'status';
             if (trustSubCmd === 'status') {
-                const trust = checkTrust(process.cwd());
+                const trust = checkTrust(getActiveProjectDir(ctx));
                 ctx.addMessage('system', `Trust: ${trust.trusted ? '✓ Trusted' : '✗ Untrusted'}\n${trust.reason}${trust.changed ? '\n⚠️ CALLIOPE.md has changed since trust was granted' : ''}`);
             }
             else if (trustSubCmd === 'add' || trustSubCmd === 'yes') {
-                const dir = parts[2] || process.cwd();
+                const dir = parts[2] || getActiveProjectDir(ctx);
                 trustProject(dir, parts.slice(3).join(' ') || undefined);
                 ctx.addMessage('system', `✓ Trusted: ${dir}`);
             }
             else if (trustSubCmd === 'remove' || trustSubCmd === 'no') {
                 // Absorbs the old /untrust
-                const dir = parts[2] || process.cwd();
+                const dir = parts[2] || getActiveProjectDir(ctx);
                 untrustProject(dir);
                 ctx.addMessage('system', `✗ Untrusted: ${dir}`);
             }
@@ -858,13 +945,21 @@ Stop a running loop with /loop stop`);
                 }
             }
             else if (trustSubCmd === 'clear') {
-                const dir = parts[2] || process.cwd();
+                const dir = parts[2] || getActiveProjectDir(ctx);
                 removeFromRegistry(dir);
                 ctx.addMessage('system', `Removed from trust registry: ${dir}`);
             }
             else {
                 ctx.addMessage('system', 'Usage: /trust [status|add|remove|list|clear]\n  /trust add [path]    - trust a project\n  /trust remove [path] - untrust a project');
             }
+            if (['add', 'yes', 'remove', 'no', 'clear'].includes(trustSubCmd)) {
+                try {
+                    refreshProjectContext(ctx);
+                }
+                catch (error) {
+                    ctx.addMessage('error', error instanceof Error ? error.message : String(error));
+                }
+            }
             break;
         }
         case '/cost': {
@@ -941,59 +1036,17 @@ Stop a running loop with /loop stop`);
             }
             break;
         }
+        case '/export':
+        case '/import':
+        case '/branch':
+        case '/checkout':
+        case '/diff':
+        case '/replay':
+        case '/new':
+        case '/sessions':
         case '/resume': {
-            // Resume a session by loading saved LLM message history
-            // Usage: /resume [sessionId] - resume a specific session, or current session if no ID
-            const targetSessionId = parts[1];
-            if (targetSessionId) {
-                const resumedSession = storage.setCurrentSessionById(targetSessionId);
-                if (!resumedSession) {
-                    ctx.addMessage('system', `Session not found: ${targetSessionId}`);
-                    break;
-                }
-                ctx.sessionRef.current = resumedSession;
-            }
-            if (ctx.ledger) {
-                ctx.ledger.loadSnapshot(storage.loadIterationLedger(targetSessionId || ctx.sessionRef.current?.id));
-                if (ctx.sessionRef.current?.id) {
-                    storage.saveIterationLedger(ctx.ledger, ctx.sessionRef.current.id);
-                }
-            }
-            // Try loading full message history first (preferred - preserves tool calls etc.)
-            const savedMessages = storage.loadMessageHistory(targetSessionId);
-            if (savedMessages && savedMessages.length > 0) {
-                // Replace current LLM messages with saved ones
-                ctx.llmMessages.current.length = 0;
-                for (const msg of savedMessages) {
-                    ctx.llmMessages.current.push(msg);
-                }
-                ctx.addMessage('system', `Restored ${savedMessages.length} messages from saved session${targetSessionId ? ` (${targetSessionId})` : ''}`);
-                ctx.setContextTokens(ctx.estimateContextTokens());
-            }
-            else {
-                // Fall back to chat.log history (legacy format, user/assistant only)
-                const history = storage.getChatHistory(20, targetSessionId);
-                if (history.length === 0) {
-                    ctx.addMessage('system', 'No previous messages to resume. Start a conversation first, messages are auto-saved.');
-                }
-                else {
-                    ctx.llmMessages.current.length = 0;
-                    ctx.llmMessages.current.push({
-                        role: 'system',
-                        content: buildFullSystemPrompt(getActiveProjectDir(ctx), ctx.actualProvider),
-                    });
-                    for (const msg of history) {
-                        if (msg.role === 'user' || msg.role === 'assistant') {
-                            ctx.llmMessages.current.push({
-                                role: msg.role,
-                                content: msg.content,
-                            });
-                        }
-                    }
-                    ctx.addMessage('system', `Loaded ${history.length} messages from chat log (legacy format, tool context not preserved)`);
-                    ctx.setContextTokens(ctx.estimateContextTokens());
-                }
-            }
+            const { handleSessionCommand } = await import('./session-commands.js');
+            await handleSessionCommand(parts, ctx);
             break;
         }
         case '/restore': {