nexus-prime 7.9.8 → 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/agents/adapters/mcp/definitions.js

@@ -15,6 +15,7 @@ export const FIRST_CLASS_TOOLS = new Set([
     'nexus_search',
     'nexus_runtime_health',
     'nexus_run_status',
+    'nexus_user_workflow_trace',
     'kernel_run_step',
     'kernel_run_verify',
     'kernel_run_merge',
@@ -881,6 +882,18 @@ export function buildMcpToolDefinitions() {
                 required: ['runId'],
             },
         },
+        {
+            name: 'nexus_user_workflow_trace',
+            description: 'Return the local user-agent workflow trace for a run: user goal, agent actions, context, verification, failure signals, and next actions.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    runId: { type: 'string', description: 'Execution run ID' },
+                    format: { type: 'string', enum: ['text', 'json'], description: 'Response format' },
+                },
+                required: ['runId'],
+            },
+        },
         // ── Darwin Loop ──────────────────────────────────────────────────
         {
             name: 'nexus_darwin_propose',

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

@@ -10,5 +10,7 @@ type McpResult = {
         text: string;
     }>;
 };
+export declare function extractSkillSelectorsFromPrompt(prompt: string): string[];
+export declare function inferSpawnWorkersIntent(actions: unknown[]): 'plan' | 'mutate';
 export declare function handleOrchestrationGroup(toolName: string, hctx: McpHandlerCtx, request: any, args: Record<string, unknown>, ctx?: any): Promise<McpResult | undefined>;
 export {};

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

@@ -20,6 +20,25 @@ import { getSharedTelemetry } from '../../../../engines/telemetry-remote.js';
 import { requireRuntime } from '../util/require-runtime.js';
 import { ensureCrGraphBuilt } from '../../../../engines/code-review-graph-client.js';
 import { recordFirstBootstrap } from '../../../../engines/telemetry.js';
