nexus-prime 7.9.19 → 7.9.21

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

@@ -976,11 +976,10 @@ export function buildMcpToolDefinitions() {
                 required: ['taskId', 'goal', 'findings'],
             },
         },
-        // When NEXUS_DISABLE_WORKFORCE=1 (the daemon default since v7.6.1),
+        // When NEXUS_DISABLE_WORKFORCE=1 (explicit break-glass mode),
         // strip the 24 nexus_synapse_* / nexus_architects_* tools from the
         // catalog so the model doesn't see surface area for engines that
-        // aren't initialized at runtime. Set NEXUS_DISABLE_WORKFORCE=0 to
-        // re-enable both engines + their tools.
+        // aren't initialized at runtime.
         ...(process.env.NEXUS_DISABLE_WORKFORCE === '1' ? [] : synapseToolDefinitions),
         ...(process.env.NEXUS_DISABLE_WORKFORCE === '1' ? [] : architectsToolDefinitions),
         // ── Workforce (unified worker+job layer) ──────────────────────────

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

@@ -173,7 +173,7 @@ export async function handleGovernanceGroup(toolName, hctx, request, args, ctx)
             const manifest = ensureBootstrap({
                 packageRoot: PROJECT_ROOT,
                 workspaceRoot: hctx.nexusRef.getWorkspaceContext().workspaceRoot,
-                phase: 'runtime',
+                phase: 'install',
                 silent: true,
             });
             const memoryMaintenance = hctx.nexusRef.maintainMemory();

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

