@linzumi/cli 0.0.4-beta → 0.0.6-beta

package/src/channelSession.ts

@@ -33,6 +33,63 @@
   Relationship: Surfaces non-auto-accepted Codex app-server approval requests
   as Kandan message state, then resolves the blocked app-server request only
   after a scoped Kandan approval control arrives.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Batches live Codex streaming deltas at the runner boundary so
+  one logical Codex item stays one Kandan row without per-token persistence
+  churn, while turn completion still flushes all pending live output before
+  final reconciliation.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Stores stream and turn registries in bounded keyed caches so
+  long local Codex turns avoid repeated array replacement while preserving the
+  deterministic reconciliation order required by the transcript state machine.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Keeps approval requests, TUI input mirrors, and turn membership
+  registries keyed by their stable logical ids, so approval resolution,
+  duplicate-output guards, and local-TUI mirroring remain constant-time under
+  long-running shared Codex sessions.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Delegates shared Codex stream timer/flush/forward-chain
+  behavior to `streamDeltaQueue.ts`, leaving this module to map each concrete
+  Codex event kind into Kandan transcript semantics.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Uses `pendingKandanMessageQueue.ts` for accepted human replies
+  so high-volume shared Codex threads drain pending work without repeated
+  `Array.shift()` reindexing, while preserving interrupt fusion and recovery
+  requeue semantics at this orchestration seam.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Delegates app-server runtime option construction to
+  `codexRuntimeOptions.ts` so this orchestrator applies a single tested mapping
+  for model, effort, fast tier, approval policy, and sandbox settings.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Delegates user-visible local Codex message state labels,
+  approval metadata extraction, and Codex notification-to-processing-reason
+  mapping to `localCodexMessageState.ts`.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-codex-driver-worldclass-spec.md
+  Relationship: Delegates pure Codex turn lifecycle queries to
+  `localCodexTurnState.ts` so interruption, completion, and failure paths share
+  one tested interpretation of idle/starting/active/completing states.
+
+- Date: 2026-04-26
+  Spec: plans/2026-04-26-local-runner-port-forward-approval.md
+  Relationship: Watches descendant listener ports, prompts the authorized
+  Kandan listener user for approval, and resolves the approval into a dynamic
+  runner forwarding capability before publishing the same-origin preview URL.
 */
 import {
   availabilityMessage,
@@ -48,6 +105,10 @@ import {
 } from "./channelSessionSupport";
 import { createHash, randomUUID } from "node:crypto";
 import { type CodexAppServerClient } from "./codexAppServer";
+import {
+  codexThreadRuntimeOverrides,
+  codexTurnRuntimeOverrides,
+} from "./codexRuntimeOptions";
 import {
   codexAssistantDeltaFromNotification,
   codexAssistantStructuredMessage,
@@ -64,14 +125,46 @@ import {
   webSearchProgressBody,
   codexUserInputMessageFromNotification,
   codexUserInputMessagesForTurn,
+  type CodexAssistantDelta,
+  type CodexCommandOutputDelta,
+  type CodexFileChangeDelta,
+  type CodexReasoningDelta,
   type CodexUserInputMessage,
 } from "./codexOutput";
 import { arrayValue, integerValue, objectValue, stringValue } from "./json";
 import {
   codexInputForQueuedKandanMessage,
-  interruptQueuedMessages,
   type QueuedKandanMessage,
 } from "./kandanQueue";
+import {
+  approvalRequestKey,
+  codexApprovalMessageState,
+  processingMessageStateFromActive,
+  processingReasonForCodexNotification,
+  type ActiveProcessingState,
+  type CodexApprovalMessageState,
+  type LocalCodexMessageState,
+  type LocalCodexProcessingReason,
+} from "./localCodexMessageState";
+import {
+  activeQueuedSeqForTurn,
+  activeTurnId,
+  completingQueuedSeqForTurn,
+  interruptibleQueuedSeq,
+  markInterruptAfterStart,
+  shouldClearTurnAfterFailure,
+  turnCanForwardByState,
+  type TurnState,
+} from "./localCodexTurnState";
+import {
+  createPendingKandanMessageQueue,
+  dequeuePendingKandanMessage,
+  enqueuePendingKandanMessage,
+  interruptPendingKandanMessages,
+  pendingKandanMessageQueueLength,
+  requeuePendingKandanMessageFront,
+  type PendingKandanMessageQueue,
+} from "./pendingKandanMessageQueue";
 import { type PhoenixClient } from "./phoenix";
 import {
   type JsonObject,
@@ -82,6 +175,46 @@ import {
   isJsonObject,
 } from "./protocol";
 import { type RunnerLogger } from "./runnerLogger";
+import {
+  boundedCacheValues,
+  createBoundedCache,
+  forgetBoundedCacheValue,
+  getBoundedCacheValue,
+  rememberBoundedCacheValue,
+  type BoundedCache,
+} from "./boundedCache";
+import {
+  coalesceAssistantDeltas,
+  coalesceCommandOutputDeltas,
+  coalesceFileChangeDeltas,
+  coalesceReasoningDeltas,
+  firstDeltaTurnId,
+} from "./streamDeltaCoalescing";
+import {
+  clearStreamDeltaFlushTimer,
+  createStreamDeltaQueue,
+  enqueueStreamDelta,
+  flushStreamDeltaQueue,
+  type StreamDeltaQueue,
+  type StreamDeltaQueueRuntime,
+} from "./streamDeltaQueue";
+import {
+  startPortForwardWatcher,
+  type PortForwardCandidate,
+  type PortForwardWatcher,
+  type PortForwardWatcherOptions,
+} from "./portForwardWatcher";
+import {
+  approvedTargetFromRequest,
+  forwardPreviewPath,
+  pendingRequestFromCandidate,
+  portForwardPromptBody,
+  portForwardPromptLabel,
+  portForwardPromptReason,
+  reviewPortForwardCandidate,
+  revocationCapabilities,
+  type PendingPortForwardRequest,
+} from "./portForwardApproval";
 
 export type ChannelSessionRuntime = {
   readonly handleCodexNotification: (
@@ -102,9 +235,20 @@ export type ChannelSessionRunnerOptions = {
   readonly codexBin: string;
   readonly fast?: boolean | undefined;
   readonly launchTui?: boolean | undefined;
+  readonly enablePortForwardWatch?: boolean | undefined;
+  readonly initialForwardPorts?: readonly number[] | undefined;
+  readonly suppressedForwardPorts?: (() => readonly number[]) | undefined;
+  readonly portForwardWatcher?: PortForwardWatchRuntimeOptions | undefined;
+  readonly onForwardPortApproved?: ((port: number) => JsonObject | undefined) | undefined;
+  readonly onForwardPortRevoked?: ((port: number) => JsonObject | undefined) | undefined;
   readonly channelSession: KandanChannelSessionOptions;
 };
 
+type PortForwardWatchRuntimeOptions =
+  Partial<Omit<PortForwardWatcherOptions, "onCandidate">> & {
+    readonly start?: ((options: PortForwardWatcherOptions) => PortForwardWatcher) | undefined;
+  };
+
 type ChannelSessionContext = {
   readonly kandan: PhoenixClient;
   readonly codex: CodexAppServerClient;
@@ -121,39 +265,39 @@ type ChannelSessionState = {
   turn: TurnState;
   closed: boolean;
   minSeq: number;
-  queue: QueuedKandanMessage[];
-  forwardedTurnIds: string[];
-  forwardingTurnIds: string[];
-  retryableTurnIds: string[];
-  localTuiTurnIds: string[];
-  mirroredTuiInputProjections: MirroredTuiInputProjection[];
-  pendingTuiInputMirrors: PendingTuiInputMirror[];
-  turnReplyTargets: TurnReplyTarget[];
-  streamingAssistantOutputs: StreamingAssistantOutput[];
-  streamingReasoningOutputs: StreamingReasoningOutput[];
-  streamingCommandOutputs: StreamingCommandOutput[];
-  streamingFileChangeOutputs: StreamingFileChangeOutput[];
-  forwardedTerminalInputKeys: string[];
-  webSearchProgressOutputs: WebSearchProgressOutput[];
-  pendingApprovalRequests: PendingCodexApprovalRequest[];
+  queue: PendingKandanMessageQueue;
+  forwardedTurnIds: Set<string>;
+  forwardingTurnIds: Set<string>;
+  retryableTurnIds: Set<string>;
+  localTuiTurnIds: Set<string>;
+  mirroredTuiInputProjections: BoundedCache<MirroredTuiInputProjection>;
+  pendingTuiInputMirrors: Map<string, Promise<void>>;
+  turnReplyTargets: BoundedCache<TurnReplyTarget>;
+  streamingAssistantOutputs: BoundedCache<StreamingAssistantOutput>;
+  streamingReasoningOutputs: BoundedCache<StreamingReasoningOutput>;
+  streamingCommandOutputs: BoundedCache<StreamingCommandOutput>;
+  streamingFileChangeOutputs: BoundedCache<StreamingFileChangeOutput>;
+  assistantDeltaQueue: StreamDeltaQueue<CodexAssistantDelta>;
+  reasoningDeltaQueue: StreamDeltaQueue<CodexReasoningDelta>;
+  commandOutputQueue: StreamDeltaQueue<CodexCommandOutputDelta>;
+  fileChangeQueue: StreamDeltaQueue<CodexFileChangeDelta>;
+  forwardedTerminalInputKeys: Set<string>;
+  webSearchProgressOutputs: BoundedCache<WebSearchProgressOutput>;
+  pendingApprovalRequests: Map<string, PendingCodexApprovalRequest>;
+  pendingPortForwardRequests: Map<string, PendingPortForwardRequest>;
+  approvedForwardPorts: Set<number>;
+  approvedForwardTargets: Map<number, PortForwardCandidate>;
+  dismissedForwardTargets: Map<number, PortForwardCandidate>;
+  portForwardWatcher: PortForwardWatcher | undefined;
   activeProcessingState: ActiveProcessingState | undefined;
-  assistantDeltaForwardChain: Promise<void>;
-  reasoningDeltaForwardChain: Promise<void>;
-  commandOutputForwardChain: Promise<void>;
-  fileChangeForwardChain: Promise<void>;
   terminalInputForwardChain: Promise<void>;
   webSearchProgressForwardChain: Promise<void>;
   typingHeartbeat: ReturnType<typeof setInterval> | undefined;
   typingHeartbeatInFlight: boolean;
 };
 
-type TurnState =
-  | { readonly status: "idle" }
-  | { readonly status: "starting"; readonly queuedSeq: number; readonly interruptAfterStart: boolean }
-  | { readonly status: "active"; readonly turnId: string; readonly queuedSeq: number }
-  | { readonly status: "completing"; readonly turnId: string; readonly queuedSeq: number };
-
 const codexTypingHeartbeatMs = 5_000;
+const defaultStreamFlushIntervalMs = 150;
 const maxForwardedTurnIds = 64;
 
 type StreamingAssistantOutput = {
@@ -200,27 +344,11 @@ type MirroredTuiInputProjection = {
   readonly itemKeys: string[];
 };
 
-type PendingTuiInputMirror = {
-  readonly turnId: string;
-  readonly promise: Promise<void>;
-};
-
 type TurnReplyTarget = {
   readonly turnId: string;
   readonly replyToSeq: number;
 };
 
-type ActiveProcessingState =
-  | {
-      readonly seq: number;
-      readonly reason: Exclude<LocalCodexProcessingReason, "awaiting approval">;
-    }
-  | {
-      readonly seq: number;
-      readonly reason: "awaiting approval";
-      readonly approval: CodexApprovalMessageState;
-    };
-
 type PendingCodexApprovalRequest = {
   readonly requestId: string;
   readonly sourceSeq: number;
@@ -229,12 +357,6 @@ type PendingCodexApprovalRequest = {
   readonly reject: (error: Error) => void;
 };
 
-type CodexApprovalMessageState = {
-  readonly requestId: string;
-  readonly kind: string;
-  readonly summary: string;
-};
-
 export async function attachChannelSession(
   args: ChannelSessionContext,
 ): Promise<ChannelSessionRuntime> {
@@ -283,6 +405,7 @@ export async function attachChannelSession(
   await bindChannelSession(args, state, payloadContext);
   await processBufferedKandanEvents(args, state, runnerIdentity, payloadContext, eventBuffer.pending);
   eventBuffer.ready = true;
+  startPortForwardWatchIfEnabled(args, state, payloadContext);
   await drainKandanMessageQueue(args, state, payloadContext);
 
   return {
@@ -401,6 +524,9 @@ export async function attachChannelSession(
     },
     close: async () => {
       state.closed = true;
+      state.portForwardWatcher?.close();
+      state.portForwardWatcher = undefined;
+      clearPendingStreamFlushTimers(state);
       rejectPendingApprovalRequests(state, new Error("runner closed"));
       await stopCodexTyping(args, state);
     },
@@ -436,26 +562,31 @@ function initialChannelSessionState(
     turn: { status: "idle" },
     closed: false,
     minSeq: cursor,
-    queue: [],
-    forwardedTurnIds: [],
-    forwardingTurnIds: [],
-    retryableTurnIds: [],
-    localTuiTurnIds: [],
-    mirroredTuiInputProjections: [],
-    pendingTuiInputMirrors: [],
-    turnReplyTargets: [],
-    streamingAssistantOutputs: [],
-    streamingReasoningOutputs: [],
-    streamingCommandOutputs: [],
-    streamingFileChangeOutputs: [],
-    forwardedTerminalInputKeys: [],
-    webSearchProgressOutputs: [],
-    pendingApprovalRequests: [],
+    queue: createPendingKandanMessageQueue(),
+    forwardedTurnIds: new Set<string>(),
+    forwardingTurnIds: new Set<string>(),
+    retryableTurnIds: new Set<string>(),
+    localTuiTurnIds: new Set<string>(),
+    mirroredTuiInputProjections: createBoundedCache(maxForwardedTurnIds),
+    pendingTuiInputMirrors: new Map<string, Promise<void>>(),
+    turnReplyTargets: createBoundedCache(maxForwardedTurnIds),
+    streamingAssistantOutputs: createBoundedCache(maxForwardedTurnIds),
+    streamingReasoningOutputs: createBoundedCache(maxForwardedTurnIds),
+    streamingCommandOutputs: createBoundedCache(maxForwardedTurnIds),
+    streamingFileChangeOutputs: createBoundedCache(maxForwardedTurnIds),
+    assistantDeltaQueue: createStreamDeltaQueue(),
+    reasoningDeltaQueue: createStreamDeltaQueue(),
+    commandOutputQueue: createStreamDeltaQueue(),
+    fileChangeQueue: createStreamDeltaQueue(),
+    forwardedTerminalInputKeys: new Set<string>(),
+    webSearchProgressOutputs: createBoundedCache(maxForwardedTurnIds),
+    pendingApprovalRequests: new Map<string, PendingCodexApprovalRequest>(),
+    pendingPortForwardRequests: new Map<string, PendingPortForwardRequest>(),
+    approvedForwardPorts: new Set<number>(),
+    approvedForwardTargets: new Map<number, PortForwardCandidate>(),
+    dismissedForwardTargets: new Map<number, PortForwardCandidate>(),
+    portForwardWatcher: undefined,
     activeProcessingState: undefined,
-    assistantDeltaForwardChain: Promise.resolve(),
-    reasoningDeltaForwardChain: Promise.resolve(),
-    commandOutputForwardChain: Promise.resolve(),
-    fileChangeForwardChain: Promise.resolve(),
     terminalInputForwardChain: Promise.resolve(),
     webSearchProgressForwardChain: Promise.resolve(),
     typingHeartbeat: undefined,
@@ -463,6 +594,27 @@ function initialChannelSessionState(
   };
 }
 
+function startPortForwardWatchIfEnabled(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+): void {
+  if (args.options.enablePortForwardWatch !== true || state.portForwardWatcher !== undefined) {
+    return;
+  }
+
+  const { start: configuredStart, ...watchOptions } = args.options.portForwardWatcher ?? {};
+  const start = configuredStart ?? startPortForwardWatcher;
+  for (const port of args.options.initialForwardPorts ?? []) {
+    state.approvedForwardPorts.add(port);
+  }
+  state.portForwardWatcher = start({
+    ...watchOptions,
+    onCandidate: candidate => publishPortForwardPrompt(args, state, payloadContext, candidate),
+    onError: error => args.log("port_forward.watch_failed", { message: error.message }),
+  });
+}
+
 async function bindChannelSession(
   args: ChannelSessionContext,
   state: ChannelSessionState,
@@ -531,6 +683,10 @@ async function handleChannelSessionControl(
     return resolvePendingCodexApprovalRequest(args, state, control);
   }
 
+  if (control.type === "resolve_port_forward_request") {
+    return resolvePendingPortForwardRequest(args, state, payloadContext, control);
+  }
+
   if (control.type !== "interrupt_queued_messages") {
     return undefined;
   }
@@ -543,11 +699,8 @@ async function handleChannelSessionControl(
     return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
   }
 
-  const interrupted = interruptQueuedMessages(state.queue, control.throughSeq);
-  const activeQueuedSeq =
-    state.turn.status === "active" || state.turn.status === "starting"
-      ? state.turn.queuedSeq
-      : undefined;
+  const interrupted = interruptPendingKandanMessages(state.queue, control.throughSeq);
+  const activeQueuedSeq = interruptibleQueuedSeq(state.turn);
   const targetsActiveTurn =
     control.throughSeq !== undefined && activeQueuedSeq === control.throughSeq;
 
@@ -563,7 +716,6 @@ async function handleChannelSessionControl(
         turnId: state.turn.turnId,
       });
 
-      state.queue = interrupted.ok ? interrupted.queue : state.queue;
       state.turn = { status: "idle" };
       clearActiveProcessingState(state, interruptedActiveSeq);
       await publishMessageState(args, state.kandanThreadId, interruptedActiveSeq, {
@@ -571,23 +723,19 @@ async function handleChannelSessionControl(
       });
       break;
     case "starting":
-      state.queue = interrupted.ok ? interrupted.queue : state.queue;
-      state.turn = {
-        status: "starting",
-        queuedSeq: state.turn.queuedSeq,
-        interruptAfterStart: true,
-      };
+      state.turn = markInterruptAfterStart(state.turn);
       break;
     case "idle":
     case "completing":
-      state.queue = interrupted.ok ? interrupted.queue : state.queue;
       break;
   }
 
   args.log("codex.queued_messages_interrupted", {
     through_seq: control.throughSeq ?? null,
     selected_count: interrupted.ok ? interrupted.selectedCount : 0,
-    remaining_count: interrupted.ok ? interrupted.remainingCount : state.queue.length,
+    remaining_count: interrupted.ok
+      ? interrupted.remainingCount
+      : pendingKandanMessageQueueLength(state.queue),
   });
   if (interrupted.ok) {
     for (const seq of interrupted.selectedSeqs) {
@@ -618,19 +766,15 @@ async function resolvePendingCodexApprovalRequest(
     return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
   }
 
-  const approval = state.pendingApprovalRequests.find(
-    pending =>
-      pending.requestId === control.requestId &&
-      pending.sourceSeq === control.sourceSeq,
+  const approval = state.pendingApprovalRequests.get(
+    approvalRequestKey(control.requestId, control.sourceSeq),
   );
 
   if (approval === undefined) {
     return { instanceId: args.instanceId, ok: false, error: "approval_request_not_found" };
   }
 
-  state.pendingApprovalRequests = state.pendingApprovalRequests.filter(
-    pending => pending !== approval,
-  );
+  state.pendingApprovalRequests.delete(approvalRequestKey(control.requestId, control.sourceSeq));
 
   const codexDecision = control.decision === "approve" ? "accept" : "decline";
   approval.resolve({ decision: codexDecision });
@@ -651,6 +795,335 @@ async function resolvePendingCodexApprovalRequest(
   return { instanceId: args.instanceId, ok: true };
 }
 
+async function resolvePendingPortForwardRequest(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+  control: Extract<KandanControl, { readonly type: "resolve_port_forward_request" }>,
+): Promise<JsonObject> {
+  if (!portForwardControlSenderAllowed(args, payloadContext, control)) {
+    args.log("port_forward.request_resolution_ignored", {
+      request_id: control.requestId,
+      actor_slug: control.actorSlug ?? null,
+      actor_user_id: control.actorUserId ?? null,
+      reason: "sender_not_allowed",
+    });
+    return { instanceId: args.instanceId, ok: false, error: "sender_not_allowed" };
+  }
+
+  const request = state.pendingPortForwardRequests.get(control.requestId);
+
+  if (request === undefined) {
+    return { instanceId: args.instanceId, ok: false, error: "port_forward_request_not_found" };
+  }
+
+  state.pendingPortForwardRequests.delete(control.requestId);
+
+  if (control.decision === "deny") {
+    state.dismissedForwardTargets.set(request.port, approvedTargetFromRequest(request));
+    await publishMessageStateForPortForwardResult(args, state, request, "failed");
+    args.log("port_forward.request_denied", {
+      request_id: control.requestId,
+      port: request.port,
+      pid: request.pid,
+    });
+    return { instanceId: args.instanceId, ok: true };
+  }
+
+  state.approvedForwardPorts.add(request.port);
+  state.approvedForwardTargets.set(request.port, approvedTargetFromRequest(request));
+  const capabilities = args.options.onForwardPortApproved?.(request.port);
+  await publishForwardPortResolvedEvent(args, request, capabilities);
+  await publishMessageStateForPortForwardResult(args, state, request, "processed");
+  await publishPortForwardReadyMessage(args, state, payloadContext, request);
+
+  args.log("port_forward.request_approved", {
+    request_id: control.requestId,
+    port: request.port,
+    pid: request.pid,
+  });
+
+  return { instanceId: args.instanceId, ok: true, port: request.port };
+}
+
+function portForwardControlSenderAllowed(
+  args: ChannelSessionContext,
+  payloadContext: RunnerPayloadContext,
+  control: Extract<KandanControl, { readonly type: "resolve_port_forward_request" }>,
+): boolean {
+  if (control.actorSlug === undefined && control.actorUserId === undefined) {
+    return false;
+  }
+
+  return senderAllowed(
+    args.options.channelSession.listenUser,
+    {
+      actorSlug: control.actorSlug,
+      actorUserId: control.actorUserId,
+    },
+    payloadContext.runnerIdentity,
+  );
+}
+
+async function publishPortForwardPrompt(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+  candidate: PortForwardCandidate,
+): Promise<void> {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+    args.log("port_forward.prompt_skipped", {
+      port: candidate.port,
+      pid: candidate.pid,
+      reason: "thread_not_bound",
+    });
+    return;
+  }
+
+  const review = reviewPortForwardCandidate({
+    candidate,
+    threadBound: true,
+    suppressedPorts: new Set(args.options.suppressedForwardPorts?.() ?? []),
+    approvedPorts: state.approvedForwardPorts,
+    approvedTargets: state.approvedForwardTargets,
+    dismissedTargets: state.dismissedForwardTargets,
+    pendingRequests: Array.from(state.pendingPortForwardRequests.values()),
+  });
+
+  switch (review.type) {
+    case "skip":
+      return;
+    case "remember_approved_target":
+      state.approvedForwardTargets.set(review.target.port, review.target);
+      return;
+    case "revoke_and_prompt":
+      await revokeApprovedForwardPort(args, state, review.revoked, review.reason);
+      break;
+    case "prompt":
+      break;
+  }
+
+  const requestId = `port-forward-${randomUUID()}`;
+  const label = portForwardPromptLabel(candidate);
+  const body = portForwardPromptBody(candidate, requestId);
+  const payload = {
+    ...localRunnerPayload(
+      args.options,
+      args.instanceId,
+      "port_forward_request",
+      state.codexThreadId,
+      payloadContext,
+    ),
+    reply_to_seq: state.rootSeq ?? null,
+    structured: {
+      kind: "local_runner_port_forward_request",
+      request_id: requestId,
+      port: candidate.port,
+      pid: candidate.pid,
+      command: candidate.command,
+      ...(candidate.cwd === undefined ? {} : { cwd: candidate.cwd }),
+      command_label: label,
+    },
+  };
+
+  const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
+    workspace: args.options.channelSession.workspaceSlug,
+    channel: args.options.channelSession.channelSlug,
+    thread_id: state.kandanThreadId,
+    body,
+    payload,
+  });
+  const sourceSeq = integerValue(reply.seq);
+
+  if (sourceSeq === undefined) {
+    throw new Error("port forward prompt did not return a Kandan message seq");
+  }
+
+  const request = pendingRequestFromCandidate({
+    requestId,
+    sourceSeq,
+    candidate,
+  });
+  state.pendingPortForwardRequests.set(requestId, request);
+
+  await publishForwardPortRequestedEvent(args, request);
+  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
+    status: "processing",
+    reason: "awaiting approval",
+    approval: {
+      requestId,
+      kind: "local_runner_port_forward",
+      summary: `Open runner port ${candidate.port} from ${label}`,
+      reason: portForwardPromptReason(candidate),
+      choices: [
+        {
+          decision: "approve",
+          label: "Open preview",
+          description: `Allow Kandan to proxy HTTP, HTTPS, and WebSocket traffic for runner port ${candidate.port}.`,
+        },
+        {
+          decision: "deny",
+          label: "Deny",
+          description: `Keep runner port ${candidate.port} private for this runner session.`,
+        },
+      ],
+      allowedActorSlug: args.options.channelSession.listenUser,
+      allowedActorUserId:
+        args.options.channelSession.listenUser.toLowerCase() ===
+        (payloadContext.runnerIdentity.actorUsername ?? "").toLowerCase()
+          ? payloadContext.runnerIdentity.actorUserId
+          : undefined,
+    },
+  });
+
+  args.log("port_forward.request_pending", {
+    request_id: requestId,
+    port: candidate.port,
+    pid: candidate.pid,
+  });
+}
+
+async function revokeApprovedForwardPort(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  target: PortForwardCandidate,
+  reason: "listener_changed",
+): Promise<void> {
+  state.approvedForwardPorts.delete(target.port);
+  state.approvedForwardTargets.delete(target.port);
+  const capabilities = args.options.onForwardPortRevoked?.(target.port);
+
+  await pushOptional(args.kandan, args.topic, "forward_port_revoked", {
+    instanceId: args.instanceId,
+    port: target.port,
+    pid: target.pid,
+    command: target.command,
+    ...(target.cwd === undefined ? {} : { cwd: target.cwd }),
+    reason,
+    capabilities: revocationCapabilities(capabilities, target.port),
+  }, args.log);
+
+  args.log("port_forward.approved_port_revoked", {
+    port: target.port,
+    pid: target.pid,
+    reason,
+  });
+}
+
+async function publishPortForwardReadyMessage(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+  request: PendingPortForwardRequest,
+): Promise<void> {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+    return;
+  }
+
+  const path = forwardPreviewPath(args.options.runnerId, request.port);
+  await pushOptional(args.kandan, args.topic, "session:post_thread_message", {
+    workspace: args.options.channelSession.workspaceSlug,
+    channel: args.options.channelSession.channelSlug,
+    thread_id: state.kandanThreadId,
+    body: `Runner port ${request.port} is open in Kandan: [Open preview](${path})`,
+    payload: {
+      ...localRunnerPayload(
+        args.options,
+        args.instanceId,
+        "port_forward_ready",
+        state.codexThreadId,
+        payloadContext,
+      ),
+      ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
+      structured: {
+        kind: "local_runner_port_forward_ready",
+        status: "ready",
+        summary: `Runner port ${request.port} is open in Kandan.`,
+        next_action: "Open HTTP/HTTPS/WebSocket preview",
+        source_path: path,
+        link_label: "Open preview",
+        request_id: request.requestId,
+        port: request.port,
+        pid: request.pid,
+        command: request.command,
+        ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
+        url: path,
+      },
+    },
+  }, args.log);
+}
+
+async function publishForwardPortRequestedEvent(
+  args: ChannelSessionContext,
+  request: PendingPortForwardRequest,
+): Promise<void> {
+  await pushOptional(args.kandan, args.topic, "forward_port_requested", {
+    instanceId: args.instanceId,
+    requestId: request.requestId,
+    port: request.port,
+    pid: request.pid,
+    command: request.command,
+    ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
+  }, args.log);
+}
+
+async function publishForwardPortResolvedEvent(
+  args: ChannelSessionContext,
+  request: PendingPortForwardRequest,
+  capabilities: JsonObject | undefined,
+): Promise<void> {
+  await pushOptional(args.kandan, args.topic, "forward_port_resolved", {
+    instanceId: args.instanceId,
+    requestId: request.requestId,
+    port: request.port,
+    pid: request.pid,
+    command: request.command,
+    ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
+    decision: "approve",
+    ...(capabilities === undefined ? {} : { capabilities }),
+  }, args.log);
+}
+
+async function publishMessageStateForPortForwardResult(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  request: PendingPortForwardRequest,
+  status: "processed" | "failed",
+): Promise<void> {
+  if (state.kandanThreadId === undefined) {
+    return;
+  }
+
+  switch (status) {
+    case "processed":
+      await publishMessageState(args, state.kandanThreadId, request.sourceSeq, {
+        status: "processed",
+      });
+      break;
+    case "failed":
+      await publishMessageState(args, state.kandanThreadId, request.sourceSeq, {
+        status: "failed",
+        reason: "port_forward_denied",
+      });
+      break;
+  }
+}
+
+function parsePortForwardDecision(
+  body: string,
+): { readonly decision: "approve" | "deny"; readonly requestId: string } | undefined {
+  const match = body.trim().match(/^\/kandan\s+(approve|deny)-port-forward\s+(\S+)$/i);
+
+  if (match === null) {
+    return undefined;
+  }
+
+  return {
+    decision: match[1]?.toLocaleLowerCase() === "approve" ? "approve" : "deny",
+    requestId: match[2] ?? "",
+  };
+}
+
 async function handleKandanChatEvent(
   args: ChannelSessionContext,
   state: ChannelSessionState,
@@ -698,6 +1171,28 @@ async function handleKandanChatEvent(
     return;
   }
 
+  const portForwardDecision = parsePortForwardDecision(event.body);
+  if (portForwardDecision !== undefined) {
+    const result = await resolvePendingPortForwardRequest(args, state, payloadContext, {
+      type: "resolve_port_forward_request",
+      instanceId: args.instanceId,
+      requestId: portForwardDecision.requestId,
+      decision: portForwardDecision.decision,
+      actorUserId: event.actorUserId,
+      actorSlug: event.actorSlug,
+    });
+
+    if (result.ok === true) {
+      await publishKandanMessageState(args, event, { status: "processed" });
+    } else {
+      await publishKandanMessageState(args, event, {
+        status: "failed",
+        reason: stringValue(result.error) ?? "port_forward_decision_failed",
+      });
+    }
+    return;
+  }
+
   if (state.kandanThreadId === undefined) {
     if (state.rootSeq === undefined || event.replyToSeq !== state.rootSeq) {
       const bound = await bindUnboundHistoricalThread(args, state, event);
@@ -734,7 +1229,7 @@ async function handleKandanChatEvent(
     return;
   }
 
-  state.queue.push({
+  enqueuePendingKandanMessage(state.queue, {
     seq: event.seq,
     actorSlug: event.actorSlug,
     actorUserId: event.actorUserId,
@@ -744,7 +1239,7 @@ async function handleKandanChatEvent(
     seq: event.seq,
     actor_slug: event.actorSlug ?? null,
     actor_user_id: event.actorUserId ?? null,
-    queue_depth: state.queue.length,
+    queue_depth: pendingKandanMessageQueueLength(state.queue),
   });
   await publishKandanMessageState(args, event, { status: "queued" });
   await drainKandanMessageQueue(args, state, payloadContext);
@@ -852,7 +1347,7 @@ async function drainKandanMessageQueue(
     return;
   }
 
-  const next = state.queue.shift();
+  const next = dequeuePendingKandanMessage(state.queue);
 
   if (next === undefined) {
     return;
@@ -865,7 +1360,7 @@ async function drainKandanMessageQueue(
     actor_slug: next.actorSlug ?? null,
     actor_user_id: next.actorUserId ?? null,
     codex_thread_id: state.codexThreadId ?? null,
-    queue_depth: state.queue.length,
+    queue_depth: pendingKandanMessageQueueLength(state.queue),
   });
   await publishQueuedMessageState(args, state, next, {
     status: "processing",
@@ -928,7 +1423,7 @@ async function drainKandanMessageQueue(
           oldCodexThreadId,
           newCodexThreadId,
         );
-        state.queue = [next, ...state.queue];
+        requeuePendingKandanMessageFront(state.queue, next);
         state.turn = { status: "idle" };
         await drainKandanMessageQueue(args, state, payloadContext);
         return;
@@ -1026,7 +1521,7 @@ async function requestKandanApproval(
   turnId: string,
   payloadContext: RunnerPayloadContext,
 ): Promise<JsonObject> {
-  const sourceSeq = activeQueuedSeqForTurn(state, turnId);
+  const sourceSeq = activeQueuedSeqForTurn(state.turn, turnId);
 
   if (sourceSeq === undefined || state.kandanThreadId === undefined) {
     const message = `Codex approval request has no active Kandan source message: ${request.method}`;
@@ -1050,43 +1545,23 @@ async function requestKandanApproval(
   });
 
   return new Promise<JsonObject>((resolve, reject) => {
-    state.pendingApprovalRequests = [
-      ...state.pendingApprovalRequests,
-      {
-        requestId: approval.requestId,
-        sourceSeq,
-        turnId,
-        resolve,
-        reject,
-      },
-    ];
+    const request = {
+      requestId: approval.requestId,
+      sourceSeq,
+      turnId,
+      resolve,
+      reject,
+    };
+    state.pendingApprovalRequests.set(
+      approvalRequestKey(request.requestId, request.sourceSeq),
+      request,
+    );
   });
 }
 
-function codexApprovalMessageState(request: JsonRpcRequest): CodexApprovalMessageState {
-  const params = objectValue(request.params) ?? {};
-  const command = stringValue(params.command) ?? stringValue(params.cmd);
-  const filePath =
-    stringValue(params.path) ??
-    stringValue(params.filePath) ??
-    stringValue(params.file);
-  const summary =
-    command ??
-    filePath ??
-    stringValue(params.reason) ??
-    stringValue(params.summary) ??
-    request.method;
-
-  return {
-    requestId: String(request.id),
-    kind: request.method,
-    summary,
-  };
-}
-
 function rejectPendingApprovalRequests(state: ChannelSessionState, error: Error): void {
-  const pendingApprovals = state.pendingApprovalRequests;
-  state.pendingApprovalRequests = [];
+  const pendingApprovals = [...state.pendingApprovalRequests.values()];
+  state.pendingApprovalRequests.clear();
   pendingApprovals.forEach(approval => approval.reject(error));
 }
 
@@ -1095,11 +1570,12 @@ function rejectPendingApprovalRequestsForTurn(
   turnId: string,
   error: Error,
 ): void {
-  const pendingApprovals = state.pendingApprovalRequests;
-  state.pendingApprovalRequests = pendingApprovals.filter(approval => approval.turnId !== turnId);
-  pendingApprovals
-    .filter(approval => approval.turnId === turnId)
-    .forEach(approval => approval.reject(error));
+  for (const [key, approval] of state.pendingApprovalRequests) {
+    if (approval.turnId === turnId) {
+      state.pendingApprovalRequests.delete(key);
+      approval.reject(error);
+    }
+  }
 }
 
 async function forwardCompletedCodexTurn(
@@ -1115,24 +1591,21 @@ async function forwardCompletedCodexTurn(
   if (
     state.kandanThreadId === undefined ||
     state.codexThreadId === undefined ||
-    state.forwardedTurnIds.includes(turnId) ||
-    state.forwardingTurnIds.includes(turnId) ||
+    state.forwardedTurnIds.has(turnId) ||
+    state.forwardingTurnIds.has(turnId) ||
     !turnCanForward(state, turnId)
   ) {
     return;
   }
 
-  const completingQueuedSeq =
-    state.turn.status === "active" && state.turn.turnId === turnId
-      ? state.turn.queuedSeq
-      : undefined;
+  const completingQueuedSeq = completingQueuedSeqForTurn(state.turn, turnId);
   const completingActiveTurn = completingQueuedSeq !== undefined;
   const completingLocalTuiTurn = isLocalTuiTurn(state, turnId);
   if (completingQueuedSeq !== undefined) {
     state.turn = { status: "completing", turnId, queuedSeq: completingQueuedSeq };
   }
   await waitForPendingTuiInputMirror(state, turnId);
-  await waitForStreamingForwardChains(state);
+  await waitForStreamingForwardChains(args, state, payloadContext);
   rememberForwardingTurnId(state, turnId);
   forgetRetryableTurnId(state, turnId);
 
@@ -1200,7 +1673,7 @@ async function forwardCompletedCodexTurn(
 
       if (
         stringValue(message.structured.kind) === "codex_terminal_input" &&
-        state.forwardedTerminalInputKeys.includes(message.itemKey)
+        state.forwardedTerminalInputKeys.has(message.itemKey)
       ) {
         continue;
       }
@@ -1311,13 +1784,22 @@ async function forwardAssistantDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+  const delta = codexAssistantDeltaFromNotification(params);
+
+  if (delta === undefined) {
     return;
   }
 
-  const delta = codexAssistantDeltaFromNotification(params);
+  await forwardAssistantDeltaPayload(args, state, delta, payloadContext);
+}
 
-  if (delta === undefined) {
+async function forwardAssistantDeltaPayload(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  delta: CodexAssistantDelta,
+  payloadContext: RunnerPayloadContext,
+): Promise<void> {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     return;
   }
 
@@ -1421,17 +1903,17 @@ function enqueueAssistantDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): void {
-  const previous = state.assistantDeltaForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => forwardAssistantDelta(args, state, params, payloadContext));
+  const delta = codexAssistantDeltaFromNotification(params);
 
-  state.assistantDeltaForwardChain = next.catch(error => {
-    args.log("codex.delta_forward_failed", {
-      turn_id: codexNotificationTurnId(params) ?? null,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
+  if (delta === undefined) {
+    return;
+  }
+
+  enqueueStreamDelta(
+    state.assistantDeltaQueue,
+    delta,
+    assistantDeltaQueueRuntime(args, state, payloadContext),
+  );
 }
 
 function enqueueReasoningDelta(
@@ -1440,17 +1922,17 @@ function enqueueReasoningDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): void {
-  const previous = state.reasoningDeltaForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => forwardReasoningDelta(args, state, params, payloadContext));
+  const delta = codexReasoningDeltaFromNotification(params);
 
-  state.reasoningDeltaForwardChain = next.catch(error => {
-    args.log("codex.reasoning_delta_forward_failed", {
-      turn_id: codexNotificationTurnId(params) ?? null,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
+  if (delta === undefined) {
+    return;
+  }
+
+  enqueueStreamDelta(
+    state.reasoningDeltaQueue,
+    delta,
+    reasoningDeltaQueueRuntime(args, state, payloadContext),
+  );
 }
 
 function enqueueCommandOutputDelta(
@@ -1459,17 +1941,17 @@ function enqueueCommandOutputDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): void {
-  const previous = state.commandOutputForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => forwardCommandOutputDelta(args, state, params, payloadContext));
+  const delta = codexCommandOutputDeltaFromNotification(params);
 
-  state.commandOutputForwardChain = next.catch(error => {
-    args.log("codex.command_output_forward_failed", {
-      turn_id: codexNotificationTurnId(params) ?? null,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
+  if (delta === undefined) {
+    return;
+  }
+
+  enqueueStreamDelta(
+    state.commandOutputQueue,
+    delta,
+    commandOutputQueueRuntime(args, state, payloadContext),
+  );
 }
 
 function enqueueFileChangeDelta(
@@ -1478,17 +1960,97 @@ function enqueueFileChangeDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): void {
-  const previous = state.fileChangeForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => forwardFileChangeDelta(args, state, params, payloadContext));
+  const delta = codexFileChangeDeltaFromNotification(params);
 
-  state.fileChangeForwardChain = next.catch(error => {
-    args.log("codex.file_change_forward_failed", {
-      turn_id: codexNotificationTurnId(params) ?? null,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
+  if (delta === undefined) {
+    return;
+  }
+
+  enqueueStreamDelta(
+    state.fileChangeQueue,
+    delta,
+    fileChangeQueueRuntime(args, state, payloadContext),
+  );
+}
+
+function assistantDeltaQueueRuntime(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+): StreamDeltaQueueRuntime<CodexAssistantDelta> {
+  return {
+    flushIntervalMs: streamFlushIntervalMs(args),
+    coalesce: coalesceAssistantDeltas,
+    firstTurnId: firstDeltaTurnId,
+    forward: delta => forwardAssistantDeltaPayload(args, state, delta, payloadContext),
+    logFailure: (turnId, error) => {
+      args.log("codex.delta_forward_failed", {
+        turn_id: turnId ?? null,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    },
+  };
+}
+
+function reasoningDeltaQueueRuntime(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+): StreamDeltaQueueRuntime<CodexReasoningDelta> {
+  return {
+    flushIntervalMs: streamFlushIntervalMs(args),
+    coalesce: coalesceReasoningDeltas,
+    firstTurnId: firstDeltaTurnId,
+    forward: delta => forwardReasoningDeltaPayload(args, state, delta, payloadContext),
+    logFailure: (turnId, error) => {
+      args.log("codex.reasoning_delta_forward_failed", {
+        turn_id: turnId ?? null,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    },
+  };
+}
+
+function commandOutputQueueRuntime(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+): StreamDeltaQueueRuntime<CodexCommandOutputDelta> {
+  return {
+    flushIntervalMs: streamFlushIntervalMs(args),
+    coalesce: coalesceCommandOutputDeltas,
+    firstTurnId: firstDeltaTurnId,
+    forward: delta => forwardCommandOutputDeltaPayload(args, state, delta, payloadContext),
+    logFailure: (turnId, error) => {
+      args.log("codex.command_output_forward_failed", {
+        turn_id: turnId ?? null,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    },
+  };
+}
+
+function fileChangeQueueRuntime(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+): StreamDeltaQueueRuntime<CodexFileChangeDelta> {
+  return {
+    flushIntervalMs: streamFlushIntervalMs(args),
+    coalesce: coalesceFileChangeDeltas,
+    firstTurnId: firstDeltaTurnId,
+    forward: delta => forwardFileChangeDeltaPayload(args, state, delta, payloadContext),
+    logFailure: (turnId, error) => {
+      args.log("codex.file_change_forward_failed", {
+        turn_id: turnId ?? null,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    },
+  };
+}
+
+function streamFlushIntervalMs(args: ChannelSessionContext): number {
+  return args.options.channelSession.streamFlushMs ?? defaultStreamFlushIntervalMs;
 }
 
 function enqueueTerminalInput(
@@ -1552,12 +2114,12 @@ function enqueueFileChangeCompletion(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  const previous = state.fileChangeForwardChain;
+  const previous = state.fileChangeQueue.chain;
   const next = previous
     .catch(() => undefined)
     .then(() => completeFileChangeOutputs(args, state, turnId));
 
-  state.fileChangeForwardChain = next.catch(error => {
+  state.fileChangeQueue.chain = next.catch(error => {
     args.log("codex.file_change_completion_failed", {
       turn_id: turnId,
       message: error instanceof Error ? error.message : String(error),
@@ -1571,17 +2133,26 @@ async function forwardReasoningDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+  const delta = codexReasoningDeltaFromNotification(params);
+
+  if (delta === undefined) {
     return;
   }
 
-  const delta = codexReasoningDeltaFromNotification(params);
+  await forwardReasoningDeltaPayload(args, state, delta, payloadContext);
+}
 
-  if (delta === undefined) {
+async function forwardReasoningDeltaPayload(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  delta: CodexReasoningDelta,
+  payloadContext: RunnerPayloadContext,
+): Promise<void> {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     return;
   }
 
-  const turnId = delta.turnId ?? activeTurnId(state);
+  const turnId = delta.turnId ?? activeTurnId(state.turn);
 
   if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
     return;
@@ -1662,17 +2233,26 @@ async function forwardCommandOutputDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+  const delta = codexCommandOutputDeltaFromNotification(params);
+
+  if (delta === undefined) {
     return;
   }
 
-  const delta = codexCommandOutputDeltaFromNotification(params);
+  await forwardCommandOutputDeltaPayload(args, state, delta, payloadContext);
+}
 
-  if (delta === undefined) {
+async function forwardCommandOutputDeltaPayload(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  delta: CodexCommandOutputDelta,
+  payloadContext: RunnerPayloadContext,
+): Promise<void> {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     return;
   }
 
-  const turnId = delta.turnId ?? activeTurnId(state);
+  const turnId = delta.turnId ?? activeTurnId(state.turn);
 
   if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
     return;
@@ -1763,17 +2343,26 @@ async function forwardFileChangeDelta(
   params: JsonObject,
   payloadContext: RunnerPayloadContext,
 ): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
+  const delta = codexFileChangeDeltaFromNotification(params);
+
+  if (delta === undefined) {
     return;
   }
 
-  const delta = codexFileChangeDeltaFromNotification(params);
+  await forwardFileChangeDeltaPayload(args, state, delta, payloadContext);
+}
 
-  if (delta === undefined) {
+async function forwardFileChangeDeltaPayload(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  delta: CodexFileChangeDelta,
+  payloadContext: RunnerPayloadContext,
+): Promise<void> {
+  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
     return;
   }
 
-  const turnId = delta.turnId ?? activeTurnId(state);
+  const turnId = delta.turnId ?? activeTurnId(state.turn);
 
   if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
     return;
@@ -1859,11 +2448,11 @@ async function forwardTerminalInput(
 
   const terminal = codexTerminalInputFromNotification(params);
 
-  if (terminal === undefined || state.forwardedTerminalInputKeys.includes(terminal.itemKey)) {
+  if (terminal === undefined || state.forwardedTerminalInputKeys.has(terminal.itemKey)) {
     return;
   }
 
-  const turnId = terminal.turnId ?? activeTurnId(state);
+  const turnId = terminal.turnId ?? activeTurnId(state.turn);
 
   if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
     return;
@@ -2023,7 +2612,7 @@ async function completeFileChangeOutputs(
   state: ChannelSessionState,
   turnId: string,
 ): Promise<void> {
-  const outputs = state.streamingFileChangeOutputs.filter(
+  const outputs = boundedCacheValues(state.streamingFileChangeOutputs).filter(
     output => output.turnId === turnId,
   );
 
@@ -2215,21 +2804,18 @@ function findMirroredTuiInputProjection(
   state: ChannelSessionState,
   logicalKey: string,
 ): MirroredTuiInputProjection | undefined {
-  return state.mirroredTuiInputProjections.find(
-    projection => projection.logicalKey === logicalKey,
-  );
+  return getBoundedCacheValue(state.mirroredTuiInputProjections, logicalKey);
 }
 
 function rememberMirroredTuiInputProjection(
   state: ChannelSessionState,
   projection: MirroredTuiInputProjection,
 ): void {
-  state.mirroredTuiInputProjections = [
-    ...state.mirroredTuiInputProjections.filter(
-      existing => existing.logicalKey !== projection.logicalKey,
-    ),
+  rememberBoundedCacheValue(
+    state.mirroredTuiInputProjections,
+    projection.logicalKey,
     projection,
-  ].slice(-maxForwardedTurnIds);
+  );
 }
 
 function rememberMirroredTuiInputItemKey(
@@ -2253,28 +2839,28 @@ function findStreamingAssistantOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): StreamingAssistantOutput | undefined {
-  return state.streamingAssistantOutputs.find(output => output.itemKey === itemKey);
+  return getBoundedCacheValue(state.streamingAssistantOutputs, itemKey);
 }
 
 function findStreamingReasoningOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): StreamingReasoningOutput | undefined {
-  return state.streamingReasoningOutputs.find(output => output.itemKey === itemKey);
+  return getBoundedCacheValue(state.streamingReasoningOutputs, itemKey);
 }
 
 function findStreamingCommandOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): StreamingCommandOutput | undefined {
-  return state.streamingCommandOutputs.find(output => output.itemKey === itemKey);
+  return getBoundedCacheValue(state.streamingCommandOutputs, itemKey);
 }
 
 function findStreamingFileChangeOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): StreamingFileChangeOutput | undefined {
-  return state.streamingFileChangeOutputs.find(output => output.itemKey === itemKey);
+  return getBoundedCacheValue(state.streamingFileChangeOutputs, itemKey);
 }
 
 type StreamedStructuredOutput = {
@@ -2352,7 +2938,7 @@ function resolveStreamingAssistantOutputForCompletedMessage(
     return { status: "none" };
   }
 
-  const candidates = state.streamingAssistantOutputs.filter(
+  const candidates = boundedCacheValues(state.streamingAssistantOutputs).filter(
     output => output.turnId === turnId,
   );
 
@@ -2391,8 +2977,8 @@ function turnIsFinalizingOrForwarded(
   turnId: string,
 ): boolean {
   return (
-    state.forwardingTurnIds.includes(turnId) ||
-    state.forwardedTurnIds.includes(turnId)
+    state.forwardingTurnIds.has(turnId) ||
+    state.forwardedTurnIds.has(turnId)
   );
 }
 
@@ -2400,114 +2986,88 @@ function rememberStreamingAssistantOutput(
   state: ChannelSessionState,
   output: StreamingAssistantOutput,
 ): void {
-  state.streamingAssistantOutputs = [
-    ...state.streamingAssistantOutputs.filter(existing => existing.itemKey !== output.itemKey),
-    output,
-  ].slice(-maxForwardedTurnIds);
+  rememberBoundedCacheValue(state.streamingAssistantOutputs, output.itemKey, output);
 }
 
 function forgetStreamingAssistantOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): void {
-  state.streamingAssistantOutputs = state.streamingAssistantOutputs.filter(
-    output => output.itemKey !== itemKey,
-  );
+  forgetBoundedCacheValue(state.streamingAssistantOutputs, itemKey);
 }
 
 function rememberStreamingReasoningOutput(
   state: ChannelSessionState,
   output: StreamingReasoningOutput,
 ): void {
-  state.streamingReasoningOutputs = [
-    ...state.streamingReasoningOutputs.filter(existing => existing.itemKey !== output.itemKey),
-    output,
-  ].slice(-maxForwardedTurnIds);
+  rememberBoundedCacheValue(state.streamingReasoningOutputs, output.itemKey, output);
 }
 
 function forgetStreamingReasoningOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): void {
-  state.streamingReasoningOutputs = state.streamingReasoningOutputs.filter(
-    output => output.itemKey !== itemKey,
-  );
+  forgetBoundedCacheValue(state.streamingReasoningOutputs, itemKey);
 }
 
 function rememberStreamingCommandOutput(
   state: ChannelSessionState,
   output: StreamingCommandOutput,
 ): void {
-  state.streamingCommandOutputs = [
-    ...state.streamingCommandOutputs.filter(existing => existing.itemKey !== output.itemKey),
-    output,
-  ].slice(-maxForwardedTurnIds);
+  rememberBoundedCacheValue(state.streamingCommandOutputs, output.itemKey, output);
 }
 
 function forgetStreamingCommandOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): void {
-  state.streamingCommandOutputs = state.streamingCommandOutputs.filter(
-    output => output.itemKey !== itemKey,
-  );
+  forgetBoundedCacheValue(state.streamingCommandOutputs, itemKey);
 }
 
 function rememberStreamingFileChangeOutput(
   state: ChannelSessionState,
   output: StreamingFileChangeOutput,
 ): void {
-  state.streamingFileChangeOutputs = [
-    ...state.streamingFileChangeOutputs.filter(existing => existing.itemKey !== output.itemKey),
-    output,
-  ].slice(-maxForwardedTurnIds);
+  rememberBoundedCacheValue(state.streamingFileChangeOutputs, output.itemKey, output);
 }
 
 function forgetStreamingFileChangeOutput(
   state: ChannelSessionState,
   itemKey: string,
 ): void {
-  state.streamingFileChangeOutputs = state.streamingFileChangeOutputs.filter(
-    output => output.itemKey !== itemKey,
-  );
+  forgetBoundedCacheValue(state.streamingFileChangeOutputs, itemKey);
 }
 
 function rememberForwardedTerminalInputKey(
   state: ChannelSessionState,
   itemKey: string,
 ): void {
-  if (state.forwardedTerminalInputKeys.includes(itemKey)) {
+  if (state.forwardedTerminalInputKeys.has(itemKey)) {
     return;
   }
 
-  state.forwardedTerminalInputKeys = [...state.forwardedTerminalInputKeys, itemKey]
-    .slice(-maxForwardedTurnIds);
+  rememberBoundedStringSet(state.forwardedTerminalInputKeys, itemKey, maxForwardedTurnIds);
 }
 
 function findWebSearchProgressOutput(
   state: ChannelSessionState,
   turnId: string,
 ): WebSearchProgressOutput | undefined {
-  return state.webSearchProgressOutputs.find(output => output.turnId === turnId);
+  return getBoundedCacheValue(state.webSearchProgressOutputs, turnId);
 }
 
 function rememberWebSearchProgressOutput(
   state: ChannelSessionState,
   output: WebSearchProgressOutput,
 ): void {
-  state.webSearchProgressOutputs = [
-    ...state.webSearchProgressOutputs.filter(existing => existing.turnId !== output.turnId),
-    output,
-  ].slice(-maxForwardedTurnIds);
+  rememberBoundedCacheValue(state.webSearchProgressOutputs, output.turnId, output);
 }
 
 function forgetWebSearchProgressOutput(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.webSearchProgressOutputs = state.webSearchProgressOutputs.filter(
-    output => output.turnId !== turnId,
-  );
+  forgetBoundedCacheValue(state.webSearchProgressOutputs, turnId);
 }
 
 function mergeWebSearchQueries(
@@ -2560,7 +3120,7 @@ function rememberLocalTuiTurnIfNeeded(
     return;
   }
 
-  state.localTuiTurnIds = rememberTurnId(state.localTuiTurnIds, turnId);
+  rememberBoundedStringSet(state.localTuiTurnIds, turnId, maxForwardedTurnIds);
   if (state.kandanThreadId !== undefined) {
     startCodexTypingHeartbeat(args, state, state.kandanThreadId);
   }
@@ -2568,7 +3128,7 @@ function rememberLocalTuiTurnIfNeeded(
 }
 
 function isLocalTuiTurn(state: ChannelSessionState, turnId: string): boolean {
-  return state.localTuiTurnIds.includes(turnId);
+  return state.localTuiTurnIds.has(turnId);
 }
 
 function ensureKandanThreadForLocalTuiTurn(
@@ -2585,7 +3145,7 @@ function forgetLocalTuiTurnId(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.localTuiTurnIds = state.localTuiTurnIds.filter(id => id !== turnId);
+  state.localTuiTurnIds.delete(turnId);
 }
 
 function rememberPendingTuiInputMirror(
@@ -2593,63 +3153,88 @@ function rememberPendingTuiInputMirror(
   turnId: string,
   promise: Promise<void>,
 ): void {
-  state.pendingTuiInputMirrors = [
-    ...state.pendingTuiInputMirrors.filter(pending => pending.turnId !== turnId),
-    { turnId, promise },
-  ].slice(-maxForwardedTurnIds);
+  state.pendingTuiInputMirrors.delete(turnId);
+  state.pendingTuiInputMirrors.set(turnId, promise);
+  trimBoundedMap(state.pendingTuiInputMirrors, maxForwardedTurnIds);
 }
 
 function forgetPendingTuiInputMirror(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.pendingTuiInputMirrors = state.pendingTuiInputMirrors.filter(
-    pending => pending.turnId !== turnId,
-  );
+  state.pendingTuiInputMirrors.delete(turnId);
 }
 
 async function waitForPendingTuiInputMirror(
   state: ChannelSessionState,
   turnId: string,
 ): Promise<void> {
-  const pending = state.pendingTuiInputMirrors.find(
-    mirror => mirror.turnId === turnId,
-  );
+  const pending = state.pendingTuiInputMirrors.get(turnId);
 
   if (pending !== undefined) {
-    await pending.promise;
+    await pending;
   }
 }
 
 async function waitForStreamingForwardChains(
+  args: ChannelSessionContext,
   state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
 ): Promise<void> {
+  flushPendingStreamingDeltas(args, state, payloadContext);
   await Promise.all([
-    state.assistantDeltaForwardChain.catch(() => undefined),
-    state.reasoningDeltaForwardChain.catch(() => undefined),
-    state.commandOutputForwardChain.catch(() => undefined),
-    state.fileChangeForwardChain.catch(() => undefined),
+    state.assistantDeltaQueue.chain.catch(() => undefined),
+    state.reasoningDeltaQueue.chain.catch(() => undefined),
+    state.commandOutputQueue.chain.catch(() => undefined),
+    state.fileChangeQueue.chain.catch(() => undefined),
     state.terminalInputForwardChain.catch(() => undefined),
     state.webSearchProgressForwardChain.catch(() => undefined),
   ]);
 }
 
+function flushPendingStreamingDeltas(
+  args: ChannelSessionContext,
+  state: ChannelSessionState,
+  payloadContext: RunnerPayloadContext,
+): void {
+  flushStreamDeltaQueue(
+    state.assistantDeltaQueue,
+    assistantDeltaQueueRuntime(args, state, payloadContext),
+  );
+  flushStreamDeltaQueue(
+    state.reasoningDeltaQueue,
+    reasoningDeltaQueueRuntime(args, state, payloadContext),
+  );
+  flushStreamDeltaQueue(
+    state.commandOutputQueue,
+    commandOutputQueueRuntime(args, state, payloadContext),
+  );
+  flushStreamDeltaQueue(
+    state.fileChangeQueue,
+    fileChangeQueueRuntime(args, state, payloadContext),
+  );
+}
+
+function clearPendingStreamFlushTimers(state: ChannelSessionState): void {
+  clearStreamDeltaFlushTimer(state.assistantDeltaQueue);
+  clearStreamDeltaFlushTimer(state.reasoningDeltaQueue);
+  clearStreamDeltaFlushTimer(state.commandOutputQueue);
+  clearStreamDeltaFlushTimer(state.fileChangeQueue);
+}
+
 function rememberTurnReplyTarget(
   state: ChannelSessionState,
   turnId: string,
   replyToSeq: number,
 ): void {
-  state.turnReplyTargets = [
-    ...state.turnReplyTargets.filter(target => target.turnId !== turnId),
-    { turnId, replyToSeq },
-  ].slice(-maxForwardedTurnIds);
+  rememberBoundedCacheValue(state.turnReplyTargets, turnId, { turnId, replyToSeq });
 }
 
 function sourceMessageSeqForTurn(
   state: ChannelSessionState,
   turnId: string,
 ): number | undefined {
-  return state.turnReplyTargets.find(target => target.turnId === turnId)?.replyToSeq;
+  return getBoundedCacheValue(state.turnReplyTargets, turnId)?.replyToSeq;
 }
 
 function fileChangePaths(structured: JsonObject): string[] {
@@ -2710,7 +3295,7 @@ function isRecoverableCodexThreadError(error: unknown): boolean {
 }
 
 function turnCanForward(state: ChannelSessionState, turnId: string): boolean {
-  if (state.retryableTurnIds.includes(turnId)) {
+  if (state.retryableTurnIds.has(turnId)) {
     return true;
   }
 
@@ -2718,26 +3303,18 @@ function turnCanForward(state: ChannelSessionState, turnId: string): boolean {
     return true;
   }
 
-  switch (state.turn.status) {
-    case "active":
-      return state.turn.turnId === turnId;
-    case "completing":
-      return state.turn.turnId === turnId;
-    case "idle":
-    case "starting":
-      return false;
-  }
+  return turnCanForwardByState(state.turn, turnId);
 }
 
 function rememberForwardedTurnId(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  if (state.forwardedTurnIds.includes(turnId)) {
+  if (state.forwardedTurnIds.has(turnId)) {
     return;
   }
 
-  state.forwardedTurnIds = rememberTurnId(state.forwardedTurnIds, turnId);
+  rememberBoundedStringSet(state.forwardedTurnIds, turnId, maxForwardedTurnIds);
   forgetRetryableTurnId(state, turnId);
 }
 
@@ -2745,39 +3322,54 @@ function rememberForwardingTurnId(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.forwardingTurnIds = rememberTurnId(state.forwardingTurnIds, turnId);
+  rememberBoundedStringSet(state.forwardingTurnIds, turnId, maxForwardedTurnIds);
 }
 
 function forgetForwardingTurnId(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.forwardingTurnIds = state.forwardingTurnIds.filter(id => id !== turnId);
+  state.forwardingTurnIds.delete(turnId);
 }
 
 function rememberRetryableTurnId(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.retryableTurnIds = rememberTurnId(state.retryableTurnIds, turnId);
+  rememberBoundedStringSet(state.retryableTurnIds, turnId, maxForwardedTurnIds);
 }
 
 function forgetRetryableTurnId(
   state: ChannelSessionState,
   turnId: string,
 ): void {
-  state.retryableTurnIds = state.retryableTurnIds.filter(id => id !== turnId);
+  state.retryableTurnIds.delete(turnId);
 }
 
-function rememberTurnId(
-  values: readonly string[],
-  turnId: string,
-): string[] {
-  if (values.includes(turnId)) {
-    return [...values];
+function rememberBoundedStringSet(values: Set<string>, value: string, maxSize: number): void {
+  values.delete(value);
+  values.add(value);
+  trimBoundedSet(values, maxSize);
+}
+
+function trimBoundedSet(values: Set<string>, maxSize: number): void {
+  while (values.size > maxSize) {
+    const oldest = values.values().next().value;
+    if (oldest === undefined) {
+      return;
+    }
+    values.delete(oldest);
   }
+}
 
-  return [...values, turnId].slice(-maxForwardedTurnIds);
+function trimBoundedMap<V>(values: Map<string, V>, maxSize: number): void {
+  while (values.size > maxSize) {
+    const oldest = values.keys().next().value;
+    if (oldest === undefined) {
+      return;
+    }
+    values.delete(oldest);
+  }
 }
 
 async function stopCodexTyping(
@@ -2852,24 +3444,6 @@ function stopCodexTypingHeartbeat(state: ChannelSessionState): void {
   }
 }
 
-type LocalCodexProcessingReason =
-  | "starting turn"
-  | "streaming response"
-  | "running terminal command"
-  | "interrupt requested"
-  | "awaiting approval";
-
-type LocalCodexMessageState =
-  | { readonly status: "queued" }
-  | { readonly status: "processed" }
-  | {
-      readonly status: "processing";
-      readonly reason: LocalCodexProcessingReason;
-      readonly approval?: CodexApprovalMessageState | undefined;
-    }
-  | { readonly status: "ignored"; readonly reason: string }
-  | { readonly status: "failed"; readonly reason: string };
-
 async function publishKandanMessageState(
   args: ChannelSessionContext,
   event: KandanChatEvent,
@@ -2930,6 +3504,18 @@ async function publishMessageState(
           approval_request_id: state.approval.requestId,
           approval_kind: state.approval.kind,
           approval_summary: state.approval.summary,
+          ...(state.approval.reason === undefined
+            ? {}
+            : { approval_reason: state.approval.reason }),
+          ...(state.approval.choices === undefined
+            ? {}
+            : { approval_choices: state.approval.choices }),
+          ...(state.approval.allowedActorSlug === undefined
+            ? {}
+            : { approval_allowed_actor_slug: state.approval.allowedActorSlug }),
+          ...(state.approval.allowedActorUserId === undefined
+            ? {}
+            : { approval_allowed_actor_user_id: state.approval.allowedActorUserId }),
         }
       : {}),
     ...(actorSlug === undefined ? {} : { actor_slug: actorSlug }),
@@ -2939,51 +3525,6 @@ async function publishMessageState(
   await pushOptional(args.kandan, args.topic, "message_state", payload, args.log);
 }
 
-function processingReasonForCodexNotification(
-  method: string,
-  params: JsonObject,
-): Exclude<LocalCodexProcessingReason, "awaiting approval"> | undefined {
-  if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta") {
-    return "streaming response";
-  }
-
-  if (
-    method.startsWith("item/commandExecution/") ||
-    method === "command/exec/outputDelta"
-  ) {
-    return "running terminal command";
-  }
-
-  const item = objectValue(params.item) ?? params;
-  const itemType = stringValue(item.type);
-
-  switch (itemType) {
-    case "commandExecution":
-    case "terminalInput":
-      return "running terminal command";
-    case "agentMessage":
-    case "reasoning":
-    case "fileChange":
-    case "web_search_call":
-    case "webSearchCall":
-    case "webSearch":
-      return "streaming response";
-    default:
-      return undefined;
-  }
-}
-
-function activeTurnId(state: ChannelSessionState): string | undefined {
-  switch (state.turn.status) {
-    case "active":
-    case "completing":
-      return state.turn.turnId;
-    case "idle":
-    case "starting":
-      return undefined;
-  }
-}
-
 function abortReason(params: JsonObject): string {
   return (
     stringValue(params.reason) ??
@@ -3001,7 +3542,7 @@ async function failActiveCodexTurn(
   payloadContext: RunnerPayloadContext,
 ): Promise<void> {
   rejectPendingApprovalRequestsForTurn(state, turnId, new Error(reason));
-  const seq = activeQueuedSeqForTurn(state, turnId);
+  const seq = activeQueuedSeqForTurn(state.turn, turnId);
 
   if (seq !== undefined && state.kandanThreadId !== undefined) {
     await publishMessageState(args, state.kandanThreadId, seq, {
@@ -3014,10 +3555,7 @@ async function failActiveCodexTurn(
   forgetLocalTuiTurnId(state, turnId);
   rememberForwardedTurnId(state, turnId);
 
-  if (
-    state.turn.status !== "idle" &&
-    (state.turn.status === "starting" || state.turn.turnId === turnId)
-  ) {
+  if (shouldClearTurnAfterFailure(state.turn, turnId)) {
     state.turn = { status: "idle" };
   }
 
@@ -3025,27 +3563,13 @@ async function failActiveCodexTurn(
   await drainKandanMessageQueue(args, state, payloadContext);
 }
 
-function activeQueuedSeqForTurn(
-  state: ChannelSessionState,
-  turnId: string,
-): number | undefined {
-  switch (state.turn.status) {
-    case "active":
-    case "completing":
-      return state.turn.turnId === turnId ? state.turn.queuedSeq : undefined;
-    case "idle":
-    case "starting":
-      return undefined;
-  }
-}
-
 async function refreshActiveProcessingState(
   args: ChannelSessionContext,
   state: ChannelSessionState,
   turnId: string,
   reason: Exclude<LocalCodexProcessingReason, "awaiting approval">,
 ): Promise<void> {
-  const seq = activeQueuedSeqForTurn(state, turnId);
+  const seq = activeQueuedSeqForTurn(state.turn, turnId);
 
   if (seq === undefined || state.kandanThreadId === undefined) {
     return;
@@ -3092,19 +3616,6 @@ function clearActiveProcessingState(state: ChannelSessionState, seq: number): vo
   }
 }
 
-function processingMessageStateFromActive(
-  state: ActiveProcessingState,
-): Extract<LocalCodexMessageState, { readonly status: "processing" }> {
-  switch (state.reason) {
-    case "awaiting approval":
-      return { status: "processing", reason: state.reason, approval: state.approval };
-    case "starting turn":
-    case "streaming response":
-    case "running terminal command":
-    case "interrupt requested":
-      return { status: "processing", reason: state.reason };
-  }
-}
 
 function extractThreadIdFromResponse(response: JsonRpcResponse): string {
   if ("error" in response) {
@@ -3152,63 +3663,6 @@ async function startCodexThread(
   return extractThreadIdFromResponse(start);
 }
 
-function codexThreadRuntimeOverrides(options: ChannelSessionRunnerOptions): JsonObject {
-  const session = options.channelSession;
-
-  return {
-    ...(session.model === undefined ? {} : { model: session.model }),
-    ...(session.reasoningEffort === undefined
-      ? {}
-      : { reasoningEffort: session.reasoningEffort }),
-    ...(options.fast === true ? { serviceTier: "fast" } : {}),
-    ...(session.approvalPolicy === undefined
-      ? {}
-      : { approvalPolicy: session.approvalPolicy }),
-    ...(session.sandbox === undefined ? {} : { sandbox: session.sandbox }),
-  };
-}
-
-function codexTurnRuntimeOverrides(options: ChannelSessionRunnerOptions): JsonObject {
-  const session = options.channelSession;
-
-  return {
-    cwd: options.cwd,
-    ...(session.model === undefined ? {} : { model: session.model }),
-    ...(session.reasoningEffort === undefined ? {} : { effort: session.reasoningEffort }),
-    ...(options.fast === true ? { serviceTier: "fast" } : {}),
-    ...(session.approvalPolicy === undefined
-      ? {}
-      : { approvalPolicy: session.approvalPolicy }),
-    ...(session.sandbox === undefined
-      ? {}
-      : { sandboxPolicy: codexSandboxPolicy(session.sandbox, options.cwd) }),
-  };
-}
-
-function codexSandboxPolicy(sandbox: string, cwd: string): JsonObject {
-  switch (sandbox) {
-    case "danger-full-access":
-      return { type: "dangerFullAccess" };
-    case "read-only":
-      return {
-        type: "readOnly",
-        access: { type: "fullAccess" },
-        networkAccess: false,
-      };
-    case "workspace-write":
-      return {
-        type: "workspaceWrite",
-        writableRoots: [cwd],
-        readOnlyAccess: { type: "fullAccess" },
-        networkAccess: false,
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false,
-      };
-    default:
-      throw new Error(`unsupported Codex sandbox mode: ${sandbox}`);
-  }
-}
-
 async function pushOk(
   kandan: PhoenixClient,
   topic: string,