@rynfar/meridian 1.70.0 → 1.71.1

package/dist/{cli-zdbv40d5.js → cli-hxxy0m1z.js}

@@ -900,17 +900,20 @@ var pluginlessWarned = new LRUMap(256);
 function clearPluginlessWarnings() {
   pluginlessWarned.clear();
 }
-function notePluginlessOpenCodeRequest(input) {
+function isPluginlessOpenCodeRequest(input) {
   if (!input.userAgent?.toLowerCase().startsWith("opencode/"))
-    return;
-  if (input.agentModeHeader)
+    return false;
+  return !input.agentModeHeader;
+}
+function notePluginlessOpenCodeRequest(input) {
+  if (!isPluginlessOpenCodeRequest(input))
     return;
   const key = input.sessionId || "(keyless)";
   if (pluginlessWarned.get(key))
     return;
   pluginlessWarned.set(key, true);
   const shortId = input.sessionId ? `${input.sessionId.slice(0, 12)}…` : "(no session header)";
-  return `OpenCode request without the Meridian plugin's agent headers (session ${shortId}). ` + `OpenCode runs its internal title/summary agents under your session id, so Meridian ` + `cannot tell them apart from your conversation: the first turn of each session can fail ` + `with a 400 or replay against a cold cache. Fix: meridian setup (or update the plugin).`;
+  return `OpenCode request without the Meridian plugin's agent headers (session ${shortId}). ` + `OpenCode runs its internal title/summary agents under your session id, so Meridian ` + `cannot tell them apart from your conversation: concurrent turns are admitted rather ` + `than refused, but the one that loses the race replays against a cold prompt cache — ` + `slower and billed as uncached input. Fix: meridian setup (or update the plugin).`;
 }
 function runSetup(pluginPath, configPath, generation = "v1") {
   const path = configPath ?? findOpencodeConfigPath();
@@ -971,4 +974,4 @@ function runSetup(pluginPath, configPath, generation = "v1") {
   return { configPath: path, pluginPath, alreadyConfigured, removedStale, created: false };
 }
 
-export { LRUMap, PRIORITY_ATTESTATION_HEADER, verifyPriorityAttestation, init_priorityAttestation, UnparseableConfigError, MissingV1PluginError, MissingV2PluginError, DuplicateMeridianConfigError, findOpencodeConfigPath, findPluginPath, SUPPORTED_OPENCODE_V2_VERSIONS, findV2PluginPath, classifyOpenCodeVersion, detectOpenCodeGeneration, pluginPathForGeneration, checkPluginConfigured, clearPluginlessWarnings, notePluginlessOpenCodeRequest, runSetup };
+export { LRUMap, PRIORITY_ATTESTATION_HEADER, verifyPriorityAttestation, init_priorityAttestation, UnparseableConfigError, MissingV1PluginError, MissingV2PluginError, DuplicateMeridianConfigError, findOpencodeConfigPath, findPluginPath, SUPPORTED_OPENCODE_V2_VERSIONS, findV2PluginPath, classifyOpenCodeVersion, detectOpenCodeGeneration, pluginPathForGeneration, checkPluginConfigured, clearPluginlessWarnings, isPluginlessOpenCodeRequest, notePluginlessOpenCodeRequest, runSetup };

package/dist/{cli-198xnjcn.js → cli-ryt69ryf.js}

@@ -75,9 +75,10 @@ import {
   PRIORITY_ATTESTATION_HEADER,
   checkPluginConfigured,
   init_priorityAttestation,
+  isPluginlessOpenCodeRequest,
   notePluginlessOpenCodeRequest,
   verifyPriorityAttestation
-} from "./cli-zdbv40d5.js";
+} from "./cli-hxxy0m1z.js";
 import {
   __commonJS,
   __esm,
@@ -6870,6 +6871,13 @@ function ordinalSuffix(n) {
 function linkRequestAbort(signal) {
   const controller = new AbortController;
   let attached = false;
+  const linkedAt = Date.now();
+  let cause;
+  const classify = () => {
+    if (!controller.signal.aborted)
+      return "none";
+    return cause ?? "unknown_abort";
+  };
   const abort = (reason) => {
     if (!controller.signal.aborted)
       controller.abort(reason);
@@ -6889,6 +6897,19 @@ function linkRequestAbort(signal) {
         return;
       signal.removeEventListener("abort", forwardAbort);
       attached = false;
+    },
+    setCause: (labeled) => {
+      cause ??= labeled;
+    },
+    abortSnapshot: () => {
+      const snapshot = {
+        cause: classify(),
+        aborted: controller.signal.aborted
+      };
+      if (controller.signal.aborted) {
+        snapshot.elapsedMs = Math.max(0, Date.now() - linkedAt);
+      }
+      return snapshot;
     }
   };
 }
@@ -23873,6 +23894,45 @@ function canRecoverCapturedToolUses(input) {
       return false;
   }
 }
+function isStreamedToolBlockComplete(record2) {
+  if (!record2.forwardedStart)
+    return false;
+  if (!record2.naturalStop)
+    return false;
+  if (record2.startedInputObject)
+    return true;
+  if (!record2.json.trim())
+    return false;
+  try {
+    const parsed = JSON.parse(record2.json);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+function canRecoverUncapturedToolUses(input) {
+  if (!input.uncapturedRecoveryEnabled)
+    return false;
+  if (!input.passthrough)
+    return false;
+  if (input.reason !== "max_turns")
+    return false;
+  if (input.attemptedMaxTurns !== 1)
+    return false;
+  if (input.capturedToolUses > 0)
+    return false;
+  if (input.streamedToolUses <= 0)
+    return false;
+  if (input.droppedToolUseIds > 0)
+    return false;
+  if (input.sawDuplicateToolUse)
+    return false;
+  if (input.forceSingleToolUse)
+    return false;
+  if (input.earlyStopFired)
+    return false;
+  return true;
+}
 function extractSdkTermination(errMsg) {
   const stderrTail = extractStderrTail(errMsg);
   const haystack = `${errMsg}
@@ -23937,6 +23997,9 @@ function formatSdkTermination(t, ctx) {
     parts.push(`deferred=${ctx.hasDeferredTools}`);
   if (ctx.sdkSessionId)
     parts.push(`session=${ctx.sdkSessionId.slice(0, 8)}`);
+  if (ctx.abort) {
+    parts.push(`abort=${ctx.abort.cause}`);
+  }
   if (t.rawTail)
     parts.push(`raw=${JSON.stringify(t.rawTail)}`);
   if (t.stderrTail)
@@ -36925,6 +36988,7 @@ function createProxyServer(config2 = {}) {
   let durableWritesRevoked = false;
   let inFlightRequests = 0;
   const activeRequestAborts = new Set;
+  const activeShutdownLabels = new Map;
   const internalHopToken = randomUUID6();
   const errorEnvelope = (shape, type, message) => shape === "anthropic" ? { type: "error", error: { type, message } } : { error: { type, message, code: null } };
   const DRAIN_MESSAGE = "Meridian is shutting down and is not accepting new requests. Retry against another instance.";
@@ -37216,6 +37280,7 @@ function createProxyServer(config2 = {}) {
         body: options.body,
         forcedProfileId: candidate,
         turnWatchdogSignal: options.turnWatchdogSignal,
+        requestAbortLink: options.requestAbortLink,
         forceFreshPriorityReplay: priorityPublication !== undefined && (options.durableRoute?.forceFreshReplay === true || options.currentProfileId !== undefined && candidate !== options.currentProfileId),
         priorityPublication,
         priorityAttemptExposure: exposure
@@ -37293,7 +37358,7 @@ data: ${JSON.stringify(lastError)}
   const handleMessages = async (c, requestMeta, options) => {
     const requestStartAt = requestMeta.queueEnteredAt;
     const requestSignal = options.turnWatchdogSignal ? AbortSignal.any([c.req.raw.signal, options.turnWatchdogSignal]) : c.req.raw.signal;
-    const requestAbort = linkRequestAbort(requestSignal);
+    const requestAbort = options.requestAbortLink ?? linkRequestAbort(requestSignal);
     let streamOwnsAbortLink = false;
     return withClaudeLogContext({ requestId: requestMeta.requestId, endpoint: requestMeta.endpoint }, async () => {
       const adapter = detectAdapter(c);
@@ -37628,6 +37693,7 @@ data: ${JSON.stringify(lastError)}
                 wantsStream: body.stream === true,
                 currentProfileId: assignedProfile,
                 turnWatchdogSignal: options.turnWatchdogSignal,
+                requestAbortLink: options.requestAbortLink,
                 publicationTurn,
                 claimTurn: trustedTurn,
                 durableRoute
@@ -37776,6 +37842,10 @@ data: ${JSON.stringify(lastError)}
         const taskBudget = Number.isFinite(parsedBudget) ? { total: parsedBudget } : body.task_budget ? { total: body.task_budget.total ?? body.task_budget } : undefined;
         const betas = betaFilter.forwarded;
         const agentSessionId = adapter.getSessionId(c, body);
+        const pluginlessOpenCode = isPluginlessOpenCodeRequest({
+          userAgent: c.req.header("user-agent"),
+          agentModeHeader: c.req.header("x-opencode-agent-mode")
+        });
         const pluginlessWarning = notePluginlessOpenCodeRequest({
           userAgent: c.req.header("user-agent"),
           agentModeHeader: c.req.header("x-opencode-agent-mode"),
@@ -37842,8 +37912,9 @@ data: ${JSON.stringify(lastError)}
         if (lineageResult.type === "undo" && adapterBase === "opencode" && !agentSessionId) {
           lineageResult = { type: "diverged", reason: "missing-session-header" };
         }
+        const protocolRunsConcurrentTurnsPerSessionKey = adapter.runsConcurrentTurnsPerSessionKey === true || pluginlessOpenCode;
         const declaresPerRequestConcurrentFlow = requestSource?.startsWith("fork-") === true || isSubagentRequest;
-        const declaresConcurrentFlow = declaresPerRequestConcurrentFlow || adapter.runsConcurrentTurnsPerSessionKey === true;
+        const declaresConcurrentFlow = declaresPerRequestConcurrentFlow || protocolRunsConcurrentTurnsPerSessionKey;
         const durableCheckpointIds = durableMappingAtTurn.status === "found" ? durableMappingAtTurn.session.passthroughToolCallIds : undefined;
         const trailingSystemReminderOptions = adapterBase === "claude-code" ? { allowTrailingSystemReminder: true } : undefined;
         const durableCheckpointContinuation = durableCheckpointIds?.length && durableMappingAtTurn.status === "found" && matchesStoredLineagePrefix(durableMappingAtTurn.session, lineageMessages) ? coalesceCompleteToolResultContinuation((body.messages || []).slice(durableMappingAtTurn.session.messageCount), durableCheckpointIds, trailingSystemReminderOptions) : undefined;
@@ -37903,7 +37974,7 @@ data: ${JSON.stringify(lastError)}
             headers: { "Content-Type": "application/json" }
           });
         }
-        if (lostRaceWhileWaiting && !declaresPerRequestConcurrentFlow && adapter.runsConcurrentTurnsPerSessionKey === true && lineageResult.type === "undo") {
+        if (lostRaceWhileWaiting && !declaresPerRequestConcurrentFlow && protocolRunsConcurrentTurnsPerSessionKey && lineageResult.type === "undo") {
           lineageResult = { type: "diverged", reason: "concurrent-race" };
         }
         if (options.forceFreshPriorityReplay) {
@@ -38310,6 +38381,7 @@ data: ${JSON.stringify(lastError)}
                   name: toolName,
                   reason: exceedsForcedSingle ? "forced_single" : "same_tool_repeat"
                 });
+                requestAbort.setCause("passthrough_single_step");
                 requestAbort.abort("passthrough single-step complete");
               } else {
                 capturedSignatures.add(signature);
@@ -38880,7 +38952,8 @@ Subprocess stderr: ${stderrOutput}`;
                 requestSource,
                 isResume,
                 hasDeferredTools,
-                sdkSessionId: currentSessionId || resumeSessionId
+                sdkSessionId: currentSessionId || resumeSessionId,
+                abort: requestAbort.abortSnapshot()
               })} captured=${capturedToolUses.length}`, requestMeta.requestId);
               claudeLog("passthrough.max_turns_recovered", {
                 mode: "non_stream",
@@ -39165,11 +39238,14 @@ Subprocess stderr: ${stderrOutput}`;
               let nextPassthroughToolCallAssistantUuid;
               let nextPassthroughToolCallIds;
               let sawCanonicalResult = false;
+              const uncapturedToolRecoveryEnabled = env("PASSTHROUGH_UNCAPTURED_TOOL_RECOVERY") === "1";
+              const streamedToolBlockRecords = new Map;
               const silentTurnRecoveryEnabled = env("SILENT_TURN_RECOVERY") !== "0";
               let silentTurnRecoveryAttempted = false;
               let silentTurnRecovered = false;
               const streamedToolUseIds = new Set;
               let pendingTerminalDelta = null;
+              let lastAttemptMaxTurns;
               let pendingStructuredFrames = [];
               let pendingStructuredTextLength = 0;
               let terminalDeltaSent = false;
@@ -39313,6 +39389,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         advisorModel
                       }, requestAbort.controller);
                       attemptMaxTurns = attemptQuery.options.maxTurns;
