nexus-prime 7.9.22 → 7.9.23

package/dist/agents/adapters/ide-compat.d.ts

@@ -2,10 +2,10 @@
  * Nexus Prime — IDE Compatibility Utilities
  * Provides MCP config templates and detection logic for all supported IDEs.
  *
- * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex
+ * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex, and peer agent clients.
  */
-export type IDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'cline' | 'zed' | 'codex';
-export type CallerIDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'zed' | 'codex';
+export type IDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'cline' | 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'zed' | 'codex';
+export type CallerIDEId = 'claude-code' | 'cursor' | 'windsurf' | 'continue' | 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'zed' | 'codex';
 export interface McpConfigOutput {
     /** Absolute path where the config should be written */
     configPath: string | null;

package/dist/agents/adapters/ide-compat.js

@@ -2,7 +2,7 @@
  * Nexus Prime — IDE Compatibility Utilities
  * Provides MCP config templates and detection logic for all supported IDEs.
  *
- * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex
+ * Supported: VS Code (Claude Code ext), JetBrains, Cursor, Windsurf, Zed, Continue.dev, Aider, Cline, Codex, and peer agent clients.
  */
 import { existsSync } from 'fs';
 import { homedir } from 'os';
@@ -29,6 +29,18 @@ function detectCallerIDEFromEnv() {
     if (hasAnyEnvPrefix('WINDSURF_')) {
         return 'windsurf';
     }
+    if (hasAnyEnvPrefix('OPENCLAW_') || hasAnyEnvPrefix('ANTIGRAVITY_')) {
+        return 'openclaw';
+    }
+    if (hasAnyEnvPrefix('HERMES_')) {
+        return 'hermes';
+    }
+    if (hasAnyEnvPrefix('NANOCLAW_')) {
+        return 'nanoclaw';
+    }
+    if (hasAnyEnvPrefix('PICOCLAW_')) {
+        return 'picoclaw';
+    }
     if (hasAnyEnvPrefix('CONTINUE_')) {
         return 'continue';
     }
@@ -46,6 +58,14 @@ function detectCallerIDEFromFilesystem(startDir) {
             return 'continue';
         if (existsSync(join(current, '.windsurf')))
             return 'windsurf';
+        if (existsSync(join(current, '.openclaw')))
+            return 'openclaw';
+        if (existsSync(join(current, '.hermes')))
+            return 'hermes';
+        if (existsSync(join(current, '.nanoclaw')))
+            return 'nanoclaw';
+        if (existsSync(join(current, '.picoclaw')))
+            return 'picoclaw';
         if (existsSync(join(current, '.zed')))
             return 'zed';
         const parent = dirname(current);
@@ -84,6 +104,22 @@ export function detectInstalledIDEs(workspaceRoot) {
         existsSync(join(home, '.windsurf'))) {
         detected.push('windsurf');
     }
+    if (existsSync(join(workspaceRoot, '.openclaw')) ||
+        existsSync(join(home, '.openclaw'))) {
+        detected.push('openclaw');
+    }
+    if (existsSync(join(workspaceRoot, '.hermes')) ||
+        existsSync(join(home, '.hermes'))) {
+        detected.push('hermes');
+    }
+    if (existsSync(join(workspaceRoot, '.nanoclaw')) ||
+        existsSync(join(home, '.nanoclaw'))) {
+        detected.push('nanoclaw');
+    }
+    if (existsSync(join(workspaceRoot, '.picoclaw')) ||
+        existsSync(join(home, '.picoclaw'))) {
+        detected.push('picoclaw');
+    }
     // Continue.dev: .continue/ directory
     if (existsSync(join(workspaceRoot, '.continue')) ||
         existsSync(join(home, '.continue'))) {
@@ -140,6 +176,20 @@ export function getMcpConfigForIDE(ide, workspaceRoot) {
             }, null, 2);
             return { configPath, content, merge: true };
         }
+        case 'openclaw':
+        case 'hermes':
+        case 'nanoclaw':
+        case 'picoclaw': {
+            const configPath = ide === 'openclaw'
+                ? join(home, '.openclaw', 'openclaw.json')
+                : join(home, `.${ide}`, 'mcp.json');
+            const content = JSON.stringify({
+                mcpServers: {
+                    'nexus-prime': entry,
+                },
+            }, null, 2);
+            return { configPath, content, merge: true };
+        }
         case 'continue': {
             // Continue.dev uses ~/.continue/config.json
             const configPath = join(home, '.continue', 'config.json');

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

@@ -279,7 +279,10 @@ export function buildMcpToolDefinitions() {
                     crews: { type: 'array', items: { type: 'string' }, description: 'Optional hard crew selectors' },
                     specialists: { type: 'array', items: { type: 'string' }, description: 'Optional hard specialist selectors' },
                     optimizationProfile: { type: 'string', enum: ['standard', 'max'], description: 'Planner optimization profile override' },
-                    executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset that maps orchestration depth, verification strictness, and backend routing' }
+                    executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset that maps orchestration depth, verification strictness, and backend routing' },
+                    background: { type: 'boolean', description: 'When true, return a queued receipt immediately and let the run continue in the async gate.' },
+                    async: { type: 'boolean', description: 'Alias for background; useful for clients that prefer explicit async orchestration.' },
+                    waitMs: { type: 'number', description: 'Optional bounded wait before returning a queued receipt. Clamped to 45 seconds; normal orchestrate calls default to 15 seconds.' }
                 },
                 required: ['prompt'],
             },

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

@@ -16,9 +16,18 @@ import { handleMiscGroup } from './handlers/misc.js';
 import { handleWorkforceGroup } from './handlers/workforce.js';
 import { nexusEventBus } from '../../../engines/event-bus.js';
 import { recordToolInvocation } from './tool-health.js';
-import { withAsyncGate } from './async-gate.js';
+import { getAsyncGate, withAsyncGate } from './async-gate.js';
 import { getCircuitManager, checkBackpressure } from './circuit.js';
-import { createRun } from '../../../engines/orchestrator/store.js';
+import { completeRun, createRun, failRun, updateStage } from '../../../engines/orchestrator/store.js';
+function summarizeAsyncMcpResult(toolName, result) {
+    const text = result?.content
+        ?.map((part) => part?.type === 'text' ? String(part.text ?? '') : '')
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+    const firstLine = text?.split('\n').find((line) => line.trim())?.trim();
+    return (firstLine ? `${toolName}: ${firstLine}` : `${toolName} completed asynchronously`).slice(0, 1024);
+}
 /** Tools that may exceed the MCP client timeout (~60s). Wrap in async gate. */
 const SLOW_TOOLS = new Set([
     'nexus_orchestrate',
@@ -69,6 +78,37 @@ const TOOL_ETA_MS = {
     nexus_autofix: 45_000,
     nexus_hypertune_max: 45_000,
 };
+const DEFAULT_MAX_SYNC_MS = 2000;
+const ORCHESTRATE_DEFAULT_MAX_SYNC_MS = 15_000;
+const MAX_CLIENT_SYNC_WAIT_MS = 45_000;
+function isTruthyFlag(value) {
+    if (value === true)
+        return true;
+    if (typeof value === 'number')
+        return value > 0;
+    if (typeof value === 'string')
+        return ['1', 'true', 'yes', 'on'].includes(value.trim().toLowerCase());
+    return false;
+}
+function coerceBoundedWaitMs(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0)
+        return undefined;
+    return Math.min(MAX_CLIENT_SYNC_WAIT_MS, Math.floor(numeric));
+}
+function shouldReturnQueuedReceipt(toolName, args) {
+    if (!SLOW_TOOLS.has(toolName))
+        return false;
+    return isTruthyFlag(args.background)
+        || isTruthyFlag(args.async)
+        || isTruthyFlag(args.queue)
+        || isTruthyFlag(args.detach);
+}
+function resolveMaxSyncMs(toolName, args) {
+    return coerceBoundedWaitMs(args.waitMs)
+        ?? coerceBoundedWaitMs(args.maxSyncMs)
+        ?? (toolName === 'nexus_orchestrate' ? ORCHESTRATE_DEFAULT_MAX_SYNC_MS : DEFAULT_MAX_SYNC_MS);
+}
 /**
  * Route a tool call to the appropriate handler group.
  *
@@ -127,9 +167,9 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
             }, {
                 tool: toolName,
                 args,
-                maxSyncMs: 2000,
+                maxSyncMs: resolveMaxSyncMs(toolName, args),
                 etaMs: TOOL_ETA_MS[toolName],
-                alwaysQueue: toolName === 'nexus_orchestrate',
+                alwaysQueue: shouldReturnQueuedReceipt(toolName, args),
             });
             if ('queued' in gated && gated.queued) {
                 // Persist orchestration run record for durable stage tracking
@@ -138,6 +178,7 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                     const client = hctx.getToolProfile();
                     try {
                         createRun(gated.runId, goal, client);
+                        updateStage(gated.runId, 'executing', 20);
                     }
                     catch { /* non-fatal */ }
                 }
@@ -147,8 +188,24 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                 const runId = gated.runId;
                 let unsubOk = null;
                 let unsubFail = null;
+                let finalized = false;
                 const finalize = (success) => {
+                    if (finalized)
+                        return;
+                    finalized = true;
                     const durationMs = Date.now() - startedAt;
+                    if (toolName === 'nexus_orchestrate') {
+                        try {
+                            const job = getAsyncGate().getJob(runId);
+                            if (success) {
+                                completeRun(runId, summarizeAsyncMcpResult(toolName, job?.result));
+                            }
+                            else {
+                                failRun(runId, job?.error ?? `${toolName} failed asynchronously`);
+                            }
+                        }
+                        catch { /* durable run updates are best-effort */ }
+                    }
                     try {
                         circuit.recordComplete(toolName, durationMs, success);
                     }
@@ -166,6 +223,11 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                     if (ev.runId === runId)
                         finalize(false);
                 });
