@getmarrow/mcp 3.9.58 → 3.9.60

package/README.md

@@ -57,7 +57,7 @@ Verify current claims through the [public evidence manifest](https://getmarrow.a
 ## Install
 
 ```bash
-npx @getmarrow/mcp setup
+npx -y --package=@getmarrow/mcp@latest marrow-mcp setup
 ```
 
 Set the key through trusted secret storage:
@@ -75,7 +75,7 @@ Then configure the MCP server:
   "mcpServers": {
     "marrow": {
       "command": "npx",
-      "args": ["-y", "@getmarrow/mcp"]
+      "args": ["-y", "--package=@getmarrow/mcp@latest", "marrow-mcp"]
     }
   }
 }
@@ -96,15 +96,44 @@ npx -y @getmarrow/install@latest activate
 npx -y @getmarrow/install@latest doctor
 
 # Manual MCP-only setup
-npx -y @getmarrow/mcp@latest setup
+npx -y --package=@getmarrow/mcp@latest marrow-mcp setup
 
 # Verify live read latency, last success, and local backlog
-npx -y @getmarrow/mcp@latest ping
+npx -y --package=@getmarrow/mcp@latest marrow-mcp ping
 ```
 
 Detection and notification are automatic. After explicit installer activation, the local controller may restore only Marrow-managed hooks/configuration. Package upgrades, owner policy, credentials, and unrelated configuration remain explicit and subject to the operator's normal change policy.
 
-## What's New in v3.9.58
+## What's New in v3.9.60
+
+v3.9.60 restores the complete control-and-proof loop for ordinary MCP clients:
+
+- cached guidance no longer cuts live status, ask, runtime, or handoff reads down to an impossible 500 ms deadline;
+- `marrow_auto` waits for the bounded think-and-commit path and reports the live decision and proof result in-band;
+- `marrow_commit` now shares the same abort and deadline contract as the other control calls;
+- transient retries use a one-second delay so a slow edge path is not immediately hit again;
+- spool status surfaces backlogs under older credential namespaces without replaying them across an unverified tenant boundary;
+- a plan-gated handoff is reported as unavailable for the current plan, not as an API or authentication outage;
+- the release canary runs with the customer's default client deadlines instead of silently overriding them.
+
+MCP-only hosts, including Grok today, receive Marrow's control instructions but cannot expose native always-on lifecycle hooks unless the host implements them. Marrow reports that capability boundary explicitly instead of claiming hook coverage it cannot observe.
+
+## Previous: v3.9.59
+
+v3.9.59 makes the six-tool control path reliable and honest across ordinary edge and geographic latency:
+
+- the default health deadline is 2.5 seconds instead of an unrealistically narrow 400 ms;
+- `MARROW_PING_TIMEOUT_MS` can tune the probe between 500 ms and 5 seconds;
+- authenticated control reads tolerate cold network/TLS paths while cached reads still return quickly;
+- status, ask, runtime, and handoff responses report measured current/p50/p99 latency plus owner-only queue health;
+- a first-session outage returns a clearly labeled local safety brief, and infrastructure failures are never mislabeled as policy denials;
+- timeout errors return a concrete retry delay instead of an unresolved placeholder;
+- Cloudflare edge denials are separated from key-scope or Marrow policy rejections;
+- MCP initialization carries the always-on control/proof instructions even when a client does not request the optional prompt template;
+- update, launch, setup, spool, and ping commands use the unambiguous `npx --package ... marrow-mcp` form;
+- explicit spool drains tolerate slow edge delivery without extending passive hook latency.
+
+## Previous: v3.9.58
 
 v3.9.58 makes latency evidence accurate by reusing one initialized MCP process for the complete control-path canary:
 
@@ -133,7 +162,7 @@ v3.9.56 adds tenant-scoped coordination and evidence-only replay to the existing
 - transient failures can use an owner-only, account/key/agent-scoped last-known brief for at most one hour, clearly labeled with its age;
 - 401 and 403 responses never use cached guidance, and cached runtime guidance cannot authorize high-risk work;
 - `marrow_ask` now maps to the canonical decision brief contract instead of a separate route;
-- `npx -y @getmarrow/mcp@latest ping` reports current latency, rolling measured p50/p99, last success, and lifecycle backlog health;
+- `npx -y --package=@getmarrow/mcp@latest marrow-mcp ping` reports current latency, rolling measured p50/p99, last success, and lifecycle backlog health;
 - `marrow_coordinate` acquires/releases tenant-scoped resource leases and carries compact child proof packets without sharing transcripts;
 - `marrow_replay_compare` compares already-recorded baseline and candidate outcomes with durable proof and never executes either model;
 - both new tools preserve agent-bound key scope, reject unsafe path identifiers, and return unavailable or incomplete evidence rather than manufacturing a winner.
@@ -316,15 +345,15 @@ it does not run models, retain prompts, or infer a winner from labels.
 
 ## Passive Use
 
-`npx @getmarrow/mcp setup` installs supported prompt, tool-result, and session-stop hooks so the agent can receive before-action context, record meaningful tool outcomes, and keep unfinished closure visible without the owner repeatedly prompting it to use Marrow.
+`npx -y --package=@getmarrow/mcp@latest marrow-mcp setup` installs supported prompt, tool-result, and session-stop hooks so the agent can receive before-action context, record meaningful tool outcomes, and keep unfinished closure visible without the owner repeatedly prompting it to use Marrow.
 
 The hooks send compact classifications and lifecycle receipts. They do not need raw prompts, completions, command output, tool output, or credentials. A completed tool or session does not automatically become a successful business outcome; explicit success/failure closure is required.
 
 Transient lifecycle receipts use a bounded owner-only spool and are retried with stable event IDs. Operators can inspect and drain it without exposing event content:
 
 ```bash