@@ -77,7 +77,7 @@ export async function handleRuntimeGroup(toolName, hctx, request, args, ctx) {
             if (!requestedTool) {
                 return { content: [{ type: 'text', text: 'tool_name is required.' }] };
             }
-            const allToolDefs = this.getDecoratedToolDefinitions(hctx.getToolProfile());
+            const allToolDefs = hctx.getDecoratedToolDefinitions(hctx.getToolProfile());
             const found = allToolDefs.find(t => t.name === requestedTool);
             if (!found) {
                 const available = allToolDefs.map(t => t.name).join(', ');

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

@@ -110,6 +110,12 @@ export interface McpHandlerCtx {
     getDarwinLoop(args?: Record<string, unknown>): DarwinLoop;
     /** Current MCP tool profile — 'autonomous' or 'full' */
     getToolProfile(): McpToolProfile;
+    /** Get decorated tool definitions for lazy tool discovery */
+    getDecoratedToolDefinitions(profile?: McpToolProfile): Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+    }>;
     /** True if `target` looks like a package (node_modules, built artifacts, etc.) */
     isPackageLikeWorkspace(target: string): boolean;
     /** Resolve a candidate path relative to the workspace root */

package/dist/agents/adapters/mcp.js

@@ -623,7 +623,7 @@ export class MCPAdapter {
             : 'Full MCP profile active. Low-level and authoring tools are exposed.';
     }
     finalizeToolDefinitions(tools, profile = this.getToolProfile()) {
-        const taskContext = this.currentTask || this.getRuntime().getUsageSnapshot()?.orchestration?.lastPrompt || '';
+        const taskContext = this.currentTask || this.runtime?.getUsageSnapshot()?.orchestration?.lastPrompt || '';
         const userTier = getSharedLicenseManager().getStatus().tier;
         const profileFiltered = profile === 'full'
             ? tools.slice()
@@ -715,14 +715,21 @@ export class MCPAdapter {
     setupToolHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             const profile = this.getToolProfile();
-            this.getRuntime().recordClientInstructionStatus({
-                clientId: this.name,
-                clientFamily: this.name === 'openclaw' ? 'antigravity' : this.name,
-                toolProfile: profile,
-                status: profile === 'autonomous' ? 'guided' : 'manual',
-                summary: this.describeClientInstructionStatus(profile),
-                updatedAt: Date.now(),
-            });
+            setTimeout(() => {
+                try {
+                    this.getRuntime().recordClientInstructionStatus({
+                        clientId: this.name,
+                        clientFamily: this.name === 'openclaw' ? 'antigravity' : this.name,
+                        toolProfile: profile,
+                        status: profile === 'autonomous' ? 'guided' : 'manual',
+                        summary: this.describeClientInstructionStatus(profile),
+                        updatedAt: Date.now(),
+                    });
+                }
+                catch {
+                    // Tool enumeration must stay fast and side-effect best-effort.
+                }
+            }, 0);
             return {
                 tools: this.listTools(profile),
             };
@@ -957,6 +964,7 @@ export class MCPAdapter {
             getRepoNgramIndex: (a = {}) => self.getRepoNgramIndex(a),
             getDarwinLoop: (a = {}) => self.getDarwinLoop(a),
             getToolProfile: () => self.getToolProfile(),
+            getDecoratedToolDefinitions: (profile) => self.getDecoratedToolDefinitions(profile),
             isPackageLikeWorkspace: (target) => self.isPackageLikeWorkspace(target),
             resolveToolPath: (p, a = {}) => self.resolveToolPath(p, a),
             telemetry: self.telemetry,

package/dist/cli/doctor-storage.js

@@ -12,10 +12,9 @@ import { resolveRunsBudget, resolveWorktreeBudget } from './cleanup.js';
 import { dirBytes, formatBytes } from '../install/fs-purge.js';
 import { enumerateNgramArchives, enumerateStatePaths, getNexusStateDir, getRuntimeTmpRoots, getWorktreeRoots, } from '../install/state-locator.js';
 import { INSTALL_ARCH_GENERATION, loadManifest, } from '../install/manifest.js';
-import { getNgramFootprintBytes } from '../engines/ngram-index.js';
+import { getNgramFootprintBytes, NGRAM_DEFAULT_FOOTPRINT_BYTES } from '../engines/ngram-index.js';
 import { getSharedLicenseManager } from '../licensing/license-manager.js';
 const NGRAM_DEFAULT_WAL_LIMIT_BYTES = 64 * 1024 * 1024;
-const NGRAM_DEFAULT_FOOTPRINT_BYTES = 512 * 1024 * 1024;
 function readEnvBytesPositive(name, fallback) {
     const raw = process.env[name];
     if (!raw)

package/dist/cli.js

@@ -30,7 +30,7 @@ import { cliSetup, configureIDE, computeFileHash, readSetupMarker, writeSetupMar
 import { isNewUser, promptLicenseKey, printReturningUserBanner } from './cli/interactive-setup.js';
 import { runHookBootstrap, runHookMemory, runHookMindkit, runHookGhostPass, runHookSessionDna } from './cli/hook.js';
 import { resolveWorkspaceContext } from './engines/workspace-resolver.js';
-import { ensureDaemonReady, getDaemonStatus, stopDaemon } from './daemon/client.js';
+import { ensureDaemonReady, getDaemonStatus, pingDaemonHealth, stopDaemon } from './daemon/client.js';
 import { NexusDaemonServer } from './daemon/server.js';
 import { DaemonSupervisor } from './daemon/supervisor.js';
 import { startDaemonBackedMcpProxy } from './daemon/proxy.js';
@@ -720,8 +720,10 @@ program
     try {
         const record = await ensureDaemonManaged({ force: options.force });
         const dashboardPort = process.env.NEXUS_DASHBOARD_PORT ?? '3377';
+        const health = await pingDaemonHealth(record).catch(() => null);
+        const dashboardUrl = health?.dashboardUrl ?? `http://localhost:${dashboardPort}`;
         console.log(`Nexus Prime daemon running (pid ${record.pid}, ${formatDaemonAddress(record)})`);
-        console.log(`Dashboard: http://localhost:${dashboardPort}`);
+        console.log(`Dashboard: ${dashboardUrl}`);
     }
     catch (err) {
         console.error(`Failed to start daemon: ${err.message}`);
@@ -820,15 +822,14 @@ program
     if (process.env.NEXUS_DAEMON_FAST_START === undefined) {
         process.env.NEXUS_DAEMON_FAST_START = '1';
     }
-    // Default the daemon to "workforce-disabled" mode: Synapse + Architects
-    // engines stay in the source tree (tests still run, code is preserved)
-    // but they don't open their SQLite DBs, run schema migrations, or
-    // surface their 24 MCP tools to clients. Saves ~700ms boot, shrinks
-    // the model-visible tool catalog, and removes the empty Workforce
-    // surface from the dashboard. Re-enable with NEXUS_DISABLE_WORKFORCE=0
-    // for users who actually hire operatives + dispatch missions.
-    if (process.env.NEXUS_DISABLE_WORKFORCE === undefined) {
-        process.env.NEXUS_DISABLE_WORKFORCE = '1';
+    // Keep daemon startup fast, but do not disable workforce. Synapse and
+    // Architects can lazily warm on first hire/tool call unless the operator
+    // explicitly sets the NEXUS_DISABLE_WORKFORCE escape hatch.
+    if (process.env.NEXUS_SYNAPSE_LAZY === undefined) {
+        process.env.NEXUS_SYNAPSE_LAZY = '1';
+    }
+    if (process.env.NEXUS_ARCHITECTS_LAZY === undefined) {
+        process.env.NEXUS_ARCHITECTS_LAZY = '1';
     }
     const workspaceContext = resolveWorkspaceContext({ workspaceRoot: getWorkspaceRoot() });
     const daemon = new NexusDaemonServer(workspaceContext);
@@ -976,11 +977,16 @@ program
         });
     }
     console.error('Starting Nexus Prime MCP Server (standalone)...');
-    await runStartupHygiene({
-        repoRoot: workspaceContext.repoRoot,
-        workspaceStateRoot: workspaceContext.stateRoot,
-        mode: 'stale',
-    });
+    setTimeout(() => {
+        void runStartupHygiene({
+            repoRoot: workspaceContext.repoRoot,
+            workspaceStateRoot: workspaceContext.stateRoot,
+            mode: 'stale',
+        }).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[nexus-prime] Startup hygiene skipped: ${message}`);
+        });
+    }, 0);
     nexus = createNexusPrime({
         adapters: ['mcp'],
         runtime: {
@@ -995,8 +1001,8 @@ program
     if (!adapterReady) {
         throw new Error('MCP adapter did not become ready before the startup deadline.');
     }
-    await startup;
     flushPrimedMcpStdioInput();
+    await startup;
     console.error('Nexus Prime MCP Server running on stdio (standalone)');
     console.error('Memory persistence: active (~/.nexus-prime/memory.db)');
     const shutdown = async (signal) => {

package/dist/daemon/client.d.ts

@@ -9,6 +9,7 @@ export interface DaemonHealthResponse {
     stateKey: string;
     workspaceRoot: string;
     repoRoot: string;
+    dashboardUrl?: string | null;
     startedAt: number;
 }
 export interface DaemonStatus {

package/dist/daemon/server.js

@@ -390,6 +390,7 @@ export class NexusDaemonServer {
                     stateKey: this.workspace.stateKey,
                     workspaceRoot: this.workspace.workspaceRoot,
                     repoRoot: this.workspace.repoRoot,
+                    dashboardUrl: this.nexus?.getDashboardAddress?.() ?? null,
                     startedAt: this.lockRecord?.startedAt ?? Date.now(),
                 });
                 return;

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

@@ -258,10 +258,15 @@ function renderPyramidWidget() {
     if (!container) return;
     const h = S.memHealth;
     if (!h) { container.innerHTML = ''; return; }
+    const tierCounts = h.tierCounts || {};
+    const count = (...values) => {
+        const positive = values.find(v => Number(v) > 0);
+        return positive != null ? Number(positive) : 0;
+    };
     const counts = {
-        prefrontal:  h.working  ?? h.prefrontal  ?? 0,
-        hippocampus: h.episodic ?? h.hippocampus ?? 0,
-        cortex:      h.semantic ?? h.cortex      ?? 0,
+        prefrontal:  count(h.working, h.prefrontal, tierCounts.prefrontal),
+        hippocampus: count(h.episodic, h.hippocampus, tierCounts.hippocampus),
+        cortex:      count(h.semantic, h.cortex, tierCounts.cortex),
     };
     renderPyramid(container, counts, _activeTier, tier => {
         _activeTier = tier;
@@ -793,6 +798,14 @@ function renderOrchestrationPipeline() {
     }
     host.style.display = 'block';
     const same = dec && cmp && dec.runId === cmp.runId;
+    const completionState = (completion) => {
+        const state = completion?.state || '';
+        const result = String(completion?.result || '');
+        if (state === 'failed' && /without a repository patch|no applicable diff|no selected mutation bindings|advisory/i.test(result)) {
+            return 'inspected';
+        }
+        return state;
+    };
     const stateColor = (state) => state === 'merged' || state === 'inspected' ? 'var(--accent-good, #4ade80)'
         : state === 'rolled_back' ? 'var(--accent-warn, #fbbf24)'
         : state === 'failed' ? 'var(--accent-bad, #ff5f57)'
@@ -814,9 +827,10 @@ function renderOrchestrationPipeline() {
             ${chipList('skills', dec.skills)}
             ${chipList('files', dec.files)}
         </div>` : '';
+    const cmpState = completionState(cmp);
     const cmpBlock = cmp ? `
-        <div style="border-left:3px solid ${stateColor(cmp.state)};padding:8px 12px">
-            <div style="font-size:13px;font-weight:600;margin-bottom:4px">Completion · run ${esc((cmp.runId || '').slice(-8))} · <span style="color:${stateColor(cmp.state)}">${esc(cmp.state || '')}</span></div>
+        <div style="border-left:3px solid ${stateColor(cmpState)};padding:8px 12px">
+            <div style="font-size:13px;font-weight:600;margin-bottom:4px">Completion · run ${esc((cmp.runId || '').slice(-8))} · <span style="color:${stateColor(cmpState)}">${esc(cmpState || '')}</span></div>
             <div style="font-size:12px;color:var(--muted);margin-bottom:6px">${esc(cmp.result || '')}</div>
             <div>${chip('verified', `${cmp.verifiedWorkers ?? 0}/${cmp.totalWorkers ?? 0}`)}${chip('saved', `${fmtNum(cmp.savedTokens ?? 0)} t`)}${chip('compression', `${cmp.compressionPct ?? 0}%`)}${chip('duration', `${Math.round((cmp.durationMs ?? 0) / 100) / 10}s`)}</div>
         </div>` : '';

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

@@ -14,6 +14,7 @@ const esc = s => s == null ? '' : String(s)
 const MAX_EVENTS = 200;
 const MAX_RESOLVED_MCP = 24;
 const LONG_CALL_MS = 2000;
+const STALE_CALL_MS = 5 * 60 * 1000;
 const _events = [];
 let _mounted = false;
 let _filter = 'all';
@@ -23,6 +24,8 @@ let _toolCalls = 0;
 let _activeTools = new Map();
 // resolved MCP calls (newest-first, capped at MAX_RESOLVED_MCP)
 let _resolvedMcp = [];
+// tool name -> latest completion/shutdown timestamp, used to ignore older replayed starts
+let _settledToolTimes = new Map();
 // active-bar pulse timer
 let _pulseTimer = null;
 // toast queue
@@ -62,6 +65,89 @@ function humanMs(ms) {
   return `${(ms / 1000).toFixed(1)}s`;
 }
 
+function toolNameFromPayload(payload) {
+  return String(payload.toolName ?? payload.tool ?? payload.name ?? '').trim();
+}
+
+function eventMillis(evt, payload) {
+  const raw = evt?.time ?? payload?.time ?? payload?.ts ?? null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric) && numeric > 0) return numeric;
+  const parsed = Date.parse(String(raw ?? ''));
+  return Number.isFinite(parsed) ? parsed : Date.now();
+}
+
+function capResolvedMcp() {
+  if (_resolvedMcp.length > MAX_RESOLVED_MCP) _resolvedMcp.length = MAX_RESOLVED_MCP;
+}
+
+function rememberSettledTool(tool, eventTime) {
+  if (!tool) return;
+  const previous = _settledToolTimes.get(tool) ?? 0;
+  if (eventTime >= previous) _settledToolTimes.set(tool, eventTime);
+  if (_settledToolTimes.size > MAX_RESOLVED_MCP * 2) {
+    const oldest = [..._settledToolTimes.entries()].sort((a, b) => a[1] - b[1])[0]?.[0];
+    if (oldest) _settledToolTimes.delete(oldest);
+  }
+}
+
+function wasSettledAfter(tool, eventTime) {
+  const settledAt = tool ? _settledToolTimes.get(tool) : null;
+  return Number.isFinite(settledAt) && Number.isFinite(eventTime) && eventTime <= settledAt;
+}
+
+function activeToolKey(trackKey, tool) {
+  if (trackKey && _activeTools.has(trackKey)) return trackKey;
+  if (tool && _activeTools.has(tool)) return tool;
+  if (tool) {
+    for (const [key, entry] of _activeTools.entries()) {
+      if (entry.tool === tool) return key;
+    }
+  }
+  if (!trackKey && !tool && _activeTools.size === 1) {
+    return _activeTools.keys().next().value;
+  }
+  return null;
+}
+
+function settleActiveTool(trackKey, tool, payload = {}, opts = {}) {
+  const key = activeToolKey(trackKey, tool);
+  if (!key) return false;
+  const entry = _activeTools.get(key);
+  if (!entry) return false;
+  const elapsed = Number(opts.durationMs ?? payload.durationMs ?? 0) || (Date.now() - entry.startedAt);
+  const status = String(payload.status ?? '').toLowerCase();
+  _resolvedMcp.unshift({
+    tool: entry.tool || tool || key,
+    durationMs: elapsed,
+    error: payload.error ?? (status && status !== 'ok' ? status : null),
+    stale: opts.stale === true,
+  });
+  rememberSettledTool(entry.tool || tool || key, Number(opts.eventTime ?? Date.now()));
+  capResolvedMcp();
+  _activeTools.delete(key);
+  if (entry.callId) _activeTools.delete(entry.callId);
+  if (entry.tool) _activeTools.delete(entry.tool);
+  if (trackKey) _activeTools.delete(trackKey);
+  if (tool) _activeTools.delete(tool);
+  return true;
+}
+
+function expireStaleActiveTools() {
+  const now = Date.now();
+  for (const [key, entry] of [..._activeTools.entries()]) {
+    if (now - entry.startedAt > STALE_CALL_MS) {
+      settleActiveTool(key, entry.tool, {}, { stale: true, durationMs: now - entry.startedAt });
+    }
+  }
+}
+
+function clearActiveToolsAsStale() {
+  for (const [key, entry] of [..._activeTools.entries()]) {
+    settleActiveTool(key, entry.tool, {}, { stale: true, durationMs: Date.now() - entry.startedAt });
+  }
+}
+
 /* ── Mount ──────────────────────────────────────────────────────────────────── */
 function mount() {
   const el = $('runtime-view');
@@ -122,6 +208,7 @@ function mount() {
     _totalTokensSaved = 0;
     _toolCalls = 0;
     _activeTools.clear();
+    _settledToolTimes.clear();
     renderAll();
   });
 
@@ -131,6 +218,7 @@ function mount() {
 
 /* ── Render ─────────────────────────────────────────────────────────────────── */
 function renderAll() {
+  expireStaleActiveTools();
   renderKPIs();
   renderMcpStrip();
   renderFeed();
@@ -162,10 +250,12 @@ function renderMcpStrip() {
     </div>`;
   });
 
-  const resolved = _resolvedMcp.slice(0, MAX_RESOLVED_MCP).map(({ tool, durationMs, error }) => {
-    const cls = error ? 'rt-mcp-pill rt-mcp-err' : 'rt-mcp-pill rt-mcp-done';
+  const resolved = _resolvedMcp.slice(0, MAX_RESOLVED_MCP).map(({ tool, durationMs, error, stale }) => {
+    const cls = error ? 'rt-mcp-pill rt-mcp-err' : stale ? 'rt-mcp-pill rt-mcp-long' : 'rt-mcp-pill rt-mcp-done';
     const badge = error
       ? `<span class="rt-mcp-badge rt-mcp-badge-err">err</span>`
+      : stale
+        ? `<span class="rt-mcp-badge rt-mcp-badge-ok">stale</span>`
       : `<span class="rt-mcp-badge rt-mcp-badge-ok">${humanMs(durationMs)}</span>`;
     return `<div class="${cls}">${esc(tool)}${badge}</div>`;
   });
@@ -182,6 +272,7 @@ function renderMcpStrip() {
 function ensurePulseTimer() {
   if (_pulseTimer || _activeTools.size === 0) return;
   _pulseTimer = setInterval(() => {
+    expireStaleActiveTools();
     if (_activeTools.size === 0) {
       clearInterval(_pulseTimer);
       _pulseTimer = null;
@@ -271,7 +362,8 @@ function showUpgradeNudge(msg, ctaUrl) {
 export function ingestEvent(evt) {
   const { type = '', payload = {} } = evt;
   const category = categoryFor(type);
-  const tool = String(payload.toolName ?? payload.tool ?? '');
+  const tool = toolNameFromPayload(payload);
+  const eventTime = eventMillis(evt, payload);
   const tokensSaved = Number(payload.tokensSaved ?? evt.tokensSaved ?? 0);
   const durationMs = Number(payload.durationMs ?? 0);
   const phase = String(payload.phase ?? payload.stage ?? '');
@@ -280,18 +372,22 @@ export function ingestEvent(evt) {
   const callId = String(payload.callId ?? '');
   const trackKey = callId || tool;
   if (type === 'mcp.call.start' && trackKey) {
-    _activeTools.set(trackKey, { tool, startedAt: Date.now(), callId });
-    _toolCalls++;
-    ensurePulseTimer();
-  } else if (type === 'mcp.call.complete' && trackKey) {
-    const entry = _activeTools.get(trackKey) ?? _activeTools.get(tool);
-    if (entry) {
-      const elapsed = Date.now() - entry.startedAt;
-      _resolvedMcp.unshift({ tool: entry.tool, durationMs: elapsed, error: payload.error ?? null });
-      if (_resolvedMcp.length > MAX_RESOLVED_MCP) _resolvedMcp.length = MAX_RESOLVED_MCP;
-      _activeTools.delete(trackKey);
-      _activeTools.delete(tool);
+    if (!wasSettledAfter(tool, eventTime)) {
+      _activeTools.set(trackKey, { tool, startedAt: Date.now(), callId });
+      _toolCalls++;
+      ensurePulseTimer();
+    }
+  } else if (
+    type === 'mcp.call.complete' ||
+    type === 'mcp.handler.complete' ||
+    type === 'mcp.handler.failed' ||
+    (type === 'tool.invocation' && trackKey)
+  ) {
+    if (!settleActiveTool(trackKey, tool, payload, { durationMs, eventTime })) {
+      rememberSettledTool(tool || trackKey, eventTime);
     }
+  } else if (type === 'nexus.shutdown' || type === 'orchestrator.disposed') {
+    clearActiveToolsAsStale();
   }
 
   // Toast for license events

package/dist/dashboard/server.js

@@ -1126,9 +1126,26 @@ export class DashboardServer {
         const capabilities = this.buildAdvertisedCapabilities();
         const compatibility = this.buildCompatibilityStatus(capabilities);
         const runtimeEnvelope = this.buildProbeRuntimeEnvelope();
+        const workspace = this.resolveCanonicalWorkspaceContext();
         return {
             dashboardApiVersion: DASHBOARD_API_VERSION,
-            projectName: path.basename(this.repoRoot) || 'workspace',
+            projectName: workspace.repoName,
+            repoIdentity: {
+                repoName: workspace.repoName,
+                repoRoot: workspace.repoRoot,
+                workspaceRoot: workspace.workspaceRoot,
+                workspaceSource: workspace.workspaceSource,
+                workspaceStateKey: workspace.stateKey,
+                remoteUrl: workspace.remoteUrl ?? null,
+                currentRepoId: null,
+            },
+            scanContext: {
+                repoRoot: workspace.repoRoot,
+                workspaceRoot: workspace.workspaceRoot,
+                workspaceSource: workspace.workspaceSource,
+                workspaceStateKey: workspace.stateKey,
+                notes: ['Probe snapshot uses the lightweight compatibility contract.'],
+            },
             capabilities,
             compatibility,
             dashboardUrl: this.getAddress(),
@@ -1513,6 +1530,10 @@ export class DashboardServer {
         if (payload.compatibility?.status !== 'compatible') {
             return false;
         }
+        const stateRoot = payload.runtimeEnvelope?.workspace?.stateRoot;
+        if (!stateRoot || path.resolve(stateRoot) !== path.resolve(resolveNexusStateDir())) {
+            return false;
+        }
         const required = payload.compatibility?.requiredCapabilities?.length
             ? payload.compatibility.requiredCapabilities
             : [...DASHBOARD_COMPATIBILITY_CAPABILITIES];

package/dist/engines/ngram-index.d.ts

@@ -11,6 +11,9 @@
  *
  * Persistence: SQLite (same pattern as memory.db / graph.db)
  */
+export declare const NGRAM_WARMUP_MAX_DB_BYTES: number;
+export declare const NGRAM_DEFAULT_ROTATE_BYTES: number;
+export declare const NGRAM_DEFAULT_FOOTPRINT_BYTES: number;
 export declare function getNgramWalPath(dbPath: string): string;
 export declare function getNgramShmPath(dbPath: string): string;
 export declare function getNgramFootprintBytes(dbPath: string): number;
@@ -147,7 +150,7 @@ export declare class NgramIndex {
     optimizeStorage(force?: boolean): void;
     /**
      * Operator-focused maintenance for the on-disk ngram DB.
-     * - Bounds runaway DB growth via rotation (default >= 1GB), counting the
+     * - Bounds runaway DB growth via rotation, counting the
      *   full SQLite footprint (db + wal + shm) so a runaway WAL triggers it.
      * - Vacuums only when safe (<= vacuumMaxBytes) and either forced or dirty.
      */

package/dist/engines/ngram-index.js

@@ -45,7 +45,9 @@ function safeStatSize(filePath) {
 // wal/shm misses the bug that turned ngram-index.db-wal into 84GB on disk.
 // ─────────────────────────────────────────────────────────────────────────────
 const NGRAM_DEFAULT_WAL_LIMIT_BYTES = 64 * 1024 * 1024; // 64 MB
-const NGRAM_DEFAULT_FOOTPRINT_BYTES = 512 * 1024 * 1024; // 512 MB
+export const NGRAM_WARMUP_MAX_DB_BYTES = 200 * 1024 * 1024; // 200 MB
+export const NGRAM_DEFAULT_ROTATE_BYTES = NGRAM_WARMUP_MAX_DB_BYTES;
+export const NGRAM_DEFAULT_FOOTPRINT_BYTES = NGRAM_WARMUP_MAX_DB_BYTES;
 const NGRAM_DEFAULT_CHECKPOINT_INTERVAL_MS = 30_000;
 const NGRAM_DEFAULT_CHECKPOINT_DOC_COUNT = 200;
 export function getNgramWalPath(dbPath) {
@@ -199,13 +201,13 @@ export class NgramIndex {
         this.warmHashSet();
         try {
             const sizeBytes = safeStatSize(this.dbPath);
-            // Only VACUUM on medium-size DBs. Large DBs (>200MB) take too long
+            // Only VACUUM on medium-size DBs. Large DBs take too long
             // synchronously — VACUUM rewrites the entire file. Skip here; let
             // periodic maintenance handle it.
-            if (sizeBytes > 32 * 1024 * 1024 && sizeBytes <= 200 * 1024 * 1024) {
+            if (sizeBytes > 32 * 1024 * 1024 && sizeBytes <= NGRAM_WARMUP_MAX_DB_BYTES) {
                 this.optimizeStorage(true);
             }
-            else if (sizeBytes > 200 * 1024 * 1024) {
+            else if (sizeBytes > NGRAM_WARMUP_MAX_DB_BYTES) {
                 logNgramNoticeOnce(`ngram:vacuum-skip:${this.dbPath}`, `[NgramIndex] skipping VACUUM on large DB (${Math.round(sizeBytes / 1024 / 1024)}MB) db=${this.dbPath}`);
             }
         }
@@ -217,17 +219,17 @@ export class NgramIndex {
         // Count the full SQLite footprint (db + wal + shm). The 84GB regression
         // happened because a 32MB db file had a 84GB -wal sibling that this
         // routine never inspected.
-        const rotateBytes = readEnvBytes('NEXUS_NGRAM_ROTATE_BYTES', 1024 * 1024 * 1024); // 1GB default
+        const rotateBytes = readEnvBytes('NEXUS_NGRAM_ROTATE_BYTES', NGRAM_DEFAULT_ROTATE_BYTES);
         const dbBytes = safeStatSize(this.dbPath);
         const footprint = getNgramFootprintBytes(this.dbPath);
         if (footprint <= 0 || footprint < rotateBytes)
             return;
-        // Keep only the most recent oversize archive to bound disk usage. When the
-        // operator opts out of archiving (ARCHIVE_OVERSIZE=0), drop the leftovers
-        // outright instead of growing a backlog of multi-GB carcasses.
+        // The n-gram DB is a rebuildable cache, so oversized rotation drops it by
+        // default. Operators can opt into one retained archive for forensics with
+        // NEXUS_NGRAM_ARCHIVE_OVERSIZE=1.
         const dir = path.dirname(this.dbPath);
         const base = path.basename(this.dbPath);
-        const archiveEnabled = process.env.NEXUS_NGRAM_ARCHIVE_OVERSIZE !== '0';
+        const archiveEnabled = process.env.NEXUS_NGRAM_ARCHIVE_OVERSIZE === '1';
         const existing = fs.existsSync(dir)
             ? fs.readdirSync(dir).filter((entry) => entry.startsWith(`${base}.oversize.`)).sort().reverse()
             : [];
@@ -324,8 +326,8 @@ export class NgramIndex {
         // Size guard: SELECT DISTINCT on very large DBs blocks startup under swap pressure.
         try {
             const sizeBytes = fs.statSync(this.dbPath).size;
-            if (sizeBytes > 200 * 1024 * 1024) {
-                logNgramNoticeOnce(`ngram:warmup-skip:${this.dbPath}`, `[NgramIndex] warmup skipped — DB too large (${Math.round(sizeBytes / 1024 / 1024)}MB > 200MB) db=${this.dbPath}`);
+            if (sizeBytes > NGRAM_WARMUP_MAX_DB_BYTES) {
+                logNgramNoticeOnce(`ngram:warmup-skip:${this.dbPath}`, `[NgramIndex] warmup skipped — DB too large (${Math.round(sizeBytes / 1024 / 1024)}MB > ${Math.round(NGRAM_WARMUP_MAX_DB_BYTES / 1024 / 1024)}MB) db=${this.dbPath}`);
                 return;
             }
         }
@@ -667,17 +669,17 @@ export class NgramIndex {
     }
     /**
      * Operator-focused maintenance for the on-disk ngram DB.
-     * - Bounds runaway DB growth via rotation (default >= 1GB), counting the
+     * - Bounds runaway DB growth via rotation, counting the
      *   full SQLite footprint (db + wal + shm) so a runaway WAL triggers it.
      * - Vacuums only when safe (<= vacuumMaxBytes) and either forced or dirty.
      */
     maintainBounded(options = {}) {
         const dbBytes = safeStatSize(this.dbPath);
         const footprint = this.getSqliteFootprintBytes();
-        const rotateBytes = readEnvBytes('NEXUS_NGRAM_ROTATE_BYTES', 1024 * 1024 * 1024);
+        const rotateBytes = readEnvBytes('NEXUS_NGRAM_ROTATE_BYTES', NGRAM_DEFAULT_ROTATE_BYTES);
         const vacuumMaxBytes = readEnvBytes('NEXUS_NGRAM_VACUUM_MAX_BYTES', 256 * 1024 * 1024);
         if (footprint >= rotateBytes && footprint > 0) {
-            const archiveEnabled = process.env.NEXUS_NGRAM_ARCHIVE_OVERSIZE !== '0';
+            const archiveEnabled = process.env.NEXUS_NGRAM_ARCHIVE_OVERSIZE === '1';
             const rotatedPath = `${this.dbPath}.oversize.${Date.now()}`;
             const removeSibling = (suffix) => {
                 try {

package/dist/engines/workflow-runtime.js

@@ -169,7 +169,15 @@ export class WorkflowRuntime {
             workflow.steps.forEach((step) => {
                 if (step.command)
                     verify.add(step.command);
-                actions.push(...step.bindings);
+                const verifierStep = step.role === 'verifier' || step.checkpoint === 'before-verify';
+                if (verifierStep) {
+                    step.bindings
+                        .filter((binding) => binding.type === 'run_command' && binding.command)
+                        .forEach((binding) => verify.add(binding.command || ''));
+                }
+                else {
+                    actions.push(...step.bindings);
+                }
             });
         }
         return {

package/dist/index.d.ts

@@ -213,6 +213,7 @@ export declare class NexusPrime {
     awaitReady(): Promise<void>;
     getClientRegistry(): ClientRegistry;
     getRuntimeHotAt(): number | null;
+    getDashboardAddress(): string | null;
     getSynapse(): SynapseRuntime | null;
     getArchitects(): ArchitectsRuntime | null;
     /**

package/dist/index.js

@@ -847,6 +847,9 @@ export class NexusPrime {
     getRuntimeHotAt() {
         return this.runtimeHotAt;
     }
+    getDashboardAddress() {
+        return this.dashboardServer.getAddress();
+    }
     getSynapse() {
         return this.synapse;
     }
@@ -1070,7 +1073,7 @@ export class NexusPrime {
         const bootstrapManifest = ensureBootstrap({
             packageRoot: PACKAGE_ROOT,
             workspaceRoot: this.getWorkspaceContext().workspaceRoot,
-            phase: 'runtime',
+            phase: 'install',
             silent: true,
         });
         this.runtime.recordBootstrapManifestStatus?.(bootstrapManifest);

package/dist/synapse/operatives/crud.js

@@ -26,7 +26,11 @@ function mapOperative(row) {
 }
 export function insertOperative(db, input) {
     const id = input.id ?? randomUUID();
-    const name = input.name ?? `operative-${id.slice(0, 8)}`;
+    const baseName = (input.name?.trim() || `operative-${id.slice(0, 8)}`).slice(0, 80);
+    let name = baseName;
+    for (let attempt = 2; getOperativeByName(db, name); attempt++) {
+        name = `${baseName}-${attempt}`;
+    }
     const budgetScope = input.budgetScope ?? (input.strikeTeamId ? 'crew' : 'operative');
     const budgetScopeId = input.budgetScopeId ?? input.strikeTeamId ?? id;
     db.prepare(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.19",
+  "version": "7.9.21",
   "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",