@omercnet/paseo-omp 5.1.1 → 5.2.0-next.362.1

package/server/provider/connection.ts

@@ -13,6 +13,7 @@ import type {
   OmpOperationalFailure,
   OmpOperationalFailureReporter,
 } from "../operational-failure-diagnostics";
+import type { OmpSubagentControlRegistry } from "../subagents";
 import { discoverOmpCatalog } from "./catalog";
 import { normalizeOmpCatalogOptions } from "./config-normalization";
 import type { OmpMcpConnector } from "./host-tools";
@@ -34,6 +35,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 +71,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 +724,8 @@ export function createOmpConnection(
     console.error("OMP provider failure", diagnostic),
   reportOperationalFailure: OmpOperationalFailureReporter = () => {},
   resolveHostInheritEnv?: () => Promise<readonly string[]>,
+  sessionLimit = new OmpSessionLimit(),
+  subagentControlRegistry?: OmpSubagentControlRegistry,
 ): ProviderConnection {
   const errorDetails = (error: unknown, fallback: string): { message: string } => {
     if (isOmpPublicError(error)) return { message: error.message };
@@ -757,6 +760,7 @@ export function createOmpConnection(
       session: OmpOpenedSession;
       nativeSessionId?: string;
       removeBrowserAuthorization?: () => void;
+      removeSubagentControls?: () => void;
     }
   >();
   const opening = new Map<
@@ -767,6 +771,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>>();
@@ -783,6 +794,7 @@ export function createOmpConnection(
     if (slot?.token !== token) return false;
     sessions.delete(sessionId);
     slot.removeBrowserAuthorization?.();
+    slot.removeSubagentControls?.();
     return true;
   };
 
@@ -809,7 +821,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();
     });
   };
 