-npx @getmarrow/mcp spool-status
-npx @getmarrow/mcp drain-spool
+npx -y --package=@getmarrow/mcp@latest marrow-mcp spool-status
+npx -y --package=@getmarrow/mcp@latest marrow-mcp drain-spool
 ```
 
 The output contains only state, exact pending/failed counts, oldest receipt timestamps, capacity, and an exact fix. Terminal validation/authentication failures and exhausted retries remain explicit durable failures rather than cycling indefinitely.

package/dist/cli.js

@@ -21,6 +21,7 @@ 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 control_path_state_1 = require("./control-path-state");
 const redact_1 = require("./redact");
 const runtime_contract_1 = require("./runtime-contract");
 // Parse CLI args
@@ -73,7 +74,7 @@ async function runPingCommand() {
     }
     const baseUrl = (0, index_1.validateBaseUrl)(resolved.baseUrl || 'https://api.getmarrow.ai');
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 400);
+    const timer = setTimeout(() => controller.abort(), (0, ping_state_1.resolvePingTimeoutMs)(process.env.MARROW_PING_TIMEOUT_MS));
     timer.unref?.();
     const started = Date.now();
     try {
@@ -126,12 +127,17 @@ async function runSpoolCommand(drain) {
     const status = drain
         ? await (0, lifecycle_spool_1.drainLifecycleSpool)({ apiKey, baseUrl, agentId: resolved.agentId || undefined })
         : (0, lifecycle_spool_1.lifecycleSpoolStatus)({ apiKey, agentId: resolved.agentId || undefined });
+    const namespaceAttention = status.other_namespaces.state === 'attention_required';
     process.stdout.write(`${JSON.stringify({
-        ok: status.state !== 'attention_required',
+        ok: drain
+            ? status.state === 'clear' && !namespaceAttention
+            : status.state !== 'attention_required' && !namespaceAttention,
         lifecycle_spool: status,
     }, null, 2)}\n`);
-    if (status.state === 'attention_required')
+    if (status.state === 'attention_required' || namespaceAttention)
         process.exitCode = 2;
+    else if (drain && status.state !== 'clear')
+        process.exitCode = 1;
 }
 // ─── Setup command: inject Marrow instructions into CLAUDE.md ───
 function runSetup() {
@@ -441,27 +447,76 @@ if (process.argv[2] !== 'keys') {
         }
         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) {
+            const infrastructureFailure = !['authentication_required', 'permission_denied'].includes(failure.code);
+            const supportsStale = ['marrow_agent_runtime', 'marrow_orient', 'marrow_ask', 'marrow_handoff_status', 'marrow_runtime_status', 'marrow_status'].includes(toolName || '');
+            const spool = (0, lifecycle_spool_1.lifecycleSpoolStatus)({ apiKey: API_KEY, agentId: FLEET_AGENT_ID });
+            result.failure_kind = infrastructureFailure ? 'infrastructure' : 'authorization';
+            result.control_path = (0, control_path_state_1.controlPathStats)(toolName || 'marrow_control');
+            result.lifecycle_spool = {
+                ...spool,
+                drain_command: 'npx -y --package=@getmarrow/mcp@latest marrow-mcp drain-spool',
+            };
+            result.host_capability = mcpHostCapability();
+            if (infrastructureFailure && 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_brief = cached?.context || [
+                    '## Marrow control-path outage brief',
+                    '- This is an infrastructure failure; Marrow returned no policy decision and did not deny the action.',
+                    '- Preserve local evidence and continue only low-risk, reversible work under the owner\'s existing safeguards.',
+                    '- Do not perform high-risk work until a fresh Marrow runtime gate returns allow, warn, review_required, or block.',
+                ].join('\n');
+                result.stale_source = cached ? 'last_known_guidance' : 'local_outage_safety';
+                result.stale_ms = cached?.stale_ms ?? null;
+                result.authorization_state = 'unavailable';
+                result.gate_obtained = false;
                 result.stale_can_authorize_high_risk = false;
+                const retryAfterMs = failure.retryAfterMs;
                 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.';
+                    : retryAfterMs != null
+                        ? `Wait ${retryAfterMs} ms, then retry once. Do not perform high-risk work without a fresh Marrow runtime gate.`
+                        : failure.exactFix;
             }
             return result;
         }
+        function mcpHostCapability() {
+            const raw = String(process.env.MARROW_CLIENT || process.env.MARROW_HARNESS || '').trim().toLowerCase();
+            const host = ['grok', 'claude-code', 'codex', 'cursor', 'windsurf', 'gemini', 'kimi', 'qwen', 'deepseek']
+                .includes(raw) ? raw : 'mcp-client';
+            return {
+                transport: 'mcp_stdio',
+                host,
+                tools_available: true,
+                tool_invocation: 'on_demand',
+                passive_hooks: {
+                    provided_by_mcp_transport: false,
+                    external_host_hook_state: 'unverified',
+                    observed_by_this_process: false,
+                },
+                always_on_state: 'host_dependent',
+                exact_next_action: 'Use the Marrow MCP tools on demand. Claim passive coverage only when the host separately configures trusted hooks and Marrow receives their lifecycle receipts.',
+            };
+        }
+        function clientOperationalPayload(toolName, value) {
+            const payload = value && typeof value === 'object' && !Array.isArray(value)
+                ? value
+                : { data: value };
+            const spool = (0, lifecycle_spool_1.lifecycleSpoolStatus)({ apiKey: API_KEY, agentId: FLEET_AGENT_ID });
+            return {
+                ...payload,
+                host_capability: payload.host_capability || mcpHostCapability(),
+                client_update: payload.client_update || (0, request_reliability_1.localClientUpdate)(),
+                control_path: (0, control_path_state_1.controlPathStats)(toolName),
+                lifecycle_spool: {
+                    ...spool,
+                    drain_command: 'npx -y --package=@getmarrow/mcp@latest marrow-mcp drain-spool',
+                },
+            };
+        }
         // [FIX #9] Runtime validation helper for required string params
         function requireString(args, name) {
             const val = args[name];
@@ -480,25 +535,25 @@ if (process.argv[2] !== 'keys') {
         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 toolName = options.toolName || 'marrow_control';
+            const configuredTimeoutMs = Number(process.env.MARROW_REQUEST_TIMEOUT_MS);
+            const runtimeBudget = toolName === 'marrow_agent_runtime' || toolName === 'marrow_auto.runtime';
+            const timeoutMs = Number.isFinite(configuredTimeoutMs)
+                ? Math.min(10_000, Math.max(150, Math.floor(configuredTimeoutMs)))
+                : options.highRisk || runtimeBudget ? 4_500 : 4_000;
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), timeoutMs);
             timer.unref?.();
+            const startedAt = Date.now();
             try {
-                return await operation(controller.signal);
+                const result = await operation(controller.signal);
+                (0, control_path_state_1.recordControlPathSample)(toolName, Date.now() - startedAt, true);
+                return result;
+            }
+            catch (error) {
+                (0, control_path_state_1.recordControlPathSample)(toolName, Date.now() - startedAt, false);
+                throw error;
             }
             finally {
                 clearTimeout(timer);
@@ -1631,6 +1686,9 @@ if (process.argv[2] !== 'keys') {
                         protocolVersion: '2024-11-05',
                         capabilities: { tools: {}, prompts: {} },
                         serverInfo: { name: 'marrow', version: hook_contract_1.MCP_ADAPTER_VERSION },
+                        ...(AUTO_ENROLL ? {
+                            instructions: 'Use marrow_agent_runtime before consequential actions, obey fresh allow/warn/review_required/block results, use marrow_ask for relevant prior lessons, and close meaningful outcomes with marrow_commit. Infrastructure failures are not policy denials; continue only low-risk reversible work from the returned outage-safe brief, and require a fresh gate for high-risk work. MCP tools are on demand; do not claim passive or prompt-injection coverage unless the host separately configured trusted hooks and Marrow observed their receipts.',
+                        } : {}),
                     });
                     // Auto-enroll: emit enrollment notification on connection
                     if (AUTO_ENROLL) {
@@ -1731,7 +1789,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         orientCallCount++;
                         const wantAutoWarn = args.autoWarn ?? true;
                         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) });
+                        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), toolName: 'marrow_orient' });
                         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` +
