nexus-prime 6.0.2 → 6.2.0

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

@@ -13,6 +13,8 @@ import { handleGovernanceGroup } from './handlers/governance.js';
 import { handleRuntimeGroup } from './handlers/runtime.js';
 import { handleDiscoveryGroup } from './handlers/discovery.js';
 import { handleMiscGroup } from './handlers/misc.js';
+import { nexusEventBus } from '../../../engines/event-bus.js';
+import { recordToolInvocation } from './tool-health.js';
 /**
  * Route a tool call to the appropriate handler group.
  *
@@ -22,11 +24,24 @@ import { handleMiscGroup } from './handlers/misc.js';
  */
 export async function dispatchMcpToolCall(hctx, request, args, ctx) {
     const toolName = String(request.params?.name ?? '');
-    // Try each group in priority order. Groups return undefined for unknown tools.
-    return (await handleOrchestrationGroup(toolName, hctx, request, args, ctx) ??
-        await handleMemoryGroup(toolName, hctx, request, args, ctx) ??
-        await handleGovernanceGroup(toolName, hctx, request, args, ctx) ??
-        await handleRuntimeGroup(toolName, hctx, request, args, ctx) ??
-        await handleDiscoveryGroup(toolName, hctx, request, args, ctx) ??
-        await handleMiscGroup(toolName, hctx, request, args, ctx));
+    const startedAt = Date.now();
+    try {
+        // Try each group in priority order. Groups return undefined for unknown tools.
+        const result = (await handleOrchestrationGroup(toolName, hctx, request, args, ctx) ??
+            await handleMemoryGroup(toolName, hctx, request, args, ctx) ??
+            await handleGovernanceGroup(toolName, hctx, request, args, ctx) ??
+            await handleRuntimeGroup(toolName, hctx, request, args, ctx) ??
+            await handleDiscoveryGroup(toolName, hctx, request, args, ctx) ??
+            await handleMiscGroup(toolName, hctx, request, args, ctx));
+        const durationMs = Date.now() - startedAt;
+        recordToolInvocation(toolName, durationMs, 'ok');
+        nexusEventBus.emit('tool.invocation', { toolName, durationMs, status: 'ok' });
+        return result;
+    }
+    catch (err) {
+        const durationMs = Date.now() - startedAt;
+        recordToolInvocation(toolName, durationMs, 'error');
+        nexusEventBus.emit('tool.invocation', { toolName, durationMs, status: 'error' });
+        throw err;
+    }
 }

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

@@ -253,28 +253,11 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                             formatBullets([
                                 `Workspace: ${workspace.repoName} (${workspace.workspaceSource})`,
                                 `Client: ${bootstrap.client?.displayName || bootstrap.client?.clientId || 'unknown'} (${bootstrap.client?.state || 'unknown'})`,
-                                `Bootstrap depth: ${bootstrap.depth || bootstrapDepth}`,
                                 `Memory recall: ${bootstrap.memoryRecall?.count ?? 0} result(s)`,
                                 `Memory stats: prefrontal ${bootstrap.memoryStats?.prefrontal ?? 0} · hippocampus ${bootstrap.memoryStats?.hippocampus ?? 0} · cortex ${bootstrap.memoryStats?.cortex ?? 0}`,
                                 `Recommended next step: ${bootstrap.recommendedNextStep || 'nexus_orchestrate'}`,
-                                `Execution mode: ${bootstrap.recommendedExecutionMode || 'autonomous'}`,
                                 `Token optimization: ${bootstrap.tokenOptimization?.autoApplied ? `auto-applied — saved ${Number(bootstrap.tokenOptimization?.planMetrics?.savings ?? 0).toLocaleString()} tokens (${bootstrap.tokenOptimization?.planMetrics?.pct ?? 0}% reduction)` : (bootstrap.tokenOptimization?.required ? 'required before broad reading' : 'not required yet')}`,
                                 `Catalog health: ${bootstrap.catalogHealth?.overall || 'unknown'} · selected ${bootstrap.artifactSelectionAudit?.selected?.length || 0}`,
-                                `Shortlist: ${bootstrap.shortlist?.skills?.slice(0, 3).join(', ') || 'none'} (skills), ${bootstrap.shortlist?.specialists?.slice(0, 3).join(', ') || 'none'} (specialists)`,
-                                `Knowledge fabric: ${bootstrap.sourceMixRecommendation?.dominantSource || bootstrap.knowledgeFabric?.dominantSource || 'awaiting source mix'}`,
-                                `RAG: ${bootstrap.ragCandidateStatus?.attachedCollections || 0} attached · ${bootstrap.ragCandidateStatus?.retrievedChunks || 0} retrieved`,
-                                `Task graph: ${bootstrap.taskGraphPreview?.phases?.length || 0} phases · ${bootstrap.taskGraphPreview?.independentBranches || 0} branches`,
-                                `Worker plan: ${bootstrap.workerPlanPreview?.totalWorkers || 0} workers planned`,
-                                bootstrap.needsDeepBootstrap ? 'Deep preparation: still recommended before risky or cross-file work' : 'Deep preparation: not currently required',
-                                `Payload ref: ${workspace.stateKey} · ${detailLevel}`,
-                                `Session summary: ${bootstrap.sessionSummaryBootstrap?.savedTokens ? `reused ${Number(bootstrap.sessionSummaryBootstrap.savedTokens || 0).toLocaleString()} tokens from the previous visit` : 'none available yet'}`,
-                                bootstrap.projectMemoryBootstrap?.count
-                                    ? `Project memory: recovered ${bootstrap.projectMemoryBootstrap.count} prior project memories`
-                                    : 'Project memory: no prior project memories recovered',
-                                bootstrap.autoGhostPass?.applied
-                                    ? `Auto ghost-pass: ${bootstrap.autoGhostPass.riskAreas.length} risk area(s) · ${bootstrap.autoGhostPass.workerApproaches} approach(es)`
-                                    : `Auto ghost-pass: skipped`,
-                                `Bootstrap status: ${bootstrap.clientBootstrapStatus?.clients?.length || 0} client manifests tracked`,
                                 (() => {
                                     try {
                                         const _lic = getSharedLicenseManager().getStatus();
@@ -287,11 +270,30 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                         return '';
                                     }
                                 })(),
+                                ...(detailLevel === 'debug' ? [
+                                    `Bootstrap depth: ${bootstrap.depth || bootstrapDepth}`,
+                                    `Execution mode: ${bootstrap.recommendedExecutionMode || 'autonomous'}`,
+                                    `Shortlist: ${bootstrap.shortlist?.skills?.slice(0, 3).join(', ') || 'none'} (skills), ${bootstrap.shortlist?.specialists?.slice(0, 3).join(', ') || 'none'} (specialists)`,
+                                    `Knowledge fabric: ${bootstrap.sourceMixRecommendation?.dominantSource || bootstrap.knowledgeFabric?.dominantSource || 'awaiting source mix'}`,
+                                    `RAG: ${bootstrap.ragCandidateStatus?.attachedCollections || 0} attached · ${bootstrap.ragCandidateStatus?.retrievedChunks || 0} retrieved`,
+                                    `Task graph: ${bootstrap.taskGraphPreview?.phases?.length || 0} phases · ${bootstrap.taskGraphPreview?.independentBranches || 0} branches`,
+                                    `Worker plan: ${bootstrap.workerPlanPreview?.totalWorkers || 0} workers planned`,
+                                    bootstrap.needsDeepBootstrap ? 'Deep preparation: still recommended before risky or cross-file work' : 'Deep preparation: not currently required',
+                                    `Payload ref: ${workspace.stateKey} · ${detailLevel}`,
+                                    `Session summary: ${bootstrap.sessionSummaryBootstrap?.savedTokens ? `reused ${Number(bootstrap.sessionSummaryBootstrap.savedTokens || 0).toLocaleString()} tokens from the previous visit` : 'none available yet'}`,
+                                    bootstrap.projectMemoryBootstrap?.count
+                                        ? `Project memory: recovered ${bootstrap.projectMemoryBootstrap.count} prior project memories`
+                                        : 'Project memory: no prior project memories recovered',
+                                    bootstrap.autoGhostPass?.applied
+                                        ? `Auto ghost-pass: ${bootstrap.autoGhostPass.riskAreas.length} risk area(s) · ${bootstrap.autoGhostPass.workerApproaches} approach(es)`
+                                        : `Auto ghost-pass: skipped`,
+                                    `Bootstrap status: ${bootstrap.clientBootstrapStatus?.clients?.length || 0} client manifests tracked`,
+                                ] : []),
                             ]),
                             detailLevel === 'debug' && bootstrap.tokenOptimization?.autoApplied && bootstrap.tokenOptimization?.plan
                                 ? `Auto token plan\n\`\`\`txt\n${bootstrap.tokenOptimization.plan}\n\`\`\``
                                 : '',
