@omercnet/paseo-omp 0.4.0-next.123.1 → 0.4.0-next.125.1

package/server/provider/session.ts

@@ -1,13 +1,10 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import type {
   ProviderConfigState,
   ProviderError,
   ProviderEvent,
   ProviderInput,
-  ProviderPermissionResponse,
   ProviderSessionConfig,
-  ProviderToolCallDetail,
-  ProviderUsage,
 } from "@getpaseo/plugin/server/provider";
 import type {
   OmpOperationalFailure,
@@ -35,14 +32,10 @@ import type {
   OmpAvailableCommand,
   OmpBranchResult,
   OmpCompactionResult,
-  OmpExtensionUiResponse,
   OmpMessage,
   OmpModel,
   OmpRpcEvent,
   OmpSessionState,
-  OmpSessionStats,
-  OmpToolApprovalCancel,
-  OmpToolApprovalRequest,
 } from "./omp-rpc-protocol";
 import { OmpRpcRequestRejectedError } from "./omp-rpc-transport";
 import {
@@ -64,9 +57,11 @@ import {
   OmpPublicError,
   utf8Bytes,
 } from "./security";
+import { OmpSessionCompaction } from "./session-compaction";
 import type { OmpSessionDescriptor } from "./session-descriptors";
 import { validateNativeSessionId } from "./session-descriptors";
 import { isNativeTurnActivity, isPassiveUiMethod, isRuntimeConfigEvent } from "./session-events";
+import { OmpSessionPermissions } from "./session-permissions";
 import {
   type ActiveTurn,
   assistantTerminalOutcome,
@@ -79,6 +74,7 @@ import {
   terminalOutcome,
   unknownTerminalOutcomeError,
 } from "./session-terminal";
+import { OmpSessionUsage } from "./session-usage";
 import { OmpSubsessionProjector } from "./subsessions";
 import {
   defaultOmpTimelineScheduler,
@@ -96,10 +92,6 @@ type NativeSessionTransition = (previousSessionId: string, nextSessionId: string
 type RewindCleanupQuarantine = (cleanup: Promise<void>) => void;
 type RewindSessionRetirement = () => void;
 type SessionPermissionInput = Extract<ProviderInput, { type: "session.permission" }>;
-type OmpQuestionRequest = Extract<
-  Extract<OmpRpcEvent, { type: "extension_ui_request" }>,
-  { method: "select" | "confirm" | "input" | "editor" }
->;
 type Emit = (event: ProviderEvent) => void;
 const LOCAL_ONLY_SETTLE_MS = 5_000;
 const AGENT_END_STATE_TIMEOUT_MS = 2_000;
@@ -115,8 +107,8 @@ const MAX_AGENT_END_CORRELATION_MESSAGES = 512;
 const MAX_TRACKED_ENTRY_IDS = 1_024;
 const MAX_UNCLAIMED_BRANCH_ENTRIES = 1_024;
 const MAX_PENDING_USERS = 256;
-const MAX_PENDING_PERMISSIONS = 32;
-const MAX_PENDING_PERMISSION_BYTES = 2 * 1024 * 1024;
+const _MAX_PENDING_PERMISSIONS = 32;
+const _MAX_PENDING_PERMISSION_BYTES = 2 * 1024 * 1024;
 const MAX_USER_ECHOES = 512;
 const MAX_BUFFERED_TURN_EVENTS = 512;
 const MAX_BUFFERED_VALUE_ITEMS = 1_024;
@@ -128,8 +120,8 @@ const MAX_UNCLAIMED_BRANCH_BYTES = 4 * 1024 * 1024;
 class OmpCatalogEscape extends OmpPublicError {}
 const MAX_REPLAY_MESSAGES = 100_000;
 const REPLAY_TIMEOUT_MS = 20_000;
-const OMP_ASK_USER_FREEFORM_SENTINEL = "✏️ Type custom response...";
-const MAX_FREEFORM_RESPONSE_BYTES = 64 * 1024;
+const _OMP_ASK_USER_FREEFORM_SENTINEL = "✏️ Type custom response...";
+const _MAX_FREEFORM_RESPONSE_BYTES = 64 * 1024;
 const OMP_BUILTIN_COMMANDS: readonly OmpAvailableCommand[] = [
   {
     name: "compact",
@@ -255,56 +247,6 @@ type PendingAbort = {
   forceTerminal: boolean;
   promise: Promise<void>;
 };
-type PendingPermission = {
-  nativeId: string;
-  header: string;
-  fingerprint: string;
-  optionValues: ReadonlyMap<string, string>;
-  actionBehaviors: ReadonlyMap<string, "allow" | "deny">;
-  retainedBytes: number;
-  displayValues: ReadonlyMap<string, string>;
-  generation: number;
-  runtime: OmpRuntimeSession;
-  expiresAt?: number;
-  timer?: unknown;
-  turnId?: string;
-  request: OmpQuestionRequest;
-  freeformSentinel?: string;
-};
-type PendingToolPermission = {
-  nativeId: string;
-  toolCallId: string;
-  fingerprint: string;
-  retainedBytes: number;
-  generation: number;
-  runtime: OmpRuntimeSession;
-  expiresAt?: number;
-  timer?: unknown;
-  turnId?: string;
-};
-
-type PendingFreeformSelection = {
-  value: string;
-  nativeSelectId: string;
-  generation: number;
-  runtime: OmpRuntimeSession;
-  turnId?: string;
-};
-
-function permissionFingerprint(request: OmpQuestionRequest): string {
-  return createHash("sha256").update(JSON.stringify(request)).digest("base64url");
-}
-
-type ActiveCompaction = {
-  id: string;
-  trigger: "auto" | "manual";
-  turnId: string;
-  generation: number;
-  retrying: boolean;
-  action?: string;
-  preTokens?: number;
-};
-
 function providerError(error: unknown, fallback: string): { message: string } {
   return { message: isOmpPublicError(error) ? error.message : fallback };
 }
@@ -364,30 +306,12 @@ export class OmpProviderSession {
   private configRevision = 0;
   private recoveryUsesNativeConfig = false;
   private activeAbort: PendingAbort | null = null;
-  private usageEpoch = 0;
-  private usageSequence = 0;
-  private usageSample: {
-    turn: ActiveTurn;
-    generation: number;
-    runtime: OmpRuntimeSession;
-    epoch: number;
-    sequence: number;
-    promise: Promise<OmpSessionState | undefined>;
-  } | null = null;
-  private activeCompaction: ActiveCompaction | null = null;
-  private discardedCompactionEnds = 0;
-  private lastUsage: ProviderUsage | null = null;
+  private readonly usage: OmpSessionUsage;
+  private readonly compaction: OmpSessionCompaction;
   private revertInFlight = false;
   private runtimeTurnCompleted = false;
   private commandCatalog: OmpAvailableCommand[];
-  private permissionSequence = 0;
-  private readonly permissionNamespace = randomUUID();
-  private readonly pendingPermissions = new Map<string, PendingPermission>();
-  private readonly inFlightPermissions = new Map<string, PendingPermission>();
-  private pendingFreeformSelection: PendingFreeformSelection | null = null;
-  private readonly pendingToolPermissions = new Map<string, PendingToolPermission>();
-  private readonly inFlightToolPermissions = new Map<string, PendingToolPermission>();
-  private readonly resolvedToolApprovalIds = new BoundedStringSet(MAX_TRACKED_ENTRY_IDS);
+  private readonly permissions: OmpSessionPermissions;
   private unsupportedThinkingNoticePending = false;
   private unsupportedThinkingNoticePublished = false;
 
@@ -420,6 +344,26 @@ export class OmpProviderSession {
     this.id = id;
     this.cwd = config.cwd;
     this.scheduler = scheduler;
+    this.usage = new OmpSessionUsage(
+      id,
+      emit,
+      scheduler,
+      () => ({
+        closed: this.closed,
+        runtimeDead: this.runtimeDead !== null,
+        generation: this.generation,
+        runtime: this.runtime,
+        activeTurn: this.activeTurn,
+      }),
+      (turn) =>
+        !this.closed &&
+        !this.runtimeDead &&
+        !turn.terminal &&
+        !turn.terminalizing &&
+        !turn.agentEndPending &&
+        turn.generation === this.generation &&
+        this.activeTurn === turn,
+    );
     this.dataFilter = new OmpPublicDataSerializer(outputRedactionValues);
     this.nativeModelsByPublicId = nativeModelsByPublicId;
     this.commandCatalog = commandCatalog;
@@ -433,6 +377,31 @@ export class OmpProviderSession {
       capabilities.includes("timeline.plugin"),
       hostTools.labels,
     );
+    this.compaction = new OmpSessionCompaction(
+      id,
+      emit,
+      this.projector,
+      this.dataFilter,
+      this.usage,
+    );
+    this.permissions = new OmpSessionPermissions({
+      sessionId: id,
+      emit,
+      scheduler,
+      dataFilter: this.dataFilter,
+      projector: this.projector,
+      readContext: () => ({
+        runtime: this.runtime,
+        generation: this.generation,
+        activeTurn: this.activeTurn,
+        closed: this.closed,
+        runtimeDead: this.runtimeDead !== null,
+      }),
+      handleRuntimeFailure: (message) => this.handleRuntimeFailure(message),
+      invalidateRuntime: (message) => this.invalidateRuntime(message),
+      markAgentEvidence: (turn) => this.markAgentEvidence(turn),
+      reevaluateDeferredTerminal: () => this.reevaluateDeferredPermissionTerminal(),
+    });
     this.subsessions = capabilities.includes("session.subsession")
       ? new OmpSubsessionProjector(
           id,
@@ -774,289 +743,6 @@ export class OmpProviderSession {
     });
   }
 
-  private usageFrom(
-    state: OmpSessionState | undefined,
-    stats: OmpSessionStats | undefined,
-  ): ProviderUsage | undefined {
-    if (!state?.contextUsage && !stats) return undefined;
-    const stateContext = state?.contextUsage;
-    const statsContext = stats?.contextUsage;
-    const modelCapacity = state?.model?.contextWindow;
-    const inputTokens = stats?.tokens?.input;
-    const cachedInputTokens = stats?.tokens?.cacheRead;
-    const outputTokens = stats?.tokens?.output;
-    const totalCostUsd = stats?.cost;
-    const contextTokens =
-      typeof stateContext?.tokens === "number"
-        ? stateContext.tokens
-        : typeof statsContext?.tokens === "number"
-          ? statsContext.tokens
-          : undefined;
-    const contextWindow =
-      typeof stateContext?.contextWindow === "number" && stateContext.contextWindow > 0
-        ? stateContext.contextWindow
-        : typeof statsContext?.contextWindow === "number" && statsContext.contextWindow > 0
-          ? statsContext.contextWindow
-          : typeof modelCapacity === "number" && modelCapacity > 0
-            ? modelCapacity
-            : undefined;
-    const usage: ProviderUsage = {
-      ...(typeof inputTokens === "number" ? { inputTokens } : {}),
-      ...(typeof cachedInputTokens === "number" ? { cachedInputTokens } : {}),
-      ...(typeof outputTokens === "number" ? { outputTokens } : {}),
-      ...(typeof totalCostUsd === "number" ? { totalCostUsd } : {}),
-      ...(contextTokens !== undefined ? { contextWindowUsedTokens: contextTokens } : {}),
-      ...(contextWindow !== undefined ? { contextWindowMaxTokens: contextWindow } : {}),
-    };
-    return Object.keys(usage).length > 0 ? usage : undefined;
-  }
-
-  private ownsUsageSample(
-    turn: ActiveTurn,
-    generation: number,
-    runtime: OmpRuntimeSession,
-  ): boolean {
-    return (
-      !this.closed &&
-      !this.runtimeDead &&
-      !turn.terminal &&
-      generation === this.generation &&
-      runtime === this.runtime &&
-      this.activeTurn === turn
-    );
-  }
-
-  private publishUsageSnapshot(
-    turn: ActiveTurn,
-    minimumEpoch = this.usageEpoch,
-    minimumSequence = turn.usageSampleFloor,
-  ): Promise<OmpSessionState | undefined> {
-    const generation = turn.generation;
-    const runtime = this.runtime;
-    if (!this.ownsUsageSample(turn, generation, runtime)) return Promise.resolve(undefined);
-    const current = this.usageSample;
-    if (current) {
-      if (
-        current.turn === turn &&
-        current.generation === generation &&
-        current.runtime === runtime &&
-        current.epoch >= minimumEpoch &&
-        current.sequence >= minimumSequence
-      ) {
-        return current.promise;
-      }
-      return current.promise.then(() => {
-        if (!this.ownsUsageSample(turn, generation, runtime)) return undefined;
-        return this.publishUsageSnapshot(turn, minimumEpoch, minimumSequence);
-      });
-    }
-    const epoch = this.usageEpoch;
-    const sequence = ++this.usageSequence;
-    const promise = Promise.allSettled([runtime.getState(), runtime.getSessionStats()]).then(
-      ([stateResult, statsResult]) => {
-        if (
-          !this.ownsUsageSample(turn, generation, runtime) ||
-          epoch !== this.usageEpoch ||
-          epoch < minimumEpoch ||
-          sequence < turn.usageSampleFloor ||
-          sequence < minimumSequence
-        ) {
-          return undefined;
-        }
-        const state = stateResult.status === "fulfilled" ? stateResult.value : undefined;
-        const stats = statsResult.status === "fulfilled" ? statsResult.value : undefined;
-        const usage = this.usageFrom(state, stats);
-        if (usage) {
-          this.lastUsage = usage;
-          this.emit({ type: "session.usage", sessionId: this.id, turnId: turn.turnId, usage });
-        }
-        return state;
-      },
-    );
-    this.usageSample = { turn, generation, runtime, epoch, sequence, promise };
-    void promise.finally(() => {
-      if (this.usageSample?.promise === promise) this.usageSample = null;
-    });
-    return promise;
-  }
-
-  private async boundedUsageSnapshot(
-    turn: ActiveTurn,
-    timeoutMs: number,
-  ): Promise<OmpSessionState | undefined> {
-    const timeout = Promise.withResolvers<undefined>();
-    const timer = this.scheduler.set(() => timeout.resolve(undefined), timeoutMs);
-    try {
-      return await Promise.race([this.publishUsageSnapshot(turn), timeout.promise]);
-    } finally {
-      this.scheduler.clear(timer);
-    }
-  }
-
-  private async boundedTerminalState(
-    turn: ActiveTurn,
-    timeoutMs: number,
-  ): Promise<OmpSessionState | undefined> {
-    const generation = turn.generation;
-    const runtime = this.runtime;
-    const timeout = Promise.withResolvers<undefined>();
-    const timer = this.scheduler.set(() => timeout.resolve(undefined), timeoutMs);
-    try {
-      const state = await Promise.race([runtime.getState(), timeout.promise]);
-      return this.ownsUsageSample(turn, generation, runtime) ? state : undefined;
-    } catch {
-      return undefined;
-    } finally {
-      this.scheduler.clear(timer);
-    }
-  }
-
-  private isActiveTurn(turn: ActiveTurn): boolean {
-    return (
-      !this.closed &&
-      !this.runtimeDead &&
-      !turn.terminal &&
-      !turn.terminalizing &&
-      !turn.agentEndPending &&
-      turn.generation === this.generation &&
-      this.activeTurn === turn
-    );
-  }
-
-  private scheduleUsagePoll(turn: ActiveTurn, delayMs = USAGE_POLL_MS): void {
-    if (!this.isActiveTurn(turn) || turn.usagePollTimer !== undefined) return;
-    turn.usagePollTimer = this.scheduler.set(() => {
-      turn.usagePollTimer = undefined;
-      this.pollUsage(turn);
-    }, delayMs);
-  }
-
-  private pollUsage(turn: ActiveTurn): void {
-    if (!this.isActiveTurn(turn) || turn.usagePoll) return;
-    const poll = this.publishUsageSnapshot(turn).then(() => undefined);
-    turn.usagePoll = poll;
-    void poll.finally(() => {
-      if (turn.usagePoll === poll) turn.usagePoll = undefined;
-      this.scheduleUsagePoll(turn);
-    });
-  }
-
-  private stopUsagePoll(turn: ActiveTurn): void {
-    if (turn.usagePollTimer === undefined) return;
-    this.scheduler.clear(turn.usagePollTimer);
-    turn.usagePollTimer = undefined;
-  }
-
-  private startCompaction(turn: ActiveTurn, trigger: "auto" | "manual", action?: string): void {
-    if (this.discardedCompactionEnds > 0) {
-      this.discardedCompactionEnds += 1;
-      return;
-    }
-    const active = this.activeCompaction;
-    if (active && active.trigger === trigger && active.action === action) {
-      active.retrying = false;
-      return;
-    }
-    if (active) {
-      this.retireCompaction("OMP emitted overlapping compactions");
-      this.discardedCompactionEnds = 2;
-      return;
-    }
-    const operation: ActiveCompaction = {
-      id: randomUUID(),
-      trigger,
-      turnId: turn.turnId,
-      generation: turn.generation,
-      action,
-      retrying: false,
-      preTokens: this.lastUsage?.contextWindowUsedTokens,
-    };
-    this.activeCompaction = operation;
-    this.projector.flush(true);
-    this.emit({
-      type: "timeline.item",
-      sessionId: this.id,
-      item: {
-        id: operation.id,
-        type: "compaction",
-        status: "loading",
-        trigger,
-        ...(operation.preTokens !== undefined ? { preTokens: operation.preTokens } : {}),
-      },
-    });
-  }
-
-  private finishCompaction(
-    state: "completed" | "failed" | "canceled" | "skipped",
-    options: { tokensBefore?: number | null; message?: string } = {},
-  ): void {
-    const operation = this.activeCompaction;
-    if (!operation) return;
-    this.activeCompaction = null;
-    this.projector.flush(true);
-    if (state === "completed") {
-      this.usageEpoch += 1;
-      const staleSample = this.usageSample;
-      if (staleSample && staleSample.epoch < this.usageEpoch) {
-        this.usageSample = null;
-        staleSample.turn.usagePoll = undefined;
-      }
-      this.lastUsage = null;
-    }
-    if (state !== "completed") {
-      const defaultMessage =
-        state === "failed"
-          ? "OMP compaction failed"
-          : state === "canceled"
-            ? "OMP compaction canceled"
-            : "OMP compaction skipped";
-      this.emit({
-        type: "timeline.item",
-        sessionId: this.id,
-        item: {
-          id: operation.id,
-          type: "notification",
-          level: state === "failed" ? "error" : "info",
-          message: this.dataFilter.text(options.message ?? defaultMessage, 4_096),
-        },
-      });
-      return;
-    }
-    const tokensBefore = options.tokensBefore ?? operation.preTokens;
-    this.emit({
-      type: "timeline.item",
-      sessionId: this.id,
-      item: {
-        id: operation.id,
-        type: "compaction",
-        status: "completed",
-        trigger: operation.trigger,
-        ...(tokensBefore !== undefined ? { preTokens: tokensBefore } : {}),
-      },
-    });
-  }
-
-  private retireCompaction(message: string): void {
-    const operation = this.activeCompaction;
-    if (!operation) return;
-    this.activeCompaction = null;
-    this.emit({
-      type: "timeline.item",
-      sessionId: this.id,
-      item: {
-        id: operation.id,
-        type: "compaction",
-        status: "completed",
-        trigger: operation.trigger,
-      },
-    });
-    this.emit({
-      type: "timeline.item",
-      sessionId: this.id,
-      item: { id: `${operation.id}:error`, type: "error", message },
-    });
-  }
-
   private async replayHistory(preferPersistedTranscript = false): Promise<void> {
     if (!this.runtime.canReplayHistory) {
       throw new OmpPublicError("OMP session history cannot be replayed safely");
@@ -1294,7 +980,7 @@ export class OmpProviderSession {
     const configRefresh = this.configRefreshInFlight;
     this.cancelConfigRefreshRetry();
     this.lifetime.abort(new Error(message));
-    this.resolveAllPermissions(true);
+    this.permissions.resolveAllPermissions(true);
     this.subsessions?.close();
     this.projector.close();
     this.unsubscribe();
@@ -1449,8 +1135,8 @@ export class OmpProviderSession {
         turn.starting = false;
         turn.acknowledged = true;
         this.startTurn(turn, false);
-        this.startCompaction(turn, "manual");
-        this.pollUsage(turn);
+        this.compaction.start(turn, "manual");
+        this.usage.poll(turn);
         const bufferedEvents = turn.bufferedEvents.splice(0);
         turn.replayingBufferedEvents = true;
         for (const event of bufferedEvents) this.handleTurnEvent(turn, event);
@@ -1541,8 +1227,8 @@ export class OmpProviderSession {
       else {
         turn.steerReady.resolve();
         turn.terminal = true;
-        this.finishCompaction("failed", { message: "OMP prompt failed" });
-        this.resolveTurnPermissions(turn.turnId);
+        this.compaction.finish("failed", { message: "OMP prompt failed" });
+        this.permissions.resolveTurnPermissions(turn.turnId);
         this.projector.finishTurn(turn.turnId);
         if (this.activeTurn === turn) this.activeTurn = null;
       }
@@ -1714,7 +1400,7 @@ export class OmpProviderSession {
       const result = await compaction;
       turn.manualCompactionPending = false;
       if (this.closed || this.runtimeDead || turn.generation !== this.generation) return;
-      this.finishCompaction("completed", { tokensBefore: result.tokensBefore });
+      this.compaction.finish("completed", { tokensBefore: result.tokensBefore });
       await this.finishTurn(turn, turn.interrupted ? "canceled" : "completed");
     } catch (error) {
       if (this.closed || this.runtimeDead || turn.generation !== this.generation) return;
@@ -1722,7 +1408,7 @@ export class OmpProviderSession {
       const raw = providerError(error, "OMP compaction failed");
       const failure = { message: this.dataFilter.text(raw.message, 4_096) };
       const state = turn.interrupted ? "canceled" : "failed";
-      this.finishCompaction(state, { message: failure.message });
+      this.compaction.finish(state, { message: failure.message });
       await this.finishTurn(turn, state, state === "failed" ? failure : undefined, true, true);
     }
   }
@@ -1743,7 +1429,7 @@ export class OmpProviderSession {
     }
     const forceTerminal = turn.awaitingPermissionEvidence;
     turn.awaitingPermissionEvidence = false;
-    if (forceTerminal) this.resolveTurnPermissions(turn.turnId);
+    if (forceTerminal) this.permissions.resolveTurnPermissions(turn.turnId);
     const pending = this.activeAbort;
     if (turn.interrupted) {
       if (pending?.turn === turn) await this.settleInterrupt(input.requestId, pending);
@@ -2154,118 +1840,7 @@ export class OmpProviderSession {
   }
 
   async permission(input: SessionPermissionInput): Promise<void> {
-    const typed = this.pendingToolPermissions.get(input.permissionId);
-    if (typed) {
-      await this.respondToToolPermission(input, typed);
-      return;
-    }
-    const pending = this.pendingPermissions.get(input.permissionId);
-    if (!pending) throw new OmpPublicError("Unknown OMP permission request");
-    if (!this.permissionOwnerIsCurrent(pending)) {
-      this.pendingPermissions.delete(input.permissionId);
-      if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-      this.emit({
-        type: "session.permission_resolved",
-        sessionId: this.id,
-        permissionId: input.permissionId,
-      });
-      throw new OmpPublicError("OMP permission request is no longer active");
-    }
-    const { generation, runtime } = pending;
-    this.pendingPermissions.delete(input.permissionId);
-    this.inFlightPermissions.set(input.permissionId, pending);
-    if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-    try {
-      const freeformValue = this.freeformSelection(pending, input.response);
-      if (freeformValue !== undefined) {
-        this.pendingFreeformSelection = {
-          value: freeformValue,
-          nativeSelectId: pending.nativeId,
-          generation,
-          runtime,
-          ...(pending.turnId ? { turnId: pending.turnId } : {}),
-        };
-      }
-      const response = this.extensionUiResponse(pending, input.response);
-      await runtime.respondToExtensionUi(response);
-    } catch (error) {
-      if (this.pendingFreeformSelection?.nativeSelectId === pending.nativeId) {
-        this.pendingFreeformSelection = null;
-      }
-      if (this.inFlightPermissions.get(input.permissionId) !== pending) return;
-      this.inFlightPermissions.delete(input.permissionId);
-      if (
-        this.permissionOwnerIsCurrent(pending) &&
-        generation === this.generation &&
-        runtime === this.runtime
-      ) {
-        this.pendingPermissions.set(input.permissionId, pending);
-        this.armPermissionTimeout(input.permissionId, pending);
-        throw error;
-      }
-      return;
-    }
-    if (this.inFlightPermissions.get(input.permissionId) !== pending) return;
-    this.inFlightPermissions.delete(input.permissionId);
-    this.emit({
-      type: "session.permission_resolved",
-      sessionId: this.id,
-      permissionId: input.permissionId,
-    });
-    this.reevaluateDeferredPermissionTerminal();
-  }
-  private async respondToToolPermission(
-    input: SessionPermissionInput,
-    pending: PendingToolPermission,
-  ): Promise<void> {
-    if (!this.permissionOwnerIsCurrent(pending)) {
-      this.pendingToolPermissions.delete(input.permissionId);
-      if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-      this.resolvedToolApprovalIds.add(pending.nativeId);
-      this.emit({
-        type: "session.permission_resolved",
-        sessionId: this.id,
-        permissionId: input.permissionId,
-      });
-      throw new OmpPublicError("OMP permission request is no longer active");
-    }
-    if (
-      input.response.selectedActionId !== undefined &&
-      input.response.selectedActionId !== input.response.behavior
-    ) {
-      throw new OmpPublicError("OMP permission action is invalid");
-    }
-    this.pendingToolPermissions.delete(input.permissionId);
-    this.inFlightToolPermissions.set(input.permissionId, pending);
-    if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-    try {
-      await pending.runtime.respondToToolApproval({
-        type: "tool_approval_response",
-        id: pending.nativeId,
-        toolCallId: pending.toolCallId,
-        approved: input.response.behavior === "allow",
-      });
-    } catch (error) {
-      if (this.inFlightToolPermissions.get(input.permissionId) !== pending) return;
-      this.inFlightToolPermissions.delete(input.permissionId);
-      this.resolvedToolApprovalIds.add(pending.nativeId);
-      this.emit({
-        type: "session.permission_resolved",
-        sessionId: this.id,
-        permissionId: input.permissionId,
-      });
-      this.reevaluateDeferredPermissionTerminal();
-      throw error;
-    }
-    if (this.inFlightToolPermissions.get(input.permissionId) !== pending) return;
-    this.inFlightToolPermissions.delete(input.permissionId);
-    this.resolvedToolApprovalIds.add(pending.nativeId);
-    this.emit({
-      type: "session.permission_resolved",
-      sessionId: this.id,
-      permissionId: input.permissionId,
-    });
-    this.reevaluateDeferredPermissionTerminal();
+    await this.permissions.respond(input);
   }
 
   close(input?: SessionCloseInput): Promise<void> {
@@ -2299,12 +1874,12 @@ export class OmpProviderSession {
       if (turn.started) await this.finishTurn(turn, "canceled", undefined, true, true);
       else {
         this.settleUnstartedTurn(turn);
-        this.finishCompaction("canceled");
+        this.compaction.finish("canceled");
       }
     }
     this.imageMaterializer.clear();
-    this.finishCompaction("canceled");
-    this.resolveAllPermissions(true);
+    this.compaction.finish("canceled");
+    this.permissions.resolveAllPermissions(true);
     this.closed = true;
     this.configRefreshAttempts = 0;
     this.configRefreshDirty = false;
@@ -2463,7 +2038,7 @@ export class OmpProviderSession {
       }
       if (this.subsessions) await recovered.setSubagentSubscription("events");
       this.generation += 1;
-      this.lastUsage = null;
+      this.usage.clearLatest();
       this.runtimeDead = null;
       this.runtimeDisposal = null;
       unsubscribeBootstrap();
@@ -2629,7 +2204,7 @@ export class OmpProviderSession {
         this.handleRuntimeFailure("OMP emitted an unnegotiated tool approval request");
         return;
       }
-      this.publishToolPermission(event);
+      this.permissions.publishToolPermission(event);
       return;
     }
     if (event.type === "tool_approval_cancel") {
@@ -2637,18 +2212,17 @@ export class OmpProviderSession {
         this.handleRuntimeFailure("OMP emitted an unnegotiated tool approval cancellation");
         return;
       }
-      this.cancelToolPermission(event);
+      this.permissions.cancelToolPermission(event);
       return;
     }
     if (event.type === "extension_ui_request") {
       if (event.method === "cancel") {
-        if (this.pendingFreeformSelection?.nativeSelectId === event.targetId) {
-          this.pendingFreeformSelection = null;
-        }
-        this.resolvePermissionByNativeId(event.targetId ?? "");
+        this.permissions.clearPendingFreeformSelection(event.targetId);
+        this.permissions.resolvePermissionByNativeId(event.targetId ?? "");
         return;
       }
-      if (event.method === "input" && this.submitPendingFreeformSelection(event)) return;
+      if (event.method === "input" && this.permissions.submitPendingFreeformSelection(event))
+        return;
       if (
         event.method === "select" ||
         event.method === "confirm" ||
@@ -2659,7 +2233,7 @@ export class OmpProviderSession {
           this.handleRuntimeFailure();
           return;
         }
-        this.publishPermission(event);
+        this.permissions.publishPermission(event);
         return;
       }
 
@@ -2810,50 +2384,20 @@ export class OmpProviderSession {
     if (event.type === "auto_compaction_start") {
       turn.nativeActivity = true;
       this.cancelLocalOnlyCompletion(turn);
-      this.startCompaction(turn, "auto", event.action);
+      this.compaction.start(turn, "auto", event.action);
       return;
     }
     if (event.type === "auto_compaction_end") {
-      if (this.discardedCompactionEnds > 0) {
-        this.discardedCompactionEnds -= 1;
-        return;
+      if (this.compaction.handleAutoEnd(turn, event)) {
+        this.usage.schedulePoll(turn, USAGE_REFRESH_MS);
       }
-      const operation = this.activeCompaction;
-      if (
-        operation?.trigger !== "auto" ||
-        operation.turnId !== turn.turnId ||
-        operation.generation !== turn.generation
-      ) {
-        return;
-      }
-      if (event.action !== undefined && operation.action !== event.action) {
-        this.retireCompaction("OMP emitted overlapping compactions");
-        this.discardedCompactionEnds = 1;
-        return;
-      }
-      if (event.willRetry) {
-        operation.retrying = true;
-        return;
-      }
-      const state = event.aborted
-        ? "canceled"
-        : event.errorMessage
-          ? "failed"
-          : event.skipped
-            ? "skipped"
-            : "completed";
-      this.finishCompaction(state, {
-        tokensBefore: event.result?.tokensBefore ?? event.result?.preTokens,
-        message: event.errorMessage,
-      });
-      this.scheduleUsagePoll(turn, USAGE_REFRESH_MS);
       return;
     }
     if (event.type === "agent_end" && turn.manualCompactionPending) return;
     if (event.type === "tool_execution_start") turn.activeToolCallIds.add(event.toolCallId);
     if (event.type === "tool_execution_end") {
       turn.activeToolCallIds.delete(event.toolCallId);
-      if (event.toolName === "ask_user") this.pendingFreeformSelection = null;
+      if (event.toolName === "ask_user") this.permissions.clearPendingFreeformSelection();
     }
     if (event.type === "tool_execution_start" || event.type === "tool_execution_end") {
       try {
@@ -3128,24 +2672,6 @@ export class OmpProviderSession {
     });
   }
 
-  private submitPendingFreeformSelection(
-    request: Extract<OmpQuestionRequest, { method: "input" }>,
-  ): boolean {
-    const pending = this.pendingFreeformSelection;
-    if (!pending) return false;
-    this.pendingFreeformSelection = null;
-    if (
-      pending.generation !== this.generation ||
-      pending.runtime !== this.runtime ||
-      (pending.turnId !== undefined && this.activeTurn?.turnId !== pending.turnId)
-    ) {
-      return false;
-    }
-    void pending.runtime
-      .respondToExtensionUi({ type: "extension_ui_response", id: request.id, value: pending.value })
-      .catch(() => this.handleRuntimeFailure("OMP freeform response failed"));
-    return true;
-  }
   private replaceSlashCommands(commands: OmpAvailableCommand[]): void {
     this.slashCommands.clear();
     for (const command of [...OMP_BUILTIN_COMMANDS, ...commands]) {
@@ -3177,687 +2703,11 @@ export class OmpProviderSession {
         }),
     });
   }
-  private toolPermissionDetail(
-    request: OmpToolApprovalRequest,
-  ): ProviderToolCallDetail | undefined {
-    switch (request.identity.kind) {
-      case "shell":
-        return {
-          type: "shell",
-          command: this.dataFilter.text(request.identity.command, 24 * 1024),
-        };
-      case "edit":
-        return {
-          type: "edit",
-          filePath: this.dataFilter.text(request.identity.paths[0] ?? "", 4_096),
-          newString: this.dataFilter.text(request.identity.content, 20 * 1024),
-        };
-      case "write":
-        return {
-          type: "write",
-          filePath: this.dataFilter.text(request.identity.path, 4_096),
-          content: this.dataFilter.text(request.identity.content, 20 * 1024),
-        };
-      case "other":
-        return;
-    }
-  }
-
-  private publishToolPermission(request: OmpToolApprovalRequest): void {
-    const fingerprint = createHash("sha256").update(JSON.stringify(request)).digest("base64url");
-    if (this.resolvedToolApprovalIds.has(request.id)) {
-      this.handleRuntimeFailure("OMP reused a resolved tool approval identifier");
-      return;
-    }
-    for (const pending of [
-      ...this.pendingToolPermissions.values(),
-      ...this.inFlightToolPermissions.values(),
-    ]) {
-      if (pending.nativeId !== request.id) continue;
-      if (pending.fingerprint !== fingerprint || pending.toolCallId !== request.toolCallId) {
-        this.handleRuntimeFailure("OMP changed a pending tool approval request");
-      }
-      return;
-    }
-    const pendingCount =
-      this.pendingPermissions.size +
-      this.inFlightPermissions.size +
-      this.pendingToolPermissions.size +
-      this.inFlightToolPermissions.size;
-    if (pendingCount >= MAX_PENDING_PERMISSIONS) {
-      this.resolvedToolApprovalIds.add(request.id);
-      void this.runtime
-        .respondToToolApproval({
-          type: "tool_approval_response",
-          id: request.id,
-          toolCallId: request.toolCallId,
-          cancelled: true,
-        })
-        .catch(() => this.handleRuntimeFailure());
-      return;
-    }
-
-    this.permissionSequence += 1;
-    const permissionId = `omp:permission:${this.permissionNamespace}:${this.permissionSequence}`;
-    const detail = this.toolPermissionDetail(request);
-    const filteredInput = this.dataFilter.json(request.input, 8 * 1024, 32 * 1024);
-    const input =
-      filteredInput && typeof filteredInput === "object" && !Array.isArray(filteredInput)
-        ? filteredInput
-        : {};
-    const descriptionParts = [
-      request.detail.reason,
-      ...request.detail.lines,
-      ...(request.detail.providerSafetyChecks ?? []),
-    ].filter((part): part is string => Boolean(part));
-    const publicRequest = {
-      id: permissionId,
-      name: `omp.${this.dataFilter.text(request.toolName, 256)}`,
-      kind: "tool" as const,
-      title: `Allow ${this.dataFilter.text(request.toolName, 256)}?`,
-      ...(descriptionParts.length > 0
-        ? { description: this.dataFilter.text(descriptionParts.join("\n"), 16 * 1024) }
-        : {}),
-      input: {
-        ...input,
-        identity: this.dataFilter.json(request.identity, 20 * 1024, 32 * 1024),
-        tier: request.tier,
-        toolCallId: request.toolCallId,
-      },
-      ...(detail ? { detail } : {}),
-      actions: [
-        { id: "allow", label: "Allow", behavior: "allow" as const, variant: "primary" as const },
-        { id: "deny", label: "Deny", behavior: "deny" as const, variant: "danger" as const },
-      ],
-      metadata: {
-        tier: request.tier,
-        redacted: request.detail.redacted,
-        truncated: request.detail.truncated,
-        redactedFields: request.detail.redactedFields,
-        truncatedFields: request.detail.truncatedFields,
-      },
-    };
-    const pending: PendingToolPermission = {
-      nativeId: request.id,
-      toolCallId: request.toolCallId,
-      fingerprint,
-      retainedBytes: boundedJsonBytes(
-        publicRequest,
-        MAX_PENDING_PERMISSION_BYTES,
-        512,
-        MAX_PENDING_PERMISSION_BYTES,
-        4_096,
-      ),
-      generation: this.generation,
-      runtime: this.runtime,
-      ...(this.activeTurn ? { turnId: this.activeTurn.turnId } : {}),
-      ...(request.timeout !== undefined ? { expiresAt: Date.now() + request.timeout } : {}),
-    };
-    let retainedBytes = pending.retainedBytes;
-    for (const item of this.pendingPermissions.values()) retainedBytes += item.retainedBytes;
-    for (const item of this.inFlightPermissions.values()) retainedBytes += item.retainedBytes;
-    for (const item of this.pendingToolPermissions.values()) retainedBytes += item.retainedBytes;
-    for (const item of this.inFlightToolPermissions.values()) retainedBytes += item.retainedBytes;
-    if (
-      pending.retainedBytes === Number.POSITIVE_INFINITY ||
-      retainedBytes > MAX_PENDING_PERMISSION_BYTES
-    ) {
-      void this.runtime
-        .respondToToolApproval({
-          type: "tool_approval_response",
-          id: request.id,
-          toolCallId: request.toolCallId,
-          cancelled: true,
-        })
-        .catch(() => this.handleRuntimeFailure());
-      this.resolvedToolApprovalIds.add(request.id);
-      return;
-    }
-    this.pendingToolPermissions.set(permissionId, pending);
-    this.armToolPermissionTimeout(permissionId, pending);
-    this.projector.markAskPermissionRendered();
-    if (this.activeTurn) {
-      this.activeTurn.awaitingPermissionEvidence = true;
-      this.markAgentEvidence(this.activeTurn);
-    }
-    this.emit({ type: "session.permission", sessionId: this.id, request: publicRequest });
-  }
-
-  private cancelToolPermission(request: OmpToolApprovalCancel): void {
-    for (const permissions of [this.pendingToolPermissions, this.inFlightToolPermissions]) {
-      for (const [permissionId, pending] of permissions) {
-        if (pending.nativeId !== request.targetId) continue;
-        if (pending.toolCallId !== request.toolCallId) {
-          this.handleRuntimeFailure("OMP tool approval cancellation did not match its tool call");
-          return;
-        }
-        permissions.delete(permissionId);
-        if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-        this.resolvedToolApprovalIds.add(pending.nativeId);
-        this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-        this.reevaluateDeferredPermissionTerminal();
-        return;
-      }
-    }
-    if (!this.resolvedToolApprovalIds.has(request.targetId)) {
-      this.handleRuntimeFailure("OMP canceled an unknown tool approval request");
-    }
-  }
-
-  private publishPermission(request: OmpQuestionRequest): void {
-    if (request.method === "select" && !request.options?.length) {
-      this.handleRuntimeFailure();
-      return;
-    }
-    const fingerprint = permissionFingerprint(request);
-    let existingId: string | undefined;
-    let existingPending: PendingPermission | undefined;
-    for (const [permissionId, pending] of this.pendingPermissions) {
-      if (pending.nativeId !== request.id) continue;
-      if (pending.fingerprint === fingerprint) {
-        existingId = permissionId;
-        existingPending = pending;
-      } else {
-        this.pendingPermissions.delete(permissionId);
-        if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-        this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-      }
-      break;
-    }
-    if (!existingId) {
-      for (const pending of this.inFlightPermissions.values()) {
-        if (pending.nativeId !== request.id) continue;
-        if (pending.fingerprint !== fingerprint) this.handleRuntimeFailure();
-        return;
-      }
-    }
-    if (
-      !existingId &&
-      this.pendingPermissions.size +
-        this.inFlightPermissions.size +
-        this.pendingToolPermissions.size +
-        this.inFlightToolPermissions.size >=
-        MAX_PENDING_PERMISSIONS
-    ) {
-      this.rejectPermissionRequest(request, "Too many OMP questions are already pending");
-      return;
-    }
-    if (existingPending?.timer !== undefined) this.scheduler.clear(existingPending.timer);
-    if (!existingId) this.permissionSequence += 1;
-    const id =
-      existingId ?? `omp:permission:${this.permissionNamespace}:${this.permissionSequence}`;
-    const header = this.dataFilter.text(request.title ?? "OMP question", 4_096);
-    const freeformSentinel =
-      request.method === "select" && request.options.includes(OMP_ASK_USER_FREEFORM_SENTINEL)
-        ? OMP_ASK_USER_FREEFORM_SENTINEL
-        : undefined;
-    const optionValues = new Map<string, string>();
-    const displayValues = new Map<string, string>();
-    const usedOptionLabels = new Set<string>();
-    const optionDetails = request.method === "select" ? request.optionDetails : undefined;
-    const selectableOptions =
-      request.method === "select"
-        ? request.options.flatMap((nativeValue, index) =>
-            nativeValue === freeformSentinel ? [] : [{ nativeValue, index }],
-          )
-        : [];
-    const options =
-      request.method === "select"
-        ? selectableOptions.map(({ nativeValue, index }) => {
-            const baseLabel = this.dataFilter.text(nativeValue, 4_096);
-            let label = baseLabel;
-            let suffix = 2;
-            while (usedOptionLabels.has(label)) {
-              label = `${baseLabel} (${suffix})`;
-              suffix += 1;
-            }
-            usedOptionLabels.add(label);
-            const value = `${id}:option:${index}`;
-            optionValues.set(value, nativeValue);
-            displayValues.set(label, nativeValue);
-            return {
-              label,
-              value,
-              ...(optionDetails?.[index]?.description
-                ? {
-                    description: this.dataFilter.text(
-                      optionDetails[index]?.description ?? "",
-                      16_384,
-                    ),
-                  }
-                : {}),
-            };
-          })
-        : undefined;
-    const questionOptions =
-      request.method === "confirm" ? [{ label: "Yes" }, { label: "No" }] : (options ?? []);
-    const actions =
-      request.method === "select"
-        ? [
-            ...(options ?? []).map((option) => ({
-              id: option.value,
-              label: option.label,
-              behavior: "allow" as const,
-              variant: "secondary" as const,
-            })),
-            {
-              id: "cancel",
-              label: "Cancel",
-              behavior: "deny" as const,
-              variant: "secondary" as const,
-            },
-          ]
-        : [
-            {
-              id: "submit",
-              label: request.method === "confirm" ? "Confirm" : "Submit",
-              behavior: "allow" as const,
-              variant: "primary" as const,
-            },
-            {
-              id: "cancel",
-              label: "Cancel",
-              behavior: "deny" as const,
-              variant: "secondary" as const,
-            },
-          ];
-    const pending: PendingPermission = {
-      nativeId: request.id,
-      header,
-      fingerprint,
-      optionValues,
-      actionBehaviors: new Map(actions.map((action) => [action.id, action.behavior])),
-      displayValues,
-      generation: this.generation,
-      runtime: this.runtime,
-      request,
-      retainedBytes: boundedJsonBytes(
-        { request, header, options: questionOptions, actions },
-        MAX_PENDING_PERMISSION_BYTES,
-        512,
-        MAX_PENDING_PERMISSION_BYTES,
-        4_096,
-      ),
-      ...(this.activeTurn ? { turnId: this.activeTurn.turnId } : {}),
-      ...(request.timeout !== undefined ? { expiresAt: Date.now() + request.timeout } : {}),
-      ...(freeformSentinel ? { freeformSentinel } : {}),
-    };
-    let retainedPermissionBytes = pending.retainedBytes;
-    for (const [permissionId, retained] of this.pendingPermissions) {
-      if (permissionId !== existingId) retainedPermissionBytes += retained.retainedBytes;
-    }
-    for (const retained of this.inFlightPermissions.values()) {
-      retainedPermissionBytes += retained.retainedBytes;
-    }
-    for (const retained of this.pendingToolPermissions.values()) {
-      retainedPermissionBytes += retained.retainedBytes;
-    }
-    for (const retained of this.inFlightToolPermissions.values()) {
-      retainedPermissionBytes += retained.retainedBytes;
-    }
-    if (
-      pending.retainedBytes === Number.POSITIVE_INFINITY ||
-      retainedPermissionBytes > MAX_PENDING_PERMISSION_BYTES
-    ) {
-      if (existingId) {
-        this.pendingPermissions.delete(existingId);
-        this.emit({
-          type: "session.permission_resolved",
-          sessionId: this.id,
-          permissionId: existingId,
-        });
-      }
-      this.rejectPermissionRequest(request, "OMP question data exceeded the pending input budget");
-      return;
-    }
-    this.pendingPermissions.set(id, pending);
-    this.armPermissionTimeout(id, pending);
-    this.projector.markAskPermissionRendered();
-    if (this.activeTurn) {
-      this.activeTurn.awaitingPermissionEvidence = true;
-      this.markAgentEvidence(this.activeTurn);
-    }
-    this.emit({
-      type: "session.permission",
-      sessionId: this.id,
-      request: {
-        id,
-        name: `omp.${request.method}`,
-        kind: "question",
-        title: header,
-        ...(request.method === "confirm"
-          ? { description: this.dataFilter.text(request.message, 64 * 1024) }
-          : {}),
-        input: {
-          questions: [
-            {
-              header,
-              question: this.dataFilter.text(
-                request.method === "confirm" ? request.message : request.title,
-                64 * 1024,
-              ),
-              options: questionOptions,
-              multiSelect: false,
-              ...(freeformSentinel ? { allowOther: true } : {}),
-              ...(request.method === "input" && request.placeholder
-                ? { placeholder: this.dataFilter.text(request.placeholder, 4_096) }
-                : {}),
-              ...((request.method === "input" || request.method === "editor") && request.prefill
-                ? { prefill: this.dataFilter.text(request.prefill) }
-                : {}),
-            },
-          ],
-        },
-        actions,
-      },
-    });
-  }
-
-  private rejectPermissionRequest(request: OmpQuestionRequest, description: string): void {
-    this.emit({
-      type: "session.notice",
-      sessionId: this.id,
-      notice: {
-        id: `omp:permission-rejected:${this.permissionSequence + 1}`,
-        severity: "warning",
-        title: "OMP question canceled",
-        description,
-      },
-    });
-    void this.runtime
-      .respondToExtensionUi({ type: "extension_ui_response", id: request.id, cancelled: true })
-      .catch(() => this.handleRuntimeFailure());
-  }
-
-  private freeformSelection(
-    pending: PendingPermission,
-    response: ProviderPermissionResponse,
-  ): string | undefined {
-    if (
-      pending.request.method !== "select" ||
-      !pending.freeformSentinel ||
-      response.behavior !== "allow" ||
-      response.selectedActionId !== undefined
-    ) {
-      return;
-    }
-    const answers = response.updatedInput?.answers;
-    const answer =
-      answers && typeof answers === "object" && !Array.isArray(answers)
-        ? answers[pending.header]
-        : undefined;
-    const value = Array.isArray(answer) ? answer[0] : answer;
-    if (
-      typeof value !== "string" ||
-      pending.optionValues.has(value) ||
-      pending.displayValues.has(value)
-    ) {
-      return;
-    }
-    if (
-      value === pending.freeformSentinel ||
-      value.trim().length === 0 ||
-      value.includes("\0") ||
-      utf8Bytes(value) > MAX_FREEFORM_RESPONSE_BYTES
-    ) {
-      throw new OmpPublicError("OMP freeform response is invalid");
-    }
-    return value;
-  }
-
-  private extensionUiResponse(
-    pending: PendingPermission,
-    response: ProviderPermissionResponse,
-  ): OmpExtensionUiResponse {
-    if (response.selectedActionId !== undefined) {
-      const expectedBehavior = pending.actionBehaviors.get(response.selectedActionId);
-      if (expectedBehavior === undefined || expectedBehavior !== response.behavior) {
-        throw new OmpPublicError("OMP permission action is invalid");
-      }
-    }
-    const { nativeId, request, header } = pending;
-    if (request.method === "confirm") {
-      if (response.behavior === "deny") {
-        return { type: "extension_ui_response", id: nativeId, confirmed: false };
-      }
-      const answers = response.updatedInput?.answers;
-      const answer =
-        answers && typeof answers === "object" && !Array.isArray(answers)
-          ? answers[header]
-          : undefined;
-      return {
-        type: "extension_ui_response",
-        id: nativeId,
-        confirmed: typeof answer === "string" ? /^yes$/iu.test(answer.trim()) : true,
-      };
-    }
-    this.reevaluateDeferredPermissionTerminal();
-    if (response.behavior === "deny") {
-      return { type: "extension_ui_response", id: nativeId, cancelled: true };
-    }
-    const selectedValue = response.selectedActionId
-      ? pending.optionValues.get(response.selectedActionId)
-      : undefined;
-    if (selectedValue !== undefined) {
-      return { type: "extension_ui_response", id: nativeId, value: selectedValue };
-    }
-    const answers = response.updatedInput?.answers;
-    if (!answers || typeof answers !== "object" || Array.isArray(answers)) {
-      throw new OmpPublicError("OMP question response requires answers");
-    }
-    const answer = answers[header];
-    const publicValue = Array.isArray(answer) ? answer[0] : answer;
-    if (typeof publicValue !== "string") {
-      throw new OmpPublicError("OMP question response is invalid");
-    }
-    if (
-      request.method === "select" &&
-      pending.freeformSentinel &&
-      publicValue !== pending.freeformSentinel &&
-      !pending.displayValues.has(publicValue) &&
-      !pending.optionValues.has(publicValue)
-    ) {
-      if (
-        publicValue.trim().length === 0 ||
-        publicValue.includes("\0") ||
-        utf8Bytes(publicValue) > MAX_FREEFORM_RESPONSE_BYTES
-      ) {
-        throw new OmpPublicError("OMP freeform response is invalid");
-      }
-      this.pendingFreeformSelection = {
-        value: publicValue,
-        nativeSelectId: pending.nativeId,
-        generation: pending.generation,
-        runtime: pending.runtime,
-        ...(pending.turnId ? { turnId: pending.turnId } : {}),
-      };
-      return {
-        type: "extension_ui_response",
-        id: nativeId,
-        value: pending.freeformSentinel,
-      };
-    }
-    if (request.method === "select") {
-      const mapped =
-        pending.optionValues.get(publicValue) ?? pending.displayValues.get(publicValue);
-      if (mapped === undefined) {
-        throw new OmpPublicError("OMP selection response is invalid");
-      }
-      return { type: "extension_ui_response", id: nativeId, value: mapped };
-    }
-    return { type: "extension_ui_response", id: nativeId, value: publicValue };
-  }
-
-  private resolvePermissionByNativeId(nativeId: string): void {
-    for (const permissions of [this.pendingPermissions, this.inFlightPermissions]) {
-      for (const [permissionId, pending] of permissions) {
-        if (pending.nativeId !== nativeId) continue;
-        permissions.delete(permissionId);
-        if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-        this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-        this.reevaluateDeferredPermissionTerminal();
-        return;
-      }
-    }
-  }
-
-  private resolveTurnPermissions(turnId: string): void {
-    if (this.pendingFreeformSelection?.turnId === turnId) this.pendingFreeformSelection = null;
-    this.resolvePermissions((pending) => pending.turnId === turnId, true);
-    this.resolveToolPermissions((pending) => pending.turnId === turnId, true);
-  }
-  private resolveAllPermissions(cancelNative = false): void {
-    this.pendingFreeformSelection = null;
-    this.resolvePermissions(() => true, cancelNative);
-    this.resolveToolPermissions(() => true, cancelNative);
-  }
-
-  private resolvePermissions(
-    matches: (pending: PendingPermission) => boolean,
-    cancelNative: boolean,
-  ): void {
-    const permissionIds = new Set<string>();
-    for (const permissions of [this.pendingPermissions, this.inFlightPermissions]) {
-      for (const [permissionId, pending] of permissions) {
-        if (!matches(pending)) continue;
-        permissions.delete(permissionId);
-        if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-        permissionIds.add(permissionId);
-        if (cancelNative && permissions === this.pendingPermissions) {
-          void pending.runtime
-            .respondToExtensionUi({
-              type: "extension_ui_response",
-              id: pending.nativeId,
-              cancelled: true,
-            })
-            .catch(() => {
-              if (!this.closed && !this.runtimeDead) {
-                this.invalidateRuntime("OMP permission cancellation failed");
-              }
-            });
-        }
-      }
-    }
-    for (const permissionId of permissionIds) {
-      this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-    }
-    this.reevaluateDeferredPermissionTerminal();
-  }
-  private resolveToolPermissions(
-    matches: (pending: PendingToolPermission) => boolean,
-    cancelNative: boolean,
-  ): void {
-    const permissionIds = new Set<string>();
-    for (const permissions of [this.pendingToolPermissions, this.inFlightToolPermissions]) {
-      for (const [permissionId, pending] of permissions) {
-        if (!matches(pending)) continue;
-        permissions.delete(permissionId);
-        if (pending.timer !== undefined) this.scheduler.clear(pending.timer);
-        this.resolvedToolApprovalIds.add(pending.nativeId);
-        permissionIds.add(permissionId);
-        if (cancelNative && permissions === this.pendingToolPermissions) {
-          void pending.runtime
-            .respondToToolApproval({
-              type: "tool_approval_response",
-              id: pending.nativeId,
-              toolCallId: pending.toolCallId,
-              cancelled: true,
-            })
-            .catch(() => {
-              if (!this.closed && !this.runtimeDead) {
-                this.invalidateRuntime("OMP tool permission cancellation failed");
-              }
-            });
-        }
-      }
-    }
-    for (const permissionId of permissionIds) {
-      this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-    }
-    this.reevaluateDeferredPermissionTerminal();
-  }
-
-  private armToolPermissionTimeout(permissionId: string, pending: PendingToolPermission): void {
-    if (pending.expiresAt === undefined) return;
-    const remainingMs = Math.max(0, pending.expiresAt - Date.now());
-    pending.timer = this.scheduler.set(() => {
-      if (this.pendingToolPermissions.get(permissionId) !== pending) return;
-      this.pendingToolPermissions.delete(permissionId);
-      this.inFlightToolPermissions.set(permissionId, pending);
-      void pending.runtime
-        .respondToToolApproval({
-          type: "tool_approval_response",
-          id: pending.nativeId,
-          toolCallId: pending.toolCallId,
-          cancelled: true,
-          timedOut: true,
-        })
-        .then(
-          () => {
-            if (this.inFlightToolPermissions.get(permissionId) !== pending) return;
-            this.inFlightToolPermissions.delete(permissionId);
-            this.resolvedToolApprovalIds.add(pending.nativeId);
-            this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-            this.reevaluateDeferredPermissionTerminal();
-          },
-          () => this.handleRuntimeFailure(),
-        );
-    }, remainingMs);
-  }
-
-  private armPermissionTimeout(permissionId: string, pending: PendingPermission): void {
-    if (pending.expiresAt === undefined) return;
-    const remainingMs = Math.max(0, pending.expiresAt - Date.now());
-    pending.timer = this.scheduler.set(() => {
-      if (this.pendingPermissions.get(permissionId) !== pending) return;
-      this.pendingPermissions.delete(permissionId);
-      if (!this.permissionOwnerIsCurrent(pending)) {
-        this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-        this.reevaluateDeferredPermissionTerminal();
-        return;
-      }
-      this.inFlightPermissions.set(permissionId, pending);
-      void pending.runtime
-        .respondToExtensionUi({
-          type: "extension_ui_response",
-          id: pending.nativeId,
-          cancelled: true,
-          timedOut: true,
-        })
-        .then(
-          () => {
-            if (this.inFlightPermissions.get(permissionId) !== pending) return;
-            this.inFlightPermissions.delete(permissionId);
-            this.emit({ type: "session.permission_resolved", sessionId: this.id, permissionId });
-            this.reevaluateDeferredPermissionTerminal();
-          },
-          () => this.handleRuntimeFailure(),
-        );
-    }, remainingMs);
-  }
-
-  private permissionOwnerIsCurrent(pending: PendingPermission | PendingToolPermission): boolean {
-    if (
-      this.closed ||
-      this.runtimeDead ||
-      pending.generation !== this.generation ||
-      pending.runtime !== this.runtime
-    ) {
-      return false;
-    }
-    if (pending.turnId === undefined) return true;
-    return this.activeTurn?.turnId === pending.turnId && !this.activeTurn.terminal;
-  }
 
   private hasTerminalConflict(turn: ActiveTurn, includeChildren = true): boolean {
-    const ownsTurn = (pending: PendingPermission | PendingToolPermission) =>
-      pending.turnId === turn.turnId;
     return (
       turn.awaitingPermissionEvidence ||
-      [...this.pendingPermissions.values()].some(ownsTurn) ||
-      [...this.inFlightPermissions.values()].some(ownsTurn) ||
-      [...this.pendingToolPermissions.values()].some(ownsTurn) ||
-      [...this.inFlightToolPermissions.values()].some(ownsTurn) ||
+      this.permissions.hasForTurn(turn.turnId) ||
       turn.activeToolCallIds.size > 0 ||
       turn.steersInFlight > 0 ||
       (includeChildren && Boolean(this.subsessions?.hasActiveChildren()))
@@ -3993,7 +2843,7 @@ export class OmpProviderSession {
     await Promise.allSettled(turn.userLookups);
     this.refreshAmbiguousTerminal(turn);
     if (turn.terminal || this.activeTurn !== turn || turn.deferredAgentEnd !== candidate) return;
-    const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
+    const state = await this.usage.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
     if (turn.terminal || this.activeTurn !== turn || turn.deferredAgentEnd !== candidate) return;
     if (!state) {
       turn.operationalTerminalStage = "unresolved";
@@ -4023,10 +2873,7 @@ export class OmpProviderSession {
     ) {
       return;
     }
-    turn.usageSampleFloor = this.usageSequence + 1;
-    if (this.usageSample?.turn === turn && this.usageSample.sequence < turn.usageSampleFloor) {
-      this.usageSample = null;
-    }
+    this.usage.invalidateBeforeNextSample(turn);
     this.publishPendingUsers(turn);
     await this.finishTurn(turn, "completed", undefined, false, false, true);
   }
@@ -4055,7 +2902,7 @@ export class OmpProviderSession {
       this.beginTerminalization(turn, replacement);
       return;
     }
-    this.pollUsage(turn);
+    this.usage.poll(turn);
   }
 
   private beginTerminalization(turn: ActiveTurn, candidate: TerminalCandidate): void {
@@ -4069,11 +2916,8 @@ export class OmpProviderSession {
     }
     turn.terminalizing = true;
     this.cancelAmbiguousTerminal(turn);
-    turn.usageSampleFloor = this.usageSequence + 1;
-    if (this.usageSample?.turn === turn && this.usageSample.sequence < turn.usageSampleFloor) {
-      this.usageSample = null;
-    }
-    this.stopUsagePoll(turn);
+    this.usage.invalidateBeforeNextSample(turn);
+    this.usage.stopPoll(turn);
     turn.agentEndDeadlineTimer = this.scheduler.set(() => {
       turn.agentEndDeadlineTimer = undefined;
       if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
@@ -4165,14 +3009,14 @@ export class OmpProviderSession {
     ) {
       this.resetAgentEndProbe(turn);
       turn.deferredAgentEnd = candidate;
-      this.pollUsage(turn);
+      this.usage.poll(turn);
       return;
     }
     if (turn.interrupted) {
       await this.completeAgentEnd(turn, candidate.event);
       return;
     }
-    const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
+    const state = await this.usage.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
     if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
     if (!turn.interrupted && this.subsessions?.hasActiveChildren()) {
       this.resetAgentEndProbe(turn);
@@ -4185,7 +3029,7 @@ export class OmpProviderSession {
     ) {
       this.resetAgentEndProbe(turn);
       turn.deferredAgentEnd = candidate;
-      this.pollUsage(turn);
+      this.usage.poll(turn);
       return;
     }
     if (state) {
@@ -4227,7 +3071,7 @@ export class OmpProviderSession {
         !turn.interrupted &&
         this.activeTurn === turn
       ) {
-        const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
+        const state = await this.usage.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
         if (
           turn.terminal ||
           this.activeTurn !== turn ||
@@ -4305,9 +3149,9 @@ export class OmpProviderSession {
     turn.steerReady.resolve();
     turn.starting = false;
     turn.terminal = true;
-    this.stopUsagePoll(turn);
+    this.usage.stopPoll(turn);
     this.cancelAmbiguousTerminal(turn);
-    this.resolveTurnPermissions(turn.turnId);
+    this.permissions.resolveTurnPermissions(turn.turnId);
     this.projector.finishTurn(turn.turnId);
     if (this.activeTurn === turn) this.activeTurn = null;
   }
@@ -4332,7 +3176,7 @@ export class OmpProviderSession {
     turn.starting = false;
     turn.steerReady.resolve();
     this.emit({ type: "session.turn", sessionId: this.id, turnId: turn.turnId, state: "started" });
-    if (pollUsage) this.pollUsage(turn);
+    if (pollUsage) this.usage.poll(turn);
   }
   private finishTurn(
     turn: ActiveTurn,
@@ -4362,7 +3206,7 @@ export class OmpProviderSession {
     turn.agentEndPending = false;
     this.cancelLocalOnlyCompletion(turn);
     this.cancelAmbiguousTerminal(turn);
-    this.stopUsagePoll(turn);
+    this.usage.stopPoll(turn);
     if (turn.manualCompactionDeadlineTimer !== undefined) {
       this.scheduler.clear(turn.manualCompactionDeadlineTimer);
       turn.manualCompactionDeadlineTimer = undefined;
@@ -4381,7 +3225,7 @@ export class OmpProviderSession {
     const terminalization = (async () => {
       if (!turn.terminalOutcome?.usageSampled && !this.closed && !this.runtimeDead) {
         await Promise.race([
-          this.boundedUsageSnapshot(turn, FINAL_USAGE_WAIT_MS),
+          this.usage.boundedSnapshot(turn, FINAL_USAGE_WAIT_MS),
           wake.promise.then(() => undefined),
         ]);
       }
@@ -4408,17 +3252,17 @@ export class OmpProviderSession {
       }
       this.imageMaterializer.clear();
       turn.terminal = true;
-      if (this.usageSample?.turn === turn) this.usageSample = null;
-      if (!preserveCompactions && this.activeCompaction) {
-        if (outcome.state === "canceled") this.finishCompaction("canceled");
+      this.usage.clearSample(turn);
+      if (!preserveCompactions && this.compaction.active) {
+        if (outcome.state === "canceled") this.compaction.finish("canceled");
         else {
-          this.finishCompaction("failed", {
+          this.compaction.finish("failed", {
             message: outcome.error?.message ?? "OMP compaction ended without a terminal result",
           });
         }
       }
       this.publishPendingUsers(turn);
-      this.resolveTurnPermissions(turn.turnId);
+      this.permissions.resolveTurnPermissions(turn.turnId);
       try {
         this.projector.finishTurn(turn.turnId, preserveCompactions);
       } catch (error) {
@@ -4449,15 +3293,14 @@ export class OmpProviderSession {
   ): void {
     this.imageMaterializer.clear();
     if (this.closed || this.runtimeDead) return;
-    this.discardedCompactionEnds = 0;
-    this.resolveAllPermissions();
+    this.compaction.resetDiscardedEnds();
+    this.permissions.resolveAllPermissions();
     this.recoveryUsesNativeConfig ||=
       this.configRefreshInFlight !== null || this.configRefreshDirty || this.configMutationInFlight;
     const turn = this.activeTurn;
-    if (turn) this.stopUsagePoll(turn);
-    this.usageSample = null;
-    this.finishCompaction(compactionState, { message });
-    this.lastUsage = null;
+    if (turn) this.usage.stopPoll(turn);
+    this.usage.reset();
+    this.compaction.finish(compactionState, { message });
     this.generation += 1;
     this.projector.resetRuntimeGeneration("OMP runtime ended during compaction");
     this.runtimeDead = message;