@getmarrow/mcp 3.9.59 → 3.9.61

package/README.md

@@ -104,7 +104,30 @@ 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.59
+## What's New in v3.9.61
+
+v3.9.61 keeps an authoritative proof-pack rejection distinct from a control-path outage:
+
+- backend `MARROW_PROOF_PACK_INCOMPLETE` responses are reported as `validation` / `proof_required`, not infrastructure failures;
+- the exact missing proof fields and backend repair instruction remain visible to the agent;
+- live proof validation does not return a stale outage brief or unavailable authorization state;
+- proof enforcement remains fail-closed, and successful commit behavior is unchanged.
+
+## Previous: 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:
 

package/dist/cli.js

@@ -127,11 +127,14 @@ 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: drain ? status.state === 'clear' : 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;
@@ -444,15 +447,21 @@ if (process.argv[2] !== 'keys') {
         }
         function toolFailure(toolName, failure) {
             const result = (0, request_reliability_1.structuredRequestFailure)(failure);
-            const infrastructureFailure = !['authentication_required', 'permission_denied'].includes(failure.code);
+            const proofValidation = failure.code === 'proof_required';
+            const infrastructureFailure = !proofValidation && !['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.failure_kind = proofValidation ? 'validation' : 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 (proofValidation) {
+                result.proof_required = true;
+                result.exact_next_action = failure.exactFix;
+            }
             if (infrastructureFailure && supportsStale) {
                 let cached = null;
                 try {
@@ -479,6 +488,24 @@ if (process.argv[2] !== 'keys') {
             }
             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
@@ -486,6 +513,7 @@ if (process.argv[2] !== 'keys') {
             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: {
@@ -512,21 +540,13 @@ 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 toolName = options.toolName || 'marrow_control';
-            const hasCache = options.cacheAware !== false && Boolean(cachedGuidance());
             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 ? 4_500 : hasCache ? 500 : 4_000;
+                : options.highRisk || runtimeBudget ? 4_500 : 4_000;
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), timeoutMs);
             timer.unref?.();
@@ -1672,7 +1692,7 @@ if (process.argv[2] !== 'keys') {
                         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.',
+                            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
@@ -1841,12 +1861,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,
@@ -1858,10 +1876,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) }],
                         });
@@ -1953,18 +1971,43 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         }
                         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',
                             },
@@ -1973,48 +2016,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) }],
                         });
@@ -2431,12 +2455,35 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         return;
                     }
                     if (toolName === 'marrow_handoff_status') {
-                        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));
+                        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') {