nexus-prime 7.9.0 → 7.9.2

package/dist/agents/adapters/mcp/async-gate.d.ts

@@ -15,6 +15,7 @@ export type AsyncJobStatus = 'pending' | 'running' | 'completed' | 'failed';
 export interface AsyncJob {
     runId: string;
     tool: string;
+    args?: Record<string, unknown>;
     status: AsyncJobStatus;
     stage: string;
     progress: number;
@@ -29,10 +30,13 @@ export interface AsyncJob {
     };
     error?: string;
     etaMs?: number;
+    lifecycleReportedAt?: number;
 }
 export interface AsyncGateOpts {
     /** Tool name — for job metadata */
     tool: string;
+    /** Original tool args, used when a poll observes final lifecycle state. */
+    args?: Record<string, unknown>;
     /** If handler resolves within this window, return inline. Default: 2000ms */
     maxSyncMs?: number;
     /** Human-readable hint for estimated duration */
@@ -67,6 +71,7 @@ declare class AsyncGate {
         }>;
     };
     updateStage(runId: string, stage: string, progress: number): void;
+    markLifecycleReported(runId: string): void;
     /** Return jobs that have been running longer than their stale threshold. */
     getStaleJobs(now: number, defaultStaleMs: number, etaMultiplier: number): AsyncJob[];
     /** Mark a running job as failed (watchdog reap). */

package/dist/agents/adapters/mcp/async-gate.js

@@ -25,6 +25,7 @@ class AsyncGate {
         const job = {
             runId,
             tool: opts.tool,
+            args: opts.args,
             status: 'pending',
             stage: 'queued',
             progress: 0,
@@ -55,8 +56,12 @@ class AsyncGate {
                 job.error = err instanceof Error ? err.message : String(err);
                 job.completedAt = Date.now();
                 nexusEventBus.emit('async_gate.failed', { runId, tool: opts.tool, error: job.error });
-                // Do not rethrow — if deadline already won there is no downstream catcher;
-                // job state is updated so polls return the error correctly.
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Run ${runId} failed\nTool: ${opts.tool}\nError: ${job.error ?? 'unknown'}`,
+                        }],
+                };
             }
         })();
         // Suppress unhandled rejection: deadline may win while work is still in flight.
@@ -118,6 +123,11 @@ class AsyncGate {
             job.progress = Math.min(99, progress);
         }
     }
+    markLifecycleReported(runId) {
+        const job = this.jobs.get(runId);
+        if (job)
+            job.lifecycleReportedAt = Date.now();
+    }
     /** Return jobs that have been running longer than their stale threshold. */
     getStaleJobs(now, defaultStaleMs, etaMultiplier) {
         const stale = [];

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

@@ -26,6 +26,23 @@ const SLOW_TOOLS = new Set([
     'nexus_ghost_pass',
     'nexus_spawn_workers',
     'nexus_optimize_tokens',
+    'nexus_search',
+    'nexus_assemble_context',
+    'nexus_graph_query',
+    'nexus_session_search',
+    'nexus_memory_export',
+    'nexus_memory_backup',
+    'nexus_memory_import',
+    'nexus_memory_hygiene',
+    'nexus_memory_audit',
+    'nexus_pattern_search',
+    'nexus_knowledge_provenance',
+    'nexus_rag_ingest_collection',
+    'nexus_workflow_run',
+    'nexus_automation_run',
+    'nexus_doctor',
+    'nexus_autofix',
+    'nexus_hypertune_max',
 ]);
 /** Estimated wall-clock duration for each slow tool (ms). */
 const TOOL_ETA_MS = {
@@ -34,6 +51,23 @@ const TOOL_ETA_MS = {
     nexus_ghost_pass: 45_000,
     nexus_spawn_workers: 30_000,
     nexus_optimize_tokens: 10_000,
+    nexus_search: 20_000,
+    nexus_assemble_context: 20_000,
+    nexus_graph_query: 30_000,
+    nexus_session_search: 20_000,
+    nexus_memory_export: 20_000,
+    nexus_memory_backup: 30_000,
+    nexus_memory_import: 30_000,
+    nexus_memory_hygiene: 30_000,
+    nexus_memory_audit: 30_000,
+    nexus_pattern_search: 20_000,
+    nexus_knowledge_provenance: 20_000,
+    nexus_rag_ingest_collection: 45_000,
+    nexus_workflow_run: 45_000,
+    nexus_automation_run: 45_000,
+    nexus_doctor: 20_000,
+    nexus_autofix: 45_000,
+    nexus_hypertune_max: 45_000,
 };
 /**
  * Route a tool call to the appropriate handler group.
@@ -90,7 +124,7 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
             const gated = await withAsyncGate(async () => {
                 const r = await runHandlers();
                 return r ?? { content: [{ type: 'text', text: `Tool ${toolName} returned no result` }] };
-            }, { tool: toolName, maxSyncMs: 2000, etaMs: TOOL_ETA_MS[toolName] });
+            }, { tool: toolName, args, maxSyncMs: 2000, etaMs: TOOL_ETA_MS[toolName] });
             if ('queued' in gated && gated.queued) {
                 // Persist orchestration run record for durable stage tracking
                 if (toolName === 'nexus_orchestrate') {

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

@@ -4,10 +4,11 @@
  * federation_status, run_status.
  * Extracted from mcp.ts (Phase 3 split).
  */
-import { formatBullets, formatJsonDetails, } from '../helpers.js';
+import { formatBullets, formatJsonDetails, 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';
+import * as path from 'path';
 import { requireRuntime } from '../util/require-runtime.js';
 import { getAsyncGate } from '../async-gate.js';
 import { getRun as getOrchRun } from '../../../../engines/orchestrator/store.js';
@@ -231,6 +232,37 @@ export async function handleRuntimeGroup(toolName, hctx, request, args, ctx) {
             // Check async gate first (fast in-memory jobs from withAsyncGate)
             const asyncJob = getAsyncGate().getJob(runId);
             if (asyncJob) {
+                if (!asyncJob.lifecycleReportedAt
+                    && (asyncJob.status === 'completed' || asyncJob.status === 'failed')) {
+                    if (asyncJob.status === 'completed') {
+                        hctx.telemetry.observeSuccessfulToolCall(asyncJob.tool, asyncJob.args ?? {});
+                    }
+                    const shouldPersistSuccess = [
+                        'nexus_orchestrate',
+                        'nexus_plan_execution',
+                        'nexus_session_dna',
+                        'nexus_ghost_pass',
+                        'nexus_mindkit_check',
+                    ].includes(asyncJob.tool);
+                    try {
+                        if (asyncJob.tool !== 'nexus_store_memory' && (asyncJob.status === 'failed' || shouldPersistSuccess)) {
+                            const workspace = hctx.getWorkspace(asyncJob.args ?? {});
+                            const repoName = workspace.repoName || path.basename(workspace.repoRoot || '');
+                            const summary = asyncJob.status === 'completed'
+                                ? `MCP ${asyncJob.tool} completed asynchronously. ${buildAutoMemorySummary(asyncJob.tool, asyncJob.args ?? {})}`
+                                : `MCP ${asyncJob.tool} failed asynchronously: ${asyncJob.error ?? 'unknown failure'}. ${buildAutoMemorySummary(asyncJob.tool, asyncJob.args ?? {})}`;
+                            hctx.nexusRef.storeMemory(summary.slice(0, 1200), asyncJob.status === 'completed' ? 0.55 : 0.72, [
+                                '#mcp-result',
+                                '#auto',
+                                `#tool:${asyncJob.tool}`,
+                                ...(repoName ? [`repo:${repoName}`, `#repo:${repoName}`] : []),
+                                ...(asyncJob.status === 'completed' ? ['#workspace'] : ['#failure-mode', '#runtime-result', '#inbox']),
+                            ]);
+                        }
+                    }
+                    catch { /* best-effort lifecycle memory */ }
+                    getAsyncGate().markLifecycleReported(runId);
+                }
                 if (fmt === 'nxl')
                     return nxlResult(asyncJob);
                 return getAsyncGate().formatStatus(runId);

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

@@ -7,7 +7,7 @@
  *   3. Transient retries   — SQLite-busy / cold runtime → one retry with backoff.
  *
  * Per-client timeouts (AI Lead refinement):
- *   Codex 90 s · Claude Code 60 s · Cursor 30 s · default 25 s
+ *   Codex 90 s · Claude Code 60 s · Cursor 30 s · MCP clients 60 s · default 60 s
  *
  * Types and `envelopeToMcpResponse` are canonical in ./envelope.ts;
  * re-exported from here for backward compatibility.