@@ -879,6 +893,7 @@ export function createOmpConnection(
                 query: input.query,
                 limit: input.limit,
                 sessionDir: listingConfig.sessionDir,
+                signal: shutdown.signal,
               })
             ).map((session) => ({
               persistence: { version: 1, data: { sessionId: session.id } },
@@ -906,8 +921,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);
@@ -978,6 +998,7 @@ export function createOmpConnection(
                 environment,
                 hostInheritEnv,
                 scheduler,
+                controller.signal,
               )
             : await OmpProviderSession.open(
                 input,
@@ -1018,12 +1039,12 @@ export function createOmpConnection(
             nativeReservations.release(nativeSessionId, token);
             return;
           }
-          const browserAgentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
+          const agentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
           // A history session has no live Paseo browser tools to authorize.
           const browserAuthorization = historyOnly
             ? undefined
             : browserAuthorizationRegistry?.register(
-                browserAgentId,
+                agentId,
                 session.openPaseoBrowser.bind(session),
               );
           session.setBrowserAuthorizationIssuer(browserAuthorization?.issue ?? null);
@@ -1033,11 +1054,17 @@ export function createOmpConnection(
                 browserAuthorization.remove();
               }
             : undefined;
+          // A history session has no runtime, so it has no subagents to control.
+          const removeSubagentControls =
+            session instanceof OmpProviderSession
+              ? subagentControlRegistry?.register(agentId, session)
+              : undefined;
           sessions.set(input.sessionId, {
             token,
             session,
             nativeSessionId,
             ...(removeBrowserAuthorization ? { removeBrowserAuthorization } : {}),
+            ...(removeSubagentControls ? { removeSubagentControls } : {}),
           });
           await session.publishOpened(input.requestId);
           if (
@@ -1189,7 +1216,10 @@ export function createOmpConnection(
     shutdown.abort(shutdownReason);
     for (const { controller } of opening.values()) controller.abort(shutdownReason);
     for (const { session } of sessions.values()) session.beginConnectionShutdown();
-    for (const slot of sessions.values()) slot.removeBrowserAuthorization?.();
+    for (const slot of sessions.values()) {
+      slot.removeBrowserAuthorization?.();
+      slot.removeSubagentControls?.();
+    }
     const failures: unknown[] = [];
     const operationBatch = [...activeOperations];
     const operationResults = await Promise.allSettled(operationBatch);
@@ -1313,7 +1343,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-process.ts

@@ -64,12 +64,15 @@ export async function terminatePosixProcessTree(
 
 export type ProcessTreeCleanup = "verified" | "uncertain" | "failed";
 
-export async function stopWindowsTree(pid: number): Promise<ProcessTreeCleanup> {
+export async function stopWindowsTree(
+  pid: number,
+  spawnTaskkill: typeof spawn = spawn,
+): Promise<ProcessTreeCleanup> {
   const result = Promise.withResolvers<ProcessTreeCleanup>();
   const systemRoot = process.env.SystemRoot ?? WINDOWS_DEFAULT_SYSTEM_ROOT;
   let taskkill: ChildProcessWithoutNullStreams;
   try {
-    taskkill = spawn(
+    taskkill = spawnTaskkill(
       join(systemRoot, "System32", "taskkill.exe"),
       ["/PID", String(pid), "/T", "/F"],
       {
@@ -99,13 +102,10 @@ export async function stopWindowsTree(pid: number): Promise<ProcessTreeCleanup>
   }, PROCESS_STOP_TIMEOUT_MS);
   taskkill.once("error", () => finish("failed"));
   taskkill.once("close", (code, signal) => {
-    finish(
-      code === 0 && signal === null
-        ? "verified"
-        : code === 128 && signal === null
-          ? "uncertain"
-          : "failed",
-    );
+    // 128 means taskkill found no such process because it already exited; retrying only repeats
+    // 128. Callers still wait for the root OMP process's own exit, so a live root cannot pass.
+    // Descendants of an already exited root cannot be enumerated by taskkill and are not checked.
+    finish((code === 0 || code === 128) && signal === null ? "verified" : "failed");
   });
   return result.promise;
 }

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",
@@ -128,6 +130,7 @@ export const OMP_RPC_COMMAND_POLICIES = {
   bash: "unsupported",
   abort_bash: "unsupported",
   get_session_stats: "implemented",
+  get_session_lease: "unsupported",
   export_html: "unsupported",
   switch_session: "unsupported",
   branch: "implemented",
@@ -142,15 +145,21 @@ export const OMP_RPC_COMMAND_POLICIES = {
   abort_and_restore_queue: "unsupported",
   btw: "unsupported",
   btw_cancel: "unsupported",
-  cancel_subagent: "unsupported",
+  cancel_subagent: "implemented",
   fork: "unsupported",
   get_btw_history: "unsupported",
   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",
@@ -158,7 +167,7 @@ export const OMP_RPC_COMMAND_POLICIES = {
   set_ask_dialog: "implemented",
   set_cache_warming: "unsupported",
   set_slow_mode: "unsupported",
-  steer_subagent: "unsupported",
+  steer_subagent: "implemented",
 } as const;
 export const OMP_RPC_RESPONSE_POLICIES = OMP_RPC_COMMAND_POLICIES;
 export const OMP_PROTOCOL_VIOLATION_CATEGORIES = [
@@ -254,9 +263,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 +417,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 +1622,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 +1826,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"),
@@ -1967,6 +2002,8 @@ export const OmpSubagentsResultSchema = z.object({
     )
     .max(1_024),
 });
+export const OmpCancelSubagentResultSchema = z.object({ cancelled: z.boolean() });
+export const OmpSteerSubagentResultSchema = z.object({}).strict().optional();
 export const OmpSubagentMessagesResultSchema = z.object({
   sessionFile: boundedString(MAX_PATH_LENGTH),
   fromByte: z.number().int().nonnegative(),
@@ -1997,6 +2034,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/omp-rpc.ts

@@ -16,6 +16,7 @@ import {
   OmpBranchMessagesResultSchema,
   type OmpBranchResult,
   OmpBranchResultSchema,
+  OmpCancelSubagentResultSchema,
   type OmpCompactionResult,
   OmpCompactionResultSchema,
   type OmpExtensionUiResponse,
@@ -41,6 +42,7 @@ import {
   OmpSessionStateSchema,
   type OmpSessionStats,
   OmpSessionStatsSchema,
+  OmpSteerSubagentResultSchema,
   type OmpSubagentMessagesResult,
   OmpSubagentMessagesResultSchema,
   type OmpSubagentSnapshot,
@@ -105,6 +107,9 @@ export interface OmpRuntimeSession {
     subagentId?: string;
     sessionFile?: string;
   }): Promise<OmpSubagentMessagesResult>;
+  /** Resolves `false` when OMP no longer lists the subagent as running for this session. */
+  cancelSubagent(subagentId: string): Promise<boolean>;
+  steerSubagent(subagentId: string, message: string): Promise<void>;
   prompt(
     message: string,
     images?: readonly OmpImage[],
@@ -466,6 +471,26 @@ class OmpRpcSession implements OmpRuntimeSession {
     );
   }
 
+  async cancelSubagent(subagentId: string): Promise<boolean> {
+    const safeId = validateBoundedText(subagentId, "subagent identifier", MAX_ID_LENGTH);
+    return OmpCancelSubagentResultSchema.parse(
+      await this.process.request({ type: "cancel_subagent", subagentId: safeId }),
+    ).cancelled;
+  }
+
+  async steerSubagent(subagentId: string, message: string): Promise<void> {
+    const safeId = validateBoundedText(subagentId, "subagent identifier", MAX_ID_LENGTH);
+    const safeMessage = validateBoundedText(message, "subagent steering message", MAX_TEXT_LENGTH);
+    if (!safeMessage.trim()) throw new Error("Invalid OMP subagent steering message");
+    OmpSteerSubagentResultSchema.parse(
+      await this.process.request({
+        type: "steer_subagent",
+        subagentId: safeId,
+        message: safeMessage,
+      }),
+    );
+  }
+
   async getBranchMessages(): Promise<Array<{ entryId: string; text: string }>> {
     const result = OmpBranchMessagesResultSchema.parse(
       await this.process.request({ type: "get_branch_messages" }),

package/server/provider/registration.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
 import type { OmpOperationalFailureReporter } from "../operational-failure-diagnostics";
 import { probeOmpAvailability } from "../provider-diagnostics";
+import type { OmpSubagentControlRegistry } from "../subagents";
 import { mergeOmpInheritedEnvironmentNames } from "./config-normalization";
 import { createOmpConnection, OmpNativeSessionReservations } from "./connection";
 import type { OmpMcpConnector } from "./host-tools";
@@ -12,6 +13,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";
 
@@ -116,11 +118,14 @@ export interface OmpProviderOptions {
   timelineScheduler?: OmpTimelineScheduler;
   replayTimeoutMs?: number;
   environment?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
   /** Fixed, non-secret profile/store identity for providers whose configuration is server-owned. */
   catalogIdentity?: Readonly<Record<string, string>>;
   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?: (
@@ -128,6 +133,7 @@ export interface OmpProviderOptions {
     timeoutMs: number | undefined,
   ) => Promise<ProviderAvailabilityCompat>;
   resolveHostInheritEnv?: () => Promise<readonly string[]>;
+  subagentControlRegistry?: OmpSubagentControlRegistry;
 }
 
 function stableJson(value: unknown): string {
@@ -150,6 +156,8 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       reportProtocolViolation: options.reportProtocolViolation,
     });
   const nativeReservations = new OmpNativeSessionReservations();
+  const sessionLimit = options.sessionLimit ?? new OmpSessionLimit();
+  const platform = options.platform ?? process.platform;
   const checkAvailability: NonNullable<ProviderRegistrationCompat["checkAvailability"]> = async (
     catalogOptions,
     context,
@@ -159,6 +167,12 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
     }
     const providerOptions = parseOmpProviderOptions(catalogOptions.providerOptions);
     const environment = { ...(options.environment ?? process.env), ...providerOptions.env };
+    // Windows env names are case-insensitive, but a copy keeps only the literal key (often
+    // `Path`), so `environment.PATH` would miss it and OMP would look not installed.
+    if (platform === "win32" && environment.PATH === undefined) {
+      const pathKey = Object.keys(environment).find((name) => name.toUpperCase() === "PATH");
+      if (pathKey !== undefined) environment.PATH = environment[pathKey];
+    }
     const configuredCommand: readonly [string, ...string[]] = providerOptions.command?.[0]
       ? [providerOptions.command[0], ...providerOptions.command.slice(1)]
       : [environment.OMP_COMMAND || "omp"];
@@ -167,6 +181,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       cwd:
         catalogOptions.scope === "workspace" && catalogOptions.cwd ? catalogOptions.cwd : homedir(),
       environment,
+      platform,
       timeoutMs: context?.timeoutMs,
     });
   };
@@ -216,6 +231,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
       const capabilities = CAPABILITIES.filter((capability) =>
         requestedCapabilities.has(capability),
       );
+      await sessionLimit.refresh();
       return createOmpConnection(
         runtime,
         capabilities,
@@ -229,6 +245,8 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         undefined,
         options.reportOperationalFailure,
         options.resolveHostInheritEnv,
+        sessionLimit,
+        options.subagentControlRegistry,
       );
     },
   };

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;