nexus-prime 4.7.2 → 4.8.1

package/README.md

@@ -114,6 +114,8 @@ nexus_session_bootstrap(goal="<task>", files=[...])
 nexus_orchestrate(prompt="<raw user request>")
 ```
 
+These are Nexus Prime MCP tool invocations, not shell commands.
+
 Use `nexus_plan_execution` only when you explicitly want the ledger before mutation. Let Nexus choose crews, specialists, skills, workflows, hooks, automations, worker count, and token strategy unless you need hard constraints.
 
 ## Core Capabilities
@@ -628,6 +630,18 @@ Inventory Snapshot: 109 skills · 64 workflows · 9 hooks · 5 automations · 7
 ## 📜 Release History
 
 <details open>
+<summary><b>v4.8.0</b> · 2026-03-31 · Seamless Intelligence Upgrade — smarter runtime routing, durable memory controls, and governed work graphs</summary>
+
+- **Bootstrap truth for Codex and MCP clients**: Managed docs and bootstrap detection now describe `nexus_session_bootstrap` and `nexus_orchestrate` as MCP tool invocations, not shell commands.
+- **Runtime intelligence surfaces**: Scheduled automations, execution presets, session search, and governed skill distribution/promotion now extend the operator control plane.
+- **Durable control-plane governance**: Work claims, scoped approvals, and scoped budgets now preserve ancestry and lease semantics across missions and operatives.
+- **Memory control upgrades**: Actor-scoped memory CRUD, history, feedback, and retention hints now complement the existing project-aware memory engine.
+- **Channel ingress contract**: Slack, Telegram, and Feishu/Lark mappings now have a normalized gateway surface for thread identity, artifacts, and status exchange.
+
+Full notes: [releases/v4.8.0.md](./releases/v4.8.0.md) · Full history: [CHANGELOG.md](./CHANGELOG.md)
+</details>
+
+<details>
 <summary><b>v4.7.2</b> · 2026-03-31 · Runtime Efficiency — CPU optimization, middleware hardening, and skill sharing</summary>
 
 - **~80% idle CPU reduction**: Polling intervals across 6 subsystems reduced from aggressive (2-60s) to relaxed (30-300s). Memory maintenance, event bus, and pod network no longer burn cycles when idle.

package/dist/agents/adapters/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAsF5C,KAAK,cAAc,GAAG,YAAY,GAAG,MAAM,CAAC;AAE5C,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AA2TF,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,OAAO,CAAC,CAAkB;IAClC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,oBAAoB,CAAgG;IAC5H,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,kBAAkB,CAAqB;IAE/C,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,eAAe;IAqEvB,OAAO,CAAC,GAAG;;IAqBX,OAAO,CAAC,gBAAgB;IA4BxB,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,yBAAyB;IAqFjC,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,4BAA4B;IAWpC,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,yBAAyB;IA2CjC,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,YAAY;YAON,mBAAmB;IA0DjC,OAAO,CAAC,+BAA+B;IAMvC,OAAO,CAAC,uBAAuB;IA0B/B,OAAO,CAAC,2BAA2B;IAqBnC,OAAO,CAAC,uBAAuB;IAkC/B,cAAc,CAAC,OAAO,GAAE,cAAsC,GAAG,iBAAiB,EAAE;IAIpF,OAAO,CAAC,oBAAoB;IA80B5B,OAAO,CAAC,iBAAiB;YAyGX,cAAc;IAugE5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlD,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;CAOzC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/mcp.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAuF5C,KAAK,cAAc,GAAG,YAAY,GAAG,MAAM,CAAC;AAE5C,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AA2TF,qBAAa,UAAW,YAAW,OAAO;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAG,KAAK,CAAU;IACtB,SAAS,UAAS;IAClB,MAAM,EAAE,MAAM,EAAE,CAAM;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,OAAO,CAAC,CAAkB;IAClC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,oBAAoB,CAAgG;IAC5H,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,kBAAkB,CAAqB;IAE/C,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,eAAe;IAqEvB,OAAO,CAAC,GAAG;;IAqBX,OAAO,CAAC,gBAAgB;IA4BxB,WAAW,CAAC,KAAK,EAAE,UAAU;IAI7B,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,yBAAyB;IAqFjC,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,4BAA4B;IAWpC,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,yBAAyB;IA2CjC,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,YAAY;YAON,mBAAmB;IA0DjC,OAAO,CAAC,+BAA+B;IAMvC,OAAO,CAAC,uBAAuB;IA0B/B,OAAO,CAAC,2BAA2B;IAqBnC,OAAO,CAAC,uBAAuB;IAkC/B,cAAc,CAAC,OAAO,GAAE,cAAsC,GAAG,iBAAiB,EAAE;IAIpF,OAAO,CAAC,oBAAoB;IAu8B5B,OAAO,CAAC,iBAAiB;YAyGX,cAAc;IAsuE5B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;IAItC,OAAO,CAAC,IAAI;IAmBN,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlD,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;CAOzC"}

package/dist/agents/adapters/mcp.js

@@ -29,6 +29,7 @@ import { getSharedTelemetry } from '../../engines/telemetry-remote.js';
 import { getGstackBridge } from '../../engines/gstack-bridge.js';
 import { getSharedContextDiscovery } from '../../engines/context-discovery.js';
 import { MiddlewarePipeline } from '../../engines/middleware-pipeline.js';
+import { applyExecutionPreset, listExecutionPresets, resolveExecutionPreset } from '../../engines/execution-presets.js';
 import { synapseToolDefinitions, handleSynapseToolCall } from '../../synapse/index.js';
 import { architectsToolDefinitions, handleArchitectsToolCall } from '../../architects/index.js';
 const tokenEngine = new TokenSupremacyEngine();
@@ -410,13 +411,26 @@ export class MCPAdapter {
         console.error(`\x1b[36m╚${'═'.repeat(width - 2)}╝\x1b[0m\n`);
     }
     classifyToolCategory(toolName) {
-        if (['nexus_store_memory', 'nexus_recall_memory', 'nexus_memory_stats'].includes(toolName))
+        if ([
+            'nexus_store_memory',
+            'nexus_recall_memory',
+            'nexus_memory_stats',
+            'nexus_memory_trace',
+            'nexus_memory_export',
+            'nexus_memory_backup',
+            'nexus_memory_import',
+            'nexus_memory_maintain',
+            'nexus_memory_update',
+            'nexus_memory_delete',
+            'nexus_memory_history',
+            'nexus_memory_feedback',
+        ].includes(toolName))
             return 'memory';
         if (['nexus_orchestrate', 'nexus_plan_execution', 'nexus_spawn_workers'].includes(toolName))
             return 'orchestration';
         if (['nexus_ghost_pass', 'nexus_mindkit_check', 'nexus_optimize_tokens'].includes(toolName))
             return 'execution';
-        if (['nexus_session_bootstrap', 'nexus_session_dna', 'nexus_token_report'].includes(toolName))
+        if (['nexus_session_bootstrap', 'nexus_session_dna', 'nexus_session_search', 'nexus_token_report'].includes(toolName))
             return 'intelligence';
         if (toolName === 'nexus_run_status' || toolName === 'nexus_federation_status' || toolName.startsWith('nexus_list_'))
             return 'system';
@@ -968,6 +982,67 @@ export class MCPAdapter {
                     required: ['id'],
                 },
             },
+            {
+                name: 'nexus_memory_update',
+                description: 'Expert surface: update an existing memory item, including content, tags, scope, state, retention, and actor-scoped provenance.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Memory ID to update' },
+                        content: { type: 'string', description: 'Optional replacement content' },
+                        priority: { type: 'number', description: 'Optional replacement priority' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'Optional replacement tags' },
+                        scope: { type: 'string', enum: ['session', 'project', 'user', 'promoted', 'shared'], description: 'Optional replacement scope' },
+                        state: { type: 'string', enum: ['active', 'quarantined', 'scrap', 'expired'], description: 'Optional replacement state' },
+                        trust: { type: 'number', description: 'Optional replacement trust score' },
+                        expiresAt: { type: 'number', description: 'Optional replacement expiry timestamp in milliseconds since epoch' },
+                        retentionHint: { type: 'string', enum: ['default', 'session', 'short', 'standard', 'long', 'forever'], description: 'Optional retention policy hint' },
+                        provenance: { type: 'object', description: 'Optional actor scope and provenance overrides' },
+                    },
+                    required: ['id'],
+                },
+            },
+            {
+                name: 'nexus_memory_delete',
+                description: 'Expert surface: soft-delete or permanently delete a memory item while preserving deletion history.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Memory ID to delete' },
+                        hardDelete: { type: 'boolean', description: 'When true, permanently remove the memory row instead of expiring it' },
+                        reason: { type: 'string', description: 'Optional deletion reason recorded in memory history' },
+                        provenance: { type: 'object', description: 'Optional actor scope and provenance overrides' },
+                    },
+                    required: ['id'],
+                },
+            },
+            {
+                name: 'nexus_memory_history',
+                description: 'Expert surface: inspect the mutation and feedback history for a memory item.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Memory ID to inspect' },
+                        limit: { type: 'number', description: 'Maximum history entries to return (default 20)' },
+                    },
+                    required: ['id'],
+                },
+            },
+            {
+                name: 'nexus_memory_feedback',
+                description: 'Expert surface: attach explicit operator feedback to a memory item to promote, demote, quarantine, or re-score it.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Memory ID to score' },
+                        reaction: { type: 'string', enum: ['positive', 'negative', 'promote', 'demote', 'quarantine'], description: 'Feedback reaction to apply' },
+                        rating: { type: 'number', description: 'Optional numeric score from -1 to 1' },
+                        note: { type: 'string', description: 'Optional operator note stored in history' },
+                        provenance: { type: 'object', description: 'Optional actor scope and provenance overrides' },
+                    },
+                    required: ['id'],
+                },
+            },
             {
                 name: 'nexus_session_bootstrap',
                 description: 'Read-only session-start summary. Returns current client identity, memory recall summary, memory stats, recommended next step, recommended execution mode, shortlist recommendations, and whether token optimization will be required.',
@@ -996,7 +1071,8 @@ export class MCPAdapter {
                         automations: { type: 'array', items: { type: 'string' }, description: 'Optional hard automation selectors' },
                         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' }
+                        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' }
                     },
                     required: ['prompt'],
                 },
@@ -1102,6 +1178,7 @@ export class MCPAdapter {
                         dslCompiler: { type: 'string', description: 'DSL compiler selector' },
                         backendMode: { type: 'string', enum: ['default', 'shadow', 'experimental'], description: 'Backend execution mode' },
                         optimizationProfile: { type: 'string', enum: ['standard', 'max'], description: 'Planner optimization profile' },
+                        executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset for cheap, balanced, deep, or release-grade runs' },
                     },
                     required: ['goal', 'files'],
                 },
@@ -1118,11 +1195,17 @@ export class MCPAdapter {
                         workflows: { type: 'array', items: { type: 'string' }, description: 'Optional workflow selectors' },
                         crews: { type: 'array', items: { type: 'string' }, description: 'Optional crew selectors' },
                         specialists: { type: 'array', items: { type: 'string' }, description: 'Optional specialist selectors' },
-                        optimizationProfile: { type: 'string', enum: ['standard', 'max'], description: 'Planner optimization profile' }
+                        optimizationProfile: { type: 'string', enum: ['standard', 'max'], description: 'Planner optimization profile' },
+                        executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset for cheap, balanced, deep, or release-grade planning' }
                     },
                     required: ['goal'],
                 },
             },
+            {
+                name: 'nexus_list_execution_presets',
+                description: 'List the execution presets that map user intent onto runtime depth, verification strictness, and backend selection.',
+                inputSchema: { type: 'object', properties: {}, required: [] },
+            },
             {
                 name: 'nexus_audit_evolution',
                 description: 'Identify recurring failure patterns, file hotspots, and code areas needing refactoring. Call at sprint boundaries, after major bug fixes, or when the same files keep breaking. Returns prioritized recommendations.',
@@ -1156,6 +1239,58 @@ export class MCPAdapter {
                     required: ['action'],
                 },
             },
+            {
+                name: 'nexus_session_search',
+                description: 'Search prior Session DNA snapshots without promoting transcripts into long-term memory.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Terms to search across prior session snapshots' },
+                        limit: { type: 'number', description: 'Maximum hits to return (default 5)' },
+                        minScore: { type: 'number', description: 'Minimum deterministic score threshold' },
+                        sessionsDir: { type: 'string', description: 'Optional alternate sessions directory' },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'nexus_channel_map_thread',
+                description: 'Map an inbound Slack, Telegram, or Feishu/Lark thread onto a Nexus session or mission while preserving external thread identity.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        provider: { type: 'string', enum: ['slack', 'telegram', 'feishu', 'lark', 'feishu-lark'], description: 'Channel provider' },
+                        conversationId: { type: 'string', description: 'Provider-native conversation or channel identifier' },
+                        threadId: { type: 'string', description: 'Provider-native thread identifier' },
+                        messageId: { type: 'string', description: 'Provider-native message identifier' },
+                        parentMessageId: { type: 'string', description: 'Optional parent message identifier' },
+                        workspaceId: { type: 'string', description: 'Optional workspace or tenant identifier' },
+                        targetKind: { type: 'string', enum: ['session', 'mission'], description: 'Nexus target type' },
+                        targetId: { type: 'string', description: 'Nexus session or mission identifier' },
+                        sourceUrl: { type: 'string', description: 'Optional canonical source URL' },
+                    },
+                    required: ['provider', 'conversationId', 'targetKind', 'targetId'],
+                },
+            },
+            {
+                name: 'nexus_channel_artifact_envelope',
+                description: 'Wrap a Nexus artifact for delivery back to Slack, Telegram, or Feishu/Lark with preserved thread metadata and attachments.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        provider: { type: 'string', enum: ['slack', 'telegram', 'feishu', 'lark', 'feishu-lark'], description: 'Channel provider' },
+                        thread: { type: 'object', description: 'Channel thread mapping object returned by nexus_channel_map_thread' },
+                        artifactType: { type: 'string', description: 'Artifact category such as session-summary or mission-status' },
+                        artifactId: { type: 'string', description: 'Optional artifact identifier' },
+                        title: { type: 'string', description: 'Artifact title' },
+                        summary: { type: 'string', description: 'Artifact summary' },
+                        body: { type: 'string', description: 'Optional artifact body' },
+                        attachments: { type: 'array', items: { type: 'object' }, description: 'Optional attachment descriptors' },
+                        metadata: { type: 'object', description: 'Optional metadata payload' },
+                    },
+                    required: ['provider', 'thread', 'artifactType', 'title', 'summary'],
+                },
+            },
             // ── HyperTune Max ─────────────────────────────────────────────────
             {
                 name: 'nexus_hypertune_max',
@@ -1980,8 +2115,12 @@ export class MCPAdapter {
                 const optimizationProfile = request.params.arguments?.optimizationProfile
                     ? String(request.params.arguments.optimizationProfile)
                     : undefined;
+                const executionPreset = request.params.arguments?.executionPreset
+                    ? String(request.params.arguments.executionPreset)
+                    : undefined;
                 try {
-                    const execution = await this.nexusRef.orchestrate(prompt, {
+                    const preset = resolveExecutionPreset(executionPreset);
+                    const execution = await this.nexusRef.orchestrate(prompt, applyExecutionPreset({
                         files,
                         workers,
                         skillNames: skills,
@@ -1991,7 +2130,7 @@ export class MCPAdapter {
                         crewSelectors: crews,
                         specialistSelectors: specialists,
                         optimizationProfile,
-                    });
+                    }, executionPreset));
                     const verifiedWorkers = execution.workerResults.filter((worker) => worker.verified).length;
                     const tokenPlan = execution?.knowledgeFabric?.repo?.readingPlan;
                     const canAutoApplyTokenPlan = Boolean(tokenPlan
@@ -2053,6 +2192,7 @@ export class MCPAdapter {
                         tokens: execution.tokenTelemetry,
                         verifiedWorkers,
                         continuationChildren: execution.continuationChildren,
+                        executionPreset: preset ? { id: preset.id, name: preset.name, summary: preset.summary } : undefined,
                         autoTokenApplyNote,
                     };
                     return {
@@ -2068,6 +2208,7 @@ export class MCPAdapter {
                                         `Assets: ${(execution.activeSkills || []).length} skills · ${(execution.activeWorkflows || []).length} workflows · ${(runtimeUsage.artifactSelectionAudit?.selected?.length || 0)} audited selections`,
                                         `Task graph: ${runtimeUsage.taskGraph?.phases?.length || execution.taskGraph?.phases?.length || 0} phases · ${runtimeUsage.workerPlan?.totalWorkers || execution.workerPlan?.totalWorkers || 0} worker lanes`,
                                         `Catalog health: ${runtimeUsage.catalogHealth?.overall || 'unknown'}`,
+                                        preset ? `Preset: ${preset.name} (${preset.id})` : null,
                                         `Verification: ${verifiedWorkers}/${execution.workerResults.length} worker(s) verified`,
                                         `Worktrees: ${runtimeUsage.worktreeHealth?.overall || 'unknown'} · repaired ${runtimeUsage.worktreeHealth?.repairedEntries || 0} · broken ${runtimeUsage.worktreeHealth?.brokenEntries || 0}`,
                                         `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}% · dominant ${runtimeUsage.sourceAwareTokenBudget?.dominantSource || execution.knowledgeFabric?.sourceMix?.dominantSource || 'repo'}`,
@@ -2364,6 +2505,105 @@ export class MCPAdapter {
                         }],
                 };
             }
+            case 'nexus_memory_update': {
+                const id = String(request.params.arguments?.id ?? '');
+                const result = this.nexusRef.updateMemory(id, {
+                    content: request.params.arguments?.content == null ? undefined : String(request.params.arguments.content),
+                    priority: request.params.arguments?.priority == null ? undefined : Number(request.params.arguments.priority),
+                    tags: Array.isArray(request.params.arguments?.tags)
+                        ? request.params.arguments.tags.map(String)
+                        : undefined,
+                    scope: request.params.arguments?.scope ? String(request.params.arguments.scope) : undefined,
+                    state: request.params.arguments?.state ? String(request.params.arguments.state) : undefined,
+                    trust: request.params.arguments?.trust == null ? undefined : Number(request.params.arguments.trust),
+                    expiresAt: request.params.arguments?.expiresAt == null ? undefined : Number(request.params.arguments.expiresAt),
+                    retentionHint: request.params.arguments?.retentionHint ? String(request.params.arguments.retentionHint) : undefined,
+                    provenance: request.params.arguments?.provenance,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                result.updated ? 'Memory updated.' : `Memory update skipped for ${id}.`,
+                                result.updated
+                                    ? formatBullets([
+                                        `ID: ${result.item?.id || id}`,
+                                        `Scope: ${result.item?.scope || 'n/a'} · state ${result.item?.state || 'n/a'}`,
+                                        `History event: ${result.historyEntry?.eventType || 'updated'}`,
+                                    ])
+                                    : null,
+                                formatJsonDetails('Structured details', result ?? {}),
+                            ].filter(Boolean).join('\n\n'),
+                        }],
+                };
+            }
+            case 'nexus_memory_delete': {
+                const id = String(request.params.arguments?.id ?? '');
+                const result = this.nexusRef.deleteMemory(id, {
+                    hardDelete: Boolean(request.params.arguments?.hardDelete),
+                    reason: request.params.arguments?.reason ? String(request.params.arguments.reason) : undefined,
+                    provenance: request.params.arguments?.provenance,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                result.deleted ? 'Memory deleted.' : `Memory delete skipped for ${id}.`,
+                                result.deleted
+                                    ? formatBullets([
+                                        `ID: ${result.item?.id || id}`,
+                                        `Mode: ${result.hardDelete ? 'hard delete' : 'soft delete'}`,
+                                        `History event: ${result.historyEntry?.eventType || 'deleted'}`,
+                                    ])
+                                    : null,
+                                formatJsonDetails('Structured details', result ?? {}),
+                            ].filter(Boolean).join('\n\n'),
+                        }],
+                };
+            }
+            case 'nexus_memory_history': {
+                const id = String(request.params.arguments?.id ?? '');
+                const limit = Number(request.params.arguments?.limit ?? 20);
+                const result = this.nexusRef.getMemoryHistory(id, limit);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                `Memory history ready for ${id}.`,
+                                formatBullets([
+                                    `Entries: ${result.length}`,
+                                    `Latest event: ${result[0]?.eventType || 'none'}`,
+                                ]),
+                                formatJsonDetails('Structured details', result),
+                            ].join('\n\n'),
+                        }],
+                };
+            }
+            case 'nexus_memory_feedback': {
+                const id = String(request.params.arguments?.id ?? '');
+                const result = this.nexusRef.submitMemoryFeedback(id, {
+                    reaction: request.params.arguments?.reaction ? String(request.params.arguments.reaction) : undefined,
+                    rating: request.params.arguments?.rating == null ? undefined : Number(request.params.arguments.rating),
+                    note: request.params.arguments?.note ? String(request.params.arguments.note) : undefined,
+                    provenance: request.params.arguments?.provenance,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                result.accepted ? 'Memory feedback recorded.' : `Memory feedback skipped for ${id}.`,
+                                result.accepted
+                                    ? formatBullets([
+                                        `ID: ${result.item?.id || id}`,
+                                        `Priority: ${Number(result.priority ?? 0).toFixed(2)}`,
+                                        `Trust: ${Number(result.trust ?? 0).toFixed(2)}`,
+                                    ])
+                                    : null,
+                                formatJsonDetails('Structured details', result ?? {}),
+                            ].filter(Boolean).join('\n\n'),
+                        }],
+                };
+            }
             case 'nexus_describe_tool': {
                 const requestedTool = String(request.params.arguments?.tool_name ?? '');
                 if (!requestedTool) {
@@ -2562,7 +2802,11 @@ export class MCPAdapter {
                 const optimizationProfile = request.params.arguments?.optimizationProfile
                     ? String(request.params.arguments.optimizationProfile)
                     : undefined;
-                const execution = await this.getRuntime().run({
+                const executionPreset = request.params.arguments?.executionPreset
+                    ? String(request.params.arguments.executionPreset)
+                    : undefined;
+                const preset = resolveExecutionPreset(executionPreset);
+                const execution = await this.getRuntime().run(applyExecutionPreset({
                     goal,
                     files: rawFiles,
                     workers: workersCount,
@@ -2579,7 +2823,7 @@ export class MCPAdapter {
                     optimizationProfile,
                     executionMode: 'manual-low-level',
                     manualOverrides: ['nexus_spawn_workers'],
-                });
+                }, executionPreset));
                 const verifiedWorkers = execution.workerResults.filter(result => result.verified).length;
                 const modifiedFiles = execution.workerResults.reduce((sum, result) => sum + result.modifiedFiles.length, 0);
                 execution.activeSkills.forEach(skill => {
@@ -2603,6 +2847,7 @@ export class MCPAdapter {
                 this.box('🐝 PHANTOM RUNTIME', [
                     `Run: ${execution.runId.padEnd(28, ' ')} State: ${execution.state.padEnd(18, ' ')}`,
                     `Workers: ${execution.workerResults.length.toString().padEnd(5, ' ')} Verified: ${verifiedWorkers.toString().padEnd(10, ' ')} Files: ${String(modifiedFiles).padEnd(12, ' ')}`,
+                    `${`Preset: ${preset?.name ?? 'manual'}`.padEnd(61, ' ')}`,
                     `Decision: ${(execution.finalDecision?.action ?? 'none').padEnd(52, ' ')}`
                 ], execution.state === 'merged' ? '32' : execution.state === 'rolled_back' ? '33' : '31');
                 return {
@@ -2615,6 +2860,7 @@ export class MCPAdapter {
                                 `State: ${execution.state}`,
                                 `Artifacts: ${execution.artifactsPath}`,
                                 `Workers: ${execution.workerResults.length}`,
+                                preset ? `Preset: ${preset.name} (${preset.id})` : null,
                                 `Verified Workers: ${verifiedWorkers}`,
                                 `Modified Files: ${modifiedFiles}`,
                                 `Decision: ${execution.finalDecision?.action ?? 'none'}`,
@@ -2824,6 +3070,92 @@ export class MCPAdapter {
                     };
                 }
             }
+            case 'nexus_session_search': {
+                const query = String(request.params.arguments?.query ?? '');
+                const result = this.nexusRef.searchSessionHistory(query, {
+                    limit: request.params.arguments?.limit == null ? undefined : Number(request.params.arguments.limit),
+                    minScore: request.params.arguments?.minScore == null ? undefined : Number(request.params.arguments.minScore),
+                    sessionsDir: request.params.arguments?.sessionsDir ? String(request.params.arguments.sessionsDir) : undefined,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                `Session search ready for "${query}".`,
+                                formatBullets([
+                                    `Hits: ${result.length}`,
+                                    `Top session: ${result[0]?.session.sessionId || 'none'}`,
+                                ]),
+                                formatJsonDetails('Structured details', result),
+                            ].join('\n\n'),
+                        }],
+                };
+            }
+            case 'nexus_channel_map_thread': {
+                const result = this.nexusRef.mapChannelThread({
+                    provider: String(request.params.arguments?.provider ?? ''),
+                    conversationId: String(request.params.arguments?.conversationId ?? ''),
+                    threadId: request.params.arguments?.threadId ? String(request.params.arguments.threadId) : undefined,
+                    messageId: request.params.arguments?.messageId ? String(request.params.arguments.messageId) : undefined,
+                    parentMessageId: request.params.arguments?.parentMessageId ? String(request.params.arguments.parentMessageId) : undefined,
+                    workspaceId: request.params.arguments?.workspaceId ? String(request.params.arguments.workspaceId) : undefined,
+                    target: {
+                        kind: String(request.params.arguments?.targetKind ?? 'session'),
+                        id: String(request.params.arguments?.targetId ?? ''),
+                    },
+                    sourceUrl: request.params.arguments?.sourceUrl ? String(request.params.arguments.sourceUrl) : undefined,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                'Channel thread mapped.',
+                                formatBullets([
+                                    `Provider: ${result.provider}`,
+                                    `Target: ${result.target.kind}:${result.target.id}`,
+                                    `Thread key: ${result.threadKey}`,
+                                ]),
+                                formatJsonDetails('Structured details', result),
+                            ].join('\n\n'),
+                        }],
+                };
+            }
+            case 'nexus_channel_artifact_envelope': {
+                const result = this.nexusRef.createChannelArtifactEnvelope({
+                    provider: String(request.params.arguments?.provider ?? ''),
+                    thread: request.params.arguments?.thread,
+                    artifactType: String(request.params.arguments?.artifactType ?? ''),
+                    artifactId: request.params.arguments?.artifactId ? String(request.params.arguments.artifactId) : undefined,
+                    title: String(request.params.arguments?.title ?? ''),
+                    summary: String(request.params.arguments?.summary ?? ''),
+                    body: request.params.arguments?.body ? String(request.params.arguments.body) : undefined,
+                    attachments: Array.isArray(request.params.arguments?.attachments)
+                        ? request.params.arguments.attachments.map((attachment) => ({
+                            name: String(attachment.name ?? ''),
+                            kind: String(attachment.kind ?? 'file'),
+                            content: attachment.content == null ? undefined : String(attachment.content),
+                            path: attachment.path == null ? undefined : String(attachment.path),
+                            mimeType: attachment.mimeType == null ? undefined : String(attachment.mimeType),
+                            sizeBytes: attachment.sizeBytes == null ? undefined : Number(attachment.sizeBytes),
+                        }))
+                        : undefined,
+                    metadata: request.params.arguments?.metadata,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                'Channel artifact envelope ready.',
+                                formatBullets([
+                                    `Provider: ${result.provider}`,
+                                    `Artifact: ${result.artifactType}`,
+                                    `Attachments: ${result.attachments.length}`,
+                                ]),
+                                formatJsonDetails('Structured details', result),
+                            ].join('\n\n'),
+                        }],
+                };
+            }
             case 'nexus_skill_register': {
                 const graphEngine = getGraphEngine();
                 const registry = new SkillCardRegistry(graphEngine);
@@ -3094,7 +3426,11 @@ export class MCPAdapter {
                 const optimizationProfile = request.params.arguments?.optimizationProfile
                     ? String(request.params.arguments.optimizationProfile)
                     : undefined;
-                const planner = await this.getRuntime().planExecution({
+                const executionPreset = request.params.arguments?.executionPreset
+                    ? String(request.params.arguments.executionPreset)
+                    : undefined;
+                const preset = resolveExecutionPreset(executionPreset);
+                const planner = await this.getRuntime().planExecution(applyExecutionPreset({
                     goal,
                     files,
                     skillNames: skills,
@@ -3102,13 +3438,14 @@ export class MCPAdapter {
                     crewSelectors: crews,
                     specialistSelectors: specialists,
                     optimizationProfile,
-                });
+                }, executionPreset));
                 return {
                     content: [{
                             type: 'text',
                             text: [
                                 `🧭 Execution Plan — ${planner.objective}`,
                                 '',
+                                preset ? `Preset: ${preset.name} (${preset.id})` : 'Preset: manual',
                                 `Crew: ${planner.selectedCrew.name} (${planner.selectedCrew.confidence.score.toFixed(2)})`,
                                 `Specialists: ${planner.selectedSpecialists.length > 0 ? planner.selectedSpecialists.map((specialist) => `${specialist.name}(${specialist.authority})`).join(', ') : 'none'}`,
                                 `Skills: ${planner.selectedSkills.length > 0 ? planner.selectedSkills.join(', ') : 'none'}`,
@@ -3124,6 +3461,19 @@ export class MCPAdapter {
                         }],
                 };
             }
+            case 'nexus_list_execution_presets': {
+                const presets = listExecutionPresets();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: [
+                                'Execution presets ready.',
+                                formatBullets(presets.map((preset) => `${preset.id}: ${preset.summary}`)),
+                                formatJsonDetails('Structured details', presets),
+                            ].join('\n\n'),
+                        }],
+                };
+            }
             case 'nexus_list_skills': {
                 const skills = this.getRuntime().listSkills();
                 return {