@@ -16,6 +16,7 @@ import type { RunHandlerOptions } from './envelope.js';
 import type { HandlerEnvelope } from './envelope.js';
 export type { HandlerErrorCode, HandlerEnvelope, RunHandlerOptions } from './envelope.js';
 export { envelopeToMcpResponse } from './envelope.js';
+export declare function resolveHandlerTimeoutForTest(opts?: RunHandlerOptions): number;
 /**
  * Run a handler function with timeout, retry, and structured envelope.
  *

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

@@ -7,7 +7,7 @@
  *   3. Transient retries   — SQLite-busy / cold runtime → one retry with backoff.
  *
  * Per-client timeouts (AI Lead refinement):
- *   Codex 90 s · Claude Code 60 s · Cursor 30 s · default 25 s
+ *   Codex 90 s · Claude Code 60 s · Cursor 30 s · MCP clients 60 s · default 60 s
  *
  * Types and `envelopeToMcpResponse` are canonical in ./envelope.ts;
  * re-exported from here for backward compatibility.
@@ -20,16 +20,25 @@ const CLIENT_TIMEOUTS = {
     'codex': 90_000,
     'claude-code': 60_000,
     'cursor': 30_000,
+    'openclaw': 90_000,
+    'opencode': 90_000,
+    'windsurf': 90_000,
+    'antigravity': 90_000,
+    'mcp': 60_000,
 };
-const DEFAULT_TIMEOUT = 25_000;
+const DEFAULT_TIMEOUT = 60_000;
 function resolveTimeout(opts) {
     if (opts.timeoutMs !== undefined)
         return opts.timeoutMs;
-    if (opts.callerName && opts.callerName in CLIENT_TIMEOUTS) {
-        return CLIENT_TIMEOUTS[opts.callerName];
+    const callerName = String(opts.callerName ?? '').trim().toLowerCase();
+    if (callerName && callerName in CLIENT_TIMEOUTS) {
+        return CLIENT_TIMEOUTS[callerName];
     }
     return DEFAULT_TIMEOUT;
 }
+export function resolveHandlerTimeoutForTest(opts = {}) {
+    return resolveTimeout(opts);
+}
 // ─── Error classification ─────────────────────────────────────────────────────
 function classifyError(err) {
     const msg = err instanceof Error ? err.message : String(err);

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

@@ -59,6 +59,8 @@ export declare class MCPAdapter implements Adapter {
         }>;
     }>;
     private executeToolRequest;
+    private parseAsyncReceipt;
+    private maybeStoreToolOutcomeMemory;
     private buildHandlerCtx;
     private handleToolCall;
     /**

package/dist/agents/adapters/mcp.js

@@ -818,6 +818,7 @@ export class MCPAdapter {
         const result = envelopeToMcpResponse(envelope);
         const durationMs = Date.now() - startTimeMs;
         const resultPreview = envelope.ok ? buildResultPreview(result) : null;
+        const asyncReceipt = envelope.ok ? this.parseAsyncReceipt(result) : null;
         nexusEventBus.emit('mcp.call.complete', {
             callId,
             serverName: 'nexus-prime',
@@ -830,27 +831,71 @@ export class MCPAdapter {
                 ? { result: resultPreview }
                 : { error: envelope.error.message }),
         });
-        this.telemetry.observeSuccessfulToolCall(toolName, args);
-        // Surface meaningful tool calls on the SSE feed without persisting them as memories.
-        // Previously a low-priority memory was auto-stored on every non-read-only tool call,
-        // which polluted recall with audit-log entries like "nexus_store_memory: priority=0.85,
-        // tags=...". Recall now stays focused on user-stored knowledge.
-        if (this.nexusRef && !isReadOnlyMcpTool(toolName)) {
+        if (envelope.ok && !asyncReceipt?.queued) {
+            this.telemetry.observeSuccessfulToolCall(toolName, args);
+        }
+        // Surface meaningful tool calls on the SSE feed; persist only high-signal outcomes.
+        if (this.nexusRef) {
             const repoRoot = this.nexusRef.getWorkspaceContext?.()?.repoRoot ?? '';
             const repoName = repoRoot ? path.basename(repoRoot) : '';
-            try {
-                nexusEventBus.emit('memory.snapshot', {
-                    kind: 'tool-invocation',
-                    toolName,
-                    repo: repoName,
-                    summary: buildAutoMemorySummary(toolName, args),
-                });
+            if (!isReadOnlyMcpTool(toolName)) {
+                try {
+                    nexusEventBus.emit('memory.snapshot', {
+                        kind: 'tool-invocation',
+                        toolName,
+                        repo: repoName,
+                        summary: buildAutoMemorySummary(toolName, args),
+                    });
+                }
+                catch { /* best-effort */ }
             }
-            catch { /* best-effort */ }
+            this.maybeStoreToolOutcomeMemory(toolName, args, envelope, durationMs, repoName, asyncReceipt);
         }
         const decorated = this.decorateLifecycleResponse(toolName, result);
         return this.injectMemoryContext(toolName, args, decorated);
     }
