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

package/client/provider-launch-settings.tsx

@@ -8,6 +8,7 @@ import {
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Text, View } from "react-native";
 import {
+  MAX_SESSIONS_UPPER_BOUND,
   providerLaunchSettings,
   providerLaunchSettingsSchema,
 } from "../shared/provider-launch-settings";
@@ -23,6 +24,11 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
   useEffect(() => {
     setRawNames(savedNames);
   }, [savedNames]);
+  const savedMaxSessions = String(settings.values.maxSessions);
+  const [rawMaxSessions, setRawMaxSessions] = useState(() => savedMaxSessions);
+  useEffect(() => {
+    setRawMaxSessions(savedMaxSessions);
+  }, [savedMaxSessions]);
   const inheritEnv = [
     ...new Set(
       rawNames
@@ -31,7 +37,7 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
         .filter(Boolean),
     ),
   ];
-  const next = providerLaunchSettingsSchema.safeParse({ inheritEnv });
+  const next = providerLaunchSettingsSchema.safeParse({ ...settings.values, inheritEnv });
   const error = next.success
     ? null
     : (next.error.issues[0]?.message ?? "Enter valid variable names.");
@@ -39,6 +45,14 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
     if (!next.success) return;
     await settings.save(next.data, settings.revision);
   }, [next, settings]);
