nexus-prime 4.4.0 → 4.5.0

package/README.md

@@ -246,6 +246,28 @@ nexus-prime setup all
 nexus-prime setup status
 ```
 
+### GStack Workspace Coordination
+
+[GStack](https://github.com/garrytan/gstack) is a workspace coordination and deployment tool that complements Nexus Prime for web browsing, deployment workflows, planning, and team coordination. If you have GStack installed globally at `~/gstack`, Nexus Prime will auto-detect and enable it:
+
+```bash
+# Check GStack configuration for this project
+cat .gstackrc
+
+# Available GStack skills (when enabled)
+/browse              # Web browsing & navigation (preferred over MCP Chrome)
+/ship                # Prepare & execute deployments
+/land-and-deploy     # Landing page & feature deployment
+/canary              # Canary deployment testing
+/qa                  # Full QA & testing workflows
+/review              # Code review (integrates with Git)
+/plan-eng-review     # Engineering review planning
+/retro               # Sprint retrospectives
+/document-release    # Release notes & documentation
+```
+
+For full GStack integration docs, see [`GSTACK.md`](./GSTACK.md).
+
 ### Runtime contract
 
 ```txt
@@ -632,6 +654,32 @@ Inventory Snapshot: 109 skills · 64 workflows · 9 hooks · 5 automations · 7
 ## 📜 Release History
 
 <details open>
+<summary><b>v4.5.0</b> · 2026-03-27 · Neural Ascension — Auto-optimization, memory injection, and sci-fi command center</summary>
+
+- **Auto token optimization**: Bootstrap auto-applies token planning when 5+ candidate files detected. Quality floor (0.7) ensures task-referenced and recently modified files never get skipped. Zero manual `nexus_optimize_tokens` calls needed.
+- **Seamless memory injection**: Every MCP tool response auto-recalls top 3 relevant memories (30s rate limit, 0.4 score floor, SHA1-cached). Recursion-safe — skips memory tools.
+- **Auto ghost-pass**: Refactoring tasks with 3+ files or 3+ phases auto-detect risk areas before execution begins.
+- **MCP category visuals**: 5 distinct sci-fi themes (memory/orchestration/execution/intelligence/system) with per-category ANSI borders, colors, and thematic labels.
+- **Dashboard noise reduction**: Server-side rate limiting for 5 event types (2-10s windows), noise suppression for auto/empty signals, System filter button, client-side type+summary dedup.
+- **Cross-project memory**: New APIs for cross-project browsing and project index. Dashboard project selector, tag-based search with fuzzy toggle, cross-project memory lane.
+- **Animated installation**: 10-frame braille spinner, compact logo for narrow terminals, progress bars, phase headers, build metadata in success message.
+- **Lifecycle policy substrate**: Feature flags with env overrides for all new auto-behaviors. Fail-open defaults with decision metrics.
+
+Full history: [CHANGELOG.md](./CHANGELOG.md)
+</details>
+
+<details>
+<summary><b>v4.4.0</b> · 2026-03-27 · Lifecycle policy automation, cross-project memory APIs, and signal-aware dashboard UX</summary>
+
+- **Lifecycle policy substrate**: Added policy-gated auto behaviors with fail-open decisions, feature kill switches, and decision metrics for bootstrap token planning, memory-context injection, MCP visuals, and ghost-pass automation.
+- **Memory platform expansion**: Added `/api/memory/cross-project` and `/api/memory/projects`, shared-only governance defaults, and tag+content+fuzzy cross-project query support.
+- **Dashboard signal quality**: Added server-side event throttles/noise suppression, explicit `mcp` + `system` taxonomy alignment, a `System` event filter chip, and dual-key dedup (`id` + `type/summary` in 2s, severity bypass).
+- **CLI/install visual layer**: Expanded ASCII toolkit (compact logo, richer loaders, phase/sub-brand helpers), added TTY-aware install spinner, and surfaced phase/sub-brand rendering in CLI summaries/help.
+
+Full history: [CHANGELOG.md](./CHANGELOG.md)
+</details>
+
+<details>
 <summary><b>v4.3.4</b> · 2026-03-26 · Semantic retrieval hardening, truthful worker budgets, and canonical promoted assets</summary>
 
 - **Semantic retrieval and matching**: RAG chunks now carry embeddings with semantic-first retrieval, Context Assembler relevance uses Embedder-backed scoring, and Synapse asset matching blends semantic and lexical signals instead of pure Jaccard hot paths.

