@rynfar/meridian 1.64.0 → 1.65.1

package/dist/{cli-4ghkaajs.js → cli-7cts44b5.js}

@@ -4,14 +4,16 @@ import {
   choosePriorityProfile,
   getActiveProfileId,
   getEffectiveProfiles,
+  getPriorityFailbackPolicy,
   getRoutingMode,
   listProfiles,
   resolveCooldownUntil,
   resolvePriorityOrder,
   resolveProfile,
   restoreActiveProfile,
-  setActiveProfile
-} from "./cli-m0p2bc8v.js";
+  setActiveProfile,
+  shouldPromotePriorityAssignment
+} from "./cli-pdpry6q0.js";
 import {
   isTrackedPlugin,
   recordError,
@@ -69,9 +71,12 @@ import {
 } from "./cli-vj9cv18n.js";
 import {
   LRUMap,
+  PRIORITY_ATTESTATION_HEADER,
   checkPluginConfigured,
-  notePluginlessOpenCodeRequest
-} from "./cli-pbvm9kc2.js";
+  init_priorityAttestation,
+  notePluginlessOpenCodeRequest,
+  verifyPriorityAttestation
+} from "./cli-n8t34zmq.js";
 import {
   __commonJS,
   __esm,
@@ -2304,6 +2309,7 @@ function canonicalizeOpenCodeMessagesForLineage(messages) {
 var openCodeAdapter;
 var init_opencode2 = __esm(() => {
   init_fileChanges();
+  init_priorityAttestation();
   init_messages();
   init_fingerprint();
   init_tools();
@@ -2325,6 +2331,25 @@ var init_opencode2 = __esm(() => {
     getAgentMode(c) {
       return c.req.header("x-opencode-agent-mode");
     },
+    getRoutingTurnIdentity(c) {
+      if (c.req.header("x-meridian-profile") !== undefined)
+        return;
+      const sessionId = c.req.header("x-opencode-session");
+      const agentId = c.req.header("x-opencode-agent-name");
+      if (!sessionId || !agentId || c.req.header("x-opencode-agent-mode") !== "primary") {
+        return;
+      }
+      const attestation = verifyPriorityAttestation(c.req.header(PRIORITY_ATTESTATION_HEADER));
+      if (!attestation || attestation.sessionId !== sessionId || attestation.agentId !== agentId) {
+        return;
+      }
+      return {
+        kind: "human",
+        turnId: attestation.turnId,
+        issuedAt: attestation.issuedAt,
+        generation: attestation.generation === "oc1" ? "opencode-v1" : "opencode-v2-beta-18314"
+      };
+    },
     extractWorkingDirectory(body) {
       return extractClientCwd(body);
     },
@@ -22691,6 +22716,7 @@ var BILLING_SIGNALS = [
   /insufficient (?:credit|funds|balance)/
 ];
 var HIT_YOUR_LIMIT = /hit your (?:[\w-]+ )?limit/;
+var OUT_OF_USAGE_CREDITS = /^\s*(?:(?:error|api error|claude code returned an error result):\s*)*you(?:'|’)re out of usage credits(?:[.!]\s*)?(?:\/model to switch models\.?)?\s*$/;
 var HTTP_401 = /(?:^|[^0-9a-f])401(?![0-9a-f]|:\d)/;
 var HTTP_429 = /(?:^|[^0-9a-f])429(?![0-9a-f]|:\d)/;
 var HTTP_500 = /(?:^|[^0-9a-f])500(?![0-9a-f]|:\d)/;
@@ -22711,7 +22737,7 @@ function classifyError(errMsg, model) {
       message: "Claude authentication expired or invalid. Run 'claude login' in your terminal to re-authenticate, then restart the proxy."
     };
   }
-  if (HTTP_429.test(lower) || lower.includes("rate limit") || lower.includes("too many requests") || HIT_YOUR_LIMIT.test(lower) || lower.includes("usage limit reached")) {
+  if (HTTP_429.test(lower) || lower.includes("rate limit") || lower.includes("too many requests") || HIT_YOUR_LIMIT.test(lower) || lower.includes("usage limit reached") || OUT_OF_USAGE_CREDITS.test(lower)) {
     const hint = lower.includes("1m") || lower.includes("context") ? extendedContextHint(model) : "";
     return {
       status: 429,
@@ -31276,6 +31302,7 @@ function getRecoveryClaimTombstonePath(claimPath, claimToken) {
 // src/proxy/sessionStore.ts
 var STORE_META_KEY = "\x00meridian-session-store";
 var STORE_META_VERSION = 1;
+var PRIORITY_STORE_META_VERSION = 3;
 function keyDigest(key) {
   return createHash5("sha256").update(key).digest("hex");
 }
@@ -31292,6 +31319,18 @@ function getStoredSessionGeneration(session, key) {
 function keyGeneration(key, session, meta3) {
   return session ? getStoredSessionGeneration(session, key) : absenceGeneration(key, meta3);
 }
+function priorityGenerationKey(routeKey) {
+  return `priority:${routeKey}`;
+}
+function priorityAbsenceGeneration(routeKey, meta3) {
+  return absenceGeneration(priorityGenerationKey(routeKey), meta3);
+}
+function getPriorityAssignmentGeneration(assignment, routeKey) {
+  return `r:${keyDigest(priorityGenerationKey(routeKey))}:${assignment.generationId}`;
+}
+function priorityAssignmentGeneration(routeKey, assignment, meta3) {
+  return assignment ? getPriorityAssignmentGeneration(assignment, routeKey) : priorityAbsenceGeneration(routeKey, meta3);
+}
 function advanceKeySlot(key, meta3) {
   const slot = keySlot(key);
   const current = meta3.slots[slot] ?? 0;
@@ -31301,6 +31340,8 @@ function advanceKeySlot(key, meta3) {
   meta3.slots[slot] = current + 1;
 }
 var DEFAULT_MAX_STORED_SESSIONS = 1e4;
+var DEFAULT_MAX_PRIORITY_ASSIGNMENTS = 5000;
+var DEFAULT_MAX_PRIORITY_ATTEMPTS = 5000;
 var STALE_LOCK_THRESHOLD_MS = 30000;
 var DEFAULT_LOCK_WAIT_MS = 1e4;
 var LOCK_RETRY_MS = 10;
@@ -31314,6 +31355,24 @@ function getMaxStoredSessionsLimit() {
     return DEFAULT_MAX_STORED_SESSIONS;
   return parsed;
 }
+function getMaxPriorityAssignmentsLimit() {
+  const raw2 = process.env.MERIDIAN_MAX_PRIORITY_ASSIGNMENTS;
+  if (!raw2)
+    return DEFAULT_MAX_PRIORITY_ASSIGNMENTS;
+  const parsed = Number.parseInt(raw2, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return DEFAULT_MAX_PRIORITY_ASSIGNMENTS;
+  return parsed;
+}
+function getMaxPriorityAttemptsLimit() {
+  const raw2 = process.env.MERIDIAN_MAX_PRIORITY_ATTEMPTS;
+  if (!raw2)
+    return DEFAULT_MAX_PRIORITY_ATTEMPTS;
+  const parsed = Number.parseInt(raw2, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return DEFAULT_MAX_PRIORITY_ATTEMPTS;
+  return parsed;
+}
 function getLockWaitMs() {
   const raw2 = process.env.MERIDIAN_SESSION_LOCK_TIMEOUT_MS ?? process.env.CLAUDE_PROXY_SESSION_LOCK_TIMEOUT_MS;
   if (!raw2)
@@ -31701,6 +31760,98 @@ function validateStoredSession(key, value) {
     }
   }
 }
+function hasExactObjectKeys(value, expected) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index]);
+}
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function validatePriorityAssignment(routeKey, value) {
+  if (!routeKey || routeKey.length > 512 || !value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} is invalid`);
+  }
+  const assignment = value;
+  if (!hasExactObjectKeys(assignment, [
+    "profileId",
+    "lastHumanTurnDigest",
+    "lastHumanTurnIssuedAt",
+    "mappingKey",
+    "mappingGeneration",
+    "generationId",
+    "updatedAt"
+  ])) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has unknown or missing fields`);
+  }
+  if (typeof assignment.profileId !== "string" || !assignment.profileId || assignment.profileId.length > 128) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid profileId`);
+  }
+  if (typeof assignment.lastHumanTurnDigest !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(assignment.lastHumanTurnDigest)) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid human-turn digest`);
+  }
+  if (typeof assignment.lastHumanTurnIssuedAt !== "number" || !Number.isSafeInteger(assignment.lastHumanTurnIssuedAt) || assignment.lastHumanTurnIssuedAt < 0) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid human-turn issue time`);
+  }
+  if (typeof assignment.mappingKey !== "string" || !assignment.mappingKey || assignment.mappingKey.length > 1024) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid mappingKey`);
+  }
+  const expectedMappingPrefix = typeof assignment.mappingKey === "string" ? `p:${keyDigest(assignment.mappingKey)}:` : "";
+  if (typeof assignment.mappingGeneration !== "string" || !assignment.mappingGeneration.startsWith(expectedMappingPrefix) || !UUID_PATTERN2.test(assignment.mappingGeneration.slice(expectedMappingPrefix.length))) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid mapping generation`);
+  }
+  if (typeof assignment.generationId !== "string" || !UUID_PATTERN2.test(assignment.generationId)) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid generationId`);
+  }
+  if (typeof assignment.updatedAt !== "number" || !Number.isSafeInteger(assignment.updatedAt) || assignment.updatedAt < 0) {
+    throw new Error(`session store priority route ${JSON.stringify(routeKey)} has invalid updatedAt`);
+  }
+  return {
+    profileId: assignment.profileId,
+    lastHumanTurnDigest: assignment.lastHumanTurnDigest,
+    lastHumanTurnIssuedAt: assignment.lastHumanTurnIssuedAt,
+    mappingKey: assignment.mappingKey,
+    mappingGeneration: assignment.mappingGeneration,
+    generationId: assignment.generationId,
+    updatedAt: assignment.updatedAt
+  };
+}
+function validatePriorityAttempt(routeKey, value) {
+  if (!routeKey || routeKey.length > 512 || !value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`session store priority attempt ${JSON.stringify(routeKey)} is invalid`);
+  }
+  const attempt = value;
+  if (!hasExactObjectKeys(attempt, [
+    "blocked",
+    "blockedTurnDigest",
+    "blockedTurnIssuedAt",
+    "pendingTurnDigest",
+    "pendingTurnIssuedAt",
+    "ownerToken",
+    "generationId",
+    "updatedAt"
+  ]))
+    throw new Error(`session store priority attempt ${JSON.stringify(routeKey)} has unknown or missing fields`);
+  const validDigest = (digest) => digest === null || typeof digest === "string" && /^[A-Za-z0-9_-]{43}$/.test(digest);
+  const validIssuedAt = (issuedAt) => issuedAt === null || typeof issuedAt === "number" && Number.isSafeInteger(issuedAt) && issuedAt >= 0;
+  if (typeof attempt.blocked !== "boolean" || !validDigest(attempt.blockedTurnDigest) || !validIssuedAt(attempt.blockedTurnIssuedAt) || !validDigest(attempt.pendingTurnDigest) || !validIssuedAt(attempt.pendingTurnIssuedAt) || attempt.blockedTurnDigest === null !== (attempt.blockedTurnIssuedAt === null) || attempt.pendingTurnDigest === null !== (attempt.pendingTurnIssuedAt === null) || attempt.ownerToken !== null && (typeof attempt.ownerToken !== "string" || !UUID_PATTERN2.test(attempt.ownerToken)) || attempt.ownerToken === null && attempt.pendingTurnDigest !== null || !attempt.blocked && attempt.ownerToken === null) {
+    throw new Error(`session store priority attempt ${JSON.stringify(routeKey)} has invalid state`);
+  }
+  if (typeof attempt.generationId !== "string" || !UUID_PATTERN2.test(attempt.generationId)) {
+    throw new Error(`session store priority attempt ${JSON.stringify(routeKey)} has invalid generationId`);
+  }
+  if (typeof attempt.updatedAt !== "number" || !Number.isSafeInteger(attempt.updatedAt) || attempt.updatedAt < 0) {
+    throw new Error(`session store priority attempt ${JSON.stringify(routeKey)} has invalid updatedAt`);
+  }
+  return {
+    blocked: attempt.blocked,
+    blockedTurnDigest: attempt.blockedTurnDigest,
+    blockedTurnIssuedAt: attempt.blockedTurnIssuedAt,
+    pendingTurnDigest: attempt.pendingTurnDigest,
+    pendingTurnIssuedAt: attempt.pendingTurnIssuedAt,
+    ownerToken: attempt.ownerToken,
+    generationId: attempt.generationId,
+    updatedAt: attempt.updatedAt
+  };
+}
 function emptyStoreDocument() {
   return { sessions: {}, meta: { version: STORE_META_VERSION, slots: {} } };
 }
@@ -31709,7 +31860,7 @@ function validateStoreMeta(value) {
     throw new Error("session store metadata must be an object");
   }
   const meta3 = value;
-  if (meta3.version !== STORE_META_VERSION || typeof meta3.slots !== "object" || meta3.slots === null || Array.isArray(meta3.slots)) {
+  if (meta3.version !== STORE_META_VERSION && meta3.version !== PRIORITY_STORE_META_VERSION || typeof meta3.slots !== "object" || meta3.slots === null || Array.isArray(meta3.slots)) {
     throw new Error("session store metadata has an unsupported format");
   }
   for (const [slot, counter] of Object.entries(meta3.slots)) {
@@ -31717,7 +31868,55 @@ function validateStoreMeta(value) {
       throw new Error(`session store metadata has invalid generation slot ${JSON.stringify(slot)}`);
     }
   }
-  return { version: STORE_META_VERSION, slots: { ...meta3.slots } };
+  const slots = { ...meta3.slots };
+  if (meta3.version === STORE_META_VERSION) {
+    if (!hasExactObjectKeys(meta3, ["version", "slots"])) {
+      throw new Error("session store v1 metadata has unknown or missing fields");
+    }
+    return { version: STORE_META_VERSION, slots };
+  }
+  if (!hasExactObjectKeys(meta3, ["version", "slots", "priorityAssignments", "priorityAttempts", "priorityRollbackMappings"])) {
+    throw new Error("session store v3 metadata has unknown or missing fields");
+  }
+  if (typeof meta3.priorityAssignments !== "object" || meta3.priorityAssignments === null || Array.isArray(meta3.priorityAssignments))
+    throw new Error("session store v3 metadata has invalid priority assignments");
+  if (typeof meta3.priorityAttempts !== "object" || meta3.priorityAttempts === null || Array.isArray(meta3.priorityAttempts))
+    throw new Error("session store v3 metadata has invalid priority attempts");
+  if (typeof meta3.priorityRollbackMappings !== "object" || meta3.priorityRollbackMappings === null || Array.isArray(meta3.priorityRollbackMappings))
+    throw new Error("session store v3 metadata has invalid priority rollback mappings");
+  const priorityAssignments = {};
+  for (const [routeKey, assignment] of Object.entries(meta3.priorityAssignments)) {
+    priorityAssignments[routeKey] = validatePriorityAssignment(routeKey, assignment);
+  }
+  const priorityAttempts = {};
+  for (const [routeKey, attempt] of Object.entries(meta3.priorityAttempts)) {
+    priorityAttempts[routeKey] = validatePriorityAttempt(routeKey, attempt);
+  }
+  const priorityRollbackMappings = {};
+  for (const [routeKey, value2] of Object.entries(meta3.priorityRollbackMappings)) {
+    if (!priorityAssignments[routeKey] || !value2 || typeof value2 !== "object" || Array.isArray(value2)) {
+      throw new Error(`session store priority rollback ${JSON.stringify(routeKey)} is invalid`);
+    }
+    const rollback = value2;
+    if (!hasExactObjectKeys(rollback, ["mappingKey", "mappingGeneration"]) || typeof rollback.mappingKey !== "string" || !rollback.mappingKey || rollback.mappingKey.length > 1024) {
+      throw new Error(`session store priority rollback ${JSON.stringify(routeKey)} is invalid`);
+    }
+    const expectedMappingPrefix = `p:${keyDigest(rollback.mappingKey)}:`;
+    if (typeof rollback.mappingGeneration !== "string" || !rollback.mappingGeneration.startsWith(expectedMappingPrefix) || !UUID_PATTERN2.test(rollback.mappingGeneration.slice(expectedMappingPrefix.length))) {
+      throw new Error(`session store priority rollback ${JSON.stringify(routeKey)} has invalid mapping generation`);
+    }
+    priorityRollbackMappings[routeKey] = {
+      mappingKey: rollback.mappingKey,
+      mappingGeneration: rollback.mappingGeneration
+    };
+  }
+  return {
+    version: PRIORITY_STORE_META_VERSION,
+    slots,
+    priorityAssignments,
+    priorityAttempts,
+    priorityRollbackMappings
+  };
 }
 function readStoreDocumentStrict(path3) {
   let data;
@@ -31742,6 +31941,21 @@ function readStoreDocumentStrict(path3) {
     validateStoredSession(key, value);
     sessions[key] = value;
   }
+  if (meta3.version === PRIORITY_STORE_META_VERSION) {
+    for (const [routeKey, rollback] of Object.entries(meta3.priorityRollbackMappings)) {
+      const assignment = meta3.priorityAssignments[routeKey];
+      const mapping = sessions[rollback.mappingKey];
+      if (!mapping) {
+        throw new Error(`session store priority rollback ${JSON.stringify(routeKey)} has no retained mapping`);
+      }
+      if (rollback.mappingKey === assignment.mappingKey) {
+        throw new Error(`session store priority rollback ${JSON.stringify(routeKey)} aliases its current mapping`);
+      }
+      if (getStoredSessionGeneration(mapping, rollback.mappingKey) !== rollback.mappingGeneration) {
+        throw new Error(`session store priority rollback ${JSON.stringify(routeKey)} has a stale mapping generation`);
+      }
+    }
+  }
   return { sessions, meta: meta3 };
 }
 function readStoreStrict(path3) {
@@ -31842,6 +32056,19 @@ function lookupSharedSession(key) {
   const result = lookupSharedSessionResult(key);
   return result.status === "found" ? result.session : undefined;
 }
+function lookupPriorityAssignmentResult(routeKey) {
+  try {
+    const document = readStoreDocumentStrict(getStorePath());
+    const assignment = document.meta.version === PRIORITY_STORE_META_VERSION ? document.meta.priorityAssignments[routeKey] : undefined;
+    const generation = priorityAssignmentGeneration(routeKey, assignment, document.meta);
+    const attempt = document.meta.version === PRIORITY_STORE_META_VERSION ? document.meta.priorityAttempts[routeKey] : undefined;
+    return assignment ? { status: "found", assignment, generation, attempt } : { status: "missing", generation, attempt };
+  } catch (error51) {
+    const normalized = error51 instanceof Error ? error51 : new Error(String(error51));
+    console.error("[sessionStore] priority route read failed:", normalized.message);
+    return { status: "error", error: normalized };
+  }
+}
 function lookupSharedSessionByClaudeIdResult(claudeSessionId) {
   try {
     const document = readStoreDocumentStrict(getStorePath());
@@ -31876,6 +32103,9 @@ function validateTranscriptLocator(locator, claudeSessionId) {
     throw new Error("currentTranscript.lifecycleGeneration must be non-empty");
   }
 }
+function isPriorityRollbackMapping(meta3, key) {
+  return meta3.version === PRIORITY_STORE_META_VERSION && Object.values(meta3.priorityRollbackMappings).some((rollback) => rollback.mappingKey === key);
+}
 function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughToolCallAssistantUuid, passthroughToolCallIds, currentTranscript, sourceTranscript, expectedGeneration) {
   if (currentTranscript !== undefined) {
     validateTranscriptLocator(currentTranscript, claudeSessionId);
@@ -31890,6 +32120,8 @@ function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, mes
   }
   let storedGeneration = false;
   mutateStore(({ sessions: store, meta: meta3 }) => {
+    if (isPriorityRollbackMapping(meta3, key))
+      return false;
     const existing = store[key];
     if (expectedGeneration !== undefined) {
       const actual = keyGeneration(key, existing, meta3);
@@ -31926,18 +32158,412 @@ function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, mes
     };
     const maxEntries = getMaxStoredSessionsLimit();
     const keys = Object.keys(store);
-    if (keys.length > maxEntries) {
-      const sorted = keys.filter((candidate) => candidate !== key).sort((a, b) => (store[a].lastUsedAt || 0) - (store[b].lastUsedAt || 0));
-      const toRemove = sorted.slice(0, keys.length - maxEntries);
-      for (const candidate of toRemove)
-        delete store[candidate];
+    const protectedMappings = meta3.version === PRIORITY_STORE_META_VERSION ? new Set([
+      ...Object.values(meta3.priorityAssignments).map((assignment) => assignment.mappingKey),
+      ...Object.values(meta3.priorityRollbackMappings).map((rollback) => rollback.mappingKey)
+    ]) : new Set;
+    protectedMappings.add(key);
+    const removeCount = Math.max(0, keys.length - maxEntries);
+    const removable = keys.filter((candidate) => !protectedMappings.has(candidate)).sort((a, b) => (store[a].lastUsedAt || 0) - (store[b].lastUsedAt || 0));
+    if (removable.length < removeCount)
+      return false;
+    for (const candidate of removable.slice(0, removeCount)) {
+      delete store[candidate];
+      advanceKeySlot(candidate, meta3);
     }
     advanceKeySlot(key, meta3);
     storedGeneration = getStoredSessionGeneration(store[key], key);
+    if (meta3.version === PRIORITY_STORE_META_VERSION) {
+      for (const [routeKey, assignment] of Object.entries(meta3.priorityAssignments)) {
+        if (assignment.mappingKey !== key)
+          continue;
+        assignment.mappingGeneration = storedGeneration;
+        assignment.generationId = randomUUID2();
+        assignment.updatedAt = Date.now();
+        advanceKeySlot(priorityGenerationKey(routeKey), meta3);
+      }
+    }
     return true;
   });
   return storedGeneration;
 }
+function validatePriorityAttemptTurn(turn) {
+  if (!turn)
+    return;
+  if (!/^[A-Za-z0-9_-]{43}$/.test(turn.turnId) || !Number.isSafeInteger(turn.issuedAt) || turn.issuedAt < 0) {
+    throw new Error("priority attempt requires a valid trusted turn");
+  }
+}
+function claimPriorityAttempt(options) {
+  if (!options.routeKey || options.routeKey.length > 512) {
+    throw new Error("priority attempt requires a bounded route key");
+  }
+  validatePriorityAttemptTurn(options.turn);
+  const ownerToken = randomUUID2();
+  let claimed = false;
+  mutateStore((document) => {
+    const assignment = document.meta.version === PRIORITY_STORE_META_VERSION ? document.meta.priorityAssignments[options.routeKey] : undefined;
+    if (priorityAssignmentGeneration(options.routeKey, assignment, document.meta) !== options.expectedAssignmentGeneration)
+      return false;
+    const existing = document.meta.version === PRIORITY_STORE_META_VERSION ? document.meta.priorityAttempts[options.routeKey] : undefined;
+    if (existing) {
+      const floor = Math.max(assignment?.lastHumanTurnIssuedAt ?? -1, existing.blockedTurnIssuedAt ?? -1, existing.pendingTurnIssuedAt ?? -1);
+      if (!options.turn || options.turn.issuedAt <= floor)
+        return false;
+    } else if (document.meta.version === PRIORITY_STORE_META_VERSION && Object.keys(document.meta.priorityAttempts).length >= getMaxPriorityAttemptsLimit()) {
+      return false;
+    }
+    if (document.meta.version === STORE_META_VERSION) {
+      document.meta = {
+        version: PRIORITY_STORE_META_VERSION,
+        slots: document.meta.slots,
+        priorityAssignments: {},
+        priorityAttempts: {},
+        priorityRollbackMappings: {}
+      };
+    }
+    const previous = document.meta.priorityAttempts[options.routeKey];
+    let blocked = previous?.blocked ?? false;
+    let blockedTurnDigest = previous?.blockedTurnDigest ?? null;
+    let blockedTurnIssuedAt = previous?.blockedTurnIssuedAt ?? null;
+    if (previous?.ownerToken) {
+      blocked = true;
+      if (previous.pendingTurnIssuedAt !== null && (blockedTurnIssuedAt === null || previous.pendingTurnIssuedAt > blockedTurnIssuedAt)) {
+        blockedTurnDigest = previous.pendingTurnDigest;
+        blockedTurnIssuedAt = previous.pendingTurnIssuedAt;
+      }
+    }
+    document.meta.priorityAttempts[options.routeKey] = {
+      blocked,
+      blockedTurnDigest,
+      blockedTurnIssuedAt,
+      pendingTurnDigest: options.turn?.turnId ?? null,
+      pendingTurnIssuedAt: options.turn?.issuedAt ?? null,
+      ownerToken,
+      generationId: randomUUID2(),
+      updatedAt: Date.now()
+    };
+    advanceKeySlot(`priority-attempt:${options.routeKey}`, document.meta);
+    claimed = true;
+    return true;
+  });
+  return claimed ? { ownerToken } : false;
+}
+function settlePriorityAttempt(routeKey, ownerToken, disposition) {
+  if (!routeKey || routeKey.length > 512 || !UUID_PATTERN2.test(ownerToken))
+    return false;
+  let settled = false;
+  mutateStore((document) => {
+    if (document.meta.version !== PRIORITY_STORE_META_VERSION)
+      return false;
+    const attempt = document.meta.priorityAttempts[routeKey];
+    if (!attempt || attempt.ownerToken !== ownerToken)
+      return false;
+    if (disposition === "block") {
+      attempt.blocked = true;
+      if (attempt.pendingTurnIssuedAt !== null && (attempt.blockedTurnIssuedAt === null || attempt.pendingTurnIssuedAt > attempt.blockedTurnIssuedAt)) {
+        attempt.blockedTurnDigest = attempt.pendingTurnDigest;
+        attempt.blockedTurnIssuedAt = attempt.pendingTurnIssuedAt;
+      }
+      attempt.pendingTurnDigest = null;
+      attempt.pendingTurnIssuedAt = null;
+      attempt.ownerToken = null;
+      attempt.generationId = randomUUID2();
+      attempt.updatedAt = Date.now();
+    } else if (attempt.blocked) {
+      attempt.pendingTurnDigest = null;
+      attempt.pendingTurnIssuedAt = null;
+      attempt.ownerToken = null;
+      attempt.generationId = randomUUID2();
+      attempt.updatedAt = Date.now();
+    } else {
+      delete document.meta.priorityAttempts[routeKey];
+    }
+    advanceKeySlot(`priority-attempt:${routeKey}`, document.meta);
+    settled = true;
+    return true;
+  });
+  return settled;
+}
+function releasePriorityAttempt(routeKey, ownerToken) {
+  return settlePriorityAttempt(routeKey, ownerToken, "release");
+}
+function blockPriorityAttempt(routeKey, ownerToken) {
+  return settlePriorityAttempt(routeKey, ownerToken, "block");
+}
+function validatePriorityPublicationInput(options) {
+  if (!options.key || options.key.length > 1024)
+    throw new Error("priority publication requires a bounded mapping key");
+  if (!options.priority.routeKey || options.priority.routeKey.length > 512) {
+    throw new Error("priority publication requires a bounded route key");
+  }
+  if (!options.priority.profileId || options.priority.profileId.length > 128) {
+    throw new Error("priority publication requires a bounded profile ID");
+  }
+  if (!/^[A-Za-z0-9_-]{43}$/.test(options.priority.lastHumanTurnDigest)) {
+    throw new Error("priority publication requires a valid human-turn digest");
+  }
+  if (!Number.isSafeInteger(options.priority.lastHumanTurnIssuedAt) || options.priority.lastHumanTurnIssuedAt < 0) {
+    throw new Error("priority publication requires a valid human-turn issue time");
+  }
+  if (options.attemptOwnerToken !== undefined && !UUID_PATTERN2.test(options.attemptOwnerToken)) {
+    throw new Error("priority publication requires a valid attempt owner token");
+  }
+  if (options.currentTranscript !== undefined)
+    validateTranscriptLocator(options.currentTranscript, options.claudeSessionId);
+  if (options.rollbackMappingKey !== undefined && (!options.rollbackMappingKey || options.rollbackMappingKey.length > 1024)) {
+    throw new Error("priority publication requires a bounded rollback mapping key");
+  }
+  if (options.sourceTranscript !== undefined) {
+    if (!isAbsolute4(options.sourceTranscript.configDir)) {
+      throw new Error("sourceTranscript.configDir must be an absolute path");
+    }
+    if (options.sourceTranscript.projectDir !== undefined && !isAbsolute4(options.sourceTranscript.projectDir)) {
+      throw new Error("sourceTranscript.projectDir must be an absolute path");
+    }
+  }
+}
+function storeSharedSessionAndPriorityAssignment(options) {
+  validatePriorityPublicationInput(options);
+  let result = false;
+  mutateStore((document) => {
+    const existing = document.sessions[options.key];
+    const actualMappingGeneration = keyGeneration(options.key, existing, document.meta);
+    if (actualMappingGeneration !== options.expectedMappingGeneration)
+      return false;
+    if (document.meta.version === PRIORITY_STORE_META_VERSION) {
+      const markerOwners = Object.entries(document.meta.priorityRollbackMappings).filter(([, rollback]) => rollback.mappingKey === options.key);
+      if (markerOwners.some(([routeKey]) => routeKey !== options.priority.routeKey))
+        return false;
+      const ownMarker = document.meta.priorityRollbackMappings[options.priority.routeKey];
+      if (ownMarker?.mappingKey === options.key && ownMarker.mappingGeneration !== actualMappingGeneration)
+        return false;
+    }
+    const existingAssignments = document.meta.version === PRIORITY_STORE_META_VERSION ? document.meta.priorityAssignments : {};
+    const existingAssignment = existingAssignments[options.priority.routeKey];
+    const actualAssignmentGeneration = priorityAssignmentGeneration(options.priority.routeKey, existingAssignment, document.meta);
+    if (actualAssignmentGeneration !== options.priority.expectedAssignmentGeneration)
+      return false;
+    const existingAttempt = document.meta.version === PRIORITY_STORE_META_VERSION ? document.meta.priorityAttempts[options.priority.routeKey] : undefined;
+    if (options.attemptOwnerToken !== undefined) {
+      if (existingAttempt?.ownerToken !== options.attemptOwnerToken)
+        return false;
+    } else if (existingAttempt) {
+      return false;
+    }
+    const sessionIdChanged = existing !== undefined && existing.claudeSessionId !== options.claudeSessionId;
+    if (options.sourceTranscript !== undefined) {
+      if (!sessionIdChanged || options.sourceTranscript.sessionId !== existing?.claudeSessionId) {
+        throw new Error("sourceTranscript.sessionId must match the replaced claudeSessionId");
+      }
+    }
+    const previousClaudeSessionId = sessionIdChanged ? existing.claudeSessionId : existing?.previousClaudeSessionId;
+    const resolvedCurrentTranscript = sessionIdChanged ? options.currentTranscript : existing?.currentTranscript ?? options.currentTranscript;
+    const previousTranscript = sessionIdChanged ? existing?.currentTranscript ?? options.sourceTranscript : existing?.previousTranscript;
+    const stored = {
+      claudeSessionId: options.claudeSessionId,
+      revision: (existing?.revision ?? 0) + 1,
+      generationId: randomUUID2(),
+      createdAt: existing?.createdAt || Date.now(),
+      lastUsedAt: Date.now(),
+      messageCount: options.messageCount,
+      lineageHash: options.lineageHash,
+      messageHashes: options.messageHashes,
+      messageBlockHashes: options.messageBlockHashes,
+      sdkMessageUuids: options.sdkMessageUuids,
+      passthroughToolCallAssistantUuid: options.passthroughToolCallAssistantUuid ?? undefined,
+      passthroughToolCallIds: options.passthroughToolCallIds ?? undefined,
+      contextUsage: options.contextUsage,
+      ...resolvedCurrentTranscript ? { currentTranscript: resolvedCurrentTranscript } : {},
+      ...previousTranscript ? { previousTranscript } : {},
+      ...previousClaudeSessionId ? { previousClaudeSessionId } : {}
+    };
+    document.sessions[options.key] = stored;
+    advanceKeySlot(options.key, document.meta);
+    const mappingGeneration = getStoredSessionGeneration(stored, options.key);
+    if (document.meta.version === STORE_META_VERSION) {
+      document.meta = {
+        version: PRIORITY_STORE_META_VERSION,
+        slots: document.meta.slots,
+        priorityAssignments: {},
+        priorityAttempts: {},
+        priorityRollbackMappings: {}
+      };
+    }
+    const assignment = {
+      profileId: options.priority.profileId,
+      lastHumanTurnDigest: options.priority.lastHumanTurnDigest,
+      lastHumanTurnIssuedAt: options.priority.lastHumanTurnIssuedAt,
+      mappingKey: options.key,
+      mappingGeneration,
+      generationId: randomUUID2(),
+      updatedAt: Date.now()
+    };
+    const priorityAssignments = document.meta.priorityAssignments;
+    const priorityRollbackMappings = document.meta.priorityRollbackMappings;
+    priorityAssignments[options.priority.routeKey] = assignment;
+    const existingRollback = priorityRollbackMappings[options.priority.routeKey];
+    const rollbackMappingKey = options.rollbackMappingKey ?? existingAssignment?.mappingKey;
+    if (rollbackMappingKey && rollbackMappingKey !== options.key) {
+      const rollbackMapping = document.sessions[rollbackMappingKey];
+      if (!rollbackMapping) {
+        throw new Error("priority rollback mapping disappeared before publication");
+      }
+      const rollbackMappingGeneration = getStoredSessionGeneration(rollbackMapping, rollbackMappingKey);
+      if (existingAssignment?.mappingKey === rollbackMappingKey && existingAssignment.mappingGeneration !== rollbackMappingGeneration)
+        return false;
+      priorityRollbackMappings[options.priority.routeKey] = existingRollback?.mappingKey === rollbackMappingKey ? existingRollback : { mappingKey: rollbackMappingKey, mappingGeneration: rollbackMappingGeneration };
+    } else {
+      delete priorityRollbackMappings[options.priority.routeKey];
+    }
+    advanceKeySlot(priorityGenerationKey(options.priority.routeKey), document.meta);
+    const maxSessions = getMaxStoredSessionsLimit();
+    const maxAssignments = getMaxPriorityAssignmentsLimit();
+    const referencedMappingKeys = () => new Set(Object.values(priorityAssignments).map((candidate) => candidate.mappingKey));
+    const sortedRoutes = Object.keys(priorityAssignments).filter((candidate) => candidate !== options.priority.routeKey && priorityRollbackMappings[candidate] === undefined).sort((left, right) => priorityAssignments[left].updatedAt - priorityAssignments[right].updatedAt);
+    while (Object.keys(priorityAssignments).length > maxAssignments || referencedMappingKeys().size > maxSessions) {
+      const candidate = sortedRoutes.shift();
+      if (!candidate)
+        return false;
+      delete priorityAssignments[candidate];
+      delete priorityRollbackMappings[candidate];
+      advanceKeySlot(priorityGenerationKey(candidate), document.meta);
+    }
+    const protectedMappings = referencedMappingKeys();
+    protectedMappings.add(options.key);
+    for (const rollback of Object.values(priorityRollbackMappings)) {
+      protectedMappings.add(rollback.mappingKey);
+    }
+    const protectedExistingCount = [...protectedMappings].filter((candidate) => document.sessions[candidate] !== undefined).length;
+    const retainedSessionLimit = Math.max(maxSessions, protectedExistingCount);
+    const sortedSessions = Object.keys(document.sessions).filter((candidate) => !protectedMappings.has(candidate)).sort((left, right) => document.sessions[left].lastUsedAt - document.sessions[right].lastUsedAt);
+    while (Object.keys(document.sessions).length > retainedSessionLimit) {
+      const candidate = sortedSessions.shift();
+      if (!candidate)
+        break;
+      delete document.sessions[candidate];
+      advanceKeySlot(candidate, document.meta);
+    }
+    result = {
+      mappingGeneration,
+      assignmentGeneration: getPriorityAssignmentGeneration(assignment, options.priority.routeKey),
+      previousMapping: existing ? structuredClone(existing) : null,
+      previousAssignment: existingAssignment ? structuredClone(existingAssignment) : null
+    };
+    return true;
+  });
+  return result;
+}
+function finalizeSharedSessionAndPriorityAssignment(options) {
+  let finalized = false;
+  mutateStore((document) => {
+    if (document.meta.version !== PRIORITY_STORE_META_VERSION)
+      return false;
+    const mapping = document.sessions[options.key];
+    if (keyGeneration(options.key, mapping, document.meta) !== options.expectedMappingGeneration)
+      return false;
+    const assignment = document.meta.priorityAssignments[options.routeKey];
+    if (!assignment || priorityAssignmentGeneration(options.routeKey, assignment, document.meta) !== options.expectedAssignmentGeneration)
+      return false;
+    const rollback = document.meta.priorityRollbackMappings[options.routeKey];
+    if (rollback?.mappingKey !== options.rollbackMappingKey)
+      return false;
+    const attempt = document.meta.priorityAttempts[options.routeKey];
+    if (options.attemptOwnerToken !== undefined) {
+      if (attempt?.ownerToken !== options.attemptOwnerToken)
+        return false;
+    } else if (attempt)
+      return false;
+    delete document.meta.priorityRollbackMappings[options.routeKey];
+    if (options.attemptOwnerToken !== undefined) {
+      delete document.meta.priorityAttempts[options.routeKey];
+      advanceKeySlot(`priority-attempt:${options.routeKey}`, document.meta);
+    }
+    assignment.generationId = randomUUID2();
+    assignment.updatedAt = Date.now();
+    advanceKeySlot(priorityGenerationKey(options.routeKey), document.meta);
+    const protectedMappings = new Set([
+      ...Object.values(document.meta.priorityAssignments).map((candidate) => candidate.mappingKey),
+      ...Object.values(document.meta.priorityRollbackMappings).map((rollback2) => rollback2.mappingKey)
+    ]);
+    const maxSessions = getMaxStoredSessionsLimit();
+    const protectedExistingCount = [...protectedMappings].filter((candidate) => document.sessions[candidate] !== undefined).length;
+    const retainedLimit = Math.max(maxSessions, protectedExistingCount);
+    const removable = Object.keys(document.sessions).filter((candidate) => !protectedMappings.has(candidate)).sort((left, right) => document.sessions[left].lastUsedAt - document.sessions[right].lastUsedAt);
+    while (Object.keys(document.sessions).length > retainedLimit) {
+      const candidate = removable.shift();
+      if (!candidate)
+        break;
+      delete document.sessions[candidate];
+      advanceKeySlot(candidate, document.meta);
+    }
+    finalized = true;
+    return true;
+  });
+  return finalized;
+}
+function rollbackSharedSessionAndPriorityAssignment(options) {
+  let result = false;
+  mutateStore((document) => {
+    if (document.meta.version !== PRIORITY_STORE_META_VERSION)
+      return false;
+    const currentMapping = document.sessions[options.key];
+    if (keyGeneration(options.key, currentMapping, document.meta) !== options.expectedMappingGeneration)
+      return false;
+    const currentAssignment = document.meta.priorityAssignments[options.routeKey];
+    if (priorityAssignmentGeneration(options.routeKey, currentAssignment, document.meta) !== options.expectedAssignmentGeneration)
+      return false;
+    const attempt = document.meta.priorityAttempts[options.routeKey];
+    if (options.attemptOwnerToken !== undefined) {
+      if (attempt?.ownerToken !== options.attemptOwnerToken)
+        return false;
+    } else if (attempt)
+      return false;
+    const expectedRollback = options.previousAssignment && options.previousAssignment.mappingKey !== options.key ? {
+      mappingKey: options.previousAssignment.mappingKey,
+      mappingGeneration: options.previousAssignment.mappingGeneration
+    } : undefined;
+    const actualRollback = document.meta.priorityRollbackMappings[options.routeKey];
+    if (actualRollback?.mappingKey !== expectedRollback?.mappingKey || actualRollback?.mappingGeneration !== expectedRollback?.mappingGeneration)
+      return false;
+    let restoredMapping = null;
+    if (options.previousMapping) {
+      restoredMapping = {
+        ...structuredClone(options.previousMapping),
+        revision: (options.previousMapping.revision ?? 0) + 1,
+        generationId: randomUUID2()
+      };
+      document.sessions[options.key] = restoredMapping;
+    } else {
+      delete document.sessions[options.key];
+    }
+    advanceKeySlot(options.key, document.meta);
+    const mappingGeneration = keyGeneration(options.key, restoredMapping ?? undefined, document.meta);
+    let restoredAssignment = null;
+    if (options.previousAssignment) {
+      restoredAssignment = {
+        ...structuredClone(options.previousAssignment),
+        mappingGeneration: options.previousAssignment.mappingKey === options.key ? mappingGeneration : options.previousAssignment.mappingGeneration,
+        generationId: randomUUID2(),
+        updatedAt: Date.now()
+      };
+      document.meta.priorityAssignments[options.routeKey] = restoredAssignment;
+    } else {
+      delete document.meta.priorityAssignments[options.routeKey];
+    }
+    delete document.meta.priorityRollbackMappings[options.routeKey];
+    advanceKeySlot(priorityGenerationKey(options.routeKey), document.meta);
+    const assignmentGeneration = priorityAssignmentGeneration(options.routeKey, restoredAssignment ?? undefined, document.meta);
+    result = {
+      mappingGeneration,
+      assignmentGeneration,
+      restoredMapping,
+      restoredAssignment
+    };
+    return true;
+  });
+  return result;
+}
 function sameTranscriptLocator(left, right) {
   return left?.sessionId === right.sessionId && left.configDir === right.configDir && left.projectDir === right.projectDir && left.lifecycleGeneration === right.lifecycleGeneration;
 }
@@ -31945,6 +32571,8 @@ function attachSharedTranscriptLocator(key, expectedClaudeSessionId, locator, ex
   validateTranscriptLocator(locator, expectedClaudeSessionId);
   let attachedGeneration = false;
   mutateStore(({ sessions: store, meta: meta3 }) => {
+    if (isPriorityRollbackMapping(meta3, key))
+      return false;
     const existing = store[key];
     if (!existing || existing.claudeSessionId !== expectedClaudeSessionId)
       return false;
@@ -31955,8 +32583,20 @@ function attachSharedTranscriptLocator(key, expectedClaudeSessionId, locator, ex
       existing.revision = (existing.revision ?? 0) + 1;
       existing.generationId = randomUUID2();
       advanceKeySlot(key, meta3);
+      attachedGeneration = getStoredSessionGeneration(existing, key);
+      if (meta3.version === PRIORITY_STORE_META_VERSION) {
+        for (const [routeKey, assignment] of Object.entries(meta3.priorityAssignments)) {
+          if (assignment.mappingKey !== key)
+            continue;
+          assignment.mappingGeneration = attachedGeneration;
+          assignment.generationId = randomUUID2();
+          assignment.updatedAt = Date.now();
+          advanceKeySlot(priorityGenerationKey(routeKey), meta3);
+        }
+      }
+    } else {
+      attachedGeneration = getStoredSessionGeneration(existing, key);
     }
-    attachedGeneration = getStoredSessionGeneration(existing, key);
     return true;
   });
   return attachedGeneration;
@@ -31971,6 +32611,8 @@ function evictSharedSession(key, expectedGeneration) {
     }
     if (expectedGeneration !== undefined && getStoredSessionGeneration(existing, key) !== expectedGeneration)
       return false;
+    if (isPriorityRollbackMapping(meta3, key))
+      return false;
     delete store[key];
     advanceKeySlot(key, meta3);
     evicted = true;
@@ -32008,6 +32650,17 @@ function clearSharedSessions() {
       delete store[key];
       advanceKeySlot(key, meta3);
     }
+    if (meta3.version === PRIORITY_STORE_META_VERSION) {
+      for (const routeKey of Object.keys(meta3.priorityAssignments)) {
+        delete meta3.priorityAssignments[routeKey];
+        delete meta3.priorityRollbackMappings[routeKey];
+        advanceKeySlot(priorityGenerationKey(routeKey), meta3);
+      }
+      for (const routeKey of Object.keys(meta3.priorityAttempts)) {
+        delete meta3.priorityAttempts[routeKey];
+        advanceKeySlot(`priority-attempt:${routeKey}`, meta3);
+      }
+    }
     return true;
   });
 }
@@ -32110,6 +32763,56 @@ function stateFromSharedSession(shared) {
     previousTranscript: shared.previousTranscript
   };
 }
