@omercnet/paseo-omp 0.2.1 → 0.3.0-next.101.1

package/server/provider/session.ts

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import type {
   ProviderConfigState,
   ProviderContent,
+  ProviderError,
   ProviderEvent,
   ProviderInput,
   ProviderPermissionResponse,
@@ -72,6 +73,7 @@ type OmpQuestionRequest = Extract<
 type Emit = (event: ProviderEvent) => void;
 const LOCAL_ONLY_SETTLE_MS = 5_000;
 const AGENT_END_STATE_TIMEOUT_MS = 2_000;
+const AGENT_END_HISTORY_TIMEOUT_MS = 2_000;
 const CONFIG_REFRESH_RETRY_BASE_MS = 250;
 const CONFIG_REFRESH_MAX_ATTEMPTS = 3;
 const USAGE_POLL_MS = 1_000;
@@ -82,6 +84,7 @@ const AGENT_END_SETTLE_MS = 5_000;
 const MAX_PROMPT_PARTS = 64;
 const MAX_PROMPT_TEXT_LENGTH = 1024 * 1024;
 const RPC_REQUEST_ID_BYTES = 36;
+const MAX_AGENT_END_CORRELATION_MESSAGES = 512;
 const MAX_TRACKED_ENTRY_IDS = 1_024;
 const MAX_UNCLAIMED_BRANCH_ENTRIES = 1_024;
 const MAX_PENDING_USERS = 256;
@@ -140,6 +143,16 @@ function applicableThinkingLevel(
   return model?.reasoning === false ? undefined : level;
 }
 
+function fixedSessionMode(modeId = "full") {
+  const mode = OMP_MODES.find((candidate) => candidate.id === modeId);
+  if (!mode) throw new OmpPublicError("OMP mode is unavailable");
+  return {
+    ...mode,
+    label: `${mode.label} (fixed for session)`,
+    description: `${mode.description} Approval mode is fixed for this session; create a new session to choose another mode.`,
+  };
+}
+
 export function ompPersistenceSessionId(input: SessionOpenInput): string | undefined {
   if (!input.persistence) return;
   if (input.persistence.version !== 1) {
@@ -215,6 +228,24 @@ type PendingUser = {
   fallbackOnFinish: boolean;
   bufferedEchoes: OmpMessage[];
 };
+type TerminalCorrelationEvidence = "fresh-native-user" | "current-assistant";
+
+type TerminalCorrelation = {
+  policy: "initial-turn" | "ordered-legacy" | "native-command";
+  evidence: Map<TerminalCorrelationEvidence, number>;
+};
+
+type TerminalCandidate = {
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>;
+  arrivalSequence: number;
+  confidence:
+    | "keyed"
+    | "initial-turn"
+    | "ordered-legacy"
+    | "native-command"
+    | "interrupted"
+    | "ambiguous";
+};
 
 type ActiveTurn = {
   turnId: string;
@@ -232,10 +263,8 @@ type ActiveTurn = {
   awaitingPermissionEvidence: boolean;
   activitySequence: number;
   acknowledged: boolean;
-  terminalOwnershipEvidence: boolean;
-  terminalOwnershipRequired: boolean;
+  terminalCorrelation: TerminalCorrelation;
   replayingBufferedEvents: boolean;
-  bufferedTerminalOwnershipEvidence: boolean;
   agentInvoked?: boolean;
   nativeRequestId?: string;
   promptAcceptedEventIndex?: number;
@@ -250,21 +279,25 @@ type ActiveTurn = {
   agentEndRetryTimer?: unknown;
   agentEndDeadlineTimer?: unknown;
   agentEndCheck?: Promise<void>;
-  terminalOwnershipTimer?: unknown;
+  ambiguousTerminalTimer?: unknown;
   terminalizing: boolean;
   terminalization?: Promise<void>;
   terminalOutcome?: TurnOutcome;
   terminalWake?: VoidDeferred;
   steerReady: VoidDeferred;
   steersInFlight: number;
-  deferredAgentEnd?: Extract<OmpRpcEvent, { type: "agent_end" }>;
+  deferredAgentEnd?: TerminalCandidate;
+  activeToolCallIds: Set<string>;
   bufferedEvents: OmpRpcEvent[];
   pendingUsers: PendingUser[];
   userEchoes: OmpMessage[];
   userCorrelationActive: boolean;
   userLookups: Set<Promise<void>>;
   completedMessageCount: number;
-  lastCompletedAssistantFailed?: boolean;
+  streamedMessageEntryIds: string[];
+  streamedMessageIdentityComplete: boolean;
+  lastCompletedAssistantOutcome?: AgentEndOutcome;
+  lastCompletedAssistantEntryId?: string;
 };
 
 type PendingAbort = {
@@ -322,7 +355,7 @@ type VoidDeferred = {
 
 type TurnOutcome = {
   state: "completed" | "failed" | "canceled";
-  error?: { message: string };
+  error?: ProviderError;
   usageSampled: boolean;
 };
 
@@ -598,30 +631,130 @@ function nativeEntryId(message: OmpMessage): string | undefined {
   return message.entryId;
 }
 
-function terminalError(
+type AgentEndOutcome = "completed" | "failed" | "canceled";
+type AssistantTerminalStatus = AgentEndOutcome | "unavailable";
+
+function assistantTerminalOutcome(
+  message: Extract<OmpMessage, { role: "assistant" }>,
+): AgentEndOutcome {
+  const stopReason = message.stopReason?.toLowerCase();
+  if (stopReason === "aborted" || stopReason === "canceled" || stopReason === "cancelled") {
+    return "canceled";
+  }
+  return stopReason === "error" || message.errorMessage ? "failed" : "completed";
+}
+
+function lastAssistantStatus(
+  messages: readonly OmpMessage[],
+  startIndex = 0,
+): AssistantTerminalStatus {
+  for (let index = messages.length - 1; index >= startIndex; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant") continue;
+    return assistantTerminalOutcome(message);
+  }
+  return "unavailable";
+}
+
+function terminalOutcome(
   event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantFailed">,
-): string | undefined {
+  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantOutcome">,
+): AgentEndOutcome | undefined {
   const messages = event.messages;
-  if (messages) {
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-      const message = messages[index];
-      if (message?.role !== "assistant") continue;
-      return message.stopReason === "error" || message.errorMessage
-        ? "OMP assistant turn failed"
-        : undefined;
-    }
+  if (
+    messages !== undefined &&
+    (event.messageCount === undefined || messages.length >= event.messageCount)
+  ) {
+    const status = lastAssistantStatus(messages);
+    return status === "unavailable" ? "completed" : status;
   }
-  if (messages && event.messageCount === undefined) return undefined;
-  if (event.messageCount === 0) return undefined;
+  if (event.messageCount === 0) return "completed";
   if (
-    turn.lastCompletedAssistantFailed !== undefined &&
-    (event.messageCount === undefined ||
-      turn.completedMessageCount + (messages?.length ?? 0) >= event.messageCount)
+    turn.lastCompletedAssistantOutcome !== undefined &&
+    (event.messageCount === undefined || turn.completedMessageCount >= event.messageCount)
   ) {
-    return turn.lastCompletedAssistantFailed ? "OMP assistant turn failed" : undefined;
+    return turn.lastCompletedAssistantOutcome;
   }
-  return "OMP agent_end omitted terminal messages; outcome is unknown";
+  return undefined;
+}
+
+function historyTerminalOutcome(
+  messages: readonly OmpMessage[],
+  declaredCount: number,
+  turn: Pick<
+    ActiveTurn,
+    | "streamedMessageEntryIds"
+    | "streamedMessageIdentityComplete"
+    | "lastCompletedAssistantOutcome"
+    | "lastCompletedAssistantEntryId"
+  >,
+  retainedMessages: readonly OmpMessage[],
+): AgentEndOutcome | undefined {
+  if (
+    messages.length < declaredCount ||
+    !turn.streamedMessageIdentityComplete ||
+    turn.streamedMessageEntryIds.length === 0
+  ) {
+    return undefined;
+  }
+  const startIndex = messages.length - declaredCount;
+  let historyIndex = startIndex;
+  for (const entryId of turn.streamedMessageEntryIds) {
+    while (historyIndex < messages.length) {
+      const historyMessage = messages[historyIndex];
+      if (historyMessage && nativeEntryId(historyMessage) === entryId) break;
+      historyIndex += 1;
+    }
+    if (historyIndex >= messages.length) return undefined;
+    const correlated = messages[historyIndex];
+    if (
+      entryId === turn.lastCompletedAssistantEntryId &&
+      (correlated?.role !== "assistant" ||
+        assistantTerminalOutcome(correlated) !== turn.lastCompletedAssistantOutcome)
+    )
+      return undefined;
+    historyIndex += 1;
+  }
+  historyIndex = startIndex;
+  for (const retained of retainedMessages) {
+    const entryId = nativeEntryId(retained);
+    if (!entryId) return undefined;
+    while (historyIndex < messages.length) {
+      const historyMessage = messages[historyIndex];
+      if (historyMessage && nativeEntryId(historyMessage) === entryId) break;
+      historyIndex += 1;
+    }
+    if (historyIndex >= messages.length) return undefined;
+    const correlated = messages[historyIndex];
+    if (!correlated || correlated.role !== retained.role) return undefined;
+    if (
+      retained.role === "assistant" &&
+      correlated.role === "assistant" &&
+      assistantTerminalOutcome(retained) !== assistantTerminalOutcome(correlated)
+    )
+      return undefined;
+    historyIndex += 1;
+  }
+  const status = lastAssistantStatus(messages, startIndex);
+  return status === "unavailable" ? undefined : status;
+}
+
+function unknownTerminalOutcomeError(
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantOutcome">,
+): string {
+  const retainedMessages = event.messages?.length ?? 0;
+  const retainedStatus = event.messages ? lastAssistantStatus(event.messages) : "unavailable";
+  const lastStatus =
+    retainedStatus === "unavailable"
+      ? (turn.lastCompletedAssistantOutcome ?? "unavailable")
+      : retainedStatus;
+  return (
+    "OMP agent_end omitted terminal messages; outcome is unknown " +
+    `(declaredCount=${event.messageCount ?? "unavailable"}, ` +
+    `observedCount=${turn.completedMessageCount}, ` +
+    `retainedTerminalMessages=${retainedMessages}, lastAssistantStatus=${lastStatus})`
+  );
 }
 
 function isNativeTurnActivity(event: OmpRpcEvent): boolean {
@@ -668,7 +801,7 @@ function createActiveTurn(
   clientMessageId: string,
   text: string,
   generation: number,
-  terminalOwnershipRequired: boolean,
+  terminalPolicy: TerminalCorrelation["policy"],
   manualCompaction = false,
 ): ActiveTurn {
   return {
@@ -693,17 +826,18 @@ function createActiveTurn(
     manualCompaction,
     activitySequence: 0,
     acknowledged: false,
-    terminalOwnershipEvidence: false,
+    terminalCorrelation: { policy: terminalPolicy, evidence: new Map() },
     replayingBufferedEvents: false,
-    bufferedTerminalOwnershipEvidence: false,
-    terminalOwnershipRequired,
     steersInFlight: 0,
+    activeToolCallIds: new Set(),
     steerReady: Promise.withResolvers<void>(),
     userCorrelationActive: false,
     userLookups: new Set(),
     userEchoes: [],
     completedMessageCount: 0,
     bufferedEvents: [],
+    streamedMessageEntryIds: [],
+    streamedMessageIdentityComplete: true,
     pendingUsers: [
       {
         clientMessageId,
@@ -715,6 +849,35 @@ function createActiveTurn(
     ],
   };
 }
+function classifyTerminalCandidate(
+  turn: ActiveTurn,
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+  arrivalSequence = turn.activitySequence,
+): TerminalCandidate {
+  if (event.requestId !== undefined) return { event, confidence: "keyed", arrivalSequence };
+  if (turn.agentInvoked === false) return { event, confidence: "ambiguous", arrivalSequence };
+  if (turn.terminalCorrelation.policy === "initial-turn") {
+    return { event, confidence: "initial-turn", arrivalSequence };
+  }
+  const assistantSequence = turn.terminalCorrelation.evidence.get("current-assistant");
+  if (
+    turn.terminalCorrelation.policy === "native-command" &&
+    assistantSequence !== undefined &&
+    assistantSequence <= arrivalSequence
+  ) {
+    return { event, confidence: "native-command", arrivalSequence };
+  }
+  const userSequence = turn.terminalCorrelation.evidence.get("fresh-native-user");
+  if (
+    userSequence !== undefined &&
+    assistantSequence !== undefined &&
+    userSequence < assistantSequence &&
+    assistantSequence <= arrivalSequence
+  ) {
+    return { event, confidence: "ordered-legacy", arrivalSequence };
+  }
+  return { event, confidence: "ambiguous", arrivalSequence };
+}
 
 export class OmpProviderSession {
   readonly id: string;
@@ -731,6 +894,7 @@ export class OmpProviderSession {
   private readonly emittedEntryIds = new BoundedStringSet(MAX_TRACKED_ENTRY_IDS);
   private readonly seenEntryIds = new BoundedStringSet(MAX_TRACKED_ENTRY_IDS);
   private branchWatermarkValid = true;
+  private readonly branchEntryIds = new Set<string>();
   private readonly unclaimedBranchEntries: Array<{ entryId: string; text: string }> = [];
   private readonly scheduler: OmpTimelineScheduler;
   private readonly dataFilter: OmpPublicDataSerializer;
@@ -782,7 +946,7 @@ export class OmpProviderSession {
     private recoveryOptions: OmpRecoveryOptions,
     private readonly hostTools: OmpHostToolsBridge,
     private nativeSessionId: string,
-    nativeSessionFile: string | undefined,
+    private readonly nativeSessionFile: string | undefined,
     private readonly config: ProviderSessionConfig,
     private configState: ProviderConfigState,
     outputRedactionValues: readonly string[],
@@ -813,6 +977,7 @@ export class OmpProviderSession {
       scheduler,
       outputRedactionValues,
       capabilities.includes("session.revert.conversation"),
+      capabilities.includes("timeline.plugin"),
       hostTools.labels,
     );
     this.subsessions = capabilities.includes("session.subsession")
@@ -825,6 +990,7 @@ export class OmpProviderSession {
           scheduler,
           () => this.resumeDeferredAgentEnd(),
           outputRedactionValues,
+          capabilities.includes("timeline.plugin"),
         )
       : null;
     this.bindRuntime(runtime);
@@ -832,6 +998,13 @@ export class OmpProviderSession {
   get persistenceSessionId(): string | undefined {
     return this.persistSession ? this.nativeSessionId : undefined;
   }
+  async openPaseoBrowser(url: string): Promise<void> {
+    if (this.closed) throw new OmpPublicError("The OMP session is closed");
+    await this.hostTools.openPaseoBrowser(url);
+  }
+  setBrowserAuthorizationIssuer(issue: ((url: string) => string | undefined) | null): void {
+    this.projector.setBrowserAuthorizationIssuer(issue);
+  }
 
   private readonly imageMaterializer = new OmpImageMaterializer();
   static async open(
@@ -976,10 +1149,12 @@ export class OmpProviderSession {
       }
       const configState: ProviderConfigState = {
         ...(state.model ? { model: ompModelId(state.model) } : {}),
-        mode: normalizedConfig.mode,
+        mode: normalizedConfig.mode ?? "full",
         ...(committedThinkingLevel ? { thinkingOption: committedThinkingLevel } : {}),
         models,
-        modes: OMP_MODES,
+        // OMP fixes approval mode at process launch. Publish only the selected mode so
+        // Paseo shows the security state without offering unsupported transitions.
+        modes: [fixedSessionMode(normalizedConfig.mode)],
         thinkingOptions,
         settings: [],
       };
@@ -1093,7 +1268,7 @@ export class OmpProviderSession {
       ...(this.config.title ? { title: this.dataFilter.text(this.config.title, 256) } : {}),
     });
     this.emit({ type: "session.config", sessionId: this.id, config: this.configState });
-    if (this.replayHistoryOnOpen) await this.replayHistory();
+    if (this.replayHistoryOnOpen) await this.replayHistory(true);
     this.publishCommands(this.commandCatalog);
     this.emit({ type: "session.ready", requestId, sessionId: this.id });
     this.readyPublished = true;
@@ -1383,7 +1558,7 @@ export class OmpProviderSession {
     });
   }
 
-  private async replayHistory(): Promise<void> {
+  private async replayHistory(preferPersistedTranscript = false): Promise<void> {
     if (!this.runtime.canReplayHistory) {
       throw new OmpPublicError("OMP session history cannot be replayed safely");
     }
@@ -1397,19 +1572,60 @@ export class OmpProviderSession {
       this.replayTimeoutMs,
     );
     try {
-      const messages = await waitForReplay(this.runtime.getMessages(), replay.signal);
-      replay.signal.throwIfAborted();
-      if (messages.length > MAX_REPLAY_MESSAGES) {
-        throw new OmpPublicError("OMP session history exceeds replay limits");
+      let messages: OmpMessage[] | undefined;
+      // OMP's RPC history is model context, which excludes failed/aborted turns. On initial
+      // resume/import prefer the already authorized journal; rewinds still use the runtime's
+      // in-memory branch because an uncommitted leaf move is not represented by file order.
+      if (
+        preferPersistedTranscript &&
+        this.nativeSessionFile &&
+        this.runtimeFactory.readPersistedSessionTranscript
+      ) {
+        try {
+          const transcript = await waitForReplay(
+            this.runtimeFactory.readPersistedSessionTranscript({
+              sessionFile: this.nativeSessionFile,
+              sessionId: this.nativeSessionId,
+              cwd: this.cwd,
+              signal: replay.signal,
+            }),
+            replay.signal,
+          );
+          messages = transcript.messages;
+          if (transcript.imageReplayWarning) {
+            this.emit({
+              type: "timeline.item",
+              sessionId: this.id,
+              item: {
+                id: "omp:replay-image-unavailable",
+                type: "notification",
+                level: "warning",
+                message: "OMP skipped one or more unavailable images while replaying this session.",
+              },
+            });
+          }
+        } catch (error) {
+          if (replay.signal.aborted) throw error;
+          this.emit({
+            type: "timeline.item",
+            sessionId: this.id,
+            item: {
+              id: "omp:replay-incomplete",
+              type: "error",
+              message:
+                "OMP could not read its complete persisted transcript; displayed history may be incomplete.",
+            },
+          });
+        }
       }
-      this.unclaimedBranchEntries.length = 0;
+      messages ??= await waitForReplay(this.runtime.getMessages(), replay.signal);
+      this.quarantineBranchEntries();
       for (const message of messages) {
         replay.signal.throwIfAborted();
         const entryId = nativeEntryId(message);
         if (entryId) this.seenEntryIds.add(entryId);
         this.projector.projectReplayMessage(message);
       }
-      this.branchWatermarkValid = true;
       this.projector.finishReplay();
       await this.subsessions?.replay(messages, this.runtime, this.runtimeFactory, replay.signal);
       replay.signal.throwIfAborted();
@@ -1705,7 +1921,7 @@ export class OmpProviderSession {
       input.prompt.clientMessageId,
       payload.text,
       this.generation,
-      this.runtimeTurnCompleted,
+      this.runtimeTurnCompleted ? "ordered-legacy" : "initial-turn",
       slashCommandName(payload.text) === "compact",
     );
     this.activeTurn = turn;
@@ -1741,9 +1957,32 @@ export class OmpProviderSession {
         }, COMPACTION_MAX_WAIT_MS);
         return;
       }
-      const acknowledgement = await runtime.prompt(payload.text, payload.images, () => {
-        turn.promptAcceptedEventIndex ??= turn.bufferedEvents.length;
-      });
+      const ownershipPending = turn.pendingUsers[0];
+      if (
+        turn.terminalCorrelation.policy === "ordered-legacy" &&
+        !this.branchWatermarkValid &&
+        ownershipPending
+      ) {
+        await this.refreshBranchEntries(turn, ownershipPending);
+        if (
+          this.closed ||
+          turn.terminal ||
+          this.activeTurn !== turn ||
+          turn.generation !== this.generation
+        ) {
+          return;
+        }
+      }
+      const acknowledgement = await runtime.prompt(
+        payload.text,
+        payload.images,
+        () => {
+          turn.promptAcceptedEventIndex ??= turn.bufferedEvents.length;
+        },
+        (requestId) => {
+          turn.nativeRequestId = requestId;
+        },
+      );
       if (this.closed || turn.terminal) return;
       turn.nativeRequestId = acknowledgement.requestId;
       this.publishPromptResult(turn, { type: "turn", turnId: turn.turnId });
@@ -1761,13 +2000,10 @@ export class OmpProviderSession {
         0,
         turn.promptAcceptedEventIndex ?? bufferedEvents.length,
       );
-      for (const event of preAcceptanceEvents) this.handleTurnEvent(turn, event);
+      for (const event of preAcceptanceEvents) this.handleTurnEvent(turn, event, false);
       this.projector.acceptLiveTurn(turn.turnId);
       for (const event of bufferedEvents) this.handleTurnEvent(turn, event);
       turn.replayingBufferedEvents = false;
-      if (acknowledgement.agentInvoked === true && turn.bufferedTerminalOwnershipEvidence) {
-        this.markTerminalOwnershipEvidence(turn);
-      }
       if (
         acknowledgement.agentInvoked === false &&
         turn.agentInvoked !== true &&
@@ -1915,11 +2151,26 @@ export class OmpProviderSession {
     text: string,
     invoke: () => Promise<void>,
   ): Promise<void> {
-    const turn = createActiveTurn(clientMessageId, text, this.generation, false);
+    if (this.activeTurn) {
+      throw new OmpPublicError("OMP already has an active turn; send this message as a steer");
+    }
+    const turn = createActiveTurn(clientMessageId, text, this.generation, "native-command");
     this.activeTurn = turn;
     try {
       await invoke();
-      if (this.closed || turn.terminal || this.activeTurn !== turn) return;
+      if (this.closed || turn.terminal || this.activeTurn !== turn) {
+        if (!turn.terminal) {
+          this.publishPendingUsers(turn);
+          this.publishPromptResult(turn, {
+            type: "failed",
+            error: {
+              message: this.closed ? "OMP session is closed" : "OMP command lost turn ownership",
+            },
+          });
+          this.settleUnstartedTurn(turn);
+        }
+        return;
+      }
       this.publishPromptResult(turn, { type: "turn", turnId: turn.turnId });
       turn.starting = false;
       turn.acknowledged = true;
@@ -1930,16 +2181,13 @@ export class OmpProviderSession {
       for (const event of bufferedEvents) this.handleTurnEvent(turn, event);
       turn.replayingBufferedEvents = false;
     } catch (error) {
-      if (turn.terminal || this.activeTurn !== turn) return;
+      if (turn.terminal) return;
+      const ownsTurn = this.activeTurn === turn;
       const failure = providerError(error, "OMP command failed");
       this.publishPendingUsers(turn);
       this.publishPromptResult(turn, { type: "failed", error: failure });
-      turn.steerReady.resolve();
-      turn.terminal = true;
-      this.imageMaterializer.clear();
-      this.resolveTurnPermissions(turn.turnId);
-      this.projector.finishTurn(turn.turnId);
-      this.activeTurn = null;
+      this.settleUnstartedTurn(turn);
+      if (ownsTurn) this.imageMaterializer.clear();
     }
   }
 
@@ -2040,6 +2288,14 @@ export class OmpProviderSession {
     this.lifetime.abort(new Error("OMP provider connection closed"));
     this.unsubscribe();
     this.unsubscribe = () => {};
+    const turn = this.activeTurn;
+    if (turn && !turn.started) {
+      this.publishPromptResult(turn, {
+        type: "failed",
+        error: { message: "OMP session closed before the prompt was accepted" },
+      });
+      this.settleUnstartedTurn(turn);
+    }
   }
   async configure(input: SessionConfigureInput): Promise<void> {
     if (this.revertInFlight) {
@@ -2296,6 +2552,23 @@ export class OmpProviderSession {
     }
   }
 
+  private async readRuntimeHistoryWithTimeout(
+    runtime: OmpRuntimeSession,
+  ): Promise<OmpMessage[] | undefined> {
+    if (!runtime.canReplayHistory) return undefined;
+    const historyRequest = runtime.getMessages();
+    void historyRequest.catch(() => undefined);
+    const timeout = Promise.withResolvers<null>();
+    const timer = this.scheduler.set(() => timeout.resolve(null), AGENT_END_HISTORY_TIMEOUT_MS);
+    try {
+      return (await Promise.race([historyRequest, timeout.promise])) ?? undefined;
+    } catch {
+      return undefined;
+    } finally {
+      this.scheduler.clear(timer);
+    }
+  }
+
   private publishCommittedConfig(
     state: OmpSessionState,
     runtime: OmpRuntimeSession,
@@ -2499,12 +2772,8 @@ export class OmpProviderSession {
       });
       if (turn.started) await this.finishTurn(turn, "canceled", undefined, true, true);
       else {
-        turn.steerReady.resolve();
-        turn.terminal = true;
-        this.stopUsagePoll(turn);
+        this.settleUnstartedTurn(turn);
         this.finishCompaction("canceled");
-        this.projector.finishTurn(turn.turnId);
-        if (this.activeTurn === turn) this.activeTurn = null;
       }
     }
     this.imageMaterializer.clear();
@@ -2783,6 +3052,7 @@ export class OmpProviderSession {
         return;
       }
       turn.localOnlyDisabled = true;
+      this.cancelAmbiguousTerminal(turn);
       turn.deferredAgentEnd = undefined;
       this.acceptPendingUser(turn, pending);
       this.emit({
@@ -2905,6 +3175,13 @@ export class OmpProviderSession {
       }
       return;
     }
+    if (
+      event.type === "agent_end" &&
+      event.requestId !== undefined &&
+      event.requestId !== turn.nativeRequestId
+    ) {
+      return;
+    }
     if (turn.starting) {
       if (
         turn.bufferedEvents.length >= MAX_BUFFERED_TURN_EVENTS ||
@@ -2927,7 +3204,11 @@ export class OmpProviderSession {
     this.handleTurnEvent(turn, event);
   }
 
-  private handleTurnEvent(turn: ActiveTurn, event: OmpRpcEvent): void {
+  private handleTurnEvent(
+    turn: ActiveTurn,
+    event: OmpRpcEvent,
+    correlatesToAcceptedPrompt = true,
+  ): void {
     if (
       turn.generation !== this.generation ||
       turn.terminal ||
@@ -2936,16 +3217,32 @@ export class OmpProviderSession {
     ) {
       return;
     }
-    if (event.type === "message_end") {
+    if (
+      event.type === "agent_end" &&
+      event.requestId !== undefined &&
+      event.requestId !== turn.nativeRequestId
+    ) {
+      return;
+    }
+    if (event.type === "message_end" && correlatesToAcceptedPrompt) {
+      const entryId = nativeEntryId(event.message);
+      if (!entryId || turn.streamedMessageEntryIds.length >= MAX_AGENT_END_CORRELATION_MESSAGES) {
+        turn.streamedMessageIdentityComplete = false;
+      } else {
+        turn.streamedMessageEntryIds.push(entryId);
+      }
       turn.completedMessageCount += 1;
       if (event.message.role === "assistant") {
-        turn.lastCompletedAssistantFailed =
-          event.message.stopReason === "error" || !!event.message.errorMessage;
+        turn.lastCompletedAssistantOutcome = assistantTerminalOutcome(event.message);
+        turn.lastCompletedAssistantEntryId = entryId;
       }
     }
     if (event.type === "prompt_error") {
       if (event.id !== turn.nativeRequestId) return;
-      const error = { message: event.error };
+      const error: ProviderError = {
+        message: this.dataFilter.text(event.error, 4_096),
+        ...(event.code ? { code: this.dataFilter.text(event.code, 256) } : {}),
+      };
       this.publishPendingUsers(turn);
       void this.finishTurn(turn, "failed", error);
       return;
@@ -2953,15 +3250,19 @@ export class OmpProviderSession {
     if (event.type === "prompt_result") {
       if (!event.id || event.id !== turn.nativeRequestId) return;
       if (event.agentInvoked) {
+        // A request-keyed prompt result proves dispatch, but an unkeyed terminal still needs
+        // ordered native user and assistant evidence from this accepted prompt.
         this.markAgentEvidence(turn);
-        if (turn.replayingBufferedEvents) turn.bufferedTerminalOwnershipEvidence = true;
-        else this.markTerminalOwnershipEvidence(turn);
         return;
       }
       if (turn.localOnlyDisabled || turn.steersInFlight > 0) return;
       if (!turn.nativeActivity && !turn.awaitingPermissionEvidence) {
         turn.agentInvoked = false;
         turn.localOnlyEligible = true;
+        if (turn.deferredAgentEnd?.confidence === "ambiguous") {
+          turn.deferredAgentEnd = undefined;
+          this.cancelAmbiguousTerminal(turn);
+        }
         this.scheduleLocalOnlyCompletion(turn);
       }
       return;
@@ -3009,8 +3310,10 @@ export class OmpProviderSession {
       return;
     }
     if (event.type === "agent_end" && turn.manualCompactionPending) return;
-    if (event.type === "tool_execution_end" && event.toolName === "ask_user") {
-      this.pendingFreeformSelection = null;
+    if (event.type === "tool_execution_start") turn.activeToolCallIds.add(event.toolCallId);
+    if (event.type === "tool_execution_end") {
+      turn.activeToolCallIds.delete(event.toolCallId);
+      if (event.toolName === "ask_user") this.pendingFreeformSelection = null;
     }
     if (event.type === "tool_execution_start" || event.type === "tool_execution_end") {
       try {
@@ -3020,6 +3323,37 @@ export class OmpProviderSession {
         return;
       }
     }
+    if (event.type === "agent_end") {
+      if (event.isTerminal === false) {
+        turn.completedMessageCount = 0;
+        turn.streamedMessageEntryIds.length = 0;
+        turn.streamedMessageIdentityComplete = true;
+        turn.lastCompletedAssistantOutcome = undefined;
+        turn.lastCompletedAssistantEntryId = undefined;
+        return;
+      }
+      const candidate: TerminalCandidate = turn.interrupted
+        ? { event, confidence: "interrupted", arrivalSequence: turn.activitySequence }
+        : classifyTerminalCandidate(turn, event);
+      if (candidate.confidence === "ambiguous") {
+        this.deferAmbiguousTerminal(turn, candidate);
+        return;
+      }
+      turn.nativeActivity = true;
+      this.cancelLocalOnlyCompletion(turn);
+      if (
+        (!turn.interrupted &&
+          candidate.confidence !== "keyed" &&
+          this.hasTerminalConflict(turn, false)) ||
+        turn.steersInFlight > 0 ||
+        turn.terminalizing
+      ) {
+        turn.deferredAgentEnd = candidate;
+        return;
+      }
+      this.beginTerminalization(turn, candidate);
+      return;
+    }
     if (isNativeTurnActivity(event)) {
       turn.nativeActivity = true;
       this.cancelLocalOnlyCompletion(turn);
@@ -3036,34 +3370,13 @@ export class OmpProviderSession {
       event.message.role === "assistant"
     ) {
       turn.awaitingPermissionEvidence = false;
-    }
-    if (event.type === "agent_end") {
-      const hasAssistantEvidence =
-        event.messages?.some((message) => message.role === "assistant") ?? false;
-      if (turn.awaitingPermissionEvidence && !hasAssistantEvidence) {
-        turn.deferredAgentEnd = event;
-        return;
-      }
-      if (hasAssistantEvidence) turn.awaitingPermissionEvidence = false;
-      if (event.isTerminal === false) return;
-      if (turn.terminalizing) {
-        turn.deferredAgentEnd = event;
-        return;
+      if (correlatesToAcceptedPrompt) {
+        turn.terminalCorrelation.evidence.set("current-assistant", turn.activitySequence + 1);
       }
-      if (turn.steersInFlight > 0) {
-        turn.deferredAgentEnd = event;
-        return;
-      }
-      this.beginTerminalization(turn, event);
-      return;
     }
     if (isNativeTurnActivity(event)) this.markAgentEvidence(turn);
-    if (event.type === "message_end" && event.message.role === "user") {
-      this.markAgentEvidence(turn);
-      this.projectUserEcho(turn, event.message);
-      return;
-    }
     this.projector.project(event, turn.turnId);
+    if (event.type === "tool_execution_end") this.resumeDeferredAgentEnd();
   }
 
   private projectUserEcho(turn: ActiveTurn, message: OmpMessage): void {
@@ -3134,52 +3447,10 @@ export class OmpProviderSession {
         pending.bufferedEchoes.push(...turn.userEchoes.splice(0));
         return;
       }
-      let resolvedId = entryId ?? this.claimUnclaimedBranchEntry(pending.text);
-      if (!resolvedId) {
-        try {
-          const messages = await this.runtime.getBranchMessages();
-          if (
-            this.closed ||
-            turn.terminal ||
-            this.activeTurn !== turn ||
-            turn.pendingUsers[0] !== pending
-          ) {
-            return;
-          }
-          if (retainedBytes(messages, MAX_UNCLAIMED_BRANCH_BYTES) === Number.POSITIVE_INFINITY) {
-            this.quarantineBranchEntries();
-            return;
-          }
-          const unseen: Array<{ entryId: string; text: string }> = [];
-          for (const branchMessage of messages) {
-            if (!this.seenEntryIds.has(branchMessage.entryId)) unseen.push(branchMessage);
-          }
-          if (!this.branchWatermarkValid) {
-            this.unclaimedBranchEntries.length = 0;
-            this.branchWatermarkValid = true;
-          } else if (
-            unseen.length <= MAX_UNCLAIMED_BRANCH_ENTRIES - this.unclaimedBranchEntries.length &&
-            retainedBytes(this.unclaimedBranchEntries, MAX_UNCLAIMED_BRANCH_BYTES) +
-              retainedBytes(unseen, MAX_UNCLAIMED_BRANCH_BYTES) <=
-              MAX_UNCLAIMED_BRANCH_BYTES
-          ) {
-            this.unclaimedBranchEntries.push(...unseen);
-          } else {
-            this.quarantineBranchEntries();
-          }
-          for (const branchMessage of messages) this.seenEntryIds.add(branchMessage.entryId);
-          resolvedId = this.claimUnclaimedBranchEntry(pending.text);
-        } catch {
-          if (
-            this.closed ||
-            turn.terminal ||
-            this.activeTurn !== turn ||
-            turn.pendingUsers[0] !== pending
-          ) {
-            return;
-          }
-          this.quarantineBranchEntries();
-        }
+      const observedSequence = turn.activitySequence;
+      let resolvedId = entryId ?? this.claimUnclaimedBranchEntry(turn, pending.text);
+      if (!resolvedId && (await this.refreshBranchEntries(turn, pending))) {
+        resolvedId = this.claimUnclaimedBranchEntry(turn, pending.text);
       }
       if (
         this.closed ||
@@ -3192,18 +3463,94 @@ export class OmpProviderSession {
       turn.userEchoes.shift();
       if (!resolvedId) return;
       turn.pendingUsers.shift();
-      this.publishCorrelatedUser(turn, pending, resolvedId);
+      this.publishCorrelatedUser(turn, pending, resolvedId, observedSequence);
+    }
+  }
+  private async refreshBranchEntries(turn: ActiveTurn, pending: PendingUser): Promise<boolean> {
+    const runtime = this.runtime;
+    try {
+      const messages = await runtime.getBranchMessages();
+      if (
+        this.closed ||
+        turn.terminal ||
+        this.activeTurn !== turn ||
+        turn.pendingUsers[0] !== pending ||
+        turn.generation !== this.generation ||
+        runtime !== this.runtime
+      ) {
+        return false;
+      }
+      if (
+        messages.length > MAX_UNCLAIMED_BRANCH_ENTRIES ||
+        retainedBytes(messages, MAX_UNCLAIMED_BRANCH_BYTES) === Number.POSITIVE_INFINITY
+      ) {
+        this.quarantineBranchEntries();
+        return false;
+      }
+      const unseen: Array<{ entryId: string; text: string }> = [];
+      const snapshotIds = new Set<string>();
+      for (const message of messages) {
+        if (snapshotIds.has(message.entryId)) {
+          this.quarantineBranchEntries();
+          return false;
+        }
+        snapshotIds.add(message.entryId);
+        if (!this.branchEntryIds.has(message.entryId)) unseen.push(message);
+      }
+      if (!this.branchWatermarkValid) {
+        this.unclaimedBranchEntries.length = 0;
+        this.branchWatermarkValid = true;
+      } else if (
+        unseen.length <= MAX_UNCLAIMED_BRANCH_ENTRIES - this.unclaimedBranchEntries.length &&
+        this.branchEntryIds.size + unseen.length <= MAX_UNCLAIMED_BRANCH_ENTRIES &&
+        retainedBytes(this.unclaimedBranchEntries, MAX_UNCLAIMED_BRANCH_BYTES) +
+          retainedBytes(unseen, MAX_UNCLAIMED_BRANCH_BYTES) <=
+          MAX_UNCLAIMED_BRANCH_BYTES
+      ) {
+        this.unclaimedBranchEntries.push(...unseen);
+      } else {
+        this.quarantineBranchEntries();
+        return false;
+      }
+      for (const message of messages) {
+        this.branchEntryIds.add(message.entryId);
+        this.seenEntryIds.add(message.entryId);
+      }
+      return true;
+    } catch {
+      if (
+        !this.closed &&
+        !turn.terminal &&
+        this.activeTurn === turn &&
+        turn.pendingUsers[0] === pending &&
+        turn.generation === this.generation &&
+        runtime === this.runtime
+      ) {
+        this.quarantineBranchEntries();
+      }
+      return false;
     }
   }
 
-  private claimUnclaimedBranchEntry(text: string): string | undefined {
+  private claimUnclaimedBranchEntry(turn: ActiveTurn, text: string): string | undefined {
     const index = this.unclaimedBranchEntries.findIndex((entry) => entry.text === text);
     if (index < 0) return undefined;
+    let matches = 0;
+    let expected = 0;
+    for (const entry of this.unclaimedBranchEntries) if (entry.text === text) matches += 1;
+    for (const pending of turn.pendingUsers) {
+      if (pending.accepted && pending.text === text) expected += 1;
+    }
+    if (matches > expected) {
+      this.quarantineBranchEntries();
+      return undefined;
+    }
     return this.unclaimedBranchEntries.splice(index, 1)[0]?.entryId;
   }
 
   private quarantineBranchEntries(): void {
     this.unclaimedBranchEntries.length = 0;
+    this.branchEntryIds.clear();
     this.branchWatermarkValid = false;
   }
 
@@ -3950,23 +4297,27 @@ export class OmpProviderSession {
     return this.activeTurn?.turnId === pending.turnId && !this.activeTurn.terminal;
   }
 
-  private reevaluateDeferredPermissionTerminal(): void {
-    const turn = this.activeTurn;
-    if (!turn?.deferredAgentEnd || turn.terminal || turn.terminalizing) return;
+  private hasTerminalConflict(turn: ActiveTurn, includeChildren = true): boolean {
     const ownsTurn = (pending: PendingPermission | PendingToolPermission) =>
       pending.turnId === turn.turnId;
-    if (
+    return (
+      turn.awaitingPermissionEvidence ||
       [...this.pendingPermissions.values()].some(ownsTurn) ||
       [...this.inFlightPermissions.values()].some(ownsTurn) ||
       [...this.pendingToolPermissions.values()].some(ownsTurn) ||
-      [...this.inFlightToolPermissions.values()].some(ownsTurn)
-    ) {
-      return;
-    }
-    const hasAssistantEvidence =
-      turn.deferredAgentEnd.messages?.some((message) => message.role === "assistant") ?? false;
-    if (!hasAssistantEvidence || turn.awaitingPermissionEvidence) return;
+      [...this.inFlightToolPermissions.values()].some(ownsTurn) ||
+      turn.activeToolCallIds.size > 0 ||
+      turn.steersInFlight > 0 ||
+      (includeChildren && Boolean(this.subsessions?.hasActiveChildren()))
+    );
+  }
+
+  private reevaluateDeferredPermissionTerminal(): void {
+    const turn = this.activeTurn;
+    if (!turn?.deferredAgentEnd || turn.terminal || turn.terminalizing) return;
+    if (this.hasTerminalConflict(turn)) return;
     const deferred = turn.deferredAgentEnd;
+    if (deferred.confidence === "ambiguous") return;
     turn.deferredAgentEnd = undefined;
     this.beginTerminalization(turn, deferred);
   }
@@ -3982,12 +4333,23 @@ export class OmpProviderSession {
     return this.slashCommands.has(commandName);
   }
 
-  private publishCorrelatedUser(turn: ActiveTurn, pending: PendingUser, entryId?: string): void {
+  private publishCorrelatedUser(
+    turn: ActiveTurn,
+    pending: PendingUser,
+    entryId: string | undefined,
+    observedSequence: number,
+  ): void {
     if (entryId) {
       if (this.emittedEntryIds.has(entryId)) return;
       this.seenEntryIds.add(entryId);
       this.emittedEntryIds.add(entryId);
-      this.markTerminalOwnershipEvidence(turn);
+      turn.terminalCorrelation.evidence.set("fresh-native-user", observedSequence);
+      this.refreshAmbiguousTerminal(turn);
+      if (this.branchWatermarkValid && !this.branchEntryIds.has(entryId)) {
+        if (this.branchEntryIds.size >= MAX_UNCLAIMED_BRANCH_ENTRIES)
+          this.quarantineBranchEntries();
+        else this.branchEntryIds.add(entryId);
+      }
       const unclaimedIndex = this.unclaimedBranchEntries.findIndex(
         (entry) => entry.entryId === entryId,
       );
@@ -4002,12 +4364,7 @@ export class OmpProviderSession {
     turn.activitySequence += 1;
     turn.localOnlyEligible = false;
     this.cancelLocalOnlyCompletion(turn);
-    if (!turn.awaitingPermissionEvidence) turn.deferredAgentEnd = undefined;
-  }
-
-  private markTerminalOwnershipEvidence(turn: ActiveTurn): void {
-    turn.terminalOwnershipEvidence = true;
-    this.cancelTerminalOwnershipTimeout(turn);
+    this.refreshAmbiguousTerminal(turn);
   }
 
   private scheduleLocalOnlyCompletion(turn: ActiveTurn): void {
@@ -4033,32 +4390,68 @@ export class OmpProviderSession {
     turn.localOnlyTimer = undefined;
   }
 
-  private scheduleTerminalOwnershipTimeout(turn: ActiveTurn): void {
-    if (
-      turn.terminalOwnershipTimer !== undefined ||
-      turn.terminalOwnershipEvidence ||
-      (turn.agentInvoked === false && turn.localOnlyEligible)
-    ) {
+  private refreshAmbiguousTerminal(turn: ActiveTurn): void {
+    const candidate = turn.deferredAgentEnd;
+    if (candidate?.confidence !== "ambiguous") return;
+    const resolved = classifyTerminalCandidate(turn, candidate.event, candidate.arrivalSequence);
+    if (resolved.confidence !== "ambiguous") {
+      this.cancelAmbiguousTerminal(turn);
+      turn.deferredAgentEnd = undefined;
+      if (turn.terminalizing || this.hasTerminalConflict(turn, false)) {
+        turn.deferredAgentEnd = resolved;
+      } else {
+        this.beginTerminalization(turn, resolved);
+      }
       return;
     }
-    turn.terminalOwnershipTimer = this.scheduler.set(() => {
-      turn.terminalOwnershipTimer = undefined;
-      if (
-        this.closed ||
-        turn.terminal ||
-        this.activeTurn !== turn ||
-        turn.terminalOwnershipEvidence
-      ) {
-        return;
-      }
-      this.handleRuntimeFailure("OMP terminal ownership could not be confirmed");
+    if (turn.activitySequence > candidate.arrivalSequence) {
+      turn.deferredAgentEnd = undefined;
+      this.cancelAmbiguousTerminal(turn);
+    }
+  }
+
+  private deferAmbiguousTerminal(turn: ActiveTurn, candidate: TerminalCandidate): void {
+    if (turn.agentInvoked === false && turn.localOnlyEligible) return;
+    this.cancelAmbiguousTerminal(turn);
+    turn.deferredAgentEnd = candidate;
+    turn.ambiguousTerminalTimer = this.scheduler.set(() => {
+      turn.ambiguousTerminalTimer = undefined;
+      void this.settleAmbiguousTerminal(turn, candidate);
     }, AGENT_END_STATE_TIMEOUT_MS);
   }
 
-  private cancelTerminalOwnershipTimeout(turn: ActiveTurn): void {
-    if (turn.terminalOwnershipTimer === undefined) return;
-    this.scheduler.clear(turn.terminalOwnershipTimer);
-    turn.terminalOwnershipTimer = undefined;
+  private cancelAmbiguousTerminal(turn: ActiveTurn): void {
+    if (turn.ambiguousTerminalTimer === undefined) return;
+    this.scheduler.clear(turn.ambiguousTerminalTimer);
+    turn.ambiguousTerminalTimer = undefined;
+  }
+
+  private async settleAmbiguousTerminal(
+    turn: ActiveTurn,
+    candidate: TerminalCandidate,
+  ): Promise<void> {
+    if (
+      this.closed ||
+      turn.terminal ||
+      this.activeTurn !== turn ||
+      turn.deferredAgentEnd !== candidate
+    ) {
+      return;
+    }
+    await Promise.allSettled(turn.userLookups);
+    this.refreshAmbiguousTerminal(turn);
+    if (turn.terminal || this.activeTurn !== turn || turn.deferredAgentEnd !== candidate) return;
+    const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
+    if (turn.terminal || this.activeTurn !== turn || turn.deferredAgentEnd !== candidate) return;
+    if (!state) {
+      this.handleRuntimeFailure("OMP agent_end state could not be confirmed");
+      return;
+    }
+    turn.deferredAgentEnd = undefined;
+    if (state.isStreaming || state.isCompacting) return;
+    await this.finishTurn(turn, "failed", {
+      message: "OMP unkeyed agent_end could not be correlated to the current prompt",
+    });
   }
 
   private async completeLocalOnlyTurn(turn: ActiveTurn): Promise<void> {
@@ -4084,15 +4477,44 @@ export class OmpProviderSession {
     await this.finishTurn(turn, "completed", undefined, false, false, true);
   }
 
-  private beginTerminalization(
-    turn: ActiveTurn,
-    event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  ): void {
+  private resetAgentEndProbe(turn: ActiveTurn): void {
+    turn.agentEndPending = false;
+    turn.terminalizing = false;
+    if (turn.agentEndRetryTimer !== undefined) {
+      this.scheduler.clear(turn.agentEndRetryTimer);
+      turn.agentEndRetryTimer = undefined;
+    }
+    if (turn.agentEndDeadlineTimer !== undefined) {
+      this.scheduler.clear(turn.agentEndDeadlineTimer);
+      turn.agentEndDeadlineTimer = undefined;
+    }
+  }
+  private ignoreActiveTerminalCandidate(turn: ActiveTurn, candidate: TerminalCandidate): void {
+    const replacement =
+      turn.deferredAgentEnd && turn.deferredAgentEnd !== candidate
+        ? turn.deferredAgentEnd
+        : undefined;
+    this.resetAgentEndProbe(turn);
+    turn.deferredAgentEnd = replacement;
+    if (replacement && replacement.confidence !== "ambiguous") {
+      turn.deferredAgentEnd = undefined;
+      this.beginTerminalization(turn, replacement);
+      return;
+    }
+    this.pollUsage(turn);
+  }
+
+  private beginTerminalization(turn: ActiveTurn, candidate: TerminalCandidate): void {
     if (turn.terminal || turn.terminalizing || turn.agentEndPending || this.activeTurn !== turn) {
       return;
     }
-    if (!turn.interrupted && this.deferAgentEndForSubsessions(turn, event)) return;
+    if (!turn.interrupted && this.deferAgentEndForSubsessions(turn, candidate)) return;
     turn.agentEndPending = true;
+    if (turn.deferredAgentEnd?.confidence === "ambiguous") {
+      turn.deferredAgentEnd = undefined;
+    }
+    turn.terminalizing = true;
+    this.cancelAmbiguousTerminal(turn);
     turn.usageSampleFloor = this.usageSequence + 1;
     if (this.usageSample?.turn === turn && this.usageSample.sequence < turn.usageSampleFloor) {
       this.usageSample = null;
@@ -4101,19 +4523,22 @@ export class OmpProviderSession {
     turn.agentEndDeadlineTimer = this.scheduler.set(() => {
       turn.agentEndDeadlineTimer = undefined;
       if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
-      if (turn.userEchoObserved) {
-        this.handleRuntimeFailure("OMP agent_end state could not be confirmed");
+      if (
+        candidate.confidence === "keyed" ||
+        (candidate.confidence === "initial-turn" && !turn.userEchoObserved)
+      ) {
+        void this.completeAgentEnd(turn, candidate.event);
       } else {
-        void this.completeAgentEnd(turn, event);
+        this.handleRuntimeFailure("OMP agent_end state could not be confirmed");
       }
     }, AGENT_END_SETTLE_MS);
-    this.finishFromAgentEnd(turn, event);
+    this.finishFromAgentEnd(turn, candidate);
   }
 
   private resumeAfterFailedSteer(turn: ActiveTurn): void {
     if (turn.terminal || this.activeTurn !== turn || turn.steersInFlight > 0) return;
     const deferred = turn.deferredAgentEnd;
-    if (deferred) {
+    if (deferred && deferred.confidence !== "ambiguous" && !this.hasTerminalConflict(turn)) {
       turn.deferredAgentEnd = undefined;
       this.beginTerminalization(turn, deferred);
       return;
@@ -4122,13 +4547,11 @@ export class OmpProviderSession {
       this.scheduleLocalOnlyCompletion(turn);
     }
   }
-  private deferAgentEndForSubsessions(
-    turn: ActiveTurn,
-    event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  ): boolean {
+
+  private deferAgentEndForSubsessions(turn: ActiveTurn, candidate: TerminalCandidate): boolean {
     if (!this.subsessions?.hasActiveChildren()) return false;
     turn.terminalizing = false;
-    turn.deferredAgentEnd = event;
+    turn.deferredAgentEnd = candidate;
     void this.subsessions.reconcile(this.runtime).catch(() => {
       if (!turn.terminal && this.activeTurn === turn) {
         this.handleRuntimeFailure("OMP subagent reconciliation failed");
@@ -4139,31 +4562,22 @@ export class OmpProviderSession {
 
   private resumeDeferredAgentEnd(): void {
     const turn = this.activeTurn;
-    if (
-      !turn ||
-      turn.terminal ||
-      turn.terminalizing ||
-      turn.steersInFlight > 0 ||
-      this.subsessions?.hasActiveChildren()
-    ) {
+    if (!turn || turn.terminal || turn.terminalizing || this.hasTerminalConflict(turn)) {
       return;
     }
-    const event = turn.deferredAgentEnd;
-    if (!event) return;
+    const candidate = turn.deferredAgentEnd;
+    if (!candidate || candidate.confidence === "ambiguous") return;
     turn.deferredAgentEnd = undefined;
-    this.beginTerminalization(turn, event);
+    this.beginTerminalization(turn, candidate);
   }
 
-  private finishFromAgentEnd(
-    turn: ActiveTurn,
-    event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  ): void {
+  private finishFromAgentEnd(turn: ActiveTurn, candidate: TerminalCandidate): void {
     if (!turn.agentEndPending || turn.terminal) return;
     if (turn.agentEndCheck) {
-      turn.deferredAgentEnd = event;
+      turn.deferredAgentEnd = candidate;
       return;
     }
-    const check = this.checkAgentEndState(turn, event);
+    const check = this.checkAgentEndState(turn, candidate);
     turn.agentEndCheck = check;
     void check.finally(() => {
       if (turn.agentEndCheck !== check) return;
@@ -4175,10 +4589,7 @@ export class OmpProviderSession {
     });
   }
 
-  private async checkAgentEndState(
-    turn: ActiveTurn,
-    event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  ): Promise<void> {
+  private async checkAgentEndState(turn: ActiveTurn, candidate: TerminalCandidate): Promise<void> {
     await Promise.allSettled(turn.userLookups);
     if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
     while (turn.userEchoes.length > 0) {
@@ -4187,37 +4598,42 @@ export class OmpProviderSession {
       await Promise.allSettled(turn.userLookups);
       if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
     }
+    if (
+      !turn.interrupted &&
+      candidate.confidence !== "keyed" &&
+      this.hasTerminalConflict(turn, false)
+    ) {
+      this.resetAgentEndProbe(turn);
+      turn.deferredAgentEnd = candidate;
+      this.pollUsage(turn);
+      return;
+    }
     if (turn.interrupted) {
-      await this.completeAgentEnd(turn, event);
+      await this.completeAgentEnd(turn, candidate.event);
       return;
     }
     const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
     if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
     if (!turn.interrupted && this.subsessions?.hasActiveChildren()) {
-      turn.agentEndPending = false;
-      if (this.deferAgentEndForSubsessions(turn, event)) return;
+      this.resetAgentEndProbe(turn);
+      if (this.deferAgentEndForSubsessions(turn, candidate)) return;
+    }
+    if (
+      !turn.interrupted &&
+      candidate.confidence !== "keyed" &&
+      this.hasTerminalConflict(turn, false)
+    ) {
+      this.resetAgentEndProbe(turn);
+      turn.deferredAgentEnd = candidate;
+      this.pollUsage(turn);
+      return;
     }
     if (state) {
       if (state.isStreaming || state.isCompacting) {
-        if (!turn.terminalOwnershipEvidence && !turn.terminalOwnershipRequired) {
-          const message = "OMP agent_end arrived while the native runtime remained active";
-          this.invalidateRuntime(message);
-          await this.finishTurn(turn, "failed", { message }, true, true);
-          return;
-        }
-        turn.agentEndPending = false;
-        turn.terminalizing = false;
-        turn.deferredAgentEnd = undefined;
-        return;
-      }
-      if (!turn.terminalOwnershipEvidence && turn.terminalOwnershipRequired) {
-        turn.agentEndPending = false;
-        turn.terminalizing = false;
-        turn.deferredAgentEnd = undefined;
-        this.scheduleTerminalOwnershipTimeout(turn);
+        this.ignoreActiveTerminalCandidate(turn, candidate);
         return;
       }
-      await this.completeAgentEnd(turn, event);
+      await this.completeAgentEnd(turn, candidate.event, true);
       return;
     }
     if (turn.userEchoObserved) {
@@ -4227,7 +4643,7 @@ export class OmpProviderSession {
     if (turn.agentEndRetryTimer === undefined) {
       turn.agentEndRetryTimer = this.scheduler.set(() => {
         turn.agentEndRetryTimer = undefined;
-        this.finishFromAgentEnd(turn, event);
+        this.finishFromAgentEnd(turn, candidate);
       }, USAGE_POLL_MS);
     }
   }
@@ -4235,17 +4651,56 @@ export class OmpProviderSession {
   private async completeAgentEnd(
     turn: ActiveTurn,
     event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-    usageSampled = false,
+    providerIdle = false,
   ): Promise<void> {
     if (turn.terminal || this.activeTurn !== turn) return;
-    const error = terminalError(event, turn);
-    if (turn.interrupted) this.subsessions?.terminalize("canceled");
-    else if (error) this.subsessions?.terminalize("failed");
-    if (turn.interrupted) await this.finishTurn(turn, "canceled", undefined, usageSampled);
-    else if (error) await this.finishTurn(turn, "failed", { message: error }, usageSampled);
-    else await this.finishTurn(turn, "completed", undefined, usageSampled);
+    let outcome = turn.interrupted ? ("canceled" as const) : terminalOutcome(event, turn);
+    if (!outcome && providerIdle && event.messageCount !== undefined) {
+      const runtime = this.runtime;
+      const history = await this.readRuntimeHistoryWithTimeout(runtime);
+      if (
+        history &&
+        history.length <= MAX_REPLAY_MESSAGES &&
+        this.isCurrentRuntime(runtime, turn.generation) &&
+        !turn.terminal &&
+        !turn.interrupted &&
+        this.activeTurn === turn
+      ) {
+        const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
+        if (
+          turn.terminal ||
+          this.activeTurn !== turn ||
+          !this.isCurrentRuntime(runtime, turn.generation)
+        )
+          return;
+        if (!turn.interrupted && state && (state.isStreaming || state.isCompacting)) {
+          this.ignoreActiveTerminalCandidate(turn, {
+            event,
+            arrivalSequence: turn.activitySequence,
+            confidence: event.requestId === undefined ? "ordered-legacy" : "keyed",
+          });
+          return;
+        }
+        if (state && !state.isStreaming && !state.isCompacting) {
+          outcome = historyTerminalOutcome(history, event.messageCount, turn, event.messages ?? []);
+        }
+      }
+    }
+    if (turn.terminal || this.activeTurn !== turn) return;
+    if (turn.interrupted || outcome === "canceled") {
+      this.subsessions?.terminalize("canceled");
+      await this.finishTurn(turn, "canceled");
+      return;
+    }
+    if (outcome === "completed") {
+      await this.finishTurn(turn, "completed");
+      return;
+    }
+    const error =
+      outcome === "failed" ? "OMP assistant turn failed" : unknownTerminalOutcomeError(event, turn);
+    this.subsessions?.terminalize("failed");
+    await this.finishTurn(turn, "failed", { message: error });
   }
-
   private publishPendingUsers(turn: ActiveTurn): void {
     for (const pending of turn.pendingUsers.splice(0)) {
       for (const echo of pending.bufferedEchoes) {
@@ -4283,6 +4738,18 @@ export class OmpProviderSession {
     pending.bufferedEchoes.length = 0;
   }
 
+  private settleUnstartedTurn(turn: ActiveTurn): void {
+    if (turn.started || turn.terminal) return;
+    turn.steerReady.resolve();
+    turn.starting = false;
+    turn.terminal = true;
+    this.stopUsagePoll(turn);
+    this.cancelAmbiguousTerminal(turn);
+    this.resolveTurnPermissions(turn.turnId);
+    this.projector.finishTurn(turn.turnId);
+    if (this.activeTurn === turn) this.activeTurn = null;
+  }
+
   private publishPromptResult(
     turn: ActiveTurn,
     result: Extract<ProviderEvent, { type: "session.prompt_result" }>["result"],
@@ -4308,7 +4775,7 @@ export class OmpProviderSession {
   private finishTurn(
     turn: ActiveTurn,
     state: "completed" | "failed" | "canceled",
-    error?: { message: string },
+    error?: ProviderError,
     usageSampled = false,
     override = false,
     preserveCompactions = false,
@@ -4332,7 +4799,7 @@ export class OmpProviderSession {
     turn.manualCompactionPending = false;
     turn.agentEndPending = false;
     this.cancelLocalOnlyCompletion(turn);
-    this.cancelTerminalOwnershipTimeout(turn);
+    this.cancelAmbiguousTerminal(turn);
     this.stopUsagePoll(turn);
     if (turn.manualCompactionDeadlineTimer !== undefined) {
       this.scheduler.clear(turn.manualCompactionDeadlineTimer);