nexus-prime 7.9.21 → 7.9.23

package/dist/engines/orchestrator.js

@@ -35,6 +35,15 @@ import { resolveWorkspaceContext } from './workspace-resolver.js';
 import { resolveWorkspaceStateRoot } from './workspace-resolver.js';
 import { bootstrapFast, hasValidBootstrapReceipt, writeBootstrapReceipt, buildRepoIdentity, } from './bootstrap/index.js';
 import { GhostPass, createSubAgentRuntime, } from '../phantom/index.js';
+function deferNexusEvent(type, payload) {
+    const handle = setImmediate(() => {
+        try {
+            nexusEventBus.emit(type, payload);
+        }
+        catch { /* advisory telemetry must not block orchestration */ }
+    });
+    handle.unref?.();
+}
 // ─── Types and constants (extracted to orchestrator/types.ts) ─────────────────
 export * from './orchestrator/types.js';
 import { MAX_AUTONOMY_HISTORY, MAX_DISCOVERED_FILES, DISCOVERY_EXTENSIONS, DISCOVERY_IGNORES, DISCOVERY_FILENAME_SKIPS, DISCOVERY_BINARY_EXTENSIONS, DISCOVERY_DEFAULT_MAX_FILE_BYTES, } from './orchestrator/types.js';
@@ -81,6 +90,8 @@ export class OrchestratorEngine {
     workflowCatalogCache;
     hookCatalogCache;
     automationCatalogCache;
+    clientSnapshotCache;
+    CLIENT_SNAPSHOT_CACHE_TTL_MS = 1_000;
     specialistCatalogItems;
     crewCatalogItems;
     crGraphClient;
@@ -203,7 +214,7 @@ export class OrchestratorEngine {
             this.agents.set(id, agent);
             inductedAgents.push(agent);
         }
-        nexusEventBus.emit('nexusnet.sync', { newItemsCount: inductedAgents.length });
+        deferNexusEvent('nexusnet.sync', { newItemsCount: inductedAgents.length });
         return inductedAgents;
     }
     decomposeTask(task) {
@@ -321,7 +332,7 @@ export class OrchestratorEngine {
         });
         const selections = await this.resolveSelections(task, intent, planner, knowledgeFabric, options);
         const catalogHealth = this.scanCatalogHealth(selections);
-        const tokenBudget = toSourceAwareTokenBudget(knowledgeFabric, plannedFiles, 'knowledge-fabric-source-aware-budget');
+        const tokenBudget = toSourceAwareTokenBudget(knowledgeFabric, plannedFiles, 'knowledge-fabric-source-aware-budget', task);
         const workerCount = decideWorkers(options.workers, planner.swarmDecision.workers, phases.length, intent, this.sessionState.repeatedFailures, knowledgeFabric);
         const mode = determineMode(intent, phases.length, workerCount, this.sessionState.repeatedFailures);
         const taskGraph = buildTaskGraph(task, phases, intent);
@@ -1245,6 +1256,8 @@ export class OrchestratorEngine {
                 estimatedCompressionPct: tokenPlan && tokenPlan.totalEstimatedTokens + tokenPlan.savings > 0
                     ? Math.round((tokenPlan.savings / (tokenPlan.totalEstimatedTokens + tokenPlan.savings)) * 100)
                     : 0,
+                codeBlockTemplates: tokenBudget.codeBlocks?.templates,
+                codeBlockReservedTokens: tokenBudget.codeBlocks?.reservedTokens,
             },
             memoryMatches,
             memoryStats,