+function finalizePrioritySessionPublication(publication) {
+  const rollback = publication.rollback;
+  if (!rollback)
+    return true;
+  const finalized = finalizeSharedSessionAndPriorityAssignment({
+    key: rollback.key,
+    routeKey: publication.routeKey,
+    expectedMappingGeneration: rollback.publishedMappingGeneration,
+    expectedAssignmentGeneration: rollback.publishedAssignmentGeneration,
+    rollbackMappingKey: rollback.previousAssignment?.mappingKey === rollback.key ? undefined : rollback.previousAssignment?.mappingKey,
+    attemptOwnerToken: publication.attemptOwnerToken
+  });
+  if (!finalized)
+    return false;
+  publication.rollback = undefined;
+  return true;
+}
+function rollbackPrioritySessionPublication(sessionId, messages, workingDirectory, publication) {
+  const rollback = publication.rollback;
+  if (!rollback)
+    return false;
+  const restored = rollbackSharedSessionAndPriorityAssignment({
+    key: rollback.key,
+    routeKey: publication.routeKey,
+    expectedMappingGeneration: rollback.publishedMappingGeneration,
+    expectedAssignmentGeneration: rollback.publishedAssignmentGeneration,
+    previousMapping: rollback.previousMapping,
+    previousAssignment: rollback.previousAssignment,
+    attemptOwnerToken: publication.attemptOwnerToken
+  });
+  if (!restored)
+    return false;
+  publication.expectedAssignmentGeneration = restored.assignmentGeneration;
+  publication.rollback = undefined;
+  if (sessionId) {
+    if (restored.restoredMapping)
+      sessionCache.set(sessionId, stateFromSharedSession(restored.restoredMapping));
+    else
+      sessionCache.delete(sessionId);
+  } else {
+    const fingerprint = getConversationFingerprint(messages, workingDirectory);
+    if (fingerprint) {
+      if (restored.restoredMapping)
+        fingerprintCache.set(fingerprint, stateFromSharedSession(restored.restoredMapping));
+      else
+        fingerprintCache.delete(fingerprint);
+    }
+  }
+  return restored.mappingGeneration;
+}
 function classifyLineage(state, messages, cacheKey2) {
   const result = verifyLineage(state, messages);
   if (result.type === "continuation" && result.resumeContentFrom !== undefined) {
@@ -32187,7 +32890,7 @@ function getSessionByClaudeId(claudeSessionId) {
   }
   return stateFromSharedSession(shared.session);
 }
-function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sdkMessageUuids, contextUsage, passthroughToolCallAssistantUuid, passthroughToolCallIds, currentTranscript, sourceTranscript, expectedGeneration) {
+function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sdkMessageUuids, contextUsage, passthroughToolCallAssistantUuid, passthroughToolCallIds, currentTranscript, sourceTranscript, expectedGeneration, priorityPublication) {
   if (!claudeSessionId)
     return false;
   const lineageHash = computeLineageHash(messages);
@@ -32211,7 +32914,53 @@ function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sd
   const key = sessionId || fp;
   if (!key)
     return false;
-  const storedGeneration = storeSharedSession(key, claudeSessionId, state.messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughToolCallAssistantUuid ?? null, passthroughToolCallIds ?? null, currentTranscript, sourceTranscript, expectedGeneration);
+  let storedGeneration;
+  if (priorityPublication) {
+    if (expectedGeneration === undefined || expectedGeneration === null) {
+      throw new Error("priority publication requires an exact mapping generation");
+    }
+    const rollback = priorityPublication.rollback;
+    if (rollback && rollback.key !== key) {
+      throw new Error("priority publication changed mapping keys within one request");
+    }
+    const published = storeSharedSessionAndPriorityAssignment({
+      key,
+      claudeSessionId,
+      messageCount: state.messageCount,
+      lineageHash,
+      messageHashes,
+      sdkMessageUuids,
+      contextUsage,
+      messageBlockHashes,
+      passthroughToolCallAssistantUuid: passthroughToolCallAssistantUuid ?? null,
+      passthroughToolCallIds: passthroughToolCallIds ?? null,
+      currentTranscript,
+      sourceTranscript,
+      expectedMappingGeneration: expectedGeneration,
+      rollbackMappingKey: rollback?.previousAssignment?.mappingKey,
+      attemptOwnerToken: priorityPublication.attemptOwnerToken,
+      priority: {
+        routeKey: priorityPublication.routeKey,
+        profileId: priorityPublication.profileId,
+        lastHumanTurnDigest: priorityPublication.lastHumanTurnDigest,
+        lastHumanTurnIssuedAt: priorityPublication.lastHumanTurnIssuedAt,
+        expectedAssignmentGeneration: priorityPublication.expectedAssignmentGeneration
+      }
+    });
+    if (!published)
+      return false;
+    priorityPublication.rollback = {
+      key,
+      previousMapping: rollback?.previousMapping ?? published.previousMapping,
+      previousAssignment: rollback?.previousAssignment ?? published.previousAssignment,
+      publishedMappingGeneration: published.mappingGeneration,
+      publishedAssignmentGeneration: published.assignmentGeneration
+    };
+    priorityPublication.expectedAssignmentGeneration = published.assignmentGeneration;
+    storedGeneration = published.mappingGeneration;
+  } else {
+    storedGeneration = storeSharedSession(key, claudeSessionId, state.messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughToolCallAssistantUuid ?? null, passthroughToolCallIds ?? null, currentTranscript, sourceTranscript, expectedGeneration);
+  }
   if (!storedGeneration)
     return false;
   if (sessionId)
@@ -32281,6 +33030,15 @@ class SessionTurnCoordinator {
         committedScopes.add(scopeKey);
         state.versions.set(scopeKey, (state.versions.get(scopeKey) ?? 0) + 1);
       },
+      markRolledBack: (scopeKey) => {
+        if (released || !committedScopes.delete(scopeKey))
+          return;
+        const current = state.versions.get(scopeKey) ?? 0;
+        if (current <= 1)
+          state.versions.delete(scopeKey);
+        else
+          state.versions.set(scopeKey, current - 1);
+      },
       release: () => {
         if (released)
           return;
@@ -34853,7 +35611,18 @@ function createProxyServer(config2 = {}) {
     }
     if (failure) {
       await reader.cancel().catch(() => {});
-      return { failed: true, errorPayload: failure.payload, errorType: failure.type, response: res };
+      const replay = new ReadableStream({
+        start(ctrl) {
+          for (const chunk of consumed)
+            ctrl.enqueue(chunk);
+          ctrl.close();
+        }
+      });
+      const response2 = new Response(replay, { status: res.status, headers: res.headers });
+      const completion2 = responseCompletions.get(res);
+      if (completion2)
+        responseCompletions.set(response2, completion2);
+      return { failed: true, errorPayload: failure.payload, errorType: failure.type, response: response2 };
     }
     const rest = new ReadableStream({
       start(ctrl) {
@@ -34877,23 +35646,84 @@ function createProxyServer(config2 = {}) {
       responseCompletions.set(response, completion);
     return { failed: false, errorPayload: null, errorType: null, response };
   }
-  async function dispatchPriority(c, body, requestMeta, orderedCandidateIds, sessionKey, wantsStream, turnWatchdogSignal) {
+  async function dispatchPriority(options) {
+    let attemptOwnerToken;
+    if (options.durableRoute && options.publicationTurn) {
+      try {
+        const claim = claimPriorityAttempt({
+          routeKey: options.durableRoute.routeKey,
+          expectedAssignmentGeneration: options.durableRoute.expectedGeneration,
+          turn: options.claimTurn
+        });
+        if (!claim) {
+          return options.context.json({
+            type: "error",
+            error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
+          }, 503);
+        }
+        attemptOwnerToken = claim.ownerToken;
+      } catch (error51) {
+        claudeLog("priority.attempt_claim_failed", {
+          routeKey: options.durableRoute.routeKey,
+          error: error51 instanceof Error ? error51.message : String(error51)
+        });
+        return options.context.json({
+          type: "error",
+          error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
+        }, 503);
+      }
+    }
+    const settleAttempt = (disposition) => {
+      if (!attemptOwnerToken || !options.durableRoute)
+        return true;
+      try {
+        return disposition === "block" ? blockPriorityAttempt(options.durableRoute.routeKey, attemptOwnerToken) : releasePriorityAttempt(options.durableRoute.routeKey, attemptOwnerToken);
+      } catch (error51) {
+        claudeLog("priority.attempt_settle_failed", {
+          routeKey: options.durableRoute.routeKey,
+          disposition,
+          error: error51 instanceof Error ? error51.message : String(error51)
+        });
+        return false;
+      }
+    };
+    const unavailableAttemptResponse = () => options.context.json({
+      type: "error",
+      error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
+    }, 503);
     let lastError = null;
     let lastStatus = 429;
     let previous = null;
     let previousReason = "rate_limit_error";
-    for (const [attempt, candidate] of orderedCandidateIds.entries()) {
-      const inner = await handleMessages(c, forkAttemptMeta(requestMeta, attempt), {
-        body,
+    for (const [attempt, candidate] of options.candidateIds.entries()) {
+      const exposure = { committed: false };
+      const priorityPublication = options.durableRoute && options.publicationTurn ? {
+        routeKey: options.durableRoute.routeKey,
+        profileId: candidate,
+        lastHumanTurnDigest: options.publicationTurn.turnId,
+        lastHumanTurnIssuedAt: options.publicationTurn.issuedAt,
+        attemptOwnerToken,
+        expectedAssignmentGeneration: options.durableRoute.expectedGeneration
+      } : undefined;
+      const inner = await handleMessages(options.context, forkAttemptMeta(options.requestMeta, attempt), {
+        body: options.body,
         forcedProfileId: candidate,
-        turnWatchdogSignal
+        turnWatchdogSignal: options.turnWatchdogSignal,
+        forceFreshPriorityReplay: priorityPublication !== undefined && (options.durableRoute?.forceFreshReplay === true || options.currentProfileId !== undefined && candidate !== options.currentProfileId),
+        priorityPublication,
+        priorityAttemptExposure: exposure
       });
       const sniffed = await sniffAccountFailure(inner);
       if (!sniffed.failed) {
-        if (sessionKey)
-          priorityAssignments.set(sessionKey, candidate);
+        if (options.sessionKey && !options.durableRoute) {
+          const previousAssignment = priorityAssignments.get(options.sessionKey);
+          priorityAssignments.set(options.sessionKey, {
+            profileId: candidate,
+            requestId: options.publicationTurn?.turnId ?? previousAssignment?.requestId
+          });
+        }
         if (previous) {
-          claudeLog("profile.failover", { from: previous, to: candidate, reason: previousReason, sessionKey });
+          claudeLog("profile.failover", { from: previous, to: candidate, reason: previousReason, sessionKey: options.sessionKey });
           plog(`[PROXY] PRIORITY failover ${previous} -> ${candidate} (${previousReason})`);
         }
         return sniffed.response;
@@ -34910,8 +35740,16 @@ function createProxyServer(config2 = {}) {
       lastStatus = inner.status;
       previous = candidate;
       previousReason = reason;
+      if (exposure.committed) {
+        claudeLog("priority.failover_withheld", { profile: candidate, reason: exposure.reason ?? "attempt_exposed" });
+        if (!settleAttempt("block"))
+          return unavailableAttemptResponse();
+        return sniffed.response;
+      }
     }
-    if (wantsStream) {
+    if (!settleAttempt("release"))
+      return unavailableAttemptResponse();
+    if (options.wantsStream) {
       return new Response(`event: error
 data: ${JSON.stringify(lastError)}
 
@@ -34950,18 +35788,85 @@ data: ${JSON.stringify(lastError)}
         }
       };
       let resumedMappingMayBeAdvanced = false;
+      let priorityTerminalCommitted = false;
+      let recoveryPublishedTarget;
+      let priorityRollbackRetirement;
       const evictSession2 = (...args) => {
         try {
+          if (priorityTerminalCommitted && options.priorityPublication)
+            return true;
+          if (options.priorityPublication?.rollback) {
+            const rollbackScopeKey = options.priorityPublication.rollback.key;
+            const restoredGeneration = rollbackPrioritySessionPublication(args[0], args[2] ?? options.body.messages ?? [], args[1], options.priorityPublication);
+            if (!restoredGeneration) {
+              requestMeta.retainSessionTurnFence?.();
+              return false;
+            }
+            requestMeta.sessionTurnLease?.markRolledBack(rollbackScopeKey);
+            resumedMappingMayBeAdvanced = false;
+            const retirements = [];
+            if (managedForkTarget && managedForkPublished) {
+              managedForkPublished = false;
+              retirements.push(abandonManagedFork("priority_publication_rollback"));
+            }
+            if (recoveryPublishedTarget) {
+              const recoveryTarget = recoveryPublishedTarget;
+              recoveryPublishedTarget = undefined;
+              retirements.push(abandonFork(recoveryTarget, sessionGcOptions).catch((error51) => {
+                claudeLog("session.fork_abandon_failed", {
+                  reason: "priority_recovery_publication_rollback",
+                  error: error51 instanceof Error ? error51.message : String(error51)
+                });
+              }));
+            }
+            if (retirements.length > 0) {
+              const pending = Promise.all(retirements).then(() => {
+                return;
+              });
+              priorityRollbackRetirement = priorityRollbackRetirement ? Promise.all([priorityRollbackRetirement, pending]).then(() => {
+                return;
+              }) : pending;
+            }
+            return true;
+          }
+          if (options.priorityPublication) {
+            return false;
+          }
           const evicted = evictSession(...args);
           if (!evicted && resumedMappingMayBeAdvanced) {
             requestMeta.retainSessionTurnFence?.();
           }
-          if (evicted)
+          if (evicted) {
             resumedMappingMayBeAdvanced = false;
+            const retirements = [];
+            if (managedForkTarget && managedForkPublished) {
+              managedForkPublished = false;
+              retirements.push(abandonManagedFork("mapping_evicted_after_publication"));
+            }
+            if (recoveryPublishedTarget) {
+              const recoveryTarget = recoveryPublishedTarget;
+              recoveryPublishedTarget = undefined;
+              retirements.push(abandonFork(recoveryTarget, sessionGcOptions).catch((error51) => {
+                claudeLog("session.fork_abandon_failed", {
+                  reason: "recovery_mapping_evicted_after_publication",
+                  error: error51 instanceof Error ? error51.message : String(error51)
+                });
+              }));
+            }
+            if (retirements.length > 0) {
+              const pending = Promise.all(retirements).then(() => {
+                return;
+              });
+              priorityRollbackRetirement = priorityRollbackRetirement ? Promise.all([priorityRollbackRetirement, pending]).then(() => {
+                return;
+              }) : pending;
+            }
+          }
           return evicted;
         } catch (error51) {
-          if (resumedMappingMayBeAdvanced)
+          if (resumedMappingMayBeAdvanced || options.priorityPublication?.rollback) {
             requestMeta.retainSessionTurnFence?.();
+          }
           throw error51;
         }
       };
@@ -34970,6 +35875,7 @@ data: ${JSON.stringify(lastError)}
       let managedForkCommitted = false;
       let managedForkPublished = false;
       let managedForkAbandoned = false;
+      let managedForkAbandonment;
       let managedForkSuperseded = false;
       let managedFreshTarget = false;
       let unexpectedManagedForkTarget;
@@ -34978,30 +35884,36 @@ data: ${JSON.stringify(lastError)}
         releaseManagedForkPins?.();
         releaseManagedForkPins = undefined;
       };
-      const abandonManagedFork = async (reason) => {
-        if (unexpectedManagedForkTarget) {
-          const unexpected = unexpectedManagedForkTarget;
-          unexpectedManagedForkTarget = undefined;
-          await registerLiveTranscript(unexpected, sessionGcOptions).then((exact) => abandonFork(exact, sessionGcOptions)).catch((error51) => {
-            claudeLog("session.unexpected_fork_track_failed", {
-              reason,
-              sessionId: unexpected.sessionId,
-              error: error51 instanceof Error ? error51.message : String(error51)
+      const abandonManagedFork = (reason) => {
+        if (managedForkAbandonment)
+          return managedForkAbandonment;
+        const pending = (async () => {
+          if (unexpectedManagedForkTarget) {
+            const unexpected = unexpectedManagedForkTarget;
+            unexpectedManagedForkTarget = undefined;
+            await registerLiveTranscript(unexpected, sessionGcOptions).then((exact) => abandonFork(exact, sessionGcOptions)).catch((error51) => {
+              claudeLog("session.unexpected_fork_track_failed", {
+                reason,
+                sessionId: unexpected.sessionId,
+                error: error51 instanceof Error ? error51.message : String(error51)
+              });
             });
+          }
+          if (!managedForkTarget || managedForkPublished || managedForkAbandoned) {
+            if (managedForkPublished || !managedForkTarget)
+              releaseManagedPins();
+            return;
+          }
+          managedForkAbandoned = true;
+          await abandonFork(managedForkTarget, sessionGcOptions).catch((error51) => {
+            const message = error51 instanceof Error ? error51.message : String(error51);
+            claudeLog("session.fork_abandon_failed", { reason, error: message });
           });
-        }
-        if (!managedForkTarget || managedForkPublished || managedForkAbandoned) {
-          if (managedForkPublished || !managedForkTarget)
-            releaseManagedPins();
-          return;
-        }
-        managedForkAbandoned = true;
-        await abandonFork(managedForkTarget, sessionGcOptions).catch((error51) => {
-          const message = error51 instanceof Error ? error51.message : String(error51);
-          claudeLog("session.fork_abandon_failed", { reason, error: message });
-        });
-        releaseManagedPins();
-        sweepSessionGc();
+          releaseManagedPins();
+          sweepSessionGc();
+        })();
+        managedForkAbandonment = pending;
+        return pending;
       };
       const commitManagedFork = async () => {
         if (!managedForkTarget || managedForkSuperseded || managedForkCommitted)
@@ -35009,6 +35921,24 @@ data: ${JSON.stringify(lastError)}
         await commitFork(managedForkTarget, sessionGcOptions);
         managedForkCommitted = true;
       };
+      const assertPriorityPublicationReady = () => {
+        if (options.priorityPublication && !options.priorityPublication.rollback) {
+          throw new Error("Durable priority attempt reached terminal without atomic publication");
+        }
+      };
+      const finalizePriorityPublication = () => {
+        assertPriorityPublicationReady();
+        const publication = options.priorityPublication;
+        if (!publication)
+          return;
+        if (requestAbort.controller.signal.aborted || durableWritesRevoked) {
+          throw new Error("Durable priority attempt was revoked before terminal finalization");
+        }
+        if (!finalizePrioritySessionPublication(publication)) {
+          throw new Error("Durable priority attempt changed before terminal finalization");
+        }
+        priorityTerminalCommitted = true;
+      };
       try {
         let makePrompt = function() {
           if (structuredMessages) {
@@ -35021,6 +35951,29 @@ data: ${JSON.stringify(lastError)}
           return textPrompt;
         };
         const body = options.body;
+        const markPriorityAttemptExposure = (reason) => {
+          const exposure = options.priorityAttemptExposure;
+          if (!exposure || exposure.committed)
+            return;
+          exposure.committed = true;
+          exposure.reason = reason;
+        };
+        const observePriorityAttemptMessage = (message) => {
+          if (message?.type === "assistant" && Array.isArray(message.message?.content) && message.message.content.length > 0) {
+            markPriorityAttemptExposure("assistant_content");
+            return;
+          }
+          if (message?.type === "stream_event") {
+            const type = message.event?.type;
+            if (type === "message_start" || type === "content_block_start" || type === "content_block_delta") {
+              markPriorityAttemptExposure("stream_content");
+              return;
+            }
+          }
+          if (message?.type === "result" && message.structured_output !== undefined) {
+            markPriorityAttemptExposure("structured_output");
+          }
+        };
         if (!Array.isArray(body.messages)) {
           return c.json({ type: "error", error: { type: "invalid_request_error", message: "messages: Field required" } }, 400);
         }
@@ -35045,17 +35998,118 @@ data: ${JSON.stringify(lastError)}
             if (unknown2.length > 0)
               claudeLog("priority.unknown_order_ids", { unknown: unknown2 });
             const assignmentCwd = adapter.extractClientWorkingDirectory?.(body) ?? adapter.extractWorkingDirectory(body);
-            const sessionKey = getPriorityAssignmentKey(adapter.getSessionId(c, body), lineageMessages, assignmentCwd);
-            const assigned = sessionKey ? priorityAssignments.get(sessionKey) : undefined;
-            let first;
-            if (assigned && order.includes(assigned) && !priorityExhaustion.isExhausted(assigned)) {
-              first = assigned;
-            } else {
+            const adapterSessionId = adapter.getSessionId(c, body);
+            const sessionKey = getPriorityAssignmentKey(adapterSessionId, lineageMessages, assignmentCwd);
+            const preferred = order[0];
+            if (preferred !== undefined) {
+              const trustedTurn = requestMeta.routingTurnIdentity;
+              let promotionTurn = trustedTurn;
+              let publicationTurn;
+              const failbackPolicy = getPriorityFailbackPolicy(process.env.MERIDIAN_PRIORITY_FAILBACK ?? getSetting("priorityFailback"));
+              let durableRoute;
+              let assignment;
+              let routeMappingIsCurrent = false;
+              if (adapterSessionId) {
+                const routeKey = `${adapter.name}:${adapterSessionId}`;
+                const routeResult = lookupPriorityAssignmentResult(routeKey);
+                if (routeResult.status === "error") {
+                  return c.json({
+                    type: "error",
+                    error: { type: "overloaded_error", message: "Durable priority routing state is unavailable" }
+                  }, 503);
+                }
+                if (routeResult.status === "found") {
+                  durableRoute = { routeKey, expectedGeneration: routeResult.generation };
+                  assignment = {
+                    profileId: routeResult.assignment.profileId,
+                    requestId: routeResult.assignment.lastHumanTurnDigest
+                  };
+                  publicationTurn = {
+                    turnId: routeResult.assignment.lastHumanTurnDigest,
+                    issuedAt: routeResult.assignment.lastHumanTurnIssuedAt
+                  };
+                  if (trustedTurn) {
+                    const sameHumanTurn = trustedTurn.turnId === routeResult.assignment.lastHumanTurnDigest;
+                    const strictlyNewer = trustedTurn.issuedAt > routeResult.assignment.lastHumanTurnIssuedAt;
+                    if (sameHumanTurn) {
+                      publicationTurn = {
+                        turnId: trustedTurn.turnId,
+                        issuedAt: Math.max(trustedTurn.issuedAt, routeResult.assignment.lastHumanTurnIssuedAt)
+                      };
+                    } else if (strictlyNewer) {
+                      publicationTurn = trustedTurn;
+                    } else {
+                      promotionTurn = undefined;
+                      claudeLog("priority.attestation_replay_withheld", {
+                        routeKey,
+                        issuedAt: trustedTurn.issuedAt,
+                        highWater: routeResult.assignment.lastHumanTurnIssuedAt
+                      });
+                    }
+                  }
+                  const mapped = lookupSharedSessionResult(routeResult.assignment.mappingKey);
+                  if (mapped.status === "error") {
+                    return c.json({
+                      type: "error",
+                      error: { type: "overloaded_error", message: "Durable priority session state is unavailable" }
+                    }, 503);
+                  }
+                  routeMappingIsCurrent = mapped.status === "found" && mapped.generation === routeResult.assignment.mappingGeneration;
+                  if (!routeMappingIsCurrent) {
+                    if (!promotionTurn) {
+                      return c.json({
+                        type: "error",
+                        error: { type: "overloaded_error", message: "Durable priority session state is unavailable" }
+                      }, 503);
+                    }
+                    durableRoute = { ...durableRoute, forceFreshReplay: true };
+                  }
+                } else if (routeResult.attempt && !trustedTurn) {
+                  return c.json({
+                    type: "error",
+                    error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
+                  }, 503);
+                } else if (trustedTurn) {
+                  durableRoute = { routeKey, expectedGeneration: routeResult.generation };
+                  publicationTurn = trustedTurn;
+                } else if (sessionKey) {
+                  assignment = priorityAssignments.get(sessionKey);
+                }
+              } else if (sessionKey) {
+                assignment = priorityAssignments.get(sessionKey);
+              }
+              const shouldPromote = assignment !== undefined && durableRoute !== undefined && routeMappingIsCurrent && assignment.profileId !== preferred && order.includes(assignment.profileId) && !priorityExhaustion.isExhausted(assignment.profileId) && !priorityExhaustion.isExhausted(preferred) && shouldPromotePriorityAssignment({
+                policy: failbackPolicy,
+                assignment,
+                requestId: promotionTurn?.turnId,
+                requestKind: promotionTurn?.kind
+              });
+              const assignedProfile = assignment?.profileId;
+              const assignmentIsHealthy = assignedProfile !== undefined && order.includes(assignedProfile) && !priorityExhaustion.isExhausted(assignedProfile);
+              const retainOnlyProfile = durableRoute && !promotionTurn ? assignedProfile : undefined;
+              if (retainOnlyProfile !== undefined && !order.includes(retainOnlyProfile)) {
+                return c.json({
+                  type: "error",
+                  error: { type: "overloaded_error", message: "Durable priority routing state is unavailable" }
+                }, 503);
+              }
               const pick2 = choosePriorityProfile(order, (id) => priorityExhaustion.isExhausted(id));
-              first = pick2?.id ?? order[0];
+              const first = retainOnlyProfile ?? (shouldPromote ? preferred : assignmentIsHealthy ? assignedProfile : pick2?.id ?? preferred);
+              const candidates = retainOnlyProfile ? [retainOnlyProfile] : [first, ...order.filter((id) => id !== first && !priorityExhaustion.isExhausted(id))];
+              return dispatchPriority({
+                context: c,
+                body,
+                requestMeta,
+                candidateIds: candidates,
+                sessionKey,
+                wantsStream: body.stream === true,
+                currentProfileId: assignedProfile,
+                turnWatchdogSignal: options.turnWatchdogSignal,
+                publicationTurn,
+                claimTurn: trustedTurn,
+                durableRoute
+              });
             }
-            const candidates = [first, ...order.filter((id) => id !== first && !priorityExhaustion.isExhausted(id))];
-            return dispatchPriority(c, body, requestMeta, candidates, sessionKey, body.stream === true, options.turnWatchdogSignal);
           }
         }
         const profile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile, options.forcedProfileId || c.req.header("x-meridian-profile") || undefined, routingMode === "sticky" ? { routingMode, stickySessionKey: adapter.getSessionId(c, body) } : undefined);
@@ -35303,6 +36357,12 @@ data: ${JSON.stringify(lastError)}
             headers: { "Content-Type": "application/json" }
           });
         }
+        if (options.forceFreshPriorityReplay) {
+          if (!options.priorityPublication || !agentSessionId || !durableMappingKey) {
+            throw new Error("Fresh priority replay requires trusted keyed durable publication");
+          }
+          lineageResult = { type: "diverged", reason: "priority-failback" };
+        }
         if (pipeline.some((t) => t.onSession)) {
           const mismatch = lineageResult.type === "diverged" ? lineageResult.mismatch : undefined;
           runTransformHook(pipeline, "onSession", {
@@ -35464,6 +36524,7 @@ data: ${JSON.stringify(lastError)}
           managedForkCommitted = false;
           managedForkPublished = false;
           managedForkAbandoned = false;
+          managedForkAbandonment = undefined;
           managedForkSuperseded = false;
           managedFreshTarget = false;
           unexpectedManagedForkTarget = undefined;
@@ -35632,14 +36693,26 @@ data: ${JSON.stringify(lastError)}
         const trackFileChanges = !(process.env.MERIDIAN_NO_FILE_CHANGES ?? process.env.CLAUDE_PROXY_NO_FILE_CHANGES) && pipelineCtx.shouldTrackFileChanges;
         const fileChangeHook = trackFileChanges ? createFileChangeHook(fileChanges, mcpPrefix) : undefined;
         const discoveredTools = new Set;
+        const priorityExposureHook = options.priorityAttemptExposure ? {
+          matcher: "",
+          hooks: [async (input) => {
+            const toolName = input && typeof input === "object" ? Reflect.get(input, "tool_name") : undefined;
+            if (toolName !== "ToolSearch")
+              markPriorityAttemptExposure(toolName === "StructuredOutput" ? "structured_output_tool" : "tool_use");
+            return {};
+          }]
+        } : undefined;
         const sdkHooks = passthrough ? {
           PreToolUse: [{
             matcher: "",
             hooks: [async (input) => {
               if (input.tool_name === "ToolSearch")
                 return {};
-              if (input.tool_name === "StructuredOutput")
+              if (input.tool_name === "StructuredOutput") {
+                markPriorityAttemptExposure("structured_output_tool");
                 return {};
+              }
+              markPriorityAttemptExposure("tool_use");
               const toolName = stripMcpPrefix(input.tool_name);
               if (hasDeferredTools && coreSet && !coreSet.has(toolName.toLowerCase())) {
                 discoveredTools.add(toolName);
@@ -35700,6 +36773,12 @@ data: ${JSON.stringify(lastError)}
           }]
         } : {
           ...pipelineCtx.sdkHooks ?? {},
+          ...priorityExposureHook ? {
+            PreToolUse: [
+              priorityExposureHook,
+              ...pipelineCtx.sdkHooks?.PreToolUse ?? []
+            ]
+          } : {},
           ...fileChangeHook ? { PostToolUse: [fileChangeHook] } : {}
         };
         const stderrLines = [];
@@ -35735,6 +36814,11 @@ data: ${JSON.stringify(lastError)}
               mappingInvalidated = true;
             return evicted;
           };
+          const settleInterruptedNonStreamMapping = () => {
+            if (options.priorityPublication && !options.priorityPublication.rollback && managedForkTarget && !managedForkPublished)
+              return true;
+            return invalidateNonStreamMapping();
+          };
           try {
             if (!claudeExecutable) {
               claudeExecutable = await resolveClaudeExecutableAsync();
@@ -35824,7 +36908,7 @@ data: ${JSON.stringify(lastError)}
                 } catch (error51) {
                   const errMsg = error51 instanceof Error ? error51.message : String(error51);
                   releaseHeldDenies("non_stream_attempt_error");
-                  if (didYieldContent)
+                  if (didYieldContent || options.priorityAttemptExposure?.committed)
                     throw error51;
                   const refusal = classifyResumeRefusal(error51, resumeSessionId ? stderrLines.slice(attemptStderrStart).join(`
 `) : undefined);
@@ -36030,6 +37114,7 @@ data: ${JSON.stringify(lastError)}
               }
             }();
             for await (const message of response) {
+              observePriorityAttemptMessage(message);
               const observedSessionId = message.session_id;
               if (typeof observedSessionId === "string" && observedSessionId) {
                 const returnedSessionId = observedSessionId;
@@ -36168,7 +37253,7 @@ data: ${JSON.stringify(lastError)}
           } catch (error51) {
             const failedResumedTurn = isResume && !managedForkTarget && !sawCanonicalResult;
             if ((requestAbort.controller.signal.aborted || durableWritesRevoked || failedResumedTurn) && !isIndependentSession) {
-              if (!invalidateNonStreamMapping()) {
+              if (!settleInterruptedNonStreamMapping()) {
                 throw new Error("Shared session mapping changed before interrupted non-stream invalidation");
               }
               claudeLog("session.interrupted_mapping_evicted", {
@@ -36178,7 +37263,7 @@ data: ${JSON.stringify(lastError)}
             }
             releaseHeldDenies("non_stream_error");
             if (!isIndependentSession && passthrough && capturedToolUses.length > 0 && !sawCanonicalResult) {
-              if (!invalidateNonStreamMapping()) {
+              if (!settleInterruptedNonStreamMapping()) {
                 throw new Error("Shared session mapping changed before non-stream recovery invalidation");
               }
               claudeLog("passthrough.noncanonical_session_evicted", { mode: "non_stream", reason: "drain_error" });
@@ -36362,7 +37447,7 @@ Subprocess stderr: ${stderrOutput}`;
               try {
                 mappingStored = await publishPinnedTranscript(publicationTranscriptLocator(currentSessionId), () => {
                   assertDurableWritesAllowed();
-                  const stored = storeSession(profileSessionId, lineageMessages, currentSessionId, profileScopedCwd, reconcileReturnedSessionUuids(sdkUuidMap, allMessages.length, currentClientAssistantUuid, resumeSessionId, currentSessionId), lastUsage, earlyStopFired ? nextPassthroughToolCallAssistantUuid : null, earlyStopFired ? nextPassthroughToolCallIds : null, publicationTranscriptLocator(currentSessionId), managedForkTarget?.sessionId === currentSessionId ? managedForkSource : undefined, mappingExpectedGeneration);
+                  const stored = storeSession(profileSessionId, lineageMessages, currentSessionId, profileScopedCwd, reconcileReturnedSessionUuids(sdkUuidMap, allMessages.length, currentClientAssistantUuid, resumeSessionId, currentSessionId), lastUsage, earlyStopFired ? nextPassthroughToolCallAssistantUuid : null, earlyStopFired ? nextPassthroughToolCallIds : null, publicationTranscriptLocator(currentSessionId), managedForkTarget?.sessionId === currentSessionId ? managedForkSource : undefined, mappingExpectedGeneration, options.priorityPublication);
                   if (stored) {
                     mappingExpectedGeneration = stored;
                     if (managedForkTarget?.sessionId === currentSessionId)
@@ -36399,6 +37484,7 @@ Subprocess stderr: ${stderrOutput}`;
               }
             }
           }
+          finalizePriorityPublication();
           const responseSessionId = currentSessionId || resumeSessionId || `session_${Date.now()}`;
           return new Response(JSON.stringify({
             id: `msg_${Date.now()}`,
@@ -36603,7 +37689,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                       return;
                     } catch (error51) {
                       const errMsg = error51 instanceof Error ? error51.message : String(error51);
-                      if (didYieldClientEvent)
+                      if (didYieldClientEvent || options.priorityAttemptExposure?.committed)
                         throw error51;
                       const refusal = classifyResumeRefusal(error51, resumeSessionId ? stderrLines.slice(attemptStderrStart).join(`
 `) : undefined);
@@ -36843,6 +37929,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                 }));
                 try {
                   for await (const message of guardedResponse) {
+                    observePriorityAttemptMessage(message);
                     if (streamClosed && !awaitingEarlyStopDrain) {
                       exitedBeforeCanonicalTerminal = true;
                       break;
@@ -37194,7 +38281,7 @@ data: ${JSON.stringify({
                     await commitManagedFork();
                     const mappingStored = await publishPinnedTranscript(publicationTranscriptLocator(currentSessionId), () => {
                       assertDurableWritesAllowed();
-                      const stored = storeSession(profileSessionId, lineageMessages, currentSessionId, profileScopedCwd, reconcileReturnedSessionUuids(sdkUuidMap, allMessages.length, currentClientAssistantUuid, resumeSessionId, currentSessionId), lastUsage, earlyStopFired ? nextPassthroughToolCallAssistantUuid : null, earlyStopFired ? nextPassthroughToolCallIds : null, publicationTranscriptLocator(currentSessionId), managedForkTarget?.sessionId === currentSessionId ? managedForkSource : undefined, mappingExpectedGeneration);
+                      const stored = storeSession(profileSessionId, lineageMessages, currentSessionId, profileScopedCwd, reconcileReturnedSessionUuids(sdkUuidMap, allMessages.length, currentClientAssistantUuid, resumeSessionId, currentSessionId), lastUsage, earlyStopFired ? nextPassthroughToolCallAssistantUuid : null, earlyStopFired ? nextPassthroughToolCallIds : null, publicationTranscriptLocator(currentSessionId), managedForkTarget?.sessionId === currentSessionId ? managedForkSource : undefined, mappingExpectedGeneration, options.priorityPublication);
                       if (stored) {
                         mappingExpectedGeneration = stored;
                         if (managedForkTarget?.sessionId === currentSessionId)
@@ -37342,6 +38429,7 @@ data: ${JSON.stringify({
                         recoveryForkTarget
                       ])) {
                         const recoveryMessage = event;
+                        observePriorityAttemptMessage(recoveryMessage);
                         if (recoveryMessage.session_id) {
                           if (recoveryMessage.session_id !== recoveryForkTarget.sessionId) {
                             if (recoveryMessage.session_id !== recoveryForkSource?.sessionId) {
@@ -37403,10 +38491,11 @@ data: ${JSON.stringify({
                       await commitFork(recoveryForkTarget, sessionGcOptions);
                       const recoveryMappingStored = await publishPinnedTranscript(recoveryForkTarget, () => {
                         assertDurableWritesAllowed();
-                        const stored = storeSession(profileSessionId, lineageMessages, recoverySessionId, profileScopedCwd, recoverySdkUuidMap, lastUsage, recoveryToolCallAssistantUuid ?? null, recoveryToolCallAssistantUuid ? [...recoveryEarlyStop.expected] : null, recoveryForkTarget, recoveryForkSource, mappingExpectedGeneration);
+                        const stored = storeSession(profileSessionId, lineageMessages, recoverySessionId, profileScopedCwd, recoverySdkUuidMap, lastUsage, recoveryToolCallAssistantUuid ?? null, recoveryToolCallAssistantUuid ? [...recoveryEarlyStop.expected] : null, recoveryForkTarget, recoveryForkSource, mappingExpectedGeneration, options.priorityPublication);
                         if (stored) {
                           mappingExpectedGeneration = stored;
                           recoveryForkPublished = true;
+                          recoveryPublishedTarget = recoveryForkTarget;
                         }
                         return stored;
                       }, sessionGcOptions);
@@ -37491,6 +38580,8 @@ data: ${JSON.stringify(lifted.frame)}
                       });
                       sweepSessionGc();
                     }
+                    if (priorityRollbackRetirement)
+                      await priorityRollbackRetirement;
                     releaseRecoveryForkPins?.();
                   }
                 }
@@ -37563,6 +38654,8 @@ data: ${JSON.stringify({
                       claudeLog("response.file_changes", { mode: "stream", count: fileChanges.length });
                     }
                   }
+                  assertPriorityPublicationReady();
+                  finalizePriorityPublication();
                   if (messageStartEmitted) {
                     sendTerminalDelta(streamedToolUseIds.size > 0 ? "tool_use" : undefined);
                     safeEnqueue(encoder.encode(`event: message_stop
@@ -37763,7 +38856,7 @@ data: ${JSON.stringify({
                     await commitManagedFork();
                     const mappingStored = await publishPinnedTranscript(publicationTranscriptLocator(currentSessionId), () => {
                       assertDurableWritesAllowed();
-                      const stored = storeSession(profileSessionId, lineageMessages, currentSessionId, profileScopedCwd, reconcileReturnedSessionUuids(sdkUuidMap, allMessages.length, currentClientAssistantUuid, resumeSessionId, currentSessionId), lastUsage, nextPassthroughToolCallAssistantUuid, nextPassthroughToolCallIds, publicationTranscriptLocator(currentSessionId), managedForkTarget?.sessionId === currentSessionId ? managedForkSource : undefined, mappingExpectedGeneration);
+                      const stored = storeSession(profileSessionId, lineageMessages, currentSessionId, profileScopedCwd, reconcileReturnedSessionUuids(sdkUuidMap, allMessages.length, currentClientAssistantUuid, resumeSessionId, currentSessionId), lastUsage, nextPassthroughToolCallAssistantUuid, nextPassthroughToolCallIds, publicationTranscriptLocator(currentSessionId), managedForkTarget?.sessionId === currentSessionId ? managedForkSource : undefined, mappingExpectedGeneration, options.priorityPublication);
                       if (stored) {
                         mappingExpectedGeneration = stored;
                         if (managedForkTarget?.sessionId === currentSessionId)
@@ -37796,6 +38889,8 @@ data: ${JSON.stringify({
                       });
                     }
                   }
+                  assertPriorityPublicationReady();
+                  finalizePriorityPublication();
                   safeEnqueue(encoder.encode(`event: message_delta
 data: ${JSON.stringify({
                     type: "message_delta",
@@ -37939,6 +39034,8 @@ data: ${JSON.stringify({
                 }
               } finally {
                 await abandonManagedFork("stream_complete_without_commit");
+                if (priorityRollbackRetirement)
+                  await priorityRollbackRetirement;
                 requestAbort.detach();
               }
             })().finally(() => {
@@ -38067,6 +39164,7 @@ data: ${JSON.stringify({
     };
     let body;
     let sharedSessionRevisionsAtArrival;
+    let routingTurnIdentity;
     try {
       try {
         body = await c.req.json();
@@ -38086,6 +39184,7 @@ data: ${JSON.stringify({
       }
       if (Array.isArray(body?.messages)) {
         const adapter = detectAdapter(c);
+        routingTurnIdentity = adapter.getRoutingTurnIdentity?.(c, body);
         const agentSessionId = adapter.getSessionId(c, body);
         if (agentSessionId) {
           const arrivalProfileIds = new Set(getEffectiveProfiles(finalConfig.profiles).map((profile) => profile.id));
@@ -38164,6 +39263,7 @@ data: ${JSON.stringify({
         sdkActiveDurationMs: 0,
         sessionTurnLease,
         sharedSessionRevisionsAtArrival,
+        routingTurnIdentity,
         retainSessionTurnFence: () => {
           retainSessionTurnFence = true;
         }