helixmind 0.6.1 → 0.6.3

package/dist/cli/commands/chat.js

@@ -21,6 +21,7 @@ import { showHelixMenu } from './helix-menu.js';
 import { initializeTools } from '../agent/tools/registry.js';
 import { runAgentLoop, AgentController, AgentAbortError } from '../agent/loop.js';
 import { PermissionManager } from '../agent/permissions.js';
+import { parseTurnDirectives } from '../agent/turn-directives.js';
 import { UndoStack } from '../agent/undo.js';
 import { renderStatusBar, getGitInfo } from '../ui/statusbar.js';
 import { CheckpointStore } from '../checkpoints/store.js';
@@ -48,11 +49,13 @@ import { WorldModelManager } from '../jarvis/world-model.js';
 import { AutonomyManager } from '../jarvis/autonomy.js';
 import { NotificationManager } from '../jarvis/notifications.js';
 import { SkillManager } from '../jarvis/skills.js';
+import { SkillScorer } from '../jarvis/skill-scoring.js';
 import { JarvisTelegramBot, parseTelegramCommand } from '../jarvis/telegram-bot.js';
 import { LearningJournal } from '../jarvis/learning.js';
 import { SentimentAnalyzer } from '../jarvis/sentiment.js';
 import { acquireJarvisSlot, releaseJarvisSlot } from '../jarvis/instance-lock.js';
 import { buildRuntimeContext } from '../jarvis/runtime-context.js';
+import { buildSkillBuildSpecFromProposal, buildSkillBuildTask, detectSkillBuildFromFailure } from '../jarvis/skill-builder.js';
 import { BrainInstanceManager } from '../brain/instance-manager.js';
 import { BrowserController } from '../browser/controller.js';
 import { VisionProcessor } from '../browser/vision.js';
@@ -60,6 +63,7 @@ import { classifyTask } from '../validation/classifier.js';
 import { generateCriteria } from '../validation/criteria.js';
 import { validationLoop } from '../validation/autofix.js';
 import { createValidationProvider } from '../validation/model.js';
+import { resolveValidationDecision } from '../validation/policy.js';
 import { renderValidationSummary, renderValidationStart, renderClassification } from '../validation/reporter.js';
 import { storeValidationResult, getValidationStats, renderValidationStats } from '../validation/stats.js';
 import { isFeatureAvailable, getJarvisLimitsForPlan, getBrainLimitsForPlan, isLoggedIn } from '../auth/feature-gate.js';