-                            formatJsonDetails('Structured details', payload),
+                            detailLevel === 'debug' ? formatJsonDetails('Structured details', payload) : '',
                             hctx.formatProtocolChecklist(),
                         ].filter(Boolean).join('\n\n'),
                     }],
@@ -331,6 +333,36 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             const executionPreset = request.params.arguments?.executionPreset
                 ? String(request.params.arguments.executionPreset)
                 : undefined;
+            // Auto-apply token optimization when explicit files are provided.
+            // Gives agents an upfront reading plan before orchestrate runs.
+            // No-files path relies on knowledge fabric (handled inside orchestrate).
+            let upfrontTokenNote = '';
+            if (files && files.length > 3) {
+                try {
+                    const statLimit = pLimit(8);
+                    const fileRefs = await Promise.all(files.map((p) => statLimit(async () => {
+                        const resolved = hctx.resolveToolPath(p, request.params.arguments ?? {});
+                        try {
+                            const stat = await fsPromises.stat(resolved);
+                            return { path: resolved, sizeBytes: stat.size, lastModified: stat.mtimeMs };
+                        }
+                        catch {
+                            return { path: resolved, sizeBytes: 0 };
+                        }
+                    })));
+                    const upfrontPlan = await getTokenEngine().plan(prompt, fileRefs);
+                    if (upfrontPlan.savings > 0) {
+                        const pct = upfrontPlan.totalEstimatedTokens > 0
+                            ? Math.round(upfrontPlan.savings / (upfrontPlan.totalEstimatedTokens + upfrontPlan.savings) * 100)
+                            : 0;
+                        upfrontTokenNote = `Token plan: ${upfrontPlan.files.filter(a => a.action === 'full').length} full reads, ${upfrontPlan.files.filter(a => a.action === 'outline').length} outlines, ${upfrontPlan.files.filter(a => a.action === 'skip').length} skipped. ~${upfrontPlan.savings.toLocaleString()} tokens saved (${pct}%). `;
+                        nexusEventBus.emit('tokens.optimized', { savings: upfrontPlan.savings, pct, source: 'orchestrate-preflight' });
+                    }
+                }
+                catch {
+                    // Non-fatal: proceed without upfront plan
+                }
+            }
             try {
                 const preset = resolveExecutionPreset(executionPreset);
                 const execution = await hctx.nexusRef.orchestrate(prompt, applyExecutionPreset({
@@ -457,27 +489,30 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     content: [{
                             type: 'text',
                             text: [
+                                upfrontTokenNote ? `[Token plan] ${upfrontTokenNote}` : '',
                                 `Orchestrated run ${execution.state}.`,
                                 formatBullets([
                                     `Workspace: ${workspace.repoName} (${workspace.workspaceSource})`,
                                     `Run ID: ${execution.runId}`,
                                     `Summary: ${summarizeExecution(execution)}`,
                                     `Crew: ${execution.plannerState?.selectedCrew?.name || 'baseline path'}`,
-                                    `Specialists: ${execution.plannerState?.selectedSpecialists.map((specialist) => specialist.name).slice(0, 4).join(', ') || 'none selected'}`,
-                                    `Assets: ${(execution.activeSkills || []).length} skills · ${(execution.activeWorkflows || []).length} workflows · ${(runtimeUsage.artifactSelectionAudit?.selected?.length || 0)} audited selections`,
-                                    `Task graph: ${runtimeUsage.taskGraph?.phases?.length || execution.taskGraph?.phases?.length || 0} phases · ${runtimeUsage.workerPlan?.totalWorkers || execution.workerPlan?.totalWorkers || 0} workers`,
-                                    `Catalog health: ${runtimeUsage.catalogHealth?.overall || 'unknown'}`,
-                                    preset ? `Preset: ${preset.name} (${preset.id})` : null,
                                     `Verification: ${verifiedWorkers}/${execution.workerResults.length} worker(s) verified`,
-                                    `Worktrees: ${runtimeUsage.worktreeHealth?.overall || 'unknown'} · repaired ${runtimeUsage.worktreeHealth?.repairedEntries || 0} · broken ${runtimeUsage.worktreeHealth?.brokenEntries || 0}`,
-                                    `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}% · dominant ${runtimeUsage.sourceAwareTokenBudget?.dominantSource || execution.knowledgeFabric?.sourceMix?.dominantSource || 'repo'}`,
+                                    `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}%`,
                                     autoTokenApplyNote || null,
-                                    `RAG: ${(runtimeUsage.ragUsageSummary?.attachedCollections || execution.knowledgeFabric?.rag.attachedCollections.length || 0)} attached · ${(runtimeUsage.ragUsageSummary?.retrievedChunks || execution.knowledgeFabric?.rag.hits.length || 0)} retrieved`,
-                                    `Memory scopes: ${Object.entries(runtimeUsage.memoryScopeUsage?.byScope || execution.memoryScopeUsage?.byScope || {}).map(([scope, count]) => `${scope}:${count}`).join(' · ') || 'awaiting shared/session reads'}`,
-                                    `Payload ref: ${workspace.stateKey} · ${detailLevel}`,
+                                    ...(detailLevel === 'debug' ? [
+                                        `Specialists: ${execution.plannerState?.selectedSpecialists.map((specialist) => specialist.name).slice(0, 4).join(', ') || 'none selected'}`,
+                                        `Assets: ${(execution.activeSkills || []).length} skills · ${(execution.activeWorkflows || []).length} workflows · ${(runtimeUsage.artifactSelectionAudit?.selected?.length || 0)} audited selections`,
+                                        `Task graph: ${runtimeUsage.taskGraph?.phases?.length || execution.taskGraph?.phases?.length || 0} phases · ${runtimeUsage.workerPlan?.totalWorkers || execution.workerPlan?.totalWorkers || 0} workers`,
+                                        `Catalog health: ${runtimeUsage.catalogHealth?.overall || 'unknown'}`,
+                                        preset ? `Preset: ${preset.name} (${preset.id})` : null,
+                                        `Worktrees: ${runtimeUsage.worktreeHealth?.overall || 'unknown'} · repaired ${runtimeUsage.worktreeHealth?.repairedEntries || 0} · broken ${runtimeUsage.worktreeHealth?.brokenEntries || 0}`,
+                                        `RAG: ${(runtimeUsage.ragUsageSummary?.attachedCollections || execution.knowledgeFabric?.rag.attachedCollections.length || 0)} attached · ${(runtimeUsage.ragUsageSummary?.retrievedChunks || execution.knowledgeFabric?.rag.hits.length || 0)} retrieved`,
+                                        `Memory scopes: ${Object.entries(runtimeUsage.memoryScopeUsage?.byScope || execution.memoryScopeUsage?.byScope || {}).map(([scope, count]) => `${scope}:${count}`).join(' · ') || 'awaiting shared/session reads'}`,
+                                        `Payload ref: ${workspace.stateKey} · ${detailLevel}`,
+                                    ] : []),
                                 ]),
                                 detailLevel === 'debug' && execution.result ? `Result\n\`\`\`\n${execution.result}\n\`\`\`` : `Result preview\n\`\`\`\n${truncateText(execution.result || summarizeExecution(execution), 900)}\n\`\`\``,
-                                formatJsonDetails('Structured details', payload),
+                                detailLevel === 'debug' ? formatJsonDetails('Structured details', payload) : '',
                                 hctx.formatRemainingProtocolSteps(),
                             ].filter(Boolean).join('\n\n'),
                         }],

package/dist/agents/adapters/mcp/tool-health.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Per-tool invocation ring buffer and health aggregator.
+ *
+ * Stores the last RING_SIZE durations per tool (ok + error separately).
+ * Used by dispatch.ts to record each call; exposed via /api/runtime/tool-health.
+ */
+export declare function recordToolInvocation(toolName: string, durationMs: number, status: 'ok' | 'error'): void;
+export interface ToolHealthEntry {
+    toolName: string;
+    p50Ms: number;
+    p95Ms: number;
+    errorRate: number;
+    recentCount: number;
+    lastSeenMs: number;
+    status: 'green' | 'amber' | 'red';
+}
+export declare function getToolHealthSummary(): ToolHealthEntry[];

package/dist/agents/adapters/mcp/tool-health.js

@@ -0,0 +1,57 @@
+/**
+ * Per-tool invocation ring buffer and health aggregator.
+ *
+ * Stores the last RING_SIZE durations per tool (ok + error separately).
+ * Used by dispatch.ts to record each call; exposed via /api/runtime/tool-health.
+ */
+const RING_SIZE = 100;
+const ERROR_RATE_WINDOW_MS = 5 * 60 * 1000; // 5-minute sliding window for error rate
+const _rings = new Map();
+export function recordToolInvocation(toolName, durationMs, status) {
+    let ring = _rings.get(toolName);
+    if (!ring) {
+        ring = [];
+        _rings.set(toolName, ring);
+    }
+    ring.push({ ts: Date.now(), durationMs, status });
+    if (ring.length > RING_SIZE)
+        ring.shift();
+}
+function percentile(sorted, p) {
+    if (!sorted.length)
+        return 0;
+    const idx = Math.ceil((p / 100) * sorted.length) - 1;
+    return sorted[Math.max(0, idx)];
+}
+export function getToolHealthSummary() {
+    const now = Date.now();
+    const result = [];
+    for (const [toolName, ring] of _rings) {
+        if (!ring.length)
+            continue;
+        const windowStart = now - ERROR_RATE_WINDOW_MS;
+        const recent = ring.filter(r => r.ts >= windowStart);
+        const allDurations = ring.map(r => r.durationMs).sort((a, b) => a - b);
+        const errors = recent.filter(r => r.status === 'error').length;
+        const errorRate = recent.length > 0 ? errors / recent.length : 0;
+        const p50Ms = percentile(allDurations, 50);
+        const p95Ms = percentile(allDurations, 95);
+        const lastSeenMs = ring[ring.length - 1].ts;
+        // Red: error rate > 5% OR p95 > 5s in last 5 min
+        // Amber: error rate > 1% OR p95 > 2s
+        let status;
+        if (errorRate > 0.05 || p95Ms > 5_000)
+            status = 'red';
+        else if (errorRate > 0.01 || p95Ms > 2_000)
+            status = 'amber';
+        else
+            status = 'green';
+        result.push({ toolName, p50Ms, p95Ms, errorRate, recentCount: recent.length, lastSeenMs, status });
+    }
+    // Sort: red first, then amber, then green; within tier sort by p95 desc
+    return result.sort((a, b) => {
+        const tier = { red: 0, amber: 1, green: 2 };
+        const td = tier[a.status] - tier[b.status];
+        return td !== 0 ? td : b.p95Ms - a.p95Ms;
+    });
+}

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

@@ -3,6 +3,9 @@
  *
  * Extracted from mcp.ts (Phase 3 split) to keep each file under 1500 LOC.
  * Uses BFS with pLimit(8) concurrency — no sync FS calls, no per-entry stat.
+ *
+ * Fast path: `git ls-files` for repos (< 300 ms even on large codebases).
+ * Fall back to walkDir only when not inside a git repository.
  */
 /**
  * Recursively walk `root`, returning all file paths.
@@ -10,8 +13,12 @@
  */
 export declare function walkDir(root: string): Promise<string[]>;
 /**
- * Scan `cwd` for TypeScript source files, caching by top-level directory mtime.
- * The caller provides the cache map so it lives with the adapter instance.
+ * Enumerate TypeScript source files via `git ls-files` (fast path) or
+ * recursive walkDir (fallback for non-git directories).
+ *
+ * `git ls-files` completes in < 300 ms even on large repos; walkDir on a
+ * repo with thousands of files can exceed the 25 s MCP handler timeout.
+ * Cache keyed on cwd + top-level directory mtime so repeated calls are free.
  */
 export declare function scanSourceFiles(cwd: string, scanCache: Map<string, {
     mtimeMs: number;

package/dist/agents/adapters/mcp/util/walk.js

@@ -3,10 +3,14 @@
  *
  * Extracted from mcp.ts (Phase 3 split) to keep each file under 1500 LOC.
  * Uses BFS with pLimit(8) concurrency — no sync FS calls, no per-entry stat.
+ *
+ * Fast path: `git ls-files` for repos (< 300 ms even on large codebases).
+ * Fall back to walkDir only when not inside a git repository.
  */
 import { promises as fsPromises } from 'fs';
 import * as path from 'path';
 import { pLimit } from '../../../../engines/util/p-limit.js';
+import { execAsync } from '../../../../utils/exec-async.js';
 const SKIP = new Set([
     'node_modules', 'dist', '.git', '.next', '.turbo', '.cache',
     'coverage', '.nexus-prime', '.claude', '.vercel', 'build', 'out',
@@ -47,8 +51,12 @@ export async function walkDir(root) {
     return results;
 }
 /**
- * Scan `cwd` for TypeScript source files, caching by top-level directory mtime.
- * The caller provides the cache map so it lives with the adapter instance.
+ * Enumerate TypeScript source files via `git ls-files` (fast path) or
+ * recursive walkDir (fallback for non-git directories).
+ *
+ * `git ls-files` completes in < 300 ms even on large repos; walkDir on a
+ * repo with thousands of files can exceed the 25 s MCP handler timeout.
+ * Cache keyed on cwd + top-level directory mtime so repeated calls are free.
  */
 export async function scanSourceFiles(cwd, scanCache) {
     let topMtime = 0;
@@ -57,14 +65,28 @@ export async function scanSourceFiles(cwd, scanCache) {
         topMtime = stat.mtimeMs;
     }
     catch {
-        // missing dir → walk and return [] safely
+        // missing dir — fall through and return []
     }
     const cached = scanCache.get(cwd);
     if (cached && cached.mtimeMs === topMtime) {
         return cached.files;
     }
-    const files = await walkDir(cwd);
-    const filtered = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'));
+    let filtered;
+    try {
+        // Fast path: git ls-files lists only tracked + untracked (unignored) files.
+        // -z uses NUL separators so paths with spaces work correctly.
+        const { stdout } = await execAsync('git ls-files --cached --others --exclude-standard -z -- "*.ts"', { cwd, timeout: 8_000 });
+        filtered = stdout
+            .split('\0')
+            .filter(Boolean)
+            .map((f) => path.isAbsolute(f) ? f : path.join(cwd, f))
+            .filter((f) => !f.endsWith('.d.ts'));
+    }
+    catch {
+        // Not a git repo or git unavailable — fall back to directory walk.
+        const files = await walkDir(cwd);
+        filtered = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'));
+    }
     scanCache.set(cwd, { mtimeMs: topMtime, files: filtered });
     return filtered;
 }

package/dist/agents/adapters/mcp.js

@@ -913,9 +913,14 @@ export class MCPAdapter {
             const swarm = await this.getOrchestrator().induce(goal);
             nexusEventBus.emit('nexusnet.sync', { newItemsCount: swarm.length });
         }
-        // v6: Lazy-init Synapse/Architects on first tool call if not yet initialized
+        // v6: Lazy-init Synapse/Architects on first tool call if not yet initialized.
+        // Mandate + hire tools need Architects live so coordination bridge is set before
+        // executeMandatePipeline runs (otherwise worklistId is null, orphaned teams).
         if (toolName.startsWith('nexus_synapse_')) {
             this.nexusRef.ensureSynapseInit();
+            if (toolName === 'nexus_synapse_mandate' || toolName === 'nexus_synapse_assign_mission' || toolName === 'nexus_synapse_hire') {
+                this.nexusRef.ensureArchitectsInit();
+            }
         }
         const synapseResponse = await handleSynapseToolCall(toolName, args, this.nexusRef.getSynapse?.() ?? null);
         if (synapseResponse) {

package/dist/architects/bootstrap.js

@@ -185,41 +185,65 @@ export function initArchitects(options) {
     if (hasOperative)
         ward.start();
     const onOperativeHired = ({ operativeId, strikeTeamId }) => {
-        knownOperatives.add(operativeId);
-        operativeActivity.set(operativeId, { strikeTeamId, lastSortieAt: null });
-        ensureImplicitWorklist(strikeTeamId);
+        try {
+            knownOperatives.add(operativeId);
+            operativeActivity.set(operativeId, { strikeTeamId, lastSortieAt: null });
+            ensureImplicitWorklist(strikeTeamId);
+        }
+        catch (err) {
+            console.error('[Architects] onOperativeHired failed', operativeId, err);
+            nexusEventBus.emit('architects.event.failed', { event: 'operative.hired', operativeId, error: String(err) });
+        }
     };
     const onMissionAssigned = ({ operativeId, missionId, title }) => {
-        const activity = operativeActivity.get(operativeId);
-        const strikeTeamId = activity?.strikeTeamId ?? null;
-        if (!strikeTeamId)
-            return;
-        const worklistId = ensureImplicitWorklist(strikeTeamId);
-        upsertWorkItem(db, {
-            id: missionId,
-            worklistId,
-            title,
-            status: 'todo',
-            assignedOperativeId: operativeId,
-            constructionLockId: null,
-            dependsOn: [],
-            branch: null,
-            mergedAt: null,
-            createdAt: new Date().toISOString(),
-        });
+        try {
+            const activity = operativeActivity.get(operativeId);
+            const strikeTeamId = activity?.strikeTeamId ?? null;
+            if (!strikeTeamId)
+                return;
+            const worklistId = ensureImplicitWorklist(strikeTeamId);
+            upsertWorkItem(db, {
+                id: missionId,
+                worklistId,
+                title,
+                status: 'todo',
+                assignedOperativeId: operativeId,
+                constructionLockId: null,
+                dependsOn: [],
+                branch: null,
+                mergedAt: null,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error('[Architects] onMissionAssigned failed', missionId, err);
+            nexusEventBus.emit('architects.event.failed', { event: 'mission.assigned', operativeId, missionId, error: String(err) });
+        }
     };
     const onSortieCompleted = ({ operativeId, missionId, status }) => {
-        const activity = operativeActivity.get(operativeId);
-        if (activity) {
-            activity.lastSortieAt = new Date().toISOString();
-            operativeActivity.set(operativeId, activity);
+        try {
+            const activity = operativeActivity.get(operativeId);
+            if (activity) {
+                activity.lastSortieAt = new Date().toISOString();
+                operativeActivity.set(operativeId, activity);
+            }
+            if (!missionId)
+                return;
+            updateWorkItemStatus(db, missionId, status === 'completed' ? 'done' : status === 'failed' ? 'failed' : 'blocked');
+        }
+        catch (err) {
+            console.error('[Architects] onSortieCompleted failed', missionId, err);
+            nexusEventBus.emit('architects.event.failed', { event: 'sortie.completed', operativeId, missionId: missionId ?? undefined, error: String(err) });
         }
-        if (!missionId)
-            return;
-        updateWorkItemStatus(db, missionId, status === 'completed' ? 'done' : status === 'failed' ? 'failed' : 'blocked');
     };
     const onStriketeamDeployed = ({ strikeTeamId }) => {
-        ensureImplicitWorklist(strikeTeamId);
+        try {
+            ensureImplicitWorklist(strikeTeamId);
+        }
+        catch (err) {
+            console.error('[Architects] onStriketeamDeployed failed', strikeTeamId, err);
+            nexusEventBus.emit('architects.event.failed', { event: 'striketeam.deployed', strikeTeamId, error: String(err) });
+        }
     };
     const onStanddown = () => setConvergencePaused(true);
     const onResumed = () => setConvergencePaused(false);

package/dist/cli/hook.js

@@ -17,6 +17,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { spawn } from 'child_process';
 function findDaemonLock(cwd) {
     const nexusPrimeDir = path.join(os.homedir(), '.nexus-prime');
     if (!fs.existsSync(nexusPrimeDir))
@@ -103,6 +104,31 @@ async function readStdinJson() {
 // --------------------------------------------------------------------------
 // Hook subcommands
 // --------------------------------------------------------------------------
+function spawnDaemon(cwd) {
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        return;
+    try {
+        const child = spawn(process.execPath, [entrypoint, 'daemon', '__serve'], {
+            cwd,
+            env: { ...process.env, NEXUS_WORKSPACE_ROOT: cwd },
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+    catch { /* never block the hook */ }
+}
+async function waitForDaemonLock(cwd, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const lock = findDaemonLock(cwd);
+        if (lock)
+            return lock;
+        await new Promise(r => setTimeout(r, 100).unref());
+    }
+    return null;
+}
 /** UserPromptSubmit — call nexus_session_bootstrap so the model never has to. */
 export async function runHookBootstrap() {
     const data = await readStdinJson();
@@ -110,9 +136,15 @@ export async function runHookBootstrap() {
     const goal = String(data.user_message ?? data.prompt ?? '').trim();
     if (!goal)
         return;
-    const lock = findDaemonLock(cwd);
+    let lock = findDaemonLock(cwd);
+    if (!lock) {
+        // Daemon not running — spawn it and wait up to 1.5 s for the lock to appear.
+        // If it doesn't come up in time, fall back silently (never block the model).
+        spawnDaemon(cwd);
+        lock = await waitForDaemonLock(cwd, 1_500);
+    }
     if (!lock)
-        return; // no daemon running — model must bootstrap manually
+        return;
     await callDaemonTool(lock, 'nexus_session_bootstrap', {
         goal: goal.slice(0, 500),
     }, 10_000);

package/dist/cli/install-wizard.js

@@ -5,6 +5,7 @@
  */
 import { createHash } from 'crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
 import { detectInstalledIDEs, getMcpConfigForIDE } from '../agents/adapters/ide-compat.js';
@@ -93,9 +94,12 @@ export async function configureIDE(ide, opts = {}) {
                 silent: opts.verbose === false,
                 workspaceRoot,
             });
-            // Write Claude Code hooks alongside the MCP entry (idempotent merge)
+            // Write Claude Code hooks alongside the MCP entry (idempotent merge).
+            // Write to both workspace and global user settings so desktop-mode
+            // Claude Code (which reads ~/.claude/settings.json) also auto-bootstraps.
             if (ide === 'claude-code') {
                 _writeClaudeCodeHooks(workspaceRoot);
+                _writeClaudeCodeHooks(homedir());
             }
             // Write workspace-local configs for other IDEs that may be present
             _writeWorkspaceLocalConfigs(ide, workspaceRoot);

package/dist/dashboard/app/index.html

@@ -23,6 +23,11 @@
 <script type="module" src="./main.js"></script>
 </head>
 <body>
+<script>
+if(location.protocol==='file:'){
+  document.write('<div style="position:fixed;top:0;left:0;right:0;z-index:9999;background:#d97706;color:#fff;text-align:center;padding:6px 12px;font:13px/1.4 system-ui,sans-serif">Preview mode \u2014 API unavailable. Open <a href="http://localhost:3377/" style="color:#fff;text-decoration:underline">http://localhost:3377/</a> for the live dashboard.</div><div style="height:34px"></div>');
+}
+</script>
 <div class="noise" aria-hidden="true"></div>
 <div id="toast-stack" aria-live="polite" aria-atomic="true"></div>
 
@@ -108,6 +113,12 @@
           <div><div class="kb-col-hd"><span class="kb-col-title">Done</span><span class="kb-count" id="kc-done">0</span></div><div class="kb-body" id="kb-done"></div></div>
         </div>
 
+        <!-- Tool health strip -->
+        <div id="tool-health-card" class="card" style="margin-bottom:16px;display:none">
+          <div class="shd" style="margin-bottom:8px">Tool Health <span id="tool-health-stamp" style="font-size:11px;opacity:.5;font-weight:400"></span></div>
+          <div id="tool-health-list" style="display:flex;flex-wrap:wrap;gap:8px"></div>
+        </div>
+
         <!-- Events feed + system pulse -->
         <div class="cockpit-bottom">
           <div class="card">

package/dist/dashboard/app/main.js

@@ -47,6 +47,10 @@ 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();
+    }
     if (tab === 'workforce' && ['synapse','operative','mission'].includes(evt.category)) {
         Workforce.render();
     }

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

@@ -18,6 +18,10 @@
 .org-box.root-box { border-color: rgba(0,255,136,0.4); color: var(--accent); }
 .org-box.team-box { border-color: rgba(0,212,255,0.3); color: var(--secondary); }
 .org-vline { width: 1px; height: 14px; background: var(--border); margin: 0 auto; }
+.org-row { display: flex; gap: 16px; flex-wrap: wrap; justify-content: center; align-items: flex-start; }
+.org-branch { display: flex; flex-direction: column; align-items: center; }
+/* Team tint: subtree root gets a faint background based on team color slot */
+.org-branch[data-team] > div > .org-box { border-color: rgba(0,212,255,0.25); }
 .op-status-dot {
     display: inline-block; width: 5px; height: 5px; border-radius: 50%;
     margin-right: 5px; background: var(--text-dim); vertical-align: middle;

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

@@ -72,6 +72,8 @@ export async function load() {
         api('/api/dashboard/surface/operate', 5000),
         api('/api/synapse/health', 5000),
     ]);
+    // Non-blocking: tool health data from ring buffer
+    loadToolHealth();
     S.tokensSummary  = tok;
     S.tokensLifetime = life;
     S.operateSurface = op;
@@ -94,6 +96,7 @@ export function render() {
     renderKanban();
     renderEvents();
     renderPulse();
+    renderToolHealth();
 }
 
 /* ── Memory pyramid (above kanban) ── */
@@ -295,6 +298,40 @@ function renderPulse() {
     el.innerHTML=rows.map(([k,v])=>`<div class="row"><span class="row-k">${esc(k)}</span><span class="row-v">${esc(v)}</span></div>`).join('');
 }
 
+/* ── Tool health strip ── */
+let _toolHealth = [];
+
+export async function loadToolHealth() {
+    const data = await api('/api/runtime/tool-health', 10_000);
+    if (Array.isArray(data)) {
+        _toolHealth = data;
+        renderToolHealth();
+    }
+}
+
+function renderToolHealth() {
+    const card = $('tool-health-card');
+    const list = $('tool-health-list');
+    const stamp = $('tool-health-stamp');
+    if (!card || !list) return;
+    if (!_toolHealth.length) { card.style.display = 'none'; return; }
+    card.style.display = '';
+    if (stamp) stamp.textContent = 'updated ' + new Date().toLocaleTimeString([], {hour:'2-digit',minute:'2-digit',second:'2-digit'});
+
+    const colorMap = { green: 'var(--accent)', amber: '#ffd14d', red: '#ff5f57' };
+    list.innerHTML = _toolHealth.map(t => {
+        const col = colorMap[t.status] || 'var(--muted)';
+        const errPct = Math.round((t.errorRate || 0) * 100);
+        const p95 = t.p95Ms >= 1000 ? (t.p95Ms / 1000).toFixed(1) + 's' : t.p95Ms + 'ms';
+        const pill = errPct > 0 ? `<span style="background:#ff5f5722;color:#ff5f57;border-radius:4px;padding:1px 5px;font-size:10px">${errPct}% err</span>` : '';
+        return `<div style="display:flex;align-items:center;gap:6px;padding:4px 8px;border-radius:6px;background:var(--surface2);font-size:12px">
+            <span style="width:8px;height:8px;border-radius:50%;background:${col};flex-shrink:0"></span>
+            <span style="font-family:var(--font-mono);color:var(--fg1)">${esc(t.toolName.replace('nexus_',''))}</span>
+            <span style="color:var(--muted)">${p95}</span>${pill}
+        </div>`;
+    }).join('');
+}
+
 /* ── Run drawer helper ── */
 function _openRunDrawer(runId) {
     const run = S.runs.find(r=>r.id===runId||r.runId===runId);

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

@@ -168,6 +168,28 @@ export function render() {
 }
 
 /* ── Org chart ── */
+function _renderOpNode(op) {
+    const sc=op.status==='ACTIVE'||op.status==='active'?'active':op.status==='ZOMBIE'||op.status==='dead'?'dead':'';
+    const interval=op.sortieIntervalMs||60000, lastAt=op.lastSortieAt||op.heartbeatAt||Date.now();
+    const pillId=`op-pill-${esc(op.id||op.operativeId||'')}`;
+    return `<div class="org-box" id="${pillId}" data-opid="${esc(op.id||op.operativeId)}" data-opname="${esc(op.role||op.name||'agent')}" data-interval="${interval}" data-lastat="${lastAt}">
+        <span class="op-status-dot ${esc(sc)}"></span>${esc(op.role||op.name||'agent')}
+    </div>`;
+}
+
+function _renderOrgBranch(op, childrenOf, depth) {
+    const kids = childrenOf.get(op.id||op.operativeId) || [];
+    const kidsHtml = (depth < 3 && kids.length)
+        ? `<div class="org-vline"></div><div class="org-row">${kids.map(k => _renderOrgBranch(k, childrenOf, depth+1)).join('')}</div>`
+        : '';
+    const teamTint = op.team ? `data-team="${esc(op.team)}"` : '';
+    return `<div class="org-branch" ${teamTint}>
+        <div style="display:flex;flex-direction:column;align-items:center">
+            ${_renderOpNode(op)}${kidsHtml}
+        </div>
+    </div>`;
+}
+
 function renderOrgChart() {
     const el=$('org-container'); if (!el) return;
     const ops=S.synapseHealth;
@@ -175,30 +197,29 @@ function renderOrgChart() {
         el.innerHTML=`<div class="empty"><div class="empty-title">${V.empty.workforce}</div><div class="empty-sub">Hire a specialist from the panel below.</div></div>`;
         return;
     }
-    const teams={};
-    for (const op of ops) { const t=op.team||'solo'; (teams[t]=teams[t]||[]).push(op); }
-    const tHtml=Object.entries(teams).map(([name,members])=>{
-        const mHtml=members.map(op=>{
-            const sc=op.status==='ACTIVE'||op.status==='active'?'active':op.status==='ZOMBIE'||op.status==='dead'?'dead':'';
-            const interval=op.sortieIntervalMs||60000, lastAt=op.lastSortieAt||op.heartbeatAt||Date.now();
-            const pillId=`op-pill-${esc(op.id||op.operativeId||'')}`;
-            return `<div style="display:flex;flex-direction:column;align-items:center">
-                <div class="org-vline" style="height:10px"></div>
-                <div class="org-box" id="${pillId}" data-opid="${esc(op.id||op.operativeId)}" data-opname="${esc(op.role||op.name||'agent')}" data-interval="${interval}" data-lastat="${lastAt}">
-                    <span class="op-status-dot ${esc(sc)}"></span>${esc(op.role||op.name||'agent')}
-                </div>
-            </div>`;
-        }).join('');
-        return `<div style="display:flex;flex-direction:column;align-items:center">
-            <div class="org-box team-box">${esc(name)}</div>
-            <div class="org-vline"></div>
-            <div style="display:flex;gap:10px;flex-wrap:wrap;justify-content:center">${mHtml}</div>
-        </div>`;
-    }).join('');
+
+    // Build parent→children map keyed by operative id (null = root).
+    const childrenOf = new Map();
+    for (const op of ops) {
+        const parent = op.reportsToOperativeId || null;
+        if (!childrenOf.has(parent)) childrenOf.set(parent, []);
+        childrenOf.get(parent).push(op);
+    }
+    // Operatives with no parent whose parent id doesn't match any known op are also roots.
+    const knownIds = new Set(ops.map(o => o.id||o.operativeId));
+    for (const op of ops) {
+        if (op.reportsToOperativeId && !knownIds.has(op.reportsToOperativeId)) {
+            if (!childrenOf.has(null)) childrenOf.set(null, []);
+            childrenOf.get(null).push(op);
+        }
+    }
+    const roots = childrenOf.get(null) || ops; // fallback: all ops as roots if no hierarchy
+
+    const tHtml = roots.map(op => _renderOrgBranch(op, childrenOf, 0)).join('');
     el.innerHTML=`<div style="display:flex;flex-direction:column;align-items:center">
         <div class="org-box root-box">Orchestrator</div>
         <div class="org-vline"></div>
-        <div style="display:flex;gap:16px;flex-wrap:wrap;justify-content:center">${tHtml}</div>
+        <div class="org-row">${tHtml}</div>
     </div>`;
 
     // Attach click + heartbeat
@@ -266,11 +287,30 @@ function renderSpecialistGrid() {
 }
 
 /* ── Hire sheet ── */
+function _buildHireSelectors() {
+    const ops = (S.synapseHealth || []);
+    const teams = [...new Set(ops.map(o => o.team).filter(Boolean))];
+    const opOptions = [`<option value="">— none (team lead) —</option>`,
+        ...ops.map(o => `<option value="${esc(o.id||o.operativeId)}">${esc(o.role||o.name||o.id)}</option>`)
+    ].join('');
+    const teamOptions = [`<option value="">— solo —</option>`,
+        ...teams.map(t => `<option value="${esc(t)}">${esc(t)}</option>`)
+    ].join('');
+    const sel = (id, label, opts) =>
+        `<label style="display:block;margin-bottom:4px;font-size:var(--text-sm);color:var(--text-muted)">${label}</label>
+         <select id="${id}" style="width:100%;background:var(--bg-panel);border:1px solid var(--border);border-radius:var(--radius);padding:6px 10px;font-size:var(--text-sm);color:var(--text-main);margin-bottom:var(--space-4)">${opts}</select>`;
+    return { opOptions: sel('hire-reports-to', 'Reports to (optional)', opOptions),
+             teamOptions: sel('hire-team', 'Strike team (optional)', teamOptions) };
+}
+
 function _showHireSheet(specialistId, name) {
+    const { opOptions, teamOptions } = _buildHireSelectors();
     openDrawer({ title: `Hire ${name}`,
         body: `<div class="dsec">
             <div class="dsec-title">Specialist</div>
             <div style="font-size:var(--text-sm);color:var(--text-muted);margin-bottom:var(--space-4)">${esc(name)}<br><span style="opacity:.6">${esc(specialistId)}</span></div>
+            ${opOptions}
+            ${teamOptions}
             <label style="display:block;margin-bottom:var(--space-2);font-size:var(--text-sm);color:var(--text-muted)">Budget cap (USD)</label>
             <input type="number" id="hire-budget" value="2.00" step="0.50" min="0.50" max="50"
                 style="width:100%;background:var(--bg-panel);border:1px solid var(--border);border-radius:var(--radius);padding:6px 10px;font-size:var(--text-sm);color:var(--text-main);margin-bottom:var(--space-4)">
@@ -281,12 +321,19 @@ function _showHireSheet(specialistId, name) {
         const specId = btn.target.dataset.specid;
         const specName = btn.target.dataset.specname;
         const budget = parseFloat(document.getElementById('hire-budget')?.value||'2');
+        const reportsToVal = (document.getElementById('hire-reports-to')?.value||'').trim()||null;
+        const teamVal = (document.getElementById('hire-team')?.value||'').trim()||null;
         btn.target.disabled = true;
         btn.target.textContent = 'Hiring…';
 
         // Optimistic hire: open the success drawer immediately (<5ms), then reconcile.
         const optimisticRecord = { operative: { specialistId: specId, _pending: true }, pricing: null };
-        const result = await post('/api/synapse/hire', { specialistId: specId, budgetCapUsd: budget }, { optimistic: optimisticRecord });
+        const result = await post('/api/synapse/hire', {
+            specialistId: specId,
+            budgetCapUsd: budget,
+            reportsToOperativeId: reportsToVal,
+            strikeTeamId: teamVal,
+        }, { optimistic: optimisticRecord });
 
         // Immediately open drawer with pending state.
         openDrawer({ title: `${specName} hired`,

package/dist/dashboard/routes/governance.js

@@ -88,8 +88,8 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
             const operativeId = result?.id ?? result?.operativeId ?? null;
             const baseUrl = ctx.getAddress() ?? 'http://localhost:3377';
             // Optionally fire a warm-up first sortie (body.fireFirstSortie === true).
-            // Non-blocking — we don't await; the dispatch runs in the background.
-            let firstDispatchRunId = null;
+            // Non-blocking — dispatch runs in the background; runId is emitted via SSE
+            // (synapse.first-sortie.dispatched) when ready so the client doesn't race.
             if (body.fireFirstSortie === true && operativeId && result?.specialistId) {
                 const repoRoot = ctx.repoRoot ?? process.cwd();
                 scheduleFirstSortie({
@@ -97,14 +97,20 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
                     repoRoot,
                     repoName: path.basename(repoRoot),
                     budgetCapUsd: result?.budgetCapUsd ?? 0.50,
-                }).then(r => { if (r)
-                    firstDispatchRunId = r.runId; }).catch(() => { });
+                }).then(r => {
+                    if (r?.runId) {
+                        nexusEventBus.emit('dashboard.action', {
+                            action: 'synapse.first-sortie.dispatched',
+                            status: 'ok',
+                            target: r.runId,
+                        });
+                    }
+                }).catch(() => { });
             }
             ctx.respondJson(res, {
                 operative: result,
                 pricing,
                 firstSortieEstimate: pricing,
-                firstDispatchRunId,
                 dashboardUrl: operativeId ? `${baseUrl}/#workforce/${operativeId}` : `${baseUrl}/#workforce`,
             }, 201);
         }
@@ -114,6 +120,10 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
         return true;
     }
     if (req.method === 'POST' && url.pathname === '/api/synapse/deploy-crew') {
+        // Ensure Architects is live before mandate so coordination bridge is wired.
+        // getSynapse() triggers ensureSynapseInit(); getArchitects() triggers ensureArchitectsInit()
+        // + reconnectSynapseCoordination() so worklistId is non-null in the pipeline.
+        ctx.getArchitects();
         const synapse = ctx.getSynapse();
         if (!synapse) {
             const initErr = ctx.getSynapseInitError();

package/dist/dashboard/routes/health.js

@@ -1,3 +1,4 @@
+import { getToolHealthSummary } from '../../agents/adapters/mcp/tool-health.js';
 export const handleHealthRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/api/license') {
         const { getSharedLicenseManager } = await import('../../licensing/index.js');
@@ -22,5 +23,9 @@ export const handleHealthRoutes = async (ctx, req, res, url) => {
         await ctx.respondCachedJson(res, 'health', 15_000, () => ctx.collectHealth());
         return true;
     }
+    if (req.method === 'GET' && url.pathname === '/api/runtime/tool-health') {
+        ctx.respondJson(res, getToolHealthSummary());
+        return true;
+    }
     return false;
 };

package/dist/dashboard/server.js

@@ -281,6 +281,16 @@ export class DashboardServer {
                 this.serveAppAsset(res, url.pathname);
                 return;
             }
+            // Root-level aliases so relative paths in index.html work when served at /
+            // (e.g. ./styles/tokens.css → /styles/tokens.css → here).
+            // /app/* kept for backward compat (bookmarks, devtools, any hardcoded refs).
+            const ROOT_APP_PREFIXES = ['/styles/', '/views/', '/widgets/'];
+            const ROOT_APP_FILES = new Set(['/main.js', '/api.js', '/router.js', '/sse.js', '/state.js', '/vocabulary.js']);
+            if (req.method === 'GET' && (ROOT_APP_PREFIXES.some(p => url.pathname.startsWith(p)) ||
+                ROOT_APP_FILES.has(url.pathname))) {
+                this.serveAppAsset(res, '/app' + url.pathname);
+                return;
+            }
             if (req.method === 'GET' && url.pathname === '/welcome') {
                 this.serveStaticHtml(res, path.join(__dirname, 'welcome.html'));
                 return;
@@ -415,6 +425,7 @@ export class DashboardServer {
     serveAppIndex(res) {
         const strictHeaders = {
             'Content-Type': 'text/html',
+            'Cache-Control': 'no-cache, must-revalidate',
             'Content-Security-Policy': [
                 "default-src 'self'",
                 "style-src 'self'",

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

@@ -174,6 +174,8 @@ export class SseBroker {
     }
 }
 function mapEventCategory(type) {
+    if (type === 'tool.invocation')
+        return 'mcp';
     if (type.startsWith('mcp.'))
         return 'mcp';
     if (type.startsWith('planner.'))

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.health.tick' | 'memory.sqlite.retry' | 'pod.signal' | 'tokens.optimized' | 'tokens.searchSaved' | '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' | 'nexus.shutdown' | 'orchestrator.disposed' | 'orchestrator.funnel.stage' | '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' | '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.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' | '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';
+export type NexusEventType = 'system.boot' | 'planner.stage' | 'memory.store' | 'memory.dedup' | 'memory.recall' | 'memory.flushed' | 'memory.health.tick' | 'memory.sqlite.retry' | 'pod.signal' | 'tokens.optimized' | 'tokens.searchSaved' | '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' | 'nexus.shutdown' | 'orchestrator.disposed' | 'orchestrator.funnel.stage' | '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' | '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.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';
 export interface NexusEventPayloads {
     'system.boot': {
         version: string;
@@ -302,6 +302,11 @@ export interface NexusEventPayloads {
         stage: string;
         error: string;
     };
+    'tool.invocation': {
+        toolName: string;
+        durationMs: number;
+        status: 'ok' | 'error';
+    };
     'memory.tier.promoted': {
         memoryId: string;
         from: string;
@@ -620,6 +625,13 @@ export interface NexusEventPayloads {
         subject: string;
         error: string;
     };
+    'architects.event.failed': {
+        event: string;
+        operativeId?: string;
+        missionId?: string;
+        strikeTeamId?: string;
+        error: string;
+    };
     'ledger.duplicate-prevented': {
         fingerprint: string;
         existingId: string;

package/dist/synapse/bootstrap.js

@@ -144,7 +144,7 @@ export function initSynapse(options) {
         if (payload.operativeId) {
             db.prepare('UPDATE synapse_operatives SET health_state=\'BLOCKED\', state=\'SUSPENDED\', suspend_reason=\'manual\' WHERE id=?').run(payload.operativeId);
             nexusEventBus.emit('synapse.operative.health.changed', { operativeId: payload.operativeId, healthState: 'BLOCKED' });
-            providers.memory.store(`[Architects:Blocked] ${payload.operativeId} ${payload.reason ?? ''}`.trim(), 0.82, ['#synapse', '#blocked']);
+            providers.memory.store(`[Architects:Blocked] ${payload.operativeId} ${payload.reason ?? ''}`.trim(), 0.82, ['#synapse', '#blocked'], undefined, 0, { provenance: { agentId: payload.operativeId, source: 'system' } });
         }
     };
     const stallListener = ({ operativeId }) => {

package/dist/synapse/mandate/pipeline.js

@@ -69,6 +69,7 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
         // Ensure Architects creates a blueprint + worklist for this team (auto-wiring)
         const worklistId = providers.coordination?.getWorklistId(teamId) ?? null;
         const blueprintId = worklistId ? `implicit-blueprint:${teamId}` : null;
+        let leadOperativeId = null;
         const operativeIds = Array.from({ length: maxOps }, (_, index) => {
             const skill = matched.skills[index] ?? matched.skills[0];
             const specialist = matched.specialists[index] ?? matched.specialists[0] ?? null;
@@ -82,7 +83,11 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
                 strikeTeamId: teamId,
                 sortieIntervalMs: SynapseConfig.sortieIntervalMs,
                 origin: 'mandate',
+                // First operative is the team lead; subsequent members report to it.
+                reportsToOperativeId: index === 0 ? null : leadOperativeId,
             });
+            if (index === 0)
+                leadOperativeId = operative.id;
             nexusEventBus.emit('synapse.operative.hired', {
                 operativeId: operative.id,
                 name: operative.name,
@@ -152,7 +157,12 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
             correlationId: teamId,
             status: 'deployed',
         });
-        providers.memory.store(`[Synapse:Mandate] ${mandateText}`, 0.85, ['#synapse', '#mandate', `#team:${teamId}`]);
+        providers.memory.store(`[Synapse:Mandate] ${mandateText}`, 0.85, ['#synapse', '#mandate', `#team:${teamId}`], undefined, 0, {
+            provenance: {
+                source: 'runtime',
+                containerTags: [`#team:${teamId}`, ...(worklistId ? [`#worklist:${worklistId}`] : [])],
+            },
+        });
         return getStrikeTeam(db, teamId);
     })();
     return team;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "6.0.2",
+  "version": "6.2.0",
   "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",
@@ -25,6 +25,7 @@
     "nexus-prime": "dist/cli.js"
   },
   "scripts": {
+    "prepare": "git config core.hooksPath .hooks || true",
     "nexus:dev": "node dev-orchestrator.mjs",
     "generate:competitive-landscape": "tsx scripts/generate-competitive-landscape.ts",
     "generate:readme-catalog": "tsx scripts/generate-readme-runtime-catalog.ts",