commandmate 0.44.1 → 0.44.3

package/dist/server/src/lib/session/agent-event-state.js

@@ -39,604 +39,75 @@
  * @module lib/session/agent-event-state
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIFECYCLE_AGENT_EVENT_TYPES = exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.STRUCTURED_STATE_MAX_AGE_MS = exports.AGENT_EVENT_DEDUP_WINDOW_MS = exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = void 0;
-exports.isSameAgentModelName = isSameAgentModelName;
-exports.onAgentModelChange = onAgentModelChange;
-exports.getAgentModelBaseline = getAgentModelBaseline;
-exports.getAgentEventDropCounts = getAgentEventDropCounts;
-exports.getPendingDecisions = getPendingDecisions;
-exports.getAgentTurn = getAgentTurn;
-exports.getPublishedAgentTurn = getPublishedAgentTurn;
-exports.closeAgentTurn = closeAgentTurn;
-exports.observeScraperCompletionEvidence = observeScraperCompletionEvidence;
+exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = exports.recordAskUserQuestion = exports.getAskUserQuestion = exports.clearAskUserQuestion = exports.isAwaitingInstruction = exports.getAwaitingInstruction = exports.STRUCTURED_STATE_MAX_AGE_MS = exports.getStructuredSessionState = exports.observeScraperCompletionEvidence = exports.joinOpenTurnFromDuplicate = exports.getPublishedAgentTurn = exports.getPendingDecisions = exports.getAgentTurn = exports.closeAgentTurn = exports.recordCapturedModelInfo = exports.recordAgentReportedModel = exports.recordAgentReportedEffort = exports.onAgentModelChange = exports.isSameAgentModelName = exports.getResolvedAgentModelInfo = exports.getLastReportedAgentEffort = exports.getLastKnownAgentModel = exports.getLastKnownAgentEffort = exports.getLastCapturedModelInfo = exports.getAgentModelBaseline = exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = exports.shortSessionTag = exports.LIFECYCLE_AGENT_EVENT_TYPES = exports.isDuplicateAgentEvent = exports.getRecentEventKeyCount = exports.getRecentEventIdentityCount = exports.getAgentEventDropCounts = exports.classifyAgentEventDelivery = exports.agentEventKeyClaimedAt = exports.AGENT_EVENT_DEDUP_WINDOW_MS = void 0;
 exports.recordAgentStopEvent = recordAgentStopEvent;
 exports.getLastStopEventAt = getLastStopEventAt;
 exports.recordAgentEvent = recordAgentEvent;
-exports.getAwaitingInstruction = getAwaitingInstruction;
-exports.isAwaitingInstruction = isAwaitingInstruction;
 exports.getLastAgentEvent = getLastAgentEvent;
-exports.getLastKnownAgentModel = getLastKnownAgentModel;
-exports.recordAgentReportedModel = recordAgentReportedModel;
-exports.recordCapturedModelInfo = recordCapturedModelInfo;
-exports.getLastCapturedModelInfo = getLastCapturedModelInfo;
-exports.getResolvedAgentModelInfo = getResolvedAgentModelInfo;
-exports.recordAgentReportedEffort = recordAgentReportedEffort;
-exports.getLastReportedAgentEffort = getLastReportedAgentEffort;
-exports.getLastKnownAgentEffort = getLastKnownAgentEffort;
 exports.beginAgentEventGeneration = beginAgentEventGeneration;
 exports.getAgentEventGenerationStartedAt = getAgentEventGenerationStartedAt;
 exports.discardAgentEventState = discardAgentEventState;
-exports.getStructuredSessionState = getStructuredSessionState;
 exports.reportPermissionRequestPending = reportPermissionRequestPending;
 exports.reportQuestionPending = reportQuestionPending;
 exports.getStructuredPromptWaiting = getStructuredPromptWaiting;
 exports.corroborateStructuredPromptWaiting = corroborateStructuredPromptWaiting;
 exports.markStructuredPromptRecorded = markStructuredPromptRecorded;
 exports.clearStructuredPromptWaiting = clearStructuredPromptWaiting;
-exports.recordAskUserQuestion = recordAskUserQuestion;
-exports.getAskUserQuestion = getAskUserQuestion;
-exports.clearAskUserQuestion = clearAskUserQuestion;
-exports.isDuplicateAgentEvent = isDuplicateAgentEvent;
-exports.getRecentEventKeyCount = getRecentEventKeyCount;
-exports.classifyAgentEventDelivery = classifyAgentEventDelivery;
-exports.getRecentEventIdentityCount = getRecentEventIdentityCount;
 exports.clearAgentStopEvents = clearAgentStopEvents;
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
-const agent_event_types_1 = require("../../lib/hooks/agent-event-types");
-// Issue #2100: the shared list of tool names that mean "a human is being asked
-// to CHOOSE". Pure — its own only import is `permission-request-payload`, which
-// this module already reached for `ASK_USER_QUESTION_TOOL` — and importing it
-// here rather than repeating `'question'` is what keeps the release rule below
-// and `pendingDecisionKind`'s reader from drifting apart.
-const pending_decision_kind_1 = require("../../lib/hooks/pending-decision-kind");
-// Issue #1784: the terminal-frame half of "which model / effort is this on".
-const model_info_extractor_1 = require("../../lib/detection/model-info-extractor");
-const status_mapping_1 = require("../../lib/session/status-mapping");
-// Issue #1930: the turn model. Pure, so importing it here costs nothing at
-// runtime beyond the two bounds it owns.
+const auto_yes_enter_fallback_state_1 = require("../../lib/polling/auto-yes-enter-fallback-state");
+const agent_event_dedup_1 = require("../../lib/session/agent-event-dedup");
+const agent_event_model_1 = require("../../lib/session/agent-event-model");
 const provisional_turn_1 = require("../../lib/session/provisional-turn");
