nexus-prime 7.9.18 → 7.9.20

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

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

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

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

package/dist/cli/doctor-storage.js

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

package/dist/cli.js

@@ -30,7 +30,7 @@ import { cliSetup, configureIDE, computeFileHash, readSetupMarker, writeSetupMar
 import { isNewUser, promptLicenseKey, printReturningUserBanner } from './cli/interactive-setup.js';
 import { runHookBootstrap, runHookMemory, runHookMindkit, runHookGhostPass, runHookSessionDna } from './cli/hook.js';
 import { resolveWorkspaceContext } from './engines/workspace-resolver.js';
-import { ensureDaemonReady, getDaemonStatus, stopDaemon } from './daemon/client.js';
+import { ensureDaemonReady, getDaemonStatus, pingDaemonHealth, stopDaemon } from './daemon/client.js';
 import { NexusDaemonServer } from './daemon/server.js';
 import { DaemonSupervisor } from './daemon/supervisor.js';
 import { startDaemonBackedMcpProxy } from './daemon/proxy.js';
@@ -720,8 +720,10 @@ program
     try {
         const record = await ensureDaemonManaged({ force: options.force });
         const dashboardPort = process.env.NEXUS_DASHBOARD_PORT ?? '3377';
+        const health = await pingDaemonHealth(record).catch(() => null);
+        const dashboardUrl = health?.dashboardUrl ?? `http://localhost:${dashboardPort}`;
         console.log(`Nexus Prime daemon running (pid ${record.pid}, ${formatDaemonAddress(record)})`);
-        console.log(`Dashboard: http://localhost:${dashboardPort}`);
+        console.log(`Dashboard: ${dashboardUrl}`);
     }
     catch (err) {
         console.error(`Failed to start daemon: ${err.message}`);
@@ -820,15 +822,14 @@ program
     if (process.env.NEXUS_DAEMON_FAST_START === undefined) {
         process.env.NEXUS_DAEMON_FAST_START = '1';
     }
-    // Default the daemon to "workforce-disabled" mode: Synapse + Architects
-    // engines stay in the source tree (tests still run, code is preserved)
-    // but they don't open their SQLite DBs, run schema migrations, or
-    // surface their 24 MCP tools to clients. Saves ~700ms boot, shrinks
-    // the model-visible tool catalog, and removes the empty Workforce
-    // surface from the dashboard. Re-enable with NEXUS_DISABLE_WORKFORCE=0
-    // for users who actually hire operatives + dispatch missions.
-    if (process.env.NEXUS_DISABLE_WORKFORCE === undefined) {
-        process.env.NEXUS_DISABLE_WORKFORCE = '1';
+    // Keep daemon startup fast, but do not disable workforce. Synapse and
+    // Architects can lazily warm on first hire/tool call unless the operator
+    // explicitly sets the NEXUS_DISABLE_WORKFORCE escape hatch.
+    if (process.env.NEXUS_SYNAPSE_LAZY === undefined) {
+        process.env.NEXUS_SYNAPSE_LAZY = '1';
+    }
+    if (process.env.NEXUS_ARCHITECTS_LAZY === undefined) {
+        process.env.NEXUS_ARCHITECTS_LAZY = '1';
     }
     const workspaceContext = resolveWorkspaceContext({ workspaceRoot: getWorkspaceRoot() });
     const daemon = new NexusDaemonServer(workspaceContext);

package/dist/daemon/client.d.ts

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

package/dist/daemon/server.js

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

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

@@ -395,6 +395,12 @@
     color: var(--text-main); margin-bottom: 4px;
 }
 .frh-sub { font-size: var(--text-sm); color: var(--text-dim); }
+.frh-command {
+    display: grid;
+    grid-template-columns: minmax(220px, 1fr) auto auto;
+    gap: 8px;
+    margin-bottom: 14px;
+}
 .frh-picks { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
 .frh-pick {
     background: var(--bg-panel); border: 1px solid var(--border); border-radius: var(--radius);
@@ -417,6 +423,8 @@
 }
 @media (max-width: 768px) {
     #kanban-board { grid-template-columns: repeat(2, 1fr); }
+    .frh-command,
+    .frh-picks { grid-template-columns: 1fr; }
 }
 @media (max-width: 480px) {
     #kanban-board { grid-template-columns: 1fr; }

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

@@ -76,12 +76,14 @@ function normalizeOperative(op) {
 
 /* ── Data loader ── */
 export async function load() {
-    const [tok, life, op, sh, health] = await Promise.all([
+    const [tok, life, op, sh, health, memHealth, runs] = await Promise.all([
         api('/api/tokens/summary'),
         api('/api/tokens/lifetime', 15000),
         api('/api/dashboard/surface/operate', 5000),
         api('/api/synapse/health', 5000),
         api('/api/health', 15000),
+        api('/api/memory/health', 15000),
+        api('/api/runs?limit=12', 3000),
     ]);
     // Non-blocking: tool health data from ring buffer
     loadToolHealth();
@@ -91,6 +93,8 @@ export async function load() {
     S.synapseHealthRaw = sh;
     S.synapseHealth  = (Array.isArray(sh) ? sh : (sh?.operatives||[])).map(normalizeOperative);
     S.healthData     = health;
+    S.memHealth      = memHealth;
+    S.runs           = Array.isArray(runs) ? runs : [];
     notifyNotReady([sh]);
     // Prefetch curated specialists for first-run hero (non-blocking)
     if (!S.synapseHealth.length && !S.curatedSpecialists) {
@@ -354,13 +358,14 @@ function renderFirstRunHero() {
     if (!parent) return;
 
     const hasOps = S.synapseHealth.length > 0;
+    const hasRuns = (S.runs || []).length > 0;
     const alreadySeen = (() => { try { return !!localStorage.getItem(FIRST_RUN_KEY); } catch { return false; } })();
 
     // Remove any existing hero card
     const existing = $('first-run-hero');
     if (existing) existing.remove();
 
-    if (hasOps || alreadySeen) return;
+    if (hasOps || (alreadySeen && hasRuns)) return;
 
     const specs = (S.curatedSpecialists || []).slice(0, 3);
     if (!specs.length) return; // Still loading — will re-render when prefetch resolves
@@ -376,10 +381,15 @@ function renderFirstRunHero() {
     card.className = 'first-run-hero card';
     card.innerHTML = `
         <div class="frh-header">
-            <div class="frh-title">Your next hire</div>
-            <div class="frh-sub">Hire a specialist to start running tasks autonomously.</div>
+            <div class="frh-title">${hasRuns ? 'Your next hire' : 'Start the first real run'}</div>
+            <div class="frh-sub">${hasRuns ? 'Hire a specialist to start running tasks autonomously.' : 'Run a goal from the dashboard or hire a specialist. The run will appear in Board and Context Log.'}</div>
         </div>
         ${noticesHtml}
+        <div class="frh-command">
+            <input id="frh-goal-input" class="form-input" type="text" placeholder="Inspect this repo and suggest the next fix" autocomplete="off">
+            <button class="btn btn-primary btn-sm" id="frh-run-btn">Run goal</button>
+            <button class="btn btn-sm" id="frh-context-btn">Open context</button>
+        </div>
         <div class="frh-picks">
             ${specs.map(s => `
             <div class="frh-pick" data-specid="${esc(s.specialistId)}" data-specname="${esc(s.name)}">
@@ -393,6 +403,33 @@ function renderFirstRunHero() {
         <button class="btn btn-ghost btn-sm frh-dismiss" style="margin-top:var(--space-3)">Dismiss</button>`;
 
     // Wire buttons before inserting
+    card.querySelector('#frh-run-btn')?.addEventListener('click', async () => {
+        const input = card.querySelector('#frh-goal-input');
+        const button = card.querySelector('#frh-run-btn');
+        const goal = (input?.value || `Inspect ${S.workspace?.repoName || 'this repo'} and report the next best action`).trim();
+        if (!goal) return;
+        if (button) {
+            button.disabled = true;
+            button.textContent = 'Queueing…';
+        }
+        setFirstRunStatus('Queueing dashboard run…');
+        const result = await post('/api/orchestrate', { goal, source: 'dashboard-onboarding' });
+        if (result.ok) {
+            setFirstRunStatus('Run queued. Board and Context Log will update as Nexus writes artifacts.');
+            bustCache('/api/runs?limit=12');
+            bustCache('/api/events');
+            setTimeout(load, 900);
+        } else {
+            setFirstRunStatus(result.error || 'Run failed to queue.', 'bad');
+            if (button) {
+                button.disabled = false;
+                button.textContent = 'Run goal';
+            }
+        }
+    });
+    card.querySelector('#frh-context-btn')?.addEventListener('click', () => {
+        window.location.hash = '#context-log';
+    });
     card.querySelectorAll('.frh-hire-btn').forEach(btn => {
         btn.addEventListener('click', async e => {
             e.stopPropagation();
@@ -452,18 +489,41 @@ function renderAgentsLiveStrip() {
 /* ── Kanban ── */
 function buildKanbanCols() {
     const cols={planning:[],hiring:[],running:[],ghostpass:[],done:[]};
-    const op=S.operateSurface; if (!op) return cols;
-    const pc=op.orchestration?.planningContext||op.planningContext;
-    if (pc?.goal) cols.planning.push({id:'ctx',goal:pc.goal,status:'planning',tokens:null,time:pc.startedAt,role:null});
-    const ws=op.orchestration?.workerPlan?.workers||op.workerPlan?.workers||[];
-    for (const w of ws) {
-        const st=String(w.status||'').toLowerCase();
-        const sg=st==='active'||st==='running'?'running':st==='hiring'?'hiring':st==='complete'||st==='done'?'done':st==='reviewing'||st.includes('ghost')?'ghostpass':null;
-        if (sg) cols[sg].push({id:w.id||w.workerId||w.goal,goal:w.goal||w.task||w.approach||'(worker)',status:st,tokens:w.tokensUsed||w.budget,time:w.startedAt||w.createdAt,role:w.role});
+    const op=S.operateSurface;
+    if (op) {
+        const pc=op.orchestration?.planningContext||op.planningContext;
+        if (pc?.goal) cols.planning.push({id:'ctx',goal:pc.goal,status:'planning',tokens:null,time:pc.startedAt,role:null});
+        const ws=op.orchestration?.workerPlan?.workers||op.workerPlan?.workers||[];
+        for (const w of ws) {
+            const st=String(w.status||'').toLowerCase();
+            const sg=st==='active'||st==='running'?'running':st==='hiring'?'hiring':st==='complete'||st==='done'?'done':st==='reviewing'||st.includes('ghost')?'ghostpass':null;
+            if (sg) cols[sg].push({id:w.id||w.workerId||w.goal,goal:w.goal||w.task||w.approach||'(worker)',status:st,tokens:w.tokensUsed||w.budget,time:w.startedAt||w.createdAt,role:w.role});
+        }
     }
-    for (const r of (S.runs||[]).slice(0,6)) {
-        if ((r.status==='complete'||r.status==='done')&&!cols.done.some(c=>c.id===r.id))
-            cols.done.push({id:r.id,goal:r.goal||r.mandate||'(run)',status:'done',tokens:r.tokensUsed||r.tokenCount,time:r.completedAt||r.createdAt,role:null});
+    for (const r of (S.runs||[]).slice(0,8)) {
+        const runId = r.runId || r.id;
+        if (!runId) continue;
+        const status = String(r.status || r.state || '').toLowerCase();
+        const stage = String(r.stage || '').toLowerCase();
+        const lane = status.includes('complete') || status === 'done' || status === 'failed'
+            ? 'done'
+            : stage.includes('hire')
+                ? 'hiring'
+                : stage.includes('ghost') || stage.includes('review')
+                    ? 'ghostpass'
+                    : status === 'running' || stage.includes('orchestrat')
+                        ? 'running'
+                        : 'planning';
+        if (!cols[lane].some(c=>c.id===runId)) {
+            cols[lane].push({
+                id: runId,
+                goal: r.goal||r.mandate||'(run)',
+                status: status || stage || 'queued',
+                tokens:r.tokensUsed||r.tokenCount,
+                time:r.completedAt||r.updatedAt||r.createdAt||r.startedAt,
+                role:null,
+            });
+        }
     }
     return cols;
 }

package/dist/dashboard/app/views/context-log.js

@@ -89,17 +89,42 @@ function decisionRows(entries) {
 }
 
 function renderRunRail(runs) {
-    if (!runs.length) return '<div class="empty"><div class="empty-title">No runs recorded</div></div>';
+    if (!runs.length) return `<div class="empty">
+        <div class="empty-title">No runs recorded</div>
+        <div class="empty-sub">Run a goal from the command bar and its context spine will appear here.</div>
+    </div>`;
     return runs.map(run => {
         const id = runIdOf(run);
         const active = id === S.contextLogSelectedRunId;
         return `<button class="context-log-run ${active ? 'active' : ''}" data-context-run="${esc(id)}">
             <span>${esc(String(id).slice(-10) || 'run')}</span>
-            <small>${esc(run.state || run.status || 'queued')} · ${esc(fmtTs(run.createdAt))}</small>
+            <small>${esc(run.stage || run.state || run.status || 'queued')} · ${esc(fmtTs(run.createdAt || run.startedAt || run.updatedAt))}</small>
         </button>`;
     }).join('');
 }
 
+function emptyContextMain() {
+    return `<div class="context-log-summary context-log-empty-state">
+        <div class="context-log-kpi"><span>Runs</span><strong>0</strong></div>
+        <div class="context-log-kpi"><span>Context</span><strong>—</strong></div>
+        <div class="context-log-kpi"><span>Decision</span><strong>—</strong></div>
+        <div class="context-log-selection">
+            <div>
+                <span>Start</span>
+                <button class="btn btn-sm" id="context-log-run-goal-btn">Run a goal</button>
+            </div>
+            <div>
+                <span>Expected here</span>
+                ${chips(['request brief', 'selection plan', 'context events', 'decisions'])}
+            </div>
+            <div>
+                <span>History</span>
+                <span class="context-log-empty">Previous runs persist after the dashboard restarts.</span>
+            </div>
+        </div>
+    </div>`;
+}
+
 export async function load() {
     const runs = await api('/api/runs?limit=30', 3000);
     S.contextLogRuns = Array.isArray(runs) ? runs : [];
@@ -130,7 +155,7 @@ export function render() {
             ${renderRunRail(S.contextLogRuns || [])}
         </aside>
         <section class="context-log-main">
-            ${spine ? summaryCard(spine) : '<div class="empty"><div class="empty-title">Select a run</div></div>'}
+            ${spine ? summaryCard(spine) : emptyContextMain()}
             <div class="context-log-grid">
                 <div>
                     <div class="shd">Context events</div>
@@ -150,6 +175,10 @@ export function render() {
             await load();
         });
     });
+    $('context-log-run-goal-btn')?.addEventListener('click', () => {
+        window.location.hash = '#board';
+        setTimeout(() => $('cmd-input')?.focus(), 100);
+    });
     $('context-log-refresh-btn')?.addEventListener('click', async () => {
         bustCache('/api/runs?limit=30');
         if (S.contextLogSelectedRunId) bustCache(spineUrl(S.contextLogSelectedRunId));

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

@@ -17,6 +17,20 @@ function fmtNum(n) {
     return String(Math.round(v));
 }
 
+function collectionIdOf(collection) {
+    return collection?.collectionId || collection?.id || '';
+}
+
+function collectionNameOf(collection) {
+    return collection?.name || collectionIdOf(collection) || 'collection';
+}
+
+function collectionCounts(collection) {
+    const sources = collection?.sourceCount ?? collection?.documentCount ?? collection?.count ?? 0;
+    const chunks = collection?.chunkCount ?? 0;
+    return `${fmtNum(sources)} sources · ${fmtNum(chunks)} chunks`;
+}
+
 /* ── Data loader ── */
 export async function load() {
     const [rags, topo] = await Promise.all([
@@ -46,24 +60,38 @@ function renderRagCollections() {
         $('rag-create-btn')?.addEventListener('click', _showCreateSheet);
         return;
     }
-    el.innerHTML=`<div style="margin-bottom:8px;display:flex;align-items:center;gap:8px;justify-content:flex-end">
+    el.innerHTML=`<div style="margin-bottom:8px;display:flex;align-items:center;gap:8px;justify-content:space-between;flex-wrap:wrap">
+        <span style="font-size:var(--text-sm);color:var(--text-muted)">Attach collections to feed the orchestrator and dashboard chat.</span>
         <button class="btn btn-sm" id="rag-create-btn">New collection</button>
     </div>
-    <div>${cols.map(c=>`<div class="mission-row">
+    <div>${cols.map(c=> {
+        const id = collectionIdOf(c);
+        const name = collectionNameOf(c);
+        const attached = (c.attachedRuntimeIds || []).length || (c.attachedSessionIds || []).length;
+        return `<div class="mission-row">
         <div class="mission-body">
-            <div class="mission-title">${esc(c.name||c.id)}</div>
+            <div class="mission-title">${esc(name)}</div>
             <div class="mission-meta" style="font-family:var(--font-mono);font-size:var(--text-sm);color:var(--text-dim)">
-                ${fmtNum(c.documentCount||c.count||0)} docs · ${fmtNum(c.tokenCount||0)} tokens
+                ${collectionCounts(c)} · ${attached ? 'attached' : 'detached'}
             </div>
         </div>
-        <button class="btn btn-sm" data-ingest="${esc(c.id)}" data-ingestname="${esc(c.name||c.id)}">Ingest</button>
-        <button class="btn btn-sm" data-drop-target="${esc(c.id)}" data-drop-name="${esc(c.name||c.id)}" title="Drop files to upload">↑ Upload</button>
-    </div>`).join('')}</div>
+        <button class="btn btn-sm" data-ingest="${esc(id)}" data-ingestname="${esc(name)}">Add source</button>
+        <button class="btn btn-sm" data-ingest-repo="${esc(id)}" data-ingestname="${esc(name)}">Ingest repo</button>
+        <button class="btn btn-sm" data-attach="${esc(id)}" data-attached="${attached ? '1' : '0'}">${attached ? 'Detach' : 'Attach'}</button>
+        <button class="btn btn-sm" data-drop-target="${esc(id)}" data-drop-name="${esc(name)}" title="Drop files to upload">Upload</button>
+    </div>`;
+    }).join('')}</div>
     ${_renderDropZone(cols)}`;
 
     $('rag-create-btn')?.addEventListener('click', _showCreateSheet);
     el.querySelectorAll('[data-ingest]').forEach(btn => {
-        btn.addEventListener('click', () => _ingestCollection(btn.dataset.ingest, btn.dataset.ingestname, btn));
+        btn.addEventListener('click', () => _showIngestSheet(btn.dataset.ingest, btn.dataset.ingestname));
+    });
+    el.querySelectorAll('[data-ingest-repo]').forEach(btn => {
+        btn.addEventListener('click', () => _ingestRepoCollection(btn.dataset.ingestRepo, btn.dataset.ingestname, btn));
+    });
+    el.querySelectorAll('[data-attach]').forEach(btn => {
+        btn.addEventListener('click', () => _toggleCollectionAttach(btn.dataset.attach, btn.dataset.attached === '1', btn));
     });
     el.querySelectorAll('[data-drop-target]').forEach(btn => {
         btn.addEventListener('click', () => _focusDropZone(btn.dataset.dropTarget, btn.dataset.dropName));
@@ -73,7 +101,7 @@ function renderRagCollections() {
 
 /** Render the drag-and-drop upload zone below the collection list. */
 function _renderDropZone(cols) {
-    const opts = cols.map(c=>`<option value="${esc(c.id)}">${esc(c.name||c.id)}</option>`).join('');
+    const opts = cols.map(c=>`<option value="${esc(collectionIdOf(c))}">${esc(collectionNameOf(c))}</option>`).join('');
     return `
     <div id="rag-drop-zone" class="rag-drop-zone" aria-label="Drop files to ingest" role="region">
       <div class="rag-drop-inner" id="rag-drop-inner">
@@ -157,7 +185,7 @@ async function _uploadFiles(files) {
     const r = await post(`/api/rag/collections/${encodeURIComponent(collectionId)}/ingest`, { inputs }).catch(() => null);
 
     if (progress) progress.textContent = '';
-    if (r && !r.error) {
+    if (r?.ok) {
         _toast(`Ingested ${inputs.length} file(s) into collection.`, 'good');
         bustCache('/api/rag/collections');
         setTimeout(load, 1200);
@@ -166,12 +194,13 @@ async function _uploadFiles(files) {
     }
 }
 
-async function _ingestCollection(id, name, btn) {
+async function _ingestRepoCollection(id, name, btn) {
     btn.disabled=true; btn.textContent='Ingesting…';
     const r=await post('/api/rag/ingest', { collectionId: id });
-    btn.disabled=false; btn.textContent='Ingest';
+    btn.disabled=false; btn.textContent='Ingest repo';
     if (r.ok) {
-        _toast(`Collection "${name}" ingestion started.`, 'good');
+        const added = r.data?.sourcesAdded ?? r.data?.chunksAdded ?? 0;
+        _toast(`Collection "${name}" ingested ${added ? fmtNum(added) : 'repo'} source(s).`, 'good');
         bustCache('/api/rag/collections');
         setTimeout(load, 1500);
     } else {
@@ -179,6 +208,68 @@ async function _ingestCollection(id, name, btn) {
     }
 }
 
+async function _toggleCollectionAttach(id, attached, btn) {
+    btn.disabled = true;
+    btn.textContent = attached ? 'Detaching…' : 'Attaching…';
+    const r = await post(`/api/rag/collections/${encodeURIComponent(id)}/${attached ? 'detach' : 'attach'}`, {});
+    if (r.ok) {
+        _toast(attached ? 'Collection detached.' : 'Collection attached.', 'good');
+        bustCache('/api/rag/collections');
+        setTimeout(load, 700);
+    } else {
+        btn.disabled = false;
+        btn.textContent = attached ? 'Detach' : 'Attach';
+        _toast(`Collection update failed: ${r.error}`, 'bad');
+    }
+}
+
+function _showIngestSheet(collectionId, collectionName) {
+    openDrawer({
+        title: `Add source to ${collectionName}`,
+        body: `<div class="dsec">
+            <div class="dsec-title">Ingest source</div>
+            <label class="form-label" for="rag-ingest-url">URL</label>
+            <input id="rag-ingest-url" class="form-input" type="url" placeholder="https://docs.example.com/page">
+            <label class="form-label" for="rag-ingest-file" style="margin-top:10px">File or folder path</label>
+            <input id="rag-ingest-file" class="form-input" type="text" placeholder="${esc(S.workspace?.repoRoot || '/path/to/repo')}">
+            <label class="form-label" for="rag-ingest-text" style="margin-top:10px">Text note</label>
+            <textarea id="rag-ingest-text" class="form-input" rows="5" placeholder="Paste notes, API docs, or decision context"></textarea>
+            <label class="form-label" for="rag-ingest-tags" style="margin-top:10px">Tags</label>
+            <input id="rag-ingest-tags" class="form-input" type="text" placeholder="repo,dashboard">
+            <button class="btn btn-primary" id="rag-ingest-confirm" style="margin-top:var(--space-4)">Ingest source</button>
+            <div id="rag-ingest-status" style="margin-top:var(--space-3);font-size:var(--text-sm);color:var(--text-muted)"></div>
+        </div>`,
+    });
+    $('rag-ingest-confirm')?.addEventListener('click', () => _submitIngest(collectionId));
+}
+
+async function _submitIngest(collectionId) {
+    const status = $('rag-ingest-status');
+    const url = ($('rag-ingest-url')?.value || '').trim();
+    const fileOrFolder = ($('rag-ingest-file')?.value || '').trim();
+    const text = ($('rag-ingest-text')?.value || '').trim();
+    const tags = ($('rag-ingest-tags')?.value || '').split(',').map(s => s.trim()).filter(Boolean);
+    const inputs = [];
+    if (url) inputs.push({ url, tags });
+    if (fileOrFolder) inputs.push({ folderPath: fileOrFolder, filePath: fileOrFolder, tags });
+    if (text) inputs.push({ text, label: 'dashboard-note', tags });
+    if (!inputs.length) {
+        if (status) { status.textContent = 'Add a URL, file/folder path, or text note.'; status.style.color = 'var(--bad)'; }
+        return;
+    }
+    if (status) { status.textContent = 'Ingesting…'; status.style.color = 'var(--text-muted)'; }
+    const r = await post(`/api/rag/collections/${encodeURIComponent(collectionId)}/ingest`, { inputs }).catch(() => null);
+    if (r?.ok) {
+        if (status) { status.textContent = `Added ${r.data?.sourcesAdded ?? inputs.length} source(s).`; status.style.color = 'var(--ok)'; }
+        _toast('RAG source ingested.', 'good');
+        bustCache('/api/rag/collections');
+        setTimeout(load, 900);
+    } else if (status) {
+        status.textContent = `Ingest failed: ${r?.error ?? 'unknown error'}`;
+        status.style.color = 'var(--bad)';
+    }
+}
+
 function _showCreateSheet() {
     openDrawer({
         title: 'Create collection',

package/dist/dashboard/routes/events.js

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { CONTEXT_LOG_FILE, DECISION_LOG_FILE, REQUEST_BRIEF_FILE, SELECTION_PLAN_FILE, } from '../../engines/orchestrator/decision-spine.js';
 import { getSharedNgramIndex } from '../../engines/ngram-index.js';
+import { getRun as getStoredRun, getSpans } from '../../engines/orchestrator/store.js';
 import { getSharedTelemetry } from '../../engines/telemetry-remote.js';
 import { getDashboardEventCards } from '../stream/sse-broker.js';
 async function readJsonArtifact(run, filename, fallback) {
@@ -29,6 +30,90 @@ async function readJsonlArtifact(run, filename, fallback) {
         return fallback;
     }
 }
+function storedRunDecisionSpine(run) {
+    const spans = getSpans(run.runId);
+    const contextLog = spans.length
+        ? spans.map((span) => ({
+            phase: span.name,
+            actor: 'dashboard',
+            reason: String(span.attrs?.summary ?? span.attrs?.state ?? span.name),
+            createdAt: span.startedAt,
+            contextRefs: [span.spanId],
+            evidenceRefs: [
+                span.attrs?.actualRunId ? `actual:${span.attrs.actualRunId}` : null,
+                span.status === 'error' && span.attrs?.error ? `error:${span.attrs.error}` : null,
+            ].filter(Boolean),
+        }))
+        : [{
+                phase: run.stage ?? 'intake',
+                actor: run.client ?? 'dashboard',
+                reason: `${run.status ?? 'queued'} run: ${run.goal ?? run.runId}`,
+                createdAt: run.updatedAt ?? run.startedAt ?? Date.now(),
+                evidenceRefs: [run.runId],
+            }];
+    const decisionLog = [{
+            verb: run.status === 'failed' ? 'blocked' : run.status === 'completed' ? 'completed' : 'queued',
+            surface: 'dashboard',
+            decision: run.status === 'failed'
+                ? (run.error ?? 'Run failed')
+                : run.status === 'completed'
+                    ? (run.resultSummary ?? 'Run completed')
+                    : `Run is ${run.stage ?? run.status ?? 'queued'}`,
+            reason: run.goal ?? '',
+            createdAt: run.completedAt ?? run.updatedAt ?? run.startedAt ?? Date.now(),
+            beforeRef: run.runId,
+            afterRef: run.status === 'completed' ? 'orchestration-store' : null,
+        }];
+    const requestBrief = {
+        runId: run.runId,
+        rawPrompt: run.goal,
+        intent: 'orchestrate',
+        risk: run.status === 'failed' ? 'needs-attention' : 'standard',
+        source: run.client ?? 'dashboard',
+        createdAt: run.startedAt,
+    };
+    const selectionPlan = {
+        runId: run.runId,
+        intent: 'orchestrate',
+        selected: {
+            files: [],
+            skills: [],
+            specialists: [],
+            crews: [],
+        },
+        executionPolicy: {
+            route: run.client ?? 'dashboard',
+            stage: run.stage,
+            progress: run.progress,
+        },
+    };
+    return {
+        runId: run.runId,
+        artifactsPath: null,
+        files: {
+            requestBrief: REQUEST_BRIEF_FILE,
+            selectionPlan: SELECTION_PLAN_FILE,
+            contextLog: CONTEXT_LOG_FILE,
+            decisionLog: DECISION_LOG_FILE,
+        },
+        artifacts: {
+            requestBrief,
+            selectionPlan,
+            contextLog,
+            decisionLog,
+        },
+        summary: {
+            intent: requestBrief.intent,
+            risk: requestBrief.risk,
+            modelRoute: null,
+            selected: selectionPlan.selected,
+            contextEvents: contextLog.length,
+            decisions: decisionLog.length,
+            latestDecision: decisionLog[decisionLog.length - 1],
+            source: 'orchestration-store',
+        },
+    };
+}
 export const handleEventRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/stream') {
         ctx.serveSse(req, res);
@@ -56,7 +141,12 @@ export const handleEventRoutes = async (ctx, req, res, url) => {
         const runId = decodeURIComponent(decisionSpineMatch[1]);
         const run = await ctx.getRuntime()?.getRun?.(runId);
         if (!run) {
-            ctx.respondJson(res, { error: 'decision-spine-not-found', runId }, 404);
+            const stored = getStoredRun(runId);
+            if (!stored) {
+                ctx.respondJson(res, { error: 'decision-spine-not-found', runId }, 404);
+                return true;
+            }
+            ctx.respondJson(res, storedRunDecisionSpine(stored));
             return true;
         }
         const [requestBrief, selectionPlan, contextLog, decisionLog] = await Promise.all([

package/dist/dashboard/routes/memory.js

@@ -1,5 +1,50 @@
+import fs from 'fs/promises';
 import path from 'path';
 import { resolveWorkspaceContext } from '../../engines/workspace-resolver.js';
+function safeWorkspacePath(value, allowedRoots) {
+    if (!value)
+        return undefined;
+    const abs = path.resolve(String(value));
+    return allowedRoots.some((root) => abs === root || abs.startsWith(root + path.sep)) ? abs : undefined;
+}
+async function isDirectory(value) {
+    try {
+        return (await fs.stat(value)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function normalizeRagInputs(body, allowedRoots) {
+    const rawInputs = Array.isArray(body?.inputs) ? body.inputs : [body ?? {}];
+    const normalized = await Promise.all(rawInputs
+        .map(async (entry) => {
+        let filePath = safeWorkspacePath(entry?.filePath, allowedRoots);
+        let folderPath = safeWorkspacePath(entry?.folderPath, allowedRoots);
+        if (filePath && !folderPath && await isDirectory(filePath)) {
+            folderPath = filePath;
+            filePath = undefined;
+        }
+        if (filePath && folderPath && filePath === folderPath) {
+            if (await isDirectory(filePath)) {
+                filePath = undefined;
+            }
+            else {
+                folderPath = undefined;
+            }
+        }
+        return {
+            filePath,
+            folderPath,
+            folderGlob: entry?.folderGlob ? String(entry.folderGlob) : undefined,
+            url: entry?.url ? String(entry.url) : undefined,
+            text: entry?.text ? String(entry.text) : undefined,
+            label: entry?.label ? String(entry.label) : undefined,
+            tags: Array.isArray(entry?.tags) ? entry.tags.map(String) : [],
+        };
+    }));
+    return normalized.filter((entry) => entry.filePath || entry.folderPath || entry.url || entry.text);
+}
 export const handleMemoryRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/api/knowledge-fabric/session') {
         const snapshot = ctx.resolveRuntimeSnapshot(url);
@@ -222,22 +267,32 @@ export const handleMemoryRoutes = async (ctx, req, res, url) => {
             ctx.respondJson(res, { error: 'orchestrator-unavailable' }, 503);
             return true;
         }
-        const inputs = Array.isArray(body.inputs)
-            ? body.inputs.map((entry) => ({
-                filePath: (() => {
-                    if (!entry?.filePath)
-                        return undefined;
-                    const abs = path.resolve(String(entry.filePath));
-                    return allowedRoots.some((root) => abs === root || abs.startsWith(root + path.sep))
-                        ? String(entry.filePath)
-                        : undefined;
-                })(),
-                url: entry?.url ? String(entry.url) : undefined,
-                text: entry?.text ? String(entry.text) : undefined,
-                label: entry?.label ? String(entry.label) : undefined,
-                tags: Array.isArray(entry?.tags) ? entry.tags.map(String) : [],
-            }))
-            : [];
+        const inputs = await normalizeRagInputs(body, allowedRoots);
+        ctx.respondJson(res, await orchestrator.ingestRagCollection(collectionId, inputs));
+        return true;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/rag/ingest') {
+        const body = await ctx.readJsonBody(req);
+        const collectionId = String(body?.collectionId ?? body?.id ?? '').trim();
+        const orchestrator = ctx.getOrchestrator();
+        const workspace = ctx.workspaceContextProvider?.() ?? resolveWorkspaceContext({ workspaceRoot: ctx.repoRoot });
+        const allowedRoots = [workspace.workspaceRoot, workspace.repoRoot].map((root) => path.resolve(root));
+        if (!orchestrator) {
+            ctx.respondJson(res, { error: 'orchestrator-unavailable' }, 503);
+            return true;
+        }
+        if (!collectionId) {
+            ctx.respondJson(res, { error: 'collectionId-required' }, 400);
+            return true;
+        }
+        let inputs = await normalizeRagInputs(body, allowedRoots);
+        if (!inputs.length && !body?.inputs && !body?.filePath && !body?.folderPath && !body?.url && !body?.text) {
+            inputs = [{
+                    folderPath: workspace.repoRoot,
+                    label: workspace.repoName || path.basename(workspace.repoRoot),
+                    tags: ['repo', 'dashboard'],
+                }];
+        }
         ctx.respondJson(res, await orchestrator.ingestRagCollection(collectionId, inputs));
         return true;
     }

package/dist/dashboard/routes/runtime.js

@@ -5,6 +5,7 @@ import { execAsync } from '../../utils/exec-async.js';
 import { recordFirstInteraction } from '../../engines/telemetry.js';
 import { pushDispatch, cancelDispatch, listActiveDispatches } from '../../engines/dispatch/push-dispatch.js';
 import { invokerRegistry } from '../../invokers/registry.js';
+import { completeRun, createRun, failRun, getRun as getStoredRun, listRecentRuns, startSpan, endSpan, updateStage, } from '../../engines/orchestrator/store.js';
 function normalizeLifetimeTokenPayload(record) {
     const savedTokens = Number(record?.totalSavedTokens ?? 0);
     const grossInputTokens = Number(record?.totalGrossInputTokens ?? 0);
@@ -48,6 +49,72 @@ function normalizeTokenSummaryPayload(record) {
         net: compressedTokens,
     };
 }
+function mergeDashboardRuns(liveRuns, storedRuns, limit) {
+    const seen = new Set();
+    return [...(liveRuns ?? []), ...(storedRuns ?? [])]
+        .map((run) => {
+        const runId = run?.runId ?? run?.id;
+        return runId ? { ...run, runId, id: run.id ?? runId } : null;
+    })
+        .filter((run) => {
+        if (!run?.runId || seen.has(run.runId))
+            return false;
+        seen.add(run.runId);
+        return true;
+    })
+        .sort((left, right) => {
+        const leftTs = Number(left.updatedAt ?? left.completedAt ?? left.createdAt ?? left.startedAt ?? 0);
+        const rightTs = Number(right.updatedAt ?? right.completedAt ?? right.createdAt ?? right.startedAt ?? 0);
+        return rightTs - leftTs;
+    })
+        .slice(0, Math.max(1, limit));
+}
+function summarizeDashboardRun(run, fallbackGoal) {
+    const state = run?.state ?? run?.status ?? 'completed';
+    const summary = run?.summary ?? run?.resultSummary ?? run?.message ?? '';
+    return String(summary || `${state}: ${fallbackGoal}`).slice(0, 1024);
+}
+async function tokenLedgerFallback(ctx) {
+    const memory = ctx.getMemory?.();
+    if (!memory)
+        return null;
+    try {
+        const { TokenAnalyticsEngine } = await import('../../engines/token-analytics.js');
+        const report = new TokenAnalyticsEngine(memory).getLifetimeReport();
+        const optimized = Number(report.totalTokensOptimized ?? 0);
+        const saved = Number(report.totalTokensSaved ?? 0);
+        const forwarded = Number(report.totalTokensForwarded ?? Math.max(0, optimized - saved));
+        if (optimized <= 0 && saved <= 0 && forwarded <= 0)
+            return null;
+        return {
+            totalSavedTokens: saved,
+            totalGrossInputTokens: optimized,
+            totalCompressedTokens: forwarded,
+            totalRuns: Number(report.totalSessions ?? 0),
+            lastUpdatedAt: Date.now(),
+            tokenLedger: report,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function mergeLifetimeTokenRecords(fileRecord, ledgerRecord) {
+    if (!ledgerRecord)
+        return fileRecord;
+    return {
+        ...fileRecord,
+        totalSavedTokens: Math.max(Number(fileRecord?.totalSavedTokens ?? 0), Number(ledgerRecord.totalSavedTokens ?? 0)),
+        totalGrossInputTokens: Math.max(Number(fileRecord?.totalGrossInputTokens ?? 0), Number(ledgerRecord.totalGrossInputTokens ?? 0)),
+        totalCompressedTokens: Math.max(Number(fileRecord?.totalCompressedTokens ?? 0), Number(ledgerRecord.totalCompressedTokens ?? 0)),
+        totalRuns: Math.max(Number(fileRecord?.totalRuns ?? 0), Number(ledgerRecord.totalRuns ?? 0)),
+        lastUpdatedAt: Math.max(Number(fileRecord?.lastUpdatedAt ?? 0), Number(ledgerRecord.lastUpdatedAt ?? 0)),
+        sources: {
+            lifetimeFile: fileRecord,
+            tokenLedger: ledgerRecord.tokenLedger,
+        },
+    };
+}
 async function readGitBranch(repoRoot) {
     try {
         const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', {
@@ -64,7 +131,9 @@ async function readGitBranch(repoRoot) {
 export const handleRuntimeRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/api/runs') {
         const limit = parseInt(url.searchParams.get('limit') || '20', 10);
-        ctx.respondJson(res, ctx.getRuntime()?.listRuns(limit) ?? []);
+        const liveRuns = ctx.getRuntime()?.listRuns(limit) ?? [];
+        const storedRuns = listRecentRuns(limit);
+        ctx.respondJson(res, mergeDashboardRuns(liveRuns, storedRuns, limit));
         return true;
     }
     if (req.method === 'GET' && url.pathname === '/api/usage') {
@@ -140,7 +209,8 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
     if (req.method === 'GET' && url.pathname === '/api/tokens/lifetime') {
         try {
             const { readLifetimeTokens } = await import('../../engines/lifetime-tokens.js');
-            ctx.respondJson(res, { ok: true, data: normalizeLifetimeTokenPayload(readLifetimeTokens()) });
+            const merged = mergeLifetimeTokenRecords(readLifetimeTokens(), await tokenLedgerFallback(ctx));
+            ctx.respondJson(res, { ok: true, data: normalizeLifetimeTokenPayload(merged) });
         }
         catch (err) {
             ctx.respondJson(res, { ok: false, error: err?.message ?? 'Failed to read lifetime tokens' });
@@ -167,7 +237,7 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
     }
     if (req.method === 'GET' && url.pathname.startsWith('/api/runs/')) {
         const runId = decodeURIComponent(url.pathname.replace('/api/runs/', ''));
-        const run = await ctx.getRuntime()?.getRun?.(runId);
+        const run = await ctx.getRuntime()?.getRun?.(runId) ?? getStoredRun(runId);
         ctx.respondJson(res, run ?? { error: 'run-not-found', runId }, run ? 200 : 404);
         return true;
     }
@@ -215,13 +285,39 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
             ctx.respondJson(res, { error: 'goal-required' }, 400);
             return true;
         }
-        const run = await orchestrator.orchestrate(goal, { ...body, goal });
-        nexusEventBus.emit('dashboard.action', {
-            action: 'runtime.execute',
-            status: run.state,
-            target: run.runId,
-        });
-        ctx.respondJson(res, run, 201);
+        const dashboardRunId = `dash_${Date.now()}`;
+        createRun(dashboardRunId, goal, 'dashboard-chat');
+        updateStage(dashboardRunId, 'orchestrating', 35);
+        const spanId = startSpan(dashboardRunId, 'dashboard.runtime.execute', undefined, { source: 'dashboard-chat' });
+        try {
+            const run = await orchestrator.orchestrate(goal, { ...body, goal, source: body.source ?? 'dashboard-chat' });
+            const actualRunId = run?.runId ?? dashboardRunId;
+            if (actualRunId !== dashboardRunId) {
+                createRun(actualRunId, goal, 'dashboard-chat');
+                updateStage(actualRunId, 'orchestrating', 80);
+            }
+            completeRun(dashboardRunId, summarizeDashboardRun(run, goal));
+            if (actualRunId !== dashboardRunId)
+                completeRun(actualRunId, summarizeDashboardRun(run, goal));
+            endSpan(spanId, run?.state === 'failed' ? 'error' : 'ok', { actualRunId, state: run?.state ?? 'completed' });
+            nexusEventBus.emit('dashboard.action', {
+                action: 'runtime.execute',
+                status: run.state,
+                target: actualRunId,
+            });
+            ctx.respondJson(res, run, 201);
+        }
+        catch (err) {
+            const message = err?.message ?? String(err);
+            failRun(dashboardRunId, message);
+            endSpan(spanId, 'error', { error: message });
+            nexusEventBus.emit('dashboard.action', {
+                action: 'runtime.execute.failed',
+                status: 'fail',
+                target: dashboardRunId,
+            });
+            ctx.respondJson(res, { error: message, runId: dashboardRunId }, 500);
+        }
         return true;
     }
     if (req.method === 'POST' && url.pathname === '/api/runtime/plan') {
@@ -315,22 +411,38 @@ export const handleRuntimeRoutes = async (ctx, req, res, url) => {
             return true;
         }
         const runId = `run_${Date.now()}`;
+        createRun(runId, goal, 'dashboard');
+        updateStage(runId, 'queued', 10);
+        const spanId = startSpan(runId, 'dashboard.orchestrate', undefined, { source: body.source ?? 'dashboard' });
         // 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' })
+        orchestrator.orchestrate(goal, { source: body.source ?? 'dashboard', dashboardRunId: runId })
             .then((run) => {
+            const actualRunId = run?.runId ?? runId;
+            if (actualRunId !== runId) {
+                createRun(actualRunId, goal, 'dashboard');
+                updateStage(actualRunId, 'orchestrating', 80);
+            }
+            const summary = summarizeDashboardRun(run, goal);
+            completeRun(runId, summary);
+            if (actualRunId !== runId)
+                completeRun(actualRunId, summary);
+            endSpan(spanId, run?.state === 'failed' ? 'error' : 'ok', { actualRunId, state: run?.state ?? 'completed' });
             nexusEventBus.emit('dashboard.action', {
                 action: 'orchestrate.complete',
                 status: run?.state === 'failed' ? 'fail' : 'ok',
-                target: run?.runId ?? runId,
+                target: actualRunId,
             });
         })
             .catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            failRun(runId, message);
+            endSpan(spanId, 'error', { error: message });
             nexusEventBus.emit('dashboard.action', {
                 action: 'orchestrate.failed',
                 status: 'fail',
-                target: err instanceof Error ? err.message : String(err),
+                target: runId,
             });
         });
         nexusEventBus.emit('dashboard.action', { action: 'orchestrate.enqueue', status: 'queued', target: runId });

package/dist/dashboard/server.js

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

package/dist/dashboard/welcome.html

@@ -312,14 +312,14 @@
 
   <!-- Step 3: Ready -->
   <div class="panel" id="panel-3" style="display:none">
-    <div class="panel-title" style="color:var(--ok)">✓ You're ready</div>
-    <div class="panel-sub">Your control plane is online. Here's what you can do next.</div>
+    <div class="panel-title" style="color:var(--ok)">✓ Control plane ready</div>
+    <div class="panel-sub">Your dashboard can now run goals, hire operatives, ingest knowledge, and show context history.</div>
 
     <div class="ready-grid">
       <div class="ready-tile">
         <div class="ready-tile-icon">🧠</div>
-        <div class="ready-tile-label">Orchestrate</div>
-        <div class="ready-tile-desc">Give an agent a goal and watch it plan, remember, and execute.</div>
+        <div class="ready-tile-label">Run a goal</div>
+        <div class="ready-tile-desc">Queue a dashboard run and watch Board plus Context Log fill with real artifacts.</div>
       </div>
       <div class="ready-tile">
         <div class="ready-tile-icon">👥</div>
@@ -328,13 +328,13 @@
       </div>
       <div class="ready-tile">
         <div class="ready-tile-icon">📡</div>
-        <div class="ready-tile-label">Live Dashboard</div>
-        <div class="ready-tile-desc">Watch every tool call, token saved, and memory formed in real time.</div>
+        <div class="ready-tile-label">Context history</div>
+        <div class="ready-tile-desc">Open prior runs, selected files, decisions, memory events, and model routing.</div>
       </div>
       <div class="ready-tile">
         <div class="ready-tile-icon">🔑</div>
-        <div class="ready-tile-label">MCP Connected</div>
-        <div class="ready-tile-desc">Nexus Prime is wired into your IDE agents via the control plane.</div>
+        <div class="ready-tile-label">Knowledge ready</div>
+        <div class="ready-tile-desc">Create RAG collections, attach them, and ingest repo files or pasted notes.</div>
       </div>
     </div>
 
@@ -348,9 +348,9 @@
     </div>
 
     <div class="actions" style="margin-top:24px">
-      <a class="btn primary" href="/">Open Board →</a>
+      <a class="btn primary" href="/#board">Open Board →</a>
       <a class="btn" href="/#workforce">Workforce</a>
-      <a class="btn" href="/#memory">Memory</a>
+      <a class="btn" href="/#context-log">Context Log</a>
     </div>
   </div>
 
@@ -561,8 +561,8 @@
 
     // ── Step 3: Ready ─────────────────────────────────────────────────────────
     function loadReadyStep() {
-      document.getElementById('page-title').textContent = 'You\'re all set 🚀';
-      document.getElementById('page-sub').textContent = 'Control plane online. Start orchestrating.';
+      document.getElementById('page-title').textContent = 'Nexus Prime is ready';
+      document.getElementById('page-sub').textContent = 'Open Board, run the first goal, or hire an operative. The dashboard will keep the run history visible.';
     }
 
     async function hireOperative() {
@@ -575,7 +575,7 @@
         const res = await fetch('/api/synapse/hire', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ specialistId: 'engineering.rapid-prototyper', budgetCapUsd: 2, name: 'Rapid Prototyper' }),
+          body: JSON.stringify({ specialistId: 'engineering.rapid-prototyper', budgetCapUsd: 2, name: 'Rapid Prototyper', fireFirstSortie: true }),
         });
         if (res.ok) {
           const d = await res.json();

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

@@ -1,7 +1,7 @@
 import { MemoryEngine } from './memory.js';
 import { PatternRegistry, type PatternCard, type PatternSearchResult } from './pattern-registry.js';
 import { RuntimeRegistry, type RuntimeRegistrySnapshot } from './runtime-registry.js';
-import { RagCollectionStore, type RagCollectionSummary, type RagRetrievalHit } from './rag-collections.js';
+import { RagCollectionStore, type RagCollectionSummary, type RagIngestInput, type RagRetrievalHit } from './rag-collections.js';
 import { TokenSupremacyEngine, type ReadingPlan } from './token-supremacy.js';
 export type KnowledgeSourceClass = 'repo' | 'memory' | 'rag' | 'patterns' | 'runtime';
 export type ModelTier = 'low' | 'high';
@@ -171,13 +171,7 @@ export declare class KnowledgeFabricEngine {
         tags?: string[];
         scope?: 'session' | 'project';
     }): import("./rag-collections.js").RagCollection;
-    ingestCollection(collectionId: string, inputs: Array<{
-        filePath?: string;
-        url?: string;
-        text?: string;
-        label?: string;
-        tags?: string[];
-    }>): Promise<{
+    ingestCollection(collectionId: string, inputs: RagIngestInput[]): Promise<{
         collection: import("./rag-collections.js").RagCollection;
         sourcesAdded: number;
         chunksAdded: number;

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

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

package/dist/engines/ngram-index.js

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

package/dist/engines/orchestrator.d.ts

@@ -7,6 +7,7 @@
 import { MemoryEngine } from './memory.js';
 import { SessionDNAManager } from './session-dna.js';
 import type { ClientRegistry } from './client-registry.js';
+import type { RagIngestInput } from './rag-collections.js';
 import { type ExecutionRun, type ExecutionTask, type SubAgentRuntime } from '../phantom/index.js';
 export * from './orchestrator/types.js';
 import { type Agent, type AutonomyIntent, type BootstrapRequestOptions, type SessionAutonomyState, type SessionBootstrapResult, type OrchestratorOptions } from './orchestrator/types.js';
@@ -96,13 +97,7 @@ export declare class OrchestratorEngine {
         tags?: string[];
         scope?: 'session' | 'project';
     }): import("./rag-collections.js").RagCollection;
-    ingestRagCollection(collectionId: string, inputs: Array<{
-        filePath?: string;
-        url?: string;
-        text?: string;
-        label?: string;
-        tags?: string[];
-    }>): Promise<{
+    ingestRagCollection(collectionId: string, inputs: RagIngestInput[]): Promise<{
         collection: import("./rag-collections.js").RagCollection;
         sourcesAdded: number;
         chunksAdded: number;

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.18",
+  "version": "7.9.20",
   "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/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",
+    "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/dashboard-runtime-adapters.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",