nexus-prime 7.4.0 → 7.6.0

package/README.md

@@ -49,8 +49,10 @@
 - [The problem](#the-problem)
 - [What changes when you install](#what-changes-when-you-install)
 - [Quick start](#quick-start)
+- [Docs and comparison](#docs-and-comparison)
 - [Features](#features)
 - [See it in action](#see-it-in-action)
+- [Competitive position](#competitive-position)
 - [Works with](#works-with)
 - [What users see](#what-users-see)
 - [Who it's for](#who-its-for)
@@ -62,6 +64,16 @@
 
 ---
 
+## Docs and comparison
+
+- Website: https://nexus-prime.cfd/
+- Comparison: https://nexus-prime.cfd/comparison.html
+- Knowledge base: https://nexus-prime.cfd/knowledge-base.html
+
+Agents should start with `nexus_session_bootstrap`, then route the raw request through `nexus_orchestrate`. Auto-bootstrap runs on first non-bootstrap call for compatible clients, but the explicit bootstrap-first path remains the safest integration contract.
+
+---
+
 ## The problem
 
 Every coding agent you use starts every session cold.
@@ -269,6 +281,12 @@ No benchmarks from a press release — this is what the dashboard shows you, on
 
 ---
 
+## Competitive position
+
+Nexus Prime is a local-first control plane for coding agents: persistent memory, workspace-scoped runtime state, dashboard observability, and MCP-native orchestration in one install. The public comparison page tracks where it differs from other agent frameworks and developer orchestrators: https://nexus-prime.cfd/comparison.html
+
+---
+
 ## Who it's for
 
 Nexus Prime is for people who take AI-assisted coding seriously:

package/dist/adapters/hooks/context.d.ts

@@ -12,11 +12,11 @@ export declare const ContextHooks: {
     readonly hypertuneMax: (task: string, files: FileRef[], graphConnectivity?: (chunk: {
         source: string;
         label: string;
-    }) => number) => {
+    }) => number) => Promise<{
         plan: ReadingPlan;
         assembly: AssemblyResult;
         budgetConfig: BudgetConfig;
-    };
+    }>;
     readonly differential: (prev: SessionSummary, curr: FileRef[]) => ContextDelta;
     readonly loadLatestSessionSummary: () => Promise<SessionSummary | null>;
     readonly allocateBudget: (workers: Array<{

package/dist/adapters/hooks/index.d.ts

@@ -37,11 +37,11 @@ export declare const Hooks: {
         readonly hypertuneMax: (task: string, files: FileRef[], graphConnectivity?: (chunk: {
             source: string;
             label: string;
-        }) => number) => {
+        }) => number) => Promise<{
             plan: import("../../engines/token-supremacy.js").ReadingPlan;
             assembly: import("../../engines/context-assembler.js").AssemblyResult;
             budgetConfig: import("../../engines/context-assembler.js").BudgetConfig;
-        };
+        }>;
         readonly differential: (prev: import("../../engines/token-supremacy.js").SessionSummary, curr: FileRef[]) => import("../../engines/token-supremacy.js").ContextDelta;
         readonly loadLatestSessionSummary: () => Promise<import("../../engines/token-supremacy.js").SessionSummary | null>;
         readonly allocateBudget: (workers: Array<{

package/dist/agents/adapters/ide-compat.js

@@ -13,7 +13,10 @@ function nexusMcpServerEntry(workspaceRoot) {
     return {
         command: 'node',
         args: [join(workspaceRoot, 'node_modules', 'nexus-prime', 'dist', 'cli.js'), 'mcp'],
-        env: {},
+        env: {
+            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
+            NEXUS_WORKSPACE_ROOT: workspaceRoot,
+        },
     };
 }
 function hasAnyEnvPrefix(prefix) {

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

@@ -2,5 +2,8 @@ export type McpToolDefinition = {
     name: string;
     description: string;
     inputSchema: Record<string, unknown>;
+    deprecated?: true;
+    deprecatedReplacement?: string;
 };
+export declare const FIRST_CLASS_TOOLS: Set<string>;
 export declare function buildMcpToolDefinitions(): McpToolDefinition[];

package/dist/agents/adapters/mcp/definitions.js

@@ -1,8 +1,26 @@
 import { synapseToolDefinitions } from '../../../synapse/index.js';
 import { architectsToolDefinitions } from '../../../architects/index.js';
 import { getGstackBridge } from '../../../engines/gstack-bridge.js';
+export const FIRST_CLASS_TOOLS = new Set([
+    'nexus_session_bootstrap',
+    'nexus_orchestrate',
+    'nexus_session_dna',
+    'nexus_store_memory',
+    'nexus_recall_memory',
+    'nexus_memory_stats',
+    'nexus_optimize_tokens',
+    'nexus_mindkit_check',
+    'nexus_ghost_pass',
+    'nexus_describe_tool',
+    'nexus_search',
+    'nexus_runtime_health',
+    'nexus_run_status',
+    'kernel_run_step',
+    'kernel_run_verify',
+    'kernel_run_merge',
+]);
 export function buildMcpToolDefinitions() {
-    return [
+    const tools = [
         // ── Memory ────────────────────────────────────────────────────────
         {
             name: 'nexus_store_memory',
@@ -1048,7 +1066,71 @@ export function buildMcpToolDefinitions() {
                 },
             },
         },
+        {
+            name: 'kernel_run_step',
+            description: 'Run a mutation step inside an isolated git worktree and record it in the kernel ledger. Returns worktreeRef, commitSha, changedFiles. Merge requires a subsequent kernel_run_verify.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    runId: { type: 'string' },
+                    stepId: { type: 'string' },
+                    task: { type: 'string' },
+                    intent: { type: 'string' },
+                    baseRef: { type: 'string', description: 'Ref/branch/sha to branch off. Defaults to HEAD.' },
+                    worktreeHintRef: { type: 'string', description: 'Optional branch label override.' },
+                    mutations: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                kind: { type: 'string', enum: ['write_file', 'append_file', 'delete_file', 'run_command'] },
+                                path: { type: 'string' },
+                                content: { type: 'string' },
+                                command: { type: 'string' },
+                                cwd: { type: 'string' },
+                            },
+                            required: ['kind'],
+                        },
+                    },
+                    metadata: { type: 'object' },
+                },
+                required: ['runId', 'stepId', 'task'],
+            },
+        },
+        {
+            name: 'kernel_run_verify',
+            description: 'Hash the files changed by a kernel step and optionally run registered verifiers. Records the snapshot used to detect stale-verify at merge time.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    runId: { type: 'string' },
+                    stepId: { type: 'string' },
+                    verifierIds: { type: 'array', items: { type: 'string' } },
+                    metadata: { type: 'object' },
+                },
+                required: ['runId', 'stepId'],
+            },
+        },
+        {
+            name: 'kernel_run_merge',
+            description: 'Fast-forward targetRef to a verified kernel step. Rejects when verify is missing, failed, or stale.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    runId: { type: 'string' },
+                    stepId: { type: 'string' },
+                    verifyId: { type: 'string', description: 'Explicit verify pin. If omitted, latest passed verify is used.' },
+                    targetRef: { type: 'string' },
+                    reason: { type: 'string' },
+                    metadata: { type: 'object' },
+                },
+                required: ['runId', 'stepId', 'targetRef'],
+            },
+        },
         // ── Embedded capabilities (auto-detected from installed skills) ──
         ...getGstackBridge().getToolDefinitions(),
     ];
+    return tools.map((tool) => FIRST_CLASS_TOOLS.has(tool.name)
+        ? tool
+        : { ...tool, deprecated: true, deprecatedReplacement: tool.deprecatedReplacement ?? 'nexus_orchestrate' });
 }

package/dist/agents/adapters/mcp/handlers/governance.js

@@ -3,7 +3,8 @@
  * graph_query, hypertune_max.
  * Extracted from mcp.ts (Phase 3 split).
  */
-import { formatBullets, formatJsonDetails, getTokenEngine, getGraphEngine, getTraversalEngine, getHybridRetriever, } from '../helpers.js';
+import { formatBullets, formatJsonDetails, getGraphEngine, getTraversalEngine, getHybridRetriever, } from '../helpers.js';
+import { getTokenEngine } from '../util/token-engine.js';
 import { nexusEventBus } from '../../../../engines/event-bus.js';
 import { formatBrandedResponse } from '../../../../engines/nexus-brand.js';
 import { formatReadingPlan } from '../../../../engines/token-supremacy.js';
@@ -289,7 +290,7 @@ export async function handleGovernanceGroup(toolName, hctx, request, args, ctx)
                     return { path: resolved, sizeBytes: 0 };
                 }
             })))).filter((f) => f.sizeBytes > 0);
