@getmarrow/mcp 3.9.83 → 3.9.85

package/dist/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MARROW_AUTO_RESPONSE_BUDGET_MAX_MS = void 0;
 exports.validatePathParam = validatePathParam;
 exports.validateBaseUrl = validateBaseUrl;
+exports.marrowAutoHttpTraceFromError = marrowAutoHttpTraceFromError;
 exports.marrowCreateKey = marrowCreateKey;
 exports.marrowListKeys = marrowListKeys;
 exports.marrowGetKey = marrowGetKey;
@@ -73,10 +74,12 @@ const SAFE_ARBITRATION_EVIDENCE_KIND = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,39}$/;
 const SAFE_ARBITRATION_EVIDENCE_REFERENCE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/;
 const SAFE_OUTCOME_OBSERVATION_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/;
 const SAFE_INSTRUCTION_REFERENCE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
-const SAFE_IDEMPOTENCY_KEY = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 const AGENT_WRITE_RECONCILIATION_ATTEMPTS = 3;
 const AGENT_WRITE_RECONCILIATION_DELAY_MS = 1_000;
 const AUTO_MANAGED_WRITE = Symbol('marrow-auto-managed-write');
+const AUTO_HTTP_TRACE = Symbol('marrow-auto-http-trace');
+const AUTO_HTTP_TRACE_ERROR = Symbol('marrow-auto-http-trace-error');
+const AUTO_HTTP_TRACE_LIMIT = 12;
 const INSTRUCTION_REFERENCE_LONG_DIGIT_RUN = /\d{7,}/;
 const INSTRUCTION_REFERENCE_DATE = /(?:^|[._:-])(?:(?:19|20)\d{2}[._:-](?:0?[1-9]|1[0-2])[._:-](?:0?[1-9]|[12]\d|3[01])|(?:0?[1-9]|1[0-2])[._:-](?:0?[1-9]|[12]\d|3[01])[._:-](?:19|20)\d{2})(?:$|[._:-])/;
 const INSTRUCTION_REFERENCE_PROVIDER_ID = /^(?:telegram|tg|discord|slack|signal|whatsapp|wa|matrix|imessage|message|msg|chat|user|thread|channel|room|dm|sms|device)[_:.-]?[A-Za-z]*\d+[A-Za-z0-9_-]*$/i;
@@ -300,14 +303,22 @@ async function safeJsonResponse(res) {
             if (contentType.includes('json'))
                 detail = await res.json();
         }
-        catch { /* ignore malformed or non-JSON error bodies */ }
+        catch (error) {
+            const failure = (0, request_reliability_1.normalizeRequestError)(error);
+            if (failure.code === 'request_timeout')
+                throw failure;
+            // Malformed error bodies do not hide the authoritative HTTP status.
+        }
         throw (0, request_reliability_1.requestErrorFromResponse)(res, detail);
     }
     let json;
     try {
         json = await res.json();
     }