+                      lastAttemptMaxTurns = attemptMaxTurns;
                       for await (const event of runSdkQueryAttempt(attemptQuery, requestAbort.controller.signal, requestMeta, "stream", managedSdkAttemptLocators())) {
                         if (event.type === "rate_limit_event") {
                           rateLimitStore.record(profile.id, event.rate_limit_info);
@@ -39760,6 +39837,9 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         if (eventType === "content_block_stop") {
                           flushToolArguments(clientIdx);
                           passthroughToolBlockNames.delete(eventIndex);
+                          const record3 = streamedToolBlockRecords.get(clientIdx);
+                          if (record3)
+                            record3.naturalStop = true;
                         }
                       }
                       if (eventType === "content_block_delta" && event.delta?.type === "text_delta" && shouldInjectSilentTurn({
@@ -39793,6 +39873,34 @@ data: ${JSON.stringify(event)}
                         if (typeof idx === "number")
                           openClientBlocks.delete(idx);
                       }
+                      if (passthrough && uncapturedToolRecoveryEnabled) {
+                        const clientIdx = eventIndex !== undefined ? sdkToClientIndex.get(eventIndex) ?? eventIndex : undefined;
+                        if (clientIdx !== undefined) {
+                          if (eventType === "content_block_start") {
+                            const block = event.content_block;
+                            if (block?.type === "tool_use" && typeof block?.id === "string" && block.id) {
+                              streamedToolBlockRecords.set(clientIdx, {
+                                id: block.id,
+                                name: block.name,
+                                json: "",
+                                startedInputObject: block.input !== undefined && block.input !== null,
+                                forwardedStart: true,
+                                naturalStop: false
+                              });
+                            }
+                          } else if (eventType === "content_block_delta") {
+                            const delta = event.delta;
+                            const record3 = streamedToolBlockRecords.get(clientIdx);
+                            if (record3 && delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+                              record3.json += delta.partial_json;
+                            }
+                          } else if (eventType === "content_block_stop") {
+                            const record3 = streamedToolBlockRecords.get(clientIdx);
+                            if (record3)
+                              record3.naturalStop = true;
+                          }
+                        }
+                      }
                       if (passthrough && eventType === "message_delta" && event.delta?.stop_reason === "tool_use" && streamedToolUseIds.size > 0) {
                         flushOpenClientBlocks("drain_close");
                         if (earlyStopEnabled) {
@@ -40469,8 +40577,40 @@ Subprocess stderr: ${stderrOutput}`;
                   capturedToolUses: capturedToolUses.length,
                   abortIsOurs: sawDuplicateToolUse
                 }) && messageStartEmitted;
+                const uncapturedEligible = (() => {
+                  if (!canRecoverUncapturedToolUses({
+                    reason: sdkTerm.reason,
+                    passthrough,
+                    capturedToolUses: capturedToolUses.length,
+                    streamedToolUses: streamedToolUseIds.size,
+                    droppedToolUseIds: droppedToolUseIds.size,
+                    sawDuplicateToolUse,
+                    forceSingleToolUse,
+                    earlyStopFired,
+                    uncapturedRecoveryEnabled: uncapturedToolRecoveryEnabled,
+                    attemptedMaxTurns: lastAttemptMaxTurns
+                  }))
+                    return false;
+                  if (!messageStartEmitted || streamClosed || pendingTerminalDelta)
+                    return false;
+                  if (durableWritesRevoked)
+                    return false;
+                  if (requestAbort.abortSnapshot().aborted)
+                    return false;
+                  for (const record3 of streamedToolBlockRecords.values()) {
+                    if (!isStreamedToolBlockComplete(record3))
+                      return false;
+                    const declared = requestTools.some((t) => t.name === record3.name);
+                    if (!declared)
+                      return false;
+                  }
+                  if (streamedToolBlockRecords.size !== streamedToolUseIds.size)
+                    return false;
+                  return true;
+                })();
+                const uncapturedRecoveryActive = uncapturedEligible;
                 const recoverableCheckpoint = canRecoverAsToolUse && sdkTerm.reason === "max_turns" && Boolean(currentSessionId) && Boolean(nextPassthroughToolCallAssistantUuid) && Boolean(nextPassthroughToolCallIds?.length) && earlyStopFired && !isIndependentSession && !sawDuplicateToolUse;
-                const mustEvictBeforeRecoveredTerminal = !isIndependentSession && canRecoverAsToolUse && !recoverableCheckpoint;
+                const mustEvictBeforeRecoveredTerminal = !isIndependentSession && canRecoverAsToolUse && !recoverableCheckpoint || !isIndependentSession && uncapturedRecoveryActive && !recoverableCheckpoint;
                 if (mustEvictBeforeRecoveredTerminal || !isIndependentSession && passthrough && streamedToolUseIds.size > 0 && !sawCanonicalResult && !recoverableCheckpoint) {
                   const evicted = evictSession2(profileSessionId, profileScopedCwd, lineageMessages, mappingExpectedGeneration);
                   if (mustEvictBeforeRecoveredTerminal && !evicted) {
@@ -40478,15 +40618,16 @@ Subprocess stderr: ${stderrOutput}`;
                   }
                   claudeLog("passthrough.noncanonical_session_evicted", { mode: "stream", reason: "drain_error" });
                 }
-                if (canRecoverAsToolUse) {
+                if (canRecoverAsToolUse || uncapturedRecoveryActive) {
                   idleStalls.clear(idleStallSessionKey);
-                  diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
+                  diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered${uncapturedRecoveryActive ? "_uncaptured" : ""} ${formatSdkTermination(sdkTerm, {
                     model,
                     requestSource,
                     isResume,
                     hasDeferredTools,
-                    sdkSessionId: currentSessionId || resumeSessionId
-                  })} captured=${capturedToolUses.length}`, requestMeta.requestId);
+                    sdkSessionId: currentSessionId || resumeSessionId,
+                    abort: requestAbort.abortSnapshot()
+                  })} captured=${capturedToolUses.length}${uncapturedRecoveryActive ? ` completed=${streamedToolBlockRecords.size}` : ""}`, requestMeta.requestId);
                   flushOpenClientBlocks("recovery");
                   const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
                   for (let i = 0;i < unseenToolUses.length; i++) {
@@ -40627,7 +40768,8 @@ data: {"type":"message_stop"}
                     requestSource,
                     isResume,
                     hasDeferredTools,
-                    sdkSessionId: currentSessionId || resumeSessionId
+                    sdkSessionId: currentSessionId || resumeSessionId,
+                    abort: requestAbort.abortSnapshot()
                   })} blocks=${nextClientBlockIndex}`, requestMeta.requestId);
                   claudeLog("passthrough.capped_turn_truncated", {
                     mode: "stream",
@@ -40700,7 +40842,8 @@ data: {"type":"message_stop"}
                   requestSource,
                   isResume,
                   hasDeferredTools,
-                  sdkSessionId: currentSessionId || resumeSessionId
+                  sdkSessionId: currentSessionId || resumeSessionId,
+                  abort: requestAbort.abortSnapshot()
                 })} envelope=${messageStartEmitted ? "open" : "unopened"} blocks=${contentBlocksForwarded} ` + `text=${textEventsForwarded} tools=${capturedToolUses.length}/${streamedToolUseIds.size}`, requestMeta.requestId);
                 const streamErrTotalMs = Date.now() - requestStartAt;
                 const streamErrQueueWaitMs = totalQueueWaitMs(requestMeta);
@@ -40780,15 +40923,18 @@ data: ${JSON.stringify({
                 await abandonManagedFork("stream_complete_without_commit");
                 if (priorityRollbackRetirement)
                   await priorityRollbackRetirement;
-                requestAbort.detach();
+                if (!streamOwnsAbortLink)
+                  requestAbort.detach();
               }
             })().finally(() => {
               resolveStreamCompletion();
             });
           },
           cancel(reason) {
+            requestAbort.setCause("stream_cancel");
             requestAbort.abort(reason);
-            requestAbort.detach();
+            if (!streamOwnsAbortLink)
+              requestAbort.detach();
             requestMeta.cascadeSubtreeCancel?.("stream_cancel");
             if (!isIndependentSession && (!managedForkTarget || managedForkPublished || clientAssistantContentExposed)) {
               evictSession2(profileSessionId, profileScopedCwd, lineageMessages, mappingExpectedGeneration);
@@ -40821,7 +40967,8 @@ data: ${JSON.stringify({
         claudeLog("proxy.error", { error: errMsg, classified: classified.type });
         const sdkTerm = extractSdkTermination(errMsg);
         diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
-          requestSource: c.req.header("x-meridian-source")?.slice(0, 64) || undefined
+          requestSource: c.req.header("x-meridian-source")?.slice(0, 64) || undefined,
+          abort: requestAbort.abortSnapshot()
         })}`, requestMeta.requestId);
         const errorQueueWaitMs = totalQueueWaitMs(requestMeta);
         const errorTotalMs = Date.now() - requestStartAt;
@@ -40908,6 +41055,14 @@ data: ${JSON.stringify({
     };
     const turnWatchdogAbort = new AbortController;
     activeRequestAborts.add(turnWatchdogAbort);
+    const requestSignalForLink = AbortSignal.any([c.req.raw.signal, turnWatchdogAbort.signal]);
+    const labelClientAbort = () => {
+      if (!turnWatchdogAbort.signal.aborted)
+        requestAbortLink?.setCause("client_abort");
+    };
+    c.req.raw.signal.addEventListener("abort", labelClientAbort, { once: true });
+    const requestAbortLink = linkRequestAbort(requestSignalForLink);
+    activeShutdownLabels.set(turnWatchdogAbort, () => requestAbortLink.setCause("process_shutdown"));
     let finished = false;
     let leaseReleased = false;
     let retainSessionTurnFence = false;
@@ -40936,6 +41091,8 @@ data: ${JSON.stringify({
       if (finished)
         return;
       finished = true;
+      requestAbortLink.detach();
+      c.req.raw.signal.removeEventListener("abort", labelClientAbort);
       if (retainSessionTurnFence && (sessionTurnLease || crossProcessTurnLease)) {
         leaseReleased = true;
         if (leaseWatchdog)
@@ -40950,6 +41107,7 @@ data: ${JSON.stringify({
       sessionTreeRegistration?.release();
       sessionTreeRegistration = undefined;
       activeRequestAborts.delete(turnWatchdogAbort);
+      activeShutdownLabels.delete(turnWatchdogAbort);
       inFlightRequests--;
     };
     let body;
@@ -40981,7 +41139,10 @@ data: ${JSON.stringify({
             requestId,
             sessionKey: agentSessionId,
             parentKey: adapter.getParentSessionId?.(c, body),
-            abort: (reason) => turnWatchdogAbort.abort(reason)
+            abort: (reason) => {
+              requestAbortLink.setCause("subtree_cancel");
+              turnWatchdogAbort.abort(reason);
+            }
           });
           subtreeSessionKey = agentSessionId;
           const clientSignal = c.req.raw.signal;
@@ -41002,6 +41163,7 @@ data: ${JSON.stringify({
             leaseWatchdog = setTimeout(() => {
               claudeLog("session.turn_watchdog_abort", { requestId, heldMs: SESSION_TURN_MAX_HOLD_MS });
               plog(`[PROXY] ${requestId} session turn exceeded ${SESSION_TURN_MAX_HOLD_MS}ms — aborting without releasing its fencing lease`);
+              requestAbortLink.setCause("session_watchdog");
               turnWatchdogAbort.abort(new Error("Session turn exceeded its maximum hold time"));
             }, SESSION_TURN_MAX_HOLD_MS);
             leaseWatchdog.unref?.();
@@ -41076,7 +41238,8 @@ data: ${JSON.stringify({
       };
       const response = await handleMessages(c, requestMeta, {
         body,
-        turnWatchdogSignal: turnWatchdogAbort.signal
+        turnWatchdogSignal: turnWatchdogAbort.signal,
+        requestAbortLink
       });
       const completion = responseCompletions.get(response);
       if (completion) {
@@ -41901,6 +42064,8 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
     },
     forceAbortInFlight: () => {
       durableWritesRevoked = true;
+      for (const label of activeShutdownLabels.values())
+        label();
       for (const controller of activeRequestAborts) {
         controller.abort(new Error("Proxy shutdown grace period elapsed"));
       }

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   startProxyServer
-} from "./cli-198xnjcn.js";
+} from "./cli-ryt69ryf.js";
 import"./cli-5jxyma6z.js";
 import"./cli-sry5aqdj.js";
 import"./cli-8yp89fan.js";
@@ -10,7 +10,7 @@ import {
 } from "./cli-9e5cxp89.js";
 import"./cli-khhjyk04.js";
 import"./cli-vj9cv18n.js";
-import"./cli-zdbv40d5.js";
+import"./cli-hxxy0m1z.js";
 import {
   __require
 } from "./cli-p9swy5t3.js";
@@ -93,7 +93,7 @@ if (args[0] === "setup") {
     runSetup,
     SUPPORTED_OPENCODE_V2_VERSIONS,
     UnparseableConfigError
-  } = await import("./setup-b3ymd9z8.js");
+  } = await import("./setup-ndmjpy23.js");
   const forceV1 = args.includes("--v1");
   const forceV2 = args.includes("--v2");
   if (forceV1 && forceV2) {
@@ -205,7 +205,7 @@ async function runCli(start = startProxyServer, runAuthCheck = async () => {
   return execFile(claudePath, ["auth", "status"], { timeout: 5000 });
 }) {
   try {
-    const { findOpencodeConfigPath, checkPluginConfigured, findPluginPath } = await import("./setup-b3ymd9z8.js");
+    const { findOpencodeConfigPath, checkPluginConfigured, findPluginPath } = await import("./setup-ndmjpy23.js");
     const configPath = findOpencodeConfigPath();
     const { existsSync } = await import("fs");
     if (existsSync(configPath) && !checkPluginConfigured(configPath)) {

package/dist/meridian/index.js

@@ -13,9 +13,12 @@ var MAX_HEADER_BYTES = 768;
 var MAX_PAYLOAD_BYTES = 384;
 var TURN_DIGEST_PATTERN = /^[A-Za-z0-9_-]{43}$/;
 var SAFE_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
-function configDirectory() {
+function meridianConfigDirectory() {
   return process.env.MERIDIAN_CONFIG_DIR ?? join(homedir(), ".config", "meridian");
 }
+function configDirectory() {
+  return meridianConfigDirectory();
+}
 function priorityAttestationKeyPath() {
   return join(configDirectory(), PRIORITY_ATTESTATION_KEY_FILE);
 }