From 2168040ac68fe812fb784c90dd41f1a5c95ae3dd Mon Sep 17 00:00:00 2001
From: YeonGyu-Kim <code.yeon.gyu@gmail.com>
Date: Mon, 11 May 2026 08:45:34 +0900
Subject: [PATCH] fix(plugin): scope synthetic-idle dedup bypass to matching
 marker

Only clear recentAnyIdles when the stored marker matches the synthetic idle timestamp for the same session, preventing accidental clobbering of newer idle markers. Add a regression test to verify other sessions keep their dedup state during this bypass path.

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
---
 src/plugin/event.test.ts | 66 ++++++++++++++++++++++++++++++++++++++++
 src/plugin/event.ts      |  5 ++-
 2 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/src/plugin/event.test.ts b/src/plugin/event.test.ts
index 8b10a5950..a400118e6 100644
--- a/src/plugin/event.test.ts
+++ b/src/plugin/event.test.ts
@@ -366,6 +366,72 @@ describe("createEventHandler - idle deduplication", () => {
 		expect((dispatchCalls[1]?.event.properties as { sessionID?: string } | undefined)?.sessionID).toBe(sessionId)
 	})
 
+	it("keeps other session dedup state untouched when bypassing synthetic-idle for current session", async () => {
+		//#given
+		const originalDateNow = Date.now
+		let currentNow = 30_000
+		Date.now = () => currentNow
+		const dispatchedSessionIds: string[] = []
+		const eventHandler = createIdleDedupSpyEventHandler({
+			onEvent: () => {},
+			sessionNotification: async (input: EventInput) => {
+				if (input.event.type !== "session.idle") {
+					return
+				}
+				const props = input.event.properties as { sessionID?: string } | undefined
+				if (props?.sessionID) {
+					dispatchedSessionIds.push(props.sessionID)
+				}
+			},
+		})
+
+		try {
+			//#when
+			await eventHandler(asEventHandlerInput({
+				event: {
+					type: "session.status",
+					properties: {
+						sessionID: "ses_a",
+						status: { type: "idle" },
+					},
+				},
+			}))
+			await eventHandler(asEventHandlerInput({
+				event: {
+					type: "session.idle",
+					properties: {
+						sessionID: "ses_b",
+					},
+				},
+			}))
+
+			currentNow += 100
+			await eventHandler(asEventHandlerInput({
+				event: {
+					type: "session.idle",
+					properties: {
+						sessionID: "ses_a",
+					},
+				},
+			}))
+
+			currentNow += 100
+			await eventHandler(asEventHandlerInput({
+				event: {
+					type: "session.idle",
+					properties: {
+						sessionID: "ses_b",
+					},
+				},
+			}))
+
+			//#then
+			expect(dispatchedSessionIds).toEqual(["ses_a", "ses_b", "ses_a"])
+		} finally {
+			Date.now = originalDateNow
+		}
+	})
+
 	it("dedups back-to-back real session.idle events for the same sessionID within 500ms", async () => {
 		//#given
 		const originalDateNow = Date.now
diff --git a/src/plugin/event.ts b/src/plugin/event.ts
index e8bb49a7d..2b94fcadf 100644
--- a/src/plugin/event.ts
+++ b/src/plugin/event.ts
@@ -417,7 +417,10 @@ export function createEventHandler(args: {
           recentSyntheticIdles.delete(sessionID);
           // Let real idle events through even when a synthetic idle fired moments earlier.
           // OpenCode diagnostics expect a concrete session.idle event signal.
-          recentAnyIdles.delete(sessionID);
+          const lastAnyIdleAt = recentAnyIdles.get(sessionID);
+          if (lastAnyIdleAt === emittedAt) {
+            recentAnyIdles.delete(sessionID);
+          }
         }
         recentRealIdles.set(sessionID, now);
         if (!shouldDispatchIdleEvent(sessionID, now)) {