@@ -80,6 +84,8 @@ const HELP_CATEGORIES = [
             { cmd: '/clear', label: '/clear', description: 'Clear conversation history' },
             { cmd: '/model', label: '/model', description: 'Switch LLM model' },
             { cmd: '/keys', label: '/keys', description: 'Manage API keys' },
+            { cmd: '/fast [prompt]', label: '/fast', description: 'Low-latency turn (skip validation, no auto-swarm)' },
+            { cmd: '/swarm [prompt]', label: '/swarm', description: 'Force swarm decomposition for one turn' },
             { cmd: '/yolo', label: '/yolo', description: 'Toggle YOLO mode' },
             { cmd: '/skip-permissions', label: '/skip-permissions', description: 'Toggle skip-permissions' },
             { cmd: '/plan', label: '/plan', description: 'Toggle plan mode (read-only → plan → execute)' },
@@ -225,10 +231,12 @@ const HELP_TEXT = `
 ${chalk.hex('#00d4ff').bold('  Chat & Interaction')}
   ${theme.primary('/help'.padEnd(22))} ${theme.dim('Show this help')}
   ${theme.primary('/clear'.padEnd(22))} ${theme.dim('Clear conversation history')}
-  ${theme.primary('/model [name]'.padEnd(22))} ${theme.dim('Switch model (interactive or direct: /model gpt-4o)')}
-  ${theme.primary('/keys'.padEnd(22))} ${theme.dim('Add/remove/update API keys')}
-  ${theme.primary('/yolo [on|off]'.padEnd(22))} ${theme.dim('Toggle YOLO mode — auto-approve ALL operations')}
-  ${theme.primary('/skip-permissions'.padEnd(22))} ${theme.dim('Toggle skip-permissions (auto-approve safe ops)')}
+  ${theme.primary('/model [name]'.padEnd(22))} ${theme.dim('Switch model (interactive or direct: /model gpt-4o)')}
+  ${theme.primary('/keys'.padEnd(22))} ${theme.dim('Add/remove/update API keys')}
+  ${theme.primary('/fast [prompt]'.padEnd(22))} ${theme.dim('One fast turn: skip validation and auto-swarm')}
+  ${theme.primary('/swarm [prompt]'.padEnd(22))} ${theme.dim('Force multi-agent swarm for one request')}
+  ${theme.primary('/yolo [on|off]'.padEnd(22))} ${theme.dim('Toggle YOLO mode — auto-approve ALL operations')}
+  ${theme.primary('/skip-permissions'.padEnd(22))} ${theme.dim('Toggle skip-permissions (auto-approve safe ops)')}
 
 ${chalk.hex('#00ff88').bold('  Spiral Memory')}
   ${theme.primary('/spiral'.padEnd(22))} ${theme.dim('Show spiral status (nodes per level)')}
@@ -407,15 +415,18 @@ export async function chatCommand(options) {
     let jarvisAutonomy;
     let jarvisNotifications;
     let jarvisSkills;
+    let jarvisSkillScorer;
     let jarvisSentiment;
     let jarvisTelegramBot = null;
     let jarvisLearning;
     let jarvisScope;
+    let jarvisRuntimeReady = false;
+    let pendingJarvisQueueBinder = null;
     let jarvisDaemonSession = null;
     let jarvisPaused = false;
     const resolveJarvisRoot = (scope) => scope === 'project' ? process.cwd() : join(homedir(), '.spiral-context');
-    // Browser controller (always instantiated — launch() is the expensive part)
-    let browserController = new BrowserController();
+    // Browser controller stays lazy so plain chat startup avoids browser setup work.
+    let browserController;
     let visionProcessor;
     // Terminal + Screen (replaces BottomChrome with framed input area)
     const terminal = new Terminal();
@@ -428,6 +439,16 @@ export async function chatCommand(options) {
     const chrome = screen;
     // Activity indicator (renders on chrome row 0 during agent work)
     const activity = new ActivityIndicator(chrome);
+    const chromeRowCache = new Map();
+    function invalidateChromeRows() {
+        chromeRowCache.clear();
+    }
+    function setChromeRow(row, content, force = false) {
+        if (!force && chromeRowCache.get(row) === content)
+            return;
+        chromeRowCache.set(row, content);
+        chrome.setRow(row, content);
+    }
     // Agent controller for pause/resume
     const agentController = new AgentController();
     let agentRunning = false;
@@ -557,28 +578,54 @@ export async function chatCommand(options) {
     }
     // Jarvis scope follows brain scope — init after brainScope detection
     jarvisScope = brainScope;
-    jarvisQueue = new JarvisQueue(resolveJarvisRoot(jarvisScope));
-    jarvisIdentity = new JarvisIdentityManager(resolveJarvisRoot(jarvisScope));
-    jarvisProposals = new ProposalJournal(resolveJarvisRoot(jarvisScope));
-    jarvisScheduler = new JarvisScheduler(resolveJarvisRoot(jarvisScope));
-    jarvisTriggers = new TriggerManager(resolveJarvisRoot(jarvisScope));
-    jarvisWorldModel = new WorldModelManager(resolveJarvisRoot(jarvisScope));
-    jarvisAutonomy = new AutonomyManager(jarvisIdentity.getIdentity().autonomyLevel);
-    jarvisNotifications = new NotificationManager(resolveJarvisRoot(jarvisScope));
-    jarvisSkills = new SkillManager(resolveJarvisRoot(jarvisScope));
-    jarvisSkills.syncRegistry();
-    jarvisLearning = new LearningJournal(resolveJarvisRoot(jarvisScope));
-    jarvisSentiment = new SentimentAnalyzer(resolveJarvisRoot(jarvisScope), {
-        onShift: (from, to, frustrationLevel) => {
-            jarvisIdentity.recordEvent({ type: 'sentiment_shift', from, to, frustrationLevel });
-            import('../brain/generator.js').then(mod => {
-                if (mod.isBrainServerRunning?.()) {
-                    mod.pushNeuronFired?.('yellow', '#ff6b6b', 'sentiment');
-                }
-            }).catch(() => { });
-        },
-    });
+    function initializeJarvisRuntime(scope = jarvisScope) {
+        const root = resolveJarvisRoot(scope);
+        jarvisScope = scope;
+        jarvisQueue = new JarvisQueue(root);
+        jarvisIdentity = new JarvisIdentityManager(root);
+        jarvisProposals = new ProposalJournal(root);
+        jarvisScheduler = new JarvisScheduler(root);
+        jarvisTriggers = new TriggerManager(root);
+        jarvisWorldModel = new WorldModelManager(root);
+        jarvisAutonomy = new AutonomyManager(jarvisIdentity.getIdentity().autonomyLevel);
+        jarvisNotifications = new NotificationManager(root);
+        jarvisSkills = new SkillManager(root);
+        jarvisSkillScorer = new SkillScorer(root);
+        jarvisSkills.syncRegistry();
+        jarvisLearning = new LearningJournal(root);
+        jarvisSentiment = new SentimentAnalyzer(root, {
+            onShift: (from, to, frustrationLevel) => {
+                jarvisIdentity.recordEvent({ type: 'sentiment_shift', from, to, frustrationLevel });
+                import('../brain/generator.js').then(mod => {
+                    if (mod.isBrainServerRunning?.()) {
+                        mod.pushNeuronFired?.('yellow', '#ff6b6b', 'sentiment');
+                    }
+                }).catch(() => { });
+            },
+        });
+        jarvisRuntimeReady = true;
+        pendingJarvisQueueBinder?.();
+    }
+    function ensureJarvisRuntime(scope = jarvisScope) {
+        if (jarvisRuntimeReady && jarvisScope === scope)
+            return;
+        initializeJarvisRuntime(scope);
+    }
+    function warmJarvisRuntime(scope = jarvisScope) {
+        if (jarvisRuntimeReady && jarvisScope === scope)
+            return;
+        setTimeout(() => {
+            try {
+                ensureJarvisRuntime(scope);
+            }
+            catch {
+                // Best effort: Jarvis can still initialize on first real use.
+            }
+        }, 0);
+    }
     let spiralEngine = null;
+    let spiralInitPromise = null;
+    let spiralInitScope = null;
     async function initSpiralEngine(scope) {
         try {
             const { SpiralEngine } = await import('../../spiral/engine.js');
@@ -593,8 +640,58 @@ export async function chatCommand(options) {
             return null;
         }
     }
-    if (config.spiral.enabled) {
-        spiralEngine = await initSpiralEngine(brainScope);
+    async function ensureSpiralEngine(scope = brainScope) {
+        if (!config.spiral.enabled)
+            return null;
+        if (spiralEngine && spiralInitScope === scope)
+            return spiralEngine;
+        if (spiralInitPromise && spiralInitScope === scope)
+            return spiralInitPromise;
+        spiralInitScope = scope;
+        spiralInitPromise = initSpiralEngine(scope).then(async (engine) => {
+            spiralEngine = engine;
+            spiralInitPromise = null;
+            if (engine && brainUrl) {
+                try {
+                    const { startLiveBrain } = await import('../brain/generator.js');
+                    await startLiveBrain(engine, project.name || 'HelixMind', scope);
+                }
+                catch {
+                    // Dashboard sync is best effort.
+                }
+            }
+            return engine;
+        }).catch((err) => {
+            spiralInitPromise = null;
+            spiralInitScope = null;
+            throw err;
+        });
+        return spiralInitPromise;
+    }
+    async function getSpiralEngine(scope = brainScope) {
+        if (!config.spiral.enabled)
+            return null;
+        if (spiralEngine && spiralInitScope === scope)
+            return spiralEngine;
+        const engine = await ensureSpiralEngine(scope);
+        spiralEngine = engine;
+        return engine;
+    }
+    function warmSpiralEngine(scope = brainScope) {
+        if (!config.spiral.enabled)
+            return;
+        void ensureSpiralEngine(scope).catch(() => { });
+    }
+    function resetSpiralEngine(scope) {
+        if (spiralEngine) {
+            try {
+                spiralEngine.close();
+            }
+            catch { /* best effort */ }
+        }
+        spiralEngine = null;
+        spiralInitPromise = null;
+        spiralInitScope = scope ?? null;
     }
     // Register current brain in manager (so limits track it)
     if (brainManager) {
@@ -617,6 +714,7 @@ export async function chatCommand(options) {
     }
     // Build SkillContext for skill activation
     function buildSkillContext() {
+        ensureJarvisRuntime();
         return {
             registerTool: (name, def, handler) => {
                 // Skills register tools into the skill manager's registry
@@ -626,10 +724,11 @@ export async function chatCommand(options) {
             unregisterTool: (_name) => { },
             addTask: (title, desc, priority) => jarvisQueue.addTask(title, desc, { priority }),
             querySpiral: async (query) => {
-                if (!spiralEngine)
+                const engine = spiralEngine ?? await ensureSpiralEngine(brainScope);
+                if (!engine)
                     return '';
                 try {
-                    const results = await spiralEngine.query(query, { maxResults: 10 });
+                    const results = await engine.query(query, { maxResults: 10 });
                     return results.level_1.concat(results.level_2, results.level_3)
                         .map((n) => `[${n.type}] ${n.content}`)
                         .join('\n')
@@ -640,10 +739,11 @@ export async function chatCommand(options) {
                 }
             },
             storeInSpiral: async (content, type, tags) => {
-                if (!spiralEngine)
+                const engine = spiralEngine ?? await ensureSpiralEngine(brainScope);
+                if (!engine)
                     return;
                 try {
-                    await spiralEngine.add(content, { type, tags });
+                    await engine.add(content, { type, tags });
                 }
                 catch { }
             },
@@ -655,8 +755,64 @@ export async function chatCommand(options) {
             log: (msg) => { renderInfo(chalk.dim(`[skill] ${msg}`)); },
         };
     }
+    function findOpenSkillBuildTask(skillName) {
+        ensureJarvisRuntime();
+        return jarvisQueue.getAllTasks().find((task) => task.status !== 'completed' &&
+            task.status !== 'failed' &&
+            task.tags?.includes('skill_build') &&
+            task.tags?.includes(`skill:${skillName}`));
+    }
+    function enqueueProposalTask(proposal) {
+        ensureJarvisRuntime();
+        if (proposal.category === 'skill_creation' || proposal.category === 'skill_update') {
+            const spec = buildSkillBuildSpecFromProposal(proposal);
+            const existing = findOpenSkillBuildTask(spec.skillName);
+            if (existing)
+                return existing;
+            const buildTask = buildSkillBuildTask(spec);
+            return jarvisQueue.addTask(buildTask.title, buildTask.description, {
+                priority: buildTask.priority,
+                tags: buildTask.tags,
+            });
+        }
+        return jarvisQueue.addTask(proposal.title, proposal.description, {
+            priority: proposal.impact === 'high' ? 'high' : 'medium',
+        });
+    }
+    function queueSkillBuildFromFailure(task, failure) {
+        ensureJarvisRuntime();
+        const spec = detectSkillBuildFromFailure({
+            taskTitle: task.title,
+            taskDescription: task.description,
+            failure,
+            existingScores: jarvisSkillScorer.scoreSkills(task.description || task.title, 'skill_gap', jarvisSkills.listSkills()),
+            existingSkillNames: jarvisSkills.listSkills().map((skill) => skill.manifest.name),
+        });
+        if (!spec)
+            return null;
+        const existing = findOpenSkillBuildTask(spec.skillName);
+        if (existing)
+            return existing;
+        const buildTask = buildSkillBuildTask(spec);
+        return jarvisQueue.addTask(buildTask.title, buildTask.description, {
+            priority: buildTask.priority,
+            tags: buildTask.tags.concat('self_improvement'),
+        });
+    }
+    async function activateBuiltSkill(task, skillName) {
+        ensureJarvisRuntime();
+        jarvisSkills.syncRegistry();
+        const result = await jarvisSkills.activateSkill(skillName, buildSkillContext());
+        if (result.success) {
+            renderInfo(chalk.green(`Activated skill "${skillName}" after task #${task.id}.`));
+        }
+        else {
+            renderInfo(chalk.yellow(`Built skill "${skillName}" but activation failed: ${result.error || 'unknown error'}`));
+        }
+    }
     // Start Telegram bot if configured (called when daemon starts)
     function startTelegramBot() {
+        ensureJarvisRuntime();
         if (jarvisTelegramBot?.isRunning)
             return;
         const teleConfig = jarvisNotifications.getConfig().targets.find(t => t.channel === 'telegram');
@@ -699,9 +855,7 @@ export async function chatCommand(options) {
                     const proposal = jarvisProposals.approve(id);
                     if (proposal) {
                         jarvisIdentity.recordEvent({ type: 'proposal_approved', proposalId: id });
-                        const task = jarvisQueue.addTask(proposal.title, proposal.description, {
-                            priority: proposal.impact === 'high' ? 'high' : 'medium',
-                        });
+                        const task = enqueueProposalTask(proposal);
                         proposal.convertedTaskId = task.id;
                         reply(`\u{1F7E2} Proposal #${id} approved \u2192 Task #${task.id} queued`);
                     }
@@ -760,7 +914,7 @@ export async function chatCommand(options) {
                 const proposal = jarvisProposals.approve(id);
                 if (proposal) {
                     jarvisIdentity.recordEvent({ type: 'proposal_approved', proposalId: id });
-                    const task = jarvisQueue.addTask(proposal.title, proposal.description, { priority: 'medium' });
+                    const task = enqueueProposalTask(proposal);
                     proposal.convertedTaskId = task.id;
                     jarvisTelegramBot?.send(`\u2705 Approved #${id} \u2192 Task #${task.id}`, { chatId });
                 }
@@ -777,6 +931,7 @@ export async function chatCommand(options) {
     }
     // Build ThinkingCallbacks for Jarvis AGI thinking loop
     function buildThinkingCallbacks(bgSession) {
+        ensureJarvisRuntime();
         return {
             sendMessage: async (prompt) => {
                 bgSession.controller.reset();
@@ -789,10 +944,11 @@ export async function chatCommand(options) {
             isAborted: () => bgSession.controller.isAborted,
             isPaused: () => jarvisPaused,
             querySpiral: async (query, maxTokens) => {
-                if (!spiralEngine)
+                const engine = spiralEngine ?? await ensureSpiralEngine(brainScope);
+                if (!engine)
                     return '';
                 try {
-                    const results = await spiralEngine.query(query, { maxResults: maxTokens ?? 50 });
+                    const results = await engine.query(query, { maxResults: maxTokens ?? 50 });
                     return results.level_1.concat(results.level_2, results.level_3)
                         .map((n) => `[${n.type}] ${n.content}`)
                         .join('\n')
@@ -803,15 +959,29 @@ export async function chatCommand(options) {
                 }
             },
             storeInSpiral: async (content, type, tags) => {
-                if (!spiralEngine)
+                const engine = spiralEngine ?? await ensureSpiralEngine(brainScope);
+                if (!engine)
                     return;
                 try {
-                    await spiralEngine.add(content, { type: type, tags });
+                    await engine.add(content, { type: type, tags });
                 }
                 catch { }
             },
             createProposal: (title, desc, rationale, opts) => {
-                return jarvisProposals.create(title, desc, rationale, opts);
+                const proposal = jarvisProposals.create(title, desc, rationale, opts);
+                if (proposal.category === 'skill_creation' &&
+                    proposal.source.startsWith('thinking') &&
+                    jarvisAutonomy.getLevel() >= 4) {
+                    const approved = jarvisProposals.approve(proposal.id);
+                    if (approved) {
+                        jarvisIdentity.recordEvent({ type: 'proposal_approved', proposalId: approved.id });
+                        const task = enqueueProposalTask(approved);
+                        approved.convertedTaskId = task.id;
+                        renderInfo(chalk.dim(`Auto-approved skill proposal #${approved.id} -> Task #${task.id}`));
+                        return approved;
+                    }
+                }
+                return proposal;
             },
             wouldLikelyBeDenied: (cat, files) => {
                 return jarvisProposals.wouldLikelyBeDenied(cat, files);
@@ -852,6 +1022,10 @@ export async function chatCommand(options) {
                     topCategories,
                 };
             },
+            getSkillScores: (taskDesc) => {
+                return jarvisSkillScorer.scoreSkills(taskDesc, 'skill_gap', jarvisSkills.listSkills())
+                    .map((score) => ({ skillName: score.skillName, totalScore: score.totalScore }));
+            },
         };
     }
     // Create session start checkpoint
@@ -1210,7 +1384,8 @@ export async function chatCommand(options) {
                                     bgSession.controller.reset();
                                     const rth = { text: '' };
                                     bgSession.buffer.onSummary = (t) => { rth.text = t; };
-                                    await sendAgentMessage(prompt, bgSession.history, provider, project, spiralEngine, config, permissions, bgSession.undoStack, checkpointStore, bgSession.controller, new ActivityIndicator(), bgSession.buffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; }, undefined, { enabled: false, verbose: false, strict: false });
+                                    const activeSpiral = await getSpiralEngine(brainScope);
+                                    await sendAgentMessage(prompt, bgSession.history, provider, project, activeSpiral, config, permissions, bgSession.undoStack, checkpointStore, bgSession.controller, new ActivityIndicator(), bgSession.buffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; }, undefined, { enabled: false, verbose: false, strict: false }, undefined, undefined, undefined, undefined, null, undefined, jarvisLearning, undefined, jarvisSkills);
                                     bgSession.buffer.onSummary = undefined;
                                     return rth.text;
                                 },
@@ -1306,6 +1481,7 @@ export async function chatCommand(options) {
                     return bugJournal.delete(id);
                 },
                 startJarvis: () => {
+                    ensureJarvisRuntime();
                     if (jarvisDaemonSession && jarvisDaemonSession.status === 'running')
                         return jarvisDaemonSession.id;
                     // Enforce cross-process Jarvis instance limit
@@ -1362,9 +1538,12 @@ export async function chatCommand(options) {
                                     pushSessionUpdate(serializeSession(bgSession));
                                 },
                                 updateStatus: () => updateStatusBar(),
-                                storeInSpiral: spiralEngine ? async (content, type, tags) => {
+                                storeInSpiral: config.spiral.enabled ? async (content, type, tags) => {
+                                    const activeSpiral = await getSpiralEngine(brainScope);
+                                    if (!activeSpiral)
+                                        return;
                                     try {
-                                        await spiralEngine.add(content, { type: type, tags });
+                                        await activeSpiral.add(content, { type: type, tags });
                                     }
                                     catch { }
                                 } : undefined,
@@ -1375,6 +1554,8 @@ export async function chatCommand(options) {
                                     jarvisLearning.recordLearning(error, solution, category, context, ['jarvis_daemon']);
                                 },
                                 thinkingCallbacks: buildThinkingCallbacks(bgSession),
+                                queueSkillBuildTask: queueSkillBuildFromFailure,
+                                onSkillBuildComplete: activateBuiltSkill,
                             });
                         }
                         catch (err) {
@@ -1398,6 +1579,7 @@ export async function chatCommand(options) {
                     return true;
                 },
                 pauseJarvis: () => {
+                    ensureJarvisRuntime();
                     if (!jarvisDaemonSession || jarvisPaused)
                         return false;
                     jarvisPaused = true;
@@ -1405,6 +1587,7 @@ export async function chatCommand(options) {
                     return true;
                 },
                 resumeJarvis: () => {
+                    ensureJarvisRuntime();
                     if (!jarvisDaemonSession || !jarvisPaused)
                         return false;
                     jarvisPaused = false;
@@ -1412,24 +1595,36 @@ export async function chatCommand(options) {
                     return true;
                 },
                 addJarvisTask: (title, description, opts) => {
+                    ensureJarvisRuntime();
                     const task = jarvisQueue.addTask(title, description, opts);
                     return serializeJarvisTask(task);
                 },
-                listJarvisTasks: () => jarvisQueue.getAllTasks().map(serializeJarvisTask),
+                listJarvisTasks: () => {
+                    ensureJarvisRuntime();
+                    return jarvisQueue.getAllTasks().map(serializeJarvisTask);
+                },
                 deleteJarvisTask: (taskId) => {
+                    ensureJarvisRuntime();
                     return jarvisQueue.removeTask(taskId);
                 },
-                getJarvisStatus: () => ({
-                    ...jarvisQueue.getStatus(),
-                    scope: jarvisScope === 'project' ? 'local' : 'global',
-                    jarvisName: jarvisIdentity.getIdentity().name,
-                }),
-                clearJarvisCompleted: () => jarvisQueue.clearCompleted(),
+                getJarvisStatus: () => {
+                    ensureJarvisRuntime();
+                    return {
+                        ...jarvisQueue.getStatus(),
+                        scope: jarvisScope === 'project' ? 'local' : 'global',
+                        jarvisName: jarvisIdentity.getIdentity().name,
+                    };
+                },
+                clearJarvisCompleted: () => {
+                    ensureJarvisRuntime();
+                    return jarvisQueue.clearCompleted();
+                },
                 // Jarvis AGI handlers (stubs — wired when AGI modules are initialized)
                 listProposals: () => [],
                 approveProposal: () => false,
                 denyProposal: () => false,
                 setAutonomyLevel: (level) => {
+                    ensureJarvisRuntime();
                     if (level < 0 || level > 5)
                         return false;
                     jarvisAutonomy.setLevel(level);
@@ -1776,19 +1971,24 @@ export async function chatCommand(options) {
                     pushBugUpdated(bugInfo);
                 }
             });
-            // Wire Jarvis queue change events to brain server
-            jarvisQueue.setOnChange((event, task) => {
-                const info = serializeJarvisTask(task);
-                if (event === 'task_created') {
-                    pushJarvisTaskCreated(info);
-                }
-                else if (event === 'task_removed') {
-                    pushJarvisTaskRemoved(task.id);
-                }
-                else {
-                    pushJarvisTaskUpdated(info);
-                }
-            });
+            // Wire Jarvis queue change events to brain server when Jarvis runtime exists.
+            pendingJarvisQueueBinder = () => {
+                if (!jarvisRuntimeReady)
+                    return;
+                jarvisQueue.setOnChange((event, task) => {
+                    const info = serializeJarvisTask(task);
+                    if (event === 'task_created') {
+                        pushJarvisTaskCreated(info);
+                    }
+                    else if (event === 'task_removed') {
+                        pushJarvisTaskRemoved(task.id);
+                    }
+                    else {
+                        pushJarvisTaskUpdated(info);
+                    }
+                });
+            };
+            pendingJarvisQueueBinder();
             // Wire browser screenshots to brain server
             pushScreenshotToBrainFn = (info) => {
                 pushBrowserScreenshot({
@@ -1888,6 +2088,34 @@ export async function chatCommand(options) {
         hints.push(chalk.dim('esc to interrupt'));
         return hints.join(chalk.dim(' \u00B7 '));
     }
+    function renderExecutionIntent(directives, validationDecision, swarmHeuristic, usingSwarm) {
+        const parts = [];
+        if (usingSwarm) {
+            const reason = swarmHeuristic.reasons.slice(0, 2).join(', ');
+            parts.push(chalk.hex('#ffd700')('swarm'));
+            if (reason)
+                parts.push(chalk.dim(reason));
+        }
+        else {
+            parts.push(chalk.hex('#00d4ff')('single-agent'));
+            if (directives.skipSwarm) {
+                parts.push(chalk.dim('swarm skipped'));
+            }
+            else if (swarmHeuristic.shouldOrchestrate) {
+                parts.push(chalk.dim('swarm available but not used'));
+            }
+        }
+        if (validationDecision.enabled) {
+            parts.push(chalk.green('validation on'));
+        }
+        else {
+            parts.push(chalk.yellow(`validation off (${validationDecision.reason})`));
+        }
+        if (directives.fastMode) {
+            parts.push(chalk.hex('#ff6600')('fast lane'));
+        }
+        renderInfo(chalk.dim('Intent: ') + parts.join(chalk.dim(' · ')));
+    }
     /**
      * Show the full prompt area using sticky bottom chrome (4 rows):
      *   ┌──────────────────────────────────────┐  ← chrome row 0 (N-3): top border / activity indicator
@@ -1912,9 +2140,9 @@ export async function chatCommand(options) {
         }
         // Now set chrome content and draw (screen must be active for these to render)
         screen.drawFrameBottom();
-        chrome.setRow(1, hintLine);
-        chrome.setRow(2, ' ' + statusLine1);
-        chrome.setRow(3, ' ' + statusLine2);
+        setChromeRow(1, hintLine, true);
+        setChromeRow(2, ' ' + statusLine1, true);
+        setChromeRow(3, ' ' + statusLine2, true);
         isAtPrompt = true;
         // Suppress stdout hook redraws while InputManager manages the cursor
         screen.inputActive = true;
@@ -2008,6 +2236,7 @@ export async function chatCommand(options) {
     // Update screen and activity on terminal resize
     process.stdout.on('resize', () => {
         closeSuggestionPanel(); // Close panel on resize (reopens on next keypress)
+        invalidateChromeRows();
         screen.handleResize();
         activity.handleResize();
         if (isAtPrompt) {
@@ -2039,9 +2268,11 @@ export async function chatCommand(options) {
         isAtPrompt = active;
         // Deactivate/activate bottom chrome so permission select menu renders cleanly
         if (active) {
+            invalidateChromeRows();
             chrome.deactivate();
         }
         else {
+            invalidateChromeRows();
             chrome.activate();
         }
     });
@@ -2065,7 +2296,7 @@ export async function chatCommand(options) {
         if (isAtPrompt) {
             const hintLine = buildHintLine();
             activity.setRestoreContent(hintLine);
-            chrome.setRow(1, hintLine);
+            invalidateChromeRows();
             updateStatusBar();
         }
     });
@@ -2234,12 +2465,7 @@ export async function chatCommand(options) {
             if (newScope === brainScope)
                 return;
             try {
-                if (spiralEngine) {
-                    try {
-                        spiralEngine.close();
-                    }
-                    catch { /* best effort */ }
-                }
+                resetSpiralEngine();
                 brainScope = newScope;
                 if (newScope === 'project') {
                     const { mkdirSync, existsSync } = await import('node:fs');
@@ -2258,7 +2484,7 @@ export async function chatCommand(options) {
                         }
                     }
                 }
-                spiralEngine = await initSpiralEngine(newScope);
+                spiralEngine = await ensureSpiralEngine(newScope);
                 const { exportBrainData } = await import('../brain/exporter.js');
                 const { startLiveBrain } = await import('../brain/generator.js');
                 await startLiveBrain(spiralEngine, project.name || 'HelixMind', newScope);
@@ -2583,6 +2809,7 @@ export async function chatCommand(options) {
     function getJarvisContextForPrompt() {
         if (!jarvisDaemonSession || jarvisDaemonSession.status !== 'running')
             return null;
+        ensureJarvisRuntime();
         const sentimentGuidance = jarvisSentiment.getResponseGuidance();
         const identityPrompt = jarvisIdentity.getIdentityPrompt(jarvisSkills.getSkillsPrompt() ?? undefined, sentimentGuidance || undefined);
         const runtimeContext = buildRuntimeContext({
@@ -2623,9 +2850,9 @@ export async function chatCommand(options) {
             line1 = `${tabBar}  ${statusLine1}`;
         }
         // Refresh hint line on row 1 (prevents stale border/status from previous layout)
-        chrome.setRow(1, buildHintLine());
-        chrome.setRow(2, ' ' + line1);
-        chrome.setRow(3, ' ' + (statusLine2 || ''));
+        setChromeRow(1, buildHintLine());
+        setChromeRow(2, ' ' + line1);
+        setChromeRow(3, ' ' + (statusLine2 || ''));
     }
     /** Push session findings to brain visualization */
     function pushFindingsToBrain(session) {
@@ -2688,6 +2915,9 @@ export async function chatCommand(options) {
     // Write the collected startup banner into the scroll region.
     // Content flows bottom-up within the region, sitting just above the input frame.
     screen.writeOutput(startupBannerParts.join(''));
+    // Warm optional heavy subsystems after the prompt is already visible.
+    warmJarvisRuntime(jarvisScope);
+    warmSpiralEngine(brainScope);
     // Footer timer — redraws statusbar on chrome rows 2+3 during agent work.
     // Skipped when:
     //   - user is at readline prompt (isAtPrompt) — prevents cursor-jumping
@@ -2701,6 +2931,7 @@ export async function chatCommand(options) {
     footerTimer.unref();
     /** Process a complete input (single line or assembled paste block) */
     async function processInput(input, displayText) {
+        const rawInput = input;
         // Clear input frame FIRST — before any renderInfo/process.stdout.write.
         // This ensures the cursor moves out of the input area so all output
         // (slash command results, "daemon started", etc.) goes to the scroll region.
@@ -2711,12 +2942,14 @@ export async function chatCommand(options) {
         promptHistory.add(input, process.cwd()).catch(() => { });
         // Handle /feed directly here (needs access to inlineProgressActive flag)
         if (input.startsWith('/feed')) {
-            if (spiralEngine) {
+            const activeSpiral = spiralEngine ?? await ensureSpiralEngine(brainScope);
+            if (activeSpiral) {
+                spiralEngine = activeSpiral;
                 const feedPath = input.split(/\s+/)[1];
                 const rootDir = process.cwd();
                 renderInfo('\u{1F300} Feeding project...\n');
                 try {
-                    const result = await runFeedPipeline(rootDir, spiralEngine, {
+                    const result = await runFeedPipeline(rootDir, activeSpiral, {
                         targetPath: feedPath,
                         onProgress: wrappedFeedProgress,
                     });
@@ -2778,8 +3011,27 @@ export async function chatCommand(options) {
             showPrompt();
             return;
         }
+        const turnDirectives = parseTurnDirectives(rawInput);
+        input = turnDirectives.input;
+        const renderedInput = displayText ?? turnDirectives.displayInput;
+        if (!input) {
+            if (turnDirectives.fastMode) {
+                renderInfo(chalk.dim('Usage: /fast <prompt>'));
+            }
+            else if (turnDirectives.forceSwarm) {
+                renderInfo(chalk.dim('Usage: /swarm <prompt>'));
+            }
+            else if (turnDirectives.strippedFlags.length > 0) {
+                renderInfo(chalk.dim('Execution flags were provided without a prompt.'));
+            }
+            showPrompt();
+            return;
+        }
         // Handle slash commands
-        if (input.startsWith('/')) {
+        if (input.startsWith('/') && !turnDirectives.forceSwarm) {
+            if (/^\/(?:jarvis|del)\b/i.test(input)) {
+                ensureJarvisRuntime();
+            }
             const handled = await handleSlashCommand(input, messages, agentHistory, config, spiralEngine, store, rl, permissions, undoStack, checkpointStore, sessionBuffer, { input: sessionTokensInput, output: sessionTokensOutput }, sessionToolCalls, (newProvider) => {
                 provider = newProvider;
                 config = store.getAll();
@@ -2788,12 +3040,7 @@ export async function chatCommand(options) {
                 typeAheadBuffer.length = 0;
             }, async (newScope) => {
                 // Switch brain scope
-                if (spiralEngine) {
-                    try {
-                        spiralEngine.close();
-                    }
-                    catch { /* best effort */ }
-                }
+                resetSpiralEngine();
                 brainScope = newScope;
                 // Create .helixmind/ dir if switching to project and it doesn't exist
                 if (newScope === 'project') {
@@ -2817,8 +3064,8 @@ export async function chatCommand(options) {
                         }
                     }
                 }
-                spiralEngine = await initSpiralEngine(newScope);
-            }, brainScope, async (action, goal) => {
+                spiralEngine = await ensureSpiralEngine(newScope);
+            }, brainScope, (scope) => getSpiralEngine(scope ?? brainScope), async (action, goal) => {
                 if (action === 'stop') {
                     // Stop all background sessions + autonomous mode
                     const running = sessionMgr.running;
@@ -3075,23 +3322,7 @@ export async function chatCommand(options) {
                 sentiment: jarvisSentiment,
                 getScope: () => jarvisScope,
                 setScope: (scope) => {
-                    jarvisScope = scope;
-                    const newRoot = resolveJarvisRoot(scope);
-                    jarvisQueue = new JarvisQueue(newRoot);
-                    jarvisIdentity = new JarvisIdentityManager(newRoot);
-                    jarvisProposals = new ProposalJournal(newRoot);
-                    jarvisScheduler = new JarvisScheduler(newRoot);
-                    jarvisTriggers = new TriggerManager(newRoot);
-                    jarvisWorldModel = new WorldModelManager(newRoot);
-                    jarvisNotifications = new NotificationManager(newRoot);
-                    jarvisSkills = new SkillManager(newRoot);
-                    jarvisSkills.syncRegistry();
-                    jarvisSentiment = new SentimentAnalyzer(newRoot, {
-                        onShift: (from, to, frustrationLevel) => {
-                            jarvisIdentity.recordEvent({ type: 'sentiment_shift', from, to, frustrationLevel });
-                        },
-                    });
-                    jarvisAutonomy = new AutonomyManager(jarvisIdentity.getIdentity().autonomyLevel);
+                    initializeJarvisRuntime(scope);
                 },
                 getSession: () => jarvisDaemonSession,
                 setSession: (s) => { jarvisDaemonSession = s; },
@@ -3106,6 +3337,7 @@ export async function chatCommand(options) {
                 startTelegramBot,
                 learning: jarvisLearning,
                 startDaemon: () => {
+                    ensureJarvisRuntime();
                     const jName = jarvisIdentity.getIdentity().name;
                     const bgSession = sessionMgr.create(jName, '\u{1F916}', agentHistory);
                     bgSession.start();
@@ -3149,7 +3381,8 @@ export async function chatCommand(options) {
                                     bgSession.controller.reset();
                                     const rth = { text: '' };
                                     bgSession.buffer.onSummary = (t) => { rth.text = t; };
-                                    await sendAgentMessage(prompt, bgSession.history, provider, project, spiralEngine, config, daemonPermissions, bgSession.undoStack, checkpointStore, bgSession.controller, new ActivityIndicator(), bgSession.buffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; }, undefined, { enabled: false, verbose: false, strict: false });
+                                    const activeSpiral = await getSpiralEngine(brainScope);
+                                    await sendAgentMessage(prompt, bgSession.history, provider, project, activeSpiral, config, daemonPermissions, bgSession.undoStack, checkpointStore, bgSession.controller, new ActivityIndicator(), bgSession.buffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; }, undefined, { enabled: false, verbose: false, strict: false }, undefined, undefined, undefined, undefined, null, undefined, jarvisLearning, undefined, jarvisSkills);
                                     bgSession.buffer.onSummary = undefined;
                                     return rth.text;
                                 },
@@ -3184,9 +3417,12 @@ export async function chatCommand(options) {
                                     }
                                 },
                                 updateStatus: () => updateStatusBar(),
-                                storeInSpiral: spiralEngine ? async (content, type, tags) => {
+                                storeInSpiral: config.spiral.enabled ? async (content, type, tags) => {
+                                    const activeSpiral = await getSpiralEngine(brainScope);
+                                    if (!activeSpiral)
+                                        return;
                                     try {
-                                        await spiralEngine.add(content, { type: type, tags });
+                                        await activeSpiral.add(content, { type: type, tags });
                                     }
                                     catch { }
                                 } : undefined,
@@ -3197,6 +3433,8 @@ export async function chatCommand(options) {
                                     jarvisLearning.recordLearning(error, solution, category, context, ['jarvis_daemon']);
                                 },
                                 thinkingCallbacks: buildThinkingCallbacks(bgSession),
+                                queueSkillBuildTask: queueSkillBuildFromFailure,
+                                onSkillBuildComplete: activateBuiltSkill,
                             });
                         }
                         catch (err) {
@@ -3245,10 +3483,11 @@ export async function chatCommand(options) {
         }
         // Frame was already cleared at processInput entry — render user message
         // Use display text (badge placeholders) if available, full text goes to model
-        renderUserMessage(displayText || input);
+        renderUserMessage(renderedInput);
         // Track user message in session buffer
         sessionBuffer.addUserMessage(input);
         // Sentiment detection on every user message
+        ensureJarvisRuntime();
         const sentimentReading = jarvisSentiment.detectSentiment(input);
         jarvisSentiment.recordReading(sentimentReading);
         // Auto-detect bug reports from user messages
@@ -3401,10 +3640,16 @@ export async function chatCommand(options) {
         }
         else {
             // ═══ NORMAL MODE ═══
-            // --- Swarm auto-detection: check if multi-task request ---
-            const forceSwarm = input.startsWith('/swarm ');
-            const swarmInput = forceSwarm ? input.slice(7).trim() : input;
-            if (!activeSwarm && (forceSwarm || swarmOrchestrator.shouldOrchestrate(swarmInput))) {
+            if (config.spiral.enabled && !turnDirectives.fastMode) {
+                spiralEngine = await ensureSpiralEngine(brainScope);
+            }
+            const effectiveValidation = resolveValidationDecision(input, { enabled: validationEnabled, verbose: validationVerbose, strict: validationStrict }, turnDirectives);
+            const swarmHeuristic = swarmOrchestrator.analyze(input);
+            const shouldUseSwarm = !activeSwarm &&
+                !turnDirectives.skipSwarm &&
+                (turnDirectives.forceSwarm || swarmHeuristic.shouldOrchestrate);
+            renderExecutionIntent(turnDirectives, effectiveValidation, swarmHeuristic, shouldUseSwarm);
+            if (shouldUseSwarm) {
                 const { pushSwarmCreated, pushSwarmUpdated, pushSwarmCompleted, pushWorkerStarted, pushWorkerCompleted, pushOutputLine: _pushOutputLine, pushSessionCreated: _pushSessionCreated } = await import('../brain/generator.js');
                 const { serializeSession: _serializeSession } = await import('../brain/control-protocol.js');
                 const swarm = new SwarmController(swarmOrchestrator, swarmExecutor, sessionMgr, {
@@ -3434,7 +3679,7 @@ export async function chatCommand(options) {
                         };
                         _pushSessionCreated(_serializeSession(session));
                         try {
-                            await sendAgentMessage(prompt, session.history, provider, project, spiralEngine, config, permissions, session.undoStack, checkpointStore, session.controller, bgActivity, session.buffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; roundToolCalls++; }, undefined, { enabled: validationEnabled, verbose: validationVerbose, strict: validationStrict }, bugJournal, undefined, undefined, undefined, null, undefined, undefined, runtime);
+                            await sendAgentMessage(prompt, session.history, provider, project, spiralEngine, config, permissions, session.undoStack, checkpointStore, session.controller, bgActivity, session.buffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; roundToolCalls++; }, undefined, effectiveValidation, bugJournal, undefined, undefined, undefined, null, undefined, undefined, runtime);
                         }
                         finally {
                             await runtime.release();
@@ -3459,8 +3704,10 @@ export async function chatCommand(options) {
                     pushWorkerCompleted,
                 });
                 activeSwarm = swarm;
-                renderInfo(chalk.hex('#ffd700')('\u{1F41D} Swarm detected — decomposing into parallel tasks...'));
-                const summary = await swarm.run(swarmInput);
+                const swarmReason = swarmHeuristic.reasons.slice(0, 2).join(', ');
+                renderInfo(chalk.hex('#ffd700')('\u{1F41D} Swarm engaged') +
+                    (swarmReason ? chalk.dim(` — ${swarmReason}`) : ''));
+                const summary = await swarm.run(input);
                 activeSwarm = null;
                 if (summary) {
                     // Swarm completed — render summary
@@ -3469,7 +3716,7 @@ export async function chatCommand(options) {
                 }
                 else {
                     // Swarm decided single task — fall through to normal agent
-                    await sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, agentController, activity, sessionBuffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; roundToolCalls++; }, () => { isAtPrompt = false; }, { enabled: validationEnabled, verbose: validationVerbose, strict: validationStrict }, bugJournal, browserController, visionProcessor, pushScreenshotToBrainFn, getJarvisContextForPrompt(), (label, tool) => {
+                    await sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, agentController, activity, sessionBuffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; roundToolCalls++; }, () => { isAtPrompt = false; }, effectiveValidation, bugJournal, browserController, visionProcessor, pushScreenshotToBrainFn, getJarvisContextForPrompt(), (label, tool) => {
                         currentStepLabel = label;
                         const fileTools = new Set(['read_file', 'write_file', 'edit_file']);
                         currentStepFile = fileTools.has(tool) ? label.replace(/^(reading|writing|editing)\s+/, '') : '';
@@ -3488,7 +3735,7 @@ export async function chatCommand(options) {
                     // Muting is handled by activity.setMuteCallbacks (mute during LLM stream,
                     // unmute during tool execution so user can answer permission prompts).
                     isAtPrompt = false;
-                }, { enabled: validationEnabled, verbose: validationVerbose, strict: validationStrict }, bugJournal, browserController, visionProcessor, pushScreenshotToBrainFn, getJarvisContextForPrompt(), (label, tool) => {
+                }, effectiveValidation, bugJournal, browserController, visionProcessor, pushScreenshotToBrainFn, getJarvisContextForPrompt(), (label, tool) => {
                     currentStepLabel = label;
                     const fileTools = new Set(['read_file', 'write_file', 'edit_file']);
                     currentStepFile = fileTools.has(tool) ? label.replace(/^(reading|writing|editing)\s+/, '') : '';
@@ -3503,22 +3750,7 @@ export async function chatCommand(options) {
         while (typeAheadBuffer.length > 0 && !agentController.isAborted) {
             const buffered = typeAheadBuffer.shift();
             if (buffered.trim()) {
-                // Process the buffered input as if user just typed it
-                sessionBuffer.addUserMessage(buffered.trim());
-                checkpointStore.createForChat(buffered.trim(), agentHistory.length);
-                roundToolCalls = 0;
-                currentStepLabel = '';
-                currentStepFile = '';
-                agentRunning = true;
-                agentController.reset();
-                updateStatusBar();
-                await sendAgentMessage(buffered.trim(), agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, agentController, activity, sessionBuffer, (inp, out) => { sessionTokensInput += inp; sessionTokensOutput += out; }, () => { sessionToolCalls++; roundToolCalls++; }, () => { showPrompt(); }, { enabled: validationEnabled, verbose: validationVerbose, strict: validationStrict }, bugJournal, browserController, visionProcessor, pushScreenshotToBrainFn, getJarvisContextForPrompt(), (label, tool) => {
-                    currentStepLabel = label;
-                    const fileTools = new Set(['read_file', 'write_file', 'edit_file']);
-                    currentStepFile = fileTools.has(tool) ? label.replace(/^(reading|writing|editing)\s+/, '') : '';
-                });
-                agentRunning = false;
-                messages.push({ role: 'user', content: buffered.trim() });
+                await processInput(buffered.trim());
             }
         }
         showPrompt();
@@ -3712,7 +3944,7 @@ async function runBackgroundSession(session, prompt, provider, project, spiralEn
         durationMs: session.elapsed,
     };
 }
-async function sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, controller, activity, sessionBuffer, onTokens, onToolCall, onAgentStart, validationOpts, bugJournal, browserController, visionProcessor, onBrowserScreenshot, jarvisContext, onStepInfo, learningJournal, runtime) {
+async function sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, controller, activity, sessionBuffer, onTokens, onToolCall, onAgentStart, validationOpts, bugJournal, browserController, visionProcessor, onBrowserScreenshot, jarvisContext, onStepInfo, learningJournal, runtime, skillManager) {
     // User message was rendered by renderUserMessage() in the caller before entering here.
     const executionRoot = runtime?.executionRoot ?? process.cwd();
     // Intent Detection: Check if user wants to feed the codebase
@@ -3811,6 +4043,7 @@ async function sendAgentMessage(input, agentHistory, provider, project, spiralEn
                 visionProcessor,
                 onBrowserScreenshot: onBrowserScreenshot ?? undefined,
                 learningJournal,
+                skillManager,
                 worktree: runtime?.worktree,
             },
             checkpointStore,
@@ -4008,9 +4241,15 @@ function showFullAutonomousWarning() {
     process.stdout.write(d('\u2502  ') + d('ESC = stop agent if needed.') + d('              \u2502') + '\n');
     process.stdout.write(d('\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F') + '\n\n');
 }
-async function handleSlashCommand(input, messages, agentHistory, config, spiralEngine, store, rl, permissions, undoStack, checkpointStore, sessionBuffer, sessionTokens, sessionToolCalls, onProviderSwitch, onBrainSwitch, currentBrainScope, onAutonomous, onValidation, sessionManager, onRegisterBrainHandlers, onSubPrompt, bugJournal, jarvisCtx, onModeChange, chrome, planCtx, worktreeCtx) {
+async function handleSlashCommand(input, messages, agentHistory, config, spiralEngine, store, rl, permissions, undoStack, checkpointStore, sessionBuffer, sessionTokens, sessionToolCalls, onProviderSwitch, onBrainSwitch, currentBrainScope, resolveSpiralEngine, onAutonomous, onValidation, sessionManager, onRegisterBrainHandlers, onSubPrompt, bugJournal, jarvisCtx, onModeChange, chrome, planCtx, worktreeCtx) {
     const parts = input.split(/\s+/);
     let cmd = parts[0].toLowerCase();
+    const ensureSpiralForScope = async (scope = currentBrainScope || 'global') => {
+        if (!resolveSpiralEngine)
+            return spiralEngine;
+        spiralEngine = await resolveSpiralEngine(scope);
+        return spiralEngine;
+    };
     // ─── Chrome-aware selectMenu ───────────────────────────
     // Deactivates Screen during interactive menus to prevent
     // stdout hook interference (menu stacking on Windows Terminal).
@@ -4112,7 +4351,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
             rl.resume();
             if (helpIdx >= 0 && helpCmds[helpIdx]) {
                 // Execute the selected command
-                return handleSlashCommand(helpCmds[helpIdx], messages, agentHistory, config, spiralEngine, store, rl, permissions, undoStack, checkpointStore, sessionBuffer, sessionTokens, sessionToolCalls, onProviderSwitch, onBrainSwitch, currentBrainScope, onAutonomous, onValidation, sessionManager, onRegisterBrainHandlers, onSubPrompt, bugJournal, jarvisCtx, onModeChange, chrome, planCtx, worktreeCtx);
+                return handleSlashCommand(helpCmds[helpIdx], messages, agentHistory, config, spiralEngine, store, rl, permissions, undoStack, checkpointStore, sessionBuffer, sessionTokens, sessionToolCalls, onProviderSwitch, onBrainSwitch, currentBrainScope, resolveSpiralEngine, onAutonomous, onValidation, sessionManager, onRegisterBrainHandlers, onSubPrompt, bugJournal, jarvisCtx, onModeChange, chrome, planCtx, worktreeCtx);
             }
             break;
         }
@@ -4211,6 +4450,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
             return 'drain'; // Sub-readline may leave phantom line events
         }
         case '/spiral':
+            spiralEngine = await ensureSpiralForScope(currentBrainScope || 'global');
             if (spiralEngine) {
                 try {
                     const status = spiralEngine.status();
@@ -4221,7 +4461,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
                 }
             }
             else {
-                renderInfo('Spiral engine disabled.');
+                renderInfo(config.spiral.enabled ? 'Spiral engine not available.' : 'Spiral engine disabled.');
             }
             break;
         case '/helix':
@@ -4242,6 +4482,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
                     renderInfo(chalk.yellow('  Cannot use local brain here — using global'));
                 }
             }
+            spiralEngine = await ensureSpiralForScope('project');
             // Auto-start brain visualization
             if (spiralEngine) {
                 try {
@@ -4282,6 +4523,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
                 }
                 catch { /* optional */ }
             }
+            spiralEngine = await ensureSpiralForScope('global');
             // Auto-start brain visualization
             if (spiralEngine) {
                 try {
@@ -4365,6 +4607,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
             }
             // Open 3D visualization (for /brain or /brain view)
             if (!brainArg || brainArg === 'view') {
+                spiralEngine = await ensureSpiralForScope(currentBrainScope || 'global');
                 if (spiralEngine) {
                     try {
                         const { exportBrainData } = await import('../brain/exporter.js');
@@ -4401,6 +4644,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
             // Handled directly in chatCommand() for access to inlineProgressActive flag
             break;
         case '/context':
+            spiralEngine = await ensureSpiralForScope(currentBrainScope || 'global');
             if (spiralEngine) {
                 const status = spiralEngine.status();
                 renderInfo(`Context: ${status.total_nodes} spiral nodes, ${status.total_edges} edges`);
@@ -4423,6 +4667,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
             break;
         }
         case '/compact':
+            spiralEngine = await ensureSpiralForScope(currentBrainScope || 'global');
             if (spiralEngine) {
                 const result = spiralEngine.evolve();
                 renderInfo(`Evolution: ${result.promoted} promoted, ${result.demoted} demoted, ${result.summarized} summarized`);
@@ -4739,6 +4984,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
         }
         case '/export': {
             const outputDir = parts[1] || process.cwd();
+            spiralEngine = await ensureSpiralForScope(currentBrainScope || 'global');
             if (spiralEngine) {
                 try {
                     const { exportToZip } = await import('../brain/archive.js');
@@ -5577,7 +5823,12 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
                     const port = getBrainPort();
                     process.stdout.write(`  ${theme.success('\u{1F310} Already connected')} on port ${port}\n`);
                 }
-                else if (spiralEngine) {
+                else {
+                    spiralEngine = await ensureSpiralForScope(currentBrainScope || 'project');
+                    if (!spiralEngine) {
+                        renderError(config.spiral.enabled ? 'No spiral engine available.' : 'Spiral engine is disabled.');
+                        break;
+                    }
                     const { exportBrainData } = await import('../brain/exporter.js');
                     exportBrainData(spiralEngine, 'HelixMind Project', currentBrainScope || 'project');
                     const url = await startLiveBrain(spiralEngine, 'HelixMind Project', currentBrainScope || 'project');
@@ -5586,9 +5837,6 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
                     process.stdout.write(`  ${theme.success('\u{1F310} Brain server started:')} ${url}\n`);
                     process.stdout.write(`  ${theme.dim('Web dashboard can now connect.')}\n`);
                 }
-                else {
-                    renderError('No spiral engine available. Run /helix first.');
-                }
             }
             catch (err) {
                 renderError(`Failed to start brain server: ${err}`);