@getmarrow/mcp 3.9.55 → 3.9.57

package/dist/cli.js

@@ -17,8 +17,12 @@ const hook_session_1 = require("./hook-session");
 const hook_pre_action_1 = require("./hook-pre-action");
 const env_1 = require("./env");
 const lifecycle_spool_1 = require("./lifecycle-spool");
+const guidance_cache_1 = require("./guidance-cache");
+const request_reliability_1 = require("./request-reliability");
+const hook_contract_1 = require("./hook-contract");
 const ping_state_1 = require("./ping-state");
 const redact_1 = require("./redact");
+const runtime_contract_1 = require("./runtime-contract");
 // Parse CLI args
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -355,9 +359,12 @@ if (process.argv[2] !== 'keys') {
         const rawBaseUrl = resolvedEnv.baseUrl || 'https://api.getmarrow.ai';
         const BASE_URL = (0, index_1.validateBaseUrl)(rawBaseUrl);
         const SESSION_ID = resolvedEnv.sessionId || undefined;
-        const FLEET_AGENT_ID = resolvedEnv.agentId || undefined; // V5: agent UUID for X-Marrow-Agent-Id header
+        // One identity must bind headers, bodies, queries, cache, and lifecycle events.
+        // resolveMarrowEnv already gives MARROW_FLEET_AGENT_ID precedence over MARROW_AGENT_ID.
+        // When no identity is configured, omit it and let the API resolve the key's
+        // bound agent instead of inventing a process-local identity that changes on restart.
+        const FLEET_AGENT_ID = resolvedEnv.agentId || undefined;
         const AUTO_ENROLL = process.env.MARROW_AUTO_ENROLL !== 'false'; // on by default
-        const AGENT_ID = process.env.MARROW_AGENT_ID || `${require('os').hostname()}-${Date.now().toString(36)}`;
         if (!API_KEY) {
             process.stderr.write('Error: MARROW_API_KEY environment variable is required\n');
             process.stderr.write(`${resolvedEnv.exactFix}\n`);
@@ -389,12 +396,6 @@ if (process.argv[2] !== 'keys') {
                 process.stderr.write(`[marrow] Warning: failed to refresh orient warnings: ${msg}\n`);
             }
         }
-        // Initial orient
-        refreshOrientWarnings().then(() => {
-            if (cachedOrientWarnings.some((w) => w.failureRate > 0.4)) {
-                process.stderr.write(`[marrow] ⚠️ High failure rate detected on startup — call marrow_orient for details before acting\n`);
-            }
-        });
         // Auto-commit tracking for session close
         let lastDecisionId = null;
         let lastCommitted = false;
@@ -432,6 +433,35 @@ if (process.argv[2] !== 'keys') {
         function error(id, code, message) {
             send({ jsonrpc: '2.0', id, error: { code, message } });
         }
+        function toolSuccess(id, value, isError = false) {
+            success(id, {
+                content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+                ...(isError ? { isError: true } : {}),
+            });
+        }
+        function toolFailure(toolName, failure) {
+            const result = (0, request_reliability_1.structuredRequestFailure)(failure);
+            const transient = failure.retryable && !['authentication_required', 'permission_denied'].includes(failure.code);
+            const supportsStale = ['marrow_agent_runtime', 'marrow_orient', 'marrow_ask', 'marrow_runtime_status', 'marrow_status'].includes(toolName || '');
+            if (transient && supportsStale) {
+                let cached = null;
+                try {
+                    cached = (0, guidance_cache_1.readGuidanceCache)({ apiKey: API_KEY, baseUrl: BASE_URL, agentId: FLEET_AGENT_ID });
+                }
+                catch { /* owner-only cache is best effort */ }
+                if (cached) {
+                    result.stale_brief = cached.context;
+                    result.stale_ms = cached.stale_ms;
+                }
+                result.disposition = 'review_required';
+                result.allow = false;
+                result.stale_can_authorize_high_risk = false;
+                result.exact_next_action = cached
+                    ? 'Use this last-known brief for low-risk context only. Obtain a fresh Marrow runtime gate before high-risk work.'
+                    : 'Retry once after retry_after_ms. Do not perform high-risk work without a fresh Marrow runtime gate.';
+            }
+            return result;
+        }
         // [FIX #9] Runtime validation helper for required string params
         function requireString(args, name) {
             const val = args[name];
@@ -440,6 +470,51 @@ if (process.argv[2] !== 'keys') {
             }
             return val;
         }
+        function requireBoolean(args, name) {
+            const value = args[name];
+            if (typeof value !== 'boolean')
+                throw new Error(`"${name}" is required and must be boolean`);
+            return value;
+        }
+        const HIGH_RISK_ACTION = /\b(?:billing|credential|database|delete|deploy|destructive|financial|key|merge|migrat(?:e|ion)|payment|production|publish|release|remove|rollback|secret|security|token|truncate|wipe)\b/i;
+        function isHighRiskAction(action, type) {
+            return HIGH_RISK_ACTION.test(`${String(type || '')} ${String(action || '')}`);
+        }
+        function cachedGuidance() {
+            try {
+                return (0, guidance_cache_1.readGuidanceCache)({ apiKey: API_KEY, baseUrl: BASE_URL, agentId: FLEET_AGENT_ID });
+            }
+            catch {
+                return null;
+            }
+        }
+        async function withControlDeadline(operation, options = {}) {
+            const hasCache = options.cacheAware !== false && Boolean(cachedGuidance());
+            const configuredCanaryMs = Number(process.env.MARROW_REQUEST_TIMEOUT_MS);
+            const timeoutMs = process.env.MARROW_CONTROL_PATH_CANARY === '1' && Number.isFinite(configuredCanaryMs)
+                ? Math.min(5_000, Math.max(500, Math.floor(configuredCanaryMs)))
+                : options.highRisk ? 2_000 : hasCache ? 400 : 1_200;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            timer.unref?.();
+            try {
+                return await operation(controller.signal);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        function storeRuntimeGuidance(runtime) {
+            try {
+                (0, guidance_cache_1.writeGuidanceCache)({
+                    apiKey: API_KEY,
+                    baseUrl: BASE_URL,
+                    agentId: FLEET_AGENT_ID,
+                    context: (0, hook_context_1.compactRuntimeContext)(runtime),
+                });
+            }
+            catch { /* owner-only cache is best effort */ }
+        }
         // [FIX #6 & #7] Safe JSON response helper for memory API functions
         async function safeMemoryResponse(res) {
             if (!res.ok) {
@@ -726,8 +801,7 @@ if (process.argv[2] !== 'keys') {
             },
             {
                 name: 'marrow_run',
-                description: 'Zero-ceremony memory logging. Single call handles orient → think → commit automatically. ' +
-                    'Use this instead of chaining marrow_think + marrow_commit when you want Marrow to just work without managing the loop yourself.',
+                description: 'One-call governed outcome capture. Records intent, obtains a gate for risky work, and closes only with an explicit measured result.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -739,27 +813,28 @@ if (process.argv[2] !== 'keys') {
                             enum: ['implementation', 'security', 'architecture', 'process', 'general'],
                             description: 'Type of action (default: general)',
                         },
+                        proof: { type: 'object', description: 'Measured evidence required to close high-risk work.' },
+                        gate_receipt_id: { type: 'string', description: 'Fresh receipt returned by marrow_agent_runtime.' },
                     },
                     required: ['description', 'success', 'outcome'],
                 },
             },
             {
                 name: 'marrow_auto',
-                description: 'Zero-friction Marrow logging. One call for any action — Marrow handles everything in the background without blocking. ' +
-                    'Pass what you are about to do. Optionally pass outcome if already done. ' +
-                    'Use for ANY action: deploys, file writes, API calls, external sends. ' +
-                    'If you only have time for one call: pass action + outcome + success together — done in one shot.',
+                description: 'Durably capture low-risk activity without blocking. Outcomes remain pending unless success is explicit; risky completion still requires a fresh gate and measured proof.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         action: { type: 'string', description: 'What you are about to do or just did' },
                         outcome: { type: 'string', description: 'What happened (if already done). Omit to log intent only.' },
-                        success: { type: 'boolean', description: 'Did it succeed (default: true)' },
+                        success: { type: 'boolean', description: 'Measured result. Omit when the outcome is not yet proven.' },
                         type: {
                             type: 'string',
                             enum: ['implementation', 'security', 'architecture', 'process', 'general'],
                             description: 'Type of action (default: general)',
                         },
+                        proof: { type: 'object', description: 'Measured completion evidence for gated work.' },
+                        gate_receipt_id: { type: 'string', description: 'Fresh receipt returned by marrow_agent_runtime.' },
                     },
                     required: ['action'],
                 },
@@ -1022,7 +1097,7 @@ if (process.argv[2] !== 'keys') {
                     type: 'object',
                     properties: {
                         period: { type: 'string', description: 'Time period: 7d (default), 14d, or 30d' },
-                        agentId: { type: 'string', description: 'Optional agent_id/session_id filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent_id/session_id filter. Defaults to the canonical fleet-bound agent identity.' },
                     },
                     required: [],
                 },
@@ -1047,7 +1122,7 @@ if (process.argv[2] !== 'keys') {
                     type: 'object',
                     properties: {
                         period: { type: 'string', description: 'Time period: 7d (default), 14d, 30d, or a day count up to 90.' },
-                        agentId: { type: 'string', description: 'Optional agent_id/session_id filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent_id/session_id filter. Defaults to the canonical fleet-bound agent identity.' },
                     },
                     required: [],
                 },
@@ -1063,7 +1138,7 @@ if (process.argv[2] !== 'keys') {
                         action: { type: 'string', description: 'What the agent is about to do.' },
                         type: { type: 'string', description: 'Decision type, e.g. deploy, audit, patch, review.' },
                         role: { type: 'string', description: 'Agent role/playbook: deploy, audit, patch, review, or general.' },
-                        agentId: { type: 'string', description: 'Optional agent_id filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent_id filter. Defaults to the canonical fleet-bound agent identity.' },
                         sessionId: { type: 'string', description: 'Optional session id. Defaults to MARROW_SESSION_ID.' },
                         surfaces: {
                             type: 'array',
@@ -1085,7 +1160,7 @@ if (process.argv[2] !== 'keys') {
                         action: { type: 'string', description: 'Optional action to test. Defaults to a production deploy safety prompt.' },
                         type: { type: 'string', description: 'Decision type, e.g. deploy, audit, patch, review.' },
                         role: { type: 'string', description: 'Agent role/playbook: deploy, audit, patch, review, or general.' },
-                        agentId: { type: 'string', description: 'Optional agent_id filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent_id filter. Defaults to the canonical fleet-bound agent identity.' },
                         sessionId: { type: 'string', description: 'Optional session id. Defaults to MARROW_SESSION_ID.' },
                         surfaces: { type: 'array', items: { type: 'string' }, description: 'Surfaces to test, e.g. production, deploy, github, npm.' },
                         context: { type: 'object', description: 'Optional non-sensitive metadata.' },
@@ -1105,7 +1180,7 @@ if (process.argv[2] !== 'keys') {
                         action: { type: 'string', description: 'What the agent is about to do.' },
                         type: { type: 'string', description: 'Decision type, e.g. deploy, audit, patch, review.' },
                         role: { type: 'string', description: 'Agent role/playbook: deploy, audit, patch, review, or general.' },
-                        agentId: { type: 'string', description: 'Optional agent_id filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent_id filter. Defaults to the canonical fleet-bound agent identity.' },
                         sessionId: { type: 'string', description: 'Optional session id. Defaults to MARROW_SESSION_ID.' },
                         surfaces: {
                             type: 'array',
@@ -1165,7 +1240,7 @@ if (process.argv[2] !== 'keys') {
                         },
                         action: { type: 'string', description: 'Optional runtime action label.' },
                         type: { type: 'string', description: 'Optional runtime action type. Defaults to coordination.' },
-                        agentId: { type: 'string', description: 'Requesting agent id. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Requesting agent id. Defaults to the canonical fleet-bound agent identity.' },
                         sessionId: { type: 'string', description: 'Optional workflow session id.' },
                         surfaces: { type: 'array', items: { type: 'string' } },
                         context: { type: 'object', description: 'Optional non-sensitive runtime metadata.' },
@@ -1174,6 +1249,75 @@ if (process.argv[2] !== 'keys') {
                     required: ['objective', 'proposals'],
                 },
             },
+            {
+                name: 'marrow_coordinate',
+                description: 'Coordinate tenant agents without sharing transcripts. Acquire or release a bounded resource lease, ' +
+                    'list current leases, or create/list compact evidence-backed child proof packets for a parent agent.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['list_leases', 'acquire_lease', 'release_lease', 'list_proof_packets', 'create_proof_packet'],
+                        },
+                        resource_type: { type: 'string', enum: ['file', 'directory', 'service', 'workflow', 'deployment', 'custom'] },
+                        resource: { type: 'string', maxLength: 160, description: 'Bounded tenant-visible resource label. Do not send secrets.' },
+                        workflow_id: { type: 'string' },
+                        ttl_seconds: { type: 'number', minimum: 30, maximum: 3600 },
+                        lease_id: { type: 'string' },
+                        lease_token: { type: 'string', description: 'One-time lease capability returned by acquire_lease.' },
+                        status: { type: 'string', enum: ['active', 'released', 'expired', 'incomplete', 'complete', 'failed'] },
+                        limit: { type: 'number', minimum: 1, maximum: 100 },
+                        decision_id: { type: 'string' },
+                        proof_pack_id: { type: 'string' },
+                        summary: { type: 'string', maxLength: 280, description: 'Compact result summary; no raw transcript.' },
+                        evidence_refs: {
+                            type: 'array', maxItems: 20, items: { type: 'string' },
+                            description: 'Opaque durable evidence identifiers only.',
+                        },
+                    },
+                    required: ['action'],
+                },
+            },
+            {
+                name: 'marrow_replay_compare',
+                description: 'Compare two already-recorded outcomes for the same tenant task using durable proof. ' +
+                    'This does not run a model or replay customer content; it returns complete or insufficient_evidence.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        comparison_id: { type: 'string', description: 'Fetch a prior replay comparison by id.' },
+                        source_decision_id: { type: 'string', description: 'Original task decision used to bind the comparison.' },
+                        workspace_binding_id: { type: 'string', description: 'Optional privacy-safe workspace binding from runtime.' },
+                        constraints: {
+                            type: 'object',
+                            additionalProperties: false,
+                            maxProperties: 7,
+                            description: 'Allowlisted comparison labels only; prompts, code, transcripts, credentials, and nested content are rejected.',
+                            properties: {
+                                environment: { type: 'string', maxLength: 80 },
+                                tests: { type: 'string', maxLength: 80 },
+                                policy_profile_id: { type: 'string', maxLength: 80 },
+                                workflow_type: { type: 'string', maxLength: 80 },
+                                task_type: { type: 'string', maxLength: 80 },
+                                required_proof: { type: 'boolean' },
+                                same_workspace: { type: 'boolean' },
+                            },
+                        },
+                        baseline: {
+                            type: 'object',
+                            properties: { label: { type: 'string' }, decision_id: { type: 'string' } },
+                            required: ['decision_id'],
+                        },
+                        candidate: {
+                            type: 'object',
+                            properties: { label: { type: 'string' }, decision_id: { type: 'string' } },
+                            required: ['decision_id'],
+                        },
+                    },
+                    required: [],
+                },
+            },
             {
                 name: 'marrow_governance_control_plane',
                 description: 'Return Marrow control-plane proof: governance, runtime gates, proof packs, fleet intelligence, supported harnesses, and exact next action.',
@@ -1209,7 +1353,7 @@ if (process.argv[2] !== 'keys') {
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        agentId: { type: 'string', description: 'Optional agent filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent filter. Defaults to the canonical fleet-bound agent identity.' },
                         limit: { type: 'number', description: 'Max events to return, default 25, max 100.' },
                     },
                     required: [],
@@ -1232,7 +1376,7 @@ if (process.argv[2] !== 'keys') {
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        agentId: { type: 'string', description: 'Optional agent filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent filter. Defaults to the canonical fleet-bound agent identity.' },
                         periodDays: { type: 'number', description: 'Lookback period in days, default 30, max 90.' },
                     },
                     required: [],
@@ -1321,7 +1465,7 @@ if (process.argv[2] !== 'keys') {
                     type: 'object',
                     properties: {
                         period: { type: 'string', description: 'Time period: 7d (default), 14d, 30d, or day count up to 90.' },
-                        agentId: { type: 'string', description: 'Optional agent_id/session_id filter. Defaults to MARROW_AGENT_ID.' },
+                        agentId: { type: 'string', description: 'Optional agent_id/session_id filter. Defaults to the canonical fleet-bound agent identity.' },
                     },
                     required: [],
                 },
@@ -1454,6 +1598,24 @@ if (process.argv[2] !== 'keys') {
                 },
             },
         ];
