@omercnet/paseo-omp 0.4.0 → 1.0.0-next.160.1

package/server/provider/session.ts

@@ -1,16 +1,11 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import type {
   ProviderConfigState,
-  ProviderContent,
   ProviderError,
   ProviderEvent,
   ProviderInput,
-  ProviderPermissionResponse,
   ProviderSessionConfig,
-  ProviderToolCallDetail,
-  ProviderUsage,
 } from "@getpaseo/plugin/server/provider";
-import { getForgeDefinitionOrNeutral } from "@getpaseo/protocol/forge-manifest";
 import type {
   OmpOperationalFailure,
   OmpOperationalFailureReporter,
@@ -30,25 +25,27 @@ import {
   withCommittedOmpSelection,
 } from "./config-normalization";
 import { OmpHostToolsBridge, type OmpMcpConnector, validateOmpHostToolConfig } from "./host-tools";
-import { isOmpImageMimeType, isValidImagePayload, OmpImageMaterializer } from "./image";
+import { isOmpImageMimeType, OmpImageMaterializer } from "./image";
+import type { OmpRuntime, OmpRuntimeSession } from "./omp-rpc";
+import { buildOmpSpawnRequest, type OmpStartOptions } from "./omp-rpc-environment";
 import type {
   OmpAvailableCommand,
   OmpBranchResult,
   OmpCompactionResult,
-  OmpExtensionUiResponse,
-  OmpImage,
   OmpMessage,
   OmpModel,
   OmpRpcEvent,
-  OmpRuntime,
-  OmpRuntimeSession,
   OmpSessionState,
-  OmpSessionStats,
-  OmpStartOptions,
-  OmpToolApprovalCancel,
-  OmpToolApprovalRequest,
-} from "./omp-rpc";
-import { buildOmpSpawnRequest, OmpRpcRequestRejectedError } from "./omp-rpc";
+} from "./omp-rpc-protocol";
+import { OmpRpcRequestRejectedError } from "./omp-rpc-transport";
+import {
+  inlinePromptFrameBytes,
+  isSafeCommandName,
+  MAX_PROMPT_TEXT_LENGTH,
+  type OmpPromptPayload,
+  promptPayload,
+  slashCommandName,
+} from "./prompt-payload";
 import {
   BoundedStringSet,
   boundedJsonBytes,
@@ -60,8 +57,24 @@ 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,
+  classifyTerminalCandidate,
+  createActiveTurn,
+  historyTerminalOutcome,
+  nativeEntryId,
+  type PendingUser,
+  type TerminalCandidate,
+  terminalOutcome,
+  unknownTerminalOutcomeError,
+} from "./session-terminal";
+import { OmpSessionUsage } from "./session-usage";
 import { OmpSubsessionProjector } from "./subsessions";
 import {
   defaultOmpTimelineScheduler,
@@ -79,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;
@@ -94,15 +103,12 @@ const USAGE_REFRESH_MS = 100;
 const FINAL_USAGE_WAIT_MS = 250;
 const COMPACTION_MAX_WAIT_MS = 5 * 60_000;
 const AGENT_END_SETTLE_MS = 5_000;
-const MAX_PROMPT_PARTS = 64;
-const MAX_PROMPT_TEXT_LENGTH = 1024 * 1024;
-const RPC_REQUEST_ID_BYTES = 36;
 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;
@@ -114,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",
@@ -234,86 +240,6 @@ async function waitForReplay<T>(operation: Promise<T>, signal: AbortSignal): Pro
   }
 }
 