@@ -1798,12 +1856,10 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         // [FIX #9] Validate required params
                         const decision_id = requireString(args, 'decision_id');
                         const outcome = requireString(args, 'outcome');
-                        if (typeof args.success !== 'boolean') {
-                            throw new Error('"success" is required and must be a boolean');
-                        }
-                        const result = await (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
+                        const commitSuccess = requireBoolean(args, 'success');
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
                             decision_id,
-                            success: args.success,
+                            success: commitSuccess,
                             outcome,
                             caused_by: args.caused_by,
                             proof: args.proof,
@@ -1815,10 +1871,10 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             surfaces: args.surfaces,
                             auto_gate: args.auto_gate,
                             model_usage: args.model_usage,
-                        }, SESSION_ID, FLEET_AGENT_ID);
+                        }, SESSION_ID, FLEET_AGENT_ID, signal), { highRisk: true, cacheAware: false, toolName: 'marrow_commit' });
                         const commitResult = { ...result, narrative: result.narrative ?? null };
-                        lastCommitted = true;
-                        lastDecisionId = null;
+                        lastCommitted = result.committed;
+                        lastDecisionId = result.committed ? null : decision_id;
                         success(id, {
                             content: [{ type: 'text', text: JSON.stringify(commitResult, null, 2) }],
                         });
