nexus-prime 7.9.9 → 7.9.10

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

@@ -7,17 +7,11 @@
 import { existsSync } from 'fs';
 import { homedir } from 'os';
 import { dirname, join, resolve } from 'path';
+import { buildNexusMcpServerConfig } from '../../engines/mcp-entrypoint.js';
 let callerIDECache;
 /** Nexus Prime MCP server entry (stdio transport). */
 function nexusMcpServerEntry(workspaceRoot) {
-    return {
-        command: 'node',
-        args: [join(workspaceRoot, 'node_modules', 'nexus-prime', 'dist', 'cli.js'), 'mcp'],
-        env: {
-            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
-            NEXUS_WORKSPACE_ROOT: workspaceRoot,
-        },
-    };
+    return buildNexusMcpServerConfig(workspaceRoot);
 }
 function hasAnyEnvPrefix(prefix) {
     return Object.keys(process.env).some((key) => key.startsWith(prefix));

package/dist/cli/install-wizard.js

@@ -11,6 +11,7 @@ import { dirname, join, resolve } from 'path';
 import { detectInstalledIDEs, getMcpConfigForIDE } from '../agents/adapters/ide-compat.js';
 import { DEFAULT_DAEMON_READY_TIMEOUT_MS, ensureDaemonReady } from '../daemon/client.js';
 import { getSetupDefinition, installSetup } from '../engines/client-bootstrap.js';
+import { buildNexusMcpServerConfig } from '../engines/mcp-entrypoint.js';
 import { resolveNexusStateDir } from '../engines/runtime-registry.js';
 import { resolveWorkspaceContext } from '../engines/workspace-resolver.js';
 import { runPostinstallCleanup } from '../postinstall/cleanup.js';
@@ -136,14 +137,7 @@ export async function configureIDE(ide, opts = {}) {
 }
 /** Nexus Prime MCP server entry used in workspace-local config writes. */
 function _nexusMcpEntry(workspaceRoot) {
-    return {
-        command: 'node',
-        args: [join(workspaceRoot, 'node_modules', 'nexus-prime', 'dist', 'cli.js'), 'mcp'],
-        env: {
-            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
-            NEXUS_WORKSPACE_ROOT: workspaceRoot,
-        },
-    };
+    return buildNexusMcpServerConfig(workspaceRoot);
 }
 /**
  * Write Claude Code PreToolUse/PostToolUse/UserPromptSubmit/Stop hooks to
@@ -379,18 +373,15 @@ function mergeIntoExistingConfig(configPath, newContent, ide) {
 }
 /** Print how to add nexus-prime manually to an MCP client. */
 export function printManualMcpInstructions() {
+    const server = buildNexusMcpServerConfig(process.cwd());
     const snippet = JSON.stringify({
         mcpServers: {
-            'nexus-prime': {
-                command: 'node',
-                args: ['node_modules/nexus-prime/dist/cli.js', 'mcp'],
-                env: {},
-            },
+            'nexus-prime': server,
         },
     }, null, 2);
     process.stdout.write('\n  Add this to your IDE\'s MCP configuration:\n\n');
     process.stdout.write(snippet.split('\n').map(l => `    ${l}`).join('\n') + '\n\n');
-    process.stdout.write('  Or run:  npx nexus-prime@latest setup\n\n');
+    process.stdout.write('  Or run:  nexus-prime setup\n\n');
 }
 /** Entry point for CLI: nexus-prime install / setup auto */
 export async function cliSetup(opts = []) {

package/dist/cli.js

@@ -18,6 +18,7 @@ import { InstructionGateway } from './engines/instruction-gateway.js';
 import { ensureBootstrap, collectBootstrapManifest, validateTargetPath, resolveCodexConfigPath, renderCodexMcpTomlConfig, writeCodexMcpConfig, hasExpectedCodexConfig, } from './engines/client-bootstrap.js';
 import { resolveNexusStateDir } from './engines/runtime-registry.js';
 import { runStartupHygiene } from './engines/runtime-hygiene.js';
+import { buildNexusMcpServerConfig, isStableNexusMcpServerConfig } from './engines/mcp-entrypoint.js';
 import { SessionDNAManager } from './engines/session-dna.js';
 import { nexusEventBus } from './engines/event-bus.js';
 import { buildRuntimeSetupCommand } from './cli-setup.js';
@@ -189,14 +190,7 @@ function readJson(targetPath) {
     }
 }
 function buildStandardMcpServerConfig(workspaceRoot) {
-    return {
-        command: 'npx',
-        args: ['-y', 'nexus-prime', 'mcp'],
-        env: {
-            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
-            ...(workspaceRoot ? { NEXUS_WORKSPACE_ROOT: workspaceRoot } : {}),
-        }
-    };
+    return buildNexusMcpServerConfig(workspaceRoot);
 }
 function writeStandardMcpConfig(targetPath, workspaceRoot) {
     const existing = readJson(targetPath);
@@ -207,13 +201,13 @@ function writeStandardMcpConfig(targetPath, workspaceRoot) {
 }
 function writeOpencodeConfig(targetPath, workspaceRoot) {
     const existing = readJson(targetPath);
+    const mcpConfig = buildStandardMcpServerConfig(workspaceRoot);
     const server = {
         type: 'local',
-        command: 'npx',
-        args: ['-y', 'nexus-prime', 'mcp'],
+        command: mcpConfig.command,
+        args: mcpConfig.args,
         environment: {
-            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
-            ...(workspaceRoot ? { NEXUS_WORKSPACE_ROOT: workspaceRoot } : {}),
+            ...mcpConfig.env,
         }
     };
     existing.mcp = existing.mcp ?? {};
@@ -251,21 +245,19 @@ function mergeCodexAgentsContent(existingContent, content) {
     const endIndex = existing.indexOf(CODEX_MANAGED_END);
     if (startIndex >= 0 && endIndex > startIndex) {
         const before = existing.slice(0, startIndex).trimEnd();
-        const after = existing.slice(endIndex + CODEX_MANAGED_END.length).trimStart();
+        const after = existing.slice(endIndex + CODEX_MANAGED_END.length).trim();
         return [
             before,
             before ? '' : undefined,
             managedBlock,
             after ? '' : undefined,
             after,
-            '',
         ].filter((value) => value !== undefined).join('\n');
     }
     return [
         existing.trimEnd(),
         '',
         managedBlock,
-        '',
     ].join('\n');
 }
 function hasCurrentCodexManagedBlock(targetPath, content) {
@@ -301,17 +293,16 @@ function mergeClaudeContent(existingContent, content) {
     const endIndex = existing.indexOf(CLAUDE_MANAGED_END);
     if (startIndex >= 0 && endIndex > startIndex) {
         const before = existing.slice(0, startIndex).trimEnd();
-        const after = existing.slice(endIndex + CLAUDE_MANAGED_END.length).trimStart();
+        const after = existing.slice(endIndex + CLAUDE_MANAGED_END.length).trim();
         return [
             before,
             before ? '' : undefined,
             managedBlock,
             after ? '' : undefined,
             after,
-            '',
         ].filter((value) => value !== undefined).join('\n');
     }
-    return [existing.trimEnd(), '', managedBlock, ''].join('\n');
+    return [existing.trimEnd(), '', managedBlock].join('\n');
 }
 function hasCurrentClaudeManagedBlock(targetPath, content) {
     if (!existsSync(targetPath))
@@ -346,17 +337,16 @@ function mergeClinerules(existingContent, content) {
     const endIndex = existing.indexOf(CLINE_MANAGED_END);
     if (startIndex >= 0 && endIndex > startIndex) {
         const before = existing.slice(0, startIndex).trimEnd();
-        const after = existing.slice(endIndex + CLINE_MANAGED_END.length).trimStart();
+        const after = existing.slice(endIndex + CLINE_MANAGED_END.length).trim();
         return [
             before,
             before ? '' : undefined,
             managedBlock,
             after ? '' : undefined,
             after,
-            '',
         ].filter((value) => value !== undefined).join('\n');
     }
-    return [existing.trimEnd(), '', managedBlock, ''].join('\n');
+    return [existing.trimEnd(), '', managedBlock].join('\n');
 }
 function hasCurrentClineManagedBlock(targetPath, content) {
     if (!existsSync(targetPath))
@@ -591,12 +581,10 @@ function hasExpectedConfig(definition) {
         const parsed = JSON.parse(readFileSync(definition.configPath, 'utf8'));
         if (definition.id === 'opencode') {
             const server = parsed?.mcp?.['nexus-prime'];
-            return Boolean(server
-                && server?.environment?.NEXUS_MCP_TOOL_PROFILE === 'autonomous');
+            return Boolean(server && isStableNexusMcpServerConfig(server, 'environment'));
         }
         const server = parsed?.mcpServers?.['nexus-prime'];
-        return Boolean(server
-            && server?.env?.NEXUS_MCP_TOOL_PROFILE === 'autonomous');
+        return Boolean(server && isStableNexusMcpServerConfig(server));
     }
     catch {
         return false;
@@ -825,7 +813,8 @@ program
     const workspaceContext = resolveWorkspaceContext({ workspaceRoot: getWorkspaceRoot() });
     const caller = detectCallerIDE();
     const marker = readSetupMarker();
-    if (caller) {
+    const autoConfigEnabled = process.env.NEXUS_MCP_AUTO_CONFIG === '1';
+    if (caller && autoConfigEnabled) {
         const isConfigured = marker?.configuredIDEs?.includes(caller) ?? false;
         const storedHash = marker?.writtenHash?.[caller];
         if (isConfigured && storedHash !== undefined) {
@@ -879,6 +868,10 @@ program
         }
     }
     // Try daemon-backed proxy first unless --standalone is passed
+    const parsedDaemonTimeout = Number(process.env.NEXUS_MCP_DAEMON_TIMEOUT_MS ?? 5000);
+    const mcpDaemonTimeoutMs = Number.isFinite(parsedDaemonTimeout)
+        ? Math.max(1000, Math.min(parsedDaemonTimeout, 15000))
+        : 5000;
     if (!options.standalone) {
         try {
             const status = await getDaemonStatus(workspaceContext);
@@ -886,6 +879,7 @@ program
                 console.error('Connecting to Nexus Prime daemon...');
                 await startDaemonBackedMcpProxy(workspaceContext, {
                     entrypoint: getCliEntrypoint(),
+                    timeoutMs: mcpDaemonTimeoutMs,
                 });
                 return;
             }
@@ -900,9 +894,11 @@ program
                 try {
                     await ensureDaemonReady(workspaceContext, {
                         entrypoint: getCliEntrypoint(),
+                        timeoutMs: mcpDaemonTimeoutMs,
                     });
                     await startDaemonBackedMcpProxy(workspaceContext, {
                         entrypoint: getCliEntrypoint(),
+                        timeoutMs: mcpDaemonTimeoutMs,
                     });
                     return;
                 }

package/dist/daemon/proxy.d.ts

@@ -1,4 +1,5 @@
 import type { WorkspaceContext } from '../engines/workspace-resolver.js';
 export declare function startDaemonBackedMcpProxy(workspace: WorkspaceContext, options?: {
     entrypoint?: string;
+    timeoutMs?: number;
 }): Promise<void>;

package/dist/daemon/proxy.js

@@ -3,12 +3,15 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { daemonRequest, ensureDaemonReady, } from './client.js';
-async function withDaemonRetry(workspace, daemonRef, entrypoint, operation) {
+async function withDaemonRetry(workspace, daemonRef, options, operation) {
     try {
         return await operation(daemonRef.current);
     }
     catch {
-        daemonRef.current = await ensureDaemonReady(workspace, { entrypoint });
+        daemonRef.current = await ensureDaemonReady(workspace, {
+            entrypoint: options.entrypoint,
+            timeoutMs: options.timeoutMs,
+        });
         return operation(daemonRef.current);
     }
 }
@@ -16,18 +19,19 @@ export async function startDaemonBackedMcpProxy(workspace, options = {}) {
     const daemonRef = {
         current: await ensureDaemonReady(workspace, {
             entrypoint: options.entrypoint,
+            timeoutMs: options.timeoutMs,
         }),
     };
     const sessionId = randomUUID();
     const server = new Server({ name: 'nexus-prime-mcp-proxy', version: '0.1.0' }, { capabilities: { tools: {} } });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        const payload = await withDaemonRetry(workspace, daemonRef, options.entrypoint, (record) => daemonRequest(record, '/rpc/list-tools', { sessionId }));
+        const payload = await withDaemonRetry(workspace, daemonRef, options, (record) => daemonRequest(record, '/rpc/list-tools', { sessionId }));
         return {
             tools: payload.tools,
         };
     });
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const payload = await withDaemonRetry(workspace, daemonRef, options.entrypoint, (record) => daemonRequest(record, '/rpc/call-tool', {
+        const payload = await withDaemonRetry(workspace, daemonRef, options, (record) => daemonRequest(record, '/rpc/call-tool', {
             sessionId,
             name: request.params?.name,
             arguments: request.params?.arguments ?? {},

package/dist/dashboard/app/api.js

@@ -9,21 +9,35 @@ import { CACHE_TTL, S, bus } from './state.js';
 
 const _cache = new Map();
 
+function _scopedUrl(url) {
+    if (typeof url !== 'string' || !url.startsWith('/api/')) return url;
+    const runtimeId = S.scope?.runtimeId;
+    if (!runtimeId) return url;
+    try {
+        const scoped = new URL(url, window.location.origin);
+        if (!scoped.searchParams.has('runtimeId')) scoped.searchParams.set('runtimeId', runtimeId);
+        return scoped.pathname + scoped.search + scoped.hash;
+    } catch {
+        return url;
+    }
+}
+
 /**
  * GET with SWR semantics: return cached data immediately (if within TTL),
  * then kick off a background refresh.  Callers get the fast synchronous hit
  * for p50 <5ms; the next render cycle gets the fresh value.
  */
 export async function api(url, ttl = CACHE_TTL) {
-    const hit = _cache.get(url);
+    const requestUrl = _scopedUrl(url);
+    const hit = _cache.get(requestUrl);
     const fresh = !hit || (Date.now() - hit.ts >= ttl);
 
     // Return stale data synchronously while refresh fires in background.
-    const refreshPromise = fresh ? _fetch(url) : Promise.resolve(hit.data);
+    const refreshPromise = fresh ? _fetch(requestUrl) : Promise.resolve(hit.data);
 
     if (hit && !fresh) {
         // Background refresh — don't await, just schedule.
-        _fetch(url).catch(() => {});
+        _fetch(requestUrl).catch(() => {});
     }
 
     return refreshPromise;
@@ -52,9 +66,10 @@ async function _fetch(url) {
  */
 export async function post(url, body, opts = {}) {
     const { optimistic } = opts;
+    const requestUrl = _scopedUrl(url);
     // If an optimistic record is provided, return it right away and let the
     // caller reconcile once the real response arrives.
-    const req = fetch(url, {
+    const req = fetch(requestUrl, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
@@ -77,7 +92,7 @@ export async function post(url, body, opts = {}) {
     if (optimistic !== undefined) {
         // Return immediately with optimistic data; the caller can await the
         // real result separately if it needs to reconcile.
-        req.then((real) => { if (!real.ok) bus.emit('post:optimistic-fail', { url, error: real.error }); });
+        req.then((real) => { if (!real.ok) bus.emit('post:optimistic-fail', { url: requestUrl, error: real.error }); });
         return { ok: true, data: optimistic, error: null, status: 202, realResponse: req };
     }
     return req;
@@ -86,6 +101,8 @@ export async function post(url, body, opts = {}) {
 /** Invalidate a cached URL so the next api() call fetches fresh. */
 export function bustCache(url) {
     _cache.delete(url);
+    const scoped = _scopedUrl(url);
+    if (scoped !== url) _cache.delete(scoped);
 }
 
 /** Clear the entire cache (e.g. after an SSE reconnect). */
@@ -122,6 +139,15 @@ export function notifyNotReady(payloads) {
     for (const p of payloads) {
         if (!p || typeof p !== 'object' || !p.notReady) continue;
         const code = String(p.pillar || 'pillar') + '-not-ready';
-        pushSystemError(code, p.reason || 'runtime not attached', undefined);
+        const reason = String(p.reason || '');
+        const optionalIdleRuntime = /not attached|not initiali[sz]ed|deferred|lazy/i.test(reason)
+            && !p.error
+            && !p.fatal
+            && !p.severity;
+        if (optionalIdleRuntime) {
+            clearSystemError(code);
+            continue;
+        }
+        pushSystemError(code, reason || 'runtime not attached', undefined);
     }
 }

package/dist/dashboard/app/index.html

@@ -185,6 +185,10 @@ if(location.protocol==='file:'){
         <div class="shd">Promotion history</div>
         <div class="card" style="margin-bottom:14px"><div id="mem-promotion-ticker" class="mem-promotion-ticker"></div></div>
 
+        <div class="memory-toolbar">
+          <button class="btn btn-sm" id="mem-graph-max-btn">Maximize graph</button>
+          <button class="btn btn-sm" id="mem-browse-btn">Browse memories</button>
+        </div>
         <div id="graph-container" class="card">
           <svg id="graph-svg"></svg>
           <div class="graph-legend">
@@ -208,6 +212,7 @@ if(location.protocol==='file:'){
           <div class="card">
             <div class="mem-search-row">
               <input id="mem-search" type="text" placeholder="Search memories…" aria-label="Search memories">
+              <button class="btn btn-sm" id="mem-list-browse-btn">Browse</button>
             </div>
             <div id="mem-list"></div>
           </div>

package/dist/dashboard/app/main.js

@@ -4,7 +4,7 @@
  */
 
 import { S, bus }                from './state.js';
-import { api, post, bustCache }   from './api.js';
+import { api, bustCache, clearCache } from './api.js';
 import { connect as connectSSE,
          setOnEvent }             from './sse.js';
 import { register as navRegister,
@@ -30,7 +30,9 @@ const esc = s => s==null?'':String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;')
 let memoryReloadTimer = null;
 
 function _memoryApiUrl() {
-    return S.workspace?.repoName ? '/api/memory?repo='+encodeURIComponent(S.workspace.repoName) : '/api/memory';
+    const params = new URLSearchParams({ includeInactive: 'true', limit: '100' });
+    if (S.workspace?.repoName) params.set('repo', S.workspace.repoName);
+    return '/api/memory?' + params.toString();
 }
 
 function _refreshMemorySoon() {
@@ -170,25 +172,57 @@ function _fmtBytes(n) {
 }
 
 async function loadProjects() {
-    const d = await api('/api/memory/projects', 30000);
-    S.projects = Array.isArray(d) ? d : (d?.projects||[]);
+    const [projectsD, runtimesD] = await Promise.all([
+        api('/api/memory/projects', 30000),
+        api('/api/runtimes', 10000),
+    ]);
+    S.projects = Array.isArray(projectsD) ? projectsD : (projectsD?.projects||[]);
+    S.runtimes = Array.isArray(runtimesD) ? runtimesD : (runtimesD?.runtimes||[]);
+    _selectDefaultRuntime();
     _renderProjectSelectors();
 }
 
 async function loadCompanies() {
     const d = await api('/api/workforce/companies', 30000);
     const companies = Array.isArray(d?.companies) ? d.companies : [];
-    const sel = $('ctx-project'); if (!sel) return;
-    if (companies.length === 0) return;
-    sel.innerHTML = '<option value="">All companies</option>' +
-        companies.map(c=>`<option value="${esc(c)}">${esc(c)}</option>`).join('');
-    sel.onchange = () => { S.company = sel.value || undefined; bustCache('/api/workforce/kanban'); bustCache('/api/workforce/workers'); bustCache('/api/workforce/jobs'); };
+    S.companies = companies;
 }
 
 function _renderProjectSelectors() {
     const sel = $('ctx-project'); if (!sel) return;
-    sel.innerHTML = '<option value="">All projects</option>' +
-        S.projects.map(p=>`<option value="${esc(p.id||p.projectId)}">${esc(p.name||p.id||'Project')}</option>`).join('');
+    const runtimeOptions = (S.runtimes||[]).map(r => {
+        const id = r.runtimeId || '';
+        const repo = r.repoIdentity || {};
+        const label = repo.repoName || repo.repoRoot || id || 'runtime';
+        const suffix = r.lastHeartbeatAt ? ' · runtime' : '';
+        return `<option value="runtime:${esc(id)}">${esc(label + suffix)}</option>`;
+    }).join('');
+    const projectOptions = S.projects.map(p=>`<option value="project:${esc(p.id||p.projectId)}">${esc(p.name||p.id||'Project')}</option>`).join('');
+    sel.innerHTML = '<option value="">All projects</option>' + runtimeOptions + projectOptions;
+    if (S.scope.runtimeId) sel.value = `runtime:${S.scope.runtimeId}`;
+    else if (S.scope.projectId) sel.value = `project:${S.scope.projectId}`;
+}
+
+function _selectDefaultRuntime() {
+    if (S.scope.runtimeId || !(S.runtimes||[]).length) return;
+    const current = S.workspace?.repoRoot || S.workspace?.workspaceRoot || '';
+    const candidates = (S.runtimes||[]).filter(r => r?.runtimeId);
+    const exact = current ? candidates.find(r => r.repoIdentity?.repoRoot === current) : null;
+    const currentLooksLikeHome = exact
+        && !exact.repoIdentity?.remoteUrl
+        && String(exact.repoIdentity?.repoRoot || '').split('/').filter(Boolean).length <= 2
+        && candidates.length > 1;
+    const remoteRepo = candidates.find(r => r.repoIdentity?.remoteUrl && r.repoIdentity?.repoName !== 'brew');
+    const deepestRepo = [...candidates].sort((a, b) => {
+        const depthA = String(a.repoIdentity?.repoRoot || '').split('/').filter(Boolean).length;
+        const depthB = String(b.repoIdentity?.repoRoot || '').split('/').filter(Boolean).length;
+        return depthB - depthA;
+    }).find(r => {
+        const root = r.repoIdentity?.repoRoot || '';
+        return root && root !== '/';
+    });
+    const selected = (exact && !currentLooksLikeHome ? exact : null) || remoteRepo || deepestRepo || candidates[0];
+    S.scope.runtimeId = selected?.runtimeId || null;
 }
 
 /* ─────────────────── Header / ticker ─────────────────── */
@@ -233,9 +267,18 @@ function _attachHandlers() {
     Memory.init();
 
     // Context selectors
-    $('ctx-project')?.addEventListener('change', e => {
-        S.scope.projectId = e.target.value || null;
-        const mp = $('mem-project-filter'); if (mp) mp.value = e.target.value;
+    $('ctx-project')?.addEventListener('change', async e => {
+        const value = e.target.value || '';
+        if (value.startsWith('runtime:')) {
+            S.scope.runtimeId = value.slice('runtime:'.length) || null;
+            S.scope.projectId = null;
+            clearCache();
+            await loadWorkspace();
+            await loadRepoTree();
+        } else {
+            S.scope.projectId = value.startsWith('project:') ? value.slice('project:'.length) : (value || null);
+        }
+        const mp = $('mem-project-filter'); if (mp) mp.value = S.scope.projectId || '';
         _reloadTab(S.tab);
     });
     $('ctx-agent')?.addEventListener('change', e => {
@@ -274,7 +317,8 @@ async function _sendChat() {
     const uEl=document.createElement('div'); uEl.className='chat-msg user'; uEl.textContent=text; msgs.appendChild(uEl); msgs.scrollTop=msgs.scrollHeight;
     const sendBtn = $('chat-send-btn'); if (sendBtn) sendBtn.disabled=true;
     try {
-        const res = await fetch('/api/runtime/execute',{ method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify({ action:'chat', message:text, projectId:S.scope?.projectId }) }).then(r=>r.json()).catch(()=>null);
+        const qs = S.scope?.runtimeId ? `?runtimeId=${encodeURIComponent(S.scope.runtimeId)}` : '';
+        const res = await fetch('/api/runtime/execute'+qs,{ method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify({ action:'chat', goal:text, message:text, projectId:S.scope?.projectId, runtimeId:S.scope?.runtimeId }) }).then(r=>r.json()).catch(()=>null);
         const aEl=document.createElement('div'); aEl.className='chat-msg agent'; aEl.textContent=res?.result||res?.message||res?.output||'Command queued.'; msgs.appendChild(aEl);
     } catch { const aEl=document.createElement('div'); aEl.className='chat-msg agent'; aEl.textContent='Could not reach agent — is the server running?'; msgs.appendChild(aEl); }
     if (sendBtn) sendBtn.disabled=false;
@@ -292,11 +336,12 @@ async function bootstrap() {
     _attachHandlers();
     _renderHeader(false);
 
-    // Fast first paint: board + workspace + projects + companies + repo-tree + license
-    const [, , , , , lic] = await Promise.all([
+    await loadWorkspace();
+    await loadProjects();
+
+    // Fast first paint: board + companies + repo-tree + license
+    const [, , , lic] = await Promise.all([
         Board.load(),
-        loadWorkspace(),
-        loadProjects(),
         loadCompanies(),
         loadRepoTree(),
         api('/api/license', 60000),

package/dist/dashboard/app/state.js

@@ -24,7 +24,7 @@ export const S = {
     startTime: Date.now(),
 
     // Context scope
-    scope:     { projectId: null, agentId: null },
+    scope:     { projectId: null, agentId: null, runtimeId: null },
     projects:  [],
     workspace: null,
 

package/dist/dashboard/app/styles/memory.css

@@ -9,7 +9,16 @@
     background: var(--bg-elevated); border: 1px solid var(--border);
     border-radius: var(--radius); overflow: hidden; position: relative; margin-bottom: 12px;
 }
+#graph-container.graph-expanded {
+    position: fixed; z-index: 60;
+    top: 56px; right: 24px; bottom: 24px; left: 360px;
+    height: auto; min-height: 0; margin-bottom: 0;
+    box-shadow: 0 0 0 1px rgba(0,255,136,0.18), 0 24px 80px rgba(0,0,0,0.68);
+}
 #graph-svg { width: 100%; height: 100%; }
+.memory-toolbar {
+    display: flex; justify-content: flex-end; gap: 8px; margin: -2px 0 8px;
+}
 .graph-legend {
     position: absolute; top: 10px; right: 10px;
     display: flex; flex-direction: column; gap: 4px;
@@ -47,7 +56,7 @@
     display: flex; align-items: center; gap: 8px;
     padding: 8px 12px; border-bottom: 1px solid var(--border);
 }
-.mem-search-row input { flex: 1; border: none; outline: none; font-size: 0.78rem; color: var(--text-main); }
+.mem-search-row input { flex: 1; border: none; outline: none; font-size: 0.78rem; color: var(--text-main); min-width: 0; }
 .mem-search-row input::placeholder { color: var(--text-dim); }
 #mem-list { max-height: 290px; overflow-y: auto; }
 .mem-item {
@@ -63,6 +72,11 @@
 .mem-title  { font-size: 0.78rem; color: var(--text-main); line-height: 1.4; }
 .mem-meta   { font-family: var(--font-mono); font-size: 0.78rem; color: var(--text-dim); margin-top: 2px; }
 
+@media (max-width: 900px) {
+    #graph-container.graph-expanded { left: 16px; right: 16px; top: 56px; bottom: 16px; }
+    .memory-bottom { grid-template-columns: 1fr; }
+}
+
 /* ── Memory Pyramid (widget container) ── */
 .pyramid-wrap {
     background: var(--bg-elevated); border: 1px solid var(--border);

package/dist/dashboard/app/views/federation.js

@@ -45,9 +45,9 @@ export function render(fed, wards, escs) {
     const container = $('federation-container');
     if (!container) return;
 
-    const peers     = Array.isArray(fed.peers) ? fed.peers : [];
+    const peers     = Array.isArray(fed.peers) ? fed.peers : (Array.isArray(fed.knownPeers) ? fed.knownPeers : []);
     const relay     = fed.relay ?? null;
-    const relayMode = fed.relayMode ?? 'degraded';
+    const relayMode = fed.relayMode ?? fed.relay?.mode ?? 'degraded';
 
     const dispatch    = wards.dispatch   ?? null;
     const worklist    = Array.isArray(wards.worklist)    ? wards.worklist    : [];
@@ -65,13 +65,13 @@ export function render(fed, wards, escs) {
                 </div>
                 ${relay ? `
                     <div class="trust-posture-body">
-                        ${_kv('Relay host',    relay.host ?? '—')}
+                        ${_kv('Relay host',    relay.host ?? (relay.configured ? 'configured' : 'local-only'))}
                         ${_kv('Relay port',    relay.port ?? '—')}
-                        ${_kv('Transport',     relay.transport ?? '—')}
+                        ${_kv('Transport',     relay.transport ?? 'local')}
                         ${_kv('Connected',     relay.connected ? 'yes' : 'no')}
                         ${_kv('Latency',       relay.latencyMs != null ? relay.latencyMs + ' ms' : '—')}
                     </div>
-                ` : `<div class="empty-sub">No relay configured.</div>`}
+                ` : `<div class="empty-sub">Local-only mode. Add a relay when you want cross-machine federation.</div>`}
             </div>
 
             <!-- Peer list card -->
@@ -101,7 +101,7 @@ export function render(fed, wards, escs) {
                         ${_kv('Limit',       dispatch.limit ?? '—')}
                         ${_kv('Throttled',   dispatch.throttled ? 'yes' : 'no')}
                     </div>
-                ` : `<div class="empty-sub">Architects runtime not initialised.</div>`}
+                ` : `<div class="empty-sub">Architects dispatch is idle. Worklists appear when a mission attaches the Architects runtime.</div>`}
             </div>
 
             <!-- Active worklist card -->
@@ -156,17 +156,17 @@ function _kv(label, value) {
 }
 
 function _peerRow(p) {
-    const online = p.status === 'online' || p.connected === true;
+    const online = p.status === 'online' || p.health === 'online' || p.connected === true || p.active === true;
     return `
         <div class="trust-event-row">
             <div class="trust-event-main">
                 <span class="chip ${online ? 'chip-ok' : 'chip-muted'}">${online ? 'online' : 'offline'}</span>
-                <span class="trust-event-type">${esc(p.name ?? p.id ?? 'peer')}</span>
+                <span class="trust-event-type">${esc(p.displayName ?? p.name ?? p.peerId ?? p.id ?? 'peer')}</span>
                 ${p.host ? `<span style="font-family:var(--font-mono);font-size:var(--caption);color:var(--text-muted)">${esc(p.host)}</span>` : ''}
             </div>
             <div class="trust-event-meta">
                 ${p.latencyMs != null ? `<span style="font-family:var(--font-mono);font-size:var(--caption);color:var(--text-muted)">${p.latencyMs}ms</span>` : ''}
-                ${p.lastSeenAt ? `<span style="color:var(--text-dim);font-size:var(--caption)">${fmtTs(p.lastSeenAt)}</span>` : ''}
+                ${p.lastSeenAt || p.lastHeartbeat ? `<span style="color:var(--text-dim);font-size:var(--caption)">${fmtTs(p.lastSeenAt || p.lastHeartbeat)}</span>` : ''}
             </div>
         </div>`;
 }

package/dist/dashboard/app/views/governance.js

@@ -50,22 +50,36 @@ export async function load() {
     if (!container) return;
     container.innerHTML = `<div class="empty"><div class="empty-title">Loading proposals…</div></div>`;
 
-    const data = await api('/api/governance/darwin', 10_000);
+    const [data, health] = await Promise.all([
+        api('/api/governance/darwin', 10_000),
+        api('/api/health', 15_000),
+    ]);
     const cycles = Array.isArray(data?.cycles) ? data.cycles : [];
 
-    render(cycles);
+    render(cycles, health);
 }
 
-export function render(cycles) {
+export function render(cycles, health = null) {
     const container = $('governance-container');
     if (!container) return;
 
     if (!cycles.length) {
         container.innerHTML = `
-            <div class="empty">
-              <div class="empty-title">No Darwin proposals yet</div>
-              <div class="empty-sub">Auto-propose generates after nexus_orchestrate when <code>NEXUS_SELF_IMPROVE=1</code>.</div>
+            <div class="trust-grid">
+              <div class="card trust-card">
+                <div class="trust-card-hd"><span class="trust-card-title">Darwin auto-propose</span><span class="chip chip-muted">idle</span></div>
+                <div class="trust-posture-body">
+                  <div class="trust-posture-row"><span>Proposals</span><strong>0</strong></div>
+                  <div class="trust-posture-row"><span>Trigger</span><strong>nexus_orchestrate</strong></div>
+                  <div class="trust-posture-row"><span>Self-improve</span><strong>${esc(health?.runtime?.selfImprove ? 'on' : 'off')}</strong></div>
+                </div>
+              </div>
+              <div class="card trust-card">
+                <div class="trust-card-hd"><span class="trust-card-title">Consensus guard</span><span class="chip chip-ok">ready</span></div>
+                <div class="empty-sub">Live Byzantine votes and review decisions appear here when proposals are created.</div>
+              </div>
             </div>`;
+        _renderByzantineSection();
         return;
     }
 
@@ -112,6 +126,7 @@ export function render(cycles) {
             });
         });
     });
+    _renderByzantineSection();
 }
 
 function cycleCard(c, isPending) {

package/dist/dashboard/app/views/memory.js

@@ -30,15 +30,20 @@ function timeAgo(ts) {
 
 let _activeTier = null;
 
+function memText(m) {
+    return m.title || m.excerpt || m.content || m.summary || m.id || '';
+}
+
 /* ── Data loader ──
  * `allSettled` is deliberate: if the topology endpoint fails or times out,
  * the memory list + health + RAG collections should still render. Previous
  * behaviour (`Promise.all`) made a single failed call hide the whole section.
  */
 export async function load() {
-    const repoParam = S.workspace?.repoName ? '?repo='+encodeURIComponent(S.workspace.repoName) : '';
+    const params = new URLSearchParams({ includeInactive: 'true', limit: '100' });
+    if (S.workspace?.repoName) params.set('repo', S.workspace.repoName);
     const [memsR, healthR, ragsR, topoR] = await Promise.allSettled([
-        api('/api/memory'+repoParam, 5000),
+        api('/api/memory?'+params.toString(), 5000),
         api('/api/memory/health', 5000),
         api('/api/rag/collections', 15000),
         api('/api/knowledge-topology', 30000),
@@ -71,10 +76,22 @@ function renderPyramidWidget() {
     const container=$('mem-pyramid-widget'); if (!container) return;
     const h=S.memHealth;
     if (!h) { container.innerHTML=''; return; }
+    const fallback = S.memories.reduce((acc, m) => {
+        const tier = m.tier || 'semantic';
+        if (tier === 'working' || tier === 'prefrontal') acc.prefrontal += 1;
+        else if (tier === 'episodic' || tier === 'hippocampus') acc.hippocampus += 1;
+        else acc.cortex += 1;
+        return acc;
+    }, { prefrontal: 0, hippocampus: 0, cortex: 0 });
+    const tierCounts = h.tierCounts || {};
+    const count = (fallbackValue, ...values) => {
+        const positive = values.find(v => Number(v) > 0);
+        return positive != null ? Number(positive) : fallbackValue;
+    };
     const counts = {
-        prefrontal:  h.working   ?? h.prefrontal  ?? 0,
-        hippocampus: h.episodic  ?? h.hippocampus ?? 0,
-        cortex:      h.semantic  ?? h.cortex      ?? 0,
+        prefrontal:  count(fallback.prefrontal, h.working, h.prefrontal, tierCounts.prefrontal),
+        hippocampus: count(fallback.hippocampus, h.episodic, h.hippocampus, tierCounts.hippocampus),
+        cortex:      count(fallback.cortex, h.semantic, h.cortex, tierCounts.cortex),
     };
     renderPyramid(container, counts, _activeTier, tier => {
         _activeTier = tier;
@@ -362,11 +379,11 @@ export function renderMemList() {
     const q=S.memQuery.toLowerCase();
     let mems=S.memories.filter(m=>{
         if (_activeTier) {
-            const tierMap={prefrontal:'working',hippocampus:'episodic',cortex:'semantic'};
-            if ((m.tier||'semantic')!==tierMap[_activeTier]) return false;
+            const tierMap={prefrontal:['working','prefrontal'],hippocampus:['episodic','hippocampus'],cortex:['semantic','cortex']};
+            if (!tierMap[_activeTier].includes(m.tier||'semantic')) return false;
         }
         if (!q) return true;
-        return [(m.title||''),(m.content||''),(m.tags||[]).join(' ')].some(s=>s.toLowerCase().includes(q));
+        return [memText(m),(m.content||''),(m.excerpt||''),(m.tags||[]).join(' ')].some(s=>s.toLowerCase().includes(q));
     }).slice(0,60);
     if (!mems.length) {
         const repoHint=S.workspace?.repoName?` for <code>${esc(S.workspace.repoName)}</code>`:'';
@@ -376,22 +393,39 @@ export function renderMemList() {
     el.innerHTML=mems.map(m=>{
         const tier=m.tier||'semantic';
         const pri=m.priority!=null?`p:${Math.round(m.priority*100)}%`:'';
+        const state=m.state && m.state !== 'active' ? ` · ${m.state}` : '';
         const decay=m.entropy>0.6?'opacity:0.6':'';
         return `<div class="mem-item" style="${decay}" data-memid="${esc(m.id)}">
             <div class="tier-dot t-${esc(tier)}"></div>
             <div style="flex:1;min-width:0">
-                <div class="mem-title">${esc(m.title||(m.content||'').substring(0,60)||m.id)}</div>
-                <div class="mem-meta">${esc(tier)}${pri?' · '+pri:''}${m.createdAt?' · '+timeAgo(m.createdAt):''}</div>
+                <div class="mem-title">${esc(memText(m).substring(0,90))}</div>
+                <div class="mem-meta">${esc(tier)}${esc(state)}${pri?' · '+pri:''}${m.createdAt?' · '+timeAgo(m.createdAt):''}</div>
             </div>
         </div>`;
     }).join('');
     el.querySelectorAll('[data-memid]').forEach(item => {
         item.addEventListener('click', () => {
-            const m=S.memories.find(x=>x.id===item.dataset.memid); if (m) _openMemDrawer({id:m.id,label:m.title||m.id,data:m});
+            const m=S.memories.find(x=>x.id===item.dataset.memid); if (m) _openMemDrawer({id:m.id,label:memText(m),data:m});
         });
     });
 }
 
+function _browseMemories() {
+    const items = S.memories.slice(0, 120);
+    openDrawer({
+        title: `Memories (${items.length})`,
+        body: items.length ? `<div class="trust-event-list">
+            ${items.map(m => `<div class="trust-event-row" data-drawer-mem="${esc(m.id)}">
+                <div class="trust-event-main">
+                    <span class="chip chip-muted">${esc(m.tier || 'semantic')}</span>
+                    <span class="trust-event-type">${esc(memText(m).slice(0, 120))}</span>
+                </div>
+                <div class="trust-event-meta">${esc(m.state || 'active')}${m.createdAt ? ' · '+esc(timeAgo(m.createdAt)) : ''}</div>
+            </div>`).join('')}
+        </div>` : '<div class="empty-sub">No memories available for the selected runtime.</div>',
+    });
+}
+
 function _openMemDrawer(node) {
     const m=node.data||node;
     const tags=(m.tags||[]).map(t=>`<span class="chip">${esc(t)}</span>`).join(' ');
@@ -404,12 +438,22 @@ function _openMemDrawer(node) {
             ['Entropy',m.entropy!=null?m.entropy.toFixed(3):'—']
         ])}</div>
         ${tags?`<div class="dsec"><div class="dsec-title">Tags</div><div class="dtags">${tags}</div></div>`:''}
-        <div class="dsec"><div class="dsec-title">Content</div><div class="dcontent">${esc(m.content||m.title||'(no content)')}</div></div>` });
+        <div class="dsec"><div class="dsec-title">Content</div><div class="dcontent">${esc(m.content||m.excerpt||m.title||'(no content)')}</div></div>` });
 }
 
 /* ── Init ── */
 export function init() {
     $('mem-search')?.addEventListener('input', e => { S.memQuery=e.target.value; renderMemList(); });
+    $('mem-browse-btn')?.addEventListener('click', _browseMemories);
+    $('mem-list-browse-btn')?.addEventListener('click', _browseMemories);
+    $('mem-graph-max-btn')?.addEventListener('click', () => {
+        const c = $('graph-container');
+        const b = $('mem-graph-max-btn');
+        if (!c || !b) return;
+        const expanded = c.classList.toggle('graph-expanded');
+        b.textContent = expanded ? 'Restore graph' : 'Maximize graph';
+        renderGraph();
+    });
     document.querySelectorAll('.lane-btn').forEach(b => b.addEventListener('click', () => {
         S.memLane=b.dataset.lane;
         document.querySelectorAll('.lane-btn').forEach(x=>x.classList.toggle('active',x===b));

package/dist/dashboard/app/views/trust.js

@@ -238,18 +238,22 @@ function _worktreesSection(health) {
 function _clientsSection(clients, primary) {
     if (!clients.length) return `<div class="empty-sub">No clients detected.</div>`;
     return `<div class="trust-event-list">
-        ${clients.slice(0, 10).map(c => `
+        ${clients.slice(0, 10).map(c => {
+            const id = c.clientId ?? c.id ?? c.name ?? '';
+            const name = c.displayName ?? c.name ?? c.clientId ?? c.id ?? 'unknown';
+            const primaryId = primary?.clientId ?? primary?.id ?? primary?.name ?? '';
+            return `
             <div class="trust-event-row">
                 <div class="trust-event-main">
-                    ${c.name === primary?.name ? `<span class="chip chip-ok">primary</span>` : `<span class="chip chip-muted">client</span>`}
-                    <span class="trust-event-type">${esc(c.name ?? c.id ?? 'unknown')}</span>
+                    ${id === primaryId ? `<span class="chip chip-ok">primary</span>` : `<span class="chip chip-muted">client</span>`}
+                    <span class="trust-event-type">${esc(name)}</span>
                     ${c.version ? `<span style="font-family:var(--font-mono);font-size:var(--caption);color:var(--text-muted)">v${esc(c.version)}</span>` : ''}
                 </div>
                 <div class="trust-event-meta">
                     ${c.sessions != null ? `<span style="font-size:var(--caption);color:var(--text-muted)">${c.sessions} session${c.sessions !== 1 ? 's' : ''}</span>` : ''}
                 </div>
             </div>
-        `).join('')}
+        `;}).join('')}
     </div>`;
 }
 

package/dist/dashboard/routes/memory.js

@@ -54,6 +54,7 @@ export const handleMemoryRoutes = async (ctx, req, res, url) => {
         const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
         const projectId = url.searchParams.get('projectId') ?? undefined;
         const includeHidden = url.searchParams.get('includeHidden') === 'true';
+        const includeInactive = url.searchParams.get('includeInactive') === 'true';
         // ?repo=<name> scopes results to memories tagged repo:<name> (written by auto-memory).
         // Defaults to the current workspace repo name when not supplied by the frontend.
         const repoNameRaw = url.searchParams.get('repo');
@@ -70,6 +71,7 @@ export const handleMemoryRoutes = async (ctx, req, res, url) => {
             workspaceId,
             projectId,
             includeHidden,
+            includeInactive,
             repoName,
         }));
         return true;

package/dist/dashboard/routes/runtime.js

@@ -190,11 +190,12 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
             ctx.respondJson(res, { error: 'orchestrator-unavailable' }, 503);
             return true;
         }
-        if (!body.goal || typeof body.goal !== 'string') {
+        const goal = typeof body.goal === 'string' ? body.goal : (typeof body.message === 'string' ? body.message : '');
+        if (!goal.trim()) {
             ctx.respondJson(res, { error: 'goal-required' }, 400);
             return true;
         }
-        const run = await orchestrator.orchestrate(String(body.goal), body);
+        const run = await orchestrator.orchestrate(goal, { ...body, goal });
         nexusEventBus.emit('dashboard.action', {
             action: 'runtime.execute',
             status: run.state,

package/dist/dashboard/server.js

@@ -395,10 +395,7 @@ export class DashboardServer {
     }
     createRouteContext() {
         const runtimes = this.runtimeRegistry.list();
-        const runtimeKeyFor = (url) => (url.searchParams.get('runtimeId')
-            || this.getRuntime()?.getRuntimeId()
-            || runtimes[0]?.runtimeId
-            || '__default__');
+        const runtimeKeyFor = (url) => this.resolveRequestedRuntimeId(url, runtimes) || '__default__';
         const runtimeSnapshotCache = new Map();
         const usageSnapshotCache = new Map();
         const repoIdentityCache = new Map();
@@ -618,8 +615,19 @@ export class DashboardServer {
         return this.runtimeProvider?.();
     }
     resolveRequestedRuntimeId(url, runtimes = this.runtimeRegistry.list()) {
-        return url.searchParams.get('runtimeId')
-            || this.getRuntime()?.getRuntimeId()
+        const requested = url.searchParams.get('runtimeId');
+        if (requested)
+            return requested;
+        const currentRuntimeId = this.getRuntime()?.getRuntimeId();
+        const currentSnapshot = currentRuntimeId
+            ? (runtimes.find((runtime) => runtime.runtimeId === currentRuntimeId) ?? this.runtimeRegistry.read(currentRuntimeId))
+            : null;
+        const currentRepoRoot = currentSnapshot?.repoIdentity?.repoRoot;
+        if (currentRuntimeId && currentRepoRoot === this.repoRoot)
+            return currentRuntimeId;
+        const repoRuntime = runtimes.find((runtime) => runtime?.repoIdentity?.repoRoot === this.repoRoot);
+        return repoRuntime?.runtimeId
+            || currentRuntimeId
             || runtimes[0]?.runtimeId
             || null;
     }
@@ -836,7 +844,7 @@ export class DashboardServer {
             tag: options.tag,
             linkedType: options.linkedType,
             recencyMs: options.recencyMs,
-            state: options.includeHidden || options.lane === 'inbox' ? undefined : 'active',
+            state: options.includeHidden || options.includeInactive || options.lane === 'inbox' ? undefined : 'active',
             lane: options.lane,
             repoId: options.repoId,
             workspaceId: options.workspaceId,

package/dist/engines/client-bootstrap.js

@@ -4,6 +4,7 @@ import { homedir } from 'os';
 import { dirname, join, resolve } from 'path';
 import { InstructionGateway } from './instruction-gateway.js';
 import { MemoryEngine } from './memory.js';
+import { buildNexusMcpServerConfig, isStableNexusMcpServerConfig } from './mcp-entrypoint.js';
 import { resolveHomeCodexRoot, resolveWorkspaceContext } from './workspace-resolver.js';
 const WELCOME_MEMORY_MESSAGE = "Welcome to Nexus Prime! Nexus Prime is fully installed and tracking context for your workspace. Use '/nexus' to ask me to analyze the codebase, run agents, and automate tasks.";
 function buildWelcomeMemoryTags(workspaceStateKey) {
@@ -218,14 +219,7 @@ function readJson(targetPath) {
     }
 }
 function buildStandardMcpServerConfig(workspaceRoot) {
-    return {
-        command: 'npx',
-        args: ['-y', 'nexus-prime', 'mcp'],
-        env: {
-            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
-            ...(workspaceRoot ? { NEXUS_WORKSPACE_ROOT: workspaceRoot } : {}),
-        },
-    };
+    return buildNexusMcpServerConfig(workspaceRoot);
 }
 function isAtlasDetected() {
     try {
@@ -298,10 +292,11 @@ function codexTomlHasAutonomousProfile(doc) {
     const envSection = getTomlSection(doc, 'mcp_servers.nexus-prime.env');
     if (!mcpSection)
         return false;
-    const commandOk = /(?:^|\n)\s*command\s*=\s*"npx"\s*(?:\n|$)/.test(mcpSection);
-    const argsOk = /(?:^|\n)\s*args\s*=\s*\[[^\]]*"nexus-prime"[^\]]*"mcp"[^\]]*\]\s*(?:\n|$)/s.test(mcpSection);
+    const commandOk = !/(?:^|\n)\s*command\s*=\s*"npx"\s*(?:\n|$)/.test(mcpSection);
+    const argsOk = /(?:^|\n)\s*args\s*=\s*\[[^\]]*"mcp"[^\]]*\]\s*(?:\n|$)/s.test(mcpSection);
     const envOk = Boolean(envSection && /(?:^|\n)\s*NEXUS_MCP_TOOL_PROFILE\s*=\s*"autonomous"\s*(?:\n|$)/.test(envSection));
-    return commandOk && argsOk && envOk;
+    const noStartupRewrite = Boolean(envSection && /(?:^|\n)\s*NEXUS_MCP_AUTO_CONFIG\s*=\s*"0"\s*(?:\n|$)/.test(envSection));
+    return commandOk && argsOk && envOk && noStartupRewrite;
 }
 export function resolveCodexConfigPath() {
     const codexHome = resolveHomeCodexRoot();
@@ -314,13 +309,14 @@ export function resolveCodexConfigPath() {
     return tomlPath;
 }
 export function renderCodexMcpTomlConfig() {
+    const server = buildNexusMcpServerConfig();
     return [
         '[mcp_servers.nexus-prime]',
-        'command = "npx"',
-        `args = ${formatTomlStringArray(['-y', 'nexus-prime', 'mcp'])}`,
+        `command = ${formatTomlString(server.command)}`,
+        `args = ${formatTomlStringArray(server.args)}`,
         '',
         '[mcp_servers.nexus-prime.env]',
-        'NEXUS_MCP_TOOL_PROFILE = "autonomous"',
+        ...Object.entries(server.env).map(([key, value]) => `${key} = ${formatTomlString(value)}`),
     ].join('\n');
 }
 export function writeCodexMcpConfig(targetPath) {
@@ -336,7 +332,7 @@ export function hasExpectedCodexConfig(targetPath) {
         const parsed = readJson(targetPath);
         const server = parsed?.mcpServers?.['nexus-prime'];
         return Boolean(server
-            && server?.env?.NEXUS_MCP_TOOL_PROFILE === 'autonomous');
+            && isStableNexusMcpServerConfig(server));
     }
     try {
         return codexTomlHasAutonomousProfile(readFileSync(targetPath, 'utf8'));
@@ -358,13 +354,13 @@ function writeStandardMcpConfig(targetPath, workspaceRoot) {
 }
 function writeOpencodeConfig(targetPath, workspaceRoot) {
     const existing = readJson(targetPath);
+    const mcpConfig = buildStandardMcpServerConfig(workspaceRoot);
     const server = {
         type: 'local',
-        command: 'npx',
-        args: ['-y', 'nexus-prime', 'mcp'],
+        command: mcpConfig.command,
+        args: mcpConfig.args,
         environment: {
-            NEXUS_MCP_TOOL_PROFILE: 'autonomous',
-            ...(workspaceRoot ? { NEXUS_WORKSPACE_ROOT: workspaceRoot } : {}),
+            ...mcpConfig.env,
         },
     };
     existing.mcp = existing.mcp ?? {};
@@ -402,21 +398,19 @@ function mergeCodexAgentsContent(existingContent, content) {
     const endIndex = existing.indexOf(CODEX_MANAGED_END);
     if (startIndex >= 0 && endIndex > startIndex) {
         const before = existing.slice(0, startIndex).trimEnd();
-        const after = existing.slice(endIndex + CODEX_MANAGED_END.length).trimStart();
+        const after = existing.slice(endIndex + CODEX_MANAGED_END.length).trim();
         return [
             before,
             before ? '' : undefined,
             managedBlock,
             after ? '' : undefined,
             after,
-            '',
         ].filter((value) => value !== undefined).join('\n');
     }
     return [
         existing.trimEnd(),
         '',
         managedBlock,
-        '',
     ].join('\n');
 }
 function hasCurrentCodexManagedBlock(targetPath, content) {
@@ -654,11 +648,11 @@ export function hasExpectedConfig(definition) {
         if (definition.id === 'opencode') {
             const server = parsed?.mcp?.['nexus-prime'];
             return Boolean(server
-                && server?.environment?.NEXUS_MCP_TOOL_PROFILE === 'autonomous');
+                && isStableNexusMcpServerConfig(server, 'environment'));
         }
         const server = parsed?.mcpServers?.['nexus-prime'];
         return Boolean(server
-            && server?.env?.NEXUS_MCP_TOOL_PROFILE === 'autonomous');
+            && isStableNexusMcpServerConfig(server));
     }
     catch {
         return false;

package/dist/engines/mcp-entrypoint.d.ts

@@ -0,0 +1,12 @@
+export interface NexusMcpServerConfig {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+export declare function buildNexusMcpCommand(): {
+    command: string;
+    args: string[];
+};
+export declare function buildNexusMcpEnv(workspaceRoot?: string): Record<string, string>;
+export declare function buildNexusMcpServerConfig(workspaceRoot?: string): NexusMcpServerConfig;
+export declare function isStableNexusMcpServerConfig(server: any, envKey?: 'env' | 'environment'): boolean;

package/dist/engines/mcp-entrypoint.js

@@ -0,0 +1,33 @@
+export function buildNexusMcpCommand() {
+    return {
+        command: 'nexus-prime',
+        args: ['mcp'],
+    };
+}
+export function buildNexusMcpEnv(workspaceRoot) {
+    return {
+        NEXUS_MCP_TOOL_PROFILE: 'autonomous',
+        NEXUS_MCP_AUTO_CONFIG: '0',
+        NEXUS_MCP_DAEMON_TIMEOUT_MS: '5000',
+        ...(workspaceRoot ? { NEXUS_WORKSPACE_ROOT: workspaceRoot } : {}),
+    };
+}
+export function buildNexusMcpServerConfig(workspaceRoot) {
+    const { command, args } = buildNexusMcpCommand();
+    return {
+        command,
+        args,
+        env: buildNexusMcpEnv(workspaceRoot),
+    };
+}
+export function isStableNexusMcpServerConfig(server, envKey = 'env') {
+    const env = server?.[envKey];
+    const args = Array.isArray(server?.args) ? server.args.map((arg) => String(arg)) : [];
+    return Boolean(server
+        && typeof server.command === 'string'
+        && server.command !== 'npx'
+        && args.includes('mcp')
+        && !args.includes('-y')
+        && env?.NEXUS_MCP_TOOL_PROFILE === 'autonomous'
+        && env?.NEXUS_MCP_AUTO_CONFIG === '0');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.9",
+  "version": "7.9.10",
   "description": "Local-first MCP control plane for coding agents with bootstrap-orchestrate execution, memory fabric, token budgeting, and worktree-backed swarms",
   "type": "module",
   "main": "dist/index.js",