-type PendingUser = {
-  clientMessageId: string;
-  text: string;
-  accepted: boolean;
-  fallbackOnFinish: boolean;
-  bufferedEchoes: OmpMessage[];
-};
-type TerminalCorrelationEvidence = "fresh-native-user" | "current-assistant";
-
-type TerminalCorrelation = {
-  policy: "initial-turn" | "ordered-legacy" | "native-command";
-  evidence: Map<TerminalCorrelationEvidence, number>;
-};
-
-type TerminalCandidate = {
-  event: Extract<OmpRpcEvent, { type: "agent_end" }>;
-  arrivalSequence: number;
-  confidence:
-    | "keyed"
-    | "initial-turn"
-    | "ordered-legacy"
-    | "native-command"
-    | "interrupted"
-    | "ambiguous";
-};
-
-type ActiveTurn = {
-  turnId: string;
-  clientMessageId: string;
-  generation: number;
-  promptResultEmitted: boolean;
-  started: boolean;
-  terminal: boolean;
-  interrupted: boolean;
-  starting: boolean;
-  nativeActivity: boolean;
-  userEchoObserved: boolean;
-  localOnlyDisabled: boolean;
-  localOnlyEligible: boolean;
-  awaitingPermissionEvidence: boolean;
-  activitySequence: number;
-  acknowledged: boolean;
-  terminalCorrelation: TerminalCorrelation;
-  replayingBufferedEvents: boolean;
-  agentInvoked?: boolean;
-  nativeRequestId?: string;
-  promptAcceptedEventIndex?: number;
-  localOnlyTimer?: unknown;
-  usagePollTimer?: unknown;
-  usagePoll?: Promise<void>;
-  usageSampleFloor: number;
-  manualCompaction: boolean;
-  manualCompactionPending: boolean;
-  manualCompactionDeadlineTimer?: unknown;
-  agentEndPending: boolean;
-  agentEndRetryTimer?: unknown;
-  agentEndDeadlineTimer?: unknown;
-  agentEndCheck?: Promise<void>;
-  ambiguousTerminalTimer?: unknown;
-  terminalizing: boolean;
-  terminalization?: Promise<void>;
-  terminalOutcome?: TurnOutcome;
-  operationalTerminalStage?: "failed" | "unresolved";
-  terminalWake?: VoidDeferred;
-  steerReady: VoidDeferred;
-  steersInFlight: number;
-  deferredAgentEnd?: TerminalCandidate;
-  activeToolCallIds: Set<string>;
-  bufferedEvents: OmpRpcEvent[];
-  pendingUsers: PendingUser[];
-  userEchoes: OmpMessage[];
-  userCorrelationActive: boolean;
-  userLookups: Set<Promise<void>>;
-  completedMessageCount: number;
-  streamedMessageEntryIds: string[];
-  streamedMessageIdentityComplete: boolean;
-  lastCompletedAssistantOutcome?: AgentEndOutcome;
-  lastCompletedAssistantEntryId?: string;
-};
-
 type PendingAbort = {
   turn: ActiveTurn;
   generation: number;
@@ -321,68 +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 VoidDeferred = {
-  promise: Promise<void>;
-  resolve(value?: void | PromiseLike<void>): void;
-  reject(reason?: unknown): void;
-};
-
-type TurnOutcome = {
-  state: "completed" | "failed" | "canceled";
-  error?: ProviderError;
-  usageSampled: boolean;
-};
-
-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 };
 }
@@ -407,492 +271,6 @@ async function settleSessionCleanup(promises: readonly Promise<void>[]): Promise
     throw new AggregateError(failures, "OMP session initialization cleanup failed");
   }
 }