-            const { plan, assembly, budgetConfig } = getTokenEngine().hypertuneMax(task, files);
+            const { plan, assembly, budgetConfig } = await getTokenEngine().hypertuneMax(task, files);
             const planText = formatReadingPlan(plan);
             const assemblyText = ContextAssembler.format(assembly, budgetConfig);
             const savings = plan.savings;

package/dist/agents/adapters/mcp/handlers/memory.js

@@ -7,7 +7,6 @@
 import { formatBullets, formatJsonDetails } from '../helpers.js';
 import { nexusEventBus } from '../../../../engines/event-bus.js';
 import { getOperativeJournal } from '../../../../engines/operative-journal.js';
-import { storeToolSummary } from '../util/auto-memory.js';
 import { requireRuntime } from '../util/require-runtime.js';
 import { nxlResult } from '../../../../nxl/index.js';
 import { consolidateMemory } from '../../../../engines/memory-consolidator.js';
@@ -368,9 +367,15 @@ export async function handleMemoryGroup(toolName, hctx, request, args, ctx) {
                 states,
                 auditLimit: limit,
             });
-            // Record hygiene sweep so dashboard memory view shows recent housekeeping.
+            // Surface hygiene-sweep on the SSE feed; do not persist as a memory.
             try {
-                storeToolSummary(hctx, 'nexus_memory_hygiene', `Hygiene sweep (${mode}): scanned ${result.audit.scanned}, purge-eligible ${result.health.purgeEligible}, quarantined ${result.health.quarantineBacklog}.`);
+                nexusEventBus.emit('memory.snapshot', {
+                    kind: 'hygiene-sweep',
+                    mode,
+                    scanned: result.audit.scanned,
+                    purgeEligible: result.health.purgeEligible,
+                    quarantineBacklog: result.health.quarantineBacklog,
+                });
             }
             catch { /* best-effort */ }
             return {

package/dist/agents/adapters/mcp/handlers/orchestration.js

@@ -3,7 +3,8 @@
  * mindkit_check, ghost_pass, spawn_workers, session_dna, plan_execution.
  * Extracted from mcp.ts (Phase 3 split).
  */
-import { normalizeDetailLevel, normalizeBootstrapDepth, normalizeResponseIntent, normalizeResponseTopology, buildWorkspaceEnvelope, formatBullets, formatJsonDetails, getTokenEngine, getGuardrailEngine, truncateText, } from '../helpers.js';
+import { normalizeDetailLevel, normalizeBootstrapDepth, normalizeResponseIntent, normalizeResponseTopology, buildWorkspaceEnvelope, formatBullets, formatJsonDetails, getGuardrailEngine, truncateText, } from '../helpers.js';
+import { getTokenEngine } from '../util/token-engine.js';
 import { nexusEventBus } from '../../../../engines/event-bus.js';
 import { formatBrandedResponse, getRandomQuote } from '../../../../engines/nexus-brand.js';
 import { hasValidBootstrapReceipt } from '../../../../engines/bootstrap/index.js';
@@ -16,7 +17,6 @@ import { promises as fsPromises } from 'fs';
 import { getSharedLicenseManager } from '../../../../licensing/index.js';
 import { SessionDNAManager } from '../../../../engines/session-dna.js';
 import { getSharedTelemetry } from '../../../../engines/telemetry-remote.js';
-import { storeToolSummary } from '../util/auto-memory.js';
 import { requireRuntime } from '../util/require-runtime.js';
 import { ensureCrGraphBuilt } from '../../../../engines/code-review-graph-client.js';
 import { recordFirstBootstrap } from '../../../../engines/telemetry.js';
@@ -136,10 +136,16 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 ctx.meta.repoRoot = workspace.repoRoot;
                 ctx.meta.repoName = workspace.repoName;
             }