package/dist/agents/adapters/mcp.d.ts

@@ -16,7 +16,12 @@ export declare class MCPAdapter implements Adapter {
     private telemetry;
     private sessionDNA;
     private runtime?;
+    private lifecyclePolicy;
+    private memoryInjectionCache;
+    private lastMemoryInjectionAt;
     private sciFiMatrixLog;
+    private classifyToolCategory;
+    private sciFiToolHeader;
     private box;
     constructor();
     private detectCallerName;
@@ -28,6 +33,9 @@ export declare class MCPAdapter implements Adapter {
     private formatRemainingProtocolSteps;
     private prependTextToResponse;
     private decorateLifecycleResponse;
+    private extractGoalLikeText;
+    private isMemoryTool;
+    private injectMemoryContext;
     private describeClientInstructionStatus;
     private finalizeToolDefinitions;
     private decorateToolDescription;

package/dist/agents/adapters/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAmE5C,KAAK,cAAc,GAAG,YAAY,GAAG,MAAM,CAAC;AAE5C,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AA4SF,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,OAAO,CAAC,CAAkB;IAElC,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,GAAG;;IAmBX,OAAO,CAAC,gBAAgB;IA4BxB,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,4BAA4B;IAWpC,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,yBAAyB;IA8BjC,OAAO,CAAC,+BAA+B;IAMvC,OAAO,CAAC,uBAAuB;IAqB/B,OAAO,CAAC,uBAAuB;IAkC/B,cAAc,CAAC,OAAO,GAAE,cAAsC,GAAG,iBAAiB,EAAE;IAIpF,OAAO,CAAC,oBAAoB;IAgzB5B,OAAO,CAAC,iBAAiB;YA4FX,cAAc;IAs3D5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlD,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;CAOzC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA0E5C,KAAK,cAAc,GAAG,YAAY,GAAG,MAAM,CAAC;AAE5C,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AAqTF,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,OAAO,CAAC,CAAkB;IAClC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,oBAAoB,CAAgG;IAC5H,OAAO,CAAC,qBAAqB,CAAK;IAElC,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,eAAe;IAqEvB,OAAO,CAAC,GAAG;;IAmBX,OAAO,CAAC,gBAAgB;IA4BxB,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,4BAA4B;IAWpC,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,yBAAyB;IA2CjC,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,YAAY;YAON,mBAAmB;IA0DjC,OAAO,CAAC,+BAA+B;IAMvC,OAAO,CAAC,uBAAuB;IAqB/B,OAAO,CAAC,uBAAuB;IAkC/B,cAAc,CAAC,OAAO,GAAE,cAAsC,GAAG,iBAAiB,EAAE;IAIpF,OAAO,CAAC,oBAAoB;IAkzB5B,OAAO,CAAC,iBAAiB;YA6FX,cAAc;IAk7D5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlD,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;CAOzC"}

package/dist/agents/adapters/mcp.js

@@ -5,6 +5,7 @@ import { statSync, readdirSync } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
+import { createHash } from 'crypto';
 import { TokenSupremacyEngine, formatReadingPlan } from '../../engines/token-supremacy.js';
 import { GhostPass, createSubAgentRuntime, summarizeExecution, } from '../../phantom/index.js';
 import { GuardrailEngine } from '../../engines/guardrails-bridge.js';
@@ -12,12 +13,14 @@ import { SessionDNAManager } from '../../engines/session-dna.js';
 import { ContextAssembler } from '../../engines/context-assembler.js';
 import { GraphMemoryEngine } from '../../engines/graph-memory.js';
 import { GraphTraversalEngine } from '../../engines/graph-traversal.js';
+import { ASCII_ART } from '../../utils/ascii-art.js';
 import { HybridRetriever } from '../../engines/hybrid-retriever.js';
 import { nexusEventBus } from '../../engines/event-bus.js';
 import { AttentionScorer } from '../../engines/attention-stream.js';
 import { SkillCardRegistry } from '../../engines/skill-card.js';
 import { DarwinLoop } from '../../engines/darwin-loop.js';
 import { nexusNetRelay } from '../../engines/nexusnet-relay.js';
+import { LifecyclePolicy } from '../../engines/lifecycle-policy.js';
 import { entanglementEngine, ContinuousAttentionStream, createKVBridge, nxl, OrchestratorEngine } from '../../engines/index.js';
 import { FederationEngine } from '../../engines/federation.js';
 import { TokenAnalyticsEngine } from '../../engines/token-analytics.js';
@@ -30,7 +33,13 @@ const kvBridge = createKVBridge({ agents: 3 });
 const orchestrator = new OrchestratorEngine();
 const darwinLoop = new DarwinLoop(orchestrator.getMemoryEngine());
 const federation = new FederationEngine();
-const fallbackRuntime = createSubAgentRuntime({ repoRoot: process.cwd() });
+// Lazy-initialized fallback runtime to avoid leaking a phantom runtime at module load
+let _fallbackRuntime = null;
+function getFallbackRuntime() {
+    if (!_fallbackRuntime)
+        _fallbackRuntime = createSubAgentRuntime({ repoRoot: process.cwd() });
+    return _fallbackRuntime;
+}
 // Lazy-initialized Graph Engine (separate DB from core memory)
 let _graphEngine = null;
 let _traversalEngine = null;
@@ -140,6 +149,7 @@ class SessionTelemetry {
     fileReadIntentCount = 0;
     callsSinceOrchestrate = 0;
     fileIntentPaths = new Set();
+    tokenAutoApplied = false;
     bootstrapped = false;
     recordCall() {
         this.callCount++;
@@ -163,6 +173,7 @@ class SessionTelemetry {
             sessionDnaCalled: this.sessionDnaCalled,
             fileReadIntentCount: this.fileReadIntentCount,
             callsSinceOrchestrate: this.callsSinceOrchestrate,
+            tokenAutoApplied: this.tokenAutoApplied,
         };
     }
     advancePhase(nextPhase) {
@@ -172,6 +183,7 @@ class SessionTelemetry {
         if (nextPhase === 'bootstrapped' || nextPhase === 'orchestrated') {
             this.resetFileIntentTracking();
             this.optimizeTokensCalled = false;
+            this.tokenAutoApplied = false;
         }
         if (nextPhase === 'orchestrated') {
             this.mindkitCheckCalled = false;
@@ -234,8 +246,14 @@ class SessionTelemetry {
             return false;
         if (this.lifecyclePhase === 'pre-bootstrap')
             return false;
+        if (this.tokenAutoApplied)
+            return false;
         return this.fileReadIntentCount >= 3 && !this.optimizeTokensCalled;
     }
+    markTokenAutoApplied() {
+        this.tokenAutoApplied = true;
+        this.optimizeTokensCalled = true;
+    }
     needsStoreMemory(currentToolName) {
         if (currentToolName === 'nexus_store_memory')
             return false;
@@ -344,6 +362,9 @@ export class MCPAdapter {
     telemetry = new SessionTelemetry();
     sessionDNA;
     runtime;
+    lifecyclePolicy = new LifecyclePolicy();
+    memoryInjectionCache = new Map();
+    lastMemoryInjectionAt = 0;
     sciFiMatrixLog(title, metrics, intent) {
         const width = 76;
         console.error(`\n\x1b[36m╔═══ [ \x1b[37m\x1b[1mNEXUS PRIME · ORCHESTRATION MATRIX\x1b[0m\x1b[36m ] ${'═'.repeat(Math.max(0, width - 48))}╗\x1b[0m`);
@@ -369,6 +390,81 @@ export class MCPAdapter {
         }
         console.error(`\x1b[36m╚${'═'.repeat(width - 2)}╝\x1b[0m\n`);
     }
+    classifyToolCategory(toolName) {
+        if (['nexus_store_memory', 'nexus_recall_memory', 'nexus_memory_stats'].includes(toolName))
+            return 'memory';
+        if (['nexus_orchestrate', 'nexus_plan_execution', 'nexus_spawn_workers'].includes(toolName))
+            return 'orchestration';
+        if (['nexus_ghost_pass', 'nexus_mindkit_check', 'nexus_optimize_tokens'].includes(toolName))
+            return 'execution';
+        if (['nexus_session_bootstrap', 'nexus_session_dna', 'nexus_token_report'].includes(toolName))
+            return 'intelligence';
+        if (toolName === 'nexus_run_status' || toolName === 'nexus_federation_status' || toolName.startsWith('nexus_list_'))
+            return 'system';
+        return 'system';
+    }
+    sciFiToolHeader(category, toolName, goal) {
+        if (!this.lifecyclePolicy.isEnabled('mcpCategoryVisuals')) {
+            console.error(`\x1b[90m[NEXUS] ◈ ${toolName} ◈\x1b[0m`);
+            return;
+        }
+        const rawPreview = goal || 'No goal payload provided.';
+        const preview = rawPreview.length > 54 ? `${rawPreview.slice(0, 53)}…` : rawPreview;
+        if (category === 'orchestration') {
+            this.sciFiMatrixLog('ORCHESTRATION MATRIX', {
+                'Category': 'orchestration',
+                'Label': 'ORCHESTRATION MATRIX',
+                'Tool': toolName,
+                'Execution': 'autonomous',
+                'Policy': 'enabled',
+                'Status': 'dispatching',
+            }, preview);
+            return;
+        }
+        const themed = {
+            memory: {
+                color: '32',
+                title: '🧠 MEMORY LATTICE QUERY',
+                lines: [
+                    `Glyph: ⬢ MEMORY NODE`,
+                    `Tool: ${toolName}`,
+                    `Intent: ${preview}`,
+                    'Border: single-line lattice',
+                ],
+            },
+            execution: {
+                color: '33',
+                title: '⚙ EXECUTION PIPELINE',
+                lines: [
+                    `Glyph: ▶ PIPE STAGE`,
+                    `Tool: ${toolName}`,
+                    `Intent: ${preview}`,
+                    'Border: high-visibility single line',
+                ],
+            },
+            intelligence: {
+                color: '34',
+                title: '📡 INTELLIGENCE RELAY',
+                lines: [
+                    `Glyph: ⟡ RELAY NODE`,
+                    `Tool: ${toolName}`,
+                    `Intent: ${preview}`,
+                    'Border: relay channel single line',
+                ],
+            },
+            system: {
+                color: '90',
+                title: '⋯ SYSTEM BUS ⋯',
+                lines: [
+                    `Glyph: ◌ BUS TRACE`,
+                    `Tool: ${toolName}`,
+                    `Intent: ${preview}`,
+                    'Border: dotted diagnostics',
+                ],
+            },
+        }[category];
+        this.box(themed.title, themed.lines, themed.color);
+    }
     box(title, content, color = '34') {
         const width = 68;
         console.error(`\n\x1b[${color}m┌─ ${title} ${'─'.repeat(Math.max(0, width - title.length - 4))}┐\x1b[0m`);
@@ -429,7 +525,7 @@ export class MCPAdapter {
             return this.nexusRef.getRuntime();
         }
         if (!this.runtime) {
-            this.runtime = fallbackRuntime;
+            this.runtime = getFallbackRuntime();
         }
         return this.runtime;
     }
@@ -490,10 +586,88 @@ export class MCPAdapter {
         }
         if (warnings.length === 0)
             return result;
-        return this.prependTextToResponse(result, [
-            'LIFECYCLE WARNING:',
-            ...warnings.map((warning) => `- ${warning}`),
-        ].join('\n'));
+        // Make warnings highly visible: prepend as plain text AND inject as structured first content block
+        const warningBlock = {
+            type: 'text',
+            text: JSON.stringify({
+                WARNING: 'NEXUS LIFECYCLE VIOLATION',
+                issues: warnings,
+                requiredActions: warnings.map((w) => w.includes('nexus_optimize_tokens') ? 'Call nexus_optimize_tokens(goal, files) NOW before reading more files'
+                    : w.includes('nexus_store_memory') ? 'Call nexus_store_memory(content, priority, tags) to persist findings'
+                        : w),
+            }, null, 2),
+        };
+        return {
+            content: [
+                warningBlock,
+                ...result.content,
+            ],
+        };
+    }
+    extractGoalLikeText(args) {
+        const candidates = [args.goal, args.task, args.prompt, args.query, args.action, args.content]
+            .map((value) => String(value ?? '').trim())
+            .filter(Boolean);
+        return candidates[0] ?? '';
+    }
+    isMemoryTool(toolName) {
+        return toolName === 'nexus_store_memory'
+            || toolName === 'nexus_recall_memory'
+            || toolName === 'nexus_memory_stats'
+            || toolName.startsWith('nexus_memory_');
+    }
+    async injectMemoryContext(toolName, args, result) {
+        const policy = this.lifecyclePolicy.evaluate('memoryInjection', {
+            toolName,
+            hasArgs: Object.keys(args ?? {}).length,
+        });
+        if (!policy.enabled || this.isMemoryTool(toolName))
+            return result;
+        const query = this.extractGoalLikeText(args);
+        if (query.length < 10)
+            return result;
+        const now = Date.now();
+        if (now - this.lastMemoryInjectionAt < 30_000)
+            return result;
+        const cacheWindowMs = Number(process.env.NEXUS_MEMORY_INJECTION_CACHE_MS ?? 30_000);
+        const minScore = Number(process.env.NEXUS_MEMORY_INJECTION_MIN_SCORE ?? 0.4);
+        const cacheKey = createHash('sha1').update(query.toLowerCase()).digest('hex').slice(0, 16);
+        const cached = this.memoryInjectionCache.get(cacheKey);
+        let matches = [];
+        if (cached && cached.expiresAt > now) {
+            matches = cached.matches;
+        }
+        else {
+            try {
+                const memory = this.getOrchestrator().getMemoryEngine();
+                const recalled = await memory.recallWithMetadata(query, 3, { minScore });
+                matches = recalled
+                    .filter((entry) => Number(entry.score) >= minScore)
+                    .map((entry) => ({ content: entry.content, score: entry.score }));
+                this.memoryInjectionCache.set(cacheKey, {
+                    expiresAt: now + cacheWindowMs,
+                    matches,
+                });
+            }
+            catch (error) {
+                console.warn('[MCP] Memory context injection skipped:', error?.message ?? error);
+                return result;
+            }
+        }
+        if (matches.length === 0)
+            return result;
+        this.lastMemoryInjectionAt = now;
+        const contextBlock = {
+            type: 'text',
+            text: [
+                '[Memory Context]',
+                ...matches.map((entry, index) => `${index + 1}. ${entry.content.slice(0, 220)}${entry.content.length > 220 ? '…' : ''} (score ${entry.score.toFixed(2)})`),
+            ].join('\n'),
+        };
+        return {
+            ...result,
+            content: [...result.content, contextBlock],
+        };
     }
     describeClientInstructionStatus(profile) {
         return profile === 'autonomous'
@@ -1106,7 +1280,7 @@ export class MCPAdapter {
             },
             {
                 name: 'nexus_rag_ingest_collection',
-                description: 'Expert surface: ingest local files, URLs, or raw text into a RAG collection.',
+                description: 'Expert surface: ingest local files, folders, URLs, or raw text into a RAG collection. Use folderPath to ingest an entire directory recursively.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -1116,14 +1290,16 @@ export class MCPAdapter {
                             items: {
                                 type: 'object',
                                 properties: {
-                                    filePath: { type: 'string' },
+                                    filePath: { type: 'string', description: 'Single file path' },
+                                    folderPath: { type: 'string', description: 'Directory path to recursively ingest all supported files' },
+                                    folderGlob: { type: 'string', description: 'Optional extension filter for folder ingestion (e.g. "*.ts")' },
                                     url: { type: 'string' },
                                     text: { type: 'string' },
                                     label: { type: 'string' },
                                     tags: { type: 'array', items: { type: 'string' } },
                                 },
                             },
-                            description: 'Collection sources',
+                            description: 'Collection sources (supports file, folder, url, or text)',
                         },
                     },
                     required: ['collectionId', 'inputs'],
@@ -1394,6 +1570,25 @@ export class MCPAdapter {
                 this.telemetry.bootstrapped = true;
             }
             const args = request.params?.arguments ?? {};
+            // Gate: block non-bootstrap tools BEFORE executing them to avoid wasted work and side effects
+            if (!this.telemetry.bootstrapped &&
+                toolName !== 'nexus_session_bootstrap' &&
+                toolName !== 'nexus_memory_stats' &&
+                !toolName.startsWith('nexus_list_') &&
+                toolName !== 'nexus_federation_status' &&
+                toolName !== 'nexus_status') {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                status: 'blocked',
+                                reason: 'nexus_session_bootstrap has not been called yet',
+                                action: 'Call nexus_session_bootstrap(goal="<your task>") first, then retry this tool',
+                                hint: 'Bootstrap recovers memory and context — skipping it means working blind'
+                            }, null, 2)
+                        }]
+                };
+            }
             const callId = `mcp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
             const startTimeMs = Date.now();
             nexusEventBus.emit('mcp.call.start', {
@@ -1427,25 +1622,8 @@ export class MCPAdapter {
                 throw error;
             }
             this.telemetry.observeSuccessfulToolCall(toolName, args);
-            if (!this.telemetry.bootstrapped &&
-                toolName !== 'nexus_session_bootstrap' &&
-                toolName !== 'nexus_memory_stats' &&
-                !toolName.startsWith('nexus_list_') &&
-                toolName !== 'nexus_federation_status' &&
-                toolName !== 'nexus_status') {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'blocked',
-                                reason: 'nexus_session_bootstrap has not been called yet',
-                                action: 'Call nexus_session_bootstrap(goal="<your task>") first, then retry this tool',
-                                hint: 'Bootstrap recovers memory and context — skipping it means working blind'
-                            }, null, 2)
-                        }]
-                };
-            }
-            return this.decorateLifecycleResponse(toolName, result);
+            const decorated = this.decorateLifecycleResponse(toolName, result);
+            return this.injectMemoryContext(toolName, args, decorated);
         });
     }
     async handleToolCall(request) {
@@ -1462,20 +1640,19 @@ export class MCPAdapter {
             tokenOptimizationApplied: toolName === 'nexus_optimize_tokens',
             toolProfile: this.getToolProfile(),
         });
-        // v1.5 Mandatory Induction Interceptor / Sci-Fi Telemetry
-        if (goal && goal.length > 20 && !['nexus_execute_nxl', 'nexus_session_bootstrap', 'nexus_plan_execution', 'nexus_memory_stats'].includes(request.params.name)) {
-            this.sciFiMatrixLog('ROUTING PROTOCOL INITIATED', {
-                'Active Protocol': 'Multi-Agent Swarm',
-                'Tool Executing': toolName,
-                'Git Isolation': 'Enabled (Worktrees)',
-                'Memory Bridge': 'Active (Shared)',
-                'POD Network': 'Online',
-                'Status': 'Executing...'
-            }, goal.substring(0, 50) + '...');
+        const toolCategory = this.classifyToolCategory(toolName);
+        const showRichHeader = goal
+            && goal.length > 20
+            && !['nexus_execute_nxl', 'nexus_session_bootstrap', 'nexus_plan_execution', 'nexus_memory_stats'].includes(request.params.name);
+        if (showRichHeader) {
+            const frameCount = Math.max(4, Math.min(8, Number(ASCII_ART.sciFiLoaderFrames?.length ?? 8)));
+            for (let i = 0; i < frameCount; i++) {
+                console.error(`\x1b[35m${ASCII_ART.sciFiLoader(i)}\x1b[0m`);
+            }
+            this.sciFiToolHeader(toolCategory, toolName, goal);
         }
         else if (toolName) {
-            // Standard trace
-            console.error(`\x1b[90m[NEXUS] Executing Tool: ${toolName}\x1b[0m`);
+            console.error(`\x1b[90m[NEXUS:${toolCategory.toUpperCase()}] ◈ ${toolName} ◈\x1b[0m`);
         }
         if (goal && goal.length > 50 && !['nexus_execute_nxl', 'nexus_session_bootstrap', 'nexus_plan_execution'].includes(request.params.name)) {
             const swarm = await this.getOrchestrator().induce(goal);
@@ -1496,6 +1673,25 @@ export class MCPAdapter {
                     ? request.params.arguments.files.map(String)
                     : undefined;
                 const bootstrap = await this.getOrchestrator().bootstrapSession(bootstrapGoal, { files });
+                const autoTokenApplied = Boolean(bootstrap.tokenOptimization?.autoApplied);
+                if (autoTokenApplied) {
+                    this.telemetry.markTokenAutoApplied();
+                    if (bootstrap.tokenOptimization?.planMetrics?.savings) {
+                        this.telemetry.recordTokens(Number(bootstrap.tokenOptimization.planMetrics.savings));
+                    }
+                }
+                this.getRuntime().recordClientToolCall('nexus_session_bootstrap', {
+                    bootstrapCalled: true,
+                    plannerCalled: true,
+                    tokenOptimizationApplied: autoTokenApplied,
+                    tokenAutoApplied: autoTokenApplied,
+                    toolProfile: this.getToolProfile(),
+                });
+                // Auto-generate a project-scoped memory on bootstrap so dashboard always has something to show
+                try {
+                    this.nexusRef.storeMemory(`Session bootstrap: ${bootstrapGoal || 'interactive session'}. Memory: prefrontal=${bootstrap.memoryStats?.prefrontal ?? 0}, hippocampus=${bootstrap.memoryStats?.hippocampus ?? 0}, cortex=${bootstrap.memoryStats?.cortex ?? 0}.`, 0.5, ['#session-start', '#auto', '#project']);
+                }
+                catch { /* best-effort */ }
                 const payload = {
                     client: bootstrap.client,
                     memoryRecall: bootstrap.memoryRecall,
@@ -1526,15 +1722,21 @@ export class MCPAdapter {
                                     `Memory stats: prefrontal ${bootstrap.memoryStats?.prefrontal ?? 0} · hippocampus ${bootstrap.memoryStats?.hippocampus ?? 0} · cortex ${bootstrap.memoryStats?.cortex ?? 0}`,
                                     `Recommended next step: ${bootstrap.recommendedNextStep || 'nexus_orchestrate'}`,
                                     `Execution mode: ${bootstrap.recommendedExecutionMode || 'autonomous'}`,
-                                    `Token optimization: ${bootstrap.tokenOptimization?.required ? 'required before broad reading' : 'not required yet'}`,
+                                    `Token optimization: ${bootstrap.tokenOptimization?.autoApplied ? 'auto-applied during bootstrap' : (bootstrap.tokenOptimization?.required ? 'required before broad reading' : 'not required yet')}`,
                                     `Catalog health: ${bootstrap.catalogHealth?.overall || 'unknown'} · selected ${bootstrap.artifactSelectionAudit?.selected?.length || 0}`,
                                     `Shortlist: ${bootstrap.shortlist?.skills?.slice(0, 3).join(', ') || 'none'} (skills), ${bootstrap.shortlist?.specialists?.slice(0, 3).join(', ') || 'none'} (specialists)`,
                                     `Knowledge fabric: ${bootstrap.sourceMixRecommendation?.dominantSource || bootstrap.knowledgeFabric?.dominantSource || 'awaiting source mix'}`,
                                     `RAG: ${bootstrap.ragCandidateStatus?.attachedCollections || 0} attached · ${bootstrap.ragCandidateStatus?.retrievedChunks || 0} retrieved`,
                                     `Task graph: ${bootstrap.taskGraphPreview?.phases?.length || 0} phases · ${bootstrap.taskGraphPreview?.independentBranches || 0} branches`,
                                     `Worker plan: ${bootstrap.workerPlanPreview?.totalWorkers || 0} lanes planned`,
+                                    bootstrap.autoGhostPass?.applied
+                                        ? `Auto ghost-pass: ${bootstrap.autoGhostPass.riskAreas.length} risk area(s) · ${bootstrap.autoGhostPass.workerApproaches} approach(es)`
+                                        : `Auto ghost-pass: skipped`,
                                     `Bootstrap status: ${bootstrap.clientBootstrapStatus?.clients?.length || 0} client manifests tracked`,
                                 ]),
+                                bootstrap.tokenOptimization?.autoApplied && bootstrap.tokenOptimization?.plan
+                                    ? `Auto token plan\n\`\`\`txt\n${bootstrap.tokenOptimization.plan}\n\`\`\``
+                                    : '',
                                 formatJsonDetails('Structured details', payload),
                                 this.formatProtocolChecklist(),
                             ].join('\n\n'),
@@ -1583,6 +1785,28 @@ export class MCPAdapter {
                         optimizationProfile,
                     });
                     const verifiedWorkers = execution.workerResults.filter((worker) => worker.verified).length;
+                    const tokenPlan = execution?.knowledgeFabric?.repo?.readingPlan;
+                    const canAutoApplyTokenPlan = Boolean(tokenPlan
+                        && Number(tokenPlan.savings || 0) > 5000
+                        && !this.getRuntime().getUsageSnapshot()?.tokenOptimizationApplied);
+                    let autoTokenApplyNote = '';
+                    if (canAutoApplyTokenPlan) {
+                        const savings = Number(tokenPlan.savings || 0);
+                        this.telemetry.recordTokens(savings);
+                        this.getRuntime().recordClientToolCall('nexus_orchestrate', {
+                            orchestrateCalled: true,
+                            plannerCalled: true,
+                            tokenOptimizationApplied: true,
+                            toolProfile: this.getToolProfile(),
+                        });
+                        autoTokenApplyNote = `Auto-applied token optimization (${savings.toLocaleString()} estimated token savings).`;
+                    }
+                    // Auto-store run summary memory so dashboard and future sessions can see what happened
+                    try {
+                        const modifiedFiles = execution.workerResults.flatMap((w) => w.modifiedFiles);
+                        this.nexusRef.storeMemory(`Run ${execution.runId} ${execution.state}: ${summarizeExecution(execution)}. Workers: ${verifiedWorkers}/${execution.workerResults.length} verified. Files modified: ${modifiedFiles.slice(0, 5).join(', ') || 'none'}.`, 0.7, ['#run-summary', '#auto', '#project']);
+                    }
+                    catch { /* best-effort */ }
                     execution.activeSkills.forEach((skill) => this.sessionDNA.recordSkill(skill.name));
                     execution.workerResults.forEach((result) => {
                         result.modifiedFiles.forEach((file) => this.sessionDNA.recordFileModified(file));
@@ -1618,6 +1842,7 @@ export class MCPAdapter {
                         tokens: execution.tokenTelemetry,
                         verifiedWorkers,
                         continuationChildren: execution.continuationChildren,
+                        autoTokenApplyNote,
                     };
                     return {
                         content: [{
@@ -1635,6 +1860,7 @@ export class MCPAdapter {
                                         `Verification: ${verifiedWorkers}/${execution.workerResults.length} worker(s) verified`,
                                         `Worktrees: ${runtimeUsage.worktreeHealth?.overall || 'unknown'} · repaired ${runtimeUsage.worktreeHealth?.repairedEntries || 0} · broken ${runtimeUsage.worktreeHealth?.brokenEntries || 0}`,
                                         `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}% · dominant ${runtimeUsage.sourceAwareTokenBudget?.dominantSource || execution.knowledgeFabric?.sourceMix?.dominantSource || 'repo'}`,
+                                        autoTokenApplyNote || null,
                                         `RAG: ${(runtimeUsage.ragUsageSummary?.attachedCollections || execution.knowledgeFabric?.rag.attachedCollections.length || 0)} attached · ${(runtimeUsage.ragUsageSummary?.retrievedChunks || execution.knowledgeFabric?.rag.hits.length || 0)} retrieved`,
                                         `Memory scopes: ${Object.entries(runtimeUsage.memoryScopeUsage?.byScope || execution.memoryScopeUsage?.byScope || {}).map(([scope, count]) => `${scope}:${count}`).join(' · ') || 'awaiting shared/session reads'}`,
                                     ]),