-function isSafeCommandName(name: string): boolean {
-  return /^[A-Za-z0-9][A-Za-z0-9._-]*(?::[A-Za-z0-9][A-Za-z0-9._-]*)*$/u.test(name);
-}
-
-type OmpPromptPayload = { text: string; images: OmpImage[]; commandName?: string };
-
-const REVIEW_LINE_MARKERS = { add: "+", remove: "-", context: " " } as const;
-
-function renderPromptAttachmentAsText(part: Exclude<ProviderContent, { type: "image" }>): string {
-  switch (part.type) {
-    case "forge_change_request": {
-      return renderChangeRequestAttachment({
-        forge: part.forge ?? "github",
-        number: part.number,
-        title: part.title,
-        url: part.url,
-        body: part.body,
-        projectPath: part.projectPath,
-        baseRefName: part.baseRefName,
-        headRefName: part.headRefName,
-      });
-    }
-    case "github_pr": {
-      return renderChangeRequestAttachment({
-        forge: "github",
-        number: part.number,
-        title: part.title,
-        url: part.url,
-        body: part.body,
-        baseRefName: part.baseRefName,
-        headRefName: part.headRefName,
-      });
-    }
-    case "forge_issue": {
-      return renderIssueAttachment({
-        forge: part.forge ?? "github",
-        number: part.number,
-        title: part.title,
-        url: part.url,
-        body: part.body,
-        projectPath: part.projectPath,
-      });
-    }
-    case "github_issue": {
-      return renderIssueAttachment({
-        forge: "github",
-        number: part.number,
-        title: part.title,
-        url: part.url,
-        body: part.body,
-      });
-    }
-    case "text": {
-      return part.text;
-    }
-    case "review": {
-      const lines = [`Paseo review attachment (${part.mode})`, `CWD: ${part.cwd}`];
-      if (part.baseRef) {
-        lines.push(`Base: ${part.baseRef}`);
-      }
-      part.comments.forEach((comment, index) => {
-        lines.push(
-          "",
-          `Comment ${index + 1}: ${comment.filePath}:${comment.side}:${comment.lineNumber}`,
-          comment.body,
-          comment.context.hunkHeader,
-        );
-        const target = comment.context.targetLine;
-        for (const line of comment.context.lines) {
-          const isTarget =
-            line.oldLineNumber === target.oldLineNumber &&
-            line.newLineNumber === target.newLineNumber &&
-            line.type === target.type &&
-            line.content === target.content;
-          const prefix = isTarget ? "> " : "  ";
-          const oldLn = padLineNumber(line.oldLineNumber);
-          const newLn = padLineNumber(line.newLineNumber);
-          lines.push(`${prefix}${oldLn} ${newLn} ${REVIEW_LINE_MARKERS[line.type]}${line.content}`);
-        }
-      });
-      return lines.join("\n");
-    }
-    case "uploaded_file": {
-      return [
-        `Uploaded file: ${part.fileName}`,
-        `Path: ${part.path}`,
-        `MIME: ${part.mimeType}`,
-        `Size: ${part.size} bytes`,
-      ].join("\n");
-    }
-    default:
-      throw new Error("unreachable");
-  }
-}
-
-function renderChangeRequestAttachment(input: {
-  forge: string;
-  number: number;
-  title: string;
-  url: string;
-  body?: string | null;
-  projectPath?: string;
-  baseRefName?: string | null;
-  headRefName?: string | null;
-}): string {
-  const lines = [
-    `${formatForgeLabel(input.forge)} ${formatChangeRequestAbbrev(input.forge)} ${formatChangeRequestNumber(input.forge, input.number)}: ${input.title}`,
-    input.url,
-  ];
-  if (input.projectPath) {
-    lines.push(`Project: ${input.projectPath}`);
-  }
-  if (input.baseRefName) {
-    lines.push(`Base: ${input.baseRefName}`);
-  }
-  if (input.headRefName) {
-    lines.push(`Head: ${input.headRefName}`);
-  }
-  if (input.body) {
-    lines.push("", input.body);
-  }
-  return lines.join("\n");
-}
-
-function renderIssueAttachment(input: {
-  forge: string;
-  number: number;
-  title: string;
-  url: string;
-  body?: string | null;
-  projectPath?: string;
-}): string {
-  const lines = [
-    `${formatForgeLabel(input.forge)} Issue ${formatIssueNumber(input.forge, input.number)}: ${input.title}`,
-    input.url,
-  ];
-  if (input.projectPath) {
-    lines.push(`Project: ${input.projectPath}`);
-  }
-  if (input.body) {
-    lines.push("", input.body);
-  }
-  return lines.join("\n");
-}
-
-function formatForgeLabel(forge: string): string {
-  return getForgeDefinitionOrNeutral(forge).displayName;
-}
-
-function formatChangeRequestAbbrev(forge: string): string {
-  return getForgeDefinitionOrNeutral(forge).changeRequestAbbrev;
-}
-
-function formatChangeRequestNumber(forge: string, number: number): string {
-  return `${getForgeDefinitionOrNeutral(forge).changeRequestNumberPrefix}${number}`;
-}
-
-function formatIssueNumber(forge: string, number: number): string {
-  return `${getForgeDefinitionOrNeutral(forge).issueNumberPrefix}${number}`;
-}
-
-function padLineNumber(lineNumber: number | null): string {
-  return (lineNumber?.toString() ?? "-").padStart(2);
-}
-
-function promptPayload(input: SessionPromptInput): OmpPromptPayload {
-  if (input.prompt.outputSchema !== undefined || input.prompt.clearPendingPermissions) {
-    throw new OmpPublicError("OMP does not support structured output or permission controls");
-  }
-  if (input.prompt.input.type === "command") {
-    const name = input.prompt.input.name.trim();
-    if (!isSafeCommandName(name)) throw new OmpPublicError("Invalid OMP command name");
-    const argumentsText = input.prompt.input.arguments.trim();
-    const text = `/${name}${argumentsText ? ` ${argumentsText}` : ""}`;
-    if (utf8Bytes(text) > MAX_PROMPT_TEXT_LENGTH)
-      throw new OmpPublicError("OMP command is too large");
-    return { text, images: [], commandName: name };
-  }
-  if (input.prompt.input.content.length > MAX_PROMPT_PARTS) {
-    throw new OmpPublicError("OMP prompt has too many content parts");
-  }
-  const parts: string[] = [];
-  const images: OmpImage[] = [];
-  let length = 0;
-  const appendText = (text: string) => {
-    length += utf8Bytes(text) + (parts.length > 0 ? 2 : 0);
-    if (length > MAX_PROMPT_TEXT_LENGTH) throw new OmpPublicError("OMP prompt is too large");
-    parts.push(text);
-  };
-  for (const part of input.prompt.input.content) {
-    if (part.type === "text") {
-      appendText(part.text);
-      continue;
-    }
-    if (part.type === "image") {
-      if (!isValidImagePayload(part.data, part.mimeType, 8 * 1024 * 1024)) {
-        throw new OmpPublicError("OMP prompt image is invalid");
-      }
-      images.push({ type: "image", data: part.data, mimeType: part.mimeType });
-      continue;
-    }
-    appendText(renderPromptAttachmentAsText(part));
-  }
-  const text = parts.join("\n\n").trim();
-  if (!text && images.length === 0) throw new OmpPublicError("OMP prompt cannot be empty");
-  return { text, images };
-}
-
-function inlinePromptFrameBytes(payload: OmpPromptPayload, delivery: "prompt" | "steer"): number {
-  const images = payload.images.map(({ type, mimeType }) => ({ type, data: "", mimeType }));
-  const frame = {
-    type: delivery,
-    message: payload.text,
-    ...(images.length > 0 ? { images } : {}),
-    ...(delivery === "prompt" ? { id: "" } : {}),
-  };
-  const requestIdBytes = delivery === "prompt" ? RPC_REQUEST_ID_BYTES : 0;
-  return (
-    utf8Bytes(JSON.stringify(frame)) +
-    requestIdBytes +
-    payload.images.reduce((total, image) => total + image.data.length, 0) +
-    1
-  );
-}
-
-function slashCommandName(text: string): string | undefined {
-  if (!text.startsWith("/")) return undefined;
-  const body = text.slice(1);
-  if (!body) return undefined;
-  const firstWhitespace = body.search(/\s/u);
-  const name = firstWhitespace === -1 ? body : body.slice(0, firstWhitespace);
-  return name || undefined;
-}
-
-function nativeEntryId(message: OmpMessage): string | undefined {
-  return message.entryId;
-}
-
-type AgentEndOutcome = "completed" | "failed" | "canceled";
-type AssistantTerminalStatus = AgentEndOutcome | "unavailable";
-
-function assistantTerminalOutcome(
-  message: Extract<OmpMessage, { role: "assistant" }>,
-): AgentEndOutcome {
-  const stopReason = message.stopReason?.toLowerCase();
-  if (stopReason === "aborted" || stopReason === "canceled" || stopReason === "cancelled") {
-    return "canceled";
-  }
-  return stopReason === "error" || message.errorMessage ? "failed" : "completed";
-}
-
-function lastAssistantStatus(
-  messages: readonly OmpMessage[],
-  startIndex = 0,
-): AssistantTerminalStatus {
-  for (let index = messages.length - 1; index >= startIndex; index -= 1) {
-    const message = messages[index];
-    if (message?.role !== "assistant") continue;
-    return assistantTerminalOutcome(message);
-  }
-  return "unavailable";
-}
-
-function terminalOutcome(
-  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantOutcome">,
-): AgentEndOutcome | undefined {
-  const messages = event.messages;
-  if (
-    messages !== undefined &&
-    (event.messageCount === undefined || messages.length >= event.messageCount)
-  ) {
-    const status = lastAssistantStatus(messages);
-    return status === "unavailable" ? "completed" : status;
-  }
-  if (event.messageCount === 0) return "completed";
-  if (
-    turn.lastCompletedAssistantOutcome !== undefined &&
-    (event.messageCount === undefined || turn.completedMessageCount >= event.messageCount)
-  ) {
-    return turn.lastCompletedAssistantOutcome;
-  }
-  return undefined;
-}
-
-function historyTerminalOutcome(
-  messages: readonly OmpMessage[],
-  declaredCount: number,
-  turn: Pick<
-    ActiveTurn,
-    | "streamedMessageEntryIds"
-    | "streamedMessageIdentityComplete"
-    | "lastCompletedAssistantOutcome"
-    | "lastCompletedAssistantEntryId"
-  >,
-  retainedMessages: readonly OmpMessage[],
-): AgentEndOutcome | undefined {
-  if (
-    messages.length < declaredCount ||
-    !turn.streamedMessageIdentityComplete ||
-    turn.streamedMessageEntryIds.length === 0
-  ) {
-    return undefined;
-  }
-  const startIndex = messages.length - declaredCount;
-  let historyIndex = startIndex;
-  for (const entryId of turn.streamedMessageEntryIds) {
-    while (historyIndex < messages.length) {
-      const historyMessage = messages[historyIndex];
-      if (historyMessage && nativeEntryId(historyMessage) === entryId) break;
-      historyIndex += 1;
-    }
-    if (historyIndex >= messages.length) return undefined;
-    const correlated = messages[historyIndex];
-    if (
-      entryId === turn.lastCompletedAssistantEntryId &&
-      (correlated?.role !== "assistant" ||
-        assistantTerminalOutcome(correlated) !== turn.lastCompletedAssistantOutcome)
-    )
-      return undefined;
-    historyIndex += 1;
-  }
-  historyIndex = startIndex;
-  for (const retained of retainedMessages) {
-    const entryId = nativeEntryId(retained);
-    if (!entryId) return undefined;
-    while (historyIndex < messages.length) {
-      const historyMessage = messages[historyIndex];
-      if (historyMessage && nativeEntryId(historyMessage) === entryId) break;
-      historyIndex += 1;
-    }
-    if (historyIndex >= messages.length) return undefined;
-    const correlated = messages[historyIndex];
-    if (!correlated || correlated.role !== retained.role) return undefined;
-    if (
-      retained.role === "assistant" &&
-      correlated.role === "assistant" &&
-      assistantTerminalOutcome(retained) !== assistantTerminalOutcome(correlated)
-    )
-      return undefined;
-    historyIndex += 1;
-  }
-  const status = lastAssistantStatus(messages, startIndex);
-  return status === "unavailable" ? undefined : status;
-}
-
-function unknownTerminalOutcomeError(
-  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantOutcome">,
-): string {
-  const retainedMessages = event.messages?.length ?? 0;
-  const retainedStatus = event.messages ? lastAssistantStatus(event.messages) : "unavailable";
-  const lastStatus =
-    retainedStatus === "unavailable"
-      ? (turn.lastCompletedAssistantOutcome ?? "unavailable")
-      : retainedStatus;
-  return (
-    "OMP agent_end omitted terminal messages; outcome is unknown " +
-    `(declaredCount=${event.messageCount ?? "unavailable"}, ` +
-    `observedCount=${turn.completedMessageCount}, ` +
-    `retainedTerminalMessages=${retainedMessages}, lastAssistantStatus=${lastStatus})`
-  );
-}
-
-function isNativeTurnActivity(event: OmpRpcEvent): boolean {
-  if (
-    event.type === "agent_start" ||
-    event.type === "turn_start" ||
-    event.type === "turn_end" ||
-    event.type === "agent_end" ||
-    event.type === "auto_compaction_start" ||
-    event.type === "auto_compaction_end"
-  ) {
-    return true;
-  }
-  if (
-    event.type === "message_start" ||
-    event.type === "message_update" ||
-    event.type === "message_end"
-  ) {
-    return event.message.role === "assistant";
-  }
-  return event.type.startsWith("tool_execution_");
-}
-function isRuntimeConfigEvent(event: OmpRpcEvent): boolean {
-  return (
-    event.type === "model_changed" ||
-    event.type === "thinking_level_changed" ||
-    event.type === "retry_fallback_applied" ||
-    event.type === "retry_fallback_succeeded"
-  );
-}
-
-function isPassiveUiMethod(method: string): boolean {
-  return (
-    method === "cancel" ||
-    method === "notify" ||
-    method === "open_url" ||
-    method === "setStatus" ||
-    method === "setWidget" ||
-    method === "setTitle" ||
-    method === "set_editor_text"
-  );
-}
-function createActiveTurn(
-  clientMessageId: string,
-  text: string,
-  generation: number,
-  terminalPolicy: TerminalCorrelation["policy"],
-  manualCompaction = false,
-): ActiveTurn {
-  return {
-    turnId: randomUUID(),
-    clientMessageId,
-    agentInvoked: undefined,
-    generation,
-    promptResultEmitted: false,
-    started: false,
-    terminal: false,
-    awaitingPermissionEvidence: false,
-    interrupted: false,
-    starting: true,
-    nativeActivity: false,
-    userEchoObserved: false,
-    localOnlyDisabled: false,
-    localOnlyEligible: false,
-    usageSampleFloor: 0,
-    agentEndPending: false,
-    terminalizing: false,
-    manualCompactionPending: manualCompaction,
-    manualCompaction,
-    activitySequence: 0,
-    acknowledged: false,
-    terminalCorrelation: { policy: terminalPolicy, evidence: new Map() },
-    replayingBufferedEvents: false,
-    steersInFlight: 0,
-    activeToolCallIds: new Set(),
-    steerReady: Promise.withResolvers<void>(),
-    userCorrelationActive: false,
-    userLookups: new Set(),
-    userEchoes: [],
-    completedMessageCount: 0,
-    bufferedEvents: [],
-    streamedMessageEntryIds: [],
-    streamedMessageIdentityComplete: true,
-    pendingUsers: [
-      {
-        clientMessageId,
-        text,
-        accepted: true,
-        fallbackOnFinish: true,
-        bufferedEchoes: [],
-      },
-    ],
-  };
-}
-function classifyTerminalCandidate(
-  turn: ActiveTurn,
-  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
-  arrivalSequence = turn.activitySequence,
-): TerminalCandidate {
-  if (event.requestId !== undefined) return { event, confidence: "keyed", arrivalSequence };
-  if (turn.agentInvoked === false) return { event, confidence: "ambiguous", arrivalSequence };
-  if (turn.terminalCorrelation.policy === "initial-turn") {
-    return { event, confidence: "initial-turn", arrivalSequence };
-  }
-  const assistantSequence = turn.terminalCorrelation.evidence.get("current-assistant");
-  if (
-    turn.terminalCorrelation.policy === "native-command" &&
-    assistantSequence !== undefined &&
-    assistantSequence <= arrivalSequence
-  ) {
-    return { event, confidence: "native-command", arrivalSequence };
-  }
-  const userSequence = turn.terminalCorrelation.evidence.get("fresh-native-user");
-  if (
-    userSequence !== undefined &&
-    assistantSequence !== undefined &&
-    userSequence < assistantSequence &&
-    assistantSequence <= arrivalSequence
-  ) {
-    return { event, confidence: "ordered-legacy", arrivalSequence };
-  }
-  return { event, confidence: "ambiguous", arrivalSequence };
-}
-
 export class OmpProviderSession {
   readonly id: string;
   readonly cwd: string;
@@ -928,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;
 
@@ -984,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;
@@ -997,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,
@@ -1046,6 +451,7 @@ export class OmpProviderSession {
     mcpConnector?: OmpMcpConnector,
     mcpInitializationTimeoutMs?: number,
     reportOperationalFailure: OmpOperationalFailureReporter = () => {},
+    hostInheritEnv: readonly string[] = [],
   ): Promise<OmpProviderSession> {
     const resumeSessionId = ompPersistenceSessionId(input);
     if (resumeSessionId && !input.config.persist) {
@@ -1061,6 +467,7 @@ export class OmpProviderSession {
     const normalizedConfig = normalizeOmpSessionConfig(
       effectiveConfig,
       capabilities.includes("permission"),
+      hostInheritEnv,
     );
     const configuredRedactionValues = configuredOutputRedactionValues(
       normalizedConfig.outputRedaction ?? "none",
@@ -1338,289 +745,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");
@@ -1685,7 +809,7 @@ export class OmpProviderSession {
           });
         }
       }
-      messages ??= await waitForReplay(this.runtime.getMessages(), replay.signal);
+      messages ??= await waitForReplay(this.runtime.getMessages(replay.signal), replay.signal);
       this.quarantineBranchEntries();
       for (const message of messages) {
         replay.signal.throwIfAborted();
@@ -1858,7 +982,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();
@@ -2013,8 +1137,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);
@@ -2105,8 +1229,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;
       }
@@ -2278,7 +1402,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;
@@ -2286,7 +1410,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);
     }
   }
