nexus-prime 7.9.17 → 7.9.18

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

@@ -292,8 +292,9 @@ export function buildMcpToolDefinitions() {
                 properties: {
                     goal: { type: 'string', description: 'What you are trying to accomplish' },
                     task: { type: 'string', description: 'Alias for goal (deprecated, use goal)' },
-                    files: { type: 'array', items: { type: 'string' }, description: 'File paths to analyze. If omitted, auto-scans src/' },
-                    budget: { type: 'number', description: 'Token budget override' }
+                    files: { type: 'array', items: { type: 'string' }, description: 'File paths to analyze. If omitted, auto-scans a capped source shortlist instead of the whole repo.' },
+                    budget: { type: 'number', description: 'Token budget override' },
+                    maxFiles: { type: 'number', description: 'Maximum files to include when files are omitted (default 80, max 200)' }
                 },
                 required: [],
             },

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

@@ -14,12 +14,28 @@ import { GhostPass, summarizeExecution } from '../../../../phantom/index.js';
 import { applyExecutionPreset, resolveExecutionPreset } from '../../../../engines/execution-presets.js';
 import { pLimit } from '../../../../engines/util/p-limit.js';
 import { promises as fsPromises } from 'fs';
+import * as path from 'path';
 import { getSharedLicenseManager } from '../../../../licensing/index.js';
 import { SessionDNAManager } from '../../../../engines/session-dna.js';
 import { getSharedTelemetry } from '../../../../engines/telemetry-remote.js';
 import { requireRuntime } from '../util/require-runtime.js';
 import { ensureCrGraphBuilt } from '../../../../engines/code-review-graph-client.js';
 import { recordFirstBootstrap } from '../../../../engines/telemetry.js';
