@getmarrow/mcp 3.9.72 → 3.9.73

package/README.md

@@ -104,7 +104,11 @@ 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.72
+## What's New in v3.9.73
+
+v3.9.73 keeps one automatic operation bound to its original runtime authorization and decision across timeout and proof-required retries, then closes that exact decision once verified proof is supplied.
+
+## Previous: v3.9.72
 
 v3.9.72 requires SDK `3.7.61` so MCP installations cannot resolve to an SDK that recursively intercepts its own Marrow control-plane traffic. The MCP tool contract is unchanged; this release aligns the tested package chain.
 
@@ -117,7 +121,7 @@ v3.9.71 makes the advertised Grok control loop true:
 - Grok native hooks are installed under `~/.grok/hooks/marrow.json` and hook parsers accept Grok camelCase envelopes;
 - idle spool nudge drains up to 40 current-namespace events so the queue does not sit as a nag;
 - if `risk_gate.enforced` is false, the gate is advisory — do not describe it as a live block;
-- `marrow_commit.decision_id` may come from `marrow_think`, `marrow_auto`, or `marrow_agent_runtime.runtime_authorization.id`.
+- `marrow_commit.decision_id` comes from `marrow_think`, `marrow_auto`, or an arbitration runtime that actually created a decision. A normal runtime authorization is a gate receipt, not a decision.
 
 ## Previous: v3.9.69
 
@@ -338,12 +342,14 @@ With installed native hooks, protected tool calls follow this automatically. For
 
 1. Call `marrow_agent_runtime` or `marrow_decision_brief`.
 2. Stop when the returned decision is `block` or `review_required`; otherwise follow its prior lesson and proof contract.
-3. Call `marrow_think` or `marrow_auto` to record intent and obtain the `decision_id` that will be closed. `marrow_agent_runtime.runtime_authorization.id` is also accepted.
+3. Call `marrow_think` or `marrow_auto` to record intent and obtain the `decision_id` that will be closed. Keep `marrow_agent_runtime.runtime_authorization.id` separate as the gate receipt for consequential work.
 4. Perform the action only when its gate allows it. For a hard external choke point, run the command through `npx @getmarrow/install run`; it verifies the signed action permit immediately before execution.
 5. Call `marrow_commit` with that `decision_id`, the outcome, gate receipt, and required proof.
 
 `marrow_agent_runtime` returns `runtime_authorization` with the authoritative gate receipt. Ordinary runtime checks do not create a decision, so they omit `decision_id`; call `marrow_think` (or use `marrow_auto`) when a decision must be created and closed. An arbitration runtime that actually creates a decision returns that server-created `decision_id`. This contract is identical across MCP-compatible hosts and SDK-owned runtimes.
 