+const agent_event_turn_1 = require("../../lib/session/agent-event-turn");
+const agent_event_structured_state_1 = require("../../lib/session/agent-event-structured-state");
+const agent_event_awaiting_instruction_1 = require("../../lib/session/agent-event-awaiting-instruction");
+const agent_event_ask_user_question_1 = require("../../lib/session/agent-event-ask-user-question");
+const global_state_1 = require("../global-state");
+var agent_event_dedup_2 = require("../../lib/session/agent-event-dedup");
+Object.defineProperty(exports, "AGENT_EVENT_DEDUP_WINDOW_MS", { enumerable: true, get: function () { return agent_event_dedup_2.AGENT_EVENT_DEDUP_WINDOW_MS; } });
+Object.defineProperty(exports, "agentEventKeyClaimedAt", { enumerable: true, get: function () { return agent_event_dedup_2.agentEventKeyClaimedAt; } });
+Object.defineProperty(exports, "classifyAgentEventDelivery", { enumerable: true, get: function () { return agent_event_dedup_2.classifyAgentEventDelivery; } });
+Object.defineProperty(exports, "getAgentEventDropCounts", { enumerable: true, get: function () { return agent_event_dedup_2.getAgentEventDropCounts; } });
+Object.defineProperty(exports, "getRecentEventIdentityCount", { enumerable: true, get: function () { return agent_event_dedup_2.getRecentEventIdentityCount; } });
+Object.defineProperty(exports, "getRecentEventKeyCount", { enumerable: true, get: function () { return agent_event_dedup_2.getRecentEventKeyCount; } });
+Object.defineProperty(exports, "isDuplicateAgentEvent", { enumerable: true, get: function () { return agent_event_dedup_2.isDuplicateAgentEvent; } });
+Object.defineProperty(exports, "LIFECYCLE_AGENT_EVENT_TYPES", { enumerable: true, get: function () { return agent_event_dedup_2.LIFECYCLE_AGENT_EVENT_TYPES; } });
+Object.defineProperty(exports, "shortSessionTag", { enumerable: true, get: function () { return agent_event_dedup_2.shortSessionTag; } });
+var agent_event_model_2 = require("../../lib/session/agent-event-model");
+Object.defineProperty(exports, "AGENT_MODEL_EFFORT_SUFFIX_PATTERN", { enumerable: true, get: function () { return agent_event_model_2.AGENT_MODEL_EFFORT_SUFFIX_PATTERN; } });
+Object.defineProperty(exports, "getAgentModelBaseline", { enumerable: true, get: function () { return agent_event_model_2.getAgentModelBaseline; } });
+Object.defineProperty(exports, "getLastCapturedModelInfo", { enumerable: true, get: function () { return agent_event_model_2.getLastCapturedModelInfo; } });
+Object.defineProperty(exports, "getLastKnownAgentEffort", { enumerable: true, get: function () { return agent_event_model_2.getLastKnownAgentEffort; } });
+Object.defineProperty(exports, "getLastKnownAgentModel", { enumerable: true, get: function () { return agent_event_model_2.getLastKnownAgentModel; } });
+Object.defineProperty(exports, "getLastReportedAgentEffort", { enumerable: true, get: function () { return agent_event_model_2.getLastReportedAgentEffort; } });
+Object.defineProperty(exports, "getResolvedAgentModelInfo", { enumerable: true, get: function () { return agent_event_model_2.getResolvedAgentModelInfo; } });
+Object.defineProperty(exports, "isSameAgentModelName", { enumerable: true, get: function () { return agent_event_model_2.isSameAgentModelName; } });
+Object.defineProperty(exports, "onAgentModelChange", { enumerable: true, get: function () { return agent_event_model_2.onAgentModelChange; } });
+Object.defineProperty(exports, "recordAgentReportedEffort", { enumerable: true, get: function () { return agent_event_model_2.recordAgentReportedEffort; } });
+Object.defineProperty(exports, "recordAgentReportedModel", { enumerable: true, get: function () { return agent_event_model_2.recordAgentReportedModel; } });
+Object.defineProperty(exports, "recordCapturedModelInfo", { enumerable: true, get: function () { return agent_event_model_2.recordCapturedModelInfo; } });
+var agent_event_turn_2 = require("../../lib/session/agent-event-turn");
+Object.defineProperty(exports, "closeAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.closeAgentTurn; } });
+Object.defineProperty(exports, "getAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.getAgentTurn; } });
+Object.defineProperty(exports, "getPendingDecisions", { enumerable: true, get: function () { return agent_event_turn_2.getPendingDecisions; } });
+Object.defineProperty(exports, "getPublishedAgentTurn", { enumerable: true, get: function () { return agent_event_turn_2.getPublishedAgentTurn; } });
+Object.defineProperty(exports, "joinOpenTurnFromDuplicate", { enumerable: true, get: function () { return agent_event_turn_2.joinOpenTurnFromDuplicate; } });
+Object.defineProperty(exports, "observeScraperCompletionEvidence", { enumerable: true, get: function () { return agent_event_turn_2.observeScraperCompletionEvidence; } });
+var agent_event_structured_state_2 = require("../../lib/session/agent-event-structured-state");
+Object.defineProperty(exports, "getStructuredSessionState", { enumerable: true, get: function () { return agent_event_structured_state_2.getStructuredSessionState; } });
+Object.defineProperty(exports, "STRUCTURED_STATE_MAX_AGE_MS", { enumerable: true, get: function () { return agent_event_structured_state_2.STRUCTURED_STATE_MAX_AGE_MS; } });
+var agent_event_awaiting_instruction_2 = require("../../lib/session/agent-event-awaiting-instruction");
+Object.defineProperty(exports, "getAwaitingInstruction", { enumerable: true, get: function () { return agent_event_awaiting_instruction_2.getAwaitingInstruction; } });
+Object.defineProperty(exports, "isAwaitingInstruction", { enumerable: true, get: function () { return agent_event_awaiting_instruction_2.isAwaitingInstruction; } });
+var agent_event_ask_user_question_2 = require("../../lib/session/agent-event-ask-user-question");
+Object.defineProperty(exports, "clearAskUserQuestion", { enumerable: true, get: function () { return agent_event_ask_user_question_2.clearAskUserQuestion; } });
+Object.defineProperty(exports, "getAskUserQuestion", { enumerable: true, get: function () { return agent_event_ask_user_question_2.getAskUserQuestion; } });
+Object.defineProperty(exports, "recordAskUserQuestion", { enumerable: true, get: function () { return agent_event_ask_user_question_2.recordAskUserQuestion; } });
 /** compositeKey -> epoch ms of the most recent stop event. */
-const lastStopEventAt = globalThis.__agentEventLastStopAt ??
-    (globalThis.__agentEventLastStopAt = new Map());
+const lastStopEventAt = (0, global_state_1.getOrInitGlobal)('__agentEventLastStopAt', () => new Map());
 /** compositeKey -> the most recent event of any kind. */
-const lastAgentEvent = globalThis.__agentEventLast ??
-    (globalThis.__agentEventLast = new Map());
-/** compositeKey -> epoch ms the current generation began. See {@link beginAgentEventGeneration}. */
-const generationStartedAt = globalThis.__agentEventGenerationStartedAt ??
-    (globalThis.__agentEventGenerationStartedAt = new Map());
-/**
- * compositeKey -> the turn this instance is in, or the last one it was in
- * (Issue #1930).
- *
- * The map that replaced "the newest event is the verdict". `lastAgentEvent`
- * above is still written on every delivery and is still what
- * `structuredEvents.lastEventType` publishes — it answers "did anything reach
- * this server, and for the right instance?", which is a diagnostic question.
- * This map answers the state question, and the two deliberately disagree
- * whenever an event carries no verdict.
- *
- * The open dialogs #1725 kept in a map of their own live on the turn now
- * ({@link TurnRecord.pendingDecisions}), because a dialog only ever happens
- * *inside* a turn and holding them apart is what let a generation bump retire
- * one and not the other.
- */
-const agentTurns = globalThis.__agentEventTurns ??
-    (globalThis.__agentEventTurns = new Map());
-/** compositeKey -> what this instance has had dropped, and why (Issue #1930). */
-const dropCounts = globalThis.__agentEventDrops ??
-    (globalThis.__agentEventDrops = new Map());
-/**
- * Monotonic suffix for {@link TurnRecord.turnId}.
- *
- * Two turns can open in the same millisecond — a `post_tool_use` closing one
- * agent's turn while another's `user_prompt_submit` lands — and an id built from
- * the timestamp alone would then compare equal across instances. `wait` reads a
- * change of id as "a new turn began", so the collision would be a missed turn
- * boundary rather than a cosmetic clash.
- */
-const turnSequence = globalThis.__agentEventTurnSeq ??
-    (globalThis.__agentEventTurnSeq = { value: 0 });
-/** compositeKey -> the `AskUserQuestion` call currently in flight (#1726). */
-const askUserQuestion = globalThis.__agentEventAskUserQuestion ??
-    (globalThis.__agentEventAskUserQuestion = new Map());
-/** dedup key -> epoch ms it was first seen. See {@link isDuplicateAgentEvent}. */
-const recentEventKeys = globalThis.__agentEventRecentKeys ??
-    (globalThis.__agentEventRecentKeys = new Map());
-/**
- * compositeKey -> (identity key -> epoch ms it was first seen) (Issue #1899).
- *
- * Nested rather than flat so the bound is *per instance*, which the flat
- * {@link recentEventKeys} is not: one chatty agent must not be able to evict
- * another's ids and let a genuine re-delivery through on a quiet pane. See
- * {@link claimEventIdentity}.
- */
-const recentEventIdentities = globalThis.__agentEventRecentIdentities ??
-    (globalThis.__agentEventRecentIdentities = new Map());
-/** compositeKey -> the agent's own "I am waiting for instructions" (#1786). */
-const awaitingInstruction = globalThis.__agentEventAwaitingInstruction ??
-    (globalThis.__agentEventAwaitingInstruction = new Map());
-/**
- * compositeKey -> the last non-null model this instance reported (Issue #1783).
- *
- * A *separate* map, not a field read off {@link lastAgentEvent}, and that is the
- * whole point of it. `lastAgentEvent` is replaced wholesale on every delivery,
- * and Claude puts the model on `SessionStart` and on a `PostModelSwitch`
- * (Issue #2363) and on nothing else — so the very next `UserPromptSubmit` would
- * overwrite the only record that ever knew it, and
- * the UI would show the model for the fraction of a second between session start
- * and the first prompt. Keeping the last *non-null* sighting separately is what
- * makes "which model is this session on" answerable at all for that tool.
- *
- * Never written with null: absent means "nothing has ever said", which is the
- * honest state for gemini, copilot, and any session that predates this server
- * process. See {@link getLastKnownAgentModel}.
- */
-const lastAgentModel = globalThis.__agentEventLastModel ??
-    (globalThis.__agentEventLastModel = new Map());
-/**
- * compositeKey -> epoch ms of the report that last wrote {@link lastAgentModel}
- * (Issue #2361).
- *
- * Kept so the frame can be judged NEWER than the hook. When #2361 was measured
- * on 2.1.263, Claude named its model on `SessionStart` and on nothing
- * CommandMate registered — `/model` fired none of the seven events, and the
- * `SessionStart` a `/clear` emits carries no `model` key — so after a switch
- * the hook latch was a true statement about a process that had since changed
- * its mind, and the screen was the only channel that heard it. Issue #2363
- * registers `PostModelSwitch`, which re-stamps this on every switch; the stamp
- * now matters for the sessions where that hook does not arrive. See
- * {@link resolveAgentModel}.
- */
-const lastAgentModelAt = globalThis.__agentEventLastModelAt ??
-    (globalThis.__agentEventLastModelAt = new Map());
-/**
- * compositeKey -> what the terminal frame last showed for this instance (#1784).
- *
- * The second source, and a strictly different kind of fact from
- * {@link lastAgentModel}: that one is the agent naming itself over the hook
- * channel, this one is the TUI's own chrome read back off the screen. It is
- * kept apart rather than folded into the first map because the two have a
- * precedence between them ({@link getResolvedAgentModelInfo}) — merging on write
- * would let a scraped display name ("Gemini 3.7 Flash") overwrite the exact id
- * the agent reported, with nothing left to recover it from.
- *
- * Latched the same way and for a sharper reason: Claude prints its model in the
- * startup banner and nowhere else, and tmux keeps 2000 lines of history, so on
- * any session that has been talking for a while the banner is simply gone. The
- * screen going quiet is not the model changing, so the last non-null sighting
- * stands until the process it described does not (see
- * {@link beginAgentEventGeneration} / {@link discardAgentEventState}).
- */
-const capturedModelInfo = globalThis.__agentCapturedModelInfo ??
-    (globalThis.__agentCapturedModelInfo = new Map());
-/**
- * compositeKey -> the effort the *agent itself* last reported (Issue #2048).
- *
- * The third source, and until #2048 there was no such thing: #1784's whole
- * premise was that "no hook payload of any tool carries an effort field", which
- * was true of the five push tools and stayed true of opencode's own screen —
- * `model-info-extractor` still records that opencode prints no effort anywhere
- * in its pane, across 17 live frames.
- *
- * What changed is the *channel*, not the screen. opencode calls it a **variant**
- * and publishes it on the frames CommandMate is subscribed to —
- * `Session.model.variant` on `session.updated` and `info.variant` on
- * `message.updated`, measured on 1.18.22 in an isolated `HOME`
- * (`docs/design/opencode-server-live-verification.md` §20.4). The names in that
- * catalogue are `low` / `medium` / `high` / `max` / `minimal` / `none` /
- * `xhigh`, and each one's entry carries an `effort` (or `reasoningEffort`) equal
- * to itself — so the value is an effort in opencode's own vocabulary as well as
- * in this map's.
- *
- * Kept apart from {@link capturedModelInfo} for the reason that map is kept
- * apart from {@link lastAgentModel}: there is a precedence between them
- * ({@link getResolvedAgentModelInfo}), and merging on write would lose it.
- * Latched the same way, and never written with null — a turn that reports no
- * variant is opencode running the model's default, not the previous choice
- * being withdrawn.
- */
-const reportedEffort = globalThis.__agentEventLastEffort ??
-    (globalThis.__agentEventLastEffort = new Map());
-/**
- * compositeKey -> the model this instance was last observed on (Issue #2357).
- *
- * A *fourth* map beside the three latches rather than a comparison against
- * them, because the latches are what they are for a reason: each remembers the
- * last non-null value its channel produced, and none of them can say "and the
- * value before that". This map holds exactly that — the previous answer of
- * {@link getResolvedAgentModelInfo} — so a write to either latch can be judged
- * as "same model", "first sighting" or "changed" without re-deriving history
- * from maps that never kept it.
- *
- * Cleared wherever the latches are cleared (generation, discard, test seam) and
- * on `session_start`, so the first model a new agent process reports is
- * recorded as its starting model and announced to nobody.
- */
-const modelBaseline = globalThis.__agentModelBaseline ??
-    (globalThis.__agentModelBaseline = new Map());
-/**
- * Listeners for the model edge, on `globalThis` for the reason the maps above
- * are: under `next dev` each route bundle evaluates this module once, and the
- * hook route (which writes the hook latch) and the status poll (which writes
- * the frame latch) are different bundles. A module-scoped set would let each
- * bundle notify only the listeners registered in the same bundle — which is
- * none, for the one that receives the hook.
- */
-const modelChangeListeners = globalThis.__agentModelChangeListeners ??
-    (globalThis.__agentModelChangeListeners = new Set());
-/**
- * A trailing reasoning-effort token in a model id (`gemini-3.7-flash-high`).
- *
- * The same five words `model-info-extractor` recognises, matched only at the
- * very end and only after a separator, so `gpt-5-mini` keeps its `mini` and a
- * model that merely ends in these letters is untouched. agy encodes the effort
- * in the id it reports on every event (`deriveEffortFromModelId`), and a user
- * moving the same model from `high` to `low` has not changed model.
- */
-exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN = /[-_ ](?:minimal|low|medium|high|xhigh)$/i;
-/**
- * Tokens a display label carries that the id does not, dropped before comparing.
- *
- * Measured pairs only: claude's banner reads `Opus 5 (1M context)` for the id
- * `claude-opus-5[1m]` — the `1m` is part of the model, the word is not.
- */
-const MODEL_LABEL_NOISE_PATTERN = /\bcontext\b/gi;
-/** Lowercase alphanumerics, effort suffix and label-only words removed. */
-function modelNameKey(value) {
-    return value
-        .replace(exports.AGENT_MODEL_EFFORT_SUFFIX_PATTERN, '')
-        .replace(MODEL_LABEL_NOISE_PATTERN, '')
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, '');
-}
-/**
- * Do two model names name the same model? (Issue #2357)
- *
- * Within one channel the answer is exact on alphanumerics — `GPT-5 mini` and
- * `gpt-5-mini` are one model rendered two ways (copilot's bar and its notice,
- * both read off the frame), while `gpt-5` and `gpt-5-mini` are two models and
- * the second is precisely the downgrade this Issue exists to announce. The
- * effort suffix is stripped first, because agy's id carries it and an effort
- * change is not a model change.
- *
- * *Across* channels the rule is widened to containment: the hook reports an
- * id, the screen prints a label, and every measured pair is the label's key
- * inside the id's (`gemini37flash` ⊂ `gemini37flashhigh`, `opus51m` ⊂
- * `claudeopus51m`, `claudesonnet46` ⊂ `anthropicclaudesonnet46`). Containment
- * is NOT applied within a channel — it would fold `gpt-5` into `gpt-5-mini` —
- * and a caller has to say which case it is in.
- *
- * Exported for the tests and for anything that has to agree with this module
- * about identity; deliberately local rather than the extractor's `sameModel`,
- * which is a single-channel exact match and is shared with #2358's edit.
- */
-function isSameAgentModelName(a, b, options = {}) {
-    const ka = modelNameKey(a);
-    const kb = modelNameKey(b);
-    if (ka === kb)
-        return true;
-    if (!options.crossSource)
-        return false;
-    if (ka.length === 0 || kb.length === 0)
-        return false;
-    return ka.includes(kb) || kb.includes(ka);
-}
-/**
- * Subscribe to the model edge (Issue #2357).
- *
- * The listener receives every transition {@link observeAgentModel} judged to be
- * a change — never a first sighting, never a value going quiet. `#2357`'s
- * realtime broadcaster and push notifier are the two subscribers; neither keeps
- * a "what was it last time?" of its own, which is the point of this being an
- * edge rather than a level.
- *
- * @returns The unsubscribe function
- */
-function onAgentModelChange(listener) {
-    modelChangeListeners.add(listener);
-    return () => {
-        modelChangeListeners.delete(listener);
-    };
-}
-/** Deliver one change; a listener that throws must not disturb the write that observed it. */
-function emitAgentModelChange(change) {
-    for (const listener of modelChangeListeners) {
-        try {
-            listener(change);
-        }
-        catch {
-            // Advisory. The hook route and the status poll are the callers, and a
-            // notification failure is not a reason to fail either.
-        }
-    }
-}
-/**
- * The model this instance was last observed on, or null. Test seam.
- */
-function getAgentModelBaseline(worktreeId, cliToolId, instanceId) {
-    return modelBaseline.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
-}
-/**
- * Judge the resolved model after a latch wrote, and announce a change
- * (Issue #2357).
- *
- * Called after every write to {@link lastAgentModel} and
- * {@link capturedModelInfo}, with the channel that wrote. What it compares is
- * {@link getResolvedAgentModelInfo}'s *model* — the merged value the UI shows —
- * against the previous merged value this map remembers. The suppression rules,
- * each of which is a measured false positive:
- *
- *  - **`null → value`** (first report, server restart): recorded as the
- *    starting model, announced to nobody.
- *  - **`value → null`**: cannot reach here — the latches never write null, so
- *    a frame that stopped showing the banner leaves the merged value where it
- *    was. A generation reset clears this map along with the latches, so the
- *    next value is a first sighting again.
- *  - **same name, either channel**: `GPT-5 mini` after `gpt-5-mini` is not a
- *    change. Compared with {@link isSameAgentModelName}; the cross-channel
- *    widening applies only when the merged value's source actually moved.
- *  - **`session_start`**: {@link recordAgentEvent} drops the baseline first, so
- *    the model a relaunched process reports is that process's starting model.
- *
- * Everything else is a change and is emitted exactly once — the baseline is
- * advanced before the listeners run, so a listener that re-enters this module
- * cannot see the same edge twice.
- */
-function observeAgentModel(worktreeId, cliToolId, instanceId, source, at) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    // Where the merged value came from is decided in one place
-    // (`resolveAgentModel`, Issue #2361): the hook's, unless the frame overtook
-    // it — and that is independent of which channel just wrote.
-    const { info, source: resolvedSource } = resolveAgentModel(key, cliToolId);
-    const resolved = info.model;
-    if (resolved === null || resolvedSource === null)
-        return;
-    const previous = modelBaseline.get(key);
-    const next = { model: resolved, source: resolvedSource };
-    if (previous === undefined) {
-        modelBaseline.set(key, next);
-        trimOldestEntries(modelBaseline, MAX_RECENT_EVENT_KEYS);
-        return;
-    }
-    if (isSameAgentModelName(previous.model, resolved, {
-        crossSource: previous.source !== resolvedSource,
-    })) {
-        // Same model, possibly a new spelling or a new channel: follow it so the
-        // next comparison is against the current representation.
-        modelBaseline.set(key, next);
-        return;
-    }
-    modelBaseline.set(key, next);
-    emitAgentModelChange({
-        worktreeId,
-        cliToolId,
-        instanceId: instanceId ?? cliToolId,
-        from: previous.model,
-        to: resolved,
-        source,
-        at,
-    });
-}
-/**
- * How long two identical events count as one delivery.
- *
- * Issue #1722 injects hooks at session start, and `--settings` hooks are
- * *concatenated* with the user's own rather than replacing them, so anyone who
- * followed the #1549 manual setup now has two `Stop` hooks posting the same
- * turn. `applyAgentStopEvent` is idempotent for the timestamp, but
- * `applyTaskEvent` is not: each delivery writes its own `agent_idle` row, and a
- * reader counting rows would see one turn as two.
- *
- * A turn cannot end twice in three seconds, and both deliveries carry the same
- * `session_id`, so the window is generous relative to the real signal and tight
- * relative to anything it could wrongly swallow.
- */
-exports.AGENT_EVENT_DEDUP_WINDOW_MS = 3000;
-/** Cap on retained dedup keys, so a long-lived server cannot grow one per turn. */
-const MAX_RECENT_EVENT_KEYS = 512;
-/** A zeroed tally. */
-function emptyDropCounts() {
-    return {
-        dedupDropped: { identity: 0, timeWindow: 0 },
-        decisionEvicted: 0,
-        idsDiscarded: 0,
-        dialogTimedOut: 0,
-        decisionOverflow: 0,
-    };
-}
-/** The live tally for one instance, created on first use. */
-function dropsFor(key) {
-    let counts = dropCounts.get(key);
-    if (!counts) {
-        counts = emptyDropCounts();
-        dropCounts.set(key, counts);
-        // The composite key is (worktree, tool, instance) and a long-lived server
-        // accumulates worktrees; bounded like every other map here (DR4-009).
-        trimOldestEntries(dropCounts, MAX_RECENT_EVENT_KEYS);
-    }
-    return counts;
-}
-/**
- * What this instance has had dropped, or a zeroed tally when nothing has.
- *
- * A copy, not the live object: this is published on the hot path and a caller
- * that could mutate it would be able to erase the evidence.
- */
-function getAgentEventDropCounts(worktreeId, cliToolId, instanceId) {
-    const counts = dropCounts.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
-    if (!counts)
-        return emptyDropCounts();
-    return { ...counts, dedupDropped: { ...counts.dedupDropped } };
-}
-/** Epoch ms the current generation began, or null when none was opened. */
-function currentGeneration(key) {
-    return generationStartedAt.get(key) ?? null;
-}
-/**
- * The turn this instance is in, with the generation fence applied.
- *
- * A turn whose {@link TurnRecord.generationAt} is not the current generation was
- * opened by a process that has been replaced. It is not deleted — the fence is
- * cheap and deleting would lose the eviction tally — it is simply not this
- * instance's turn any more.
- */
-function fencedTurn(key) {
-    const turn = agentTurns.get(key);
-    if (!turn)
-        return null;
-    if (turn.generationAt !== currentGeneration(key))
-        return null;
-    return turn;
-}
-/**
- * {@link fencedTurn} with the staleness bound applied.
- *
- * The bound is applied by *closing* the turn rather than by hiding it, so
- * `capture --json` says `closedBy: 'stale'` instead of going quiet — "the agent
- * never reported the end of this turn" and "nothing has been reported at all"
- * are different problems and an operator has to be able to tell them apart.
- *
- * Writes on read, which this module already does for corroboration, and is
- * idempotent: the close is stamped from the event's own clock, so it does not
- * move with the reader's `now`.
- */
-function effectiveTurn(key, now) {
-    const turn = fencedTurn(key);
-    if (turn === null)
-        return null;
-    if (turn.closedAt === null && now - turn.displayEvent.at >= provisional_turn_1.TURN_STALE_AFTER_MS) {
-        turn.closedAt = turn.displayEvent.at + provisional_turn_1.TURN_STALE_AFTER_MS;
-        turn.closedBy = 'stale';
-    }
-    return turn;
-}
-/** Next {@link TurnRecord.turnId}. See {@link turnSequence}. */
-function nextTurnId(at) {
-    turnSequence.value += 1;
-    return `turn-${at}-${turnSequence.value}`;
-}
-/**
- * Drop the decisions this turn is holding, counting them.
- *
- * The generation path is the one §4 D3 決定 2 names: a process that has been
- * replaced cannot have its approvals answered, and leaving them behind would
- * publish `waiting` for a pane whose dialog went away with the process that
- * drew it.
- */
-function evictDecisions(key, turn) {
-    if (turn.pendingDecisions.length === 0)
-        return;
-    dropsFor(key).decisionEvicted += turn.pendingDecisions.length;
-    turn.pendingDecisions = [];
-}
-/**
- * The decisions still describing something, dropping the ones that are not.
- *
- * The retention bound of {@link DIALOG_PENDING_MAX_MS}, applied on read and
- * counted as `dialogTimedOut` so the release is visible. Kept here rather than
- * in a timer for the reason the rest of this module has no timers: the state
- * describes a live tmux session, and a reader is the only thing that ever needs
- * the answer.
- */
-function livePendingDecisions(key, turn, now) {
-    const live = turn.pendingDecisions.filter((decision) => (0, provisional_turn_1.isDecisionLive)(decision, now));
-    const dropped = turn.pendingDecisions.length - live.length;
-    if (dropped > 0) {
-        dropsFor(key).dialogTimedOut += dropped;
-        turn.pendingDecisions = live;
-    }
-    return live;
-}
-/**
- * The approvals this instance is blocked on right now (Issue #1930).
- *
- * Published as `structuredEvents.pendingDecisions`; `#1932` is what teaches
- * `commandmate respond` to name one of these ids.
- *
- * @param now - Epoch ms; defaults to now
- */
-function getPendingDecisions(worktreeId, cliToolId, instanceId, now = Date.now()) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const turn = effectiveTurn(key, now);
-    if (turn === null)
-        return [];
-    return livePendingDecisions(key, turn, now);
-}
-/**
- * The turn record for one instance, fenced and aged, or null.
- *
- * The seam `current-output-builder` publishes from and the suites drive. The
- * returned object is the live record; nothing outside this module writes to it.
- *
- * @param now - Epoch ms; defaults to now
- */
-function getAgentTurn(worktreeId, cliToolId, instanceId, now = Date.now()) {
-    return effectiveTurn((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), now);
-}
-/** {@link getAgentTurn} projected onto the four published fields. */
-function getPublishedAgentTurn(worktreeId, cliToolId, instanceId, now = Date.now()) {
-    return (0, provisional_turn_1.derivePublishedTurn)(getAgentTurn(worktreeId, cliToolId, instanceId, now));
-}
-/**
- * Close the open turn on evidence that did not come from the agent (Issue #1930).
- *
- * The one seam for the two {@link TurnCloseReason} values nothing in the event
- * stream can produce:
- *
- *  - `scraper_evidence` — see {@link observeScraperCompletionEvidence}, which is
- *    the caller in this tree.
- *  - `resync_idle` — a source whose `capabilities.resync` lets it be re-read
- *    answering "not busy" after a dropped transport. The reconnect loop that
- *    would call it lives in `sources/opencode/subscription`, which is #1931's
- *    file and deliberately untouched here; the value is in the vocabulary and
- *    the seam accepts it, so wiring it is a call site rather than a new state.
- *
- * A no-op when no turn is open, which is the ordinary case: neither of these is
- * a statement about a session that already reported it finished.
- *
- * @param at - Epoch ms; defaults to now
- * @returns Whether a turn was closed
- */
-function closeAgentTurn(worktreeId, cliToolId, instanceId, closedBy, at = Date.now()) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const turn = fencedTurn(key);
-    if (turn === null || turn.closedAt !== null)
-        return false;
-    turn.closedAt = at;
-    turn.closedBy = closedBy;
-    return true;
-}
-/**
- * Feed one poll's reading of the pane into the turn's completion counter
- * (Issue #1930).
- *
- * `completed` is the scraper's own verdict — `ready` with positive evidence —
- * NOT the merged one, which would be circular: the merge is what the structured
- * layer's `running` overrides, so reading it back would only ever confirm this
- * layer's own answer.
- *
- * See {@link SCRAPER_COMPLETION_POLLS} for why three, and for why closing here
- * does not complete a `commandmate wait`.
- *
- * @param at - Epoch ms; defaults to now
- * @returns Whether this poll closed the turn
- */
-function observeScraperCompletionEvidence(worktreeId, cliToolId, instanceId, completed, at = Date.now()) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const turn = fencedTurn(key);
-    if (turn === null || turn.closedAt !== null)
-        return false;
-    if (!completed) {
-        turn.scraperCompletionPolls = 0;
-        return false;
-    }
-    turn.scraperCompletionPolls += 1;
-    if (turn.scraperCompletionPolls < provisional_turn_1.SCRAPER_COMPLETION_POLLS)
-        return false;
-    turn.closedAt = at;
-    turn.closedBy = 'scraper_evidence';
-    return true;
-}
+const lastAgentEvent = (0, global_state_1.getOrInitGlobal)('__agentEventLast', () => new Map());
 /**
  * Record that `instanceId` reported it stopped.
  *
@@ -714,7 +185,7 @@ function isLateSessionStart(worktreeId, cliToolId, instanceId, record, options)
         return false;
     if (options.sessionStartMayArriveLate !== true)
         return false;
-    const openTurn = getStructuredSessionState(worktreeId, cliToolId, instanceId, record.at);
+    const openTurn = (0, agent_event_structured_state_1.getStructuredSessionState)(worktreeId, cliToolId, instanceId, record.at);
     if (openTurn === null || !OPEN_TURN_STATUSES.includes(openTurn.status))
         return false;
     const openSessionId = lastAgentEvent.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId))?.sessionId ?? null;
@@ -742,8 +213,8 @@ function recordAgentEvent(worktreeId, cliToolId, instanceId, record, options = {
         // model would otherwise be the single case where the model is extracted and
         // then dropped on the floor. copilot reports none today (#1783), which is
         // exactly why this has to be decided here rather than left to be noticed.
-        latchAgentModel(key, record);
-        observeAgentModel(worktreeId, cliToolId, instanceId, 'hook', record.at);
+        (0, agent_event_model_1.latchAgentModel)(key, record);
+        (0, agent_event_model_1.observeAgentModel)(worktreeId, cliToolId, instanceId, 'hook', record.at);
         return { recorded: false, skipped: 'late-session-start' };
     }
     lastAgentEvent.set(key, record);
@@ -753,567 +224,35 @@ function recordAgentEvent(worktreeId, cliToolId, instanceId, record, options = {
         // latch so the comparison in `observeAgentModel` has nothing to compare
         // against. `/clear` (session_end + session_start on the same process, same
         // model) passes through here unchanged: same name, no edge either way.
-        modelBaseline.delete(key);
+        agent_event_model_1.modelBaseline.delete(key);
     }
-    latchAgentModel(key, record);
-    observeAgentModel(worktreeId, cliToolId, instanceId, 'hook', record.at);
-    applyAskUserQuestionTransition(key, record);
+    (0, agent_event_model_1.latchAgentModel)(key, record);
+    (0, agent_event_model_1.observeAgentModel)(worktreeId, cliToolId, instanceId, 'hook', record.at);
+    (0, agent_event_ask_user_question_1.applyAskUserQuestionTransition)(key, record);
     if (record.event === 'session_start') {
         // The agent restarting inside a pane CommandMate never touched — `claude`
         // relaunched by hand, or a `/clear` (which emits SessionEnd then
         // SessionStart on a live session) — is a new generation just as much as a
         // new tmux session is. Recorded from the event's own timestamp, so the
         // event that opens a generation is never stale against it.
-        generationStartedAt.set(key, record.at);
+        agent_event_turn_1.generationStartedAt.set(key, record.at);
+        // Issue #3397: and Auto-Yes's Enter belonged to the previous process's
+        // screen. Only here — past `isLateSessionStart` above, and past the
+        // duplicate window the intake applies before calling this — so a late or
+        // repeated `SessionStart` never expires the record of the live process.
+        (0, auto_yes_enter_fallback_state_1.beginEnterFallbackSession)(worktreeId, cliToolId, instanceId);
         // Issue #1930: and the turn the previous process was in ends with it. Done
         // here rather than inside the transition below so the two paths into a new
         // generation — this one and `beginAgentEventGeneration` — close the turn in
         // exactly one place.
-        fenceTurnForNewGeneration(key, record.at);
+        (0, agent_event_turn_1.fenceTurnForNewGeneration)(key, record.at);
     }
     // Issue #1930: after the generation is settled, so a turn opened by this
     // event belongs to the generation the event itself opened.
-    applyTurnTransition(key, record);
-    applyAwaitingInstructionTransition(key, record);
+    (0, agent_event_turn_1.applyTurnTransition)(key, record);
+    (0, agent_event_awaiting_instruction_1.applyAwaitingInstructionTransition)(key, record);
     return { recorded: true };
 }
-/**
- * End the open turn because the process that owned it has been replaced
- * (Issue #1930).
- *
- * The turn is closed and re-stamped into the new generation rather than
- * deleted, which is the difference between `capture --json` reporting
- * `closedBy: 'generation'` and reporting nothing at all. Its approvals go: they
- * were raised by a process that no longer exists, and answering one would
- * deliver a verdict into a slot nobody is holding.
- */
-function fenceTurnForNewGeneration(key, at) {
-    const turn = agentTurns.get(key);
-    if (!turn)
-        return;
-    evictDecisions(key, turn);
-    // A turn that had ALREADY ended is left where it is, which means the fence in
-    // `fencedTurn` hides it from here on. That asymmetry is deliberate: the
-    // previous process's `Stop` is not this process's, and re-stamping it into the
-    // new generation would publish `ready` — "the agent finished" — for a session
-    // nobody has typed into yet. Before #1930 the same protection came from
-    // comparing the event's timestamp against the generation.
-    if (turn.closedAt !== null)
-        return;
-    // An OPEN turn is closed and carried across, so `capture --json` can say
-    // `closedBy: 'generation'` rather than going quiet. `getStructuredSessionState`
-    // reads that reason as "nothing is known", so it publishes no verdict either
-    // way; what it buys is an operator being able to tell "the session was
-    // restarted under this turn" from "nothing was ever reported".
-    turn.closedAt = at;
-    turn.closedBy = 'generation';
-    turn.generationAt = at;
-}
-/**
- * Issue #1783: latch, never clear. An event without a model is the ordinary
- * case (Claude sends one on `SessionStart` and, since #2363, on a model
- * switch), and reading it as "the model is now unknown" would blank the display
- * on the very next event.
- */
-function latchAgentModel(key, record) {
-    if (typeof record.model === 'string' && record.model !== '') {
-        lastAgentModel.set(key, record.model.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH));
-        // Issue #2361: stamped on every model-bearing report, not only on a change
-        // of value — a hook that names the same model again is the agent
-        // re-affirming it, and a frame has to be newer than THAT to overtake.
-        lastAgentModelAt.set(key, record.at);
-    }
-}
-/**
- * The third state: "this turn is over and nobody has told me what to do next"
- * (Issue #1786).
- *
- * | event                             | effect on awaiting_instruction |
- * |-----------------------------------|--------------------------------|
- * | `notification(idle_prompt)`       | **set**                        |
- * | `user_prompt_submit`              | release                        |
- * | `session_start` / `session_end`   | release                        |
- * | everything else                   | unchanged                      |
- *
- * It is a boolean beside the status rather than a fifth `SessionStatus`, because
- * `idle_prompt` already maps to `ready` (`agentEventToSessionStatus`) and
- * `ready` means "you can send a message" everywhere in this codebase — the
- * sidebar, `deriveCliStatus`, `getNextAction`, `commandmate wait`. Widening that
- * vocabulary to carry "and it is *asking* you to" would have every consumer of
- * the four values re-decide what they mean; the boolean asks nothing of anyone
- * who does not want it.
- *
- * `stop` deliberately does NOT set it. `Stop` fires when the turn ends, which is
- * most of the time the agent has simply finished a step of its own plan;
- * `Notification(idle_prompt)` is Claude's separate, later "waiting for your
- * input" signal, and using the turn boundary instead would mark every
- * intermediate stop as a request for instructions.
- *
- * `pre_tool_use` / `post_tool_use` / `notification(permission_prompt)` leave it
- * alone, and that is not a gap: a tool call or a dialog can only happen inside a
- * turn, and the turn's own `user_prompt_submit` has already released it. Adding
- * them would only paper over a `UserPromptSubmit` that never arrived — and an
- * operator whose `UserPromptSubmit` hook is missing has no `Notification` hook
- * either, so there would be nothing to release.
- *
- * There is deliberately no age bound here, unlike every other state in this
- * module. Those bound the damage of an event that may never arrive (a lost
- * `Stop`, a dialog answered with no event to say so). This one is released by
- * events that cannot be missed while the fact is still true: typing into the
- * composer — from the app or straight into the tmux pane — raises
- * `UserPromptSubmit`, and ending the session raises `SessionEnd`. An agent that
- * has been idle for six hours genuinely is still awaiting instructions, and
- * expiring the flag would erase the notification #1790 exists to send. The
- * generation fence in {@link isAwaitingInstruction} still applies, so the flag
- * never survives the process that reported it.
- */
-function applyAwaitingInstructionTransition(key, record) {
-    switch (record.event) {
-        case 'notification':
-            if (record.detail === 'idle_prompt') {
-                awaitingInstruction.set(key, { at: record.at, message: record.message ?? null });
-            }
-            return;
-        case 'user_prompt_submit':
-        case 'session_start':
-        case 'session_end':
-            awaitingInstruction.delete(key);
-            return;
-        case 'stop':
-        case 'pre_tool_use':
-        case 'post_tool_use':
-            return;
-        default:
-            // exhaustive check: a new AgentEventType must decide its transition here
-            record.event;
-            return;
-    }
-}
-/**
- * The agent's own "waiting for your input", or null (Issue #1786).
- *
- * Fenced by generation like the rest of this module: an `idle_prompt` from the
- * Claude process that used to live in this pane is not this one's.
- */
-function getAwaitingInstruction(worktreeId, cliToolId, instanceId) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const record = awaitingInstruction.get(key);
-    if (!record)
-        return null;
-    const generation = generationStartedAt.get(key);
-    if (generation !== undefined && record.at < generation)
-        return null;
-    return record;
-}
-/** {@link getAwaitingInstruction} as the boolean the list API publishes. */
-function isAwaitingInstruction(worktreeId, cliToolId, instanceId) {
-    return getAwaitingInstruction(worktreeId, cliToolId, instanceId) !== null;
-}
-/**
- * The turn transition: what one delivery does to {@link TurnRecord}
- * (Issue #1930, §4 D3 決定 2).
- *
- * | event                              | turn                    | dialog   | display |
- * |------------------------------------|-------------------------|----------|---------|
- * | `user_prompt_submit`               | **opens a new one**     | release  | yes     |
- * | `pre_tool_use`                     | continues, else opens   | unchanged| yes     |
- * | `post_tool_use`                    | continues, else opens   | release  | yes     |
- * | `stop` (this session)              | **closes** `stop`       | release  | yes     |
- * | `stop` (another session)           | unchanged               | unchanged| no      |
- * | `session_end`                      | **closes** `session_end`| release  | no      |
- * | `session_start`                    | new generation (above)  | evicted  | no      |
- * | `notification(permission_prompt)`  | unchanged               | **open** | only to bootstrap |
- * | `notification(permission_replied)` | unchanged               | release  | no      |
- * | `notification(idle_prompt)`        | unchanged               | release  | yes     |
- * | `notification(anything else)`      | unchanged               | unchanged| no      |
- *
- * Four rows are the whole point of the Issue, and each of them was a defect
- * under "the newest event is the verdict":
- *
- *  - **`user_prompt_submit` opens a new turn, the tool-call events continue the
- *    open one.** That is what makes {@link TurnRecord.turnId} an identity: #1926
- *    re-stamped it on every `pre_tool_use`, so a consumer reading a changed id
- *    as "a new turn began" false-positived several times inside one turn. `wait`
- *    reads it that way now.
- *  - **A `stop` naming another session changes nothing.** opencode publishes
- *    `session.idle` for every session its server holds, other processes'
- *    included (#1758 §5.6).
- *  - **`session_start` / `session_end` / an unknown notification /
- *    `permission_replied` do not become the displayed event.** An event carrying
- *    no verdict must not erase one. #1903 fixed the single measured instance
- *    (copilot's late `SessionStart`) by holding the delivery; the rule is
- *    general here, and the capability it reads is still the only reason a
- *    `session_start` is held rather than recorded.
- *  - **`notification(permission_prompt)` does not become the displayed event
- *    when a turn already exists.** The dialog is a fact about the *pane*, and
- *    it is published by the decision ledger below. Letting it overwrite the
- *    display is how the pre-#1898 `waiting` outlived the approval that caused
- *    it: released, the record still said `waiting`, because the only thing it
- *    could read was the event that opened the dialog.
- *
- * `idle_prompt` is the one row that publishes `ready` **without** closing the
- * turn, and that is a measurement rather than an oversight: #1839 caught Claude
- * emitting it 62 s into a turn that ran nothing, so it cannot be a turn
- * boundary. `wait`'s gate stays armed through it; what changes is only what the
- * pane displays.
- */
-function applyTurnTransition(key, record) {
-    const generation = currentGeneration(key);
-    // An event stamped before the current generation was produced by a process
-    // that has been replaced. Refusing it here is what makes re-recording a stale
-    // `user_prompt_submit` at its original timestamp a no-op.
-    if (generation !== null && record.at < generation)
-        return;
-    switch (record.event) {
-        case 'user_prompt_submit':
-            openTurn(key, record, generation, { continueOpen: false });
-            releaseAllDecisions(key);
-            return;
-        case 'post_tool_use':
-            openTurn(key, record, generation, { continueOpen: true });
-            // The tool call the dialog was gating has finished, so somebody answered
-            // it (Issue #1726). This is the release #1725 could not have: it had no
-            // event meaning "the human answered", only `Stop` meaning "the turn
-            // ended", which can be minutes later.
-            releaseAllDecisions(key);
-            return;
-        case 'pre_tool_use':
-            // Deliberately leaves the dialog alone (Issue #1726). It is the
-            // `AskUserQuestion` invocation, and a picker being *about to be drawn* is
-            // not a fact this state can carry.
-            openTurn(key, record, generation, { continueOpen: true });
-            return;
-        case 'stop':
-            applyStopToTurn(key, record, generation);
-            return;
-        case 'session_end':
-            applySessionEndToTurn(key, record);
-            releaseAllDecisions(key);
-            return;
-        case 'session_start':
-            // The generation was opened by `recordAgentEvent` before this ran, and
-            // `fenceTurnForNewGeneration` closed the turn with it. Nothing further:
-            // the frame carries no verdict, so it is not the displayed event either.
-            return;
-        case 'notification':
-            applyNotificationToTurn(key, record, generation);
-            return;
-        default:
-            // exhaustive check: a new AgentEventType must decide its transition here
-            record.event;
-            return;
-    }
-}
-/** The three fields the turn keeps from a record. */
-function displayOf(record) {
-    return { event: record.event, at: record.at, detail: record.detail };
-}
-/**
- * Open a turn for this event, or move the display onto an open one.
- *
- * @param continueOpen - Whether an already-open turn of the same session is
- *   this event's turn. False for `user_prompt_submit`, which IS a new turn.
- */
-function openTurn(key, record, generation, { continueOpen }) {
-    const turn = fencedTurn(key);
-    const openHere = turn !== null &&
-        turn.closedAt === null &&
-        turn.openedAt !== null &&
-        (0, provisional_turn_1.closesTurn)(turn, record.sessionId);
-    if (continueOpen && openHere) {
-        turn.displayEvent = displayOf(record);
-        // A hand-configured relay posts no session id, so a turn can learn one
-        // partway through. Learning it is what lets a later `stop` be matched.
-        turn.sessionId ??= record.sessionId;
-        turn.scraperCompletionPolls = 0;
-        return;
-    }
-    // A dialog-only record (openedAt null) is not a turn; its decisions belong to
-    // the turn that is opening now, because that is when they were raised.
-    const carried = turn !== null && turn.openedAt === null && turn.closedAt === null
-        ? turn.pendingDecisions
-        : [];
-    agentTurns.set(key, {
-        turnId: nextTurnId(record.at),
-        sessionId: record.sessionId,
-        openedAt: record.at,
-        closedAt: null,
-        closedBy: null,
-        generationAt: generation,
-        displayEvent: displayOf(record),
-        pendingDecisions: carried,
-        scraperCompletionPolls: 0,
-    });
-    boundTurnMap();
-}
-/**
- * Apply a `stop` — the only event that is the agent saying its turn is over.
- *
- * A `stop` for another session leaves everything alone; see {@link closesTurn}.
- * A `stop` with no turn open still records one, because "this instance last
- * reported it stopped at T" is the fact `ready` is published from, and the
- * opening it never saw is published as null rather than guessed.
- */
-function applyStopToTurn(key, record, generation) {
-    const turn = fencedTurn(key);
-    if (turn !== null && turn.closedAt === null && turn.openedAt !== null) {
-        if (!(0, provisional_turn_1.closesTurn)(turn, record.sessionId))
-            return;
-        turn.closedAt = record.at;
-        turn.closedBy = 'stop';
-        turn.displayEvent = displayOf(record);
-        releaseAllDecisions(key);
-        return;
-    }
-    agentTurns.set(key, {
-        turnId: nextTurnId(record.at),
-        sessionId: record.sessionId,
-        openedAt: null,
-        closedAt: record.at,
-        closedBy: 'stop',
-        generationAt: generation,
-        displayEvent: displayOf(record),
-        pendingDecisions: [],
-        scraperCompletionPolls: 0,
-    });
-    boundTurnMap();
-}
-/**
- * `session_end`: the agent session this instance was talking to is gone.
- *
- * **Overwrites an existing close reason**, which is the one place in this
- * module where a later event rewrites an earlier verdict, and #1723's contract
- * is why. `/clear` emits `SessionEnd(reason=clear)` on a session that is alive
- * and about to keep going, and the turn before it may perfectly well have ended
- * with a `Stop`. Leaving that `Stop` standing would keep publishing "the agent
- * finished" about a conversation that no longer exists — the integration pin is
- * `current-output-structured-status-1723`, which asserts the session goes back
- * to the scraper the moment `SessionEnd` lands.
- *
- * `closedBy: 'session_end'` publishes no verdict of its own (see
- * {@link getStructuredSessionState}), so this is a retirement rather than a
- * different answer.
- */
-function applySessionEndToTurn(key, record) {
-    const turn = fencedTurn(key);
-    if (turn === null)
-        return;
-    if (!(0, provisional_turn_1.closesTurn)(turn, record.sessionId))
-        return;
-    turn.closedAt = record.at;
-    turn.closedBy = 'session_end';
-}
-/**
- * The notification rows of the transition table.
- *
- * Matched on `notification_type` ({@link AgentEventRecord.detail}), never on the
- * human-facing `message` (D3): the observed messages are English prose the agent
- * is free to reword.
- */
-function applyNotificationToTurn(key, record, generation) {
-    if (record.detail === 'permission_prompt') {
-        if (record.promptSettled === true) {
-            // Issue #1898: adjudicated before it was recorded, and the verdict
-            // reached the agent. There is no dialog and there never was one for a
-            // human to answer — opening a record for it published `waiting` for the
-            // whole of the tool call that followed (measured at eight seconds).
-            releaseSettledDecision(key, record);
-            return;
-        }
-        openDecision(key, generation, {
-            source: 'notification',
-            at: record.at,
-            message: record.message ?? null,
-            // Issue #2031. Was a hard `null`, which is what left an opencode approval
-            // reaching the browser with no statement of what it was for: the tool
-            // name is not in `permission.asked` and has to be carried on the record
-            // by whoever correlated it. Absent still means "this source had nothing
-            // to say", and `openDecision` leaves an earlier name in place for that.
-            toolName: record.toolName ?? null,
-            patterns: record.decisionPatterns ?? null,
-            decisionId: record.decisionId ?? null,
-            bootstrapDisplay: displayOf(record),
-        });
-        return;
-    }
-    if (record.detail === agent_event_types_1.PERMISSION_REPLIED_DETAIL) {
-        // Issue #1898. The agent's own statement that the dialog is gone — whoever
-        // answered it. Not a word this build reads a status from, so it decides
-        // nothing; all it does is retire the record.
-        if (record.promptSettled === true)
-            releaseSettledDecision(key, record);
-        return;
-    }
-    if (record.detail === 'idle_prompt') {
-        // The agent reporting it is sitting at the composer waiting for input is the
-        // agent saying nothing is in front of that composer.
-        releaseAllDecisions(key);
-        const turn = fencedTurn(key);
-        if (turn !== null && turn.closedAt === null) {
-            turn.displayEvent = displayOf(record);
-            return;
-        }
-        if (turn !== null)
-            return;
-        // Nothing to attach it to — the first thing this instance ever said, or the
-        // first since a generation. It still carries a verdict (`ready`), and #1723
-        // publishes it, so a display-only record is opened to hold it. `openedAt`
-        // stays null: an agent sitting at its composer is not in a turn, and a
-        // record that claimed otherwise would gate `wait` on a turn nobody opened.
-        agentTurns.set(key, {
-            turnId: nextTurnId(record.at),
-            sessionId: record.sessionId,
-            openedAt: null,
-            closedAt: null,
-            closedBy: null,
-            generationAt: generation,
-            displayEvent: displayOf(record),
-            pendingDecisions: [],
-            scraperCompletionPolls: 0,
-        });
-        boundTurnMap();
-        return;
-    }
-    // An unrecognised notification type is not evidence of anything, and guessing
-    // would be worse than the scraper.
-}
-/**
- * Open, or refresh, a dialog record on this instance's turn.
- *
- * `bootstrapDisplay` is used only when there is no record at all to hang the
- * decision on. That record is deliberately **not** an open turn — its
- * `openedAt` is null — so releasing the decision hands the pane back to the
- * scraper rather than asserting `running` for a turn nobody ever saw open.
- */
-function openDecision(key, generation, input) {
-    let turn = fencedTurn(key);
-    if (turn === null) {
-        turn = {
-            turnId: nextTurnId(input.at),
-            sessionId: null,
-            openedAt: null,
-            closedAt: null,
-            closedBy: null,
-            generationAt: generation,
-            displayEvent: input.bootstrapDisplay,
-            pendingDecisions: [],
-            scraperCompletionPolls: 0,
-        };
-        agentTurns.set(key, turn);
-        boundTurnMap();
-    }
-    else if (turn.closedAt !== null) {
-        // The dialog is being raised after the turn it would have belonged to
-        // ended — a `PermissionRequest` racing a `Stop`, or a re-check landing
-        // late. Re-open a dialog-only record rather than resurrecting the turn.
-        turn = {
-            turnId: nextTurnId(input.at),
-            sessionId: null,
-            openedAt: null,
-            closedAt: null,
-            closedBy: null,
-            generationAt: generation,
-            displayEvent: input.bootstrapDisplay,
-            pendingDecisions: [],
-            scraperCompletionPolls: 0,
-        };
-        agentTurns.set(key, turn);
-        boundTurnMap();
-    }
-    // Issue #1930 / S1: an id that fails validation is DISCARDED, not truncated —
-    // a truncated id compares equal to a different id sharing its prefix, and the
-    // reply to one approval would then retire another's record.
-    const decisionId = input.decisionId === null ? null : (0, provisional_turn_1.acceptExternalId)(input.decisionId);
-    if (input.decisionId !== null && decisionId === null)
-        dropsFor(key).idsDiscarded += 1;
-    const confirmed = input.source === 'notification';
-    // Which record, if any, this report is a second sighting of.
-    //
-    //  - an id matches its own record;
-    //  - an id with no record of its own may still be *confirming* the anonymous
-    //    prediction that forecast it. That is the measured pair: a
-    //    `PermissionRequest` this server declined to decide fires ~6 s before the
-    //    `Notification(permission_prompt)` that proves the dialog, and the
-    //    request carries no id;
-    //  - an anonymous report merges only with another anonymous one. A source
-    //    that publishes no ids therefore keeps exactly one dialog record per
-    //    instance, which is what #1725 did and the honest limit for it — matching
-    //    an anonymous report against an *identified* record would let one
-    //    approval's forecast confirm a different approval's dialog.
-    const existing = decisionId !== null
-        ? (turn.pendingDecisions.find((decision) => decision.decisionId === decisionId) ??
-            turn.pendingDecisions.find((decision) => decision.decisionId === null && decision.source === 'permission-request'))
-        : turn.pendingDecisions.find((decision) => decision.decisionId === null);
-    if (existing) {
-        // The same dialog, reported twice: `PermissionRequest` predicted it and the
-        // `Notification` then proved it. Keep the earliest `at` — that is when the
-        // human was first blocked, and it is what the scraper-release grace and the
-        // age bound are measured from — and take the confirmation.
-        existing.message = (0, provisional_turn_1.boundDecisionMessage)(input.message) ?? existing.message;
-        existing.toolName = (0, provisional_turn_1.boundDecisionToolName)(input.toolName) ?? existing.toolName;
-        // Issue #2031, same rule as the two lines above it: a second sighting that
-        // knows the rules fills them in, one that does not leaves the earlier
-        // answer alone. The measured pair is exactly this — the `PermissionRequest`
-        // forecast carries no patterns, the `Notification` that confirms it does.
-        existing.patterns = (0, provisional_turn_1.boundDecisionPatterns)(input.patterns) ?? existing.patterns;
-        existing.decisionId ??= decisionId;
-        if (confirmed) {
-            existing.source = 'notification';
-            existing.confirmedAt ??= input.at;
-        }
-        return;
-    }
-    if (turn.pendingDecisions.length >= provisional_turn_1.MAX_PENDING_DECISIONS_PER_TURN) {
-        // S14(d). Counted rather than dropped in silence: an agent raising more
-        // approvals than this in one turn is a fact an operator has to be able to
-        // see, and the oldest is the one a human has been looking at.
-        dropsFor(key).decisionOverflow += 1;
-        return;
-    }
-    turn.pendingDecisions.push({
-        decisionId,
-        at: input.at,
-        source: input.source,
-        message: (0, provisional_turn_1.boundDecisionMessage)(input.message),
-        toolName: (0, provisional_turn_1.boundDecisionToolName)(input.toolName),
-        patterns: (0, provisional_turn_1.boundDecisionPatterns)(input.patterns),
-        confirmedAt: confirmed ? input.at : null,
-        scraperCorroborated: false,
-        recorded: false,
-    });
-}
-/** Retire every dialog this instance was holding. */
-function releaseAllDecisions(key) {
-    const turn = fencedTurn(key);
-    if (turn !== null)
-        turn.pendingDecisions = [];
-}
-/**
- * Retire the record a verdict was delivered for (Issue #1898).
- *
- * Matched on {@link AgentEventRecord.decisionId} when both sides have one: an
- * agent that can run two approvals at once would otherwise have the reply to
- * the first retire the record for the second. When either side is anonymous the
- * release is unconditional — an unmatched id is a source that publishes none,
- * and refusing to act there would leave the pre-#1898 stall in place for it.
- */
-function releaseSettledDecision(key, record) {
-    const turn = fencedTurn(key);
-    if (turn === null || turn.pendingDecisions.length === 0)
-        return;
-    const settledId = record.decisionId === null || record.decisionId === undefined
-        ? null
-        : (0, provisional_turn_1.acceptExternalId)(record.decisionId);
-    if (settledId === null) {
-        turn.pendingDecisions = [];
-        return;
-    }
-    turn.pendingDecisions = turn.pendingDecisions.filter((decision) => decision.decisionId !== null && decision.decisionId !== settledId);
-}
-/** Keep the turn map bounded the way every other map in this module is. */
-function boundTurnMap() {
-    trimOldestEntries(agentTurns, MAX_RECENT_EVENT_KEYS);
-}
 /**
  * @returns The last structured event reported by this instance, or null when it
  *   has reported none.
@@ -1321,277 +260,6 @@ function boundTurnMap() {
 function getLastAgentEvent(worktreeId, cliToolId, instanceId) {
     return lastAgentEvent.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
 }
-/**
- * The last model this instance reported running, or null (Issue #1783).
- *
- * "Last **non-null**", which is the only useful reading: three of the four tools
- * that publish a model publish it on some events and not others, and Claude
- * publishes it on two (`SessionStart`, and each switch since #2363). Reading
- * `getLastAgentEvent()?.model` would therefore answer null for almost every
- * moment of almost every session.
- *
- * Deliberately **not** bounded by {@link STRUCTURED_STATE_MAX_AGE_MS}, unlike
- * every other reader in this module. That bound exists because a *status* that
- * nothing has refreshed is a claim about right now that may have expired — a
- * lost `Stop` leaving the layer asserting `running` forever. A model is not that
- * kind of claim: an eight-hour turn is on the same model at the end as at the
- * start, and expiring it would blank the display on precisely the long-running
- * sessions this is most useful for. What *is* honoured is identity: a new
- * generation or a discarded session drops the value, because the process that
- * reported it is gone. See {@link beginAgentEventGeneration} /
- * {@link discardAgentEventState}.
- *
- * In-memory only — nothing is written to `session_states`. After a server
- * restart codex and antigravity repopulate on their next event; Claude stays
- * null until its next `SessionStart`, a gap Phase 2 (#1784) closes from the
- * terminal frame.
- */
-function getLastKnownAgentModel(worktreeId, cliToolId, instanceId) {
-    return lastAgentModel.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
-}
-/**
- * Latch the model the agent named for itself outside an agent event
- * (Issue #2964).
- *
- * The hook channel's latch — the one {@link recordAgentEvent} writes from
- * `record.model` — for a source whose model arrives on something that is not
- * one of the seven event words. OpenCode V2 is that source: its `session.*`
- * frames carry no model, and the model it actually answered with is read off
- * the assistant messages of `GET /api/session/{id}/message` after the turn.
- *
- * Latch, never clear ({@link latchAgentModel}'s rule), and judged for a change
- * exactly as a hook-borne model is, so #2357's broadcast and push fire for it.
- *
- * @param model - The model name, or null/empty to leave the latch alone
- */
-function recordAgentReportedModel(worktreeId, cliToolId, instanceId, model, at = Date.now()) {
-    if (typeof model !== 'string' || model === '')
-        return;
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    lastAgentModel.set(key, model.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH));
-    lastAgentModelAt.set(key, at);
-    observeAgentModel(worktreeId, cliToolId, instanceId, 'hook', at);
-}
-/**
- * Latch what a terminal capture showed for this instance (Issue #1784).
- *
- * Called from the status-detection poll with the text that poll already
- * captured — no `capture-pane` is issued for this, so the feature costs nothing
- * in tmux round-trips.
- *
- * **Each half latches independently.** A Codex footer carries a model on every
- * frame but an effort only on some formats; a Claude banner carries both and
- * then scrolls away entirely. Writing `{model, effort}` wholesale would let the
- * frame that stopped showing one of them blank a value the other frame proved.
- * Nothing is ever written as null: absent means "no frame has ever shown this",
- * which is the honest state for gemini/copilot and for any session whose chrome
- * this module has no rule for.
- *
- * **The one exception is an effort the frame shows but cannot name** (Issue
- * #2835, `info.effortUnreadable`). A codex bar that draws `default` or a
- * model-defined value where `xhigh` used to be is not "not showing" the effort
- * — it is showing a different one. Keeping `xhigh` would publish a value the
- * session is no longer running at, so the effort half is dropped to null and
- * the model half latches as usual.
- *
- * @param info - {@link import('../../lib/detection/model-info-extractor').extractModelInfo}'s answer
- */
-function recordCapturedModelInfo(worktreeId, cliToolId, instanceId, info, at = Date.now()) {
-    if (!info.model && !info.effort)
-        return;
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const previous = capturedModelInfo.get(key);
-    const model = info.model ? info.model.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH) : (previous?.model ?? null);
-    capturedModelInfo.set(key, {
-        model,
-        effort: info.effortUnreadable ? null : (info.effort ?? previous?.effort ?? null),
-        // Issue #2361: the change stamp moves only when the model half takes a
-        // different value. A banner re-read on every poll keeps the stamp where the
-        // first sighting put it, so it never out-dates a hook by mere repetition.
-        modelChangedAt: model === null
-            ? null
-            : model === (previous?.model ?? null)
-                ? (previous?.modelChangedAt ?? at)
-                : at,
-    });
-    // Issue #2357: an effort-only frame leaves the model half where it was, so
-    // there is nothing to judge; a frame that named a model is the screen's
-    // report and is compared against what this instance was last seen on.
-    if (info.model)
-        observeAgentModel(worktreeId, cliToolId, instanceId, 'frame', at);
-}
-/**
- * The last model/effort a terminal capture showed, both halves possibly null.
- *
- * The raw scraped value, before precedence is applied — {@link
- * getResolvedAgentModelInfo} is what callers publishing to the UI or the API
- * want. Exported for the tests and for anything that needs to tell "the screen
- * said" apart from "the agent said".
- */
-function getLastCapturedModelInfo(worktreeId, cliToolId, instanceId) {
-    const record = capturedModelInfo.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
-    return { model: record?.model ?? null, effort: record?.effort ?? null };
-}
-/**
- * The model and reasoning effort to publish for this instance (Issue #1784).
- *
- * The single answer both surfaces should read: it folds the hook channel
- * (#1783) together with the screen under the precedence documented on
- * {@link mergeModelInfo} — hooks win for the model, the screen is the only
- * source of effort for codex/claude, and antigravity's effort is derived from
- * the id it reports rather than from its (renderer-truncated) status bar —
- * with the one exception {@link resolveAgentModel} documents (Issue #2361): a
- * claude frame that started naming a different model after the hook last
- * spoke is the newer statement, and wins.
- *
- * Both halves may be null, and routinely are: no tool publishes an effort over
- * hooks, and most tools publish neither. Callers omit the key rather than
- * emitting null — see `CliToolSessionStatus`.
- */
-function getResolvedAgentModelInfo(worktreeId, cliToolId, instanceId) {
-    return resolveAgentModel((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), cliToolId).info;
-}
-/**
- * Tools whose hook channel may name the model at session start and never again
- * (Issue #2361).
- *
- * For these, a frame that starts naming a DIFFERENT model after the hook last
- * spoke may be the only report of a mid-session switch there is, and it
- * overtakes the hook in {@link resolveAgentModel}. For every other tool the
- * rule stays #1784's — hooks win — because their hook channel re-reports the
- * model on later events (codex and antigravity on every one, opencode on every
- * `message.updated`), so a switch reaches the hook latch by itself and a frame
- * that disagrees with a hook that is still re-affirming its value is a
- * misread, not news.
- *
- * Measured on claude 2.1.263 for #2361: `SessionStart` alone carried `model`
- * among the events then registered; `/model`, `/fast` and `/effort` fired none
- * of them; the `SessionStart` that `/clear` emits carries no `model`.
- *
- * Issue #2363 registers `PostModelSwitch`, so on 2.1.263 and later the hook
- * DOES re-report every `/model` and `/fast` that changes the model, in the
- * `SessionStart` spelling (`claude-sonnet-5`, `claude-opus-5[1m]`). Claude
- * stays on this list all the same, as the **fallback** rather than the rule,
- * and the two cases the rule exists for were weighed against each other:
- *
- *  - *The hook re-reports.* The switch lands here as a hook write, stamping
- *    {@link lastAgentModelAt}; the pane re-reads the rewritten banner or the
- *    confirmation line moments later and names the same model in its label
- *    spelling, which {@link isSameAgentModelName} (cross-channel) folds into
- *    the hook's exact id. The frame does not overtake, the hook's id is what
- *    is published, and the edge fires once. Nothing in this rule had to change
- *    for that — it was written to defer to a hook that re-affirms.
- *  - *The hook does not arrive.* A claude older than the hook, a session
- *    launched without injection (`CM_AGENT_HOOKS_INJECT=0`, a hand-written
- *    `--settings`), a delivery lost to a wedged server or the 3 s
- *    de-duplication window: the latch is stale, the frame is the only channel
- *    that heard the switch, and this rule is what publishes it. Removing the
- *    tool from this set would take that back to the #2361 symptom — a stale
- *    id shown with no edge — on precisely the sessions that have no other way
- *    of reporting.
- *
- * The price of keeping it is the case #2361 already carried: a frame that
- * starts showing a stale confirmation line AFTER the hook spoke (the banner
- * scrolls away, an older `Set model to …` row becomes the fallback the
- * extractor reads) overtakes a hook that was right. That was possible before
- * #2363 — with a staler hook value underneath — and is no wider now; a switch
- * whose confirmation line the extractor does read leaves the newer row on the
- * pane, so the stale row is reachable only after a `/fast` or an automatic
- * fallback, and only until the next `/model` line or hook.
- */
-const FRAME_OVERTAKES_HOOK_MODEL_TOOLS = new Set(['claude']);
-/**
- * The merged model/effort for one instance, and which channel the model half
- * came from (Issue #2361).
- *
- * {@link mergeModelInfo}'s precedence — hooks win the model — with one
- * exception layered on top for {@link FRAME_OVERTAKES_HOOK_MODEL_TOOLS}: when
- * the frame's model half CHANGED after the hook last named a model
- * ({@link CapturedModelRecord.modelChangedAt} > {@link lastAgentModelAt}) and
- * the two do not name the same model ({@link isSameAgentModelName}, cross
- * channel), the frame's value is the newer statement and is published in the
- * hook's place. Every other case is unchanged:
- *
- *  - the frame names the same model as the hook (the startup banner after
- *    `SessionStart`, or `/model` back to the model the hook named): the hook's
- *    exact id is published, as before;
- *  - the frame's value predates the hook (a switch line still on screen when a
- *    relaunched process reports its starting model): the hook wins;
- *  - no hook has spoken: the frame is the only source, as before.
- *
- * `source` is null when neither channel has a model.
- */
-function resolveAgentModel(key, cliToolId) {
-    const hooksModel = lastAgentModel.get(key) ?? null;
-    const captured = capturedModelInfo.get(key);
-    const capturedInfo = { model: captured?.model ?? null, effort: captured?.effort ?? null };
-    // Issue #2048: the third source. Null for every tool but opencode and for
-    // every opencode session running on a model's default, so every other
-    // surface's string is byte-identical to pre-#2048.
-    const hooksEffort = reportedEffort.get(key) ?? null;
-    const frameChangedAt = captured?.modelChangedAt ?? null;
-    const frameOvertakes = hooksModel !== null &&
-        capturedInfo.model !== null &&
-        frameChangedAt !== null &&
-        FRAME_OVERTAKES_HOOK_MODEL_TOOLS.has(cliToolId) &&
-        frameChangedAt > (lastAgentModelAt.get(key) ?? 0) &&
-        !isSameAgentModelName(hooksModel, capturedInfo.model, { crossSource: true });
-    const info = (0, model_info_extractor_1.mergeModelInfo)(cliToolId, frameOvertakes ? null : hooksModel, capturedInfo, hooksEffort);
-    if (info.model === null)
-        return { info, source: null };
-    return { info, source: hooksModel !== null && !frameOvertakes ? 'hook' : 'frame' };
-}
-/**
- * Latch the effort (opencode's *variant*) the agent named for itself (#2048).
- *
- * Latch, never clear — {@link latchAgentModel}'s rule, and for the same reason:
- * `session.updated` omits `Session.model.variant` entirely when the session is
- * on a model's default, and `message.updated` omits `info.variant` on the
- * assistant message a turn opens with. Reading either absence as "the variant
- * is now unknown" would blank the display between frames of the same turn.
- *
- * Called by the tool's own reader — `lib/hooks/sources/opencode/subscription` —
- * rather than from the generic event path, because the value lives on frames
- * that map to none of the seven event words.
- *
- * @param effort - The variant name, or null/empty to leave the latch alone
- */
-function recordAgentReportedEffort(worktreeId, cliToolId, instanceId, effort) {
-    if (typeof effort !== 'string' || effort === '')
-        return;
-    reportedEffort.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), effort.slice(0, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH));
-}
-/**
- * The effort the agent last reported for this instance, or null (#2048).
- *
- * The raw latched value, before precedence — {@link getResolvedAgentModelInfo}
- * is what callers publishing to the UI or the API want. Exported so a test can
- * tell "the agent said" apart from "the screen said", the same way
- * {@link getLastCapturedModelInfo} lets it.
- */
-function getLastReportedAgentEffort(worktreeId, cliToolId, instanceId) {
-    return reportedEffort.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
-}
-/**
- * The reasoning effort this instance is running at, or null (Issue #1784).
- *
- * Convenience reader over {@link getResolvedAgentModelInfo} for callers that
- * want only the effort — `capture --json` and `instances` (#1785) among them.
- */
-function getLastKnownAgentEffort(worktreeId, cliToolId, instanceId) {
-    return getResolvedAgentModelInfo(worktreeId, cliToolId, instanceId).effort;
-}
-/**
- * How long a structured verdict is trusted after the event that produced it
- * (Issue #1723; one expression since #1930).
- *
- * The turn model owns the number now — see `provisional-turn`'s
- * {@link TURN_STALE_AFTER_MS}, which documents why it is 30 minutes. This name
- * is kept because it is what `status-evidence` and the #1723/#1725/#1903 suites
- * read, and because "the age bound on a verdict" and "how long a turn may run
- * unheard-from" really are the same fact rather than two that happen to agree.
- */
-exports.STRUCTURED_STATE_MAX_AGE_MS = provisional_turn_1.TURN_STALE_AFTER_MS;
 /**
  * Open a new generation for this instance, invalidating everything reported
  * before now (Issue #1723).
@@ -1611,43 +279,43 @@ exports.STRUCTURED_STATE_MAX_AGE_MS = provisional_turn_1.TURN_STALE_AFTER_MS;
  */
 function beginAgentEventGeneration(worktreeId, cliToolId, instanceId, at = Date.now()) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    generationStartedAt.set(key, at);