+function escapeMarkdownTableCell(value) {
+    return String(value ?? '')
+        .replace(/\r?\n/g, ' ')
+        .replace(/\|/g, '\\|')
+        .trim();
+}
+function markdownTable(headers, rows) {
+    if (rows.length === 0)
+        return '';
+    return [
+        `| ${headers.map(escapeMarkdownTableCell).join(' | ')} |`,
+        `| ${headers.map(() => '---').join(' | ')} |`,
+        ...rows.map(row => `| ${row.map(escapeMarkdownTableCell).join(' | ')} |`),
+    ].join('\n');
+}
 export function extractSkillSelectorsFromPrompt(prompt) {
     const selectors = new Set();
     const add = (value) => {
@@ -282,6 +298,9 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                 `Memory stats: prefrontal ${bootstrap.memoryStats?.prefrontal ?? 0} · hippocampus ${bootstrap.memoryStats?.hippocampus ?? 0} · cortex ${bootstrap.memoryStats?.cortex ?? 0}`,
                                 `Recommended next step: ${bootstrap.recommendedNextStep || 'nexus_orchestrate'}`,
                                 `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')}`,
+                                bootstrap.tokenOptimization?.planMetrics
+                                    ? `Token budget: original ${Number(bootstrap.tokenOptimization.planMetrics.originalTokens ?? 0).toLocaleString()} → planned ${Number(bootstrap.tokenOptimization.planMetrics.compressedTokens ?? 0).toLocaleString()} across ${Number(bootstrap.tokenOptimization.planMetrics.files ?? 0).toLocaleString()} file action(s)`
+                                    : '',
                                 `Catalog health: ${bootstrap.catalogHealth?.overall || 'unknown'} · selected ${bootstrap.artifactSelectionAudit?.selected?.length || 0}`,
                                 (() => {
                                     try {
@@ -585,8 +604,13 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             const rawFiles = Array.isArray(request.params.arguments?.files)
                 ? request.params.arguments.files.map(String)
                 : null;
-            const filePaths = rawFiles
-                ?? await hctx.scanSourceFiles(hctx.getWorkspace(request.params.arguments ?? {}).repoRoot);
+            const workspaceRoot = hctx.getWorkspace(request.params.arguments ?? {}).repoRoot;
+            const scannedFilePaths = rawFiles
+                ?? await hctx.scanSourceFiles(workspaceRoot);
+            const requestedMaxFiles = Number(request.params.arguments?.maxFiles ?? request.params.arguments?.limit ?? 80);
+            const maxFiles = Math.max(1, Math.min(Number.isFinite(requestedMaxFiles) ? Math.floor(requestedMaxFiles) : 80, 200));
+            const filePaths = rawFiles ? scannedFilePaths : scannedFilePaths.slice(0, maxFiles);
+            const omittedFiles = rawFiles ? 0 : Math.max(0, scannedFilePaths.length - filePaths.length);
             const statLimit = pLimit(8);
             const files = await Promise.all(filePaths.map((p) => statLimit(async () => {
                 const resolved = hctx.resolveToolPath(p, request.params.arguments ?? {});
@@ -660,10 +684,14 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             const dedupLine = dedupTokens > 0
                 ? `\n           ${dedupTokens.toLocaleString()} tok deduped (${delta.unchanged.length} unchanged files)`
                 : '';
+            const scanLine = rawFiles
+                ? `\n           explicit file set: ${filePaths.length.toLocaleString()} file(s)`
+                : `\n           auto-scan capped: ${filePaths.length.toLocaleString()}/${scannedFilePaths.length.toLocaleString()} file(s)${omittedFiles ? ` (${omittedFiles.toLocaleString()} omitted; pass files or maxFiles to override)` : ''}`;
             const receipt = [
                 '',
                 `▸ Receipt  ${plan.totalEstimatedTokens.toLocaleString()} tok in`,
                 `           ${plan.savings.toLocaleString()} tok saved (${pct}% vs full read)${dedupLine}`,
+                scanLine.trimStart(),
                 `           ~$${estimatedCostUsd.toFixed(4)} estimated · ~$${savedCostUsd.toFixed(4)} saved`,
             ].join('\n');
             return { content: [{ type: 'text', text: formatted + receipt + notification + nudge }] };
@@ -673,7 +701,9 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             const ctx = {
                 action: String(args?.action ?? ''),
                 tokenCount: args?.tokenCount,
-                filesToModify: args?.filesToModify,
+                filesToModify: Array.isArray(args?.filesToModify)
+                    ? args.filesToModify.map(String)
+                    : (Array.isArray(args?.files) ? args.files.map(String) : undefined),
                 isDestructive: args?.isDestructive,
             };
             const result = getGuardrailEngine().check(ctx);
@@ -685,15 +715,47 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             const nudge = result.passed
                 ? hctx.telemetry.planningNudge('high_call_count', {})
                 : hctx.telemetry.planningNudge('mindkit_fail', {});
+            const verdict = result.passed ? 'PASS' : 'FAIL';
+            const violationRows = result.violations.map((v) => {
+                const item = v;
+                return [
+                    item.id ?? 'violation',
+                    item.severity ?? 'high',
+                    item.message ?? item.description ?? 'blocked by guardrail',
+                ];
+            });
+            const warningRows = result.warnings.map((w) => {
+                const item = w;
+                return [
+                    item.id ?? 'warning',
+                    item.severity ?? 'warn',
+                    item.message ?? item.description ?? 'review recommended',
+                ];
+            });
+            const detailJson = JSON.stringify({
+                passed: result.passed,
+                score: Math.round(result.score * 100),
+                filesToModify: ctx.filesToModify ?? [],
+                violations: result.violations,
+                warnings: result.warnings,
+                summary: getGuardrailEngine().format(result)
+            }, null, 2);
             return {
                 content: [{
-                        type: 'text', text: JSON.stringify({
-                            passed: result.passed,
-                            score: Math.round(result.score * 100),
-                            violations: result.violations,
-                            warnings: result.warnings,
-                            summary: getGuardrailEngine().format(result)
-                        }, null, 2) + nudge
+                        type: 'text',
+                        text: [
+                            `Mindkit check: ${verdict}`,
+                            formatBullets([
+                                `Score: ${Math.round(result.score * 100)}/100`,
+                                `Files: ${ctx.filesToModify?.length ? ctx.filesToModify.join(', ') : 'none declared'}`,
+                                `Decision: ${result.passed ? 'proceed' : 'stop and resolve guardrail violations'}`,
+                                `Summary: ${getGuardrailEngine().format(result)}`,
+                            ]),
+                            violationRows.length ? `Violations\n${markdownTable(['Rule', 'Severity', 'Message'], violationRows)}` : '',
+                            warningRows.length ? `Warnings\n${markdownTable(['Rule', 'Severity', 'Message'], warningRows)}` : '',
+                            `Details\n\`\`\`json\n${detailJson}\n\`\`\``,
+                            nudge,
+                        ].filter(Boolean).join('\n\n')
                     }]
             };
         }
@@ -717,6 +779,17 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
             hctx.nexusRef.storeMemory(`Ghost pass for "${goal.slice(0, 80)}": ${report.riskAreas.length} risks identified.`, 0.6, ['#ghost-pass']);
             nexusEventBus.emit('ghost.pass', { task: goal, risks: report.riskAreas.length, workers: report.workerAssignments.length });
             const ghostNudge = hctx.telemetry.planningNudge('ghost_pass', { risks: report.riskAreas.length });
+            const workerTable = markdownTable(['Worker', 'Approach', 'Token Budget', 'Files'], report.workerAssignments.map((worker, index) => [
+                `Worker ${index + 1}`,
+                worker.approach,
+                worker.tokenBudget.toLocaleString(),
+                worker.files.map(file => path.basename(file.path)).slice(0, 4).join(', ') || 'n/a',
+            ]));
+            const riskTable = markdownTable(['Risk', 'Severity', 'Mitigation'], report.riskAreas.map((risk) => [
+                risk,
+                'review',
+                'Use the reading plan and isolate edits before mutation',
+            ]));
             // Console ASCII UI
             const rCount = report.riskAreas.length;
             hctx.box('👻 GHOST PASS PRE-FLIGHT', [
@@ -735,10 +808,9 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                 `Risks: ${report.riskAreas.length ? report.riskAreas.join(' | ') : 'none detected'}`,
                                 `Worker approaches: ${report.workerAssignments.length}`,
                             ]),
+                            riskTable ? `Risk table\n${riskTable}` : 'Risk table\nNo risks detected.',
+                            workerTable ? `Worker table\n${workerTable}` : '',
                             'Reading plan\n```txt\n' + formatReadingPlan(report.readingPlan) + '\n```',
-                            report.workerAssignments.length
-                                ? formatBullets(report.workerAssignments.map((worker, index) => `Worker ${index + 1}: ${worker.approach} · budget ${worker.tokenBudget.toLocaleString()} tokens`))
-                                : '',
                             ghostNudge,
                         ].filter(Boolean).join('\n\n'),
                     }],

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

@@ -120,6 +120,13 @@ export class SessionTelemetry {
             this.noteFileIntent(args.files);
             return;
         }
+        if (toolName === 'nexus_spawn_workers') {
+            if (this.lifecyclePhase === 'bootstrapped' || this.lifecyclePhase === 'orchestrated') {
+                this.advancePhase('working');
+            }
+            this.noteFileIntent(args.files);
+            return;
+        }
         if (toolName === 'nexus_store_memory') {
             if (this.isPostOrchestratePhase()) {
                 this.storeMemoryCalledPostOrchestrate = true;

package/dist/agents/adapters/mcp.js

@@ -136,6 +136,7 @@ const PRE_ORCHESTRATE_ALLOWED_TOOLS = new Set([
     'nexus_optimize_tokens',
     'nexus_mindkit_check',
     'nexus_ghost_pass',
+    'nexus_spawn_workers',
     'nexus_token_report',
     'nexus_session_dna',
     'nexus_run_status',
@@ -545,6 +546,7 @@ export class MCPAdapter {
                         code: 'orchestration-required',
                         reason: 'nexus_orchestrate has not been called for this session',
                         action: 'Call nexus_orchestrate(prompt="<your task>") before invoking mutation, worker, kernel, hook, automation, or low-level execution tools.',
+                        nextTool: 'nexus_orchestrate',
                         hint: 'Nexus Prime must own planning, token budgeting, memory recall, hooks, and review gates before work starts.',
                     }, null, 2),
                 }],

package/dist/cli/hook.js

@@ -209,8 +209,9 @@ export async function runHookMindkit() {
     if (!lock)
         return; // no daemon — skip rather than block
     const resp = await callDaemonTool(lock, 'nexus_mindkit_check', {
-        action: toolName,
-        files,
+        action: `${toolName}: ${files.join(', ')}`,
+        filesToModify: files,
+        isDestructive: ['Write', 'Edit', 'MultiEdit'].includes(toolName),
     }, 6_000);
     // Parse the tool result text to check for a block verdict
     const text = extractResultText(resp);

package/dist/cli.js

@@ -717,11 +717,11 @@ program
     .description('Start Nexus Prime daemon')
     .option('--force', 'Force restart if already running')
     .action(async (options) => {
-    const workspaceContext = resolveWorkspaceContext({ workspaceRoot: getWorkspaceRoot() });
     try {
         const record = await ensureDaemonManaged({ force: options.force });
+        const dashboardPort = process.env.NEXUS_DASHBOARD_PORT ?? '3377';
         console.log(`Nexus Prime daemon running (pid ${record.pid}, ${formatDaemonAddress(record)})`);
-        console.log(`Dashboard: http://localhost:3377`);
+        console.log(`Dashboard: http://localhost:${dashboardPort}`);
     }
     catch (err) {
         console.error(`Failed to start daemon: ${err.message}`);

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

@@ -274,6 +274,7 @@ function renderHero() {
         ?? lt?.totalSaved
         ?? lt?.lifetime?.saved
         ?? op?.tokenOptimization?.savedTokens
+        ?? op?.tokenOptimization?.estimatedSavings
         ?? t?.savedTokens
         ?? t?.saved
         ?? 0,
@@ -317,14 +318,18 @@ function getHireReadiness() {
     const synapseState = S.healthData?.runtimeEnvelope?.engines?.synapse ?? {};
     const memoryStorage = S.healthData?.memory?.storage ?? {};
     const rawReason = S.synapseHealthRaw?.reason;
+    const deferred = synapseState.deferred === true || /deferred\s*\(lazy mode\)/i.test(`${rawReason || ''} ${synapseState.reason || ''}`);
     const unavailable = Boolean(
-        S.synapseHealthRaw?.notReady
-        || synapseState.ready === false
-        || synapseState.available === false,
+        (S.synapseHealthRaw?.notReady && !deferred)
+        || (synapseState.ready === false && !deferred)
+        || (synapseState.available === false && !deferred),
     );
     if (unavailable) {
         notes.push({ tone: 'bad', text: rawReason || synapseState.reason || 'Synapse is not ready for hires in this dashboard session.' });
     }
+    if (deferred && !unavailable) {
+        notes.push({ tone: 'warn', text: 'Synapse is in lazy mode and will warm up on the first hire.' });
+    }
     if (synapseState.fallbackApplied) {
         notes.push({ tone: 'warn', text: synapseState.reason || 'Synapse is running in fallback storage mode.' });
     }
@@ -401,6 +406,7 @@ function renderFirstRunHero() {
                 specialistId: btn.dataset.specid,
                 name: btn.dataset.specname,
                 budgetCapUsd: 2,
+                fireFirstSortie: true,
             });
             if (result.ok) {
                 setFirstRunStatus(readiness.notes.some(note => note.tone === 'warn')

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

@@ -514,6 +514,7 @@ function _showHireSheet(specialistId, name) {
             budgetCapUsd: budget,
             reportsToOperativeId: reportsToVal,
             strikeTeamId: teamVal,
+            fireFirstSortie: true,
         }, { optimistic: optimisticRecord });
 
         // Immediately open drawer with pending state.
@@ -547,10 +548,10 @@ function _showHireSheet(specialistId, name) {
                 }
                 bustCache('/api/synapse/health');
                 setTimeout(load, 800);
-                // Fire warm-up dispatch so the new operative can introduce itself immediately
+                // The backend materializes this hire as a Workforce agent and
+                // starts the first sortie when fireFirstSortie is true.
                 const operativeId = real.data?.operative?.id || real.data?.operative?.operativeId;
                 if (operativeId) {
-                    // Insert dispatch-strip placeholder into the already-open drawer
                     const drawerBody = document.getElementById('drawer-body');
                     if (drawerBody) {
                         let stripDiv = drawerBody.querySelector('[data-dispatch-strip]');
@@ -563,22 +564,12 @@ function _showHireSheet(specialistId, name) {
                         _dispatches.set('__warmup__', warmupRun);
                         stripDiv.innerHTML = _buildDispatchStrip(warmupRun);
                     }
-                    fetch('/api/dispatch', {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({
-                            goal: 'Introduce yourself to the codebase. Read the README and 2 source files of your choice, store what you learn as memories.',
-                            operativeId,
-                            specialistId: specId,
-                            budgetCapUsd: 0.5,
-                        }),
-                    }).then(r => r.json()).then(dr => {
-                        _dispatches.delete('__warmup__');
-                        if (dr?.runId) {
-                            _dispatches.set(dr.runId, { runId: dr.runId, operativeId, status: 'queued', tokens: 0, costUsd: 0, messages: [], filesChanged: [] });
-                        }
-                        _refreshDrawerForOp(operativeId);
-                    }).catch(() => { _dispatches.delete('__warmup__'); _refreshDrawerForOp(operativeId); });
+                    const fd = real.data?.firstDispatch;
+                    _dispatches.delete('__warmup__');
+                    if (fd?.runId) {
+                        _dispatches.set(fd.runId, { runId: fd.runId, operativeId, status: 'queued', tokens: 0, costUsd: 0, messages: [], filesChanged: [] });
+                    }
+                    _refreshDrawerForOp(operativeId);
                 }
             } else {
                 if (msg) {
@@ -609,6 +600,15 @@ function _openOpDrawer(id, name) {
             ['Budget alloc',op.budget!=null?fmtNum(op.budget):'—'],
             ['Team',op.team||op.strikeName||'—']
         ])}</div>
+        <div class="dsec">
+            <div class="dsec-title">Agent control</div>
+            <textarea id="agent-control-input" rows="4" placeholder="Ask this agent to inspect, plan, or run a focused task"
+                style="width:100%;resize:vertical;background:var(--bg-panel);border:1px solid var(--border);border-radius:var(--radius);padding:8px 10px;color:var(--text-main);font:var(--text-sm) var(--font-sans);margin-bottom:var(--space-3)"></textarea>
+            <div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap">
+                <button class="btn btn-primary btn-sm" id="agent-control-send">Send to agent</button>
+                <span id="agent-control-status" style="font-size:var(--text-sm);color:var(--text-muted)"></span>
+            </div>
+        </div>
         <div data-dispatch-strip>${stripInner}</div>` });
     // Attach stop button handlers for any already-rendered strips
     const drawerBody = document.getElementById('drawer-body');
@@ -621,6 +621,44 @@ function _openOpDrawer(id, name) {
             });
         });
     }
+    const sendBtn = document.getElementById('agent-control-send');
+    const input = document.getElementById('agent-control-input');
+    const status = document.getElementById('agent-control-status');
+    sendBtn?.addEventListener('click', async () => {
+        const goal = input?.value?.trim();
+        if (!goal) {
+            if (status) status.textContent = 'Enter a task first.';
+            return;
+        }
+        sendBtn.disabled = true;
+        sendBtn.textContent = 'Sending…';
+        if (status) status.textContent = 'Dispatching to agent…';
+        const response = await fetch(`/api/workforce/agents/${encodeURIComponent(opId)}/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                goal,
+                message: goal,
+                specialistId: op.specialistId || op.role || undefined,
+                budgetCapUsd: op.budget || 2,
+            }),
+        }).then(r => r.json().then(data => ({ ok: r.ok, data }))).catch(error => ({ ok: false, data: { error: error?.message || String(error) } }));
+        if (response.ok) {
+            if (input) input.value = '';
+            const runId = response.data?.runId;
+            if (runId) _dispatches.set(runId, { runId, operativeId: opId, status: 'queued', tokens: 0, costUsd: 0, messages: [response.data?.message || 'Agent command queued.'], filesChanged: [] });
+            if (status) status.textContent = response.data?.mode === 'orchestrator-fallback'
+                ? 'Queued through Nexus orchestrator.'
+                : 'Queued to agent runtime.';
+            _refreshDrawerForOp(opId);
+            setTimeout(load, 800);
+        } else if (status) {
+            status.textContent = response.data?.hint || response.data?.error || 'Agent command failed.';
+            status.style.color = 'var(--bad)';
+        }
+        sendBtn.disabled = false;
+        sendBtn.textContent = 'Send to agent';
+    });
 }
 
 function _openMissionDrawer(id) {

package/dist/dashboard/routes/architects.js

@@ -27,7 +27,15 @@ export const handleArchitectsRoutes = async (ctx, req, res, url) => {
             return true;
         }
         const dispatch = architects.getDispatchStatus?.() ?? null;
-        ctx.respondJson(res, { dispatch, worklist: [], activeLocks: [] });
+        const preferred = ctx.getPreferredArchitectsWorklist(url, url.searchParams.get('worklistId'), url.searchParams.get('strikeTeamId'));
+        ctx.respondJson(res, {
+            dispatch,
+            worklist: Array.isArray(preferred?.items) ? preferred.items : [],
+            worklistId: preferred?.worklistId ?? preferred?.worklist?.id ?? null,
+            activeLocks: [],
+            idle: Boolean(preferred?.idle),
+            reason: preferred?.reason ?? '',
+        });
         return true;
     }
     /* ── POST /api/architects/wards/:wardId/resolve ──────────────────────── */

package/dist/dashboard/routes/governance.js

@@ -1,10 +1,12 @@
 import { nexusEventBus } from '../../engines/event-bus.js';
+import { getDefaultFederation } from '../../engines/federation.js';
 import { podNetwork } from '../../engines/pod-network.js';
 import { getSpecialist } from '../../engines/specialist-roster.js';
 import { estimateSpecialistSortieCost } from '../../engines/specialist-cost-estimator.js';
 import { scheduleFirstSortie } from '../../synapse/bootstrap.js';
 import { DarwinLoop } from '../../engines/darwin-loop.js';
 import { DarwinJournal } from '../../engines/darwin-journal.js';
+import { materializeWorkforceAgent, runDashboardAgentControl } from './workforce.js';
 import path from 'node:path';
 // Surface "Pillar 2 disconnected" with a tagged empty array. The marker keeps
 // existing `.map()`/`.length` iteration code working while letting the frontend
@@ -27,6 +29,22 @@ function notInitializedObject(pillar) {
         items: [],
     };
 }
+function getSynapseForMutation(ctx) {
+    let synapse = ctx.getSynapse();
+    if (synapse)
+        return synapse;
+    const reinit = ctx.getReinitSynapse?.();
+    if (reinit) {
+        try {
+            reinit();
+            synapse = ctx.getSynapse();
+        }
+        catch {
+            synapse = undefined;
+        }
+    }
+    return synapse;
+}
 export const handleGovernanceRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/api/synapse/teams') {
         const synapse = ctx.getSynapse();
@@ -44,13 +62,13 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
         return true;
     }
     if (req.method === 'POST' && url.pathname === '/api/synapse/hire') {
-        const synapse = ctx.getSynapse();
+        const synapse = getSynapseForMutation(ctx);
         if (!synapse) {
             const initErr = ctx.getSynapseInitError();
             ctx.respondJson(res, {
                 error: initErr?.message ?? 'synapse-unavailable',
                 code: 'synapse-init-failed',
-                hint: 'Check stderr for `synapse-init-failed reason=...`. Common causes: better-sqlite3 native binding mismatch, corrupt state dir, missing coordination bridge.',
+                hint: 'Synapse could not warm for this hire request. Run `nexus-prime doctor`, then retry from the dashboard.',
                 at: initErr?.at ?? null,
             }, 503);
             return true;
@@ -87,30 +105,54 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
             const pricing = specialistProfile ? estimateSpecialistSortieCost(specialistProfile) : null;
             const operativeId = result?.id ?? result?.operativeId ?? null;
             const baseUrl = ctx.getAddress() ?? 'http://localhost:3377';
+            const workforceAgent = operativeId ? materializeWorkforceAgent(ctx, {
+                operativeId,
+                name: result?.name ?? name ?? specialistProfile?.name ?? specialistId ?? 'Dashboard agent',
+                role: result?.roleTitle ?? specialistProfile?.name ?? null,
+                specialistId: result?.specialistId ?? specialistId ?? null,
+                budgetCapUsd: result?.budgetCapUsd ?? body.budgetCapUsd ?? null,
+            }) : null;
+            let firstDispatch = null;
             // Optionally fire a warm-up first sortie (body.fireFirstSortie === true).
-            // 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({
-                    operative: result,
-                    repoRoot,
-                    repoName: path.basename(repoRoot),
+            // Non-blocking: the dashboard gets an immediate hire response while the
+            // Workforce job and run lifecycle continue through SSE and kanban state.
+            if (body.fireFirstSortie === true && operativeId) {
+                firstDispatch = { queued: true, operativeId, mode: 'pending' };
+                runDashboardAgentControl(ctx, new URL(`${baseUrl}/api/workforce/agents/${encodeURIComponent(operativeId)}/dispatch`), {
+                    operativeId,
+                    specialistId: result?.specialistId ?? specialistId ?? null,
                     budgetCapUsd: result?.budgetCapUsd ?? 0.50,
+                    title: `First sortie: ${result?.name ?? specialistProfile?.name ?? operativeId}`,
+                    goal: 'Introduce yourself to the codebase. Read the README and two source files, then report the repo shape and next useful task.',
                 }).then(r => {
-                    if (r?.runId) {
-                        nexusEventBus.emit('dashboard.action', {
-                            action: 'synapse.first-sortie.dispatched',
-                            status: 'ok',
-                            target: r.runId,
-                        });
+                    nexusEventBus.emit('dashboard.action', {
+                        action: 'synapse.first-sortie.dispatched',
+                        status: 'ok',
+                        target: r.runId ?? r.job?.id ?? operativeId,
+                    });
+                }).catch((error) => {
+                    nexusEventBus.emit('dashboard.action', {
+                        action: 'synapse.first-sortie.failed',
+                        status: 'fail',
+                        target: error?.message ?? String(error),
+                    });
+                    if (result?.specialistId) {
+                        const repoRoot = ctx.repoRoot ?? process.cwd();
+                        scheduleFirstSortie({
+                            operative: result,
+                            repoRoot,
+                            repoName: path.basename(repoRoot),
+                            budgetCapUsd: result?.budgetCapUsd ?? 0.50,
+                        }).catch(() => { });
                     }
-                }).catch(() => { });
+                });
             }
             ctx.respondJson(res, {
                 operative: result,
+                agent: workforceAgent,
                 pricing,
                 firstSortieEstimate: pricing,
+                firstDispatch,
                 dashboardUrl: operativeId ? `${baseUrl}/#workforce/${operativeId}` : `${baseUrl}/#workforce`,
             }, 201);
         }
@@ -124,7 +166,7 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
         // getSynapse() triggers ensureSynapseInit(); getArchitects() triggers ensureArchitectsInit()
         // + reconnectSynapseCoordination() so worklistId is non-null in the pipeline.
         ctx.getArchitects();
-        const synapse = ctx.getSynapse();
+        const synapse = getSynapseForMutation(ctx);
         if (!synapse) {
             const initErr = ctx.getSynapseInitError();
             ctx.respondJson(res, {
@@ -234,7 +276,15 @@ export const handleGovernanceRoutes = async (ctx, req, res, url) => {
         return true;
     }
     if (req.method === 'GET' && url.pathname === '/api/federation') {
-        ctx.respondJson(res, ctx.getRuntime()?.getNetworkStatus?.() ?? {});
+        const runtimeStatus = ctx.getRuntime()?.getNetworkStatus?.();
+        const snapshot = runtimeStatus && Object.keys(runtimeStatus).length > 0
+            ? runtimeStatus
+            : getDefaultFederation().getSnapshot();
+        ctx.respondJson(res, {
+            relayMode: snapshot?.relay?.connected ? 'active' : 'local-only',
+            peers: snapshot?.knownPeers ?? [],
+            ...snapshot,
+        });
         return true;
     }
     if (req.method === 'POST' && url.pathname === '/api/synapse/reinit') {

package/dist/dashboard/routes/runtime.js

@@ -28,6 +28,26 @@ function normalizeLifetimeTokenPayload(record) {
         },
     };
 }
+function normalizeTokenSummaryPayload(record) {
+    const savedTokens = Number(record?.savedTokens ?? record?.totalSavedTokens ?? record?.saved ?? 0);
+    const grossInputTokens = Number(record?.grossInputTokens ?? record?.totalGrossInputTokens ?? record?.gross ?? 0);
+    const compressedTokens = Number(record?.compressedTokens ?? record?.totalCompressedTokens ?? record?.net ?? 0);
+    const forwardedTokens = Number(record?.forwardedTokens ?? record?.tokensForwarded ?? compressedTokens);
+    const compressionPct = Number.isFinite(Number(record?.compressionPct))
+        ? Number(record.compressionPct)
+        : (grossInputTokens > 0 ? Math.round((savedTokens / grossInputTokens) * 100) : 0);
+    return {
+        ...record,
+        savedTokens,
+        grossInputTokens,
+        compressedTokens,
+        forwardedTokens,
+        compressionPct,
+        saved: savedTokens,
+        gross: grossInputTokens,
+        net: compressedTokens,
+    };
+}
 async function readGitBranch(repoRoot) {
     try {
         const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', {
@@ -97,7 +117,7 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/api/tokens/summary') {
         await ctx.respondCachedJson(res, `tokens-summary:${url.search}`, 2_000, async () => {
             const snapshot = ctx.resolveRuntimeSnapshot(url);
-            return snapshot?.tokens ?? ctx.getRuntime()?.getTokenTelemetrySummary?.() ?? {};
+            return normalizeTokenSummaryPayload(snapshot?.tokens ?? ctx.getRuntime()?.getTokenTelemetrySummary?.() ?? {});
         });
         return true;
     }
@@ -298,7 +318,21 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
         // TTV: first goal submission from the dashboard counts as first interaction.
         void recordFirstInteraction().catch(() => { });
         // Fire-and-forget: orchestration runs in the background; caller polls /api/runs/:id.
-        orchestrator.orchestrate(goal, { source: 'dashboard' }).catch(() => { });
+        orchestrator.orchestrate(goal, { source: 'dashboard' })
+            .then((run) => {
+            nexusEventBus.emit('dashboard.action', {
+                action: 'orchestrate.complete',
+                status: run?.state === 'failed' ? 'fail' : 'ok',
+                target: run?.runId ?? runId,
+            });
+        })
+            .catch((err) => {
+            nexusEventBus.emit('dashboard.action', {
+                action: 'orchestrate.failed',
+                status: 'fail',
+                target: err instanceof Error ? err.message : String(err),
+            });
+        });
         nexusEventBus.emit('dashboard.action', { action: 'orchestrate.enqueue', status: 'queued', target: runId });
         ctx.respondJson(res, { queued: true, runId }, 202);
         return true;

package/dist/dashboard/routes/workforce.d.ts

@@ -5,5 +5,38 @@
  * GET /api/workforce/workers   — worker list
  * GET /api/workforce/jobs      — job list with optional ?status= and ?client= filters
  */
-import type { DashboardRouteHandler } from '../types.js';
+import type { DashboardRouteContext, DashboardRouteHandler } from '../types.js';
+export declare function materializeWorkforceAgent(ctx: DashboardRouteContext, input: {
+    operativeId: string;
+    name?: string | null;
+    role?: string | null;
+    specialistId?: string | null;
+    budgetCapUsd?: number | null;
+}): import("../../workforce/types.js").Worker;
+export declare function runDashboardAgentControl(ctx: DashboardRouteContext, url: URL, input: {
+    operativeId: string;
+    goal: string;
+    specialistId?: string | null;
+    budgetCapUsd?: number | null;
+    preferredRuntime?: string | null;
+    title?: string | null;
+}): Promise<{
+    ok: boolean;
+    mode: string;
+    worker: import("../../workforce/types.js").Worker;
+    job: import("../../workforce/types.js").Job;
+    runId: string;
+    invoker: string;
+    state?: undefined;
+    message?: undefined;
+} | {
+    ok: boolean;
+    mode: string;
+    worker: import("../../workforce/types.js").Worker;
+    job: import("../../workforce/types.js").Job;
+    runId: string;
+    state: import("../../phantom/runtime.js").ExecutionState;
+    message: string;
+    invoker?: undefined;
+}>;
 export declare const handleWorkforceRoutes: DashboardRouteHandler;

package/dist/dashboard/routes/workforce.js

@@ -7,12 +7,151 @@
  */
 import { getWorkforce } from '../../workforce/index.js';
 import { getSpans, listRecentRuns } from '../../engines/orchestrator/store.js';
+import { pushDispatch } from '../../engines/dispatch/push-dispatch.js';
+import { nexusEventBus } from '../../engines/event-bus.js';
+import { resolveWorkspaceContext } from '../../engines/workspace-resolver.js';
+import path from 'path';
 const VALID_WORKER_STATUSES = new Set(['idle', 'active', 'stale', 'retired']);
 const VALID_JOB_STATUSES = new Set(['backlog', 'ready', 'claimed', 'wip', 'blocked', 'review', 'done', 'failed', 'cancelled']);
 function safeLimit(raw, def) {
     const n = Number(raw);
     return Number.isFinite(n) && n > 0 ? Math.floor(n) : def;
 }
+function trimString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function getRepoIdentity(ctx, url) {
+    const selected = url ? ctx.getSelectedRepoIdentity(url) : null;
+    const repoRoot = trimString(selected?.repoRoot) ?? ctx.repoRoot ?? process.cwd();
+    try {
+        const workspace = resolveWorkspaceContext({ workspaceRoot: repoRoot });
+        return {
+            repoRoot: workspace.repoRoot,
+            repoName: trimString(selected?.repoName) ?? workspace.repoName ?? path.basename(workspace.repoRoot),
+        };
+    }
+    catch {
+        return { repoRoot, repoName: trimString(selected?.repoName) ?? (path.basename(repoRoot) || 'workspace') };
+    }
+}
+function getOperativeName(ctx, operativeId) {
+    const operatives = ctx.getSynapse()?.getOperativeHealth?.() ?? [];
+    const found = Array.isArray(operatives)
+        ? operatives.find((op) => op?.id === operativeId || op?.operativeId === operativeId)
+        : null;
+    return trimString(found?.name) ?? trimString(found?.roleTitle) ?? trimString(found?.role) ?? `Agent ${operativeId.slice(0, 8)}`;
+}
+export function materializeWorkforceAgent(ctx, input) {
+    const wf = getWorkforce(ctx.repoRoot ?? process.cwd());
+    const worker = wf.registerWorker({
+        id: input.operativeId,
+        name: input.name ?? getOperativeName(ctx, input.operativeId),
+        role: input.role ?? input.specialistId ?? 'synapse-operative',
+        client: 'synapse',
+        budgetCapUsd: Number(input.budgetCapUsd ?? 2),
+    });
+    nexusEventBus.emit('dashboard.action', {
+        action: 'workforce.agent.materialized',
+        status: 'ok',
+        target: worker.id,
+    });
+    return worker;
+}
+export async function runDashboardAgentControl(ctx, url, input) {
+    const operativeId = input.operativeId;
+    const goal = input.goal.trim();
+    const wf = getWorkforce(ctx.repoRoot ?? process.cwd());
+    const worker = wf.getWorker(operativeId) ?? materializeWorkforceAgent(ctx, {
+        operativeId,
+        specialistId: input.specialistId ?? null,
+        budgetCapUsd: input.budgetCapUsd ?? 2,
+    });
+    const job = wf.enqueueJob({
+        title: input.title ?? (goal.slice(0, 80) || 'Agent command'),
+        tier: 'tactical',
+        client: 'dashboard-agent',
+        priority: 8,
+        budgetCapUsd: input.budgetCapUsd ?? 2,
+        payload: {
+            goal,
+            operativeId,
+            specialistId: input.specialistId ?? worker.role,
+            source: 'dashboard-agent-control',
+        },
+    });
+    const claim = wf.claimJob(job.id, worker.id, 15 * 60_000);
+    if (claim)
+        wf.advanceToWip(job.id, worker.id);
+    const { repoRoot, repoName } = getRepoIdentity(ctx, url);
+    const orchestrator = ctx.getOrchestrator();
+    const memory = ctx.getMemory();
+    const memories = await memory?.recall?.(goal, 6).then((items) => (items.map((content, index) => ({ id: `recall-${index + 1}`, content, tier: 'recall', priority: 0.6 })))).catch(() => []) ?? [];
+    const files = await orchestrator?.listTopologyFiles?.(20).catch(() => []) ?? [];
+    const graphLines = files.slice(0, 12).map((file) => path.relative(repoRoot, file) || file);
+    const crGraphContext = graphLines.length
+        ? `Repo graph shortlist for this command:\n${graphLines.map((file) => `- ${file}`).join('\n')}`
+        : null;
+    try {
+        const dispatch = await pushDispatch({
+            goal,
+            specialistId: input.specialistId ?? worker.role ?? 'engineering.rapid-prototyper',
+            operativeId,
+            budgetCapUsd: Number(input.budgetCapUsd ?? worker.budgetCapUsd ?? 2),
+            workingDir: repoRoot,
+            repoName,
+            preferredRuntime: input.preferredRuntime ?? undefined,
+            memories,
+            files,
+            crGraphContext,
+            storeMemory: async (content, priority, tags) => { memory?.store?.(content, priority, tags); },
+        });
+        const cleanup = [
+            nexusEventBus.on('dispatch.complete', (payload) => {
+                if (payload.runId !== dispatch.runId)
+                    return;
+                wf.recordTokens(job.id, worker.id, Number(payload.tokensUsed ?? 0));
+                if (payload.success === false)
+                    wf.failJob(job.id, worker.id);
+                else
+                    wf.completeJob(job.id, worker.id);
+                cleanup.forEach((unsubscribe) => unsubscribe());
+            }),
+            nexusEventBus.on('dispatch.failed', (payload) => {
+                if (payload.runId !== dispatch.runId)
+                    return;
+                wf.failJob(job.id, worker.id);
+                cleanup.forEach((unsubscribe) => unsubscribe());
+            }),
+        ];
+        return { ok: true, mode: 'dispatch', worker, job: wf.getJob(job.id) ?? job, runId: dispatch.runId, invoker: dispatch.invoker };
+    }
+    catch (dispatchError) {
+        if (!orchestrator) {
+            wf.failJob(job.id, worker.id);
+            throw dispatchError;
+        }
+        const run = await orchestrator.orchestrate(goal, {
+            source: 'dashboard-agent-control',
+            workers: 1,
+            files,
+            specialistId: input.specialistId ?? worker.role,
+            operativeId,
+        });
+        if (run.state === 'failed')
+            wf.failJob(job.id, worker.id);
+        else
+            wf.completeJob(job.id, worker.id);
+        return {
+            ok: true,
+            mode: 'orchestrator-fallback',
+            worker,
+            job: wf.getJob(job.id) ?? job,
+            runId: run.runId,
+            state: run.state,
+            message: dispatchError?.message ? `Push dispatch unavailable; ran through Nexus orchestrator instead. ${dispatchError.message}` : 'Ran through Nexus orchestrator.',
+        };
+    }
+}
 export const handleWorkforceRoutes = async (ctx, req, res, url) => {
     if (!url.pathname.startsWith('/api/workforce/'))
         return false;
@@ -48,6 +187,38 @@ export const handleWorkforceRoutes = async (ctx, req, res, url) => {
         ctx.respondJson(res, { jobs });
         return true;
     }
+    const agentControlMatch = req.method === 'POST'
+        ? /^\/api\/workforce\/agents\/([^/]+)\/(?:chat|dispatch)$/.exec(url.pathname)
+        : null;
+    if (agentControlMatch) {
+        const operativeId = decodeURIComponent(agentControlMatch[1]);
+        const body = await ctx.readJsonBody(req);
+        const goal = trimString(body.goal) ?? trimString(body.message) ?? trimString(body.prompt);
+        if (!goal) {
+            ctx.respondJson(res, { error: 'goal-required' }, 400);
+            return true;
+        }
+        try {
+            const result = await runDashboardAgentControl(ctx, url, {
+                operativeId,
+                goal,
+                specialistId: trimString(body.specialistId),
+                budgetCapUsd: typeof body.budgetCapUsd === 'number' ? body.budgetCapUsd : undefined,
+                preferredRuntime: trimString(body.preferredRuntime),
+                title: trimString(body.title),
+            });
+            ctx.respondJson(res, result, 202);
+        }
+        catch (error) {
+            ctx.respondJson(res, {
+                ok: false,
+                error: error?.message ?? String(error),
+                code: 'agent-control-failed',
+                hint: 'No headless runtime or local orchestrator could accept this agent command.',
+            }, 503);
+        }
+        return true;
+    }
     if (url.pathname === '/api/workforce/runs') {
         const limit = safeLimit(url.searchParams.get('limit'), 20);
         try {

package/dist/dashboard/server.js

@@ -974,13 +974,22 @@ export class DashboardServer {
         const tokens = snapshot?.tokens ?? this.getRuntime()?.getTokenTelemetrySummary?.() ?? {};
         const budget = usage?.sourceAwareTokenBudget ?? {};
         const autoApplied = Boolean(usage?.tokenAutoApplied);
+        const savedTokens = Number(tokens?.savedTokens ?? tokens?.totalSavedTokens ?? tokens?.saved ?? 0);
+        const forwardedTokens = Number(tokens?.forwardedTokens ?? tokens?.tokensForwarded ?? tokens?.compressedTokens ?? 0);
+        const grossInputTokens = Number(tokens?.grossInputTokens ?? tokens?.totalGrossInputTokens ?? tokens?.gross ?? 0);
+        const compressionPct = Number.isFinite(Number(tokens?.compressionPct))
+            ? Number(tokens.compressionPct)
+            : (grossInputTokens > 0 ? Math.round((savedTokens / grossInputTokens) * 100) : 0);
         return {
             applied: Boolean(usage?.tokenOptimizationApplied || budget?.applied || autoApplied),
             autoApplied,
-            savedTokens: Number(tokens?.savedTokens || 0),
-            forwardedTokens: Number(tokens?.forwardedTokens || 0),
-            grossInputTokens: Number(tokens?.grossInputTokens || 0),
-            compressionPct: Number(tokens?.compressionPct || 0),
+            savedTokens,
+            forwardedTokens,
+            grossInputTokens,
+            compressionPct,
+            estimatedSavings: Number(budget?.estimatedSavings ?? savedTokens ?? 0),
+            candidateFiles: Array.isArray(budget?.candidateFiles) ? budget.candidateFiles : [],
+            selectedFiles: Array.isArray(budget?.selectedFiles) ? budget.selectedFiles : [],
             reason: budget?.reason || 'Token optimization has not reported a source-aware budget yet.',
             dominantSource: budget?.dominantSource || null,
             dropped: Array.isArray(budget?.dropped) ? budget.dropped : [],

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

@@ -828,6 +828,8 @@ export interface NexusEventPayloads {
     'orchestrator.run.complete': {
         goal: string;
         sessionId?: string;
+        runId?: string;
+        state?: string;
         durationMs?: number;
     };
 }

package/dist/engines/orchestrator.js

@@ -995,6 +995,7 @@ export class OrchestratorEngine {
         this.memoryBackgroundWorker?.start();
     }
     async orchestrate(task, options = {}) {
+        const orchestrateStartedAt = Date.now();
         this.checkCircuit();
         try {
             nexusEventBus.emit('orchestrator.run.start', {
@@ -1425,6 +1426,16 @@ export class OrchestratorEngine {
             executionLedger: ledger,
             knowledgeFabric,
         });
+        try {
+            nexusEventBus.emit('orchestrator.run.complete', {
+                goal: task.slice(0, 200),
+                sessionId: this.sessionState.sessionId,
+                runId: run.runId,
+                state: run.state,
+                durationMs: Date.now() - orchestrateStartedAt,
+            });
+        }
+        catch { /* non-fatal */ }
         return run;
     }
     /**

package/dist/index.js

@@ -890,6 +890,7 @@ export class NexusPrime {
             });
             if (this.synapse) {
                 this.synapseHealth = this.synapse.getStatus();
+                this.synapseInitError = null;
                 console.error('[NexusPrime] Synapse lazy-initialized successfully.');
             }
         }

package/dist/utils/ascii-art.js

@@ -52,6 +52,8 @@ export const ASCII_ART = {
   ║  🔄 Orchestration engines live                             ║
   ║  📡 MCP control plane active                               ║
   ║  ⚙️  Worker swarm standing by                              ║
+  ║  Dashboard: http://localhost:3377                          ║
+  ║  Open later: nexus-prime start                              ║
   ║                                                            ║
   ║  Build: ${buildDate.slice(0, 19).padEnd(47, ' ')}║
   ║  Node : ${nodeVersion.padEnd(47, ' ')}║

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.17",
+  "version": "7.9.18",
   "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",
@@ -49,7 +49,7 @@
     "test:public": "tsx test/public-surface.test.ts",
     "test:synapse": "tsx src/synapse/__tests__/run.ts",
     "test:architects": "tsx src/architects/__tests__/run.ts",
-    "test": "npm run build && tsx test/basic.test.ts && tsx test/memory.test.ts && tsx test/memory-regressions.test.ts && tsx test/memory-bridge.test.ts && tsx test/automation-runtime.test.ts && tsx test/session-dna-search.test.ts && tsx test/channel-gateway.test.ts && tsx test/semantic-ranking.test.ts && tsx test/storage-maintenance.test.ts && tsx test/ngram-index.test.ts && tsx test/security-shield.test.ts && tsx test/compaction-sentinel.test.ts && tsx test/context-compressor.test.ts && tsx test/embedder.test.ts && tsx test/skill-learner.test.ts && tsx test/skill-distribution.test.ts && tsx test/darwin-integration.test.ts && tsx test/github-bridge.test.ts && tsx test/telemetry-remote.test.ts && tsx test/orchestrator-engine.test.ts && tsx test/phase9.test.ts && tsx test/work-ledger.test.ts && tsx src/verify-token-scoring.ts && tsx test/phantom.test.ts && tsx test/rag-collections.test.ts && tsx test/dashboard.test.ts && tsx test/docs.test.ts && tsx test/competitive-landscape.test.ts && tsx test/runtime-upgrade-path.test.ts && tsx test/runtime-setup.test.ts && tsx test/control-plane-integration.test.ts && tsx test/runtime-timeout.test.ts && tsx test/mcp-dashboard-contract.test.ts && tsx test/dashboard-surfaces.test.ts && tsx test/startup-and-runtime-regressions.test.ts && tsx test/mcp-readiness-truth.test.ts && tsx test/mcp-stdio-session.test.ts && tsx test/kernel-context.test.ts && tsx test/kernel-execution.test.ts && tsx test/kernel-runtime.test.ts && tsx test/adapter-boundary.test.ts && tsx test/mcp-deprecation.test.ts && tsx test/dashboard-mutations.test.ts && tsx test/hooks-adapter.test.ts && tsx test/admin-adapter.test.ts && tsx test/pkg-subexport.test.ts && tsx test/dashboard-sse-only.test.ts && tsx test/license-sync-offline.test.ts && tsx test/mcp-killlist-v2.test.ts && tsx test/uninstall.test.ts && tsx test/uninstall-lifecycle.test.ts && tsx test/install-arch-upgrade.test.ts && tsx test/unregister-configs.test.ts && tsx test/cleanup-storage.test.ts && tsx test/dashboard-memory-truthfulness.test.ts && tsx test/runtime-lifecycle.test.ts && tsx test/orchestrate-pipeline.test.ts && tsx test/daemon-supervisor.test.ts && tsx test/auto-optimize-tokens.test.ts && npm run test:synapse && npm run test:architects && npm run test:public",
+    "test": "npm run build && tsx test/basic.test.ts && tsx test/memory.test.ts && tsx test/memory-regressions.test.ts && tsx test/memory-bridge.test.ts && tsx test/automation-runtime.test.ts && tsx test/session-dna-search.test.ts && tsx test/channel-gateway.test.ts && tsx test/semantic-ranking.test.ts && tsx test/storage-maintenance.test.ts && tsx test/ngram-index.test.ts && tsx test/security-shield.test.ts && tsx test/compaction-sentinel.test.ts && tsx test/context-compressor.test.ts && tsx test/embedder.test.ts && tsx test/skill-learner.test.ts && tsx test/skill-distribution.test.ts && tsx test/darwin-integration.test.ts && tsx test/github-bridge.test.ts && tsx test/telemetry-remote.test.ts && tsx test/orchestrator-engine.test.ts && tsx test/phase9.test.ts && tsx test/work-ledger.test.ts && tsx src/verify-token-scoring.ts && tsx test/phantom.test.ts && tsx test/rag-collections.test.ts && tsx test/dashboard.test.ts && tsx test/docs.test.ts && tsx test/competitive-landscape.test.ts && tsx test/runtime-upgrade-path.test.ts && tsx test/runtime-setup.test.ts && tsx test/control-plane-integration.test.ts && tsx test/runtime-timeout.test.ts && tsx test/mcp-dashboard-contract.test.ts && tsx test/dashboard-surfaces.test.ts && tsx test/startup-and-runtime-regressions.test.ts && tsx test/mcp-readiness-truth.test.ts && tsx test/mcp-stdio-session.test.ts && tsx test/kernel-context.test.ts && tsx test/kernel-execution.test.ts && tsx test/kernel-runtime.test.ts && tsx test/adapter-boundary.test.ts && tsx test/mcp-deprecation.test.ts && tsx test/dashboard-mutations.test.ts && tsx test/dashboard-agent-control.test.ts && tsx test/hooks-adapter.test.ts && tsx test/admin-adapter.test.ts && tsx test/pkg-subexport.test.ts && tsx test/dashboard-sse-only.test.ts && tsx test/license-sync-offline.test.ts && tsx test/mcp-killlist-v2.test.ts && tsx test/uninstall.test.ts && tsx test/uninstall-lifecycle.test.ts && tsx test/install-arch-upgrade.test.ts && tsx test/unregister-configs.test.ts && tsx test/cleanup-storage.test.ts && tsx test/dashboard-memory-truthfulness.test.ts && tsx test/runtime-lifecycle.test.ts && tsx test/orchestrate-pipeline.test.ts && tsx test/daemon-supervisor.test.ts && tsx test/auto-optimize-tokens.test.ts && npm run test:synapse && npm run test:architects && npm run test:public",
     "lint": "eslint src --ext .ts",
     "audit:prod": "npm audit --omit=dev",
     "smoke:release": "tsx scripts/release-smoke.ts",