+        const CORE_TOOL_NAMES = new Set([
+            'marrow_agent_runtime',
+            'marrow_commit',
+            'marrow_ask',
+            'marrow_status',
+            'marrow_auto',
+            'marrow_handoff_status',
+        ]);
+        function advertisedTools() {
+            return process.env.MARROW_TOOL_PROFILE === 'full'
+                ? TOOLS
+                : TOOLS.filter((tool) => CORE_TOOL_NAMES.has(tool.name));
+        }
+        function toolAllowedByActiveProfile(toolName) {
+            return process.env.MARROW_TOOL_PROFILE === 'full'
+                ? Boolean(toolName && TOOLS.some((tool) => tool.name === toolName))
+                : Boolean(toolName && CORE_TOOL_NAMES.has(toolName));
+        }
         // Request handler
         async function handleRequest(req) {
             const { id, method, params } = req;
@@ -1468,7 +1630,7 @@ if (process.argv[2] !== 'keys') {
                     success(id, {
                         protocolVersion: '2024-11-05',
                         capabilities: { tools: {}, prompts: {} },
-                        serverInfo: { name: 'marrow', version: '3.9.55' },
+                        serverInfo: { name: 'marrow', version: hook_contract_1.MCP_ADAPTER_VERSION },
                     });
                     // Auto-enroll: emit enrollment notification on connection
                     if (AUTO_ENROLL) {
@@ -1481,7 +1643,8 @@ if (process.argv[2] !== 'keys') {
                                 data: {
                                     type: 'auto_enroll',
                                     message: 'Marrow auto-enroll active. Call marrow_orient FIRST, then marrow_think before acting, marrow_commit after. Or use marrow_auto / marrow_run for one-call logging.',
-                                    agentId: AGENT_ID || 'auto',
+                                    agentId: FLEET_AGENT_ID,
+                                    client_update: (0, request_reliability_1.localClientUpdate)(),
                                 },
                             },
                         });
@@ -1554,29 +1717,21 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                     return;
                 }
                 if (method === 'tools/list') {
-                    success(id, { tools: TOOLS });
+                    success(id, { tools: advertisedTools() });
                     return;
                 }
                 if (method === 'tools/call') {
                     const toolName = params?.name;
                     const args = (params?.arguments || {});
+                    if (!toolAllowedByActiveProfile(toolName)) {
+                        error(id, -32601, 'Tool is not available in the active Marrow tool profile. Set MARROW_TOOL_PROFILE=full and restart MCP for advanced operator tools.');
+                        return;
+                    }
                     if (toolName === 'marrow_orient') {
                         orientCallCount++;
-                        let result;
                         const wantAutoWarn = args.autoWarn ?? true;
-                        try {
-                            result = await (0, index_1.marrowOrient)(API_KEY, BASE_URL, { taskType: args.taskType, autoWarn: wantAutoWarn }, SESSION_ID, FLEET_AGENT_ID);
-                        }
-                        catch (e) {
-                            // autoWarn endpoint may not be deployed yet — fall back to legacy orient
-                            if (wantAutoWarn) {
-                                process.stderr.write(`[marrow] autoWarn orient not available, falling back to legacy\n`);
-                                result = await (0, index_1.marrowOrient)(API_KEY, BASE_URL, { taskType: args.taskType, autoWarn: false }, SESSION_ID, FLEET_AGENT_ID);
-                            }
-                            else {
-                                throw e;
-                            }
-                        }
+                        const taskType = args.taskType;
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowOrient)(API_KEY, BASE_URL, { taskType, autoWarn: wantAutoWarn }, SESSION_ID, FLEET_AGENT_ID, signal), { highRisk: isHighRiskAction(`Orient before ${taskType || 'general'} work`, taskType) });
                         if (AUTO_ENROLL && orientCallCount === 1) {
                             const enrollmentText = `\n\n**Marrow control and proof active**\n\n` +
                                 `Marrow applies relevant policy and prior lessons before consequential actions, then records evidence and the real outcome afterward.\n\n` +
@@ -1680,6 +1835,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         // [FIX #9] Validate required params
                         const description = requireString(args, 'description');
                         const outcome = requireString(args, 'outcome');
+                        const measuredSuccess = requireBoolean(args, 'success');
                         // [FIX #16] Handle partial failures — return think result even if commit fails
                         let thinkResult = null;
                         try {
@@ -1697,18 +1853,12 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         try {
                             commitResult = await (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
                                 decision_id: thinkResult.decision_id,
-                                success: args.success ?? true,
+                                success: measuredSuccess,
                                 outcome,
-                                proof: {
-                                    summary: description,
-                                    checks: ['marrow_run completed'],
-                                    outcome,
-                                    blockers: (args.success ?? true) ? 'none' : 'see outcome',
-                                    commits_prs_shas: 'not applicable',
-                                    rollback_target: 'not applicable',
-                                    handoff_result_file: 'not applicable',
-                                    deployment_and_smoke: 'not applicable',
-                                },
+                                proof: args.proof && typeof args.proof === 'object' && !Array.isArray(args.proof)
+                                    ? (0, redact_1.redactSensitiveValue)(args.proof)
+                                    : undefined,
+                                gate_receipt_id: typeof args.gate_receipt_id === 'string' ? args.gate_receipt_id : undefined,
                                 action: description,
                                 type: args.type || 'general',
                             }, SESSION_ID, FLEET_AGENT_ID);
@@ -1738,50 +1888,90 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_auto') {
-                        // [FIX #9] Validate required param
                         const action = requireString(args, 'action');
                         const outcome = args.outcome;
-                        const outcomeSuccess = args.success ?? true;
+                        const outcomeSuccess = typeof args.success === 'boolean' ? args.success : undefined;
                         const type = args.type || 'general';
-                        // [FIX #8] Include pending flag so agent knows logging is deferred
+                        const highRisk = isHighRiskAction(action, type);
+                        const suppliedProof = args.proof && typeof args.proof === 'object' && !Array.isArray(args.proof)
+                            ? (0, redact_1.redactSensitiveValue)(args.proof)
+                            : undefined;
+                        let runtimeGate = null;
+                        if (highRisk) {
+                            runtimeGate = await withControlDeadline((signal) => (0, index_1.marrowAgentRuntime)(API_KEY, BASE_URL, {
+                                action: (0, redact_1.redactSensitiveText)(action),
+                                type,
+                                agent_id: FLEET_AGENT_ID,
+                                session_id: SESSION_ID,
+                                proof: suppliedProof,
+                                context: { source: 'mcp_auto_risk_upgrade' },
+                            }, SESSION_ID, FLEET_AGENT_ID, signal), { highRisk: true });
+                            storeRuntimeGuidance(runtimeGate);
+                        }
+                        const proofCanClose = !highRisk || (0, runtime_contract_1.highRiskRuntimeCanClose)(runtimeGate, suppliedProof, args.gate_receipt_id);
+                        const acceptedSuccess = proofCanClose ? outcomeSuccess : undefined;
+                        const receipt = await (0, lifecycle_spool_1.recordLifecycleEvent)({
+                            apiKey: API_KEY,
+                            baseUrl: BASE_URL,
+                            deferDelivery: true,
+                            event: {
+                                event_type: !highRisk && acceptedSuccess === false ? 'tool_failed' : !highRisk && acceptedSuccess === true ? 'tool_completed' : 'goal_started',
+                                harness: process.env.MARROW_CLIENT || process.env.MARROW_HARNESS || 'mcp',
+                                agent_id: FLEET_AGENT_ID,
+                                session_id: SESSION_ID,
+                                action,
+                                outcome_state: 'pending',
+                                success: highRisk ? undefined : acceptedSuccess,
+                                adapter_version: hook_contract_1.MCP_ADAPTER_VERSION,
+                                capability_level: 'mcp',
+                            },
+                        });
                         const response = {
                             action,
                             outcome: outcome || 'pending',
                             warnings: cachedOrientWarnings.map(formatWarningActionably),
-                            logging: 'deferred',
+                            logging: 'durably_queued',
+                            receipt,
+                            completion_state: outcomeSuccess === undefined ? 'pending_evidence' : 'delivery_pending',
+                            client_update: (0, request_reliability_1.localClientUpdate)(),
+                            ...(runtimeGate ? {
+                                runtime_gate: runtimeGate,
+                                completion_state: proofCanClose ? 'governed_delivery_pending' : 'pending_required_proof',
+                            } : {}),
                         };
-                        // Fire-and-forget the actual API calls
-                        (async () => {
-                            try {
-                                if (!outcome) {
-                                    await (0, index_1.marrowThink)(API_KEY, BASE_URL, { action, type }, SESSION_ID, FLEET_AGENT_ID);
-                                }
-                                else {
-                                    const thinkResult = await (0, index_1.marrowThink)(API_KEY, BASE_URL, { action, type }, SESSION_ID, FLEET_AGENT_ID);
-                                    await (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
-                                        decision_id: thinkResult.decision_id,
-                                        success: outcomeSuccess,
-                                        outcome,
-                                        proof: {
-                                            summary: action,
-                                            checks: ['marrow_auto completed'],
-                                            outcome,
-                                            blockers: outcomeSuccess ? 'none' : 'see outcome',
-                                            commits_prs_shas: 'not applicable',
-                                            rollback_target: 'not applicable',
-                                            handoff_result_file: 'not applicable',
-                                            deployment_and_smoke: 'not applicable',
-                                        },
-                                        action,
-                                        type,
-                                    }, SESSION_ID, FLEET_AGENT_ID);
-                                }
-                            }
-                            catch (err) {
-                                const msg = err instanceof Error ? err.message : String(err);
-                                process.stderr.write(`[marrow] marrow_auto background logging failed: ${msg}\n`);
+                        const delivery = () => (0, index_1.marrowAuto)(API_KEY, BASE_URL, {
+                            action,
+                            outcome,
+                            success: acceptedSuccess,
+                            type,
+                            proof: suppliedProof,
+                            gate_receipt_id: typeof args.gate_receipt_id === 'string'
+                                ? args.gate_receipt_id
+                                : runtimeGate?.gate_receipt?.id,
+                        }, SESSION_ID, FLEET_AGENT_ID, 1_500);
+                        if (highRisk && acceptedSuccess !== undefined) {
+                            const delivered = await delivery();
+                            if (!delivered.committed) {
+                                throw new request_reliability_1.MarrowRequestError({
+                                    code: 'invalid_response',
+                                    message: 'Marrow did not confirm the governed outcome commit',
+                                    retryable: true,
+                                    exactFix: 'Keep the outcome pending and retry marrow_commit with the fresh gate receipt and required proof.',
+                                });
                             }
-                        })();
+                            response.logging = 'governed_commit_confirmed';
+                            response.completion_state = 'closed_with_proof';
+                            response.decision_id = delivered.decision_id;
+                        }
+                        else if (!highRisk) {
+                            void delivery().catch((err) => {
+                                const failure = (0, request_reliability_1.structuredRequestFailure)(err);
+                                const errorCode = failure.error && typeof failure.error === 'object'
+                                    ? String(failure.error.code || 'request_failed')
+                                    : 'request_failed';
+                                process.stderr.write(`[marrow] marrow_auto queued; live delivery unavailable (${errorCode})\n`);
+                            });
+                        }
                         success(id, {
                             content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
                         });
@@ -1789,17 +1979,25 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                     }
                     if (toolName === 'marrow_ask') {
                         const query = requireString(args, 'query');
-                        const result = await (0, index_1.marrowAsk)(API_KEY, BASE_URL, { query }, SESSION_ID, FLEET_AGENT_ID);
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowAsk)(API_KEY, BASE_URL, { query }, SESSION_ID, FLEET_AGENT_ID, signal));
+                        try {
+                            (0, guidance_cache_1.writeGuidanceCache)({
+                                apiKey: API_KEY,
+                                baseUrl: BASE_URL,
+                                agentId: FLEET_AGENT_ID,
+                                context: `## Marrow answer\n- ${String(result.answer || 'No relevant lesson found.').slice(0, 1200)}`,
+                            });
+                        }
+                        catch { /* owner-only cache is best effort */ }
                         success(id, {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         });
                         return;
                     }
                     if (toolName === 'marrow_status') {
-                        const result = await (0, index_1.marrowStatus)(API_KEY, BASE_URL, SESSION_ID, FLEET_AGENT_ID);
-                        success(id, {
-                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                        });
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowStatus)(API_KEY, BASE_URL, SESSION_ID, FLEET_AGENT_ID, signal), { cacheAware: false });
+                        const statusRecord = result;
+                        toolSuccess(id, { ...statusRecord, client_update: statusRecord.client_update || (0, request_reliability_1.localClientUpdate)() });
                         return;
                     }
                     if (toolName === 'marrow_create_key') {
@@ -1932,17 +2130,17 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_agent_status') {
-                        const result = await (0, index_1.marrowAgentStatus)(API_KEY, BASE_URL, args.period || '7d', args.agentId || AGENT_ID, SESSION_ID, FLEET_AGENT_ID);
+                        const result = await (0, index_1.marrowAgentStatus)(API_KEY, BASE_URL, args.period || '7d', args.agentId || FLEET_AGENT_ID, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
                     if (toolName === 'marrow_runtime_status') {
-                        const result = await (0, index_1.marrowRuntimeStatus)(API_KEY, BASE_URL, args.fast !== false, SESSION_ID, FLEET_AGENT_ID);
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowRuntimeStatus)(API_KEY, BASE_URL, args.fast !== false, SESSION_ID, FLEET_AGENT_ID, signal), { cacheAware: false });
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
                     if (toolName === 'marrow_value_report') {
-                        const result = await (0, index_1.marrowValueReport)(API_KEY, BASE_URL, args.period || '7d', args.agentId || AGENT_ID, SESSION_ID, FLEET_AGENT_ID);
+                        const result = await (0, index_1.marrowValueReport)(API_KEY, BASE_URL, args.period || '7d', args.agentId || FLEET_AGENT_ID, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
@@ -1951,7 +2149,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             action: args.action,
                             type: args.type,
                             role: args.role,
-                            agent_id: args.agentId || AGENT_ID,
+                            agent_id: args.agentId || FLEET_AGENT_ID,
                             session_id: args.sessionId || SESSION_ID,
                             surfaces: Array.isArray(args.surfaces) ? args.surfaces : undefined,
                             period: args.period,
@@ -1964,7 +2162,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             action: args.action ? (0, redact_1.redactSensitiveText)(args.action) : undefined,
                             type: args.type,
                             role: args.role,
-                            agent_id: args.agentId || AGENT_ID,
+                            agent_id: args.agentId || FLEET_AGENT_ID,
                             session_id: args.sessionId || SESSION_ID,
                             surfaces: Array.isArray(args.surfaces) ? args.surfaces : undefined,
                             context: args.context && typeof args.context === 'object' && !Array.isArray(args.context)
@@ -1978,11 +2176,11 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_agent_runtime') {
-                        const result = await (0, index_1.marrowAgentRuntime)(API_KEY, BASE_URL, {
+                        const runtimeInput = {
                             action: (0, redact_1.redactSensitiveText)(args.action),
                             type: args.type,
                             role: args.role,
-                            agent_id: args.agentId || AGENT_ID,
+                            agent_id: args.agentId || FLEET_AGENT_ID,
                             session_id: args.sessionId || SESSION_ID,
                             surfaces: Array.isArray(args.surfaces) ? args.surfaces : undefined,
                             context: args.context && typeof args.context === 'object' && !Array.isArray(args.context)
@@ -1992,7 +2190,9 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                                 ? (0, redact_1.redactSensitiveValue)(args.proof)
                                 : undefined,
                             period: args.period,
-                        }, SESSION_ID, FLEET_AGENT_ID);
+                        };
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowAgentRuntime)(API_KEY, BASE_URL, runtimeInput, SESSION_ID, FLEET_AGENT_ID, signal), { highRisk: isHighRiskAction(runtimeInput.action, runtimeInput.type) });
+                        storeRuntimeGuidance(result);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
@@ -2006,7 +2206,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                                 : [],
                             action: typeof args.action === 'string' ? (0, redact_1.redactSensitiveText)(args.action) : undefined,
                             type: args.type,
-                            agent_id: args.agentId || AGENT_ID,
+                            agent_id: args.agentId || FLEET_AGENT_ID,
                             session_id: args.sessionId || SESSION_ID,
                             surfaces: Array.isArray(args.surfaces) ? args.surfaces : undefined,
                             context: args.context && typeof args.context === 'object' && !Array.isArray(args.context)
@@ -2019,6 +2219,19 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
+                    if (toolName === 'marrow_coordinate') {
+                        const coordinationArgs = { ...args };
+                        delete coordinationArgs.agent_id;
+                        delete coordinationArgs.source_agent_id;
+                        const result = await (0, index_1.marrowCoordinate)(API_KEY, BASE_URL, coordinationArgs, SESSION_ID, FLEET_AGENT_ID);
+                        success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
+                        return;
+                    }
+                    if (toolName === 'marrow_replay_compare') {
+                        const result = await (0, index_1.marrowReplayCompare)(API_KEY, BASE_URL, args, SESSION_ID, FLEET_AGENT_ID);
+                        success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
+                        return;
+                    }
                     if (toolName === 'marrow_governance_control_plane') {
                         const result = await (0, index_1.marrowGovernanceControlPlane)(API_KEY, BASE_URL, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
@@ -2049,7 +2262,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                     }
                     if (toolName === 'marrow_governance_timeline') {
                         const result = await (0, index_1.marrowGovernanceTimeline)(API_KEY, BASE_URL, {
-                            agentId: args.agentId || AGENT_ID,
+                            agentId: args.agentId || FLEET_AGENT_ID,
                             limit: args.limit,
                         }, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
@@ -2067,7 +2280,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                     }
                     if (toolName === 'marrow_buyer_proof') {
                         const result = await (0, index_1.marrowBuyerProof)(API_KEY, BASE_URL, {
-                            agentId: args.agentId || AGENT_ID,
+                            agentId: args.agentId || FLEET_AGENT_ID,
                             periodDays: args.periodDays,
                         }, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
@@ -2083,7 +2296,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                                 : undefined,
                             agent: args.agent && typeof args.agent === 'object' && !Array.isArray(args.agent)
                                 ? (0, redact_1.redactSensitiveValue)(args.agent)
-                                : { id: FLEET_AGENT_ID || AGENT_ID },
+                                : { id: FLEET_AGENT_ID },
                             selected_mode: args.selected_mode,
                             selection_source: args.selection_source,
                         }, SESSION_ID, FLEET_AGENT_ID);
@@ -2124,7 +2337,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                                 : undefined,
                             agent: args.agent && typeof args.agent === 'object' && !Array.isArray(args.agent)
                                 ? (0, redact_1.redactSensitiveValue)(args.agent)
-                                : { id: FLEET_AGENT_ID || AGENT_ID },
+                                : { id: FLEET_AGENT_ID },
                         }, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
@@ -2143,7 +2356,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_agent_performance') {
-                        const result = await (0, index_1.marrowAgentPerformance)(API_KEY, BASE_URL, args.period || '7d', args.agentId || AGENT_ID, SESSION_ID, FLEET_AGENT_ID);
+                        const result = await (0, index_1.marrowAgentPerformance)(API_KEY, BASE_URL, args.period || '7d', args.agentId || FLEET_AGENT_ID, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
@@ -2151,7 +2364,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         const result = await (0, index_1.marrowFleetLessons)(API_KEY, BASE_URL, {
                             query: args.query,
                             type: args.type,
-                            agentId: args.agentId || AGENT_ID,
+                            agentId: args.agentId || FLEET_AGENT_ID,
                             limit: args.limit,
                         }, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
@@ -2180,7 +2393,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                     if (toolName === 'marrow_handoff_status') {
                         const result = await (0, index_1.marrowHandoffStatus)(API_KEY, BASE_URL, {
                             status: args.status,
-                            agentId: args.agentId || AGENT_ID,
+                            agentId: args.agentId || FLEET_AGENT_ID,
                             limit: args.limit,
                         }, SESSION_ID, FLEET_AGENT_ID);
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
@@ -2226,8 +2439,12 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                 error(id, -32601, `Method not found: ${method}`);
             }
             catch (err) {
+                if (err instanceof request_reliability_1.MarrowRequestError && method === 'tools/call') {
+                    toolSuccess(id, toolFailure(params?.name, err), true);
+                    return;
+                }
                 const message = err instanceof Error ? err.message : String(err);
-                error(id, -32000, message);
+                error(id, -32602, (0, redact_1.redactSensitiveText)(message).slice(0, 240));
             }
         }
         // MCP stdio loop — raw stdin, no readline (readline writes prompts to stdout which breaks MCP)