@getmarrow/mcp 3.9.85 → 3.9.87

package/README.md

@@ -130,7 +130,13 @@ A direct `marrow_think` can receive a durable pending response before the backen
 
 A saved `observed_unverified` outcome is terminal observation evidence, not a committed outcome. Receipt expiry cannot retroactively authorize completed work. Preserve the original decision, receipt, proof and key; an already authorized durable checkpoint may finish through its existing exact recovery path. Do not repeat the action merely to obtain a fresh receipt.
 
-## What's New in v3.9.85
+## What's New in v3.9.87
+
+v3.9.87 hardens the authenticated control-path canary against single-sample transport blips so monitoring stops flapping on a healthy service. The canary now retries transport-class delivery failures (`request_failed`, `service_unavailable`, `connection_reset`, `dns_unavailable`, `tls_failure`, `edge_access_denied`, `rate_limited`) in-run with the same idempotent operation before declaring a failure, gives the asynchronous `marrow_auto` and `marrow_first_value` calls a separate deadline ceiling (thirty seconds via `MARROW_MCP_CANARY_ASYNC_TOOL_TIMEOUT_MS`), and raises the default total canary budget to forty-five seconds so bounded retries fit. Results recovered by a retry are annotated with `recovered_on_retry: true`. Authentication, authorization, contract, and package-identity failures remain immediate hard failures with no retry. Tool surface, client contracts, and request deadlines are unchanged.
+
+v3.9.86 was published with the adapter version constant still at `3.9.85`, so the strict canary identity check rejected it; it is deprecated — use `3.9.87`. SDK `3.7.62` and installer `0.1.56` are unchanged; install MCP `3.9.87`, reload the host, review hook trust, and verify before claiming the updated client is active.
+
+### Previous release: v3.9.85
 
 v3.9.85 keeps the existing Marrow Auto request and response deadlines active through response-body consumption and JSON parsing, so a server that sends headers and then stalls ends with the same typed bounded timeout as a stalled header response. The retry owner, four-second write-attempt ceiling, and eight-second Auto response budget are unchanged.
 

package/dist/hook-contract.d.ts

@@ -1,8 +1,8 @@
 import { resolveMarrowEnv, type ResolvedMarrowEnv } from './env';
-export declare const MCP_ADAPTER_VERSION = "3.9.85";
+export declare const MCP_ADAPTER_VERSION = "3.9.87";
 export declare const NATIVE_HOOK_MATCHER = "Bash|Edit|Write|MultiEdit|mcp__(?!marrow__marrow_).*";
 export declare const GROK_NATIVE_HOOK_MATCHER = "run_terminal_command|search_replace|write|spawn_subagent|use_tool|workflow|image_gen|image_edit|image_to_video|reference_to_video";
-export declare const MCP_PACKAGE_SPEC = "@getmarrow/mcp@3.9.85";
+export declare const MCP_PACKAGE_SPEC = "@getmarrow/mcp@3.9.87";
 export declare const CONTEXT_HOOK_COMMAND: string;
 export declare const PRE_ACTION_HOOK_COMMAND: string;
 export declare const ACTION_RESULT_HOOK_COMMAND: string;

package/dist/hook-contract.js