@@ -2307,7 +1431,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);
@@ -2718,118 +1842,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> {
@@ -2863,12 +1876,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;
@@ -3027,7 +2040,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();
@@ -3193,7 +2206,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") {
@@ -3201,18 +2214,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" ||
@@ -3223,7 +2235,7 @@ export class OmpProviderSession {
           this.handleRuntimeFailure();
           return;
         }
-        this.publishPermission(event);
+        this.permissions.publishPermission(event);
         return;
       }
 
@@ -3234,6 +2246,17 @@ export class OmpProviderSession {
       this.handleRuntimeFailure();
       return;
     }
+    if (
+      event.type === "config_warnings_changed" ||
+      event.type === "advisor_cost_changed" ||
+      event.type === "ttsr_triggered"
+    ) {
+      return;
+    }
+    if (event.type === "irc_message") {
+      this.projector.projectPassive(event);
+      return;
+    }
     if (
       event.type === "notice" ||
       event.type === "todo_reminder" ||
@@ -3363,50 +2386,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;
-      }
-      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 (this.compaction.handleAutoEnd(turn, event)) {
+        this.usage.schedulePoll(turn, USAGE_REFRESH_MS);
       }
-      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 {
@@ -3681,24 +2674,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]) {
@@ -3730,687 +2705,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()))
@@ -4546,7 +2845,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";
@@ -4576,10 +2875,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);
   }
@@ -4608,7 +2904,7 @@ export class OmpProviderSession {
       this.beginTerminalization(turn, replacement);
       return;
     }
-    this.pollUsage(turn);
+    this.usage.poll(turn);
   }
 
   private beginTerminalization(turn: ActiveTurn, candidate: TerminalCandidate): void {
@@ -4622,11 +2918,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;
@@ -4718,14 +3011,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);
@@ -4738,7 +3031,7 @@ export class OmpProviderSession {
     ) {
       this.resetAgentEndProbe(turn);
       turn.deferredAgentEnd = candidate;
-      this.pollUsage(turn);
+      this.usage.poll(turn);
       return;
     }
     if (state) {
@@ -4780,7 +3073,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 ||
@@ -4858,9 +3151,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;
   }
@@ -4885,7 +3178,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,
@@ -4915,7 +3208,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;
@@ -4934,7 +3227,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),
         ]);
       }
@@ -4961,17 +3254,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) {
@@ -5002,15 +3295,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;