+                const existingJob = getAsyncGate().getJob(runId);
+                if (existingJob?.status === 'completed')
+                    finalize(true);
+                if (existingJob?.status === 'failed')
+                    finalize(false);
                 // Return async receipt as MCP text so agent can poll
                 rawResult = {
                     content: [{

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

@@ -55,6 +55,82 @@ export function extractSkillSelectorsFromPrompt(prompt) {
 export function inferSpawnWorkersIntent(actions) {
     return actions.length > 0 ? 'mutate' : 'plan';
 }
+function namedValue(value) {
+    if (typeof value === 'string')
+        return value.trim();
+    if (!value || typeof value !== 'object')
+        return '';
+    const record = value;
+    return String(record.name ?? record.id ?? record.specialistId ?? record.skillId ?? record.workflowId ?? record.crewId ?? record.workerId ?? '').trim();
+}
+function asStringList(values, limit = 8) {
+    const array = Array.isArray(values) ? values : values ? [values] : [];
+    return [...new Set(array.map(namedValue).filter(Boolean))].slice(0, limit);
+}
+function formatSelectionList(values, fallback = 'none') {
+    return values.length > 0 ? values.join(', ') : fallback;
+}
+function formatModelRoute(route) {
+    if (!route)
+        return 'default runtime route';
+    const worker = String(route.workerTier ?? 'T1');
+    const reviewer = route.reviewerTier ? ` + reviewer ${route.reviewerTier}` : '';
+    const reason = route.reason ? ` - ${route.reason}` : '';
+    return `${worker}${reviewer}${reason}`;
+}
+function formatBudgetRoute(plan) {
+    const budgets = plan?.budgets ?? {};
+    const policy = plan?.executionPolicy?.agentFlow ?? {};
+    const total = Number(budgets.totalTokens ?? 0);
+    const codeBlocks = Number(budgets.codeBlocks ?? budgets.codeBlockPolicy?.reservedTokens ?? 0);
+    const cap = Number(policy.maxTaskCostUsd ?? 0);
+    const parts = [
+        total > 0 ? `${total.toLocaleString()} tokens` : 'budget pending',
+        codeBlocks > 0 ? `${codeBlocks.toLocaleString()} code-block tokens` : null,
+        cap > 0 ? `$${cap.toFixed(2)} task cap` : null,
+    ].filter(Boolean);
+    return parts.join(' · ');
+}
+function buildSelectionSummary(execution, runtimeUsage) {
+    const selectionPlan = execution.selectionPlan ?? {};
+    const selected = selectionPlan.selected ?? {};
+    const planner = execution.plannerState ?? {};
+    const taskGraph = runtimeUsage.taskGraph ?? execution.taskGraph ?? {};
+    const workerPlan = runtimeUsage.workerPlan ?? execution.workerPlan ?? {};
+    const audit = runtimeUsage.artifactSelectionAudit ?? execution.artifactSelectionAudit ?? {};
+    const crew = asStringList(selected.crews, 2)[0]
+        ?? namedValue(planner.selectedCrew)
+        ?? 'baseline path';
+    const specialists = asStringList(selected.specialists, 8).length > 0
+        ? asStringList(selected.specialists, 8)
+        : asStringList(planner.selectedSpecialists, 8);
+    const skills = asStringList(selected.skills, 8).length > 0
+        ? asStringList(selected.skills, 8)
+        : asStringList(execution.activeSkills, 8).concat(asStringList(planner.selectedSkills, 8)).slice(0, 8);
+    const workflows = asStringList(selected.workflows, 8).length > 0
+        ? asStringList(selected.workflows, 8)
+        : asStringList(execution.activeWorkflows, 8).concat(asStringList(planner.selectedWorkflows, 8)).slice(0, 8);
+    const workers = asStringList(selected.workers, 8).length > 0
+        ? asStringList(selected.workers, 8)
+        : asStringList(execution.workerManifests, 8);
+    return {
+        crew,
+        specialists,
+        skills: [...new Set(skills)],
+        workflows: [...new Set(workflows)],
+        hooks: asStringList(selected.hooks, 8),
+        automations: asStringList(selected.automations, 8),
+        workers,
+        modelRoute: selectionPlan.modelRoute ?? execution.requestBrief?.modelPolicy,
+        budgetRoute: formatBudgetRoute(selectionPlan),
+        agentFlow: selectionPlan.executionPolicy?.agentFlow,
+        phaseCount: Array.isArray(taskGraph.phases) ? taskGraph.phases.length : 0,
+        workerLaneCount: Number(workerPlan.totalWorkers ?? workers.length ?? execution.workerResults?.length ?? 0),
+        mode: String(workerPlan.mode ?? execution.mode ?? 'autonomous'),
+        auditSelected: Array.isArray(audit.selected) ? audit.selected.length : 0,
+        auditRejected: Array.isArray(audit.rejected) ? audit.rejected.length : 0,
+    };
+}
 export async function handleOrchestrationGroup(toolName, hctx, request, args, ctx) {
     const runtimeError = requireRuntime(hctx);
     if (runtimeError)
@@ -457,6 +533,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     result.modifiedFiles.forEach((file) => hctx.sessionDNA.recordFileModified(file));
                 });
                 const runtimeUsage = hctx.getRuntime().getUsageSnapshot();
+                const selectionSummary = buildSelectionSummary(execution, runtimeUsage);
                 hctx.sessionDNA.recordDecision('Orchestrated autonomous run completed', execution.result || summarizeExecution(execution), execution.state === 'merged' ? 0.95
                     : execution.state === 'inspected' ? 0.85
                         : execution.state === 'rolled_back' ? 0.55
@@ -491,6 +568,8 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     worktreeHealth: runtimeUsage.worktreeHealth,
                     ragUsageSummary: runtimeUsage.ragUsageSummary ?? execution.ragUsageSummary,
                     memoryScopeUsage: runtimeUsage.memoryScopeUsage ?? execution.memoryScopeUsage,
+                    selection: selectionSummary,
+                    modelRoute: selectionSummary.modelRoute,
                     verifiedWorkers,
                     continuationChildren: execution.continuationChildren.length,
                     executionPreset: preset ? { id: preset.id, name: preset.name, summary: preset.summary } : undefined,
@@ -525,6 +604,10 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                     ragUsageSummary: runtimeUsage.ragUsageSummary ?? execution.ragUsageSummary,
                     memoryScopeUsage: runtimeUsage.memoryScopeUsage ?? execution.memoryScopeUsage,
                     memoryReconciliationSummary: runtimeUsage.memoryReconciliationSummary ?? execution.memoryReconciliationSummary,
+                    requestBrief: execution.requestBrief,
+                    selectionPlan: execution.selectionPlan,
+                    selection: selectionSummary,
+                    modelRoute: selectionSummary.modelRoute,
                     tokens: execution.tokenTelemetry,
                     verifiedWorkers,
                     continuationChildren: execution.continuationChildren,
@@ -545,6 +628,14 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                     `Run ID: ${execution.runId}`,
                                     `Summary: ${summarizeExecution(execution)}`,
                                     `Crew: ${execution.plannerState?.selectedCrew?.name || 'baseline path'}`,
+                                    `Decomposition: ${selectionSummary.phaseCount} phase(s), ${selectionSummary.workerLaneCount} worker lane(s), ${selectionSummary.mode}`,
+                                    `Hired/selected: crew ${selectionSummary.crew}; specialists ${formatSelectionList(selectionSummary.specialists)}; workflows ${formatSelectionList(selectionSummary.workflows)}; skills ${formatSelectionList(selectionSummary.skills)}`,
+                                    `Model route: ${formatModelRoute(selectionSummary.modelRoute)}`,
+                                    `Budget route: ${selectionSummary.budgetRoute || 'budget pending'}`,
+                                    selectionSummary.agentFlow?.stages?.length
+                                        ? `AgentFlow gates: ${selectionSummary.agentFlow.stages.map((stage) => `${stage.stage}:${stage.ownerRole}`).join(' -> ')}`
+                                        : null,
+                                    `Selection audit: ${selectionSummary.auditSelected} selected, ${selectionSummary.auditRejected} rejected`,
                                     `Verification: ${verifiedWorkers}/${execution.workerResults.length} worker(s) verified`,
                                     `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}%`,
                                     autoTokenApplyNote || null,

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

@@ -21,6 +21,9 @@ const CLIENT_TIMEOUTS = {
     'claude-code': 60_000,
     'cursor': 30_000,
     'openclaw': 90_000,
+    'hermes': 90_000,
+    'nanoclaw': 90_000,
+    'picoclaw': 90_000,
     'opencode': 90_000,
     'windsurf': 90_000,
     'antigravity': 90_000,

package/dist/agents/adapters/mcp/util/detect-caller.js

@@ -17,6 +17,9 @@ const ENV_MAP = [
     [['CURSOR_HOME', 'CURSOR_SESSION'], 'cursor'],
     [['OPENCODE_HOME'], 'opencode'],
     [['WINDSURF_HOME', 'WINDSURF_SESSION'], 'windsurf'],
+    [['HERMES_HOME', 'HERMES_SESSION'], 'hermes'],
+    [['NANOCLAW_HOME', 'NANOCLAW_SESSION'], 'nanoclaw'],
+    [['PICOCLAW_HOME', 'PICOCLAW_SESSION'], 'picoclaw'],
 ];
 // Module-level store for the caller name obtained from the MCP initialize
 // handshake.  Takes precedence over env-var and ps fallback once set.
@@ -52,6 +55,18 @@ export function setMcpClientName(rawName) {
         _mcpHandshakeName = 'windsurf';
         return;
     }
+    if (lower.includes('hermes')) {
+        _mcpHandshakeName = 'hermes';
+        return;
+    }
+    if (lower.includes('nanoclaw') || lower.includes('nano-claw')) {
+        _mcpHandshakeName = 'nanoclaw';
+        return;
+    }
+    if (lower.includes('picoclaw') || lower.includes('pico-claw')) {
+        _mcpHandshakeName = 'picoclaw';
+        return;
+    }
     if (lower.includes('anticlaw') || lower.includes('openclaw')) {
         _mcpHandshakeName = 'openclaw';
         return;
@@ -95,6 +110,12 @@ export async function detectCallerAsync() {
             return 'opencode';
         if (ps.includes('windsurf'))
             return 'windsurf';
+        if (ps.includes('hermes'))
+            return 'hermes';
+        if (ps.includes('nanoclaw') || ps.includes('nano-claw'))
+            return 'nanoclaw';
+        if (ps.includes('picoclaw') || ps.includes('pico-claw'))
+            return 'picoclaw';
         if (ps.includes('antigravity') || ps.includes('openclaw'))
             return 'openclaw';
     }

package/dist/agents/adapters/mcp.js

@@ -719,7 +719,7 @@ export class MCPAdapter {
                 try {
                     this.getRuntime().recordClientInstructionStatus({
                         clientId: this.name,
-                        clientFamily: this.name === 'openclaw' ? 'antigravity' : this.name,
+                        clientFamily: this.name === 'openclaw' || this.name === 'antigravity' ? 'antigravity' : this.name,
                         toolProfile: profile,
                         status: profile === 'autonomous' ? 'guided' : 'manual',
                         summary: this.describeClientInstructionStatus(profile),

package/dist/agents/adapters.d.ts

@@ -24,6 +24,15 @@ declare abstract class RenderedInstructionAdapter implements Adapter {
 export declare class OpenClawAdapter extends RenderedInstructionAdapter {
     constructor();
 }
+export declare class HermesAdapter extends RenderedInstructionAdapter {
+    constructor();
+}
+export declare class NanoClawAdapter extends RenderedInstructionAdapter {
+    constructor();
+}
+export declare class PicoClawAdapter extends RenderedInstructionAdapter {
+    constructor();
+}
 export declare class ClaudeCodeAdapter extends RenderedInstructionAdapter {
     constructor();
 }
@@ -60,5 +69,5 @@ export declare class CustomAdapter extends RenderedInstructionAdapter {
     setSendHandler(handler: (message: NetworkMessage) => Promise<void>): void;
     setReceiveHandler(handler: (message: NetworkMessage) => void): void;
 }
-export type AdapterType = 'openclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
+export type AdapterType = 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
 export declare function createAdapter(type: AdapterType, customName?: string): Adapter;

package/dist/agents/adapters.js

@@ -78,6 +78,21 @@ export class OpenClawAdapter extends RenderedInstructionAdapter {
         super('openclaw', 'openclaw');
     }
 }
+export class HermesAdapter extends RenderedInstructionAdapter {
+    constructor() {
+        super('hermes', 'hermes');
+    }
+}
+export class NanoClawAdapter extends RenderedInstructionAdapter {
+    constructor() {
+        super('nanoclaw', 'nanoclaw');
+    }
+}
+export class PicoClawAdapter extends RenderedInstructionAdapter {
+    constructor() {
+        super('picoclaw', 'picoclaw');
+    }
+}
 export class ClaudeCodeAdapter extends RenderedInstructionAdapter {
     constructor() {
         super('claude-code', 'claude-code');
@@ -158,6 +173,12 @@ export function createAdapter(type, customName) {
     switch (type) {
         case 'openclaw':
             return new OpenClawAdapter();
+        case 'hermes':
+            return new HermesAdapter();
+        case 'nanoclaw':
+            return new NanoClawAdapter();
+        case 'picoclaw':
+            return new PicoClawAdapter();
         case 'claude-code':
             return new ClaudeCodeAdapter();
         case 'ruflo':

package/dist/agents/core/types.d.ts

@@ -146,7 +146,7 @@ export interface EvolutionConfig {
 }
 export interface Adapter {
     name: string;
-    type: 'openclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
+    type: 'openclaw' | 'hermes' | 'nanoclaw' | 'picoclaw' | 'claude-code' | 'ruflo' | 'langchain' | 'autogen' | 'custom' | 'mcp' | 'codex' | 'opencode' | 'cursor' | 'windsurf' | 'aider' | 'continue' | 'cline';
     connected: boolean;
     agents: string[];
     connect(): Promise<void>;

package/dist/cli/hook.d.ts

@@ -17,13 +17,11 @@
 /** UserPromptSubmit — call nexus_session_bootstrap so the model never has to. */
 export declare function runHookBootstrap(): Promise<void>;
 /**
- * PostToolUse (Edit|Write|MultiEdit|Bash) — opt-in audit memory.
+ * PostToolUse (Edit|Write|MultiEdit|Bash) — compact audit memory.
  *
- * Disabled by default because every Edit/Write/Bash was being stored as a
- * low-priority memory, which polluted recall results with audit-log entries
- * like "Edit: file_path=src/foo.ts". Real findings should be stored via
- * nexus_store_memory by the agent itself. To opt back in, set
- * NEXUS_HOOK_AUTO_MEMORY=1.
+ * The hook stores only compact, hidden lifecycle breadcrumbs. Real findings
+ * should still be stored via nexus_store_memory by the agent itself. Set
+ * NEXUS_HOOK_AUTO_MEMORY=0 to disable this hook in a local session.
  */
 export declare function runHookMemory(): Promise<void>;
 /**

package/dist/cli/hook.js

@@ -150,16 +150,14 @@ export async function runHookBootstrap() {
     }, 10_000);
 }
 /**
- * PostToolUse (Edit|Write|MultiEdit|Bash) — opt-in audit memory.
+ * PostToolUse (Edit|Write|MultiEdit|Bash) — compact audit memory.
  *
- * Disabled by default because every Edit/Write/Bash was being stored as a
- * low-priority memory, which polluted recall results with audit-log entries
- * like "Edit: file_path=src/foo.ts". Real findings should be stored via
- * nexus_store_memory by the agent itself. To opt back in, set
- * NEXUS_HOOK_AUTO_MEMORY=1.
+ * The hook stores only compact, hidden lifecycle breadcrumbs. Real findings
+ * should still be stored via nexus_store_memory by the agent itself. Set
+ * NEXUS_HOOK_AUTO_MEMORY=0 to disable this hook in a local session.
  */
 export async function runHookMemory() {
-    if (process.env.NEXUS_HOOK_AUTO_MEMORY !== '1')
+    if (process.env.NEXUS_HOOK_AUTO_MEMORY === '0')
         return;
     const data = await readStdinJson();
     const cwd = String(data.cwd ?? process.cwd());
@@ -182,7 +180,7 @@ export async function runHookMemory() {
     await callDaemonTool(lock, 'nexus_store_memory', {
         content: `${toolName}: ${inputSummary}`,
         priority: 0.2,
-        tags: ['#auto', `tool:${toolName}`, `repo:${repoName}`],
+        tags: ['#auto', '#memory-hook', '#system-hidden', `tool:${toolName}`, `repo:${repoName}`],
     }, 5_000);
 }
 /**

package/dist/cli/install-wizard.js

@@ -37,6 +37,10 @@ const SETUP_CLIENT_BY_IDE = {
     windsurf: 'windsurf',
     continue: 'continue',
     cline: 'cline',
+    openclaw: 'openclaw',
+    hermes: 'hermes',
+    nanoclaw: 'nanoclaw',
+    picoclaw: 'picoclaw',
     codex: 'codex',
 };
 function resolveSetupWorkspaceRoot(explicitWorkspaceRoot) {
@@ -365,7 +369,7 @@ function mergeIntoExistingConfig(configPath, newContent, ide) {
     try {
         const existing = JSON.parse(readFileSync(configPath, 'utf8'));
         const incoming = JSON.parse(newContent);
-        if (ide === 'cursor' || ide === 'windsurf' || ide === 'continue') {
+        if (ide === 'cursor' || ide === 'windsurf' || ide === 'continue' || ide === 'openclaw' || ide === 'hermes' || ide === 'nanoclaw' || ide === 'picoclaw') {
             // These use { mcpServers: { "nexus-prime": {...} } }
             existing.mcpServers = {
                 ...(existing.mcpServers ?? {}),