@@ -1905,23 +1961,48 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                                 session_id: SESSION_ID,
                                 proof: suppliedProof,
                                 context: { source: 'mcp_auto_risk_upgrade' },
-                            }, SESSION_ID, FLEET_AGENT_ID, signal), { highRisk: true });
+                            }, SESSION_ID, FLEET_AGENT_ID, signal), { highRisk: true, toolName: 'marrow_auto.runtime' });
                             storeRuntimeGuidance(runtimeGate);
                         }
                         const proofCanClose = !highRisk || (0, runtime_contract_1.highRiskRuntimeCanClose)(runtimeGate, suppliedProof, args.gate_receipt_id);
                         const acceptedSuccess = proofCanClose ? outcomeSuccess : undefined;
+                        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, 8_000);
+                        let delivered = null;
+                        let deliveryFailure = null;
+                        try {
+                            delivered = await delivery();
+                        }
+                        catch (err) {
+                            deliveryFailure = (0, request_reliability_1.structuredRequestFailure)(err);
+                        }
                         const receipt = await (0, lifecycle_spool_1.recordLifecycleEvent)({
                             apiKey: API_KEY,
                             baseUrl: BASE_URL,
-                            deferDelivery: true,
+                            deferDelivery: false,
                             event: {
-                                event_type: !highRisk && acceptedSuccess === false ? 'tool_failed' : !highRisk && acceptedSuccess === true ? 'tool_completed' : 'goal_started',
+                                event_type: delivered?.committed
+                                    ? 'outcome_committed'
+                                    : !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,
+                                decision_id: delivered?.decision_id,
                                 action,
-                                outcome_state: 'pending',
-                                success: highRisk ? undefined : acceptedSuccess,
+                                outcome_state: delivered?.committed ? 'closed' : 'pending',
+                                success: delivered?.committed ? acceptedSuccess : highRisk ? undefined : acceptedSuccess,
                                 adapter_version: hook_contract_1.MCP_ADAPTER_VERSION,
                                 capability_level: 'mcp',
                             },
@@ -1930,48 +2011,29 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             action,
                             outcome: outcome || 'pending',
                             warnings: cachedOrientWarnings.map(formatWarningActionably),
-                            logging: 'durably_queued',
+                            logging: delivered?.committed
+                                ? 'governed_commit_confirmed'
+                                : delivered
+                                    ? 'intent_confirmed'
+                                    : 'durably_queued',
                             receipt,
-                            completion_state: outcomeSuccess === undefined ? 'pending_evidence' : 'delivery_pending',
+                            completion_state: delivered?.committed
+                                ? 'closed_with_proof'
+                                : !proofCanClose
+                                    ? 'pending_required_proof'
+                                    : outcomeSuccess === undefined
+                                        ? 'pending_evidence'
+                                        : 'delivery_pending',
+                            decision_id: delivered?.decision_id || null,
+                            live_delivery: {
+                                accepted: Boolean(delivered),
+                                committed: Boolean(delivered?.committed),
+                                ...(deliveryFailure ? { failure: deliveryFailure } : {}),
+                            },
+                            host_capability: mcpHostCapability(),
                             client_update: (0, request_reliability_1.localClientUpdate)(),
-                            ...(runtimeGate ? {
-                                runtime_gate: runtimeGate,
-                                completion_state: proofCanClose ? 'governed_delivery_pending' : 'pending_required_proof',
-                            } : {}),
+                            ...(runtimeGate ? { runtime_gate: runtimeGate } : {}),
                         };
-                        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) }],
                         });