+export function extractSkillSelectorsFromPrompt(prompt) {
+    const selectors = new Set();
+    const add = (value) => {
+        const cleaned = value?.trim().replace(/^[$@]+/, '');
+        if (cleaned && /^[a-z0-9][a-z0-9._-]{1,120}$/i.test(cleaned)) {
+            selectors.add(cleaned);
+        }
+    };
+    for (const match of prompt.matchAll(/\[[$@]?([a-z0-9][a-z0-9._-]{1,120})\]\([^)]*\/\.agents?\/skills\/[^)]*\/SKILL\.md\)/gi)) {
+        add(match[1]);
+    }
+    for (const match of prompt.matchAll(/\/\.agents?\/skills\/([^/\s)]+)\/SKILL\.md/gi)) {
+        add(match[1]);
+    }
+    return [...selectors];
+}
+export function inferSpawnWorkersIntent(actions) {
+    return actions.length > 0 ? 'mutate' : 'plan';
+}
 export async function handleOrchestrationGroup(toolName, hctx, request, args, ctx) {
     const runtimeError = requireRuntime(hctx);
     if (runtimeError)
@@ -315,9 +334,11 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             const workers = request.params.arguments?.workers == null
                 ? undefined
                 : Number(request.params.arguments.workers);
-            const skills = Array.isArray(request.params.arguments?.skills)
+            const explicitSkills = Array.isArray(request.params.arguments?.skills)
                 ? request.params.arguments.skills.map(String)
-                : undefined;
+                : [];
+            const promptSkills = extractSkillSelectorsFromPrompt(prompt);
+            const skills = [...new Set([...explicitSkills, ...promptSkills])];
             const workflows = Array.isArray(request.params.arguments?.workflows)
                 ? request.params.arguments.workflows.map(String)
                 : undefined;
@@ -374,7 +395,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 const execution = await hctx.nexusRef.orchestrate(prompt, applyExecutionPreset({
                     files,
                     workers,
-                    skillNames: skills,
+                    skillNames: skills.length > 0 ? skills : undefined,
                     workflowSelectors: workflows,
                     hookSelectors: hooks,
                     automationSelectors: automations,
@@ -769,6 +790,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 ? String(request.params.arguments.executionPreset)
                 : undefined;
             const preset = resolveExecutionPreset(executionPreset);
+            const inferredIntent = inferSpawnWorkersIntent(actions);
             // Surface worker-plan intent on the SSE feed without persisting it as a memory.
             try {
                 nexusEventBus.emit('memory.snapshot', {
@@ -796,11 +818,18 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 backendSelectors: { memoryBackend, compressionBackend, dslCompiler },
                 backendMode,
                 optimizationProfile,
+                intent: inferredIntent,
                 executionMode: 'manual-low-level',
                 manualOverrides: ['nexus_spawn_workers'],
             }, executionPreset));
             const verifiedWorkers = execution.workerResults.filter(result => result.verified).length;
             const modifiedFiles = execution.workerResults.reduce((sum, result) => sum + result.modifiedFiles.length, 0);
+            const noDiffInspected = execution.state === 'inspected'
+                && modifiedFiles === 0
+                && !execution.workerResults.some((result) => result.diff?.trim());
+            const displayedDecision = noDiffInspected
+                ? 'no-applicable-diff'
+                : execution.finalDecision?.action ?? 'none';
             execution.activeSkills.forEach(skill => {
                 hctx.sessionDNA.recordSkill(skill.name);
                 if (skill.scope === 'global' || skill.rolloutStatus === 'promoted') {
@@ -826,7 +855,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                 `Run: ${execution.runId.padEnd(28, ' ')} State: ${execution.state.padEnd(18, ' ')}`,
                 `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, ' ')}`
+                `Decision: ${displayedDecision.padEnd(52, ' ')}`
             ], execution.state === 'merged' || execution.state === 'inspected' ? '32' : execution.state === 'rolled_back' ? '33' : '31');
             return {
                 content: [{
@@ -841,7 +870,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                             preset ? `Preset: ${preset.name} (${preset.id})` : null,
                             `Verified Workers: ${verifiedWorkers}`,
                             `Modified Files: ${modifiedFiles}`,
-                            `Decision: ${execution.finalDecision?.action ?? 'none'}`,
+                            `Decision: ${displayedDecision}`,
                             `Recommended Strategy: ${execution.finalDecision?.recommendedStrategy ?? 'n/a'}`,
                             `Planner: ${execution.plannerResult?.summary ?? 'n/a'}`,
                             `Crew: ${execution.plannerResult?.selectedCrew?.name ?? 'n/a'}`,

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

@@ -4,7 +4,7 @@
  * federation_status, run_status.
  * Extracted from mcp.ts (Phase 3 split).
  */
-import { formatBullets, formatJsonDetails, buildAutoMemorySummary, } from '../helpers.js';
+import { formatBullets, formatJsonDetails, truncateText, buildAutoMemorySummary, } from '../helpers.js';
 import { nexusEventBus } from '../../../../engines/event-bus.js';
 import { getSharedLicenseManager, snapshotPCU, formatPCUStatus } from '../../../../licensing/index.js';
 import { TokenAnalyticsEngine } from '../../../../engines/token-analytics.js';
@@ -13,6 +13,7 @@ import { requireRuntime } from '../util/require-runtime.js';
 import { getAsyncGate } from '../async-gate.js';
 import { getRun as getOrchRun } from '../../../../engines/orchestrator/store.js';
 import { nxlResult } from '../../../../nxl/index.js';
+import { summarizeUserWorkflowTrace } from '../../../../engines/user-workflow-trace.js';
 export async function handleRuntimeGroup(toolName, hctx, request, args, ctx) {
     const runtimeError = requireRuntime(hctx);
     if (runtimeError)
@@ -226,6 +227,40 @@ export async function handleRuntimeGroup(toolName, hctx, request, args, ctx) {
                     }],
             };
         }
+        case 'nexus_user_workflow_trace': {
+            const runId = String(request.params.arguments?.runId ?? '');
+            const fmt = String(request.params.arguments?.format ?? 'text');
+            const trace = await hctx.getRuntime().getUserWorkflowTrace?.(runId);
+            if (!trace) {
+                return { content: [{ type: 'text', text: `User workflow trace not found: ${runId}` }] };
+            }
+            if (fmt === 'json') {
+                return { content: [{ type: 'text', text: JSON.stringify(trace, null, 2) }] };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            summarizeUserWorkflowTrace(trace),
+                            '',
+                            formatBullets([
+                                `Run: ${trace.runId}`,
+                                `Goal: ${truncateText(trace.goal, 120)}`,
+                                `Actions: ${trace.userJourney.actions.length ? trace.userJourney.actions.slice(0, 5).join(' | ') : 'none recorded'}`,
+                                `Files: ${trace.userJourney.selectedFiles.length ? trace.userJourney.selectedFiles.slice(0, 5).join(', ') : 'none selected'}`,
+                                `Agents: ${trace.userJourney.selectedSpecialists.length ? trace.userJourney.selectedSpecialists.slice(0, 5).join(', ') : 'none selected'}`,
+                                `Signals: ${trace.signals.length ? trace.signals.map(signal => `${signal.severity}:${signal.code}`).slice(0, 8).join(', ') : 'none'}`,
+                            ]),
+                            trace.signals.length
+                                ? `Failure signals\n${formatBullets(trace.signals.map(signal => `${signal.code}: ${signal.summary}`))}`
+                                : '',
+                            trace.nextActions.length
+                                ? `Next actions\n${formatBullets(trace.nextActions)}`
+                                : '',
+                        ].filter(Boolean).join('\n\n'),
+                    }],
+            };
+        }
         case 'nexus_run_status': {
             const runId = String(request.params.arguments?.runId ?? '');
             const fmt = String(request.params.arguments?.format ?? 'text');

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

@@ -190,7 +190,7 @@ export function isReadOnlyMcpTool(toolName) {
         'nexus_list_', 'nexus_describe_', 'nexus_runtime_health',
         'nexus_doctor', 'nexus_token_report', 'nexus_recall_memory',
         'nexus_temporal_query', 'nexus_memory_stats', 'nexus_federation_status',
-        'nexus_license_usage', 'nexus_run_status', 'nexus_selection_ledger',
+        'nexus_license_usage', 'nexus_run_status', 'nexus_user_workflow_trace', 'nexus_selection_ledger',
         'nexus_operative_journal',
     ];
     return skipPrefixes.some(p => toolName.startsWith(p));

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>