+    agent_event_turn_1.generationStartedAt.set(key, at);
     // Issue #1930: the turn the previous process was in ends with that process,
     // and the approvals it was holding go with it — they were raised against a
     // slot nobody is holding open any more. The turn record is kept, closed as
     // `closedBy: 'generation'`, so `capture --json` can say why it ended instead
     // of going quiet. The dialogs #1725 kept in a map of their own live on that
     // record now, which is what makes this one call retire both.
-    fenceTurnForNewGeneration(key, at);
+    (0, agent_event_turn_1.fenceTurnForNewGeneration)(key, at);
     // Same reasoning for the question that dialog was asking (Issue #1726).
-    askUserQuestion.delete(key);
+    agent_event_ask_user_question_1.askUserQuestion.delete(key);
     // And for "waiting for your input" (Issue #1786): a new process has not asked
     // for anything yet.
-    awaitingInstruction.delete(key);
+    agent_event_awaiting_instruction_1.awaitingInstruction.delete(key);
     // And for the model (Issue #1783): a new generation is a new agent process,
     // which may have been launched on a different model entirely. Latching across
     // one would show the *previous* process's model with nothing to correct it —
     // Claude only re-reports on `SessionStart`, which lands moments later anyway.
     // A `/clear` is deliberately not affected: it reaches `recordAgentEvent` as
     // `session_end` + `session_start`, never this function.
