fix(prompt-gate): scope reservation releases

src/hooks/compaction-context-injector/recovery.ts

@@ -117,7 +117,9 @@ export function createRecoveryLogic(
           hasTools: !!tools,
           recoveredPromptConfig,
         })
-        releasePromptAsyncReservation(sessionID, "compaction-context-injector:incomplete-recovery")
+        releasePromptAsyncReservation(sessionID, "compaction-context-injector:incomplete-recovery", {
+          reservedBy: "compaction-context-injector",
+        })
         return false
       }
 

src/hooks/ralph-loop/ralph-loop-event-handler.ts

@@ -197,7 +197,9 @@ export function createRalphLoopEventHandler(
 		const props = event.properties as Record<string, unknown> | undefined
 		const runtimeRetryActivitySessionID = getRuntimeRetryActivitySessionID(event.type, props)
 		if (runtimeRetryActivitySessionID) {
-			releasePromptAsyncReservation(runtimeRetryActivitySessionID, "ralph-loop:activity")
+			releasePromptAsyncReservation(runtimeRetryActivitySessionID, "ralph-loop:activity", {
+				reservedBy: HOOK_NAME,
+			})
 			runtimeErrorRetriedSessions.delete(runtimeRetryActivitySessionID)
 			recentHandledSyntheticIdleAt.delete(runtimeRetryActivitySessionID)
 		}

src/hooks/ralph-loop/ralph-loop-hook.ts

@@ -2,6 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin"
 import type { RalphLoopOptions, RalphLoopState } from "./types"
 import { getTranscriptPath as getDefaultTranscriptPath } from "../claude-code-hooks/transcript"
 import { releasePromptAsyncReservation } from "../shared/prompt-async-gate"
+import { HOOK_NAME } from "./constants"
 import { createLoopStateController } from "./loop-state-controller"
 import { createRalphLoopEventHandler } from "./ralph-loop-event-handler"
 
@@ -71,7 +72,9 @@ export function createRalphLoopHook(
 		startLoop: (sessionID, prompt, loopOptions): boolean => {
 			const startSuccess = loopState.startLoop(sessionID, prompt, loopOptions)
 			if (startSuccess) {
-				releasePromptAsyncReservation(sessionID, "ralph-loop:start-loop")
+				releasePromptAsyncReservation(sessionID, "ralph-loop:start-loop", {
+					reservedBy: HOOK_NAME,
+				})
 			}
 			if (!startSuccess || typeof loopOptions?.messageCountAtStart === "number") {
 				return startSuccess

src/hooks/ralph-loop/verification-failure-handler.ts

@@ -90,7 +90,9 @@ export async function handleFailedVerification(
 	}
 
 	try {
-		releasePromptAsyncReservation(parentSessionID, "ralph-loop:verification-failed")
+		releasePromptAsyncReservation(parentSessionID, "ralph-loop:verification-failed", {
+			reservedBy: HOOK_NAME,
+		})
 		const promptResult = await injectContinuationPrompt(ctx, {
 			sessionID: parentSessionID,
 			prompt: buildVerificationFailurePrompt(previewState),

src/hooks/runtime-fallback/auto-retry.ts

@@ -47,7 +47,10 @@ export function createAutoRetryHelpers(deps: HookDeps) {
     }
     try {
       await ctx.client.session.abort({ path: { id: sessionID } })
-      releasePromptAsyncReservation(sessionID, `runtime-fallback-abort:${source}`)
+      releasePromptAsyncReservation(sessionID, `runtime-fallback-abort:${source}`, {
+        reservedBy: `runtime-fallback:${source}`,
+        reservedByPrefix: "runtime-fallback:",
+      })
       log(`[${HOOK_NAME}] Aborted in-flight session request (${source})`, { sessionID })
     } catch (error) {
       log(`[${HOOK_NAME}] Failed to abort in-flight session request (${source})`, {

src/hooks/shared/prompt-async-gate.test.ts

@@ -3,6 +3,7 @@ import { afterEach, describe, expect, test } from "bun:test"
 import {
   promptAfterSessionIdle,
   promptAsyncAfterSessionIdle,
+  releasePromptAsyncReservation,
   releaseAllPromptAsyncReservationsForTesting,
 } from "./prompt-async-gate"
 
@@ -154,6 +155,94 @@ describe("promptAsyncAfterSessionIdle", () => {
     expect(promptCalls).toBe(2)
   })
 
+  test("#given a peer-message promptAsync hold #when an unrelated route releases the session #then the peer-message hold remains reserved", async () => {
+    // given
+    let promptCalls = 0
+    const client = {
+      session: {
+        promptAsync: async () => {
+          promptCalls += 1
+        },
+      },
+    }
+
+    // when
+    const first = await promptAsyncAfterSessionIdle({
+      client,
+      sessionID: "ses_release_scope",
+      input: {
+        path: { id: "ses_release_scope" },
+        body: {
+          parts: [{ type: "text", text: '<peer_message from="teammate">hello</peer_message>' }],
+        },
+      },
+      source: "team-live-delivery",
+      settleMs: 0,
+    })
+    releasePromptAsyncReservation("ses_release_scope", "ralph-loop:activity")
+    const second = await promptAsyncAfterSessionIdle({
+      client,
+      sessionID: "ses_release_scope",
+      input: {
+        path: { id: "ses_release_scope" },
+        body: { parts: [{ type: "text", text: "continue" }] },
+      },
+      source: "todo-continuation-enforcer",
+      settleMs: 0,
+      postDispatchHoldMs: 0,
+    })
+
+    // then
+    expect(first.status).toBe("dispatched")
+    expect(second).toEqual({ status: "reserved", reservedBy: "team-live-delivery" })
+    expect(promptCalls).toBe(1)
+  })
+
+  test("#given a route family promptAsync hold #when the same family aborts another source #then the reservation is released", async () => {
+    // given
+    let promptCalls = 0
+    const client = {
+      session: {
+        promptAsync: async () => {
+          promptCalls += 1
+        },
+      },
+    }
+
+    // when
+    const first = await promptAsyncAfterSessionIdle({
+      client,
+      sessionID: "ses_release_family_scope",
+      input: {
+        path: { id: "ses_release_family_scope" },
+        body: { parts: [{ type: "text", text: "continue" }] },
+      },
+      source: "model-fallback:message.updated",
+      settleMs: 0,
+    })
+    const released = releasePromptAsyncReservation(
+      "ses_release_family_scope",
+      "model-fallback-abort:session.error",
+      { reservedByPrefix: "model-fallback:" },
+    )
+    const second = await promptAsyncAfterSessionIdle({
+      client,
+      sessionID: "ses_release_family_scope",
+      input: {
+        path: { id: "ses_release_family_scope" },
+        body: { parts: [{ type: "text", text: "continue again" }] },
+      },
+      source: "model-fallback:session.error",
+      settleMs: 0,
+    })
+
+    // then
+    expect(first.status).toBe("dispatched")
+    expect(released).toBe(true)
+    expect(second.status).toBe("dispatched")
+    expect(promptCalls).toBe(2)
+  })
+
   test("#given two internal prompt calls race for one idle session #when they dispatch concurrently #then only one prompt is accepted", async () => {
     // given
     let promptCalls = 0