@@ -20,7 +20,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const env_1 = require("./env");
-exports.MCP_ADAPTER_VERSION = '3.9.85';
+exports.MCP_ADAPTER_VERSION = '3.9.87';
 exports.NATIVE_HOOK_MATCHER = 'Bash|Edit|Write|MultiEdit|mcp__(?!marrow__marrow_).*';
 exports.GROK_NATIVE_HOOK_MATCHER = 'run_terminal_command|search_replace|write|spawn_subagent|use_tool|workflow|image_gen|image_edit|image_to_video|reference_to_video';
 exports.MCP_PACKAGE_SPEC = `@getmarrow/mcp@${exports.MCP_ADAPTER_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmarrow/mcp",
-  "version": "3.9.85",
+  "version": "3.9.87",
   "mcpName": "io.github.getmarrow/marrow",
   "description": "Runtime control, proof, and fleet intelligence for MCP-compatible AI agents.",
   "bin": {

package/scripts/control-path-canary.cjs

@@ -16,14 +16,24 @@ try {
 
 const CANARY_TOOL_TIMEOUT_MARGIN_MS = 2_000;
 const CANARY_TOOL_TIMEOUT_MAX_MS = 10_000;
+const CANARY_ASYNC_TOOL_TIMEOUT_MAX_MS = 30_000;
 const CANARY_DEFAULT_TOOL_TIMEOUT_MS = Math.min(
   CANARY_TOOL_TIMEOUT_MAX_MS,
   (MARROW_AUTO_RESPONSE_BUDGET_MAX_MS || 8_000) + CANARY_TOOL_TIMEOUT_MARGIN_MS,
 );
+const CANARY_DEFAULT_ASYNC_TOOL_TIMEOUT_MS = Math.min(
+  CANARY_ASYNC_TOOL_TIMEOUT_MAX_MS,
+  (MARROW_AUTO_RESPONSE_BUDGET_MAX_MS || 8_000) + CANARY_TOOL_TIMEOUT_MARGIN_MS,
+);
+const CANARY_DEFAULT_TOTAL_TIMEOUT_MS = 45_000;
+const TRANSPORT_RETRY_WAIT_MS = 1_000;
 
 if (CANARY_DEFAULT_TOOL_TIMEOUT_MS < MARROW_AUTO_RESPONSE_BUDGET_MAX_MS + CANARY_TOOL_TIMEOUT_MARGIN_MS) {
   configurationFailed = true;
 }
+if (CANARY_DEFAULT_ASYNC_TOOL_TIMEOUT_MS < MARROW_AUTO_RESPONSE_BUDGET_MAX_MS + CANARY_TOOL_TIMEOUT_MARGIN_MS) {
+  configurationFailed = true;
+}
 
 function canaryCases(operationId) {
   return [
@@ -56,6 +66,15 @@ const HOT_PATH_TOOLS = new Set([
   'marrow_agent_runtime',
   'marrow_auto',
 ]);
+const ASYNC_PATH_TOOLS = new Set([
+  'marrow_auto',
+  'marrow_first_value',
+]);
+const TRANSPORT_RETRY_ERROR_CLASSES = new Set(['tool_unavailable', 'unavailable503']);
+const AUTO_TRANSPORT_RETRY_CATEGORIES = new Set([
+  'request_failed', 'service_unavailable', 'connection_reset', 'dns_unavailable',
+  'tls_failure', 'edge_access_denied', 'rate_limited',
+]);
 const OUTPUT_LIMIT_BYTES = 256 * 1024;
 const TOOL_NAMES = new Set(canaryCases('').map(([name]) => name));
 const errorEvidence = new WeakMap();
@@ -542,7 +561,14 @@ async function executeCanary(env, options, context) {
     CANARY_TOOL_TIMEOUT_MAX_MS,
     env,
   );
-  const totalTimeoutMs = boundedMs('MARROW_MCP_CANARY_TOTAL_TIMEOUT_MS', 30_000, 2_000, 60_000, env);
+  const asyncToolTimeoutMs = boundedMs(
+    'MARROW_MCP_CANARY_ASYNC_TOOL_TIMEOUT_MS',
+    CANARY_DEFAULT_ASYNC_TOOL_TIMEOUT_MS,
+    250,
+    CANARY_ASYNC_TOOL_TIMEOUT_MAX_MS,
+    env,
+  );
+  const totalTimeoutMs = boundedMs('MARROW_MCP_CANARY_TOTAL_TIMEOUT_MS', CANARY_DEFAULT_TOTAL_TIMEOUT_MS, 2_000, 60_000, env);
   const expectedVersion = env.MARROW_EXPECTED_MCP_VERSION || packageVersion;
   const childPath = env.MARROW_MCP_CANARY_CHILD || resolve(__dirname, '../dist/cli.js');
   const childEnv = {
@@ -598,9 +624,11 @@ async function executeCanary(env, options, context) {
     const results = context.results;
     for (const [name, args] of cases) {
       const callStarted = performance.now();
+      const perToolTimeoutMs = ASYNC_PATH_TOOLS.has(name) ? asyncToolTimeoutMs : toolTimeoutMs;
       let called;
       let payload;
       let attempts = 0;
+      let recoveredOnRetry = false;
       context.retryWaitMs = 0;
       context.autoMetrics = undefined;
       context.autoPhase = undefined;
@@ -613,13 +641,13 @@ async function executeCanary(env, options, context) {
         stage('tool_call', name, attempt + 1);
         attempts += 1;
         try {
-          called = await client.request('tools/call', { name, arguments: args });
+          called = await client.request('tools/call', { name, arguments: args }, perToolTimeoutMs);
           if (client.fatalError) throw client.fatalError;
           stage('tool_validate', name, attempt + 1);
           payload = toolPayload(called, name);
         } catch (error) {
+          const evidence = errorEvidence.get(error);
           if (name === 'marrow_auto') {
-            const evidence = errorEvidence.get(error);
             autoAttemptRecords.push({
               attempt: attempt + 1,
               duration_ms: safeMs(performance.now() - outerAttemptStarted),
@@ -631,6 +659,17 @@ async function executeCanary(env, options, context) {
               actual_wait_ms: 0,
             });
           }
+          // One bounded in-run retry for transport-class failures: a single edge
+          // reset or 503 must not fail the canary when the very next call succeeds.
+          const remaining = totalTimeoutMs - (performance.now() - context.started);
+          const mayRetry = name === 'marrow_auto' ? attempt < 2 : attempt < 1;
+          if (evidence && TRANSPORT_RETRY_ERROR_CLASSES.has(evidence.error_class)
+            && mayRetry && remaining > TRANSPORT_RETRY_WAIT_MS + 250) {
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, TRANSPORT_RETRY_WAIT_MS));
+            context.retryWaitMs += TRANSPORT_RETRY_WAIT_MS;
+            recoveredOnRetry = true;
+            continue;
+          }
           throw error;
         }
         if (name !== 'marrow_auto') break;
@@ -643,11 +682,17 @@ async function executeCanary(env, options, context) {
         context.autoMetrics = autoTimings(payload);
         const waitClass = autoWaitClass(payload);
         context.autoPhase = waitClass ? payload.phase : undefined;
-        if (waitClass !== 'completion_pending') break;
+        const autoFailureCategory = payload?.live_delivery?.failure?.error?.category;
+        const transportRetryable = waitClass == null
+          && AUTO_TRANSPORT_RETRY_CATEGORIES.has(autoFailureCategory);
+        if (waitClass !== 'completion_pending' && !transportRetryable) break;
         if (attempt < 2) {
           const requested = payload.retry_after_ms;
-          const delayMs = typeof requested === 'number' && Number.isFinite(requested) && requested >= 0
-            ? Math.ceil(requested) : 250;
+          const serverWaitMs = typeof requested === 'number' && Number.isFinite(requested) && requested >= 0
+            ? Math.ceil(requested) : null;
+          const delayMs = transportRetryable
+            ? Math.max(TRANSPORT_RETRY_WAIT_MS, serverWaitMs ?? 0)
+            : serverWaitMs ?? 250;
           const remaining = totalTimeoutMs - (performance.now() - context.started);
           if (delayMs >= remaining) break;
           const waitStarted = performance.now();
@@ -655,6 +700,7 @@ async function executeCanary(env, options, context) {
           const actualWaitMs = Math.round(performance.now() - waitStarted);
           outerAttemptRecord.actual_wait_ms = actualWaitMs;
           context.retryWaitMs += actualWaitMs;
+          if (transportRetryable) recoveredOnRetry = true;
         }
       }
       const latencyMs = Math.round(performance.now() - callStarted);
@@ -662,6 +708,7 @@ async function executeCanary(env, options, context) {
       const live = payload.stale !== true && payload.source !== 'last_known' && payload.available !== false;
       if (!live) throw canaryError('contract', `${name} returned cached or unavailable guidance`);
       results.push({ tool: name, ok: true, live: true, latency_ms: latencyMs,
+        ...(recoveredOnRetry ? { recovered_on_retry: true } : {}),
         ...(name === 'marrow_auto' ? {
           ...autoTimings(payload),
           attempts,
@@ -709,7 +756,10 @@ if (require.main === module) {
 
 module.exports = {
   CANARY_DEFAULT_TOOL_TIMEOUT_MS,
+  CANARY_DEFAULT_ASYNC_TOOL_TIMEOUT_MS,
+  CANARY_DEFAULT_TOTAL_TIMEOUT_MS,
   CANARY_TOOL_TIMEOUT_MARGIN_MS,
+  CANARY_ASYNC_TOOL_TIMEOUT_MAX_MS,
   MARROW_AUTO_RESPONSE_BUDGET_MAX_MS,
   PersistentMcpClient,
   latencyGroup,

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/getmarrow/marrow-mcp",
     "source": "github"
   },
-  "version": "3.9.85",
+  "version": "3.9.87",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@getmarrow/mcp",
-      "version": "3.9.85",
+      "version": "3.9.87",
       "transport": {
         "type": "stdio"
       },