@@ -1979,7 +2041,7 @@ 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 withControlDeadline((signal) => (0, index_1.marrowAsk)(API_KEY, BASE_URL, { query }, SESSION_ID, FLEET_AGENT_ID, signal));
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowAsk)(API_KEY, BASE_URL, { query }, SESSION_ID, FLEET_AGENT_ID, signal), { toolName: 'marrow_ask' });
                         try {
                             (0, guidance_cache_1.writeGuidanceCache)({
                                 apiKey: API_KEY,
@@ -1989,15 +2051,12 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             });
                         }
                         catch { /* owner-only cache is best effort */ }
-                        success(id, {
-                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                        });
+                        toolSuccess(id, clientOperationalPayload('marrow_ask', result));
                         return;
                     }
                     if (toolName === 'marrow_status') {
-                        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)() });
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowStatus)(API_KEY, BASE_URL, SESSION_ID, FLEET_AGENT_ID, signal), { cacheAware: false, toolName: 'marrow_status' });
+                        toolSuccess(id, clientOperationalPayload('marrow_status', result));
                         return;
                     }
                     if (toolName === 'marrow_create_key') {
@@ -2135,7 +2194,7 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_runtime_status') {
-                        const result = await withControlDeadline((signal) => (0, index_1.marrowRuntimeStatus)(API_KEY, BASE_URL, args.fast !== false, SESSION_ID, FLEET_AGENT_ID, signal), { cacheAware: false });
+                        const result = await withControlDeadline((signal) => (0, index_1.marrowRuntimeStatus)(API_KEY, BASE_URL, args.fast !== false, SESSION_ID, FLEET_AGENT_ID, signal), { cacheAware: false, toolName: 'marrow_runtime_status' });
                         success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
                         return;
                     }
@@ -2191,9 +2250,9 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                                 : undefined,
                             period: args.period,
                         };
-                        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) });
+                        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), toolName: 'marrow_agent_runtime' });
                         storeRuntimeGuidance(result);
-                        success(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
+                        toolSuccess(id, clientOperationalPayload('marrow_agent_runtime', result));
                         return;
                     }
                     if (toolName === 'marrow_arbitrate') {
@@ -2391,12 +2450,35 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_handoff_status') {
-                        const result = await (0, index_1.marrowHandoffStatus)(API_KEY, BASE_URL, {
-                            status: args.status,
-                            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) }] });
+                        try {
+                            const result = await withControlDeadline((signal) => (0, index_1.marrowHandoffStatus)(API_KEY, BASE_URL, {
+                                status: args.status,
+                                agentId: args.agentId || FLEET_AGENT_ID,
+                                limit: args.limit,
+                            }, SESSION_ID, FLEET_AGENT_ID, signal), { cacheAware: false, toolName: 'marrow_handoff_status' });
+                            toolSuccess(id, clientOperationalPayload('marrow_handoff_status', result));
+                        }
+                        catch (error) {
+                            if (error instanceof request_reliability_1.MarrowRequestError && error.backendCode === 'MARROW_PLAN_UPGRADE_REQUIRED') {
+                                toolSuccess(id, clientOperationalPayload('marrow_handoff_status', {
+                                    ok: true,
+                                    available: false,
+                                    state: 'not_entitled',
+                                    failure_kind: 'entitlement',
+                                    authorization_state: 'plan_limited',
+                                    credential_valid: true,
+                                    feature: 'fleet_handoff_status',
+                                    current_plan: error.currentPlan,
+                                    required_plan: 'team',
+                                    required_feature: error.requiredFeature || 'fleet_learning',
+                                    service_reachable: true,
+                                    exact_next_action: 'Use status, ask, runtime, auto, and commit on the current plan. Upgrade to Team before relying on fleet handoff status.',
+                                }));
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
                         return;
                     }
                     if (toolName === 'marrow_session_end') {