+  const nextMaxSessions = providerLaunchSettingsSchema.safeParse({
+    ...settings.values,
+    maxSessions: Number(rawMaxSessions.trim()),
+  });
+  const saveMaxSessions = useCallback(async () => {
+    if (!nextMaxSessions.success) return;
+    await settings.save(nextMaxSessions.data, settings.revision);
+  }, [nextMaxSessions, settings]);
 
   return (
     <View style={{ gap: 12 }}>
@@ -69,7 +83,9 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
             actionLabel="Clear"
             disabled={settings.saving || settings.values.inheritEnv.length === 0}
             onPress={async () => {
-              if (await settings.save({ inheritEnv: [] }, settings.revision)) setRawNames("");
+              if (await settings.save({ ...settings.values, inheritEnv: [] }, settings.revision)) {
+                setRawNames("");
+              }
             }}
           />
           {settings.saveError ? (
@@ -83,6 +99,34 @@ function ProviderLaunchSettingsControls({ settings }: { settings: ReadySettings
           ) : null}
         </SettingsCard>
       </SettingsSection>
+      <SettingsSection
+        title="Session limit"
+        info="Applies to all OMP Plugin agents on this host together, including idle ones."
+      >
+        <SettingsCard>
+          <SettingsInput
+            key={savedMaxSessions}
+            label="Open sessions"
+            hint="New OMP Plugin agents are refused while this many sessions are open. Archive idle agents to free sessions."
+            initialValue={savedMaxSessions}
+            onChangeText={setRawMaxSessions}
+            error={
+              nextMaxSessions.success
+                ? undefined
+                : `Enter a whole number from 1 to ${MAX_SESSIONS_UPPER_BOUND}.`
+            }
+            disabled={settings.saving}
+          />
+          <SettingsAction
+            label="Save session limit"
+            actionLabel="Save"
+            disabled={
+              settings.saving || rawMaxSessions === savedMaxSessions || !nextMaxSessions.success
+            }
+            onPress={() => void saveMaxSessions()}
+          />
+        </SettingsCard>
+      </SettingsSection>
     </View>
   );
 }

package/index.server.ts

@@ -25,6 +25,7 @@ import {
 } from "./server/provider/profile-providers";
 import { createOmpProvider } from "./server/provider/registration";
 import { OmpPublicError } from "./server/provider/security";
+import { OmpSessionLimit } from "./server/provider/session-limit";
 import { resolveGetOmpProviderHealth } from "./server/provider-diagnostics";
 import { resolveListOmpQuotas } from "./server/quota";
 import { resolveListOmpSessions } from "./server/sessions";
@@ -62,6 +63,11 @@ export default function contribute(server: PluginServerContext) {
     throw new OmpPublicError("OMP host launch settings are unavailable");
   };
   const browserAuthorizationRegistry = new OmpBrowserAuthorizationRegistry();
+  const sessionLimit = new OmpSessionLimit(async () => {
+    const current = await launchSettings.read();
+    return current.status === "ready" ? current.values.maxSessions : undefined;
+  });
+  const removeSessionLimitListener = launchSettings.subscribe(() => sessionLimit.refresh());
   const protocolViolations = new OmpProtocolViolationCollector();
   const operationalFailures = new OmpOperationalFailureCollector();
   const profiles = discoverOmpProfilesSync();
@@ -70,6 +76,7 @@ export default function contribute(server: PluginServerContext) {
     server.registerProvider(
       createProfileOmpProvider(profile, {
         browserAuthorizationRegistry,
+        sessionLimit,
         reportProtocolViolation: protocolViolations.report,
         reportOperationalFailure: operationalFailures.report,
         resolveHostInheritEnv,
@@ -104,6 +111,7 @@ export default function contribute(server: PluginServerContext) {
   server.registerProvider(
     createOmpProvider({
       browserAuthorizationRegistry,
+      sessionLimit,
       reportProtocolViolation: protocolViolations.report,
       reportOperationalFailure: operationalFailures.report,
       resolveHostInheritEnv,
@@ -111,6 +119,7 @@ export default function contribute(server: PluginServerContext) {
   );
   return () => {
     browserAuthorizationRegistry.clear();
+    removeSessionLimitListener();
     removeSessionOpenHook();
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "5.1.1-next.335.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/mcp-browser.ts

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
 import type { RpcInput } from "@getpaseo/plugin";
 import type { openOmpMcpAuthorizationInPaseoBrowser } from "../shared/mcp";
+import { MAX_SESSIONS_UPPER_BOUND } from "../shared/provider-launch-settings";
 import { OmpPublicError } from "./provider/security";
 
-const MAX_REGISTERED_SESSIONS = 32;
+// One registration per live session. The shared session limit refuses sessions first.
+const MAX_REGISTERED_SESSIONS = MAX_SESSIONS_UPPER_BOUND;
 const MAX_AUTHORIZATIONS_PER_SESSION = 16;
 
 type BrowserAuthorizationOpener = (url: string) => Promise<void>;

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.335.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.339.1"; // x-release-please-version

package/server/provider/connection.ts

@@ -34,6 +34,7 @@ import {
 } from "./security";
 import { type OmpOpenedSession, OmpProviderSession, ompPersistenceSessionId } from "./session";
 import { OmpHistorySession } from "./session-history";
+import { OmpSessionLimit } from "./session-limit";
 import { isOmpHistoryOnlyOpen } from "./session-purpose";
 
 type ProviderConfigurationCompat = {
@@ -69,7 +70,6 @@ const SUPPORTED_INPUTS: Readonly<Record<string, true>> = {
   "session.can_stop_runtime": true,
   "session.close": true,
 };
-const MAX_CONNECTION_SESSIONS = 32;
 const MAX_ACTIVE_OPERATIONS = 128;
 const MAX_PROVIDER_INPUT_BYTES = 2 * 1024 * 1024;
 const MAX_NESTED_OPTION_BYTES = 256 * 1024;
@@ -723,6 +723,7 @@ export function createOmpConnection(
     console.error("OMP provider failure", diagnostic),
   reportOperationalFailure: OmpOperationalFailureReporter = () => {},
   resolveHostInheritEnv?: () => Promise<readonly string[]>,
+  sessionLimit = new OmpSessionLimit(),
 ): ProviderConnection {
   const errorDetails = (error: unknown, fallback: string): { message: string } => {
     if (isOmpPublicError(error)) return { message: error.message };
@@ -767,6 +768,13 @@ export function createOmpConnection(
     string,
     { token: symbol; nativeSessionId?: string; cleanup?: Promise<void> }
   >();
+  // One session id is held by `sessions`, `opening` and `failedCleanup` at different moments, and
+  // by two of them at once while it opens or fails. After a failed close only unresolved cleanup
+  // stays counted, until it drains.
+  const untrackSessions = sessionLimit.track(() => {
+    if (closed) return failedCleanup.size;
+    return new Set([...sessions.keys(), ...opening.keys(), ...failedCleanup.keys()]).size;
+  });
   const shutdown = new AbortController();
   let catalogCleanup: Promise<void> | null = null;
   const activeOperations = new Set<Promise<void>>();
@@ -809,7 +817,9 @@ export function createOmpConnection(
       ...(quarantinedNativeSessionId ? { nativeSessionId: quarantinedNativeSessionId } : {}),
     });
     nativeReservations.quarantine(quarantinedNativeSessionId, token, cleanup, () => {
-      if (failedCleanup.get(sessionId)?.token === token) failedCleanup.delete(sessionId);
+      if (failedCleanup.get(sessionId)?.token !== token) return;
+      failedCleanup.delete(sessionId);
+      if (closed && failedCleanup.size === 0) untrackSessions();
     });
   };
 
@@ -906,8 +916,13 @@ export function createOmpConnection(
           requestFailure(input.requestId, new OmpPublicError("OMP session already exists"));
           return;
         }
-        if (sessions.size + opening.size + failedCleanup.size >= MAX_CONNECTION_SESSIONS) {
-          requestFailure(input.requestId, new OmpPublicError("OMP session limit reached"));
+        if (sessionLimit.openSessions >= sessionLimit.maxSessions) {
+          requestFailure(
+            input.requestId,
+            new OmpPublicError(
+              `OMP session limit reached (${sessionLimit.maxSessions} open sessions). Archive idle agents or raise the session limit in OMP → Plugin.`,
+            ),
+          );
           return;
         }
         const token = Symbol(input.sessionId);
@@ -1313,7 +1328,12 @@ export function createOmpConnection(
       return () => listeners.delete(listener);
     },
     close() {
-      closePromise ??= Promise.resolve().then(disposeConnection);
+      closePromise ??= Promise.resolve()
+        .then(disposeConnection)
+        .then(untrackSessions, (error: unknown) => {
+          if (failedCleanup.size === 0) untrackSessions();
+          throw error;
+        });
       return closePromise;
     },
   };

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/registration.ts

@@ -12,6 +12,7 @@ import { OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
 import type { OmpProtocolViolationDiagnostic } from "./omp-rpc-protocol";
 import { parseOmpProviderOptions } from "./provider-options";
 import { boundedJsonBytes } from "./security";
+import { OmpSessionLimit } from "./session-limit";
 import { OmpProviderOptionsSchema } from "./settings";
 import type { OmpTimelineScheduler } from "./timeline-projector";
 
@@ -121,6 +122,8 @@ export interface OmpProviderOptions {
   mcpInitializationTimeoutMs?: number;
   mcpConnector?: OmpMcpConnector;
   browserAuthorizationRegistry?: OmpBrowserAuthorizationRegistry;
+  /** Shared by every provider of one plugin instance; each provider has its own otherwise. */
+  sessionLimit?: OmpSessionLimit;
   reportProtocolViolation?: (diagnostic: OmpProtocolViolationDiagnostic) => void | Promise<void>;
   reportOperationalFailure?: OmpOperationalFailureReporter;
   availabilityProbe?: (
@@ -150,6 +153,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       reportProtocolViolation: options.reportProtocolViolation,
     });
   const nativeReservations = new OmpNativeSessionReservations();
+  const sessionLimit = options.sessionLimit ?? new OmpSessionLimit();
   const checkAvailability: NonNullable<ProviderRegistrationCompat["checkAvailability"]> = async (
     catalogOptions,
     context,
@@ -216,6 +220,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       const capabilities = CAPABILITIES.filter((capability) =>
         requestedCapabilities.has(capability),
       );
+      await sessionLimit.refresh();
       return createOmpConnection(
         runtime,
         capabilities,
@@ -229,6 +234,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         undefined,
         options.reportOperationalFailure,
         options.resolveHostInheritEnv,
+        sessionLimit,
       );
     },
   };

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-limit.ts

@@ -0,0 +1,32 @@
+import { DEFAULT_MAX_SESSIONS } from "../../shared/provider-launch-settings";
+
+/**
+ * Counts open sessions across every provider connection that shares this instance. The plugin
+ * shares one instance between all of its OMP providers, so the limit applies to the whole host.
+ */
+export class OmpSessionLimit {
+  private readonly counts = new Set<() => number>();
+  maxSessions = DEFAULT_MAX_SESSIONS;
+
+  /** `readConfigured` returns the configured limit, or `undefined` to keep the current one. */
+  constructor(private readonly readConfigured?: () => Promise<number | undefined>) {}
+
+  async refresh(): Promise<void> {
+    const configured = await this.readConfigured?.();
+    if (configured !== undefined) this.maxSessions = configured;
+  }
+
+  /** Adds a connection's open sessions to the total until the returned function runs. */
+  track(count: () => number): () => void {
+    this.counts.add(count);
+    return () => {
+      this.counts.delete(count);
+    };
+  }
+
+  get openSessions(): number {
+    let total = 0;
+    for (const count of this.counts) total += count();
+    return total;
+  }
+}

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`,

package/shared/provider-launch-settings.ts

@@ -3,9 +3,13 @@ import { z } from "zod";
 
 export const MAX_INHERITED_ENVIRONMENT_NAMES = 256;
 export const environmentNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/u);
+export const DEFAULT_MAX_SESSIONS = 32;
+// Every allowed session can open at once without reaching the 128 in-flight operations bound.
+export const MAX_SESSIONS_UPPER_BOUND = 64;
 
 export const providerLaunchSettingsSchema = z.object({
   inheritEnv: z.array(environmentNameSchema).max(MAX_INHERITED_ENVIRONMENT_NAMES).default([]),
+  maxSessions: z.number().int().min(1).max(MAX_SESSIONS_UPPER_BOUND).default(DEFAULT_MAX_SESSIONS),
 });
 
 export type ProviderLaunchSettings = z.infer<typeof providerLaunchSettingsSchema>;