@@ -1589,19 +1602,27 @@ export class OrchestratorEngine {
         return RunManagement.pruneStaleAutonomySessions(this._runMgrCtx());
     }
     resolvePrimaryClient() {
-        const primary = this.clientRegistry?.getPrimaryClient?.();
-        if (primary)
-            return this.toClientSnapshot(primary);
-        const detected = this.detectCurrentClientFromEnv();
-        return detected ? this.toClientSnapshot(detected) : undefined;
+        return this.getClientSnapshot().primary;
     }
     listDetectedClients() {
-        const clients = this.clientRegistry?.listClients?.() ?? [];
-        if (clients.length === 0) {
-            const detected = this.detectCurrentClientFromEnv();
-            return detected ? [this.toClientSnapshot(detected)] : [];
-        }
-        return clients.map((client) => this.toClientSnapshot(client));
+        return this.getClientSnapshot().clients;
+    }
+    getClientSnapshot() {
+        const now = Date.now();
+        if (this.clientSnapshotCache && now - this.clientSnapshotCache.ts < this.CLIENT_SNAPSHOT_CACHE_TTL_MS) {
+            return this.clientSnapshotCache;
+        }
+        const records = this.clientRegistry?.listClients?.() ?? [];
+        const clients = records.length > 0
+            ? records.map((client) => this.toClientSnapshot(client))
+            : (() => {
+                const detected = this.detectCurrentClientFromEnv();
+                return detected ? [this.toClientSnapshot(detected)] : [];
+            })();
+        const primary = clients.find((client) => client.state === 'primaryActive')
+            ?? clients.find((client) => client.state !== 'offline');
+        this.clientSnapshotCache = { ts: now, primary, clients };
+        return this.clientSnapshotCache;
     }
     detectCurrentClientFromEnv() {
         if (process.env.CODEX_HOME || process.env.CODEX_SESSION) {
@@ -1669,6 +1690,45 @@ export class OrchestratorEngine {
                 lastSeen: Date.now(),
             };
         }
+        if (process.env.HERMES_HOME || process.env.HERMES_SESSION) {
+            return {
+                clientId: 'hermes',
+                displayName: 'Hermes',
+                state: 'primaryActive',
+                source: 'manual',
+                inferred: false,
+                confidence: 1,
+                evidence: ['env:HERMES detected'],
+                metadata: {},
+                lastSeen: Date.now(),
+            };
+        }
+        if (process.env.NANOCLAW_HOME || process.env.NANOCLAW_SESSION) {
+            return {
+                clientId: 'nanoclaw',
+                displayName: 'NanoClaw',
+                state: 'primaryActive',
+                source: 'manual',
+                inferred: false,
+                confidence: 1,
+                evidence: ['env:NANOCLAW detected'],
+                metadata: {},
+                lastSeen: Date.now(),
+            };
+        }
+        if (process.env.PICOCLAW_HOME || process.env.PICOCLAW_SESSION) {
+            return {
+                clientId: 'picoclaw',
+                displayName: 'PicoClaw',
+                state: 'primaryActive',
+                source: 'manual',
+                inferred: false,
+                confidence: 1,
+                evidence: ['env:PICOCLAW detected'],
+                metadata: {},
+                lastSeen: Date.now(),
+            };
+        }
         if (process.env.WINDSURF_HOME || process.env.WINDSURF_SESSION) {
             return {
                 clientId: 'windsurf',

package/dist/engines/peer-connectors.d.ts

@@ -29,7 +29,7 @@ export interface PeerProfile {
 export declare function detectAtlasFoundation(): AtlasFoundationState;
 /**
  * Scans standard paths in the user's home directory to dynamically
- * discover peer AI agent ecosystems like OpenClaw, Hermes, PicoClaw, or Atlas.
+ * discover peer AI agent ecosystems like OpenClaw, Hermes, NanoClaw, PicoClaw, or Atlas.
  *
  * @returns Array of detected peer profiles
  */

package/dist/engines/peer-connectors.js

@@ -64,24 +64,31 @@ export function detectAtlasFoundation() {
 }
 /**
  * Scans standard paths in the user's home directory to dynamically
- * discover peer AI agent ecosystems like OpenClaw, Hermes, PicoClaw, or Atlas.
+ * discover peer AI agent ecosystems like OpenClaw, Hermes, NanoClaw, PicoClaw, or Atlas.
  *
  * @returns Array of detected peer profiles
  */
 export async function detectAllPeers() {
     const home = os.homedir();
     const peers = [];
+    const seenPeerIds = new Set();
     const candidates = [
         { id: 'openclaw', relativeConfig: '.openclaw/openclaw.json' },
         { id: 'hermes', relativeConfig: '.hermes/config.yaml' },
+        { id: 'hermes', relativeConfig: '.hermes/mcp.json' },
+        { id: 'nanoclaw', relativeConfig: '.nanoclaw/mcp.json' },
         { id: 'picoclaw', relativeConfig: '.picoclaw/config.yaml' },
+        { id: 'picoclaw', relativeConfig: '.picoclaw/mcp.json' },
         { id: 'opencode', relativeConfig: '.config/opencode/opencode.json' },
     ];
     for (const c of candidates) {
         const fullPath = path.join(home, c.relativeConfig);
         try {
             if (fs.existsSync(fullPath)) {
-                const capabilities = ['skill-sharing', 'memory-sync', 'tool-relay'];
+                if (seenPeerIds.has(c.id))
+                    continue;
+                seenPeerIds.add(c.id);
+                const capabilities = ['skill-sharing', 'memory-sync', 'tool-relay', 'token-budgeting', 'workforce-hiring'];
                 peers.push({
                     id: c.id,
                     configPath: fullPath,

package/dist/engines/runtime-registry.d.ts

@@ -194,6 +194,15 @@ export interface RuntimeSourceAwareTokenBudgetSnapshot {
         reason: string;
     }>;
     dominantSource?: string;
+    codeBlocks?: {
+        requested: boolean;
+        detectedBlocks: number;
+        reservedTokens: number;
+        templates: string[];
+        languages: string[];
+    };
+    qualityGates?: string[];
+    recommendations?: string[];
 }
 export interface RuntimeTaskGraphPhase {
     id: string;

package/dist/index.js

@@ -1192,6 +1192,15 @@ function detectCurrentClient() {
     if (process.env.OPENCLAW_HOME || process.env.ANTIGRAVITY_HOME) {
         return { clientId: 'antigravity', source: 'env' };
     }
+    if (process.env.HERMES_HOME || process.env.HERMES_SESSION) {
+        return { clientId: 'hermes', source: 'env' };
+    }
+    if (process.env.NANOCLAW_HOME || process.env.NANOCLAW_SESSION) {
+        return { clientId: 'nanoclaw', source: 'env' };
+    }
+    if (process.env.PICOCLAW_HOME || process.env.PICOCLAW_SESSION) {
+        return { clientId: 'picoclaw', source: 'env' };
+    }
     if (process.env.WINDSURF_HOME || process.env.WINDSURF_SESSION) {
         return { clientId: 'windsurf', source: 'env' };
     }

package/dist/install/state-locator.d.ts

@@ -36,7 +36,7 @@ export interface NgramArchiveEntry {
 export declare function enumerateNgramArchives(stateDir?: string): NgramArchiveEntry[];
 /** Known IDE registration targets discovered in a workspace + home dir. */
 export interface RegistrationTarget {
-    id: 'aider' | 'antigravity' | 'claude-desktop' | 'claude-home' | 'claude-workspace' | 'cline' | 'codex-json' | 'codex-toml' | 'continue' | 'cursor-home' | 'cursor-workspace' | 'opencode' | 'openclaw' | 'vscode-workspace' | 'windsurf';
+    id: 'aider' | 'antigravity' | 'claude-desktop' | 'claude-home' | 'claude-workspace' | 'cline' | 'codex-json' | 'codex-toml' | 'continue' | 'cursor-home' | 'cursor-workspace' | 'hermes' | 'nanoclaw' | 'opencode' | 'openclaw' | 'picoclaw' | 'vscode-workspace' | 'windsurf';
     filePath: string;
     jsonPath: string[];
 }

package/dist/install/state-locator.js

@@ -136,6 +136,9 @@ export function enumerateRegistrationTargets(workspaceRoot, home = os.homedir())
         { id: 'windsurf', filePath: path.join(home, '.windsurf', 'mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
         { id: 'antigravity', filePath: path.join(home, '.antigravity', 'mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
         { id: 'openclaw', filePath: path.join(home, '.openclaw', 'openclaw.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
+        { id: 'hermes', filePath: path.join(home, '.hermes', 'mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
+        { id: 'nanoclaw', filePath: path.join(home, '.nanoclaw', 'mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
+        { id: 'picoclaw', filePath: path.join(home, '.picoclaw', 'mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
         { id: 'aider', filePath: path.join(home, '.aider', 'mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
         { id: 'continue', filePath: path.join(home, '.continue', 'config.json'), jsonPath: ['mcpServers', 'nexus-prime'] },
         { id: 'cline', filePath: path.join(home, '.vscode', 'cline-mcp.json'), jsonPath: ['mcpServers', 'nexus-prime'] },

package/dist/synapse/bootstrap.js

@@ -86,6 +86,9 @@ function hireOperativeDirect(db, providers, input) {
         operativeId: operative.id,
         name: operative.name,
         skillId: operative.skillId,
+        specialistId: operative.specialistId,
+        roleTitle: operative.roleTitle,
+        reportsToOperativeId: operative.reportsToOperativeId,
         strikeTeamId: operative.strikeTeamId,
     });
     storeOperationalMemory(providers, `[Synapse:Hire] ${operative.name} hired as ${operative.roleTitle ?? 'Operative'}`, ['#hire'], {

package/dist/synapse/mandate/pipeline.js

@@ -10,6 +10,17 @@ import { safePublish } from '../coordination/safe-publish.js';
 function unique(values) {
     return [...new Set(values)];
 }
+function boundedRequestedOperatives(opts) {
+    const requested = Number(opts.maxOperatives ?? SynapseConfig.maxOpsPerTeam);
+    const safeRequested = Number.isFinite(requested) && requested > 0 ? Math.floor(requested) : SynapseConfig.maxOpsPerTeam;
+    return Math.max(1, Math.min(safeRequested, SynapseConfig.maxOpsPerTeam));
+}
+function decideMandateOperativeCount(signals, matched, missionTitles, opts) {
+    const requested = boundedRequestedOperatives(opts);
+    const evidenceCount = Math.max(matched.skills.length, matched.specialists.length, missionTitles.length);
+    const complexityFloor = signals.complexity === 'read' ? 1 : 2;
+    return Math.max(1, Math.min(requested, Math.max(evidenceCount || 1, complexityFloor)));
+}
 function deriveMissionTitles(mandateText, complexity, hints, planner) {
     const plannerHints = [
         ...planner.plannerState.selectedSpecialists.map((specialist) => `Coordinate with ${specialist.name}`),
@@ -29,7 +40,7 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
     const planner = planTask({
         goal: mandateText,
         files: [],
-        workers: Math.max(2, Math.min(opts.maxOperatives ?? SynapseConfig.maxOpsPerTeam, SynapseConfig.maxOpsPerTeam)),
+        workers: Math.max(2, boundedRequestedOperatives(opts)),
         roles: ['planner', 'coder'],
         strategies: ['standard'],
         verifyCommands: [],
@@ -63,7 +74,7 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
         manualOverrides: [],
     });
     const missionTitles = deriveMissionTitles(mandateText, signals.complexity, signals.subGoalHints, planner);
-    const maxOps = Math.min(opts.maxOperatives ?? SynapseConfig.maxOpsPerTeam, Math.max(1, matched.skills.length || 1));
+    const maxOps = decideMandateOperativeCount(signals, matched, missionTitles, opts);
     const budget = opts.budgetUsd ?? SynapseConfig.defaultBudgetUsd;
     const team = db.transaction(() => {
         const teamId = randomUUID();
@@ -71,9 +82,11 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
         const worklistId = providers.coordination?.getWorklistId(teamId) ?? null;
         const blueprintId = worklistId ? `implicit-blueprint:${teamId}` : null;
         let leadOperativeId = null;
+        const hiringPlan = [];
+        const missionPlan = [];
         const operativeIds = Array.from({ length: maxOps }, (_, index) => {
-            const skill = matched.skills[index] ?? matched.skills[0];
-            const specialist = matched.specialists[index] ?? matched.specialists[0] ?? null;
+            const skill = matched.skills.length > 0 ? matched.skills[index % matched.skills.length] : undefined;
+            const specialist = matched.specialists.length > 0 ? matched.specialists[index % matched.specialists.length] : null;
             const operative = insertOperative(db, {
                 id: randomUUID(),
                 name: `operative-${teamId.slice(0, 4)}-${index + 1}`,
@@ -89,10 +102,22 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
             });
             if (index === 0)
                 leadOperativeId = operative.id;
+            hiringPlan.push({
+                operativeId: operative.id,
+                name: operative.name,
+                roleTitle: operative.roleTitle,
+                skillId: operative.skillId,
+                specialistId: operative.specialistId,
+                reportsToOperativeId: operative.reportsToOperativeId,
+                budgetCapUsd: operative.budgetCapUsd,
+            });
             nexusEventBus.emit('synapse.operative.hired', {
                 operativeId: operative.id,
                 name: operative.name,
                 skillId: operative.skillId,
+                specialistId: operative.specialistId,
+                roleTitle: operative.roleTitle,
+                reportsToOperativeId: operative.reportsToOperativeId,
                 strikeTeamId: teamId,
             });
             return operative.id;
@@ -115,6 +140,13 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
                 budgetScopeId: teamId,
             });
             updateOperativeMission(db, operativeId, mission.id, teamId);
+            missionPlan.push({
+                missionId: mission.id,
+                title: mission.title,
+                assignedOperativeId: operativeId,
+                complexity: mission.complexity,
+                requiresApprovalGate: mission.requiresApprovalGate,
+            });
             nexusEventBus.emit('synapse.mission.assigned', {
                 operativeId,
                 missionId: mission.id,
@@ -135,6 +167,15 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
             }, 'mandate');
             return mission.id;
         });
+        const selectionSummary = {
+            domains: signals.domains,
+            complexity: signals.complexity,
+            skills: unique(matched.skills.slice(0, maxOps).map((skill) => skill.name).filter(Boolean)),
+            specialists: unique(matched.specialists.slice(0, maxOps).map((specialist) => specialist.name).filter(Boolean)),
+            workflows: unique(planner.plannerState.selectedWorkflows),
+            operativeCount: operativeIds.length,
+            missionCount: missionIds.length,
+        };
         insertStrikeTeam(db, {
             id: teamId,
             mandateText,
@@ -147,6 +188,7 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
             strikeTeamId: teamId,
             operativeCount: operativeIds.length,
             missionCount: missionIds.length,
+            selectionSummary,
             worklistId,
             correlationId: teamId,
         });
@@ -164,7 +206,12 @@ export async function executeMandatePipeline(db, mandateText, providers, opts =
                 containerTags: [`#team:${teamId}`, ...(worklistId ? [`#worklist:${worklistId}`] : [])],
             },
         });
-        return getStrikeTeam(db, teamId);
+        return {
+            ...getStrikeTeam(db, teamId),
+            selectionSummary,
+            hiringPlan,
+            missionPlan,
+        };
     })();
     nexusEventBus.emit('synapse.striketeam.finished', {
         strikeTeamId: team.id,

package/dist/synapse/sorties/runner.js

@@ -57,6 +57,15 @@ function createSyntheticSortie(db, operative, mission, status) {
         completedAt: new Date().toISOString(),
     });
 }
+function extractWorkflowSelectorsFromMission(title) {
+    const selectors = new Set();
+    for (const match of title.matchAll(/Execute workflow:\s*([^.;\n]+)/gi)) {
+        const selector = match[1]?.trim();
+        if (selector)
+            selectors.add(selector);
+    }
+    return [...selectors];
+}
 export async function runSortie(db, operative, providers) {
     const mission = getMission(db, operative.missionId);
     if (!mission) {
@@ -138,10 +147,33 @@ export async function runSortie(db, operative, providers) {
         });
     }
     try {
+        const workflowSelectors = extractWorkflowSelectorsFromMission(mission.title);
+        nexusEventBus.emit('synapse.sortie.selection', {
+            sortieId: sortie.id,
+            operativeId: operative.id,
+            missionId: mission.id,
+            strikeTeamId: mission.strikeTeamId,
+            skillId: operative.skillId,
+            specialistId: operative.specialistId,
+            workflowSelectors,
+            workerCount: 1,
+        });
+        safePublish(providers.coordination, {
+            phase: 'sortie',
+            summary: `Selection for ${mission.title}: skill=${operative.skillId ?? 'none'} specialist=${operative.specialistId ?? 'none'} workflows=${workflowSelectors.join(', ') || 'none'}`,
+            strikeTeamId: mission.strikeTeamId,
+            worklistId,
+            workItemId: mission.id,
+            operativeId: operative.id,
+            sortieId: sortie.id,
+            correlationId,
+            status: 'selected',
+        });
         const execution = await providers.orchestrator.orchestrate(goal, {
             files: [],
             workers: 1,
             skillNames: operative.skillId ? [operative.skillId] : [],
+            workflowSelectors,
             specialistSelectors: operative.specialistId ? [operative.specialistId] : [],
             executionMode: 'autonomous',
         });

package/dist/synapse/types.d.ts

@@ -61,6 +61,22 @@ export interface OperativeUpdateInput {
     strikeTeamId?: string | null;
     reason?: string | null;
 }
+export interface StrikeTeamHiringPlanEntry {
+    operativeId: string;
+    name: string;
+    roleTitle: string | null;
+    skillId: string | null;
+    specialistId: string | null;
+    reportsToOperativeId: string | null;
+    budgetCapUsd: number;
+}
+export interface StrikeTeamMissionPlanEntry {
+    missionId: string;
+    title: string;
+    assignedOperativeId: string;
+    complexity: MissionComplexity;
+    requiresApprovalGate: boolean;
+}
 export interface StrikeTeam {
     id: string;
     mandateText: string;
@@ -69,6 +85,17 @@ export interface StrikeTeam {
     blueprintId: string | null;
     status: 'deploying' | 'active' | 'converging' | 'done' | 'standdown';
     createdAt: string;
+    selectionSummary?: {
+        domains: string[];
+        complexity: MissionComplexity;
+        skills: string[];
+        specialists: string[];
+        workflows: string[];
+        operativeCount: number;
+        missionCount: number;
+    };
+    hiringPlan?: StrikeTeamHiringPlanEntry[];
+    missionPlan?: StrikeTeamMissionPlanEntry[];
 }
 export interface Mission {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.21",
+  "version": "7.9.23",
   "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",