@omercnet/paseo-omp 5.1.1 → 5.2.0

package/server/provider/session-descriptors.ts

@@ -10,12 +10,11 @@ const MAX_DESCRIPTOR_PREFIX_BYTES = 64 * 1024;
 const MAX_DESCRIPTOR_SUFFIX_BYTES = 64 * 1024;
 const MAX_PROMPT_PREVIEW_CHARS = 160;
 const MAX_DIRECTORY_DEPTH = 8;
-// Count caps only bound memory; the byte and time budgets bound scan work. OMP keeps one
-// directory per workspace, so these must exceed real session trees or lookups silently miss.
+// No wall-clock cutoff: it silently drops sessions on a slow disk. OMP keeps one directory per
+// workspace, so the count caps must exceed real session trees or lookups silently miss.
 const MAX_SCAN_DIRECTORIES = 65_536;
 const MAX_SCAN_FILES = 262_144;
 const MAX_SCAN_BYTES = 16 * 1024 * 1024;
-const MAX_SCAN_MS = 1_000;
 const SCAN_YIELD_INTERVAL = 128;
 const MAX_LIST_RESULTS = 500;
 const MAX_CHILD_TRANSCRIPT_BYTES = 16 * 1024 * 1024;
@@ -59,10 +58,10 @@ export interface OmpSessionListOptions {
   limit?: number;
   sessionId?: string;
   sessionDir?: string;
+  signal?: AbortSignal;
 }
 
 interface ScanBudget {
-  startedAt: number;
   directories: number;
   files: number;
   bytes: number;
@@ -155,8 +154,7 @@ function budgetExceeded(budget: ScanBudget): boolean {
     budget.exhausted ||
     budget.directories >= MAX_SCAN_DIRECTORIES ||
     budget.files >= MAX_SCAN_FILES ||
-    budget.bytes >= MAX_SCAN_BYTES ||
-    Date.now() - budget.startedAt >= MAX_SCAN_MS
+    budget.bytes >= MAX_SCAN_BYTES
   );
 }
 
@@ -418,11 +416,13 @@ async function scanSessionFiles(
   root: string,
   budget: ScanBudget,
   visit: (file: string) => Promise<boolean>,
+  signal?: AbortSignal,
 ): Promise<void> {
   const pending: Array<{ path: string; depth: number }> = [{ path: root, depth: 0 }];
   while (pending.length > 0 && !budgetExceeded(budget)) {
     const current = pending.pop();
     if (!current) return;
+    signal?.throwIfAborted();
     budget.directories += 1;
     let directory: Dir;
     try {
@@ -432,6 +432,7 @@ async function scanSessionFiles(
     }
     try {
       for await (const entry of directory) {
+        signal?.throwIfAborted();
         budget.entries += 1;
         if (budget.entries % SCAN_YIELD_INTERVAL === 0) await yieldToEventLoop();
         if (budgetExceeded(budget)) return;
@@ -469,7 +470,6 @@ export async function listOmpSessionDescriptors(
   const query = options.query?.trim().toLowerCase();
   const matches: OmpSessionDescriptor[] = [];
   const budget: ScanBudget = {
-    startedAt: Date.now(),
     directories: 0,
     files: 0,
     bytes: 0,
@@ -481,29 +481,35 @@ export async function listOmpSessionDescriptors(
       ? join(environment.HOME ?? environment.USERPROFILE ?? homedir(), options.sessionDir.slice(2))
       : resolve(options.cwd ?? homedir(), options.sessionDir)
     : ompSessionDir(environment);
-  await scanSessionFiles(root, budget, async (file) => {
-    const fileName = basename(file);
-    const stem = fileName.slice(0, -".jsonl".length);
-    if (requestedId && !stem.endsWith(`_${requestedId}`)) return true;
-    const descriptor = await parseDescriptor(file, budget);
-    if (
-      !descriptor ||
-      !stem.endsWith(`_${descriptor.id}`) ||
-      (options.cwd !== undefined && descriptor.cwd !== options.cwd)
-    )
-      return !budgetExceeded(budget);
-    if (
-      query &&
-      !descriptor.id.toLowerCase().includes(query) &&
-      !descriptor.title?.toLowerCase().includes(query) &&
-      !descriptor.firstPromptPreview?.toLowerCase().includes(query) &&
-      !descriptor.lastPromptPreview?.toLowerCase().includes(query)
-    ) {
-      return !budgetExceeded(budget);
-    }
-    retainNewest(matches, descriptor, retentionLimit);
-    return !requestedId || matches.length < 2;
-  });
+  await scanSessionFiles(
+    root,
+    budget,
+    async (file) => {
+      const fileName = basename(file);
+      const stem = fileName.slice(0, -".jsonl".length);
+      if (requestedId && !stem.endsWith(`_${requestedId}`)) return true;
+      const descriptor = await parseDescriptor(file, budget);
+      if (
+        !descriptor ||
+        !stem.endsWith(`_${descriptor.id}`) ||
+        (options.cwd !== undefined && descriptor.cwd !== options.cwd)
+      )
+        return !budgetExceeded(budget);
+      if (
+        query &&
+        !descriptor.id.toLowerCase().includes(query) &&
+        !descriptor.title?.toLowerCase().includes(query) &&
+        !descriptor.firstPromptPreview?.toLowerCase().includes(query) &&
+        !descriptor.lastPromptPreview?.toLowerCase().includes(query)
+      ) {
+        return !budgetExceeded(budget);
+      }
+      retainNewest(matches, descriptor, retentionLimit);
+      return !requestedId || matches.length < 2;
+    },
+    options.signal,
+  );
+  options.signal?.throwIfAborted();
   return matches;
 }
 

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

@@ -119,6 +119,7 @@ export class OmpHistorySession implements OmpOpenedSession {
     environment?: NodeJS.ProcessEnv,
     hostInheritEnv: readonly string[] = [],
     scheduler: OmpTimelineScheduler = defaultOmpTimelineScheduler,
+    signal?: AbortSignal,
   ): Promise<OmpHistorySession> {
     const nativeSessionId = ompPersistenceSessionId(input);
     if (!nativeSessionId || input.history !== "replay" || !input.config.persist) {
@@ -141,6 +142,7 @@ export class OmpHistorySession implements OmpOpenedSession {
       nativeSessionId,
       input.config.cwd,
       normalized.sessionDir,
+      signal,
     );
     if (!descriptor.transcriptFile) {
       throw new OmpPublicError("OMP session transcript could not be resolved in this workspace");

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" &&