-            // Auto-generate a project-scoped memory on bootstrap so dashboard always has something to show.
-            // Priority 0.4 (via storeToolSummary) ensures it passes the SSE noise filter (threshold: 0.3).
+            // Surface a session-bootstrap signal on the SSE feed without polluting persistent
+            // memory. Audit-log content like "Session bootstrap: ..." was previously stored as
+            // a real memory (priority 0.4) which dominated recall results and forced low-signal
+            // memories into hippocampus.
             try {
-                storeToolSummary(hctx, 'nexus_session_bootstrap', `Session bootstrap: ${bootstrapGoal || 'interactive session'}. Memory: prefrontal=${bootstrap.memoryStats?.prefrontal ?? 0}, hippocampus=${bootstrap.memoryStats?.hippocampus ?? 0}, cortex=${bootstrap.memoryStats?.cortex ?? 0}.`);
+                nexusEventBus.emit('memory.snapshot', {
+                    kind: 'session-bootstrap',
+                    goal: bootstrapGoal || 'interactive session',
+                    memoryStats: bootstrap.memoryStats,
+                });
             }
             catch (err) {
                 nexusEventBus.emit('mcp.handler.best-effort-failed', { toolName, stage: 'persist-session-summary', error: err instanceof Error ? err.message : String(err) });
@@ -411,7 +417,10 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     result.modifiedFiles.forEach((file) => hctx.sessionDNA.recordFileModified(file));
                 });
                 const runtimeUsage = hctx.getRuntime().getUsageSnapshot();
