nexus-prime 7.9.17 → 7.9.19

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/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) {
@@ -274,6 +278,7 @@ function renderHero() {
         ?? lt?.totalSaved
         ?? lt?.lifetime?.saved
         ?? op?.tokenOptimization?.savedTokens
+        ?? op?.tokenOptimization?.estimatedSavings
         ?? t?.savedTokens
         ?? t?.saved
         ?? 0,
@@ -317,14 +322,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.' });
     }
@@ -349,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
@@ -371,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)}">
@@ -388,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();
@@ -401,6 +443,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')
@@ -446,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));