+    parseAsyncReceipt(result) {
+        const text = result.content?.[0]?.text;
+        if (!text)
+            return null;
+        try {
+            const parsed = JSON.parse(String(text).split('\n\n')[0] ?? '{}');
+            return parsed && typeof parsed === 'object' && parsed.queued === true ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    maybeStoreToolOutcomeMemory(toolName, args, envelope, durationMs, repoName, asyncReceipt) {
+        if (!this.nexusRef || toolName === 'nexus_store_memory')
+            return;
+        if (asyncReceipt?.queued)
+            return;
+        const shouldPersistSuccess = [
+            'nexus_orchestrate',
+            'nexus_plan_execution',
+            'nexus_session_dna',
+            'nexus_ghost_pass',
+            'nexus_mindkit_check',
+        ].includes(toolName);
+        if (envelope.ok && !shouldPersistSuccess)
+            return;
+        const error = envelope.error;
+        const summary = envelope.ok
+            ? `MCP ${toolName} completed in ${durationMs}ms. ${buildAutoMemorySummary(toolName, args)}`
+            : `MCP ${toolName} failed after ${durationMs}ms: ${error?.code ?? 'error'} ${error?.message ?? 'unknown failure'}. ${buildAutoMemorySummary(toolName, args)}`;
+        const tags = [
+            '#mcp-result',
+            '#auto',
+            `#tool:${toolName}`,
+            ...(repoName ? [`repo:${repoName}`, `#repo:${repoName}`] : []),
+            ...(envelope.ok ? ['#workspace'] : ['#failure-mode', '#runtime-result', '#inbox']),
+        ];
+        try {
+            this.nexusRef.storeMemory(summary.slice(0, 1200), envelope.ok ? 0.55 : 0.72, tags);
+        }
+        catch { /* best-effort */ }
+    }
     buildHandlerCtx(args = {}) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;

package/dist/architects/bootstrap.js

@@ -245,12 +245,30 @@ export function initArchitects(options) {
             nexusEventBus.emit('architects.event.failed', { event: 'striketeam.deployed', strikeTeamId, error: String(err) });
         }
     };
+    const onStriketeamFinished = ({ strikeTeamId, intent, outcome }) => {
+        try {
+            if (intent === 'mutate' && outcome !== 'cancelled' && outcome !== 'failed')
+                return;
+            const worklistId = implicitWorklistByTeam.get(strikeTeamId);
+            if (!worklistId)
+                return;
+            db.prepare(`
+        UPDATE architects_work_items SET status='cancelled'
+        WHERE worklist_id=? AND status='todo'
+      `).run(worklistId);
+        }
+        catch (err) {
+            console.error('[Architects] onStriketeamFinished failed', strikeTeamId, err);
+            nexusEventBus.emit('architects.event.failed', { event: 'striketeam.finished', strikeTeamId, error: String(err) });
+        }
+    };
     const onStanddown = () => setConvergencePaused(true);
     const onResumed = () => setConvergencePaused(false);
     const unsubOperative = nexusEventBus.on('synapse.operative.hired', onOperativeHired);
     const unsubMission = nexusEventBus.on('synapse.mission.assigned', onMissionAssigned);
     const unsubSortie = nexusEventBus.on('synapse.sortie.completed', onSortieCompleted);
     const unsubTeam = nexusEventBus.on('synapse.striketeam.deployed', onStriketeamDeployed);
+    const unsubFinished = nexusEventBus.on('synapse.striketeam.finished', onStriketeamFinished);
     const unsubStanddown = nexusEventBus.on('synapse.compaction.standdown', onStanddown);
     const unsubResumed = nexusEventBus.on('synapse.compaction.resumed', onResumed);
     nexusEventBus.emit('architects.ready', { version: '5.0.0' });
@@ -321,6 +339,7 @@ export function initArchitects(options) {
             unsubMission();
             unsubSortie();
             unsubTeam();
+            unsubFinished();
             unsubStanddown();
             unsubResumed();
             db.close();

package/dist/architects/db/schema.d.ts

@@ -1,3 +1,3 @@
 import type { ArchitectsDb } from '../types.js';
-export declare const ARCHITECTS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS architects_blueprints (\n  id             TEXT PRIMARY KEY,\n  strike_team_id TEXT,\n  title          TEXT NOT NULL,\n  workflow_id    TEXT,\n  status         TEXT NOT NULL DEFAULT 'active'\n    CHECK(status IN ('draft','active','converging','done','archived')),\n  variables      TEXT NOT NULL DEFAULT '{}',\n  worklist_id    TEXT,\n  created_at     TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_worklists (\n  id           TEXT PRIMARY KEY,\n  blueprint_id TEXT NOT NULL,\n  title        TEXT NOT NULL,\n  created_at   TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_work_items (\n  id                    TEXT PRIMARY KEY,\n  worklist_id           TEXT NOT NULL,\n  title                 TEXT NOT NULL,\n  parent_work_item_id   TEXT,\n  correlation_id        TEXT,\n  ancestry_path         TEXT NOT NULL DEFAULT '[]',\n  status                TEXT NOT NULL DEFAULT 'todo'\n    CHECK(status IN ('todo','claimed','in_progress','done','failed','blocked')),\n  depends_on            TEXT NOT NULL DEFAULT '[]',\n  assigned_operative_id TEXT,\n  construction_lock_id  TEXT,\n  branch                TEXT,\n  merged_at             TEXT,\n  created_at            TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_construction_locks (\n  id            TEXT PRIMARY KEY,\n  work_item_id  TEXT NOT NULL,\n  operative_id  TEXT NOT NULL,\n  acquired_at   TEXT NOT NULL DEFAULT (datetime('now')),\n  released_at   TEXT,\n  lease_duration_ms INTEGER NOT NULL DEFAULT 300000,\n  lease_renewed_at  INTEGER,\n  lease_expires_at  INTEGER NOT NULL DEFAULT 0,\n  hook_ref      TEXT\n);\n\nCREATE TABLE IF NOT EXISTS architects_relay_messages (\n  id                TEXT PRIMARY KEY,\n  from_operative_id TEXT NOT NULL,\n  to_operative_id   TEXT,\n  strike_team_id    TEXT,\n  subject           TEXT NOT NULL,\n  body              TEXT NOT NULL,\n  sent_at           TEXT NOT NULL DEFAULT (datetime('now')),\n  read_at           TEXT,\n  priority          TEXT NOT NULL DEFAULT 'normal'\n    CHECK(priority IN ('normal','urgent'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_convergence_runs (\n  id             TEXT PRIMARY KEY,\n  worklist_id    TEXT NOT NULL,\n  strategy       TEXT NOT NULL DEFAULT 'bisecting'\n    CHECK(strategy IN ('sequential','bisecting')),\n  work_item_ids  TEXT NOT NULL DEFAULT '[]',\n  status         TEXT NOT NULL DEFAULT 'running'\n    CHECK(status IN ('running','merged','failed','bisecting','deferred')),\n  failed_item_id TEXT,\n  started_at     TEXT NOT NULL DEFAULT (datetime('now')),\n  completed_at   TEXT\n);\n\nCREATE TABLE IF NOT EXISTS architects_dispatch_queue (\n  id             TEXT PRIMARY KEY,\n  operative_id   TEXT NOT NULL,\n  work_item_id   TEXT NOT NULL,\n  scheduled_at   TEXT NOT NULL DEFAULT (datetime('now')),\n  dispatched_at  TEXT,\n  status         TEXT NOT NULL DEFAULT 'queued'\n    CHECK(status IN ('queued','dispatched','failed'))\n);\n\nCREATE INDEX IF NOT EXISTS idx_arch_items_worklist   ON architects_work_items(worklist_id, status);\nCREATE INDEX IF NOT EXISTS idx_arch_items_operative  ON architects_work_items(assigned_operative_id);\nCREATE INDEX IF NOT EXISTS idx_arch_locks_item       ON architects_construction_locks(work_item_id, released_at);\nCREATE INDEX IF NOT EXISTS idx_arch_blueprints_team   ON architects_blueprints(strike_team_id, worklist_id);\nCREATE INDEX IF NOT EXISTS idx_arch_relay_to_op      ON architects_relay_messages(to_operative_id, read_at);\nCREATE INDEX IF NOT EXISTS idx_arch_relay_to_team    ON architects_relay_messages(strike_team_id, read_at);\n";
+export declare const ARCHITECTS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS architects_blueprints (\n  id             TEXT PRIMARY KEY,\n  strike_team_id TEXT,\n  title          TEXT NOT NULL,\n  workflow_id    TEXT,\n  status         TEXT NOT NULL DEFAULT 'active'\n    CHECK(status IN ('draft','active','converging','done','archived')),\n  variables      TEXT NOT NULL DEFAULT '{}',\n  worklist_id    TEXT,\n  created_at     TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_worklists (\n  id           TEXT PRIMARY KEY,\n  blueprint_id TEXT NOT NULL,\n  title        TEXT NOT NULL,\n  created_at   TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_work_items (\n  id                    TEXT PRIMARY KEY,\n  worklist_id           TEXT NOT NULL,\n  title                 TEXT NOT NULL,\n  parent_work_item_id   TEXT,\n  correlation_id        TEXT,\n  ancestry_path         TEXT NOT NULL DEFAULT '[]',\n  status                TEXT NOT NULL DEFAULT 'todo'\n    CHECK(status IN ('todo','claimed','in_progress','done','failed','blocked','cancelled')),\n  depends_on            TEXT NOT NULL DEFAULT '[]',\n  assigned_operative_id TEXT,\n  construction_lock_id  TEXT,\n  branch                TEXT,\n  merged_at             TEXT,\n  created_at            TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_construction_locks (\n  id            TEXT PRIMARY KEY,\n  work_item_id  TEXT NOT NULL,\n  operative_id  TEXT NOT NULL,\n  acquired_at   TEXT NOT NULL DEFAULT (datetime('now')),\n  released_at   TEXT,\n  lease_duration_ms INTEGER NOT NULL DEFAULT 300000,\n  lease_renewed_at  INTEGER,\n  lease_expires_at  INTEGER NOT NULL DEFAULT 0,\n  hook_ref      TEXT\n);\n\nCREATE TABLE IF NOT EXISTS architects_relay_messages (\n  id                TEXT PRIMARY KEY,\n  from_operative_id TEXT NOT NULL,\n  to_operative_id   TEXT,\n  strike_team_id    TEXT,\n  subject           TEXT NOT NULL,\n  body              TEXT NOT NULL,\n  sent_at           TEXT NOT NULL DEFAULT (datetime('now')),\n  read_at           TEXT,\n  priority          TEXT NOT NULL DEFAULT 'normal'\n    CHECK(priority IN ('normal','urgent'))\n);\n\nCREATE TABLE IF NOT EXISTS architects_convergence_runs (\n  id             TEXT PRIMARY KEY,\n  worklist_id    TEXT NOT NULL,\n  strategy       TEXT NOT NULL DEFAULT 'bisecting'\n    CHECK(strategy IN ('sequential','bisecting')),\n  work_item_ids  TEXT NOT NULL DEFAULT '[]',\n  status         TEXT NOT NULL DEFAULT 'running'\n    CHECK(status IN ('running','merged','failed','bisecting','deferred')),\n  failed_item_id TEXT,\n  started_at     TEXT NOT NULL DEFAULT (datetime('now')),\n  completed_at   TEXT\n);\n\nCREATE TABLE IF NOT EXISTS architects_dispatch_queue (\n  id             TEXT PRIMARY KEY,\n  operative_id   TEXT NOT NULL,\n  work_item_id   TEXT NOT NULL,\n  scheduled_at   TEXT NOT NULL DEFAULT (datetime('now')),\n  dispatched_at  TEXT,\n  status         TEXT NOT NULL DEFAULT 'queued'\n    CHECK(status IN ('queued','dispatched','failed'))\n);\n\nCREATE INDEX IF NOT EXISTS idx_arch_items_worklist   ON architects_work_items(worklist_id, status);\nCREATE INDEX IF NOT EXISTS idx_arch_items_operative  ON architects_work_items(assigned_operative_id);\nCREATE INDEX IF NOT EXISTS idx_arch_locks_item       ON architects_construction_locks(work_item_id, released_at);\nCREATE INDEX IF NOT EXISTS idx_arch_blueprints_team   ON architects_blueprints(strike_team_id, worklist_id);\nCREATE INDEX IF NOT EXISTS idx_arch_relay_to_op      ON architects_relay_messages(to_operative_id, read_at);\nCREATE INDEX IF NOT EXISTS idx_arch_relay_to_team    ON architects_relay_messages(strike_team_id, read_at);\n";
 export declare function initArchitectsSchema(db: ArchitectsDb): void;

package/dist/architects/db/schema.js

@@ -27,7 +27,7 @@ CREATE TABLE IF NOT EXISTS architects_work_items (
   correlation_id        TEXT,
   ancestry_path         TEXT NOT NULL DEFAULT '[]',
   status                TEXT NOT NULL DEFAULT 'todo'
-    CHECK(status IN ('todo','claimed','in_progress','done','failed','blocked')),
+    CHECK(status IN ('todo','claimed','in_progress','done','failed','blocked','cancelled')),
   depends_on            TEXT NOT NULL DEFAULT '[]',
   assigned_operative_id TEXT,
   construction_lock_id  TEXT,
@@ -100,10 +100,49 @@ function addColumnIfMissing(db, table, column, ddl) {
         return;
     db.prepare(ddl).run();
 }
+/**
+ * Migrate architects_work_items to allow 'cancelled' status.
+ *
+ * SQLite cannot ALTER a CHECK constraint, so we recreate the table when the
+ * existing CHECK does not include 'cancelled'. Safe to call on new databases
+ * (the table won't exist yet — `CREATE TABLE IF NOT EXISTS` in ARCHITECTS_SCHEMA
+ * already includes 'cancelled', so nothing needs doing).
+ */
+function migrateWorkItemCancelledStatus(db) {
+    const existing = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='architects_work_items'`).get();
+    if (!existing?.sql)
+        return; // new DB — schema string already has 'cancelled'
+    if (existing.sql.includes("'cancelled'"))
+        return; // already migrated
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS architects_work_items_v2 (
+      id                    TEXT PRIMARY KEY,
+      worklist_id           TEXT NOT NULL,
+      title                 TEXT NOT NULL,
+      parent_work_item_id   TEXT,
+      correlation_id        TEXT,
+      ancestry_path         TEXT NOT NULL DEFAULT '[]',
+      status                TEXT NOT NULL DEFAULT 'todo'
+        CHECK(status IN ('todo','claimed','in_progress','done','failed','blocked','cancelled')),
+      depends_on            TEXT NOT NULL DEFAULT '[]',
+      assigned_operative_id TEXT,
+      construction_lock_id  TEXT,
+      branch                TEXT,
+      merged_at             TEXT,
+      created_at            TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    INSERT OR IGNORE INTO architects_work_items_v2 SELECT * FROM architects_work_items;
+    DROP TABLE architects_work_items;
+    ALTER TABLE architects_work_items_v2 RENAME TO architects_work_items;
+    CREATE INDEX IF NOT EXISTS idx_arch_items_worklist  ON architects_work_items(worklist_id, status);
+    CREATE INDEX IF NOT EXISTS idx_arch_items_operative ON architects_work_items(assigned_operative_id);
+  `);
+}
 export function initArchitectsSchema(db) {
     // File-based forward-only migrations (PRAGMA user_version scheme).
     runMigrations(db, 'architects');
     db.exec(ARCHITECTS_SCHEMA);
+    migrateWorkItemCancelledStatus(db);
     addColumnIfMissing(db, 'architects_work_items', 'parent_work_item_id', 'ALTER TABLE architects_work_items ADD COLUMN parent_work_item_id TEXT');
     addColumnIfMissing(db, 'architects_work_items', 'correlation_id', 'ALTER TABLE architects_work_items ADD COLUMN correlation_id TEXT');
     addColumnIfMissing(db, 'architects_work_items', 'ancestry_path', "ALTER TABLE architects_work_items ADD COLUMN ancestry_path TEXT NOT NULL DEFAULT '[]'");

package/dist/architects/types.d.ts

@@ -5,7 +5,7 @@ import type { PersistentWorkLedger } from '../engines/work-ledger.js';
 import type { NexusNetRelay } from '../engines/nexusnet-relay.js';
 import type { EngineHealthStatus } from '../engines/runtime-health.js';
 export type ArchitectsDb = BetterSqlite3.Database;
-export type WorkItemStatus = 'todo' | 'claimed' | 'in_progress' | 'done' | 'failed' | 'blocked';
+export type WorkItemStatus = 'todo' | 'claimed' | 'in_progress' | 'done' | 'failed' | 'blocked' | 'cancelled';
 export type BlueprintStatus = 'draft' | 'active' | 'converging' | 'done' | 'archived';
 export type ClaimScope = 'workitem' | 'goal' | 'mission' | 'crew' | 'project';
 export interface Blueprint {

package/dist/daemon/client.d.ts

@@ -2,6 +2,7 @@ import type { WorkspaceContext } from '../engines/workspace-resolver.js';
 import { type DaemonLockRecord } from './lock.js';
 export interface DaemonHealthResponse {
     ok: boolean;
+    ready?: boolean;
     pid: number;
     port: number;
     stateKey: string;

package/dist/daemon/client.js

@@ -16,6 +16,7 @@ function readCliPkgVersion() {
     return 'unknown';
 }
 import { acquireDaemonLock, getDaemonLockPath, isProcessAlive, readDaemonLock, removeDaemonLock, } from './lock.js';
+const DEFAULT_DAEMON_READY_TIMEOUT_MS = 45_000;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -111,7 +112,7 @@ function spawnDaemonProcess(workspace, entrypoint) {
     child.unref();
 }
 export async function ensureDaemonReady(workspace, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 15_000;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_DAEMON_READY_TIMEOUT_MS;
     const existing = acquireDaemonLock(workspace);
     if (existing.status === 'running') {
         const currentVersion = readCliPkgVersion();

package/dist/daemon/server.d.ts

@@ -13,6 +13,7 @@ export declare class NexusDaemonServer {
     private lockRecord;
     private heartbeatTimer;
     private stopping;
+    private runtimeReady;
     constructor(workspace: WorkspaceContext);
     private installProcessErrorHandlers;
     /**
@@ -21,6 +22,7 @@ export declare class NexusDaemonServer {
      * holding stale references.
      */
     getLockRecord(): DaemonLockRecord | null;
+    private startHeartbeat;
     start(): Promise<{
         started: boolean;
         record: DaemonLockRecord;

package/dist/daemon/server.js

@@ -101,6 +101,7 @@ export class NexusDaemonServer {
     lockRecord = null;
     heartbeatTimer = null;
     stopping = false;
+    runtimeReady = false;
     constructor(workspace) {
         this.workspace = workspace;
         this.httpServer = http.createServer((req, res) => {
@@ -156,6 +157,25 @@ export class NexusDaemonServer {
     getLockRecord() {
         return this.lockRecord;
     }
+    startHeartbeat() {
+        if (this.heartbeatTimer) {
+            return;
+        }
+        this.heartbeatTimer = setInterval(() => {
+            if (this.lockPath && this.lockRecord) {
+                try {
+                    this.lockRecord = writeDaemonLock(this.lockPath, {
+                        ...this.lockRecord,
+                        heartbeatAt: Date.now(),
+                    });
+                }
+                catch {
+                    // Non-fatal; worst case the next starter will detect us as stale.
+                }
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref?.();
+    }
     async start() {
         // Clear the stopping flag so a second start() after a supervisor-triggered
         // stop() doesn't silently no-op via the SIGINT/SIGTERM handler guard.
@@ -171,6 +191,17 @@ export class NexusDaemonServer {
                 record: lock.record,
             };
         }
+        const port = await listen(this.httpServer, this.host);
+        this.lockRecord = writeDaemonLock(this.lockPath, {
+            ...lock.record,
+            port,
+            token: this.authToken,
+            heartbeatAt: Date.now(),
+            pkgVersion: DAEMON_PKG_VERSION,
+        });
+        this.startHeartbeat();
+        this.installSignalHandlers();
+        this.installProcessErrorHandlers();
         await runStartupHygiene({
             repoRoot: this.workspace.repoRoot,
             workspaceStateRoot: this.workspace.stateRoot,
@@ -183,6 +214,7 @@ export class NexusDaemonServer {
         if (!preflight.ok) {
             console.error(`[nexus-daemon] startup-error: ${preflight.code} — ${preflight.hint}`);
             console.error(`[nexus-daemon] startup-error.json written to ${this.workspace.stateRoot}`);
+            await this.stop('startup-error');
             return { started: false, record: lock.record };
         }
         // Integrity check: detect + auto-repair corrupt sqlite files before
@@ -196,6 +228,7 @@ export class NexusDaemonServer {
             },
         });
         await this.nexus.start();
+        this.runtimeReady = true;
         // Optional repo-search prewarm. It can be CPU-heavy in large workspaces, so
         // keep daemon startup and dashboard responsiveness as the default behavior.
         if (process.env.NEXUS_PREWARM_REPO_SEARCH === '1' && this.workspace.gitRoot) {
@@ -206,33 +239,6 @@ export class NexusDaemonServer {
         // Warm the invoker availability cache so /api/runtimes returns fast and
         // the dashboard runtime badges render immediately on first load.
         setImmediate(() => { invokerRegistry.warmCache(); });
-        const port = await listen(this.httpServer, this.host);
-        this.lockRecord = writeDaemonLock(this.lockPath, {
-            ...lock.record,
-            port,
-            token: this.authToken,
-            heartbeatAt: Date.now(),
-            pkgVersion: DAEMON_PKG_VERSION,
-        });
-        // Heartbeat: keep lockfile fresh so stale-lock detection (30 s TTL) works
-        // correctly after a SIGKILL.  The interval is intentionally unref'd so it
-        // does not prevent clean shutdown.
-        this.heartbeatTimer = setInterval(() => {
-            if (this.lockPath && this.lockRecord) {
-                try {
-                    this.lockRecord = writeDaemonLock(this.lockPath, {
-                        ...this.lockRecord,
-                        heartbeatAt: Date.now(),
-                    });
-                }
-                catch {
-                    // Non-fatal; worst case the next starter will detect us as stale.
-                }
-            }
-        }, HEARTBEAT_INTERVAL_MS);
-        this.heartbeatTimer.unref?.();
-        this.installSignalHandlers();
-        this.installProcessErrorHandlers();
         return {
             started: true,
             record: this.lockRecord,
@@ -374,8 +380,11 @@ export class NexusDaemonServer {
                 return;
             }
             if (req.method === 'GET' && url.pathname === '/health') {
-                sendJson(res, 200, {
-                    ok: true,
+                const ready = this.runtimeReady && this.nexus !== null;
+                sendJson(res, ready ? 200 : 503, {
+                    ok: ready,
+                    ready,
+                    error: ready ? undefined : 'runtime-initializing',
                     pid: process.pid,
                     port: this.lockRecord?.port ?? 0,
                     stateKey: this.workspace.stateKey,
@@ -429,6 +438,7 @@ export class NexusDaemonServer {
             return;
         }
         this.stopping = true;
+        this.runtimeReady = false;
         nexusEventBus.emit('nexus.shutdown', { signal });
         this.cleanupTimer.unref?.();
         try {

package/dist/dashboard/app/main.js

@@ -27,6 +27,24 @@ import { mount as mountRuntimeBadges } from './widgets/runtime-badge.js';
 
 const $ = id => document.getElementById(id);
 const esc = s => s==null?'':String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+let memoryReloadTimer = null;
+
+function _memoryApiUrl() {
+    return S.workspace?.repoName ? '/api/memory?repo='+encodeURIComponent(S.workspace.repoName) : '/api/memory';
+}
+
+function _refreshMemorySoon() {
+    bustCache(_memoryApiUrl());
+    bustCache('/api/memory');
+    bustCache('/api/memory/health');
+    bustCache('/api/dashboard/surface/memory');
+    if (S.tab !== 'memory') return;
+    clearTimeout(memoryReloadTimer);
+    memoryReloadTimer = setTimeout(() => {
+        memoryReloadTimer = null;
+        Memory.load();
+    }, 150);
+}
 
 /* ─────────────────── Router ─────────────────── */
 navRegister('board',      Board.load);
@@ -53,15 +71,19 @@ setOnEvent(evt => {
         Board.render();
         _renderTicker();
     }
-    // Refresh tool health tile on any tool invocation event (board always refreshes)
-    if (String(evt.type||'') === 'tool.invocation' && tab === 'board') {
-        Board.loadToolHealth();
+    // Refresh tool health tile on tool lifecycle events.
+    if (['tool.invocation', 'mcp.handler.complete', 'mcp.handler.failed'].includes(String(evt.type||''))) {
+        bustCache('/api/runtime/tool-health');
+        bustCache('/api/dashboard/surface/operate');
+        if (tab === 'board') {
+            Board.loadToolHealth();
+        }
     }
     if (tab === 'workforce' && ['synapse','operative','mission'].includes(evt.category)) {
         Workforce.render();
     }
     if (tab === 'memory' && evt.category === 'memory') {
-        Memory.render();
+        _refreshMemorySoon();
     }
     if (tab === 'governance' && evt.category === 'darwin') {
         Governance.load();

package/dist/dashboard/server.d.ts

@@ -25,6 +25,7 @@ export declare class DashboardServer {
     private repoTreeGenerator;
     private gitUser;
     private sseBroker;
+    private unsubscribeWorkspaceChanged;
     constructor(options?: DashboardServerOptions);
     start(): void;
     stop(): void;
@@ -64,6 +65,8 @@ export declare class DashboardServer {
     private readJsonIfExists;
     private fileExists;
     private collectUsageSnapshot;
+    private normalizeDashboardRepoToken;
+    private dashboardMemoryMatchesRepoName;
     private listDashboardMemories;
     private listCrossProjectMemories;
     private listCrossProjectProjects;

package/dist/dashboard/server.js

@@ -107,6 +107,7 @@ export class DashboardServer {
     repoTreeGenerator;
     gitUser;
     sseBroker = new SseBroker();
+    unsubscribeWorkspaceChanged = null;
     constructor(options = {}) {
         this.runtimeProvider = options.runtimeProvider;
         this.orchestratorProvider = options.orchestratorProvider;
@@ -124,7 +125,16 @@ export class DashboardServer {
         this.repoTreeGenerator = new RepoTreeGenerator(this.repoRoot);
         this.gitUser = process.env.GIT_AUTHOR_NAME || process.env.GIT_COMMITTER_NAME || '';
         this.server = http.createServer((req, res) => {
-            void this.requestHandler(req, res);
+            this.requestHandler(req, res).catch((err) => {
+                console.error('[Dashboard] requestHandler unhandled error:', err instanceof Error ? err.message : String(err));
+                if (!res.headersSent && res.writable) {
+                    try {
+                        res.writeHead(500, { 'Content-Type': 'text/plain' });
+                        res.end('Internal Server Error');
+                    }
+                    catch { /* socket already dead */ }
+                }
+            });
         });
         this.server.on('error', (error) => {
             if (this.dashboardMode === 'bound') {
@@ -135,7 +145,7 @@ export class DashboardServer {
         // is promoted (e.g. from a nexus_session_bootstrap file hint). Without this
         // the dashboard keeps serving the stale "/" → "workspace" fallback for
         // up to 30s after the real repo is discovered.
-        nexusEventBus.on('workspace.changed', (payload) => {
+        this.unsubscribeWorkspaceChanged = nexusEventBus.on('workspace.changed', (payload) => {
             try {
                 this.repoRoot = payload.repoRoot || this.repoRoot;
                 this.repoTreeGenerator = new RepoTreeGenerator(this.repoRoot);
@@ -178,6 +188,10 @@ export class DashboardServer {
             controller.abort();
         }
         this.activeProbeControllers.clear();
+        if (this.unsubscribeWorkspaceChanged) {
+            this.unsubscribeWorkspaceChanged();
+            this.unsubscribeWorkspaceChanged = null;
+        }
         if (this.dashboardMode === 'bound') {
             this.sseBroker.stop();
             this.server.close();
@@ -762,6 +776,35 @@ export class DashboardServer {
             latestRun: null,
         };
     }
+    normalizeDashboardRepoToken(value) {
+        return String(value ?? '').trim().replace(/^#/, '').toLowerCase();
+    }
+    dashboardMemoryMatchesRepoName(memory, repoName) {
+        const expected = this.normalizeDashboardRepoToken(repoName);
+        if (!expected)
+            return true;
+        const tags = Array.isArray(memory.tags) ? memory.tags : [];
+        const provenance = memory.provenance ?? {};
+        const candidates = [
+            ...tags,
+            ...(Array.isArray(provenance.tags) ? provenance.tags : []),
+            ...(Array.isArray(provenance.containerTags) ? provenance.containerTags : []),
+            provenance.repoName,
+            provenance.repoId,
+            provenance.workspaceId,
+            provenance.projectId,
+        ];
+        return candidates.some((candidate) => {
+            const token = this.normalizeDashboardRepoToken(candidate);
+            if (!token)
+                return false;
+            if (token === expected)
+                return true;
+            if (token === `repo:${expected}`)
+                return true;
+            return token.startsWith('repo:') && token.slice(5) === expected;
+        });
+    }
     listDashboardMemories(options = {}) {
         const limit = Math.max(1, Number(options.limit || 40));
         const raw = this.getMemory()?.listSnapshots(Math.min(limit * 3, 200), {
@@ -769,21 +812,20 @@ export class DashboardServer {
             tag: options.tag,
             linkedType: options.linkedType,
             recencyMs: options.recencyMs,
+            state: options.includeHidden || options.lane === 'inbox' ? undefined : 'active',
             lane: options.lane,
             repoId: options.repoId,
             workspaceId: options.workspaceId,
             projectId: options.projectId,
             includeHidden: options.includeHidden,
         }) ?? [];
-        return raw
+        const visible = raw
             .filter((memory) => {
             const tags = Array.isArray(memory.tags) ? memory.tags : [];
             if (!options.includeHidden && tags.includes('#system-hidden'))
                 return false;
             if (!options.includeHidden && tags.includes('#auto') && Number(memory.priority ?? 0) < 0.4)
                 return false;
-            if (options.repoName && !tags.some((t) => t === `repo:${options.repoName}`))
-                return false;
             if (tags.includes('#quarantine') && options.lane !== 'inbox')
                 return false;
             if (!options.showPhantom && (tags.includes('#phantom-learning') || tags.includes('#swarm')))
@@ -793,8 +835,11 @@ export class DashboardServer {
             if (!options.includeHidden && (tags.includes('#hidden') || tags.includes('#repo-profile') || tags.includes('#system-hidden')))
                 return false;
             return true;
-        })
-            .slice(0, limit);
+        });
+        const scoped = options.repoName
+            ? visible.filter((memory) => this.dashboardMemoryMatchesRepoName(memory, options.repoName))
+            : visible;
+        return (options.repoName && scoped.length === 0 ? visible : scoped).slice(0, limit);
     }
     listCrossProjectMemories(options) {
         const memory = this.getMemory();
@@ -1465,6 +1510,10 @@ export class DashboardServer {
                         body: Buffer.concat(chunks).toString('utf8'),
                     });
                 });
+                res.on('error', (error) => {
+                    cleanup();
+                    reject(error);
+                });
             });
             req.on('timeout', () => {
                 req.destroy(new Error('probe-timeout'));

package/dist/dashboard/stream/sse-broker.js

@@ -97,6 +97,8 @@ export class SseBroker {
             'Access-Control-Allow-Origin': corsOrigin,
         });
         const safeWrite = (chunk) => {
+            if (!res.writable || res.destroyed)
+                return false;
             try {
                 return res.write(chunk);
             }

package/dist/engines/event-bus.d.ts

@@ -1,4 +1,4 @@
-export type NexusEventType = 'system.boot' | 'planner.stage' | 'memory.store' | 'memory.dedup' | 'memory.recall' | 'memory.flushed' | 'memory.snapshot' | 'memory.health.tick' | 'memory.sqlite.retry' | 'pod.signal' | 'tokens.optimized' | 'tokens.searchSaved' | 'orchestration.decomposed' | 'orchestration.completed' | 'session.summaryBootstrap' | 'phantom.worker.start' | 'phantom.worker.complete' | 'phantom.merge.complete' | 'phantom.merge' | 'guardrail.check' | 'ghost.pass' | 'graph.query' | 'graph.sync.failed' | 'graph.coverage.low' | 'graph.cr.build.start' | 'graph.cr.build.complete' | 'graph.cr.build.failed' | 'darwin.cycle' | 'darwin.cycle.complete' | 'session.dna' | 'skill.register' | 'skill.deploy' | 'skill.revoke' | 'hook.deploy' | 'hook.revoke' | 'hook.fire' | 'hook.error' | 'workflow.deploy' | 'workflow.run' | 'automation.deploy' | 'automation.revoke' | 'automation.run' | 'shield.decision' | 'memory.audit' | 'federation.heartbeat' | 'client.heartbeat' | 'client.inferred' | 'client.status' | 'dashboard.action' | 'workspace.changed' | 'nexus.shutdown' | 'nexus.daemon.error' | 'orchestrator.disposed' | 'orchestrator.funnel.stage' | 'orchestrator.warn' | 'nexusnet.publish' | 'nexusnet.sync' | 'mcp.call.start' | 'mcp.call.stream' | 'mcp.call.complete' | 'mcp.handler.complete' | 'mcp.handler.failed' | 'mcp.handler.retry' | 'mcp.handler.best-effort-failed' | 'tool.invocation' | 'nexus.deprecation.used' | 'memory.tier.promoted' | 'memory.tier.promoted.failed' | 'memory.pre-compaction' | 'memory.flush-requested' | 'entanglement.create' | 'entanglement.collapse' | 'entanglement.correlate' | 'cas.encode' | 'cas.decode' | 'cas.pattern_learned' | 'kv.merge' | 'kv.adapt' | 'kv.consensus' | 'byzantine.vote.started' | 'byzantine.vote.result' | 'synapse.ready' | 'synapse.operative.hired' | 'synapse.operative.retired' | 'synapse.operative.health.changed' | 'synapse.striketeam.deployed' | 'synapse.striketeam.completed' | 'synapse.mission.assigned' | 'synapse.mission.completed' | 'synapse.sortie.started' | 'synapse.sortie.completed' | 'synapse.sortie.failed' | 'synapse.fieldreport.submitted' | 'synapse.echo.fired' | 'synapse.budget.warning' | 'synapse.budget.exceeded' | 'synapse.approval.requested' | 'synapse.approval.resolved' | 'synapse.compaction.standdown' | 'synapse.compaction.resumed' | 'synapse.coordination.publish.failed' | 'synapse.watchdog.stall' | 'synapse.watchdog.zombie' | 'architects.ready' | 'architects.blueprint.instantiated' | 'architects.worklist.created' | 'architects.workitem.claimed' | 'architects.workitem.completed' | 'architects.workitem.blocked' | 'architects.constructionlock.acquired' | 'architects.constructionlock.renewed' | 'architects.constructionlock.released' | 'architects.constructionlock.contested' | 'architects.relay.sent' | 'architects.relay.read' | 'architects.sentinel.patrol' | 'architects.sentinel.stall' | 'architects.sentinel.zombie' | 'architects.ward.patrol' | 'architects.ward.escalation' | 'architects.convergence.started' | 'architects.convergence.merged' | 'architects.convergence.failed' | 'architects.dispatch.go' | 'architects.dispatch.queued' | 'architects.relay.failed' | 'architects.event.failed' | 'ledger.duplicate-prevented' | 'nexus.circuit-open' | 'nexus.circuit-tripped' | 'license.activated' | 'license.deactivated' | 'license.expired' | 'license.cap.warning' | 'license.cap.reached' | 'dispatch.started' | 'dispatch.event' | 'dispatch.token-usage' | 'dispatch.complete' | 'dispatch.failed' | 'dispatch.cancelled' | 'dispatch.budget-exceeded' | 'mcp.auto-memory.failed' | 'daemon.self-heal.db-corrupt' | 'feature.time_to_first_bootstrap' | 'feature.time_to_first_memory' | 'feature.time_to_first_interaction' | 'feature.time_to_first_mission_complete' | 'async_gate.completed' | 'async_gate.failed' | 'install.step' | 'license.tierChanged' | 'license.upgradeNudge' | 'orchestrator.run.start' | 'orchestrator.run.complete';
+export type NexusEventType = 'system.boot' | 'planner.stage' | 'memory.store' | 'memory.dedup' | 'memory.recall' | 'memory.flushed' | 'memory.snapshot' | 'memory.health.tick' | 'memory.sqlite.retry' | 'pod.signal' | 'tokens.optimized' | 'tokens.searchSaved' | 'orchestration.decomposed' | 'orchestration.completed' | 'session.summaryBootstrap' | 'phantom.worker.start' | 'phantom.worker.complete' | 'phantom.merge.complete' | 'phantom.merge' | 'guardrail.check' | 'ghost.pass' | 'graph.query' | 'graph.sync.failed' | 'graph.coverage.low' | 'graph.cr.build.start' | 'graph.cr.build.complete' | 'graph.cr.build.failed' | 'darwin.cycle' | 'darwin.cycle.complete' | 'session.dna' | 'skill.register' | 'skill.deploy' | 'skill.revoke' | 'hook.deploy' | 'hook.revoke' | 'hook.fire' | 'hook.error' | 'workflow.deploy' | 'workflow.run' | 'automation.deploy' | 'automation.revoke' | 'automation.run' | 'shield.decision' | 'memory.audit' | 'federation.heartbeat' | 'client.heartbeat' | 'client.inferred' | 'client.status' | 'dashboard.action' | 'workspace.changed' | 'nexus.shutdown' | 'nexus.daemon.error' | 'orchestrator.disposed' | 'orchestrator.funnel.stage' | 'orchestrator.warn' | 'nexusnet.publish' | 'nexusnet.sync' | 'mcp.call.start' | 'mcp.call.stream' | 'mcp.call.complete' | 'mcp.handler.complete' | 'mcp.handler.failed' | 'mcp.handler.retry' | 'mcp.handler.best-effort-failed' | 'tool.invocation' | 'nexus.deprecation.used' | 'memory.tier.promoted' | 'memory.tier.promoted.failed' | 'memory.pre-compaction' | 'memory.flush-requested' | 'entanglement.create' | 'entanglement.collapse' | 'entanglement.correlate' | 'cas.encode' | 'cas.decode' | 'cas.pattern_learned' | 'kv.merge' | 'kv.adapt' | 'kv.consensus' | 'byzantine.vote.started' | 'byzantine.vote.result' | 'synapse.ready' | 'synapse.operative.hired' | 'synapse.operative.retired' | 'synapse.operative.health.changed' | 'synapse.striketeam.deployed' | 'synapse.striketeam.completed' | 'synapse.striketeam.finished' | 'synapse.mission.assigned' | 'synapse.mission.completed' | 'synapse.sortie.started' | 'synapse.sortie.completed' | 'synapse.sortie.failed' | 'synapse.fieldreport.submitted' | 'synapse.echo.fired' | 'synapse.budget.warning' | 'synapse.budget.exceeded' | 'synapse.approval.requested' | 'synapse.approval.resolved' | 'synapse.compaction.standdown' | 'synapse.compaction.resumed' | 'synapse.coordination.publish.failed' | 'synapse.watchdog.stall' | 'synapse.watchdog.zombie' | 'architects.ready' | 'architects.blueprint.instantiated' | 'architects.worklist.created' | 'architects.workitem.claimed' | 'architects.workitem.completed' | 'architects.workitem.blocked' | 'architects.constructionlock.acquired' | 'architects.constructionlock.renewed' | 'architects.constructionlock.released' | 'architects.constructionlock.contested' | 'architects.relay.sent' | 'architects.relay.read' | 'architects.sentinel.patrol' | 'architects.sentinel.stall' | 'architects.sentinel.zombie' | 'architects.ward.patrol' | 'architects.ward.escalation' | 'architects.convergence.started' | 'architects.convergence.merged' | 'architects.convergence.failed' | 'architects.dispatch.go' | 'architects.dispatch.queued' | 'architects.relay.failed' | 'architects.event.failed' | 'ledger.duplicate-prevented' | 'nexus.circuit-open' | 'nexus.circuit-tripped' | 'license.activated' | 'license.deactivated' | 'license.expired' | 'license.cap.warning' | 'license.cap.reached' | 'dispatch.started' | 'dispatch.event' | 'dispatch.token-usage' | 'dispatch.complete' | 'dispatch.failed' | 'dispatch.cancelled' | 'dispatch.budget-exceeded' | 'mcp.auto-memory.failed' | 'daemon.self-heal.db-corrupt' | 'feature.time_to_first_bootstrap' | 'feature.time_to_first_memory' | 'feature.time_to_first_interaction' | 'feature.time_to_first_mission_complete' | 'async_gate.completed' | 'async_gate.failed' | 'install.step' | 'license.tierChanged' | 'license.upgradeNudge' | 'orchestrator.run.start' | 'orchestrator.run.complete';
 export interface NexusEventPayloads {
     'system.boot': {
         version: string;
@@ -463,6 +463,12 @@ export interface NexusEventPayloads {
         worklistId?: string | null;
         correlationId?: string | null;
     };
+    'synapse.striketeam.finished': {
+        strikeTeamId: string;
+        intent: 'read' | 'orchestrate' | 'mutate';
+        outcome: 'completed' | 'cancelled' | 'failed';
+        worklistId?: string | null;
+    };
     'synapse.mission.assigned': {
         operativeId: string;
         missionId: string;

package/dist/engines/knowledge-fabric.d.ts

@@ -149,6 +149,7 @@ export declare class KnowledgeFabricEngine {
     private readonly patternRegistry;
     private readonly memory?;
     private readonly bundleCache;
+    private readonly snapshotCache;
     constructor(options?: {
         repoRoot?: string;
         stateRoot?: string;
@@ -200,7 +201,8 @@ export declare class KnowledgeFabricEngine {
         trace: ModelTierTrace[];
     };
     private persistBundle;
-    private pruneRuntimeSnapshots;
+    private persistBundleAsync;
+    private pruneRuntimeSnapshotsAsync;
     private buildSourceMix;
     private allocateTokenBudget;
     private buildRecommendations;

package/dist/engines/knowledge-fabric.js

@@ -1,4 +1,5 @@
 import * as fs from 'fs';
+import { promises as fsp } from 'fs';
 import * as path from 'path';
 import { PatternRegistry } from './pattern-registry.js';
 import { RuntimeRegistry, resolveNexusStateDir, } from './runtime-registry.js';
@@ -14,6 +15,7 @@ export class KnowledgeFabricEngine {
     patternRegistry;
     memory;
     bundleCache = new Map();
+    snapshotCache = new Map();
     constructor(options = {}) {
         this.repoRoot = options.repoRoot ?? process.cwd();
         this.stateDir = path.join(options.stateRoot ?? resolveNexusStateDir(), 'knowledge-fabric');
@@ -22,6 +24,7 @@ export class KnowledgeFabricEngine {
         this.ragCollections = options.ragCollections ?? new RagCollectionStore(options.stateRoot);
         this.patternRegistry = options.patternRegistry ?? new PatternRegistry(options.stateRoot);
         this.memory = options.memory;
+        // eslint-disable-next-line no-restricted-syntax -- constructor sync mkdir is startup-only, not hot path
         fs.mkdirSync(this.stateDir, { recursive: true });
     }
     async compose(input) {
@@ -55,7 +58,7 @@ export class KnowledgeFabricEngine {
     }
     async composeStage(input, stage, cacheKey) {
         const runtimeSnapshot = input.runtimeSnapshot ?? this.runtimeRegistry.read(input.runtimeId);
-        const fileRefs = input.candidateFiles.map((entry) => toFileRef(entry)).filter((entry) => Boolean(entry));
+        const fileRefs = (await Promise.all(input.candidateFiles.map((entry) => toFileRef(entry)))).filter((entry) => Boolean(entry));
         const readingPlan = fileRefs.length > 0 ? await this.tokenEngine.plan(input.task, fileRefs, input.fileBoosts) : undefined;
         const selectedFiles = readingPlan
             ? readingPlan.files.filter((file) => file.action !== 'skip').map((file) => file.file.path)
@@ -226,14 +229,13 @@ export class KnowledgeFabricEngine {
         const existingTextLabels = new Set((fullCollection?.sources ?? [])
             .filter((source) => source.kind === 'text')
             .map((source) => source.label));
-        const seedPaths = dedupePaths([
+        const seedCandidates = dedupePaths([
             path.join(this.repoRoot, 'README.md'),
             path.join(this.repoRoot, 'package.json'),
             ...input.candidateFiles,
-        ])
-            .filter((target) => fs.existsSync(target))
-            .filter((target) => isReadableBootstrapSeed(target))
-            .slice(0, 6);
+        ]);
+        const seedReadable = await Promise.all(seedCandidates.map((target) => isReadableBootstrapSeed(target)));
+        const seedPaths = seedCandidates.filter((_, i) => seedReadable[i]).slice(0, 6);
         const ingestInputs = seedPaths
             .filter((target) => !existingLocations.has(path.resolve(target)))
             .map((target) => ({
@@ -241,7 +243,7 @@ export class KnowledgeFabricEngine {
             label: path.relative(this.repoRoot, target) || path.basename(target),
             tags: ['bootstrap-seeded', 'project-context'],
         }));
-        const workspaceProfile = buildWorkspaceProfileSeed(this.repoRoot);
+        const workspaceProfile = await buildWorkspaceProfileSeed(this.repoRoot);
         if (workspaceProfile && !existingTextLabels.has('workspace-profile')) {
             ingestInputs.unshift({
                 text: workspaceProfile,
@@ -265,11 +267,20 @@ export class KnowledgeFabricEngine {
         this.patternRegistry.recordOutcome(patternId, success);
     }
     getSessionSnapshot(runtimeId) {
+        // Serve from in-memory cache written by persistBundle — avoids disk read on hot path.
+        // Falls back to disk only if the snapshot was persisted by a previous process instance.
+        const cached = this.snapshotCache.get(runtimeId);
+        if (cached)
+            return cached;
         const target = path.join(this.stateDir, runtimeId, 'latest.json');
+        // eslint-disable-next-line no-restricted-syntax -- cold-start fallback, runs at most once per runtimeId per process
         if (!fs.existsSync(target))
             return undefined;
         try {
-            return JSON.parse(fs.readFileSync(target, 'utf8'));
+            // eslint-disable-next-line no-restricted-syntax -- cold-start fallback, populates snapshotCache so subsequent calls are free
+            const snapshot = JSON.parse(fs.readFileSync(target, 'utf8'));
+            this.snapshotCache.set(runtimeId, snapshot);
+            return snapshot;
         }
         catch {
             return undefined;
@@ -289,8 +300,6 @@ export class KnowledgeFabricEngine {
         };
     }
     persistBundle(bundle) {
-        const runtimeDir = path.join(this.stateDir, bundle.runtimeId);
-        fs.mkdirSync(runtimeDir, { recursive: true });
         const snapshot = {
             runtimeId: bundle.runtimeId,
             sessionId: bundle.sessionId,
@@ -314,21 +323,43 @@ export class KnowledgeFabricEngine {
             provenance: bundle.provenance,
             summary: bundle.summary,
         };
-        fs.writeFileSync(path.join(runtimeDir, 'latest.json'), JSON.stringify(snapshot, null, 2), 'utf8');
-        fs.writeFileSync(path.join(runtimeDir, `${bundle.sessionId}.json`), JSON.stringify(snapshot, null, 2), 'utf8');
-        this.pruneRuntimeSnapshots(runtimeDir);
-    }
-    pruneRuntimeSnapshots(runtimeDir) {
-        const sessionSnapshots = fs.readdirSync(runtimeDir)
-            .filter((entry) => entry.endsWith('.json') && entry !== 'latest.json')
-            .map((entry) => ({
-            entry,
-            mtimeMs: fs.statSync(path.join(runtimeDir, entry)).mtimeMs,
-        }))
-            .sort((a, b) => b.mtimeMs - a.mtimeMs);
-        for (const stale of sessionSnapshots.slice(MAX_RUNTIME_SESSION_SNAPSHOTS)) {
-            fs.unlinkSync(path.join(runtimeDir, stale.entry));
+        // Update in-memory cache immediately so getSessionSnapshot has zero disk latency.
+        this.snapshotCache.set(bundle.runtimeId, snapshot);
+        // Persist to disk asynchronously — callers never await this return value.
+        void this.persistBundleAsync(bundle.runtimeId, bundle.sessionId, snapshot);
+    }
+    async persistBundleAsync(runtimeId, sessionId, snapshot) {
+        const runtimeDir = path.join(this.stateDir, runtimeId);
+        await fsp.mkdir(runtimeDir, { recursive: true });
+        const serialized = JSON.stringify(snapshot, null, 2);
+        await Promise.all([
+            fsp.writeFile(path.join(runtimeDir, 'latest.json'), serialized, 'utf8'),
+            fsp.writeFile(path.join(runtimeDir, `${sessionId}.json`), serialized, 'utf8'),
+        ]);
+        await this.pruneRuntimeSnapshotsAsync(runtimeDir);
+    }
+    async pruneRuntimeSnapshotsAsync(runtimeDir) {
+        let entries;
+        try {
+            entries = await fsp.readdir(runtimeDir);
+        }
+        catch {
+            return;
         }
+        const candidates = entries.filter((entry) => entry.endsWith('.json') && entry !== 'latest.json');
+        if (candidates.length <= MAX_RUNTIME_SESSION_SNAPSHOTS)
+            return;
+        const withMtimes = await Promise.all(candidates.map(async (entry) => {
+            try {
+                const stat = await fsp.stat(path.join(runtimeDir, entry));
+                return { entry, mtimeMs: stat.mtimeMs };
+            }
+            catch {
+                return { entry, mtimeMs: 0 };
+            }
+        }));
+        const stale = withMtimes.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(MAX_RUNTIME_SESSION_SNAPSHOTS);
+        await Promise.all(stale.map(({ entry }) => fsp.unlink(path.join(runtimeDir, entry)).catch(() => { })));
     }
     buildSourceMix(input) {
         // Memory quality factor: scales memory weight by avg confidence × trust, penalizes high entropy
@@ -576,25 +607,26 @@ function normalizeBudget(base, totalBudget) {
     }
     return normalized;
 }
-function buildWorkspaceProfileSeed(repoRoot) {
+async function buildWorkspaceProfileSeed(repoRoot) {
     const repoName = path.basename(repoRoot) || 'workspace';
-    const packageName = readPackageName(repoRoot);
-    const topLevel = safeListDir(repoRoot)
+    const packageName = await readPackageName(repoRoot);
+    const topLevel = (await safeListDir(repoRoot))
         .slice(0, 10)
         .map((entry) => entry.name)
         .join(', ');
-    const focusAreas = ['src/synapse', 'src/architects', 'src/dashboard', 'src/phantom', 'src/engines', 'test', 'docs']
-        .filter((relativePath) => fs.existsSync(path.join(repoRoot, relativePath)))
-        .join(', ');
+    const focusAreaCandidates = ['src/synapse', 'src/architects', 'src/dashboard', 'src/phantom', 'src/engines', 'test', 'docs'];
+    const focusAreaExists = await Promise.all(focusAreaCandidates.map((relativePath) => fsp.access(path.join(repoRoot, relativePath)).then(() => true, () => false)));
+    const focusAreas = focusAreaCandidates.filter((_, i) => focusAreaExists[i]).join(', ');
     return [
         `Workspace profile: ${repoName}${packageName && packageName !== repoName ? ` (package ${packageName})` : ''}.`,
         topLevel ? `Top-level entries: ${topLevel}.` : null,
         focusAreas ? `Key areas: ${focusAreas}.` : null,
     ].filter(Boolean).join(' ');
 }
-function safeListDir(target) {
+async function safeListDir(target) {
     try {
-        return fs.readdirSync(target, { withFileTypes: true })
+        const entries = await fsp.readdir(target, { withFileTypes: true });
+        return entries
             .filter((entry) => !entry.name.startsWith('.'))
             .map((entry) => ({ name: entry.name }));
     }
@@ -602,21 +634,19 @@ function safeListDir(target) {
         return [];
     }
 }
-function readPackageName(repoRoot) {
+async function readPackageName(repoRoot) {
     const packageJsonPath = path.join(repoRoot, 'package.json');
-    if (!fs.existsSync(packageJsonPath))
-        return null;
     try {
-        const parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const parsed = JSON.parse(await fsp.readFile(packageJsonPath, 'utf8'));
         return typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : null;
     }
     catch {
         return null;
     }
 }
-function toFileRef(filePath) {
+async function toFileRef(filePath) {
     try {
-        const stat = fs.statSync(filePath);
+        const stat = await fsp.stat(filePath);
         return {
             path: filePath,
             sizeBytes: stat.size,
@@ -636,9 +666,9 @@ function dedupeStrings(values) {
 function estimateTokens(value) {
     return Math.max(1, Math.ceil(String(value || '').length / 4));
 }
-function isReadableBootstrapSeed(target) {
+async function isReadableBootstrapSeed(target) {
     try {
-        const stat = fs.statSync(target);
+        const stat = await fsp.stat(target);
         if (!stat.isFile() || stat.size > 96_000) {
             return false;
         }

package/dist/index.d.ts

@@ -281,3 +281,10 @@ export declare class NexusPrime {
     private getDefaultCapabilities;
 }
 export declare const createNexusPrime: (config?: Partial<NexusConfig>) => NexusPrime;
+export { GhostPass, PhantomOrchestrator, PhantomWorker } from './phantom/index.js';
+export type { GhostReport, WorkerTask, WorkerResult, MergeDecision } from './phantom/index.js';
+export { MemoryEngine, createMemoryEngine } from './engines/memory.js';
+export { SessionDNAManager } from './engines/session-dna.js';
+export type { SessionDNA } from './engines/session-dna.js';
+export { GithubBridge, getSharedGithubBridge } from './engines/github-bridge.js';
+export type { GithubPromotionInput, GithubPromotionResult } from './engines/github-bridge.js';

package/dist/index.js

@@ -1193,3 +1193,8 @@ function detectCurrentClient() {
     }
     return null;
 }
+// Public API surface for sibling packages (e.g., @nexus-prime/finishit)
+export { GhostPass, PhantomOrchestrator, PhantomWorker } from './phantom/index.js';
+export { MemoryEngine, createMemoryEngine } from './engines/memory.js';
+export { SessionDNAManager } from './engines/session-dna.js';
+export { GithubBridge, getSharedGithubBridge } from './engines/github-bridge.js';

package/dist/synapse/mandate/pipeline.js

@@ -166,5 +166,10 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
         });
         return getStrikeTeam(db, teamId);
     })();
+    nexusEventBus.emit('synapse.striketeam.finished', {
+        strikeTeamId: team.id,
+        intent: signals.complexity,
+        outcome: 'completed',
+    });
     return team;
 }

package/package.json

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