-                hctx.sessionDNA.recordDecision('Orchestrated autonomous run completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.95 : execution.state === 'rolled_back' ? 0.55 : 0.3);
+                hctx.sessionDNA.recordDecision('Orchestrated autonomous run completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.95
+                    : execution.state === 'inspected' ? 0.85
+                        : execution.state === 'rolled_back' ? 0.55
+                            : 0.3);
                 const timings = {
                     totalMs: Date.now() - callStartedAt,
                 };
@@ -738,10 +747,14 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 ? String(request.params.arguments.executionPreset)
                 : undefined;
             const preset = resolveExecutionPreset(executionPreset);
-            // Record worker plan intent before execution so the dashboard memory view
-            // shows something even if the run is still in progress.
+            // Surface worker-plan intent on the SSE feed without persisting it as a memory.
             try {
-                storeToolSummary(hctx, 'nexus_spawn_workers', `Worker plan: "${goal.slice(0, 100)}" — ${workersCount} workers, ${rawFiles.length} files.`);
+                nexusEventBus.emit('memory.snapshot', {
+                    kind: 'worker-plan',
+                    goal: goal.slice(0, 100),
+                    workers: workersCount,
+                    files: rawFiles.length,
+                });
             }
             catch (err) {
                 nexusEventBus.emit('mcp.handler.best-effort-failed', { toolName, stage: 'worker-plan-summary', error: err instanceof Error ? err.message : String(err) });
@@ -775,7 +788,10 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             execution.workerResults.forEach(result => {
                 result.modifiedFiles.forEach(file => hctx.sessionDNA.recordFileModified(file));
             });
-            hctx.sessionDNA.recordDecision('Runtime swarm execution completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.94 : execution.state === 'rolled_back' ? 0.45 : 0.3);
+            hctx.sessionDNA.recordDecision('Runtime swarm execution completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.94
+                : execution.state === 'inspected' ? 0.85
+                    : execution.state === 'rolled_back' ? 0.45
+                        : 0.3);
             hctx.nexusRef.storeMemory(`Runtime swarm: state=${execution.state}, workers=${execution.workerResults.length}, verified=${verifiedWorkers}, decision=${execution.finalDecision?.action ?? 'none'}`, execution.state === 'merged' ? 0.92 : 0.72, ['#phantom', '#decision', execution.state]);
             if (execution.finalDecision) {
                 nexusEventBus.emit('phantom.merge', {
@@ -789,7 +805,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 `Workers: ${execution.workerResults.length.toString().padEnd(5, ' ')} Verified: ${verifiedWorkers.toString().padEnd(10, ' ')} Files: ${String(modifiedFiles).padEnd(12, ' ')}`,
                 `${`Preset: ${preset?.name ?? 'manual'}`.padEnd(61, ' ')}`,
                 `Decision: ${(execution.finalDecision?.action ?? 'none').padEnd(52, ' ')}`
-            ], execution.state === 'merged' ? '32' : execution.state === 'rolled_back' ? '33' : '31');
+            ], execution.state === 'merged' || execution.state === 'inspected' ? '32' : execution.state === 'rolled_back' ? '33' : '31');
             return {
                 content: [{
                         type: 'text',

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

@@ -5,7 +5,6 @@
  * These are pure functions and lazy-singleton getters shared by the
  * handler files and by MCPAdapter itself.
  */
-import { TokenSupremacyEngine } from '../../../engines/token-supremacy.js';
 import { GuardrailEngine } from '../../../engines/guardrails-bridge.js';
 import { ContinuousAttentionStream, createKVBridge, OrchestratorEngine } from '../../../engines/index.js';
 import { FederationEngine } from '../../../engines/federation.js';
@@ -14,7 +13,6 @@ import { GraphTraversalEngine } from '../../../engines/graph-traversal.js';
 import { HybridRetriever } from '../../../engines/hybrid-retriever.js';
 import type { WorkspaceContext } from '../../../engines/workspace-resolver.js';
 import type { SubAgentRuntime } from '../../../phantom/index.js';
-export declare function getTokenEngine(): TokenSupremacyEngine;
 export declare function getGuardrailEngine(): GuardrailEngine;
 export declare function getCasEngine(): ContinuousAttentionStream;
 export declare function getKvBridge(): ReturnType<typeof createKVBridge>;

package/dist/agents/adapters/mcp/helpers.js

@@ -7,7 +7,6 @@
  */
 import { statSync, readdirSync } from 'fs';
 import * as path from 'path';
-import { TokenSupremacyEngine } from '../../../engines/token-supremacy.js';
 import { GuardrailEngine } from '../../../engines/guardrails-bridge.js';
 import { ContinuousAttentionStream, createKVBridge, OrchestratorEngine, } from '../../../engines/index.js';
 import { FederationEngine } from '../../../engines/federation.js';
@@ -16,7 +15,6 @@ import { GraphTraversalEngine } from '../../../engines/graph-traversal.js';
 import { HybridRetriever } from '../../../engines/hybrid-retriever.js';
 import { createSubAgentRuntime } from '../../../phantom/index.js';
 // ─── Lazy-init engine singletons ─────────────────────────────────────────────
-let _tokenEngine;
 let _guardrailEngine;
 let _casEngine;
 let _kvBridge;
@@ -24,11 +22,6 @@ let _federation;
 let _graphEngine = null;
 let _traversalEngine = null;
 let _hybridRetriever = null;
-export function getTokenEngine() {
-    if (!_tokenEngine)
-        _tokenEngine = new TokenSupremacyEngine();
-    return _tokenEngine;
-}
 export function getGuardrailEngine() {
     if (!_guardrailEngine)
         _guardrailEngine = new GuardrailEngine();

package/dist/agents/adapters/mcp/util/token-engine.d.ts

@@ -0,0 +1,2 @@
+import { TokenSupremacyEngine } from '../../../../engines/token-supremacy.js';
+export declare function getTokenEngine(): TokenSupremacyEngine;

package/dist/agents/adapters/mcp/util/token-engine.js

@@ -0,0 +1,7 @@
+import { TokenSupremacyEngine } from '../../../../engines/token-supremacy.js';
+let tokenEngine;
+export function getTokenEngine() {
+    if (!tokenEngine)
+        tokenEngine = new TokenSupremacyEngine();
+    return tokenEngine;
+}

package/dist/agents/adapters/mcp.js

@@ -830,21 +830,22 @@ export class MCPAdapter {
                 : { error: envelope.error.message }),
         });
         this.telemetry.observeSuccessfulToolCall(toolName, args);
-        // Server-side auto-memory: write a low-priority tagged memory after every
-        // meaningful tool call so MCP clients without hooks (Codex, Cursor) still
-        // accumulate context automatically. Fire-and-forget — never delays response.
-        // The isNoiseEvent filter in sse-broker.ts drops auto-memories (priority < 0.3)
-        // from the live SSE feed, so the dashboard event stream stays clean.
+        // Surface meaningful tool calls on the SSE feed without persisting them as memories.
+        // Previously a low-priority memory was auto-stored on every non-read-only tool call,
+        // which polluted recall with audit-log entries like "nexus_store_memory: priority=0.85,
+        // tags=...". Recall now stays focused on user-stored knowledge.
         if (this.nexusRef && !isReadOnlyMcpTool(toolName)) {
             const repoRoot = this.nexusRef.getWorkspaceContext?.()?.repoRoot ?? '';
             const repoName = repoRoot ? path.basename(repoRoot) : '';
-            const summary = buildAutoMemorySummary(toolName, args);
-            setImmediate(() => {
-                try {
-                    this.nexusRef.storeMemory(summary, 0.2, ['#auto', `tool:${toolName}`, ...(repoName ? [`repo:${repoName}`] : [])], undefined, undefined, { verbatim: false });
-                }
-                catch { /* best-effort; memory engine may not be ready */ }
-            });
+            try {
+                nexusEventBus.emit('memory.snapshot', {
+                    kind: 'tool-invocation',
+                    toolName,
+                    repo: repoName,
+                    summary: buildAutoMemorySummary(toolName, args),
+                });
+            }
+            catch { /* best-effort */ }
         }
         const decorated = this.decorateLifecycleResponse(toolName, result);
         return this.injectMemoryContext(toolName, args, decorated);

package/dist/cli/hook.d.ts

@@ -16,7 +16,15 @@
  */
 /** UserPromptSubmit — call nexus_session_bootstrap so the model never has to. */
 export declare function runHookBootstrap(): Promise<void>;
-/** PostToolUse (Edit|Write|MultiEdit|Bash) — auto-write low-priority memory. */
+/**
+ * PostToolUse (Edit|Write|MultiEdit|Bash) — opt-in audit memory.
+ *
+ * Disabled by default because every Edit/Write/Bash was being stored as a
+ * low-priority memory, which polluted recall results with audit-log entries
+ * like "Edit: file_path=src/foo.ts". Real findings should be stored via
+ * nexus_store_memory by the agent itself. To opt back in, set
+ * NEXUS_HOOK_AUTO_MEMORY=1.
+ */
 export declare function runHookMemory(): Promise<void>;
 /**
  * PreToolUse (Edit|Write|MultiEdit) — governance check.

package/dist/cli/hook.js

@@ -149,8 +149,18 @@ export async function runHookBootstrap() {
         goal: goal.slice(0, 500),
     }, 10_000);
 }
-/** PostToolUse (Edit|Write|MultiEdit|Bash) — auto-write low-priority memory. */
+/**
+ * PostToolUse (Edit|Write|MultiEdit|Bash) — opt-in audit memory.
+ *
+ * Disabled by default because every Edit/Write/Bash was being stored as a
+ * low-priority memory, which polluted recall results with audit-log entries
+ * like "Edit: file_path=src/foo.ts". Real findings should be stored via
+ * nexus_store_memory by the agent itself. To opt back in, set
+ * NEXUS_HOOK_AUTO_MEMORY=1.
+ */
 export async function runHookMemory() {
+    if (process.env.NEXUS_HOOK_AUTO_MEMORY !== '1')
+        return;
     const data = await readStdinJson();
     const cwd = String(data.cwd ?? process.cwd());
     const toolName = String(data.tool_name ?? '');
@@ -163,7 +173,6 @@ export async function runHookMemory() {
     if (!lock)
         return;
     const input = (data.tool_input ?? {});
-    // Summarize input without large content blobs
     const inputSummary = Object.entries(input)
         .filter(([k]) => !['content', 'new_string', 'old_string', 'result', 'command_result'].includes(k))
         .map(([k, v]) => `${k}=${String(v).slice(0, 80)}`)

package/dist/cli/install-wizard.js

@@ -139,7 +139,10 @@ function _nexusMcpEntry(workspaceRoot) {
     return {
         command: 'node',
         args: [join(workspaceRoot, 'node_modules', 'nexus-prime', 'dist', 'cli.js'), 'mcp'],
-        env: {},
+        env: {
+            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
+            NEXUS_WORKSPACE_ROOT: workspaceRoot,
+        },
     };
 }
 /**

package/dist/cli.js

@@ -780,6 +780,14 @@ program
     .addCommand(new Command('__serve')
     .description('Internal: run the daemon server process (do not call directly)')
     .action(async () => {
+    // Opt the daemon into the deferred-bootstrap fast-start path so the
+    // dashboard port listens before the (3+ second) workspace bootstrap
+    // file I/O completes. Tests that construct NexusPrime directly do not
+    // set this flag, so their synchronous workspace-file assertions still
+    // see a fully-initialized state by the time start() resolves.
+    if (process.env.NEXUS_DAEMON_FAST_START === undefined) {
+        process.env.NEXUS_DAEMON_FAST_START = '1';
+    }
     const workspaceContext = resolveWorkspaceContext({ workspaceRoot: getWorkspaceRoot() });
     const daemon = new NexusDaemonServer(workspaceContext);
     const { started, record } = await daemon.start();
@@ -1897,6 +1905,75 @@ program
         timeoutMs: opts.timeout ? Number(opts.timeout) : undefined,
     });
 });
+program
+    .command('fix-claude-hooks')
+    .description('Strip stale Nexus hook entries from ~/.claude/settings.json (use after downgrading from a newer version)')
+    .option('--dry-run', 'Show what would change without writing')
+    .option('--workspace', 'Also clean ./.claude/settings.json in the current workspace')
+    .action(async (opts) => {
+    const fs = await import('fs');
+    const path = await import('path');
+    const os = await import('os');
+    const { NEXUS_HOOK_COMMAND_MARKER } = await import('./install/claude-code-hooks.js');
+    const targets = [path.join(os.homedir(), '.claude', 'settings.json')];
+    if (opts.workspace)
+        targets.push(path.join(process.cwd(), '.claude', 'settings.json'));
+    let totalRemoved = 0;
+    for (const target of targets) {
+        if (!fs.existsSync(target)) {
+            console.log(`  skip: ${target} (not found)`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(target, 'utf8'));
+        }
+        catch (err) {
+            console.error(`  error: ${target} (invalid JSON: ${err instanceof Error ? err.message : String(err)})`);
+            continue;
+        }
+        const hooks = parsed?.hooks;
+        if (!hooks || typeof hooks !== 'object') {
+            console.log(`  ok: ${target} (no hooks block)`);
+            continue;
+        }
+        let removedHere = 0;
+        for (const event of Object.keys(hooks)) {
+            if (!Array.isArray(hooks[event]))
+                continue;
+            const before = hooks[event];
+            const after = before.filter((entry) => {
+                const entryHooks = entry?.hooks;
+                if (!Array.isArray(entryHooks))
+                    return true;
+                const hasNexus = entryHooks.some((h) => typeof h?.command === 'string' && h.command.trimStart().startsWith(NEXUS_HOOK_COMMAND_MARKER));
+                if (hasNexus)
+                    removedHere += 1;
+                return !hasNexus;
+            });
+            if (after.length === 0) {
+                delete hooks[event];
+            }
+            else {
+                hooks[event] = after;
+            }
+        }
+        if (Object.keys(hooks).length === 0)
+            delete parsed.hooks;
+        totalRemoved += removedHere;
+        if (removedHere === 0) {
+            console.log(`  ok: ${target} (no Nexus entries)`);
+            continue;
+        }
+        if (opts.dryRun) {
+            console.log(`  dry-run: ${target} would remove ${removedHere} Nexus hook entry/entries`);
+            continue;
+        }
+        fs.writeFileSync(target, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
+        console.log(`  fixed: ${target} (removed ${removedHere} entry/entries)`);
+    }
+    console.log(opts.dryRun ? `\nDry-run total: ${totalRemoved} entry/entries.` : `\nDone. Removed ${totalRemoved} stale Nexus hook entry/entries.`);
+});
 program
     .command('watch')
     .description('Tail live SSE events from the running daemon in a colored terminal feed')
@@ -1915,4 +1992,26 @@ program
 if (process.argv.length === 2) {
     process.argv.push('setup', 'auto');
 }
-program.parse();
+// Graceful fallback for unknown `nexus-prime hook <subcommand>` invocations.
+// When users downgrade from a version that wrote hook entries to
+// ~/.claude/settings.json, the older binary may not have the referenced
+// subcommand. Exiting non-zero would fail every Claude Code session start.
+// Drain piped stdin (Claude pipes JSON into hooks) and exit 0 silently.
+const KNOWN_HOOK_SUBCOMMANDS = new Set([
+    'bootstrap', 'memory', 'mindkit', 'ghost-pass', 'session-dna',
+    'generate', 'deploy', 'undeploy', 'list', 'help', '--help', '-h',
+]);
+if (process.argv[2] === 'hook' && process.argv[3] && !KNOWN_HOOK_SUBCOMMANDS.has(process.argv[3])) {
+    if (!process.stdin.isTTY) {
+        process.stdin.resume();
+        process.stdin.on('data', () => { });
+        process.stdin.on('end', () => process.exit(0));
+        setTimeout(() => process.exit(0), 200).unref();
+    }
+    else {
+        process.exit(0);
+    }
+}
+else {
+    program.parse();
+}

package/dist/daemon/server.js

@@ -185,14 +185,13 @@ export class NexusDaemonServer {
             },
         });
         await this.nexus.start();
-        // Pre-warm the n-gram repo-search index so the first nexus_orchestrate
-        // / nexus_optimize_tokens call doesn't pay the cold-build cost (Codex
-        // hard-codes a 120s tool-call timeout). setImmediate keeps it off the
-        // accept loop. Failures are deliberately swallowed — the on-demand path
-        // will rebuild the index if pre-warm fails.
-        setImmediate(() => {
-            void this.nexus?.getOrchestrator().warmRepoSearchIndex().catch(() => { });
-        });
+        // Optional repo-search prewarm. It can be CPU-heavy in large workspaces, so
+        // keep daemon startup and dashboard responsiveness as the default behavior.
+        if (process.env.NEXUS_PREWARM_REPO_SEARCH === '1' && this.workspace.gitRoot) {
+            setImmediate(() => {
+                void this.nexus?.getOrchestrator().warmRepoSearchIndex().catch(() => { });
+            });
+        }
         // Warm the invoker availability cache so /api/runtimes returns fast and
         // the dashboard runtime badges render immediately on first load.
         setImmediate(() => { invokerRegistry.warmCache(); });