@omercnet/paseo-omp 5.1.1-next.336.1 → 5.1.1-next.339.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "5.1.1-next.336.1",
+  "version": "5.1.1-next.339.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",
@@ -64,8 +64,8 @@
     "@getpaseo/client": "0.14.0",
     "@getpaseo/plugin": "0.14.0",
     "@getpaseo/server": "0.14.0",
-    "@oh-my-pi/pi-agent-core": "18.12.6",
-    "@oh-my-pi/pi-coding-agent": "18.12.6",
+    "@oh-my-pi/pi-agent-core": "18.14.0",
+    "@oh-my-pi/pi-coding-agent": "18.14.0",
     "@tanstack/react-query": "^5.102.3",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.18",

package/server/package-version.ts

@@ -1,2 +1,2 @@
 /** Release Please keeps this bundle-safe constant aligned with package.json. */
-export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.336.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.339.1"; // x-release-please-version

package/server/provider/omp-rpc-protocol.ts

@@ -71,6 +71,8 @@ export const OMP_SESSION_EVENT_POLICIES = {
   tool_execution_end: "normalize",
   auto_compaction_start: "normalize",
   auto_compaction_end: "normalize",
+  manual_compaction_start: "normalize",
+  manual_compaction_end: "normalize",
   auto_retry_start: "normalize",
   auto_retry_end: "normalize",
   retry_fallback_applied: "normalize",
@@ -148,9 +150,15 @@ export const OMP_RPC_COMMAND_POLICIES = {
   get_logout_accounts: "unsupported",
   goal: "unsupported",
   live_mute: "unsupported",
+  live_connect: "unsupported",
   live_start: "unsupported",
   live_stop: "unsupported",
   logout: "unsupported",
+  navigate_tree: "unsupported",
+  abort_branch_summary: "unsupported",
+  set_label: "unsupported",
+  dictation_start: "unsupported",
+  dictation_stop: "unsupported",
   predict_word: "unsupported",
   predict_word_feedback: "unsupported",
   promote_queued_message: "unsupported",
@@ -254,9 +262,14 @@ export const OMP_PROTOCOL_EVENT_TYPES = [
   "todo_auto_clear",
   "auto_compaction_start",
   "auto_compaction_end",
+  "manual_compaction_start",
+  "manual_compaction_end",
   "available_commands_update",
   "notice",
   "command_output",
+  "extension_error",
+  "session_info_update",
+  "config_update",
   "extension_ui_request",
   "prompt_result",
   "host_tool_call",
@@ -403,6 +416,8 @@ function eventSchemaClassification(
     case "cache_warming_start":
     case "cache_warming_end":
     case "queue_update":
+    case "session_info_update":
+    case "config_update":
       return { reason: "configuration-event-schema", expected: "valid-configuration-event" };
     case "extension_ui_request":
       return { reason: "extension-ui-schema", expected: "valid-extension-ui-event" };
@@ -1606,6 +1621,17 @@ const OmpAgentSessionEventSchema = z.discriminatedUnion("type", [
     errorMessage: boundedString(64 * 1024).optional(),
     skipped: z.boolean().optional(),
   }),
+  z.object({
+    type: z.literal("manual_compaction_start"),
+    mode: boundedString(MAX_CONFIG_EVENT_TEXT_BYTES).optional(),
+  }),
+  z.object({
+    type: z.literal("manual_compaction_end"),
+    result: OmpCompactionResultSchema.optional(),
+    aborted: z.boolean(),
+    skipped: z.boolean().optional(),
+    errorMessage: boundedString(64 * 1024).optional(),
+  }),
   z.object({
     type: z.literal("notice"),
     id: IDENTIFIER.optional(),
@@ -1799,6 +1825,14 @@ export const OmpRuntimeEventSchema = z.discriminatedUnion("type", [
     commands: z.array(OmpAvailableCommandSchema).max(MAX_ARRAY_ITEMS),
   }),
   z.object({ type: z.literal("command_output"), text: TEXT.optional() }),
+  z.object({
+    type: z.literal("extension_error"),
+    extensionPath: boundedString(MAX_PATH_LENGTH),
+    event: NAME,
+    error: boundedString(64 * 1024),
+  }),
+  z.object({ type: z.literal("session_info_update") }),
+  z.object({ type: z.literal("config_update") }),
   OmpExtensionUiRequestSchema,
   z.object({
     type: z.literal("prompt_result"),
@@ -1997,6 +2031,7 @@ export function parseOmpHostToolAgentResult(value: unknown): OmpHostToolResult["
 export type OmpRpcEvent =
   | z.infer<typeof OmpRuntimeEventSchema>
   | { type: "prompt_error"; id: string; error: string; code?: string }
+  | { type: "session_settled" }
   | { type: "process_exit"; error: string };
 export type OmpAgentSessionEvent = z.infer<typeof OmpAgentSessionEventSchema>;
 export type OmpSubagentSnapshot = z.infer<typeof OmpSubagentsResultSchema>["subagents"][number];

package/server/provider/omp-rpc-transport.ts

@@ -1090,8 +1090,11 @@ export class OmpRpcProcess {
       });
       return;
     }
-    // Emitted once the session has no live or background work. Nothing consumes it yet.
-    if (type === "session_settled") return;
+    // Emitted when the session is quiet: nothing live, queued, or pending in the background.
+    if (type === "session_settled") {
+      this.emit({ type: "session_settled" });
+      return;
+    }
     if (type === "ready") {
       if (this.readyReceived) {
         this.recordProtocolViolation("duplicate-ready", {

package/server/provider/session-compaction.ts

@@ -7,6 +7,7 @@ import type { OmpSessionUsage } from "./session-usage";
 import type { OmpTimelineProjector } from "./timeline-projector";
 
 type Emit = (event: ProviderEvent) => void;
+export type CompactionOutcome = "completed" | "failed" | "canceled" | "skipped";
 
 export interface ActiveCompaction {
   id: string;
@@ -73,51 +74,54 @@ export class OmpSessionCompaction {
     });
   }
 
-  handleAutoEnd(
+  handleEnd(
     turn: ActiveTurn,
-    event: Extract<OmpRpcEvent, { type: "auto_compaction_end" }>,
-  ): boolean {
+    event: Extract<OmpRpcEvent, { type: "auto_compaction_end" | "manual_compaction_end" }>,
+  ): CompactionOutcome | undefined {
     if (this.discardedEnds > 0) {
       this.discardedEnds -= 1;
-      return false;
+      return undefined;
     }
     const operation = this.operation;
+    const trigger = event.type === "auto_compaction_end" ? "auto" : "manual";
     if (
-      operation?.trigger !== "auto" ||
+      operation?.trigger !== trigger ||
       operation.turnId !== turn.turnId ||
       operation.generation !== turn.generation
     ) {
-      return false;
+      return undefined;
     }
-    if (event.action !== undefined && operation.action !== event.action) {
-      this.retire("OMP emitted overlapping compactions");
-      this.discardedEnds = 1;
-      return false;
-    }
-    if (event.willRetry) {
-      operation.retrying = true;
-      return false;
-    }
-    if (operation.retrying) {
-      operation.retrying = false;
-      return false;
+    if (event.type === "auto_compaction_end") {
+      if (event.action !== undefined && operation.action !== event.action) {
+        this.retire("OMP emitted overlapping compactions");
+        this.discardedEnds = 1;
+        return undefined;
+      }
+      if (event.willRetry) {
+        operation.retrying = true;
+        return undefined;
+      }
+      if (operation.retrying) {
+        operation.retrying = false;
+        return undefined;
+      }
     }
-    const state = event.aborted
+    const state: CompactionOutcome = event.aborted
       ? "canceled"
-      : event.errorMessage
-        ? "failed"
-        : event.skipped
-          ? "skipped"
+      : event.skipped
+        ? "skipped"
+        : event.errorMessage
+          ? "failed"
           : "completed";
     this.finish(state, {
       tokensBefore: event.result?.tokensBefore ?? event.result?.preTokens,
       message: event.errorMessage,
     });
-    return true;
+    return state;
   }
 
   finish(
-    state: "completed" | "failed" | "canceled" | "skipped",
+    state: CompactionOutcome,
     options: { tokensBefore?: number | null; message?: string } = {},
   ): void {
     const operation = this.operation;

package/server/provider/session-events.ts

@@ -24,6 +24,7 @@ export function isRuntimeConfigEvent(event: OmpRpcEvent): boolean {
   return (
     event.type === "model_changed" ||
     event.type === "thinking_level_changed" ||
+    event.type === "config_update" ||
     event.type === "retry_fallback_applied" ||
     event.type === "retry_fallback_succeeded"
   );

package/server/provider/session-terminal.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import type { ProviderError } from "@getpaseo/plugin/server/provider";
 import type { OmpMessage, OmpRpcEvent } from "./omp-rpc-protocol";
+import type { CompactionOutcome } from "./session-compaction";
 
 export type PendingUser = {
   clientMessageId: string;
@@ -12,7 +13,7 @@ export type PendingUser = {
 type TerminalCorrelationEvidence = "fresh-native-user" | "current-assistant";
 
 type TerminalCorrelation = {
-  policy: "initial-turn" | "ordered-legacy" | "native-command";
+  policy: "initial-turn" | "ordered-legacy" | "native-command" | "native-run";
   evidence: Map<TerminalCorrelationEvidence, number>;
 };
 
@@ -24,6 +25,7 @@ export type TerminalCandidate = {
     | "initial-turn"
     | "ordered-legacy"
     | "native-command"
+    | "native-run"
     | "interrupted"
     | "ambiguous";
 };
@@ -55,6 +57,7 @@ export type ActiveTurn = {
   usageSampleFloor: number;
   manualCompaction: boolean;
   manualCompactionPending: boolean;
+  manualCompactionOutcome?: CompactionOutcome;
   manualCompactionDeadlineTimer?: unknown;
   agentEndPending: boolean;
   agentEndRetryTimer?: unknown;
@@ -64,11 +67,14 @@ export type ActiveTurn = {
   terminalizing: boolean;
   terminalization?: Promise<void>;
   terminalOutcome?: TurnOutcome;
+  /** Listeners may hold this turn's terminal state from here on, even if publishing threw. */
+  terminalEmitAttempted: boolean;
   operationalTerminalStage?: "failed" | "unresolved";
   terminalWake?: VoidDeferred;
   steerReady: VoidDeferred;
   steersInFlight: number;
   deferredAgentEnd?: TerminalCandidate;
+  heldAgentEnd?: HeldAgentEnd;
   activeToolCallIds: Set<string>;
   bufferedEvents: OmpRpcEvent[];
   pendingUsers: PendingUser[];
@@ -82,6 +88,38 @@ export type ActiveTurn = {
   lastCompletedAssistantEntryId?: string;
 };
 
+type RunEvidence = Pick<
+  ActiveTurn,
+  | "completedMessageCount"
+  | "streamedMessageEntryIds"
+  | "streamedMessageIdentityComplete"
+  | "lastCompletedAssistantOutcome"
+  | "lastCompletedAssistantEntryId"
+>;
+
+/** A run that ended with `isTerminal: false`, kept until another run starts or OMP settles. */
+export type HeldAgentEnd = {
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>;
+  arrivalSequence: number;
+  evidence: RunEvidence;
+};
+
+/** Hands over the evidence of the run that just ended and starts the next run's evidence empty. */
+export function takeRunEvidence(turn: ActiveTurn): RunEvidence {
+  const evidence: RunEvidence = {
+    completedMessageCount: turn.completedMessageCount,
+    streamedMessageEntryIds: turn.streamedMessageEntryIds.splice(0),
+    streamedMessageIdentityComplete: turn.streamedMessageIdentityComplete,
+    lastCompletedAssistantOutcome: turn.lastCompletedAssistantOutcome,
+    lastCompletedAssistantEntryId: turn.lastCompletedAssistantEntryId,
+  };
+  turn.completedMessageCount = 0;
+  turn.streamedMessageIdentityComplete = true;
+  turn.lastCompletedAssistantOutcome = undefined;
+  turn.lastCompletedAssistantEntryId = undefined;
+  return evidence;
+}
+
 export type VoidDeferred = {
   promise: Promise<void>;
   resolve(value?: void | PromiseLike<void>): void;
@@ -249,6 +287,7 @@ export function createActiveTurn(
     usageSampleFloor: 0,
     agentEndPending: false,
     terminalizing: false,
+    terminalEmitAttempted: false,
     manualCompactionPending: manualCompaction,
     manualCompaction,
     activitySequence: 0,
@@ -276,6 +315,15 @@ export function createActiveTurn(
     ],
   };
 }
+/** A run OMP started without a client prompt: an extension, goal, or background wake. */
+export function createNativeRunTurn(generation: number): ActiveTurn {
+  return {
+    ...createActiveTurn("", "", generation, "native-run"),
+    promptResultEmitted: true,
+    pendingUsers: [],
+  };
+}
+
 export function classifyTerminalCandidate(
   turn: ActiveTurn,
   event: Extract<OmpRpcEvent, { type: "agent_end" }>,
@@ -286,6 +334,9 @@ export function classifyTerminalCandidate(
   if (turn.terminalCorrelation.policy === "initial-turn") {
     return { event, confidence: "initial-turn", arrivalSequence };
   }
+  if (turn.terminalCorrelation.policy === "native-run") {
+    return { event, confidence: "native-run", arrivalSequence };
+  }
   const assistantSequence = turn.terminalCorrelation.evidence.get("current-assistant");
   if (
     turn.terminalCorrelation.policy === "native-command" &&

package/server/provider/session.ts

@@ -73,10 +73,13 @@ import {
   assistantTerminalOutcome,
   classifyTerminalCandidate,
   createActiveTurn,
+  createNativeRunTurn,
+  type HeldAgentEnd,
   historyTerminalOutcome,
   nativeEntryId,
   type PendingUser,
   type TerminalCandidate,
+  takeRunEvidence,
   terminalOutcome,
   unknownTerminalOutcomeError,
 } from "./session-terminal";
@@ -330,6 +333,8 @@ export class OmpProviderSession implements OmpOpenedSession {
   private configRevision = 0;
   private recoveryUsesNativeConfig = false;
   private activeAbort: PendingAbort | null = null;
+  /** Frames of a run that started while the previous terminal was being confirmed or published. */
+  private runStartBacklog: OmpRpcEvent[] | null = null;
   private readonly usage: OmpSessionUsage;
   private readonly compaction: OmpSessionCompaction;
   private revertInFlight = false;
@@ -1458,33 +1463,46 @@ export class OmpProviderSession implements OmpOpenedSession {
     } catch (error) {
       if (this.closed || this.runtimeDead || turn.generation !== this.generation) return;
       turn.manualCompactionPending = false;
+      // OMP 18.13.3+ reports the outcome in manual_compaction_end before rejecting `compact`.
+      const outcome = turn.manualCompactionOutcome;
+      if (outcome === "skipped") {
+        await this.finishTurn(turn, turn.interrupted ? "canceled" : "completed");
+        return;
+      }
       const raw = providerError(error, "OMP compaction failed");
       const failure = { message: this.dataFilter.text(raw.message, 4_096) };
-      const state = turn.interrupted ? "canceled" : "failed";
+      const state = turn.interrupted || outcome === "canceled" ? "canceled" : "failed";
       this.compaction.finish(state, { message: failure.message });
       await this.finishTurn(turn, state, state === "failed" ? failure : undefined, true, true);
     }
   }
 
   async canStopRuntime(): Promise<boolean> {
-    const hasLocalWork =
+    if (this.hasLocalRuntimeWork()) return false;
+    const state = await this.runtime.getState();
+    // OMP can start a run of its own while the state lookup is pending.
+    if (this.hasLocalRuntimeWork()) return false;
+    // OMP builds that predate these fields report neither, which keeps the runtime alive.
+    return (
+      state.isSettled === true &&
+      state.hasPendingAsyncWork === false &&
+      !state.isStreaming &&
+      !state.isCompacting
+    );
+  }
+
+  private hasLocalRuntimeWork(): boolean {
+    return (
       this.closed ||
       this.runtimeDead !== null ||
       this.recoveryPromise !== null ||
       this.activeTurn !== null ||
+      this.runStartBacklog !== null ||
       this.activeAbort !== null ||
       this.revertInFlight ||
       this.configMutationInFlight ||
       this.permissions.hasPending() ||
-      Boolean(this.subsessions?.hasActiveChildren());
-    if (hasLocalWork) return false;
-    const state = await this.runtime.getState();
-    // OMP builds that predate these fields report neither, which keeps the runtime alive.
-    return (
-      state.isSettled === true &&
-      state.hasPendingAsyncWork === false &&
-      !state.isStreaming &&
-      !state.isCompacting
+      Boolean(this.subsessions?.hasActiveChildren())
     );
   }
 
@@ -2259,6 +2277,17 @@ export class OmpProviderSession implements OmpOpenedSession {
 
   private handleRuntimeEvent(event: OmpRpcEvent): void {
     if (this.closed) return;
+    if (this.runStartBacklog) {
+      this.bufferEvent(this.runStartBacklog, event);
+      return;
+    }
+    // A run that starts while the previous terminal is being confirmed or published waits for it,
+    // so neither the old turn's outcome nor the new run's frames are lost.
+    const pendingTerminal = this.activeTurn?.terminalization ?? this.activeTurn?.agentEndCheck;
+    if (event.type === "agent_start" && pendingTerminal) {
+      this.deferRunStart(event, pendingTerminal);
+      return;
+    }
     if (
       event.type === "subagent_lifecycle" ||
       event.type === "subagent_progress" ||
@@ -2336,7 +2365,8 @@ export class OmpProviderSession implements OmpOpenedSession {
       event.type === "ttsr_triggered" ||
       event.type === "cache_warming_start" ||
       event.type === "cache_warming_end" ||
-      event.type === "queue_update"
+      event.type === "queue_update" ||
+      event.type === "session_info_update"
     ) {
       return;
     }
@@ -2353,7 +2383,8 @@ export class OmpProviderSession implements OmpOpenedSession {
       event.type === "auto_retry_end" ||
       event.type === "compaction_start" ||
       event.type === "compaction_end" ||
-      event.type === "advisor_yielded"
+      event.type === "advisor_yielded" ||
+      event.type === "extension_error"
     ) {
       this.projector.projectPassive(event);
       return;
@@ -2367,13 +2398,23 @@ export class OmpProviderSession implements OmpOpenedSession {
       this.scheduleCommittedConfigRefresh();
       return;
     }
-    if (event.type === "model_changed" || event.type === "thinking_level_changed") {
+    if (
+      event.type === "model_changed" ||
+      event.type === "thinking_level_changed" ||
+      event.type === "config_update"
+    ) {
       this.scheduleCommittedConfigRefresh();
       return;
     }
-    const turn = this.activeTurn;
+    const turn =
+      this.activeTurn ?? (event.type === "agent_start" ? this.openNativeRunTurn() : null);
     if (!turn) {
-      if (event.type === "auto_compaction_start" || event.type === "auto_compaction_end") {
+      if (
+        event.type === "auto_compaction_start" ||
+        event.type === "auto_compaction_end" ||
+        event.type === "manual_compaction_start" ||
+        event.type === "manual_compaction_end"
+      ) {
         this.projector.projectPassive(event);
       }
       return;
@@ -2386,27 +2427,69 @@ export class OmpProviderSession implements OmpOpenedSession {
       return;
     }
     if (turn.starting) {
-      if (
-        turn.bufferedEvents.length >= MAX_BUFFERED_TURN_EVENTS ||
-        retainedBytes(turn.bufferedEvents, MAX_BUFFERED_TURN_BYTES) +
-          boundedJsonBytes(
-            event,
-            MAX_BUFFERED_TURN_BYTES,
-            MAX_BUFFERED_VALUE_ITEMS,
-            MAX_BUFFERED_TURN_BYTES,
-            MAX_BUFFERED_VALUE_NODES,
-          ) >
-          MAX_BUFFERED_TURN_BYTES
-      ) {
-        this.handleRuntimeFailure();
-        return;
-      }
-      turn.bufferedEvents.push(event);
+      this.bufferEvent(turn.bufferedEvents, event);
       return;
     }
     this.handleTurnEvent(turn, event);
   }
 
+  private bufferEvent(buffer: OmpRpcEvent[], event: OmpRpcEvent): void {
+    if (
+      buffer.length >= MAX_BUFFERED_TURN_EVENTS ||
+      retainedBytes(buffer, MAX_BUFFERED_TURN_BYTES) +
+        boundedJsonBytes(
+          event,
+          MAX_BUFFERED_TURN_BYTES,
+          MAX_BUFFERED_VALUE_ITEMS,
+          MAX_BUFFERED_TURN_BYTES,
+          MAX_BUFFERED_VALUE_NODES,
+        ) >
+        MAX_BUFFERED_TURN_BYTES
+    ) {
+      this.handleRuntimeFailure();
+      return;
+    }
+    buffer.push(event);
+  }
+
+  private deferRunStart(event: OmpRpcEvent, pendingTerminal: Promise<void>): void {
+    const backlog = [event];
+    this.runStartBacklog = backlog;
+    const replay = () => {
+      if (this.runStartBacklog !== backlog) return;
+      this.runStartBacklog = null;
+      for (const buffered of backlog) this.handleRuntimeEvent(buffered);
+    };
+    void pendingTerminal.then(replay, replay);
+  }
+
+  private scheduleHeldTurnCheck(turn: ActiveTurn, held: HeldAgentEnd): void {
+    this.scheduler.set(() => this.checkHeldTurn(turn, held), USAGE_POLL_MS);
+  }
+
+  /** Released OMP does not always write `session_settled` once a held run's async work is gone. */
+  private async checkHeldTurn(turn: ActiveTurn, held: HeldAgentEnd): Promise<void> {
+    if (turn.heldAgentEnd !== held || this.activeTurn !== turn) return;
+    const state = await this.usage.boundedSnapshot(turn, FINAL_USAGE_WAIT_MS);
+    if (turn.heldAgentEnd !== held || this.activeTurn !== turn) return;
+    const settled =
+      state?.isSettled === true &&
+      state.hasPendingAsyncWork === false &&
+      !state.isStreaming &&
+      !state.isCompacting;
+    if (settled) this.handleTurnEvent(turn, { type: "session_settled" });
+    else this.scheduleHeldTurnCheck(turn, held);
+  }
+
+  private openNativeRunTurn(): ActiveTurn {
+    const turn = createNativeRunTurn(this.generation);
+    this.activeTurn = turn;
+    turn.acknowledged = true;
+    this.startTurn(turn);
+    this.projector.acceptLiveTurn(turn.turnId);
+    return turn;
+  }
+
   private handleTurnEvent(
     turn: ActiveTurn,
     event: OmpRpcEvent,
@@ -2476,10 +2559,27 @@ export class OmpProviderSession implements OmpOpenedSession {
       this.compaction.start(turn, "auto", event.action);
       return;
     }
-    if (event.type === "auto_compaction_end") {
-      if (this.compaction.handleAutoEnd(turn, event)) {
-        this.usage.schedulePoll(turn, USAGE_REFRESH_MS);
-      }
+    if (event.type === "manual_compaction_start") {
+      turn.nativeActivity = true;
+      this.cancelLocalOnlyCompletion(turn);
+      // A no-op when this turn's own `compact` call already opened the operation.
+      this.compaction.start(turn, "manual");
+      return;
+    }
+    if (event.type === "auto_compaction_end" || event.type === "manual_compaction_end") {
+      const outcome = this.compaction.handleEnd(turn, event);
+      if (outcome && turn.manualCompaction) turn.manualCompactionOutcome = outcome;
+      if (outcome) this.usage.schedulePoll(turn, USAGE_REFRESH_MS);
+      return;
+    }
+    if (event.type === "session_settled") {
+      // OMP is quiet, so the held end closes this stretch; a later run opens its own turn.
+      const held = turn.heldAgentEnd;
+      if (!held) return;
+      turn.heldAgentEnd = undefined;
+      Object.assign(turn, held.evidence);
+      // Ownership is judged as of the held end's arrival, never from evidence that came later.
+      this.acceptTerminal(turn, { ...held.event, isTerminal: true }, held.arrivalSequence);
       return;
     }
     if (event.type === "agent_end" && turn.manualCompactionPending) return;
@@ -2502,35 +2602,30 @@ export class OmpProviderSession implements OmpOpenedSession {
         return;
       }
     }
+    if (event.type === "agent_start") {
+      turn.heldAgentEnd = undefined;
+      // Evidence is per run; records OMP writes between runs belong to neither.
+      takeRunEvidence(turn);
+      if (turn.agentEndPending && !turn.interrupted) {
+        // A terminal waiting to retry its idle check is stale once another run starts.
+        this.resetAgentEndProbe(turn);
+        turn.deferredAgentEnd = undefined;
+        this.usage.poll(turn);
+      }
+    }
     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;
+        const held = {
+          event,
+          arrivalSequence: turn.activitySequence,
+          evidence: takeRunEvidence(turn),
+        };
+        turn.heldAgentEnd = held;
+        this.scheduleHeldTurnCheck(turn, held);
         return;
       }
-      this.beginTerminalization(turn, candidate);
+      turn.heldAgentEnd = undefined;
+      this.acceptTerminal(turn, event, turn.activitySequence);
       return;
     }
     if (isNativeTurnActivity(event)) {
@@ -2566,6 +2661,33 @@ export class OmpProviderSession implements OmpOpenedSession {
     if (event.type === "tool_execution_end") this.resumeDeferredAgentEnd();
   }
 
+  private acceptTerminal(
+    turn: ActiveTurn,
+    event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+    arrivalSequence: number,
+  ): void {
+    const candidate: TerminalCandidate = turn.interrupted
+      ? { event, confidence: "interrupted", arrivalSequence }
+      : classifyTerminalCandidate(turn, event, arrivalSequence);
+    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);
+  }
+
   private projectUserEcho(turn: ActiveTurn, message: OmpMessage): void {
     turn.userEchoObserved = true;
     const entryId = nativeEntryId(message);
@@ -3033,6 +3155,7 @@ export class OmpProviderSession implements OmpOpenedSession {
       if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
       if (
         candidate.confidence === "keyed" ||
+        candidate.confidence === "native-run" ||
         (candidate.confidence === "initial-turn" && !turn.userEchoObserved)
       ) {
         void this.completeAgentEnd(turn, candidate.event);
@@ -3146,14 +3269,16 @@ export class OmpProviderSession implements OmpOpenedSession {
       return;
     }
     if (state) {
-      if (state.isStreaming || state.isCompacting) {
+      // A run start buffered behind this check proves this end was the last one before it, so a
+      // streaming state belongs to that new run, not to this turn.
+      if ((state.isStreaming || state.isCompacting) && !this.runStartBacklog) {
         this.ignoreActiveTerminalCandidate(turn, candidate);
         return;
       }
       await this.completeAgentEnd(turn, candidate.event, true);
       return;
     }
-    if (turn.userEchoObserved) {
+    if (turn.userEchoObserved && candidate.confidence !== "native-run") {
       await this.cancelIndeterminateTerminal(
         turn,
         "OMP agent_end state could not be confirmed",
@@ -3389,6 +3514,7 @@ export class OmpProviderSession implements OmpOpenedSession {
         throw error;
       }
       this.unclaimedBranchEntries.length = 0;
+      turn.terminalEmitAttempted = true;
       this.emit({
         type: "session.turn",
         sessionId: this.id,
@@ -3398,17 +3524,42 @@ export class OmpProviderSession implements OmpOpenedSession {
       });
       this.runtimeTurnCompleted = true;
       if (this.activeTurn === turn) this.activeTurn = null;
-    })();
+    })().catch(() => this.failTerminalization(turn));
     turn.terminalization = terminalization;
     return terminalization;
   }
 
+  /** A turn whose terminal state could not be published must not keep owning the session. */
+  private failTerminalization(turn: ActiveTurn): void {
+    const message = "OMP turn could not be finalized";
+    turn.terminal = true;
+    if (this.activeTurn === turn) this.activeTurn = null;
+    this.recordOperationalFailure({ category: "terminal-outcome", stage: "failed" });
+    // Once the terminal emit was attempted, earlier listeners may already hold it; a second,
+    // conflicting terminal would be worse than failing the runtime alone.
+    if (!turn.terminalEmitAttempted) {
+      try {
+        this.emit({
+          type: "session.turn",
+          sessionId: this.id,
+          turnId: turn.turnId,
+          state: "failed",
+          error: { message },
+        });
+      } catch {
+        // The listener that failed may fail again; the runtime failure below still applies.
+      }
+    }
+    this.handleRuntimeFailure(message);
+  }
+
   private invalidateRuntime(
     message: string,
     compactionState: "failed" | "canceled" = "failed",
   ): void {
     this.imageMaterializer.clear();
     if (this.closed || this.runtimeDead) return;
+    this.runStartBacklog = null;
     this.compaction.resetDiscardedEnds();
     this.permissions.resolveAllPermissions();
     this.recoveryUsesNativeConfig ||=

package/server/provider/timeline-projector.ts

@@ -467,6 +467,9 @@ export class OmpTimelineProjector {
       event.type === "auto_compaction_end" ||
       event.type === "compaction_start" ||
       event.type === "compaction_end" ||
+      event.type === "manual_compaction_start" ||
+      event.type === "manual_compaction_end" ||
+      event.type === "extension_error" ||
       event.type === "advisor_yielded" ||
       event.type === "config_warnings_changed" ||
       event.type === "advisor_cost_changed" ||
@@ -743,6 +746,19 @@ export class OmpTimelineProjector {
       });
       return;
     }
+    if (event.type === "extension_error") {
+      this.noticeSequence += 1;
+      this.publish({
+        type: "notification",
+        id: `omp:extension-error:${this.noticeSequence}`,
+        level: "error",
+        message: this.dataFilter.text(
+          `OMP extension ${event.extensionPath} failed in ${event.event}: ${event.error}`,
+          64 * 1024,
+        ),
+      });
+      return;
+    }
     if (event.type === "advisor_yielded") {
       this.noticeSequence += 1;
       this.publish({
@@ -753,7 +769,11 @@ export class OmpTimelineProjector {
       });
       return;
     }
-    if (event.type === "auto_compaction_start" || event.type === "compaction_start") {
+    if (
+      event.type === "auto_compaction_start" ||
+      event.type === "compaction_start" ||
+      event.type === "manual_compaction_start"
+    ) {
       const trigger = event.type === "auto_compaction_start" ? "auto" : "manual";
       const action = event.type === "auto_compaction_start" ? event.action : undefined;
       if (this.discardedCompactionEnds > 0) {
@@ -781,7 +801,11 @@ export class OmpTimelineProjector {
       this.publish({ type: "compaction", id: slot.id, status: "loading", trigger });
       return;
     }
-    if (event.type === "auto_compaction_end" || event.type === "compaction_end") {
+    if (
+      event.type === "auto_compaction_end" ||
+      event.type === "compaction_end" ||
+      event.type === "manual_compaction_end"
+    ) {
       if (this.discardedCompactionEnds > 0) {
         this.discardedCompactionEnds -= 1;
         return;
@@ -803,7 +827,7 @@ export class OmpTimelineProjector {
         this.discardedCompactionEnds = 1;
         return;
       }
-      if (event.willRetry) {
+      if (event.type !== "manual_compaction_end" && event.willRetry) {
         slot.retrying = true;
         return;
       }
@@ -826,10 +850,9 @@ export class OmpTimelineProjector {
           type: "notification",
           id: `${slot.id}:skipped`,
           level: "warning",
-          message: "OMP compaction was skipped",
+          message: this.dataFilter.text(event.errorMessage ?? "OMP compaction was skipped", 4_096),
         });
-      }
-      if (event.aborted || event.errorMessage) {
+      } else if (event.aborted || event.errorMessage) {
         this.publish({
           type: "error",
           id: `${slot.id}:error`,