-    lastAgentModel.delete(key);
-    lastAgentModelAt.delete(key);
+    agent_event_model_1.lastAgentModel.delete(key);
+    agent_event_model_1.lastAgentModelAt.delete(key);
     // Issue #1784: same argument for what the screen showed. The latch exists to
     // survive the banner scrolling away *within* one process; carrying it across
     // a relaunch would show the old process's effort with no frame left that
     // could contradict it. The next poll re-reads a live footer immediately.
-    capturedModelInfo.delete(key);
+    agent_event_model_1.capturedModelInfo.delete(key);
     // Issue #2048: and the variant the agent named, for exactly #1783's reason —
     // the new process may have been launched with a different one, or with none.
-    reportedEffort.delete(key);
+    agent_event_model_1.reportedEffort.delete(key);
     // Issue #2357: and the model this instance was last seen on. The next value
     // is a new process's starting model (`null → value`), not a change from the
     // process that was replaced.
-    modelBaseline.delete(key);
+    agent_event_model_1.modelBaseline.delete(key);
     // Issue #1899: the ids claimed for this key were issued by the process that
     // has just been replaced. Unlike the time-window keys, they never expire on
     // their own, so a generation is the only thing that retires them.
-    recentEventIdentities.delete(key);
+    agent_event_dedup_1.recentEventIdentities.delete(key);
 }
 /**
  * @returns Epoch ms the current generation began, or null when no generation
@@ -1655,7 +323,7 @@ function beginAgentEventGeneration(worktreeId, cliToolId, instanceId, at = Date.
  *   server process, whose events are then judged on age alone.
  */
 function getAgentEventGenerationStartedAt(worktreeId, cliToolId, instanceId) {
-    return generationStartedAt.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+    return agent_event_turn_1.generationStartedAt.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
 }
 /**
  * Discard the structured state for one instance — the session it described is
@@ -1669,105 +337,24 @@ function getAgentEventGenerationStartedAt(worktreeId, cliToolId, instanceId) {
 function discardAgentEventState(worktreeId, cliToolId, instanceId) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     lastAgentEvent.delete(key);
-    generationStartedAt.delete(key);
+    agent_event_turn_1.generationStartedAt.delete(key);
     // Issue #1930: the turn, and with it the dialogs it was holding. Not counted
     // as an eviction — the session is gone, so there is nobody left to tell.
-    agentTurns.delete(key);
-    dropCounts.delete(key);
-    askUserQuestion.delete(key);
-    awaitingInstruction.delete(key);
+    agent_event_turn_1.agentTurns.delete(key);
+    agent_event_dedup_1.dropCounts.delete(key);
+    agent_event_ask_user_question_1.askUserQuestion.delete(key);
+    agent_event_awaiting_instruction_1.awaitingInstruction.delete(key);
     // Issue #1783: the session that was on this model no longer exists.
-    lastAgentModel.delete(key);
-    lastAgentModelAt.delete(key);
+    agent_event_model_1.lastAgentModel.delete(key);
+    agent_event_model_1.lastAgentModelAt.delete(key);
     // Issue #1784: nor does the pane its footer was read from.
-    capturedModelInfo.delete(key);
+    agent_event_model_1.capturedModelInfo.delete(key);
     // Issue #2048: nor the variant that session was running at.
-    reportedEffort.delete(key);
+    agent_event_model_1.reportedEffort.delete(key);
     // Issue #2357: nor the model it was last seen on.
-    modelBaseline.delete(key);
+    agent_event_model_1.modelBaseline.delete(key);
     // Issue #1899: nor do the frame ids that session issued.
-    recentEventIdentities.delete(key);
-}
-/**
- * The status this instance's turn implies, or null when it implies nothing
- * (Issue #1723, re-derived from the turn model in #1930).
- *
- * Null is the answer for every session on a machine where hooks never fire,
- * which is what keeps the unconfigured environment on exactly the behaviour it
- * had before #1723. It is also the answer when:
- *
- *  - the turn belongs to a previous generation, i.e. to an agent process that
- *    used to live in this pane;
- *  - nothing has been heard about it for {@link STRUCTURED_STATE_MAX_AGE_MS};
- *  - the turn ended for a reason that says nothing about whether the pane is
- *    free — `session_end` (a `/clear` mid-turn), `stale`, `generation`, or the
- *    two the *screen* closed it on (`scraper_evidence`, `resync_idle`). Only
- *    the agent's own `Stop` publishes `ready` over this channel; everything
- *    else hands the pane back to the scraper, which is the layer those closures
- *    came from in the first place;
- *  - no decision stands and the displayed event carries no verdict.
- *
- * ## The derivation, in the order it is applied
- *
- * | condition                                   | verdict                       |
- * |---------------------------------------------|-------------------------------|
- * | an unanswered decision is live              | `waiting`                     |
- * | the turn was closed by `stop`               | `ready` / `hook_stop`         |
- * | the turn was closed by anything else        | null                          |
- * | the displayed event carries a verdict       | that verdict                  |
- * | a turn is open and it does not              | `running` / `hook_prompt_submit` |
- * | otherwise                                   | null                          |
- *
- * §4 D3's `running ⟺ open turn ∧ 未裁定なし ∧ 現世代` falls out of the first,
- * fourth and fifth rows together with the generation fence — with one measured
- * exception written into the table above it: `notification(idle_prompt)`
- * publishes `ready` **without** closing the turn (#1839 caught Claude emitting
- * it 62 s into a turn that ran nothing, so it cannot be a boundary). A reader
- * that needs the boundary rather than the display reads `closedAt`.
- *
- * Whether the tmux session is alive is NOT checked here — the caller
- * (`buildCurrentOutput`) has already answered that with the CLI tool's own
- * `isRunning()` and returned early, and asking twice would mean a second tmux
- * round-trip on the hot path for an answer it is holding.
- *
- * @param now - Epoch ms; defaults to now
- */
-function getStructuredSessionState(worktreeId, cliToolId, instanceId, now = Date.now()) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const turn = effectiveTurn(key, now);
-    if (turn === null)
-        return null;
-    const display = turn.displayEvent;
-    if (now - display.at >= exports.STRUCTURED_STATE_MAX_AGE_MS)
-        return null;
-    const seen = { event: display.event, at: display.at, detail: display.detail };
-    const pending = livePendingDecisions(key, turn, now);
-    if (pending.length > 0) {
-        // The two kinds of evidence stay apart in the reason token, exactly as
-        // `structuredWaitingReason` keeps them apart for the payload: a
-        // `Notification` is proof a dialog exists, a `PermissionRequest` this
-        // server declined to decide is the prediction that one is about to.
-        const reason = pending[0].source === 'notification'
-            ? status_mapping_1.HOOK_STATUS_REASON.PERMISSION_PROMPT
-            : status_mapping_1.HOOK_STATUS_REASON.PERMISSION_REQUEST;
-        return { status: 'waiting', reason, ...seen };
-    }
-    if (turn.closedAt !== null) {
-        if (turn.closedBy === 'stop') {
-            return { status: 'ready', reason: status_mapping_1.HOOK_STATUS_REASON.STOP, ...seen };
-        }
-        return null;
-    }
-    const verdict = (0, status_mapping_1.agentEventToSessionStatus)(display.event, display.detail);
-    // A `waiting` read off the displayed event is a dialog nothing is holding any
-    // more — the ledger above is what answers that question now. The turn is
-    // still open, so the agent is still working.
-    if (verdict === null || verdict.status === 'waiting') {
-        if (turn.openedAt === null)
-            return null;
-        return { status: 'running', reason: status_mapping_1.HOOK_STATUS_REASON.PROMPT_SUBMIT, ...seen };
-    }
-    return { ...verdict, ...seen };
+    agent_event_dedup_1.recentEventIdentities.delete(key);
 }
 /**
  * How long a `permission-request`-sourced record survives without
@@ -1793,7 +380,7 @@ exports.STRUCTURED_PROMPT_PROVISIONAL_MAX_AGE_MS = provisional_turn_1.DIALOG_PEN
  */
 function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolName, at = Date.now()) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    openDecision(key, currentGeneration(key), {
+    (0, agent_event_turn_1.openDecision)(key, (0, agent_event_turn_1.currentGeneration)(key), {
         source: 'permission-request',
         at,
         message: null,
@@ -1849,7 +436,7 @@ function reportPermissionRequestPending(worktreeId, cliToolId, instanceId, toolN
  */
 function reportQuestionPending(worktreeId, cliToolId, instanceId, input, at = Date.now()) {
     const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    openDecision(key, currentGeneration(key), {
+    (0, agent_event_turn_1.openDecision)(key, (0, agent_event_turn_1.currentGeneration)(key), {
         source: 'notification',
         at,
         // The question TEXT is not the dialog's `message`: it is published as
@@ -1880,7 +467,7 @@ function reportQuestionPending(worktreeId, cliToolId, instanceId, input, at = Da
  * @param now - Epoch ms; defaults to now
  */
 function getStructuredPromptWaiting(worktreeId, cliToolId, instanceId, now = Date.now()) {
-    return getPendingDecisions(worktreeId, cliToolId, instanceId, now)[0] ?? null;
+    return (0, agent_event_turn_1.getPendingDecisions)(worktreeId, cliToolId, instanceId, now)[0] ?? null;
 }
 /**
  * Record that the scraper has seen a blocking frame while this dialog is open
@@ -1917,368 +504,33 @@ function markStructuredPromptRecorded(worktreeId, cliToolId, instanceId) {
  * for a frame the scraper has just said is clear.
  */
 function clearStructuredPromptWaiting(worktreeId, cliToolId, instanceId) {
-    releaseAllDecisions((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
-}
-/**
- * When the in-flight question is released (Issue #1726).
- *
- * | event                             | effect on the question |
- * |-----------------------------------|------------------------|
- * | `pre_tool_use(AskUserQuestion)`   | unchanged (this IS it) |
- * | `pre_tool_use(any other tool)`    | release                |
- * | `post_tool_use`                   | release                |
- * | `notification(permission_prompt)` | **unchanged**          |
- * | `notification(idle_prompt)`       | release                |
- * | `notification(other)`             | unchanged              |
- * | `stop`                            | release                |
- * | `user_prompt_submit`              | release                |
- * | `session_start` / `session_end`   | release                |
- *
- * `PostToolUse` is the precise release — "this tool call is over" — and `Stop`
- * is the backstop for a delivery that never arrives. Issue #1726's text proposed
- * `PostToolUse` and the #1721 spike recorded it as never observed, so this Issue
- * measured it directly on a live v2.1.223 session (2026-08-06):
- *
- * ```
- * 15:36:04.112  PreToolUse   AskUserQuestion
- * 15:36:28.643  PostToolUse  AskUserQuestion   <- the human answered
- * 15:36:29.992  Stop
- * ```
- *
- * It fires, 1.3 s ahead of `Stop` here — and much further ahead whenever the
- * agent keeps working after the answer, which is the case that matters: `Stop`
- * alone would leave a finished question in place for the whole rest of the turn.
- *
- * A `PostToolUse` for any other tool releases as well: the agent could not have
- * finished another tool call while this question was still on screen.
- *
- * **`Notification(permission_prompt)` keeping the question is a live
- * measurement, not a guess.** The #1721 report says the picker emits no events
- * while it is displayed (§5.6), and a first cut of this module read that as "any
- * event means the picker is gone". Driving a real v2.1.223 session through the
- * server on 2026-08-06 disproved it:
- *
- * ```
- * 15:29:18.099  PreToolUse(AskUserQuestion)
- * 15:29:18.109  PermissionRequest(AskUserQuestion) -> no decision
- * 15:29:24.128  Notification(permission_prompt)      <- picker still on screen
- * ```
- *
- * The notification lands ~6 s after the dialog is drawn (§5.5's timing exactly),
- * which is *inside* the window §5.6 was counting rather than outside it. Under
- * the first rule it deleted the question six seconds after it arrived, and the
- * options went back to being the screen's — which is the whole feature, silently
- * off, on every real session.
- *
- * `idle_prompt` still releases: the agent reporting it is sitting at the
- * composer is the agent saying no picker is in front of it. An unrecognised
- * notification type changes nothing, because nothing is known about it.
- */
-function applyAskUserQuestionTransition(key, record) {
-    switch (record.event) {
-        case 'pre_tool_use':
-            // A `PreToolUse` for anything else means the agent has moved on to another
-            // tool, so whatever question was in flight has been answered. Only
-            // reachable when the operator's own settings.json registers a wider
-            // matcher than the injected `AskUserQuestion` one — the two files are
-            // concatenated, not substituted (#1722).
-            //
-            // Issue #2100: the exemption is the whole QUESTION vocabulary, not
-            // Claude's one spelling. opencode names its question tool `question`, and
-            // it publishes a tool part for the same call: measured on 1.18.23 in an
-            // isolated HOME, `question.asked` and
-            // `message.part.updated(tool=question, status=running)` arrive **in the
-            // same millisecond**, in that order (§27.3). Under the old test the
-            // second frame read as "the agent moved on to another tool" and deleted
-            // the episode 1 ms after the ingest recorded it, which is why
-            // `pendingDecisions[].questionOptions` and `promptData.askUserQuestion`
-            // were null for every opencode question. Claude is unaffected —
-            // `AskUserQuestion` is the first member of the same list — and the cost
-            // is that a hook tool literally named `question` no longer releases the
-            // episode, which is the same name `pendingDecisionKind` already reads as
-            // "this record is a question" for every tool.
-            if (!pending_decision_kind_1.QUESTION_DECISION_TOOL_NAMES.includes(record.detail ?? '')) {
-                askUserQuestion.delete(key);
-            }
-            return;
-        case 'notification':
-            if (record.detail === 'idle_prompt')
-                askUserQuestion.delete(key);
-            return;
-        case 'post_tool_use':
-        case 'stop':
-        case 'user_prompt_submit':
-        case 'session_start':
-        case 'session_end':
-            askUserQuestion.delete(key);
-            return;
-        default:
-            // exhaustive check: a new AgentEventType must decide its transition here
-            record.event;
-            return;
-    }
-}
-/**
- * Record the `AskUserQuestion` invocation reported for one instance.
- *
- * Idempotent by construction: the same call is reported twice on every session
- * — once by `PreToolUse` and once by the `PermissionRequest` that
- * `AskUserQuestion` also raises with a byte-identical `tool_input` — and the
- * second delivery simply overwrites the first with the same content.
- *
- * @param at - Epoch ms; defaults to now
- */
-function recordAskUserQuestion(worktreeId, cliToolId, instanceId, spec, at = Date.now()) {
-    askUserQuestion.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), { at, spec });
-}
-/**
- * The `AskUserQuestion` call in flight for this instance, or null.
- *
- * Bounded exactly like {@link getStructuredSessionState}: a record from a
- * previous generation belongs to a Claude process that no longer exists, and one
- * older than {@link STRUCTURED_STATE_MAX_AGE_MS} has outlived the screen it
- * describes. There is no provisional bound — unlike a `PermissionRequest`, a
- * `PreToolUse(AskUserQuestion)` is not a prediction that a dialog *might*
- * appear: allowing the permission request does not dismiss the picker (§5.6), so
- * the picker is drawn unconditionally.
- *
- * @param now - Epoch ms; defaults to now
- */
-function getAskUserQuestion(worktreeId, cliToolId, instanceId, now = Date.now()) {
-    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-    const episode = askUserQuestion.get(key);
-    if (!episode)
-        return null;
-    const generation = generationStartedAt.get(key);
-    if (generation !== undefined && episode.at < generation)
-        return null;
-    if (now - episode.at >= exports.STRUCTURED_STATE_MAX_AGE_MS)
-        return null;
-    return episode;
-}
-/** Drop the in-flight question for one instance. */
-function clearAskUserQuestion(worktreeId, cliToolId, instanceId) {
-    askUserQuestion.delete((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
-}
-/**
- * Whether this event is a second copy of one already handled, and should be
- * dropped.
- *
- * Only events that name a `sessionId` can be deduplicated, and calling this
- * *claims* the key: a first call answers false and marks it, so the caller must
- * ask once per request and act on the answer. Events with no session id are
- * never suppressed — a caller that omits it (the #1549 relay run without a hook
- * payload, a hand-rolled `curl`) has given us nothing to tell two deliveries of
- * one turn from two genuine turns, and inventing a match there would silently
- * drop real events.
- *
- * The subtype is part of the key (Issue #1726). It has to be, now that
- * `pre_tool_use` exists: that event's subtype is the tool name, several tool
- * calls a second is ordinary, and a key without it would read a `Bash` call and
- * the `AskUserQuestion` that follows it as one delivery and drop the second. The
- * same correction applies to two `Notification`s of different types inside the
- * window, which were previously collapsed as well.
- *
- * @param at - Epoch ms; defaults to now
- * @param detail - The event's subtype, when it has one
- */
-function isDuplicateAgentEvent(worktreeId, cliToolId, instanceId, event, sessionId, at = Date.now(), detail = null) {
-    if (!sessionId)
-        return false;
-    const key = [
-        (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId),
-        event,
-        detail ?? '',
-        sessionId,
-    ].join(' ');
-    const seenAt = recentEventKeys.get(key);
-    if (seenAt !== undefined && at - seenAt < exports.AGENT_EVENT_DEDUP_WINDOW_MS) {
-        return true;
-    }
-    recentEventKeys.set(key, at);
-    pruneRecentEventKeys(at);
-    return false;
-}
-/** Drop keys past the window, then the oldest survivors if still over the cap. */
-function pruneRecentEventKeys(now) {
-    for (const [key, seenAt] of recentEventKeys) {
-        if (now - seenAt >= exports.AGENT_EVENT_DEDUP_WINDOW_MS) {
-            recentEventKeys.delete(key);
-        }
-    }
-    // Map iterates in insertion order, so the head is the oldest.
-    while (recentEventKeys.size > MAX_RECENT_EVENT_KEYS) {
-        const oldest = recentEventKeys.keys().next();
-        if (oldest.done)
-            break;
-        recentEventKeys.delete(oldest.value);
-    }
-}
-/** How many dedup keys are currently retained. Test seam for the bound above. */
-function getRecentEventKeyCount() {
-    return recentEventKeys.size;
-}
-// =============================================================================
-// Identity de-duplication (Issue #1899)
-// =============================================================================
-/**
- * Event words whose repeat is a fact about the session, not a re-delivery
- * (Issue #1899; design §4 D3 decision 2).
- *
- * These are the two words that end something, and neither of them carries an
- * id on any source measured so far. `session.idle` — opencode's `stop` — is
- * `{ "sessionID": "ses_…" }` and nothing else, which is exactly why
- * `sources/opencode/turn-gate` exists. With no id, a generic deduper has only
- * the clock, and the clock cannot tell a second turn from a second delivery:
- * #1899 measured a real `stop` 2.5 s after the previous one being dropped,
- * which leaves the newest event at `user_prompt_submit`, the instance reading
- * `running`, and `commandmate wait` blocked until the 30-minute staleness
- * bound.
- *
- * **The exemption is conditional on the source declaring an identity**, and
- * that condition is the whole safety argument. A source that declares one is a
- * source with a real deduper elsewhere — on the SSE path, `TurnGate`, which
- * arms on `session.status(busy)` and completes on the first `session.idle`
- * after arming, so the abort double-idle (19 ms apart, §5.3.2) never reaches
- * the ingest at all. Push hooks have no such gate: #1722's concatenated
- * settings really do post two `Stop`s for one turn, and
- * {@link isDuplicateAgentEvent} — which is what every hook receiver still
- * calls — is left untouched for them.
- */
-exports.LIFECYCLE_AGENT_EVENT_TYPES = ['stop', 'session_end'];
-/**
- * Whether this delivery is a second copy of one already handled (Issue #1899).
- *
- * The tool-agnostic replacement for calling {@link isDuplicateAgentEvent}
- * directly, and it branches on the source's declared capability rather than on
- * its name — flip opencode's `eventIdentity` to `null` and every case below
- * falls back to the 3-second window it used before this Issue.
- *
- * Three rules, in order:
- *
- *  1. **The frame has an id** — key on it, with no time bound at all. An id is
- *     a claim about identity that a clock cannot improve on: two approvals
- *     1 s apart are two approvals, and the same approval replayed by
- *     `resyncPending` four minutes later is still one approval. That second
- *     half is what the ingest's window was reaching for ("a frame delivered
- *     twice by a re-sync racing the live stream") and never actually covered,
- *     since a re-sync is not obliged to land within three seconds.
- *  2. **No id, but the word ends something** — never suppressed. See
- *     {@link LIFECYCLE_AGENT_EVENT_TYPES}.
- *  3. **Anything else** — the time window, unchanged. That is every push
- *     source, and the identity-declaring source's `session.created` /
- *     `session.error`, which publish no id either but are not turn boundaries.
- *
- * Calling this *claims* the key, exactly as {@link isDuplicateAgentEvent} does:
- * ask once per delivery and act on the answer.
- */
-function classifyAgentEventDelivery(delivery) {
-    const composite = (0, auto_yes_state_1.buildCompositeKey)(delivery.worktreeId, delivery.cliToolId, delivery.instanceId);
-    if (delivery.identityKind !== null) {
-        // Issue #1930 / S1: the id is the agent's, and it becomes a Map key. One
-        // that fails validation is DISCARDED — the delivery then takes the
-        // no-id path below, which is a path this function already has — rather than
-        // truncated, because a truncated id compares equal to a different id that
-        // shares its prefix and would drop a real event as a repeat.
-        const identity = delivery.identity === null ? null : (0, provisional_turn_1.acceptExternalId)(delivery.identity);
-        if (delivery.identity !== null && identity === null)
-            dropsFor(composite).idsDiscarded += 1;
-        if (identity !== null) {
-            if (claimEventIdentity(delivery, identity)) {
-                dropsFor(composite).dedupDropped.identity += 1;
-                return { duplicate: true, by: 'identity' };
-            }
-            return { duplicate: false };
-        }
-        if (exports.LIFECYCLE_AGENT_EVENT_TYPES.includes(delivery.event)) {
-            return { duplicate: false };
-        }
-    }
-    const duplicate = isDuplicateAgentEvent(delivery.worktreeId, delivery.cliToolId, delivery.instanceId, delivery.event, delivery.sessionId, delivery.at, delivery.detail);
-    if (!duplicate)
-        return { duplicate: false };
-    dropsFor(composite).dedupDropped.timeWindow += 1;
-    return { duplicate: true, by: 'time-window' };
-}
-/**
- * Claim `(event, detail, identity)` for one instance, answering whether it was
- * already claimed.
- *
- * `event` and `detail` are in the key and are not decoration: opencode asks an
- * approval under `properties.id` and answers it under `properties.requestID`
- * with **the same `per_…` value** (#1898), so a key made of the identity alone
- * would read `permission.replied` as a repeat of `permission.asked` and drop
- * the one frame that releases the dialog. The same shape covers
- * `pre_tool_use` / `post_tool_use`, which share a `callID`.
- *
- * `sessionId` is deliberately *not* in the key. An id is unique within the
- * agent that issued it, and folding in a field that is null on some deliveries
- * would let the same frame through twice.
- */
-function claimEventIdentity(delivery, identity) {
-    const composite = (0, auto_yes_state_1.buildCompositeKey)(delivery.worktreeId, delivery.cliToolId, delivery.instanceId);
-    let claimed = recentEventIdentities.get(composite);
-    if (!claimed) {
-        claimed = new Map();
-        recentEventIdentities.set(composite, claimed);
-        // Bound the instances as well as the entries per instance: the composite
-        // key is (worktree, tool, instance) and a long-lived server accumulates
-        // worktrees (DR4-009).
-        trimOldestEntries(recentEventIdentities, MAX_RECENT_EVENT_KEYS);
-    }
-    const key = [delivery.event, delivery.detail ?? '', identity].join(' ');
-    if (claimed.has(key))
-        return true;
-    claimed.set(key, delivery.at);
-    trimOldestEntries(claimed, MAX_RECENT_EVENT_KEYS);
-    return false;
-}
-/** Drop the oldest entries until the map fits. Maps iterate in insertion order. */
-function trimOldestEntries(entries, max) {
-    while (entries.size > max) {
-        const oldest = entries.keys().next();
-        if (oldest.done)
-            break;
-        entries.delete(oldest.value);
-    }
-}
-/**
- * How many identities are retained for one instance, or across all of them when
- * no instance is named. Test seam for the bound above.
- */
-function getRecentEventIdentityCount(worktreeId, cliToolId, instanceId) {
-    if (worktreeId === undefined || cliToolId === undefined) {
-        let total = 0;
-        for (const claimed of recentEventIdentities.values())
-            total += claimed.size;
-        return total;
-    }
-    return recentEventIdentities.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId))?.size ?? 0;
+    (0, agent_event_turn_1.releaseAllDecisions)((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
 }
 /** Drop every recorded event. Test seam. */
 function clearAgentStopEvents() {
     lastStopEventAt.clear();
     lastAgentEvent.clear();
-    recentEventKeys.clear();
-    recentEventIdentities.clear();
-    generationStartedAt.clear();
+    agent_event_dedup_1.recentEventKeys.clear();
+    agent_event_dedup_1.recentEventIdentities.clear();
+    agent_event_turn_1.generationStartedAt.clear();
     // Issue #1930: the turns, the dialogs they hold, and the tally of what was
     // dropped from them.
-    agentTurns.clear();
-    dropCounts.clear();
-    askUserQuestion.clear();
-    awaitingInstruction.clear();
+    agent_event_turn_1.agentTurns.clear();
+    agent_event_turn_1.reopenedTurns.clear();
+    agent_event_dedup_1.dropCounts.clear();
+    agent_event_ask_user_question_1.askUserQuestion.clear();
+    agent_event_awaiting_instruction_1.awaitingInstruction.clear();
     // Issue #1783. CI runs with `fileParallelism: false`, so every suite in the
     // repo shares this process — a model latched by one test would otherwise be
     // read by another, in file order, and only in CI.
-    lastAgentModel.clear();
-    lastAgentModelAt.clear();
+    agent_event_model_1.lastAgentModel.clear();
+    agent_event_model_1.lastAgentModelAt.clear();
     // Issue #1784: and the same for the scraped half.
-    capturedModelInfo.clear();
+    agent_event_model_1.capturedModelInfo.clear();
     // Issue #2048: and for the variant the agent reported.
-    reportedEffort.clear();
+    agent_event_model_1.reportedEffort.clear();
     // Issue #2357: and for the model each instance was last seen on. The
     // listener set is deliberately NOT cleared — a subscription belongs to the
     // process, not to a session, and a suite that armed one expects it to stay.
-    modelBaseline.clear();
+    agent_event_model_1.modelBaseline.clear();
 }