-    catch {
+    catch (error) {
+        const failure = (0, request_reliability_1.normalizeRequestError)(error);
+        if (failure.code === 'request_timeout')
+            throw failure;
         throw (0, request_reliability_1.invalidResponseError)();
     }
     if (!json || typeof json !== 'object' || Array.isArray(json) || json.error) {
@@ -453,14 +464,14 @@ function isDurableObservedOutcome(value) {
 }
 function invocationIdempotencyKey(kind, supplied) {
     if (supplied !== undefined) {
-        if (supplied !== supplied.trim() || !SAFE_IDEMPOTENCY_KEY.test(supplied)) {
+        if (!(0, request_reliability_1.privacySafeIdempotencyKey)(supplied)) {
             throw new TypeError('Idempotency key must be a bounded privacy-safe identifier.');
         }
         return supplied;
     }
     return `mcp-${kind}:${(0, node_crypto_1.randomUUID)()}`;
 }
-function reconciliationError(exhausted) {
+function reconciliationError(exhausted, pendingReceipt) {
     return new request_reliability_1.MarrowRequestError({
         code: 'invalid_response',
         backendCode: exhausted ? 'MCP_RECONCILIATION_EXHAUSTED' : 'MCP_RECONCILIATION_INVALID',
@@ -469,8 +480,10 @@ function reconciliationError(exhausted) {
             : 'Marrow returned an invalid write reconciliation response',
         status: 202,
         retryable: exhausted,
+        retryAfterMs: exhausted ? 1000 : null,
+        pendingReceipt,
         exactFix: exhausted
-            ? 'Retry the same operation explicitly after checking Marrow status; do not assume the decision or outcome closed.'
+            ? 'Resume with the pending receipt key and request_hash, unchanged arguments, credentials, agent and session. Do not act, create another decision, or assume closure.'
             : 'Check Marrow status and retry explicitly; do not accept or act on the malformed pending response.',
     });
 }
@@ -481,27 +494,41 @@ function validCorrelationId(value) {
         && value === value.trim()
         && !/[\u0000-\u001f\u007f-\u009f]/.test(value);
 }
-function pendingDecisionId(kind, value, idempotencyKey, expectedDecisionId) {
-    if (value.retryable !== true
-        || value.committed !== false
-        || value.idempotency_key !== idempotencyKey
-        || !validCorrelationId(value.decision_id)) {
+function pendingWriteReconciliation(kind, value, idempotencyKey, expectedDecisionId) {
+    if (value.retryable !== true || value.committed !== false || value.idempotency_key !== idempotencyKey) {
         return null;
     }
     if (kind === 'think') {
-        return value.reconciliation_state === 'runtime_continuation_persistence_pending'
-            && value.decision_state === 'created'
-            ? value.decision_id
-            : null;
+        const decisionId = value.decision_id === undefined ? null
+            : validCorrelationId(value.decision_id) ? value.decision_id : undefined;
+        if (decisionId === undefined)
+            return null;
+        const typed = value.reconciliation_contract !== undefined;
+        if (typed && (value.reconciliation_contract !== 'agent_write_reconciliation.v1'
+            || value.reconciliation_operation !== 'think' || value.safe_to_continue !== false))
+            return null;
+        const canonicalPending = value.phase === 'think_pending' && value.resumable === true
+            && value.safe_to_continue !== true
+            && value.retry_after_ms === AGENT_WRITE_RECONCILIATION_DELAY_MS;
+        const state = value.reconciliation_state;
+        const validState = state === 'runtime_continuation_persistence_pending' && value.decision_state === 'created'
+            || state === 'runtime_decision_authority_pending' && value.decision_state === 'pending' && decisionId === null
+            || state === 'pending' && (value.decision_state === 'pending' && decisionId === null
+                || value.decision_state === 'created');
+        if (canonicalPending && validState)
+            return { decisionId };
+        // Keep the earlier documented identifier-bearing continuation contract compatible.
+        if (!typed && decisionId && state === 'runtime_continuation_persistence_pending'
+            && value.decision_state === 'created' && value.safe_to_continue !== true)
+            return { decisionId };
+        return null;
     }
-    if (value.decision_id !== expectedDecisionId)
+    if (!validCorrelationId(value.decision_id) || value.decision_id !== expectedDecisionId)
         return null;
     if (value.reconciliation_state === 'pending')
-        return value.decision_id;
+        return { decisionId: value.decision_id };
     return value.reconciliation_state === 'runtime_continuation_invalidation_pending'
-        && value.outcome_persisted === true
-        ? value.decision_id
-        : null;
+        && value.outcome_persisted === true ? { decisionId: value.decision_id } : null;
 }
 async function waitForWriteReconciliation(signal) {
     await new Promise((resolve, reject) => {
@@ -523,19 +550,177 @@ async function waitForWriteReconciliation(signal) {
         signal?.addEventListener('abort', abort, { once: true });
     });
 }
-async function fetchAgentWrite(url, init, kind, idempotencyKey, expectedDecisionId, autoManaged = false) {
+const AUTO_HTTP_STATE_CODES = new Set([
+    'runtime_pending', 'think_pending', 'commit_pending', 'pending',
+    'created', 'committed', 'closed', 'replayed', 'idempotent_replay',
+    'lost_ack_recovered', 'duplicate', 'original', 'new',
+]);
+function traceMs(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? Math.min(60_000, Math.round(value))
+        : null;
+}
+function traceCode(value) {
+    const code = typeof value === 'string' ? value.toLowerCase() : '';
+    return AUTO_HTTP_STATE_CODES.has(code) ? code : null;
+}
+function serverTimingEvidence(data) {
+    const timings = {};
+    const add = (name, value) => {
+        const duration = traceMs(value);
+        if (duration !== null && timings[name] === undefined)
+            timings[name] = duration;
+    };
+    const performanceShape = data?.performance;
+    if (performanceShape && typeof performanceShape === 'object' && !Array.isArray(performanceShape)) {
+        const performanceData = performanceShape;
+        add('auth_ms', performanceData.auth_ms);
+        add('parse_ms', performanceData.parse_ms);
+        const nestedTimings = performanceData.timings;
+        if (nestedTimings && typeof nestedTimings === 'object' && !Array.isArray(nestedTimings)) {
+            const nestedData = nestedTimings;
+            add('auth_ms', nestedData.auth_ms);
+            add('parse_ms', nestedData.parse_ms);
+        }
+    }
+    return {
+        server_timings_ms: timings,
+        // The backend's detailed think/commit DB and DO stage timings are deferred
+        // query-performance records, not response fields. These response spans can
+        // therefore be partial at best.
+        server_timing_coverage: Object.keys(timings).length ? 'partial' : 'unavailable',
+    };
+}
+function appendAutoHttpAttempt(trace, input) {
+    if (!trace)
+        return null;
+    if (trace.attempts.length >= AUTO_HTTP_TRACE_LIMIT) {
+        trace.dropped_count += 1;
+        return null;
+    }
+    const attempt = { ...input, actual_wait_ms: 0 };
+    trace.attempts.push(attempt);
+    return attempt;
+}
+function snapshotAutoHttpTrace(trace) {
+    return {
+        attempts: trace.attempts.map((attempt) => ({
+            ...attempt,
+            server_timings_ms: { ...attempt.server_timings_ms },
+        })),
+        dropped_count: trace.dropped_count,
+    };
+}
+function attachAutoHttpTrace(error, trace) {
+    if (error instanceof Error) {
+        Object.defineProperty(error, AUTO_HTTP_TRACE_ERROR, {
+            value: snapshotAutoHttpTrace(trace),
+            configurable: true,
+        });
+    }
+    return error;
+}
+function marrowAutoHttpTraceFromError(error) {
+    if (!(error instanceof Error))
+        return null;
+    const trace = error[AUTO_HTTP_TRACE_ERROR];
+    return trace ? snapshotAutoHttpTrace(trace) : null;
+}
+async function fetchAgentWrite(url, init, kind, idempotencyKey, expectedDecisionId, autoManaged = false, expectedRequestHash, autoHttpTrace) {
+    const headers = new Headers(init.headers);
+    // Bind the canonical wire body and authenticated scope without exposing either.
+    const requestHash = (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(canonicalAutoBindingValue({
+        url, key: idempotencyKey, body: JSON.parse(String(init.body)),
+        authorization: headers.get('Authorization'),
+        session: headers.get('X-Marrow-Session-Id'), agent: headers.get('X-Marrow-Agent-Id'),
+    }))).digest('hex');
+    if (expectedRequestHash !== undefined && (!/^[a-f0-9]{64}$/.test(expectedRequestHash)
+        || expectedRequestHash !== requestHash)) {
+        throw new TypeError('Pending request hash does not match this exact operation and authenticated scope.');
+    }
+    const pendingReceipt = {
+        contract: 'mcp_write_pending.v1', operation: kind, committed: false, safe_to_continue: false,
+        idempotency_key: idempotencyKey, request_hash: requestHash,
+    };
     let reconciledDecisionId = null;
+    // A manual receipt resume must validate its very first terminal response.
+    let reconciling = expectedRequestHash !== undefined;
     for (let attempt = 0; attempt < AGENT_WRITE_RECONCILIATION_ATTEMPTS; attempt += 1) {
         // Automatic writes have one retry owner and leave room for exact replay
         // after a lost ACK inside marrowAuto's unchanged total response deadline.
-        const response = await (0, request_reliability_1.reliableFetch)(url, init, autoManaged
-            ? { retryOwner: 'caller', timeoutMs: 4_000 }
-            : {});
-        const json = await safeJsonResponse(response);
+        const requestStarted = performance.now();
+        let receivedStatus = null;
+        let response;
+        let json;
+        try {
+            const consumed = await (0, request_reliability_1.reliableFetch)(url, init, autoManaged
+                ? {
+                    retryOwner: 'caller',
+                    timeoutMs: 4_000,
+                    consumeResponse: async (currentResponse) => {
+                        receivedStatus = currentResponse.status;
+                        return { response: currentResponse, json: await safeJsonResponse(currentResponse) };
+                    },
+                }
+                : {
+                    consumeResponse: async (currentResponse) => {
+                        receivedStatus = currentResponse.status;
+                        return { response: currentResponse, json: await safeJsonResponse(currentResponse) };
+                    },
+                });
+            response = consumed.response;
+            json = consumed.json;
+        }
+        catch (error) {
+            const failure = (0, request_reliability_1.normalizeRequestError)(error);
+            appendAutoHttpAttempt(autoHttpTrace, {
+                route_phase: kind,
+                duration_ms: traceMs(performance.now() - requestStarted) || 0,
+                status: receivedStatus ?? failure.status,
+                error_category: failure.code,
+                typed_timeout: failure.code === 'request_timeout',
+                pending_code: null,
+                replay_code: null,
+                ...serverTimingEvidence(),
+                requested_wait_ms: traceMs(failure.retryAfterMs),
+            });
+            throw error;
+        }
         if (!json.data || typeof json.data !== 'object' || Array.isArray(json.data)) {
+            appendAutoHttpAttempt(autoHttpTrace, {
+                route_phase: kind,
+                duration_ms: traceMs(performance.now() - requestStarted) || 0,
+                status: response.status,
+                error_category: 'invalid_response',
+                typed_timeout: false,
+                pending_code: null,
+                replay_code: null,
+                ...serverTimingEvidence(),
+                requested_wait_ms: null,
+            });
             throw (0, request_reliability_1.invalidResponseError)();
         }
         const data = json.data;
+        const headerWait = (0, request_reliability_1.responseRetryAfter)(response);
+        const bodyWait = traceMs(data.retry_after_ms);
+        const hasRequestedWait = bodyWait !== null || headerWait.delayMs !== null;
+        const requestedWait = headerWait.valid && hasRequestedWait
+            ? Math.max(bodyWait ?? 0, headerWait.delayMs ?? 0)
+            : null;
+        const traceAttempt = appendAutoHttpAttempt(autoHttpTrace, {
+            route_phase: kind,
+            duration_ms: traceMs(performance.now() - requestStarted) || 0,
+            status: response.status,
+            error_category: null,
+            typed_timeout: false,
+            pending_code: response.status === 202
+                ? traceCode(data.pending_code) || traceCode(data.phase) || `${kind}_pending`
+                : null,
+            replay_code: traceCode(data.replay_code) || traceCode(data.replay_state)
+                || (data.replayed === true ? 'replayed' : null),
+            ...serverTimingEvidence(data),
+            requested_wait_ms: requestedWait,
+        });
         if (autoManaged) {
             const retryGuidance = (0, request_reliability_1.responseRetryAfter)(response);
             if (!retryGuidance.valid) {
@@ -556,7 +741,7 @@ async function fetchAgentWrite(url, init, kind, idempotencyKey, expectedDecision
             // Canonical write reconciliation predates auto's phase/resumable fields.
             // Adapt only a validated exact-operation pending response.
             if (response.status === 202 && retryGuidance.valid && data.resumable !== false
-                && pendingDecisionId(kind, data, idempotencyKey, expectedDecisionId)) {
+                && pendingWriteReconciliation(kind, data, idempotencyKey, expectedDecisionId)) {
                 data.phase = `${kind}_pending`;
                 data.resumable = true;
             }
@@ -567,8 +752,12 @@ async function fetchAgentWrite(url, init, kind, idempotencyKey, expectedDecision
             return { response, data };
         }
         if (response.status !== 202 || (kind === 'commit' && data.outcome_state === 'observed_unverified')) {
-            if (reconciledDecisionId) {
-                if (kind === 'think' && data.decision_id !== reconciledDecisionId) {
+            if (reconciling) {
+                if (data.idempotency_key !== undefined && data.idempotency_key !== idempotencyKey) {
+                    throw reconciliationError(false);
+                }
+                if (kind === 'think' && (!validCorrelationId(data.decision_id)
+                    || (reconciledDecisionId && data.decision_id !== reconciledDecisionId))) {
                     throw reconciliationError(false);
                 }
                 if (kind === 'commit' && data.decision_id !== undefined && data.decision_id !== expectedDecisionId) {
@@ -577,17 +766,22 @@ async function fetchAgentWrite(url, init, kind, idempotencyKey, expectedDecision
             }
             return { response, data };
         }
-        const currentDecisionId = pendingDecisionId(kind, data, idempotencyKey, expectedDecisionId);
-        if (!currentDecisionId || (reconciledDecisionId && currentDecisionId !== reconciledDecisionId)) {
+        const pending = pendingWriteReconciliation(kind, data, idempotencyKey, expectedDecisionId);
+        if (!pending || (reconciledDecisionId && pending.decisionId && pending.decisionId !== reconciledDecisionId)) {
             throw reconciliationError(false);
         }
-        reconciledDecisionId = currentDecisionId;
+        reconciling = true;
+        if (pending.decisionId)
+            reconciledDecisionId = pending.decisionId;
         if (attempt + 1 >= AGENT_WRITE_RECONCILIATION_ATTEMPTS) {
-            throw reconciliationError(true);
+            throw reconciliationError(true, pendingReceipt);
         }
+        const waitStarted = performance.now();
         await waitForWriteReconciliation(init.signal || undefined);
+        if (traceAttempt)
+            traceAttempt.actual_wait_ms = traceMs(performance.now() - waitStarted) || 0;
     }
-    throw reconciliationError(true);
+    throw reconciliationError(true, pendingReceipt);
 }
 function clampPeriodDays(value, defaultDays = 7) {
     const parsed = typeof value === 'number' ? value : parseInt(String(value || defaultDays), 10);
@@ -653,6 +847,8 @@ async function marrowThink(apiKey, baseUrl, params, sessionId, agentId, signal,
         body.previous_outcome = (0, redact_1.redactSensitiveText)(params.previous_outcome ?? '');
     }
     const thinkUrl = `${baseUrl}/v1/agent/think${options?.responseMode === 'ack' ? '?response=ack' : ''}`;
+    if (options?.requestHash !== undefined && !options.idempotencyKey)
+        throw new TypeError('Pending resume requires the original idempotency key.');
     const idempotencyKey = invocationIdempotencyKey('think', options?.idempotencyKey);
     const thinkInit = {
         method: 'POST',
@@ -663,7 +859,7 @@ async function marrowThink(apiKey, baseUrl, params, sessionId, agentId, signal,
         body: JSON.stringify(body),
         signal,
     };
-    const { response, data } = await fetchAgentWrite(thinkUrl, thinkInit, 'think', idempotencyKey, undefined, options?.[AUTO_MANAGED_WRITE] === true);
+    const { response, data } = await fetchAgentWrite(thinkUrl, thinkInit, 'think', idempotencyKey, undefined, options?.[AUTO_MANAGED_WRITE] === true, options?.requestHash, options?.[AUTO_HTTP_TRACE]);
     return markAutoResponseStatus(data, response.status);
 }
 /**
@@ -759,7 +955,7 @@ async function marrowCommit(apiKey, baseUrl, params, sessionId, agentId, signal,
         body: JSON.stringify(body),
         signal,
     };
-    const { response, data } = await fetchAgentWrite(`${baseUrl}/v1/agent/commit`, commitInit, 'commit', resolvedIdempotencyKey, params.decision_id, params[AUTO_MANAGED_WRITE] === true);
+    const { response, data } = await fetchAgentWrite(`${baseUrl}/v1/agent/commit`, commitInit, 'commit', resolvedIdempotencyKey, params.decision_id, params[AUTO_MANAGED_WRITE] === true, undefined, params[AUTO_HTTP_TRACE]);
     if (data.outcome_state === 'observed_unverified') {
         if (!isDurableObservedOutcome(data))
             throw (0, request_reliability_1.invalidResponseError)();
@@ -913,7 +1109,7 @@ function autoContinuationDelay(pending) {
         ? Math.max(25, Math.ceil(requested))
         : 50;
 }
-async function waitForAutoContinuation(pending, startedAt, responseBudgetMs) {
+async function waitForAutoContinuation(pending, startedAt, responseBudgetMs, autoHttpTrace) {
     const remaining = responseBudgetMs - (Date.now() - startedAt) - AUTO_RESPONSE_DEADLINE_MARGIN_MS;
     if (remaining <= 0)
         return false;
@@ -922,9 +1118,14 @@ async function waitForAutoContinuation(pending, startedAt, responseBudgetMs) {
     if (delayMs >= remaining)
         return false;
     const resumeAt = performance.now() + delayMs;
+    const waitStarted = performance.now();
     do {
         await new Promise((resolve) => setTimeout(resolve, Math.ceil(resumeAt - performance.now())));
     } while (performance.now() < resumeAt);
+    const latestAttempt = autoHttpTrace?.attempts[autoHttpTrace.attempts.length - 1];
+    if (latestAttempt) {
+        latestAttempt.actual_wait_ms = Math.min(60_000, latestAttempt.actual_wait_ms + Math.max(0, Math.round(performance.now() - waitStarted)));
+    }
     return responseBudgetMs - (Date.now() - startedAt) > AUTO_RESPONSE_DEADLINE_MARGIN_MS;
 }
 function autoPartial(input) {
@@ -947,6 +1148,7 @@ function autoPartial(input) {
             ...input.timings,
             total: Date.now() - input.startedAt,
         },
+        http_attempt_trace: snapshotAutoHttpTrace(input.autoHttpTrace),
     };
 }
 /**
@@ -957,6 +1159,15 @@ function autoPartial(input) {
  * another decision.
  */
 async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs) {
+    const autoHttpTrace = { attempts: [], dropped_count: 0 };
+    try {
+        return await marrowAutoWithTrace(apiKey, baseUrl, params, sessionId, agentId, timeoutMs, autoHttpTrace);
+    }
+    catch (error) {
+        throw attachAutoHttpTrace(error, autoHttpTrace);
+    }
+}
+async function marrowAutoWithTrace(apiKey, baseUrl, params, sessionId, agentId, timeoutMs, autoHttpTrace) {
     const startedAt = Date.now();
     const responseBudgetMs = autoResponseBudget(timeoutMs);
     const operationId = resolveAutoOperationId(params.operation_id);
@@ -1005,10 +1216,10 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
                 }
                 catch (error) {
                     if ((0, request_reliability_1.normalizeRequestError)(error).code !== 'request_timeout'
-                        || !await waitForAutoContinuation({}, startedAt, responseBudgetMs)) {
+                        || !await waitForAutoContinuation({}, startedAt, responseBudgetMs, autoHttpTrace)) {
                         timings.runtime = Date.now() - phaseStarted;
                         if ((0, request_reliability_1.normalizeRequestError)(error).code === 'request_timeout') {
-                            return autoPartial({ operationId, phase: 'runtime_pending', timings, startedAt });
+                            return autoPartial({ operationId, phase: 'runtime_pending', timings, startedAt, autoHttpTrace });
                         }
                         throw error;
                     }
@@ -1091,16 +1302,17 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
                 idempotencyKey: autoIdempotencyKey(operationId, 'think'),
                 responseMode: 'ack',
                 [AUTO_MANAGED_WRITE]: true,
+                [AUTO_HTTP_TRACE]: autoHttpTrace,
             });
         }
         catch (error) {
             const failure = (0, request_reliability_1.normalizeRequestError)(error);
             const recoverable = error instanceof request_reliability_1.MarrowRequestError && failure.retryable && failure.code !== 'invalid_response';
             if (!recoverable
-                || !await waitForAutoContinuation({ retry_after_ms: failure.retryAfterMs }, startedAt, responseBudgetMs)) {
+                || !await waitForAutoContinuation({ retry_after_ms: failure.retryAfterMs }, startedAt, responseBudgetMs, autoHttpTrace)) {
                 timings.think = Date.now() - thinkStarted;
                 if (recoverable) {
-                    return autoPartial({ operationId, decisionId: pendingThinkDecisionId, phase: 'think_pending', runtimeGate, timings, startedAt,
+                    return autoPartial({ operationId, decisionId: pendingThinkDecisionId, phase: 'think_pending', runtimeGate, timings, startedAt, autoHttpTrace,
                         retryAfterMs: failure.retryAfterMs ?? undefined });
                 }
                 throw error;
@@ -1126,9 +1338,9 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             pendingThinkDecisionId = receivedDecisionId;
             operationBinding.pendingThinkDecisionId = receivedDecisionId;
         }
-        if (!await waitForAutoContinuation(thinkResult, startedAt, responseBudgetMs)) {
+        if (!await waitForAutoContinuation(thinkResult, startedAt, responseBudgetMs, autoHttpTrace)) {
             timings.think = Date.now() - thinkStarted;
-            return autoPartial({ operationId, decisionId: pendingThinkDecisionId, phase: 'think_pending', runtimeGate, timings, startedAt,
+            return autoPartial({ operationId, decisionId: pendingThinkDecisionId, phase: 'think_pending', runtimeGate, timings, startedAt, autoHttpTrace,
                 retryAfterMs: autoContinuationDelay(thinkResult) });
         }
     }
@@ -1141,6 +1353,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             runtimeGate,
             timings,
             startedAt,
+            autoHttpTrace,
             retryAfterMs: null,
         });
     }
@@ -1164,7 +1377,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
     if (genericReviewRequired && ordinaryApprovalDeclared && runtimeGate) {
         if (!(0, runtime_contract_1.hasOrdinaryOwnerApprovalProof)(params.proof)) {
             return autoPartial({
-                operationId, decisionId, phase: 'owner_approval_required', runtimeGate, timings, startedAt,
+                operationId, decisionId, phase: 'owner_approval_required', runtimeGate, timings, startedAt, autoHttpTrace,
                 resumable: false,
                 exactNextAction: 'Wait for explicit owner approval of this exact work. Then supply the server-supported proof.owner_approval object with the required measured proof and call marrow_auto with this same operation_id. Preserve the original decision and gate receipt. Do not infer or manufacture approval.',
             });
@@ -1172,7 +1385,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
         proofCanClose = (0, runtime_contract_1.ordinaryOwnerApprovalCanAttemptCommit)(runtimeGate, params.proof, gateReceiptId);
         if (!proofCanClose) {
             return autoPartial({
-                operationId, decisionId, phase: 'review_required', runtimeGate, timings, startedAt,
+                operationId, decisionId, phase: 'review_required', runtimeGate, timings, startedAt, autoHttpTrace,
                 resumable: false,
                 exactNextAction: 'The original ordinary approval receipt is expired or its enforced completion contract is not valid. Stop and reconcile fresh server guidance for this exact operation before attempting commit.',
             });
@@ -1186,6 +1399,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             runtimeGate,
             timings,
             startedAt,
+            autoHttpTrace,
             resumable: false,
             exactNextAction: 'Stop this operation and obtain the server-supported completion contract for this exact review. No supported ordinary approval path was declared. Preserve the operation and receipt references; do not infer approval or automatically retry.',
         });
@@ -1198,6 +1412,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             runtimeGate,
             timings,
             startedAt,
+            autoHttpTrace,
             resumable: false,
         });
     }
@@ -1222,6 +1437,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             runtimeGate,
             timings,
             startedAt,
+            autoHttpTrace,
             retryAfterMs: null,
         });
     }
@@ -1233,6 +1449,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             runtimeGate,
             timings,
             startedAt,
+            autoHttpTrace,
         });
     }
     const commitStarted = Date.now();
@@ -1253,16 +1470,17 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
                 surfaces: params.surfaces,
                 auto_gate: false,
                 [AUTO_MANAGED_WRITE]: true,
+                [AUTO_HTTP_TRACE]: autoHttpTrace,
             }, sessionId, agentId, commitTimeout.signal, autoIdempotencyKey(operationId, 'commit'));
         }
         catch (error) {
             const failure = (0, request_reliability_1.normalizeRequestError)(error);
             const recoverable = error instanceof request_reliability_1.MarrowRequestError && failure.retryable && failure.code !== 'invalid_response';
             if (!recoverable
-                || !await waitForAutoContinuation({ retry_after_ms: failure.retryAfterMs }, startedAt, responseBudgetMs)) {
+                || !await waitForAutoContinuation({ retry_after_ms: failure.retryAfterMs }, startedAt, responseBudgetMs, autoHttpTrace)) {
                 timings.commit = Date.now() - commitStarted;
                 if (recoverable) {
-                    return autoPartial({ operationId, decisionId, phase: 'commit_pending', runtimeGate, timings, startedAt,
+                    return autoPartial({ operationId, decisionId, phase: 'commit_pending', runtimeGate, timings, startedAt, autoHttpTrace,
                         retryAfterMs: failure.retryAfterMs ?? undefined });
                 }
                 throw error;
@@ -1277,12 +1495,12 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
         const canResumeCommit = commitResult.resumable !== false && commitResult.retryable !== false;
         if (!isAutoPendingResponse(commitResult, 'commit_pending')) {
             timings.commit = Date.now() - commitStarted;
-            return autoPartial({ operationId, decisionId, phase: 'commit_pending', runtimeGate, timings, startedAt,
+            return autoPartial({ operationId, decisionId, phase: 'commit_pending', runtimeGate, timings, startedAt, autoHttpTrace,
                 resumable: canResumeCommit });
         }
-        if (!await waitForAutoContinuation(commitResult, startedAt, responseBudgetMs)) {
+        if (!await waitForAutoContinuation(commitResult, startedAt, responseBudgetMs, autoHttpTrace)) {
             timings.commit = Date.now() - commitStarted;
-            return autoPartial({ operationId, decisionId, phase: 'commit_pending', runtimeGate, timings, startedAt,
+            return autoPartial({ operationId, decisionId, phase: 'commit_pending', runtimeGate, timings, startedAt, autoHttpTrace,
                 retryAfterMs: autoContinuationDelay(commitResult) });
         }
     }
@@ -1299,6 +1517,7 @@ async function marrowAuto(apiKey, baseUrl, params, sessionId, agentId, timeoutMs
             ...timings,
             total: Date.now() - startedAt,
         },
+        http_attempt_trace: snapshotAutoHttpTrace(autoHttpTrace),
     };
 }
 /**