nexus-prime 7.9.16 → 7.9.18

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

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

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

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

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

@@ -44,8 +44,10 @@ export async function handleRuntimeGroup(toolName, hctx, request, args, ctx) {
                     ? `- **Trial remaining**: ${licStatus.trialDaysRemaining} day${licStatus.trialDaysRemaining === 1 ? '' : 's'}`
                     : '',
                 licStatus.activationRequired
-                    ? `- **Agent motion**: Stop paid-tier work and ask the user to request or activate a Nexus Prime license now.`
-                    : `- **Agent motion**: 3-day no-license grace is active; ask the user to request a license before day 4.`,
+                    ? `- **Agent motion**: License activation is required for paid-tier work; keep license/status tools available.`
+                    : licStatus.trialPhase === 'activation'
+                        ? `- **Agent motion**: Trial remains active; ask the user to request or activate a license soon, then keep working.`
+                        : `- **Agent motion**: No license is mandatory during the first 3 days; ask the user to request a license soon.`,
             ].filter((line) => Boolean(line)) : [];
             const lines = [
                 `## License Status`,

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;
@@ -154,6 +161,8 @@ export class SessionTelemetry {
     needsOptimizeTokens(currentToolName) {
         if (currentToolName === 'nexus_optimize_tokens')
             return false;
+        if (currentToolName === 'nexus_mindkit_check')
+            return false;
         if (this.lifecyclePhase === 'pre-bootstrap')
             return false;
         if (this.tokenAutoApplied)

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/install-wizard.js

@@ -39,6 +39,13 @@ const SETUP_CLIENT_BY_IDE = {
     cline: 'cline',
     codex: 'codex',
 };
+function resolveSetupWorkspaceRoot(explicitWorkspaceRoot) {
+    return resolveWorkspaceContext({
+        workspaceRoot: explicitWorkspaceRoot,
+        cwd: process.cwd(),
+        env: process.env,
+    }).workspaceRoot;
+}
 function isSetupMarker(value) {
     if (!value || typeof value !== 'object') {
         return false;
@@ -89,7 +96,7 @@ export function writeSetupMarker(marker, markerPath = SETUP_MARKER_PATH) {
     return nextMarker;
 }
 export async function configureIDE(ide, opts = {}) {
-    const workspaceRoot = resolve(opts.workspaceRoot ?? process.cwd());
+    const workspaceRoot = resolveSetupWorkspaceRoot(opts.workspaceRoot);
     const mappedClient = SETUP_CLIENT_BY_IDE[ide];
     if (mappedClient) {
         const definition = getSetupDefinition(mappedClient, {
@@ -285,7 +292,7 @@ export function runArchitectureUpgrade(opts = {}) {
 }
 /** Run the install wizard: detect IDEs and write MCP configs. */
 export async function runInstallWizard(opts = {}) {
-    const workspaceRoot = resolve(opts.workspaceRoot ?? process.cwd());
+    const workspaceRoot = resolveSetupWorkspaceRoot(opts.workspaceRoot);
     const verbose = opts.verbose ?? true;
     const dryRun = opts.dryRun ?? false;
     const setupMarker = readSetupMarker();
@@ -414,6 +421,7 @@ export async function cliSetup(opts = []) {
     const port = process.env.NEXUS_DASHBOARD_PORT ?? '3377';
     const dashUrl = `http://localhost:${port}`;
     const isNew = options.isNewUser ?? false;
+    const workspaceRoot = resolveSetupWorkspaceRoot();
     const ANSI = { cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', reset: '\x1b[0m' };
     const isTTY = process.stdout.isTTY === true && !process.env.NO_COLOR;
     const c = (s, k) => isTTY ? `${ANSI[k]}${s}${ANSI.reset}` : s;
@@ -438,7 +446,7 @@ export async function cliSetup(opts = []) {
         }
         catch { /* non-fatal */ }
     };
-    const result = await runInstallWizard({ dryRun, verbose: false });
+    const result = await runInstallWizard({ workspaceRoot, dryRun, verbose: false });
     const allIDEs = [...result.configured, ...result.skipped, ...result.errors.map(e => e.ide)];
     if (allIDEs.length > 0) {
         for (const ide of allIDEs) {
@@ -499,7 +507,7 @@ export async function cliSetup(opts = []) {
     let daemonReady = false;
     if (!dryRun) {
         try {
-            const workspace = resolveWorkspaceContext({ workspaceRoot: process.cwd() });
+            const workspace = resolveWorkspaceContext({ workspaceRoot, cwd: process.cwd(), env: process.env });
             await withSpinner('Connecting to daemon', ensureDaemonReady(workspace, { timeoutMs: DEFAULT_DAEMON_READY_TIMEOUT_MS, entrypoint: process.argv[1] }));
             daemonReady = true;
             log(`  ${c('✓', 'green')} Dashboard: ${c(dashUrl, 'cyan')}`);

package/dist/cli.js

@@ -454,11 +454,13 @@ function resolveClaudeDesktopConfigPath() {
     return join(homedir(), '.claude', 'claude_desktop_config.json');
 }
 function getSetupDefinition(clientId) {
+    const workspaceRoot = getWorkspaceRoot();
     const instructionFiles = buildInstructionFiles(clientId);
     if (clientId === 'codex') {
         return {
             id: clientId,
             label: 'Codex',
+            workspaceRoot,
             configPath: resolveCodexConfigPath(),
             instructionFiles,
         };
@@ -467,6 +469,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Cursor',
+            workspaceRoot,
             configPath: join(homedir(), '.cursor', 'mcp.json'),
             instructionFiles,
         };
@@ -475,7 +478,8 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Claude Code',
-            configPath: join(getWorkspaceRoot(), '.mcp.json'),
+            workspaceRoot,
+            configPath: join(workspaceRoot, '.mcp.json'),
             instructionFiles,
         };
     }
@@ -483,6 +487,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Claude Desktop',
+            workspaceRoot,
             configPath: resolveClaudeDesktopConfigPath(),
             instructionFiles,
         };
@@ -491,6 +496,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Opencode',
+            workspaceRoot,
             configPath: join(homedir(), '.config', 'opencode', 'opencode.json'),
             instructionFiles,
         };
@@ -499,6 +505,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Windsurf',
+            workspaceRoot,
             configPath: join(homedir(), '.windsurf', 'mcp.json'),
             instructionFiles,
         };
@@ -507,6 +514,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Antigravity / OpenClaw',
+            workspaceRoot,
             configPath: join(homedir(), '.antigravity', 'mcp.json'),
             instructionFiles,
         };
@@ -515,6 +523,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Aider',
+            workspaceRoot,
             configPath: join(homedir(), '.aider', 'mcp.json'),
             instructionFiles,
         };
@@ -523,6 +532,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'Continue.dev',
+            workspaceRoot,
             configPath: join(homedir(), '.continue', 'config.json'),
             instructionFiles,
         };
@@ -531,6 +541,7 @@ function getSetupDefinition(clientId) {
         return {
             id: clientId,
             label: 'OpenClaw',
+            workspaceRoot,
             configPath: join(homedir(), '.openclaw', 'openclaw.json'),
             instructionFiles,
         };
@@ -538,6 +549,7 @@ function getSetupDefinition(clientId) {
     return {
         id: clientId,
         label: 'Cline',
+        workspaceRoot,
         configPath: join(homedir(), '.vscode', 'cline-mcp.json'),
         instructionFiles,
     };
@@ -548,10 +560,10 @@ function installSetup(definition) {
             writeCodexMcpConfig(definition.configPath);
         }
         else if (definition.id === 'opencode') {
-            writeOpencodeConfig(definition.configPath, getWorkspaceRoot());
+            writeOpencodeConfig(definition.configPath, definition.workspaceRoot);
         }
         else {
-            writeStandardMcpConfig(definition.configPath, getWorkspaceRoot());
+            writeStandardMcpConfig(definition.configPath, definition.workspaceRoot);
         }
     }
     for (const file of definition.instructionFiles) {
@@ -585,12 +597,12 @@ function printSetupPreview(definition) {
             console.log(JSON.stringify(definition.id === 'opencode'
                 ? {
                     mcp: {
-                        servers: [{ id: 'nexus-prime', ...buildStandardMcpServerConfig(getWorkspaceRoot()) }]
+                        servers: [{ id: 'nexus-prime', ...buildStandardMcpServerConfig(definition.workspaceRoot) }]
                     }
                 }
                 : {
                     mcpServers: {
-                        'nexus-prime': buildStandardMcpServerConfig(getWorkspaceRoot())
+                        'nexus-prime': buildStandardMcpServerConfig(definition.workspaceRoot)
                     }
                 }, null, 2));
         }
@@ -612,10 +624,10 @@ function hasExpectedConfig(definition) {
             return false;
         if (definition.id === 'opencode') {
             const server = parsed?.mcp?.['nexus-prime'];
-            return Boolean(server && isStableNexusMcpServerConfig(server, 'environment'));
+            return Boolean(server && isStableNexusMcpServerConfig(server, 'environment', definition.workspaceRoot));
         }
         const server = parsed?.mcpServers?.['nexus-prime'];
-        return Boolean(server && isStableNexusMcpServerConfig(server));
+        return Boolean(server && isStableNexusMcpServerConfig(server, 'env', definition.workspaceRoot));
     }
     catch {
         return false;
@@ -705,11 +717,11 @@ program
     .description('Start Nexus Prime daemon')
     .option('--force', 'Force restart if already running')
     .action(async (options) => {
-    const workspaceContext = resolveWorkspaceContext({ workspaceRoot: getWorkspaceRoot() });
     try {
         const record = await ensureDaemonManaged({ force: options.force });
+        const dashboardPort = process.env.NEXUS_DASHBOARD_PORT ?? '3377';
         console.log(`Nexus Prime daemon running (pid ${record.pid}, ${formatDaemonAddress(record)})`);
-        console.log(`Dashboard: http://localhost:3377`);
+        console.log(`Dashboard: http://localhost:${dashboardPort}`);
     }
     catch (err) {
         console.error(`Failed to start daemon: ${err.message}`);

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

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

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

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

package/dist/dashboard/routes/architects.js

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