+`marrow_auto` returns an `operation_id`, phase, and resumable state. If a client deadline is reached before closure, retry with the same `operation_id`; Marrow reuses the same tenant-scoped runtime authorization, think decision, and commit idempotency keys instead of opening another decision. When the phase is `proof_required`, add the requested proof and retry with that same operation ID and unchanged action/context/surfaces. Proof is validated and bound at commit; changing the tenant or action scope is rejected. A closed response reports `phase: "closed"`, `committed: true`, and `resumable: false`.
+
 Example pre-action request:
 
 ```json

package/dist/cli.js

@@ -25,7 +25,6 @@ const hook_contract_2 = 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");
 const status_cache_1 = require("./status-cache");
 const habit_loop_copy_1 = require("./habit-loop-copy");
 const host_capability_1 = require("./host-capability");
@@ -848,13 +847,13 @@ if (process.argv[2] !== 'keys') {
             {
                 name: 'marrow_commit',
                 description: 'Close a recorded action with success/failure, a specific outcome, and required proof. ' +
-                    'decision_id may come from marrow_think, marrow_auto, or marrow_agent_runtime.runtime_authorization.id. ' +
+                    'decision_id comes from marrow_think, marrow_auto, or an arbitration runtime that actually created a decision. ' +
                     'Use the gate receipt from marrow_agent_runtime for consequential work. ' +
                     'Outcome closure is required for accountable fleet learning.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        decision_id: { type: 'string', description: 'decision_id from marrow_think, marrow_auto, or marrow_agent_runtime.runtime_authorization.id' },
+                        decision_id: { type: 'string', description: 'decision_id from marrow_think, marrow_auto, or an arbitration runtime that created a decision' },
                         success: { type: 'boolean', description: 'Did the action succeed?' },
                         outcome: { type: 'string', description: 'What happened — be specific, this trains the hive' },
                         caused_by: { type: 'string', description: 'Optional: what caused this action' },
@@ -937,6 +936,10 @@ if (process.argv[2] !== 'keys') {
                         },
                         proof: { type: 'object', description: 'Measured completion evidence for gated work.' },
                         gate_receipt_id: { type: 'string', description: 'Fresh receipt returned by marrow_agent_runtime.' },
+                        operation_id: {
+                            type: 'string',
+                            description: 'Opaque 8-80 character resume token. Reuse it only with the original tenant, action, context, and surfaces; proof may be added after proof_required.',
+                        },
                     },
                     required: ['action'],
                 },
@@ -2010,35 +2013,20 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         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, toolName: 'marrow_auto.runtime' });
-                            storeRuntimeGuidance(runtimeGate);
-                        }
-                        const canonicalRuntimeReceiptId = (0, runtime_contract_1.runtimeAuthorizationReceiptId)(runtimeGate);
                         const suppliedRuntimeReceiptId = typeof args.gate_receipt_id === 'string'
                             ? args.gate_receipt_id
-                            : canonicalRuntimeReceiptId;
-                        const proofCanClose = !highRisk
-                            || (0, runtime_contract_1.highRiskRuntimeCanClose)(runtimeGate, suppliedProof, suppliedRuntimeReceiptId);
-                        const acceptedSuccess = proofCanClose ? outcomeSuccess : undefined;
+                            : undefined;
                         const delivery = () => (0, index_1.marrowAuto)(API_KEY, BASE_URL, {
                             action,
                             outcome,
-                            success: acceptedSuccess,
+                            success: outcomeSuccess,
                             type,
                             proof: suppliedProof,
                             gate_receipt_id: suppliedRuntimeReceiptId || undefined,
                             // Low-risk one-shot capture does not need a policy gate. Consequential
-                            // work already obtained and validated canonical runtime authorization.
+                            // work obtains exactly one canonical runtime authorization inside auto.
                             auto_gate: highRisk,
+                            operation_id: typeof args.operation_id === 'string' ? args.operation_id : undefined,
                         }, SESSION_ID, FLEET_AGENT_ID, 8_000);
                         let delivered = null;
                         let deliveryFailure = null;
@@ -2048,6 +2036,9 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                         catch (err) {
                             deliveryFailure = (0, request_reliability_1.structuredRequestFailure)(err);
                         }
+                        const runtimeGate = delivered?.runtime_gate || null;
+                        if (runtimeGate)
+                            storeRuntimeGuidance(runtimeGate);
                         const receipt = await (0, lifecycle_spool_1.recordLifecycleEvent)({
                             apiKey: API_KEY,
                             baseUrl: BASE_URL,
@@ -2055,18 +2046,18 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             event: {
                                 event_type: delivered?.committed
                                     ? 'outcome_committed'
-                                    : !highRisk && acceptedSuccess === false
+                                    : !highRisk && outcomeSuccess === false
                                         ? 'tool_failed'
-                                        : !highRisk && acceptedSuccess === true
+                                        : !highRisk && outcomeSuccess === 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,
+                                decision_id: delivered?.decision_id || undefined,
                                 action,
                                 outcome_state: delivered?.committed ? 'closed' : 'pending',
-                                success: delivered?.committed ? acceptedSuccess : highRisk ? undefined : acceptedSuccess,
+                                success: delivered?.committed ? outcomeSuccess : highRisk ? undefined : outcomeSuccess,
                                 adapter_version: hook_contract_2.MCP_ADAPTER_VERSION,
                                 capability_level: 'mcp',
                             },
@@ -2077,20 +2068,34 @@ Marrow is not a replacement agent or a standalone memory app. Context and prior
                             warnings: cachedOrientWarnings.map(formatWarningActionably),
                             logging: delivered?.committed
                                 ? 'governed_commit_confirmed'
-                                : delivered
-                                    ? 'intent_confirmed'
-                                    : 'durably_queued',
+                                : delivered?.resumable
+                                    ? 'resume_required'
+                                    : delivered
+                                        ? 'intent_confirmed'
+                                        : 'durably_queued',
                             receipt,
                             completion_state: delivered?.committed
                                 ? 'closed_with_proof'
-                                : !proofCanClose
+                                : delivered?.phase === 'proof_required'
                                     ? 'pending_required_proof'
-                                    : outcomeSuccess === undefined
+                                    : delivered?.phase === 'decision_created' || outcomeSuccess === undefined
                                         ? 'pending_evidence'
                                         : 'delivery_pending',
                             decision_id: delivered?.decision_id || null,
+                            operation_id: delivered?.operation_id || (typeof args.operation_id === 'string' ? args.operation_id : null),
+                            phase: delivered?.phase || null,
+                            resumable: delivered?.resumable || false,
+                            retry_after_ms: delivered?.retry_after_ms ?? null,
+                            phase_timings_ms: delivered?.phase_timings_ms || null,
+                            exact_next_action: delivered?.committed
+                                ? 'The governed outcome is closed. Reuse this decision_id only for read-only trace inspection.'
+                                : delivered?.phase === 'proof_required'
+                                    ? 'Attach the required measured proof and retry marrow_auto with this same operation_id and unchanged action, context, and surfaces.'
+                                    : delivered?.resumable
+                                        ? 'Retry marrow_auto with this same operation_id. Do not start a new auto operation.'
+                                        : 'Close this decision after the real outcome is known.',
                             live_delivery: {
-                                accepted: Boolean(delivered),
+                                accepted: Boolean(delivered?.decision_id),
                                 committed: Boolean(delivered?.committed),
                                 ...(deliveryFailure ? { failure: deliveryFailure } : {}),
                             },