@linzumi/cli 0.0.20-beta → 0.0.23-beta

package/src/channelSession.ts

@@ -1,4301 +0,0 @@
-/*
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-channel-session-module-spec.md
-  Relationship: Owns one channel-bound local Codex session: Kandan thread
-  binding, sender queueing, Codex turn lifecycle, typing heartbeat, queued
-  interrupt handling, and Codex output forwarding.
-
-- Date: 2026-04-24
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Keeps channel event dedupe bounded and represents Codex turn
-  lifecycle as an explicit state machine so queued-message interrupts cannot
-  race in-flight turn starts, malformed stored Codex thread ids can rebound,
-  and non-recoverable delivery failures become terminal failed input states.
-
-- Date: 2026-04-25
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Makes bare `processing` impossible to publish from the runner
-  by requiring each processing message state to carry the specific active
-  Codex work reason at the channel-session boundary.
-
-- Date: 2026-04-25
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  Relationship: Reduces raw Codex notifications and thread snapshots into
-  logical transcript units before Kandan projection, so TUI input projection
-  failures and ambiguous assistant-output reconciliation fail as state-machine
-  errors instead of creating source-less or duplicate-looking transcript rows,
-  and so live reasoning, command-output, terminal-interaction, search, abort,
-  live file-change, and completed tool-call observations update Kandan using
-  existing Codex output kinds.
-
-- Date: 2026-04-25
-  Spec: plans/2026-04-24-local-codex-runner-deep-quality-spec.md
-  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.
-
-- Date: 2026-05-02
-  Spec: plans/2026-05-02-agent-first-zero-to-codex-launch-plan.md
-  Relationship: Closes npm CLI runner parity gaps for attachment-backed
-  Kandan replies, runtime settings updates, and local TUI turn exclusivity.
-*/
-import {
-  availabilityMessage,
-  detectCodexVersion,
-  identityFromAccessToken,
-  isCodexAuthoredEvent,
-  localRunnerPayload,
-  parseKandanChatEvent,
-  senderAllowed,
-  type KandanChatEvent,
-  type RunnerIdentity,
-  type RunnerPayloadContext,
-} from "./channelSessionSupport";
-import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
-import { type CodexAppServerClient } from "./codexAppServer";
-import {
-  codexThreadRuntimeOverrides,
-  codexTurnRuntimeOverrides,
-} from "./codexRuntimeOptions";
-import {
-  codexAssistantDeltaFromNotification,
-  codexAssistantStructuredMessage,
-  codexCommandExecutionStructuredMessage,
-  codexCommandOutputDeltaFromNotification,
-  codexFileChangeDeltaFromNotification,
-  codexFileChangeStructuredMessage,
-  codexOutputMessagesForTurn,
-  codexReasoningDeltaFromNotification,
-  codexReasoningStructuredMessage,
-  codexTerminalInputFromNotification,
-  codexWebSearchProgressFromNotification,
-  codexWebSearchStructuredMessage,
-  webSearchProgressBody,
-  codexUserInputMessageFromNotification,
-  codexUserInputMessagesForTurn,
-  type CodexAssistantDelta,
-  type CodexCommandOutputDelta,
-  type CodexFileChangeDelta,
-  type CodexReasoningDelta,
-  type CodexUserInputMessage,
-} from "./codexOutput";
-import { arrayValue, integerValue, objectValue, stringValue } from "./json";
-import {
-  codexInputForQueuedKandanMessage,
-  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,
-  type JsonRpcRequest,
-  type JsonRpcResponse,
-  type KandanChannelSessionOptions,
-  type KandanControl,
-  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: (
-    method: string,
-    params: JsonObject,
-  ) => void;
-  readonly handleControl: (control: KandanControl) => Promise<JsonObject | undefined>;
-  readonly handleKandanReconnect: () => Promise<void>;
-  readonly currentRuntimeSettings: () => LocalCodexRuntimeSettings;
-  readonly currentCodexThreadId: () => string | undefined;
-  readonly currentKandanThreadId: () => string | undefined;
-  readonly close: () => Promise<void>;
-};
-
-export type ChannelSessionRunnerOptions = {
-  readonly kandanUrl?: string | undefined;
-  readonly token: string;
-  readonly runnerId: string;
-  readonly cwd: string;
-  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;
-  readonly topic: string;
-  readonly instanceId: string;
-  readonly options: ChannelSessionRunnerOptions;
-  readonly log: RunnerLogger;
-};
-
-type ChannelSessionState = {
-  rootSeq: number | undefined;
-  kandanThreadId: string | undefined;
-  codexThreadId: string | undefined;
-  turn: TurnState;
-  closed: boolean;
-  minSeq: number;
-  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;
-  terminalInputForwardChain: Promise<void>;
-  webSearchProgressForwardChain: Promise<void>;
-  typingHeartbeat: ReturnType<typeof setInterval> | undefined;
-  typingHeartbeatInFlight: boolean;
-  runtimeSettings: LocalCodexRuntimeSettings;
-};
-
-const codexTypingHeartbeatMs = 5_000;
-const defaultStreamFlushIntervalMs = 150;
-const maxForwardedTurnIds = 64;
-
-type LocalCodexRuntimeSettings = {
-  readonly model: string | undefined;
-  readonly reasoningEffort: string | undefined;
-  readonly approvalPolicy: string | undefined;
-  readonly sandbox: string | undefined;
-  readonly fast: boolean | undefined;
-};
-
-type StreamingAssistantOutput = {
-  readonly itemKey: string;
-  readonly turnId: string | undefined;
-  readonly seq: number;
-  readonly content: string;
-};
-
-type StreamingReasoningOutput = {
-  readonly itemKey: string;
-  readonly turnId: string | undefined;
-  readonly seq: number;
-  readonly content: string;
-};
-
-type StreamingCommandOutput = {
-  readonly itemKey: string;
-  readonly turnId: string | undefined;
-  readonly seq: number;
-  readonly output: string;
-  readonly processId: string | undefined;
-  readonly stream: string;
-};
-
-type StreamingFileChangeOutput = {
-  readonly itemKey: string;
-  readonly turnId: string | undefined;
-  readonly seq: number;
-  readonly patchText: string;
-};
-
-type WebSearchProgressOutput = {
-  readonly turnId: string;
-  readonly itemKey: string;
-  readonly seq: number;
-  readonly queries: string[];
-};
-
-type MirroredTuiInputProjection = {
-  readonly logicalKey: string;
-  readonly turnId: string;
-  readonly seq: number;
-  readonly itemKeys: string[];
-};
-
-type TurnReplyTarget = {
-  readonly turnId: string;
-  readonly replyToSeq: number;
-};
-
-type PendingCodexApprovalRequest = {
-  readonly requestId: string;
-  readonly sourceSeq: number;
-  readonly turnId: string;
-  readonly resolve: (response: JsonObject) => void;
-  readonly reject: (error: Error) => void;
-};
-
-export async function attachChannelSession(
-  args: ChannelSessionContext,
-): Promise<ChannelSessionRuntime> {
-  const session = args.options.channelSession;
-  const chatTopic = `chat:${session.workspaceSlug}:${session.channelSlug}`;
-  const state = initialChannelSessionState(
-    0,
-    session.kandanThreadId,
-    args.options,
-  );
-  const joined = await args.kandan.join(chatTopic, { last_seq: 0 }, {
-    rejoinPayload: () => ({ last_seq: state.minSeq }),
-  });
-  const cursor = integerValue(joined.cursor) ?? 0;
-  const runnerIdentity = identityFromAccessToken(args.options.token);
-  const codexVersion = detectCodexVersion(args.options.codexBin, args.options.cwd);
-  state.minSeq = cursor;
-  const payloadContext = {
-    runnerIdentity,
-    codexVersion,
-  };
-  const eventBuffer = {
-    ready: false,
-    pending: [] as KandanChatEvent[],
-  };
-
-  args.codex.onRequest?.(request =>
-    handleCodexServerRequest(args, state, payloadContext, request)
-  );
-
-  args.kandan.onEvent((topic, event, payload) => {
-    if (topic !== chatTopic || event !== "event") {
-      return;
-    }
-
-    const parsed = parseKandanChatEvent(payload);
-
-    if (parsed === undefined) {
-      return;
-    }
-
-    if (!eventBuffer.ready) {
-      eventBuffer.pending.push(parsed);
-      return;
-    }
-
-    void processKandanChatEvent(args, state, runnerIdentity, parsed, payloadContext);
-  });
-
-  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 {
-    handleCodexNotification: (method, params) => {
-      const turnId = codexNotificationTurnId(params);
-      const threadId = codexNotificationThreadId(params);
-
-      if (codexNotificationBelongsToSession(state, threadId, turnId)) {
-        const processingReason = processingReasonForCodexNotification(method, params);
-        if (turnId !== undefined && processingReason !== undefined) {
-          void refreshActiveProcessingState(args, state, turnId, processingReason).catch(error => {
-            args.log("kandan.message_state_refresh_failed", {
-              turn_id: turnId,
-              reason: processingReason,
-              message: error instanceof Error ? error.message : String(error),
-            });
-          });
-        }
-
-        switch (method) {
-          case "turn/started":
-            if (turnId !== undefined) {
-              rememberLocalTuiTurnIfNeeded(args, state, threadId, turnId);
-            }
-            break;
-          case "turn/aborted":
-          case "turn/canceled":
-          case "turn/cancelled":
-          case "turn/failed":
-            if (turnId !== undefined) {
-              void failActiveCodexTurn(args, state, turnId, abortReason(params), payloadContext)
-                .catch(error => {
-                  args.log("codex.turn_abort_handling_failed", {
-                    turn_id: turnId,
-                    message: error instanceof Error ? error.message : String(error),
-                  });
-                });
-            }
-            break;
-          case "turn/completed":
-            if (turnId !== undefined) {
-              enqueueWebSearchProgressCompletion(args, state, turnId);
-              enqueueFileChangeCompletion(args, state, turnId);
-              void forwardCompletedCodexTurn(args, state, turnId, payloadContext).catch(error => {
-                args.log("codex.turn_forward_failed", {
-                  turn_id: turnId,
-                  message: error instanceof Error ? error.message : String(error),
-                });
-              });
-            }
-            break;
-          case "item/agentMessage/delta":
-            enqueueAssistantDelta(args, state, params, payloadContext);
-            break;
-          case "item/reasoning/textDelta":
-            enqueueReasoningDelta(args, state, params, payloadContext);
-            break;
-          case "item/commandExecution/outputDelta":
-          case "command/exec/outputDelta":
-            enqueueCommandOutputDelta(args, state, params, payloadContext);
-            break;
-          case "item/fileChange/outputDelta":
-            enqueueFileChangeDelta(args, state, params, payloadContext);
-            break;
-          case "item/commandExecution/terminalInteraction":
-            enqueueTerminalInput(args, state, params, payloadContext);
-            break;
-          case "item/started":
-            enqueueWebSearchProgress(args, state, params, payloadContext);
-            break;
-          case "item/completed":
-            enqueueWebSearchProgress(args, state, params, payloadContext);
-            if (turnId !== undefined) {
-              const promise = mirrorLocalTuiInputFromNotification(
-                args,
-                state,
-                turnId,
-                params,
-                payloadContext,
-              );
-              rememberPendingTuiInputMirror(state, turnId, promise);
-              void promise
-                .catch(error => {
-                  args.log("codex.tui_input_mirror_failed", {
-                    turn_id: turnId,
-                    message: error instanceof Error ? error.message : String(error),
-                  });
-                })
-                .finally(() => forgetPendingTuiInputMirror(state, turnId));
-            }
-            break;
-        }
-      }
-    },
-    handleControl: control => handleChannelSessionControl(args, state, payloadContext, control),
-    currentRuntimeSettings: () => state.runtimeSettings,
-    currentCodexThreadId: () => state.codexThreadId,
-    currentKandanThreadId: () => state.kandanThreadId,
-    handleKandanReconnect: async () => {
-      if (state.closed) {
-        return;
-      }
-
-      args.log("kandan.reconnected", {
-        kandan_thread_id: state.kandanThreadId ?? null,
-        codex_thread_id: state.codexThreadId ?? null,
-        min_seq: state.minSeq,
-      });
-      await bindCurrentCodexThread(args, state);
-      if (state.kandanThreadId !== undefined && state.turn.status !== "idle") {
-        startCodexTypingHeartbeat(args, state, state.kandanThreadId);
-        await refreshActiveProcessingHeartbeat(args, state);
-      }
-      await drainKandanMessageQueue(args, state, payloadContext);
-    },
-    close: async () => {
-      state.closed = true;
-      state.portForwardWatcher?.close();
-      state.portForwardWatcher = undefined;
-      clearPendingStreamFlushTimers(state);
-      rejectPendingApprovalRequests(state, new Error("runner closed"));
-      await stopCodexTyping(args, state);
-    },
-  };
-}
-
-async function bindCurrentCodexThread(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-): Promise<void> {
-  if (state.codexThreadId === undefined) {
-    return;
-  }
-
-  const session = args.options.channelSession;
-  await pushOk(args.kandan, args.topic, "session:bind", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: state.kandanThreadId ?? null,
-    codex_thread_id: state.codexThreadId,
-    instance_id: args.instanceId,
-  });
-}
-
-function initialChannelSessionState(
-  cursor: number,
-  kandanThreadId: string | undefined,
-  options: ChannelSessionRunnerOptions,
-): ChannelSessionState {
-  return {
-    rootSeq: undefined,
-    kandanThreadId,
-    codexThreadId: undefined,
-    turn: { status: "idle" },
-    closed: false,
-    minSeq: cursor,
-    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,
-    terminalInputForwardChain: Promise.resolve(),
-    webSearchProgressForwardChain: Promise.resolve(),
-    typingHeartbeat: undefined,
-    typingHeartbeatInFlight: false,
-    runtimeSettings: runtimeSettingsFromOptions(options),
-  };
-}
-
-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,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  const session = args.options.channelSession;
-  const codexVersion = payloadContext.codexVersion;
-
-  if (state.kandanThreadId === undefined) {
-    state.codexThreadId = await startCodexThread(args.codex, args.options);
-    const reply = await pushOk(args.kandan, args.topic, "session:announce", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      body: availabilityMessage(args.options, codexVersion, state.codexThreadId),
-      payload: localRunnerPayload(
-        args.options,
-        args.instanceId,
-        "availability",
-        state.codexThreadId,
-        payloadContext,
-      ),
-      client_message_id: `local-codex-root-${args.instanceId}`,
-    });
-    state.rootSeq = integerValue(reply.seq);
-    if (state.rootSeq !== undefined) {
-      state.minSeq = Math.max(state.minSeq, state.rootSeq);
-    }
-  } else {
-    const resolved = await pushOk(args.kandan, args.topic, "session:resolve_thread_session", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-    });
-    state.rootSeq = integerValue(resolved.seq);
-    state.codexThreadId = stringValue(resolved.codex_thread_id);
-
-    if (state.codexThreadId === undefined) {
-      throw new Error(
-        "Kandan thread root metadata did not include a Codex thread id",
-      );
-    }
-
-    await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body: availabilityMessage(args.options, codexVersion, state.codexThreadId),
-      payload: localRunnerPayload(
-        args.options,
-        args.instanceId,
-        "availability",
-        state.codexThreadId,
-        payloadContext,
-      ),
-    });
-  }
-}
-
-async function handleChannelSessionControl(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  payloadContext: RunnerPayloadContext,
-  control: KandanControl,
-): Promise<JsonObject | undefined> {
-  if (control.type === "update_session_settings") {
-    return updateSessionSettings(args, state, control);
-  }
-
-  if (control.type === "resolve_codex_approval_request") {
-    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;
-  }
-
-  if (
-    state.codexThreadId === undefined ||
-    state.kandanThreadId === undefined ||
-    control.threadId !== state.codexThreadId
-  ) {
-    return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
-  }
-
-  const interrupted = interruptPendingKandanMessages(state.queue, control.throughSeq);
-  const activeQueuedSeq = interruptibleQueuedSeq(state.turn);
-  const targetsActiveTurn =
-    control.throughSeq !== undefined && activeQueuedSeq === control.throughSeq;
-
-  if (!interrupted.ok && !targetsActiveTurn) {
-    return { instanceId: args.instanceId, ok: false, error: "queue_empty" };
-  }
-
-  switch (state.turn.status) {
-    case "active":
-      const interruptedActiveSeq = state.turn.queuedSeq;
-      await args.codex.request("turn/interrupt", {
-        threadId: state.codexThreadId,
-        turnId: state.turn.turnId,
-      });
-
-      state.turn = { status: "idle" };
-      clearActiveProcessingState(state, interruptedActiveSeq);
-      await publishMessageState(args, state.kandanThreadId, interruptedActiveSeq, {
-        status: "processed",
-      });
-      break;
-    case "starting":
-      state.turn = markInterruptAfterStart(state.turn);
-      break;
-    case "idle":
-    case "completing":
-      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
-      : pendingKandanMessageQueueLength(state.queue),
-  });
-  if (interrupted.ok) {
-    for (const seq of interrupted.selectedSeqs) {
-      await publishMessageState(args, state.kandanThreadId, seq, {
-        status: "processing",
-        reason: "interrupt requested",
-      });
-    }
-  }
-  await drainKandanMessageQueue(args, state, payloadContext);
-  return {
-    instanceId: args.instanceId,
-    ok: true,
-    interruptedQueuedMessages: interrupted.ok ? interrupted.selectedCount : 0,
-  };
-}
-
-function updateSessionSettings(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  control: Extract<KandanControl, { readonly type: "update_session_settings" }>,
-): JsonObject {
-  if (
-    state.codexThreadId === undefined ||
-    control.threadId !== state.codexThreadId
-  ) {
-    return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
-  }
-
-  state.runtimeSettings = mergeRuntimeSettings(state.runtimeSettings, control);
-  void publishRuntimeSettings(args, state).catch(error => {
-    args.log("kandan.session_settings_publish_failed", {
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
-  args.log("codex.session_settings_updated", {
-    model: state.runtimeSettings.model ?? null,
-    reasoning_effort: state.runtimeSettings.reasoningEffort ?? null,
-    approval_policy: state.runtimeSettings.approvalPolicy ?? null,
-    sandbox: state.runtimeSettings.sandbox ?? null,
-    fast: state.runtimeSettings.fast ?? null,
-  });
-
-  return {
-    instanceId: args.instanceId,
-    ok: true,
-    model: state.runtimeSettings.model ?? null,
-    reasoningEffort: state.runtimeSettings.reasoningEffort ?? null,
-    approvalPolicy: state.runtimeSettings.approvalPolicy ?? null,
-    sandbox: state.runtimeSettings.sandbox ?? null,
-    fast: state.runtimeSettings.fast ?? null,
-  };
-}
-
-async function resolvePendingCodexApprovalRequest(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  control: Extract<KandanControl, { readonly type: "resolve_codex_approval_request" }>,
-): Promise<JsonObject> {
-  if (
-    state.codexThreadId === undefined ||
-    state.kandanThreadId === undefined ||
-    control.threadId !== state.codexThreadId
-  ) {
-    return { instanceId: args.instanceId, ok: false, error: "thread_not_bound" };
-  }
-
-  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.delete(approvalRequestKey(control.requestId, control.sourceSeq));
-
-  const codexDecision = control.decision === "approve" ? "accept" : "decline";
-  approval.resolve({ decision: codexDecision });
-  state.activeProcessingState = { seq: approval.sourceSeq, reason: "streaming response" };
-
-  await publishMessageState(args, state.kandanThreadId, approval.sourceSeq, {
-    status: "processing",
-    reason: "streaming response",
-  });
-
-  args.log("codex.approval_request_resolved", {
-    request_id: control.requestId,
-    source_seq: control.sourceSeq,
-    decision: control.decision,
-    codex_decision: codexDecision,
-  });
-
-  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,
-  runnerIdentity: RunnerIdentity,
-  payloadContext: RunnerPayloadContext,
-  event: KandanChatEvent,
-): Promise<void> {
-  const session = args.options.channelSession;
-
-  if (
-    event.type !== "thread.message" ||
-    event.threadId === undefined ||
-    (event.body.trim() === "" && event.attachments.length === 0)
-  ) {
-    args.log("kandan.message_ignored", {
-      seq: event.seq,
-      actor_slug: event.actorSlug ?? null,
-      actor_user_id: event.actorUserId ?? null,
-      reason: "not_thread_message_or_empty",
-    });
-    return;
-  }
-
-  if (isCodexAuthoredEvent(event)) {
-    args.log("kandan.message_ignored", {
-      seq: event.seq,
-      actor_slug: event.actorSlug ?? null,
-      actor_user_id: event.actorUserId ?? null,
-      reason: "codex_authored",
-    });
-    return;
-  }
-
-  if (!senderAllowed(session.listenUser, event, runnerIdentity)) {
-    args.log("kandan.message_ignored", {
-      seq: event.seq,
-      actor_slug: event.actorSlug ?? null,
-      actor_user_id: event.actorUserId ?? null,
-      reason: "sender_not_allowed",
-    });
-    await publishKandanMessageState(args, event, {
-      status: "ignored",
-      reason: "sender_not_allowed",
-    });
-    return;
-  }
-
-  if (event.body.trimStart().startsWith("&")) {
-    args.log("kandan.message_ignored", {
-      seq: event.seq,
-      actor_slug: event.actorSlug ?? null,
-      actor_user_id: event.actorUserId ?? null,
-      reason: "human_only",
-    });
-    await publishKandanMessageState(args, event, {
-      status: "ignored",
-      reason: "human_only",
-    });
-    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);
-
-      if (!bound) {
-        args.log("kandan.message_ignored", {
-          seq: event.seq,
-          actor_slug: event.actorSlug ?? null,
-          actor_user_id: event.actorUserId ?? null,
-          reason: "not_root_reply",
-        });
-        await publishKandanMessageState(args, event, {
-          status: "ignored",
-          reason: "not_root_reply",
-        });
-        return;
-      }
-    } else {
-      state.kandanThreadId = event.threadId;
-    }
-  }
-
-  if (event.threadId !== state.kandanThreadId) {
-    args.log("kandan.message_ignored", {
-      seq: event.seq,
-      actor_slug: event.actorSlug ?? null,
-      actor_user_id: event.actorUserId ?? null,
-      reason: "different_thread",
-    });
-    await publishKandanMessageState(args, event, {
-      status: "ignored",
-      reason: "different_thread",
-    });
-    return;
-  }
-
-  enqueuePendingKandanMessage(state.queue, {
-    seq: event.seq,
-    actorSlug: event.actorSlug,
-    actorUserId: event.actorUserId,
-    body: event.body,
-    attachments: event.attachments,
-  });
-  args.log("kandan.message_queued", {
-    seq: event.seq,
-    actor_slug: event.actorSlug ?? null,
-    actor_user_id: event.actorUserId ?? null,
-    queue_depth: pendingKandanMessageQueueLength(state.queue),
-  });
-  await publishKandanMessageState(args, event, { status: "queued" });
-  await drainKandanMessageQueue(args, state, payloadContext);
-}
-
-async function bindUnboundHistoricalThread(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  event: KandanChatEvent,
-): Promise<boolean> {
-  if (event.threadId === undefined || event.replyToSeq === undefined) {
-    return false;
-  }
-
-  const session = args.options.channelSession;
-
-  try {
-    const resolved = await pushOk(args.kandan, args.topic, "session:resolve_thread_session", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: event.threadId,
-    });
-    const rootSeq = integerValue(resolved.seq);
-    const codexThreadId = stringValue(resolved.codex_thread_id);
-
-    if (rootSeq !== event.replyToSeq || codexThreadId === undefined) {
-      return false;
-    }
-
-    state.rootSeq = rootSeq;
-    state.kandanThreadId = event.threadId;
-    state.codexThreadId = codexThreadId;
-    await bindCurrentCodexThread(args, state);
-    args.log("kandan.thread_bound_from_historical_reply", {
-      seq: event.seq,
-      kandan_thread_id: event.threadId,
-      root_seq: rootSeq,
-      codex_thread_id: codexThreadId,
-    });
-    return true;
-  } catch (error) {
-    args.log("kandan.thread_bind_from_historical_reply_failed", {
-      seq: event.seq,
-      kandan_thread_id: event.threadId,
-      message: error instanceof Error ? error.message : String(error),
-    });
-    return false;
-  }
-}
-
-async function processBufferedKandanEvents(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  runnerIdentity: RunnerIdentity,
-  payloadContext: RunnerPayloadContext,
-  pendingEvents: readonly KandanChatEvent[],
-): Promise<void> {
-  const events = [...pendingEvents].sort(
-    (left, right) => left.seq - right.seq,
-  );
-
-  for (const event of events) {
-    await processKandanChatEvent(args, state, runnerIdentity, event, payloadContext);
-  }
-}
-
-async function processKandanChatEvent(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  runnerIdentity: RunnerIdentity,
-  event: KandanChatEvent,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (event.seq <= state.minSeq) {
-    return;
-  }
-
-  state.minSeq = event.seq;
-  args.log("kandan.chat_event", {
-    seq: event.seq,
-    type: event.type,
-    actor_slug: event.actorSlug ?? null,
-    actor_user_id: event.actorUserId ?? null,
-    thread_id: event.threadId ?? null,
-    reply_to_seq: event.replyToSeq ?? null,
-    local_runner_event_type: event.localRunnerEventType ?? null,
-  });
-
-  try {
-    await handleKandanChatEvent(args, state, runnerIdentity, payloadContext, event);
-  } catch (error) {
-    args.log("kandan.chat_event_failed", {
-      seq: event.seq,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  }
-}
-
-async function drainKandanMessageQueue(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (
-    state.closed ||
-    state.turn.status !== "idle" ||
-    localTuiTurnIsActive(state)
-  ) {
-    return;
-  }
-
-  const next = dequeuePendingKandanMessage(state.queue);
-
-  if (next === undefined) {
-    return;
-  }
-
-  state.turn = { status: "starting", queuedSeq: next.seq, interruptAfterStart: false };
-  state.activeProcessingState = { seq: next.seq, reason: "starting turn" };
-  args.log("codex.turn_starting", {
-    queued_seq: next.seq,
-    actor_slug: next.actorSlug ?? null,
-    actor_user_id: next.actorUserId ?? null,
-    codex_thread_id: state.codexThreadId ?? null,
-    queue_depth: pendingKandanMessageQueueLength(state.queue),
-  });
-  await publishQueuedMessageState(args, state, next, {
-    status: "processing",
-    reason: "starting turn",
-  });
-
-  try {
-    const codexThreadId = state.codexThreadId;
-
-    if (codexThreadId === undefined) {
-      throw new Error("Codex thread is not bound");
-    }
-
-    if (state.kandanThreadId !== undefined) {
-      startCodexTypingHeartbeat(args, state, state.kandanThreadId);
-    }
-
-    const started = await args.codex.request("turn/start", {
-      threadId: codexThreadId,
-      input: await codexInputItemsForQueuedKandanMessage(args, next),
-      ...codexTurnRuntimeOverrides(runtimeOptionsForSettings(args.options, state.runtimeSettings)),
-    });
-    const turnId = extractTurnIdFromResponse(started);
-    const interruptAfterStart =
-      state.turn.status === "starting" && state.turn.interruptAfterStart;
-    state.turn = { status: "active", turnId, queuedSeq: next.seq };
-    rememberTurnReplyTarget(state, turnId, next.seq);
-    args.log("codex.turn_started", { turn_id: turnId });
-
-    if (interruptAfterStart) {
-      await args.codex.request("turn/interrupt", {
-        threadId: codexThreadId,
-        turnId,
-      });
-      state.turn = { status: "idle" };
-      clearActiveProcessingState(state, next.seq);
-      if (state.kandanThreadId !== undefined) {
-        await publishMessageState(args, state.kandanThreadId, next.seq, {
-          status: "processed",
-        });
-      }
-      await drainKandanMessageQueue(args, state, payloadContext);
-    }
-  } catch (error) {
-    if (isRecoverableCodexThreadError(error) && state.kandanThreadId !== undefined) {
-      const oldCodexThreadId = state.codexThreadId;
-      try {
-        await stopCodexTyping(args, state);
-        const newCodexThreadId = await startCodexThread(args.codex, args.options);
-        state.codexThreadId = newCodexThreadId;
-        args.log("codex.thread_rebound", {
-          kandan_thread_id: state.kandanThreadId,
-          old_codex_thread_id: oldCodexThreadId ?? null,
-          new_codex_thread_id: newCodexThreadId,
-        });
-        await postCodexThreadReboundMessage(
-          args,
-          state,
-          payloadContext,
-          oldCodexThreadId,
-          newCodexThreadId,
-        );
-        requeuePendingKandanMessageFront(state.queue, next);
-        state.turn = { status: "idle" };
-        await drainKandanMessageQueue(args, state, payloadContext);
-        return;
-      } catch (recoveryError) {
-        args.log("codex.thread_rebind_failed", {
-          kandan_thread_id: state.kandanThreadId,
-          old_codex_thread_id: oldCodexThreadId ?? null,
-          message: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
-        });
-      }
-    }
-
-    state.turn = { status: "idle" };
-    clearActiveProcessingState(state, next.seq);
-    await stopCodexTyping(args, state);
-    await publishQueuedMessageState(
-      args,
-      state,
-      next,
-      {
-        status: "failed",
-        reason: error instanceof Error ? error.message : String(error),
-      },
-    );
-    args.log("codex.turn_start_failed", {
-      queued_seq: next.seq,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  }
-}
-
-async function handleCodexServerRequest(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  payloadContext: RunnerPayloadContext,
-  request: JsonRpcRequest,
-): Promise<JsonObject> {
-  const params = objectValue(request.params) ?? {};
-  const turnId = stringValue(params.turnId);
-
-  if (codexApprovalRequestCanAutoAccept(state.runtimeSettings, request.method)) {
-    args.log("codex.server_request_auto_accepted", {
-      method: request.method,
-      turn_id: turnId ?? null,
-    });
-    return { decision: "accept" };
-  }
-
-  if (codexApprovalRequestCanSurface(request.method)) {
-    if (turnId === undefined) {
-      throw new Error(`Codex approval request missing turn id: ${request.method}`);
-    }
-
-    return requestKandanApproval(args, state, request, turnId, payloadContext);
-  }
-
-  const message = `unhandled Codex app-server request: ${request.method}`;
-
-  args.log("codex.server_request_unhandled", {
-    method: request.method,
-    turn_id: turnId ?? null,
-  });
-
-  if (turnId !== undefined) {
-    await failActiveCodexTurn(args, state, turnId, message, payloadContext);
-  }
-
-  throw new Error(message);
-}
-
-function codexApprovalRequestCanAutoAccept(
-  settings: LocalCodexRuntimeSettings,
-  method: string,
-): boolean {
-  return (
-    settings.approvalPolicy === "never" &&
-    (
-      method === "item/commandExecution/requestApproval" ||
-      method === "item/fileChange/requestApproval"
-    )
-  );
-}
-
-function codexApprovalRequestCanSurface(method: string): boolean {
-  return (
-    method === "item/commandExecution/requestApproval" ||
-    method === "item/fileChange/requestApproval"
-  );
-}
-
-async function requestKandanApproval(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  request: JsonRpcRequest,
-  turnId: string,
-  payloadContext: RunnerPayloadContext,
-): Promise<JsonObject> {
-  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}`;
-    await failActiveCodexTurn(args, state, turnId, message, payloadContext);
-    throw new Error(message);
-  }
-
-  const approval = codexApprovalMessageState(request);
-  state.activeProcessingState = { seq: sourceSeq, reason: "awaiting approval", approval };
-  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
-    status: "processing",
-    reason: "awaiting approval",
-    approval,
-  });
-
-  args.log("codex.approval_request_pending", {
-    request_id: approval.requestId,
-    source_seq: sourceSeq,
-    turn_id: turnId,
-    method: request.method,
-  });
-
-  return new Promise<JsonObject>((resolve, reject) => {
-    const request = {
-      requestId: approval.requestId,
-      sourceSeq,
-      turnId,
-      resolve,
-      reject,
-    };
-    state.pendingApprovalRequests.set(
-      approvalRequestKey(request.requestId, request.sourceSeq),
-      request,
-    );
-  });
-}
-
-function rejectPendingApprovalRequests(state: ChannelSessionState, error: Error): void {
-  const pendingApprovals = [...state.pendingApprovalRequests.values()];
-  state.pendingApprovalRequests.clear();
-  pendingApprovals.forEach(approval => approval.reject(error));
-}
-
-function rejectPendingApprovalRequestsForTurn(
-  state: ChannelSessionState,
-  turnId: string,
-  error: Error,
-): void {
-  for (const [key, approval] of state.pendingApprovalRequests) {
-    if (approval.turnId === turnId) {
-      state.pendingApprovalRequests.delete(key);
-      approval.reject(error);
-    }
-  }
-}
-
-async function forwardCompletedCodexTurn(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (isLocalTuiTurn(state, turnId)) {
-    ensureKandanThreadForLocalTuiTurn(state);
-  }
-
-  if (
-    state.kandanThreadId === undefined ||
-    state.codexThreadId === undefined ||
-    state.forwardedTurnIds.has(turnId) ||
-    state.forwardingTurnIds.has(turnId) ||
-    !turnCanForward(state, turnId)
-  ) {
-    return;
-  }
-
-  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(args, state, payloadContext);
-  rememberForwardingTurnId(state, turnId);
-  forgetRetryableTurnId(state, turnId);
-
-  try {
-    const read = await args.codex.request("thread/read", {
-      threadId: state.codexThreadId,
-      includeTurns: true,
-    });
-    const tuiInputMessages =
-      isLocalTuiTurn(state, turnId)
-        ? codexUserInputMessagesForTurn(read, turnId)
-        : [];
-    const messages = codexOutputMessagesForTurn(read, turnId);
-    args.log("codex.turn_completed", {
-      turn_id: turnId,
-      tui_input_count: tuiInputMessages.length,
-      output_count: messages.length,
-    });
-
-    if (isLocalTuiTurn(state, turnId)) {
-      ensureKandanThreadForLocalTuiTurn(state);
-    }
-
-    for (const message of tuiInputMessages) {
-      await mirrorLocalTuiInputMessage(args, state, turnId, message, payloadContext);
-    }
-
-    if (
-      completingLocalTuiTurn &&
-      sourceMessageSeqForTurn(state, turnId) === undefined
-    ) {
-      throw new LogicalProjectionError(
-        `Cannot forward Codex output for local TUI turn ${turnId} before mirroring its human input`,
-      );
-    }
-
-    for (const message of messages) {
-      const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
-      const rootSeq = state.rootSeq;
-      const streamedStructured = resolveStreamingStructuredOutputForCompletedMessage(
-        state,
-        message.itemKey,
-        message.structured,
-      );
-
-      if (streamedStructured !== undefined) {
-        await editCodexStructuredOutput(
-          args,
-          state,
-          streamedStructured.seq,
-          message.body,
-          message.structured,
-        );
-        forgetStreamingStructuredOutput(state, message.itemKey, message.structured);
-        args.log("kandan.codex_output_forwarded", {
-          turn_id: turnId,
-          item_key: message.itemKey,
-          structured_kind: stringValue(message.structured.kind) ?? null,
-          command: stringValue(message.structured.command) ?? null,
-          file_paths: fileChangePaths(message.structured),
-        });
-        continue;
-      }
-
-      if (
-        stringValue(message.structured.kind) === "codex_terminal_input" &&
-        state.forwardedTerminalInputKeys.has(message.itemKey)
-      ) {
-        continue;
-      }
-
-      const streamed = resolveStreamingAssistantOutputForCompletedMessage(
-        state,
-        turnId,
-        message.itemKey,
-        message.body,
-        message.structured,
-      );
-
-      switch (streamed.status) {
-        case "none":
-          await streamCompletedCodexOutput(args, state, payloadContext, {
-            turnId,
-            sourceMessageSeq,
-            rootSeq,
-            message,
-          });
-          break;
-        case "matched":
-          await editStreamedCodexOutput(
-            args,
-            state,
-            streamed.output.seq,
-            message.itemKey,
-            message.body,
-            "completed",
-          );
-          forgetStreamingAssistantOutput(state, streamed.output.itemKey);
-          break;
-        case "ambiguous":
-          throw new LogicalProjectionError(
-            `Cannot reconcile completed assistant item ${message.itemKey} for turn ${turnId}; ${streamed.candidateCount} active streamed assistant outputs exist`,
-          );
-      }
-      args.log("kandan.codex_output_forwarded", {
-        turn_id: turnId,
-        item_key: message.itemKey,
-        structured_kind: stringValue(message.structured.kind) ?? null,
-        command: stringValue(message.structured.command) ?? null,
-        file_paths: fileChangePaths(message.structured),
-      });
-    }
-
-    rememberForwardedTurnId(state, turnId);
-    forgetLocalTuiTurnId(state, turnId);
-    if (completingQueuedSeq !== undefined) {
-      await publishMessageState(args, state.kandanThreadId, completingQueuedSeq, {
-        status: "processed",
-      });
-      clearActiveProcessingState(state, completingQueuedSeq);
-    }
-  } catch (error) {
-    if (error instanceof LogicalProjectionError) {
-      if (completingQueuedSeq !== undefined && state.kandanThreadId !== undefined) {
-        await publishMessageState(args, state.kandanThreadId, completingQueuedSeq, {
-          status: "failed",
-          reason: error.message,
-        });
-        clearActiveProcessingState(state, completingQueuedSeq);
-      }
-      forgetLocalTuiTurnId(state, turnId);
-      rememberForwardedTurnId(state, turnId);
-      args.log("codex.logical_projection_failed", {
-        turn_id: turnId,
-        message: error.message,
-      });
-      return;
-    }
-
-    rememberRetryableTurnId(state, turnId);
-    throw error;
-  } finally {
-    forgetForwardingTurnId(state, turnId);
-    if (
-      completingActiveTurn &&
-      state.turn.status === "completing" &&
-      state.turn.turnId === turnId
-    ) {
-      state.turn = { status: "idle" };
-      await stopCodexTyping(args, state);
-      await drainKandanMessageQueue(args, state, payloadContext);
-    }
-    if (completingLocalTuiTurn && !completingActiveTurn) {
-      await stopCodexTyping(args, state);
-      await drainKandanMessageQueue(args, state, payloadContext);
-    }
-  }
-}
-
-async function forwardAssistantDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  const delta = codexAssistantDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  await forwardAssistantDeltaPayload(args, state, delta, payloadContext);
-}
-
-async function forwardAssistantDeltaPayload(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  delta: CodexAssistantDelta,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
-    return;
-  }
-
-  if (
-    delta.turnId !== undefined &&
-    turnIsFinalizingOrForwarded(state, delta.turnId)
-  ) {
-    return;
-  }
-
-  if (delta.turnId !== undefined) {
-    await waitForPendingTuiInputMirror(state, delta.turnId);
-  }
-
-  if (
-    delta.turnId !== undefined &&
-    isLocalTuiTurn(state, delta.turnId) &&
-    sourceMessageSeqForTurn(state, delta.turnId) === undefined
-  ) {
-    args.log("codex.delta_waiting_for_tui_input_projection", {
-      turn_id: delta.turnId,
-      item_key: delta.itemKey,
-    });
-    return;
-  }
-
-  const existing = findStreamingAssistantOutput(state, delta.itemKey);
-  const nextContent = `${existing?.content ?? ""}${delta.delta}`;
-  const sourceMessageSeq =
-    delta.turnId === undefined ? undefined : sourceMessageSeqForTurn(state, delta.turnId);
-  const rootSeq = state.rootSeq;
-
-  if (delta.turnId !== undefined && sourceMessageSeq === undefined) {
-    args.log("codex.delta_without_source_message", {
-      turn_id: delta.turnId,
-      item_key: delta.itemKey,
-    });
-    return;
-  }
-
-  if (existing === undefined && nextContent.trim() === "") {
-    return;
-  }
-
-  if (existing === undefined) {
-    const session = args.options.channelSession;
-    const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body: nextContent,
-      payload: {
-        ...localRunnerPayload(
-          args.options,
-          args.instanceId,
-          "codex_output",
-          state.codexThreadId,
-          payloadContext,
-          sourceMessageSeq,
-        ),
-        ...(rootSeq === undefined ? {} : { reply_to_seq: rootSeq }),
-        structured: codexAssistantStructuredMessage(delta.itemKey, nextContent, "streaming"),
-      },
-      client_message_id: streamingClientMessageId(args.instanceId, delta),
-    });
-    const seq = integerValue(reply.seq);
-
-    if (seq !== undefined) {
-      rememberStreamingAssistantOutput(state, {
-        itemKey: delta.itemKey,
-        turnId: delta.turnId,
-        seq,
-        content: nextContent,
-      });
-    }
-  } else {
-    await editStreamedCodexOutput(
-      args,
-      state,
-      existing.seq,
-      delta.itemKey,
-      nextContent,
-      "streaming",
-    );
-    rememberStreamingAssistantOutput(state, {
-      ...existing,
-      content: nextContent,
-    });
-  }
-
-  args.log("kandan.codex_delta_forwarded", {
-    item_key: delta.itemKey,
-    turn_id: delta.turnId ?? null,
-    content_length: nextContent.length,
-  });
-}
-
-function enqueueAssistantDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): void {
-  const delta = codexAssistantDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  enqueueStreamDelta(
-    state.assistantDeltaQueue,
-    delta,
-    assistantDeltaQueueRuntime(args, state, payloadContext),
-  );
-}
-
-function enqueueReasoningDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): void {
-  const delta = codexReasoningDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  enqueueStreamDelta(
-    state.reasoningDeltaQueue,
-    delta,
-    reasoningDeltaQueueRuntime(args, state, payloadContext),
-  );
-}
-
-function enqueueCommandOutputDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): void {
-  const delta = codexCommandOutputDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  enqueueStreamDelta(
-    state.commandOutputQueue,
-    delta,
-    commandOutputQueueRuntime(args, state, payloadContext),
-  );
-}
-
-function enqueueFileChangeDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): void {
-  const delta = codexFileChangeDeltaFromNotification(params);
-
-  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(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): void {
-  const previous = state.terminalInputForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => forwardTerminalInput(args, state, params, payloadContext));
-
-  state.terminalInputForwardChain = next.catch(error => {
-    args.log("codex.terminal_input_forward_failed", {
-      turn_id: codexNotificationTurnId(params) ?? null,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
-}
-
-function enqueueWebSearchProgress(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): void {
-  const previous = state.webSearchProgressForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => forwardWebSearchProgress(args, state, params, payloadContext));
-
-  state.webSearchProgressForwardChain = next.catch(error => {
-    args.log("codex.web_search_progress_forward_failed", {
-      turn_id: codexNotificationTurnId(params) ?? null,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
-}
-
-function enqueueWebSearchProgressCompletion(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  const previous = state.webSearchProgressForwardChain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => completeWebSearchProgress(args, state, turnId));
-
-  state.webSearchProgressForwardChain = next.catch(error => {
-    args.log("codex.web_search_progress_completion_failed", {
-      turn_id: turnId,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
-}
-
-function enqueueFileChangeCompletion(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  const previous = state.fileChangeQueue.chain;
-  const next = previous
-    .catch(() => undefined)
-    .then(() => completeFileChangeOutputs(args, state, turnId));
-
-  state.fileChangeQueue.chain = next.catch(error => {
-    args.log("codex.file_change_completion_failed", {
-      turn_id: turnId,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  });
-}
-
-async function forwardReasoningDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  const delta = codexReasoningDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  await forwardReasoningDeltaPayload(args, state, delta, payloadContext);
-}
-
-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.turn);
-
-  if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
-    return;
-  }
-
-  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
-
-  if (sourceMessageSeq === undefined) {
-    args.log("codex.reasoning_without_source_message", {
-      turn_id: turnId,
-      item_key: delta.itemKey,
-    });
-    return;
-  }
-
-  const existing = findStreamingReasoningOutput(state, delta.itemKey);
-  const nextContent = `${existing?.content ?? ""}${delta.delta}`;
-
-  if (existing === undefined && nextContent.trim() === "") {
-    return;
-  }
-
-  if (existing === undefined) {
-    const session = args.options.channelSession;
-    const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body: nextContent,
-      payload: {
-        ...localRunnerPayload(
-          args.options,
-          args.instanceId,
-          "codex_output",
-          state.codexThreadId,
-          payloadContext,
-          sourceMessageSeq,
-        ),
-        ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
-        structured: codexReasoningStructuredMessage(delta.itemKey, nextContent, "streaming"),
-      },
-      client_message_id: streamingClientMessageId(args.instanceId, {
-        itemKey: `reasoning:${delta.itemKey}`,
-        turnId,
-      }),
-    });
-    const seq = integerValue(reply.seq);
-
-    if (seq !== undefined) {
-      rememberStreamingReasoningOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        content: nextContent,
-      });
-    }
-  } else {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      existing.seq,
-      nextContent,
-      codexReasoningStructuredMessage(delta.itemKey, nextContent, "streaming"),
-    );
-    rememberStreamingReasoningOutput(state, { ...existing, content: nextContent });
-  }
-
-  args.log("kandan.codex_reasoning_delta_forwarded", {
-    item_key: delta.itemKey,
-    turn_id: turnId,
-    content_length: nextContent.length,
-  });
-}
-
-async function forwardCommandOutputDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  const delta = codexCommandOutputDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  await forwardCommandOutputDeltaPayload(args, state, delta, payloadContext);
-}
-
-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.turn);
-
-  if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
-    return;
-  }
-
-  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
-
-  if (sourceMessageSeq === undefined) {
-    args.log("codex.command_output_without_source_message", {
-      turn_id: turnId,
-      item_key: delta.itemKey,
-    });
-    return;
-  }
-
-  const existing = findStreamingCommandOutput(state, delta.itemKey);
-  const output = `${existing?.output ?? ""}${delta.delta}`;
-  const body = commandOutputBody("command output", output);
-  const structured = codexCommandExecutionStructuredMessage(
-    delta.itemKey,
-    {
-      command: "command output",
-      output,
-      processId: delta.processId,
-      stream: delta.stream,
-    },
-    "streaming",
-  );
-
-  if (existing === undefined) {
-    const session = args.options.channelSession;
-    const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body,
-      payload: {
-        ...localRunnerPayload(
-          args.options,
-          args.instanceId,
-          "codex_output",
-          state.codexThreadId,
-          payloadContext,
-          sourceMessageSeq,
-        ),
-        ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
-        structured,
-      },
-      client_message_id: streamingClientMessageId(args.instanceId, {
-        itemKey: `command:${delta.itemKey}`,
-        turnId,
-      }),
-    });
-    const seq = integerValue(reply.seq);
-
-    if (seq !== undefined) {
-      rememberStreamingCommandOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        output,
-        processId: delta.processId,
-        stream: delta.stream,
-      });
-    }
-  } else {
-    await editCodexStructuredOutput(args, state, existing.seq, body, structured);
-    rememberStreamingCommandOutput(state, {
-      ...existing,
-      output,
-      processId: delta.processId ?? existing.processId,
-      stream: delta.stream,
-    });
-  }
-
-  args.log("kandan.codex_command_output_forwarded", {
-    item_key: delta.itemKey,
-    turn_id: turnId,
-    process_id: delta.processId ?? null,
-    stream: delta.stream,
-    output_length: output.length,
-  });
-}
-
-async function forwardFileChangeDelta(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  const delta = codexFileChangeDeltaFromNotification(params);
-
-  if (delta === undefined) {
-    return;
-  }
-
-  await forwardFileChangeDeltaPayload(args, state, delta, payloadContext);
-}
-
-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.turn);
-
-  if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
-    return;
-  }
-
-  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
-
-  if (sourceMessageSeq === undefined) {
-    args.log("codex.file_change_without_source_message", {
-      turn_id: turnId,
-      item_key: delta.itemKey,
-    });
-    return;
-  }
-
-  const existing = findStreamingFileChangeOutput(state, delta.itemKey);
-  const patchText = `${existing?.patchText ?? ""}${delta.patchText}`;
-  const structured = codexFileChangeStructuredMessage(
-    delta.itemKey,
-    patchText,
-    "streaming",
-    "started",
-  );
-
-  if (existing === undefined) {
-    const session = args.options.channelSession;
-    const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body: patchText,
-      payload: {
-        ...localRunnerPayload(
-          args.options,
-          args.instanceId,
-          "codex_output",
-          state.codexThreadId,
-          payloadContext,
-          sourceMessageSeq,
-        ),
-        ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
-        structured,
-      },
-      client_message_id: streamingClientMessageId(args.instanceId, {
-        itemKey: `file-change:${delta.itemKey}`,
-        turnId,
-      }),
-    });
-    const seq = integerValue(reply.seq);
-
-    if (seq !== undefined) {
-      rememberStreamingFileChangeOutput(state, {
-        itemKey: delta.itemKey,
-        turnId,
-        seq,
-        patchText,
-      });
-    }
-  } else {
-    await editCodexStructuredOutput(args, state, existing.seq, patchText, structured);
-    rememberStreamingFileChangeOutput(state, {
-      ...existing,
-      patchText,
-    });
-  }
-
-  args.log("kandan.codex_file_change_forwarded", {
-    item_key: delta.itemKey,
-    turn_id: turnId,
-    patch_length: patchText.length,
-  });
-}
-
-async function forwardTerminalInput(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
-    return;
-  }
-
-  const terminal = codexTerminalInputFromNotification(params);
-
-  if (terminal === undefined || state.forwardedTerminalInputKeys.has(terminal.itemKey)) {
-    return;
-  }
-
-  const turnId = terminal.turnId ?? activeTurnId(state.turn);
-
-  if (turnId === undefined || turnIsFinalizingOrForwarded(state, turnId)) {
-    return;
-  }
-
-  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
-
-  if (sourceMessageSeq === undefined) {
-    args.log("codex.terminal_input_without_source_message", {
-      turn_id: turnId,
-      item_key: terminal.itemKey,
-    });
-    return;
-  }
-
-  const session = args.options.channelSession;
-  await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: state.kandanThreadId,
-    body: terminal.inputText,
-    payload: {
-      ...localRunnerPayload(
-        args.options,
-        args.instanceId,
-        "codex_output",
-        state.codexThreadId,
-        payloadContext,
-        sourceMessageSeq,
-      ),
-      ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
-      structured: {
-        kind: "codex_terminal_input",
-        item_id: terminal.itemKey,
-        transcript_unit_id: `codex_terminal_input:${terminal.itemKey}`,
-        stream_state: "completed",
-        process_id: terminal.processId ?? "",
-        input_text: terminal.inputText,
-      },
-    },
-    client_message_id: streamingClientMessageId(args.instanceId, {
-      itemKey: `terminal:${terminal.itemKey}`,
-      turnId,
-    }),
-  });
-  rememberForwardedTerminalInputKey(state, terminal.itemKey);
-  args.log("kandan.codex_output_forwarded", {
-    turn_id: turnId,
-    item_key: terminal.itemKey,
-    structured_kind: "codex_terminal_input",
-    command: null,
-    file_paths: [],
-  });
-}
-
-async function forwardWebSearchProgress(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
-    return;
-  }
-
-  const progress = codexWebSearchProgressFromNotification(params);
-
-  if (progress === undefined || progress.turnId === undefined) {
-    return;
-  }
-
-  const sourceMessageSeq = sourceMessageSeqForTurn(state, progress.turnId);
-
-  if (sourceMessageSeq === undefined) {
-    args.log("codex.web_search_without_source_message", {
-      turn_id: progress.turnId,
-      item_key: progress.itemKey,
-    });
-    return;
-  }
-
-  const itemKey = webSearchProgressItemKey(progress.turnId);
-  const existing = findWebSearchProgressOutput(state, progress.turnId);
-  const queries = mergeWebSearchQueries(existing?.queries ?? [], progress.queries);
-  const body = webSearchProgressBody(queries);
-  const structured = codexWebSearchStructuredMessage(itemKey, queries, "streaming");
-
-  if (existing === undefined) {
-    const session = args.options.channelSession;
-    const reply = await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-      body,
-      payload: {
-        ...localRunnerPayload(
-          args.options,
-          args.instanceId,
-          "codex_output",
-          state.codexThreadId,
-          payloadContext,
-          sourceMessageSeq,
-        ),
-        ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
-        structured,
-      },
-      client_message_id: webSearchProgressClientMessageId(args.instanceId, progress.turnId),
-    });
-    const seq = integerValue(reply.seq);
-
-    if (seq !== undefined) {
-      rememberWebSearchProgressOutput(state, {
-        turnId: progress.turnId,
-        itemKey,
-        seq,
-        queries,
-      });
-    }
-  } else if (queries.length !== existing.queries.length) {
-    await editCodexStructuredOutput(args, state, existing.seq, body, structured);
-    rememberWebSearchProgressOutput(state, {
-      ...existing,
-      queries,
-    });
-  }
-
-  args.log("kandan.codex_web_search_progress_forwarded", {
-    turn_id: progress.turnId,
-    item_key: progress.itemKey,
-    query_count: queries.length,
-  });
-}
-
-async function completeWebSearchProgress(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-): Promise<void> {
-  const existing = findWebSearchProgressOutput(state, turnId);
-
-  if (existing === undefined) {
-    return;
-  }
-
-  await editCodexStructuredOutput(
-    args,
-    state,
-    existing.seq,
-    webSearchProgressBody(existing.queries),
-    codexWebSearchStructuredMessage(existing.itemKey, existing.queries, "completed"),
-  );
-  forgetWebSearchProgressOutput(state, turnId);
-}
-
-async function completeFileChangeOutputs(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-): Promise<void> {
-  const outputs = boundedCacheValues(state.streamingFileChangeOutputs).filter(
-    output => output.turnId === turnId,
-  );
-
-  for (const output of outputs) {
-    await editCodexStructuredOutput(
-      args,
-      state,
-      output.seq,
-      output.patchText,
-      codexFileChangeStructuredMessage(
-        output.itemKey,
-        output.patchText,
-        "completed",
-        "completed",
-      ),
-    );
-  }
-}
-
-function streamingClientMessageId(
-  instanceId: string,
-  delta: { readonly itemKey: string; readonly turnId: string | undefined },
-): string {
-  const digest = createHash("sha256")
-    .update(`${instanceId}:${delta.turnId ?? "turn"}:${delta.itemKey}`)
-    .digest("hex")
-    .slice(0, 32);
-
-  return `local-codex-stream-${digest}`;
-}
-
-function webSearchProgressClientMessageId(instanceId: string, turnId: string): string {
-  const digest = createHash("sha256")
-    .update(`${instanceId}:${turnId}:web-search`)
-    .digest("hex")
-    .slice(0, 32);
-
-  return `local-codex-search-${digest}`;
-}
-
-function webSearchProgressItemKey(turnId: string): string {
-  return `web-search:${turnId}`;
-}
-
-function commandOutputBody(command: string, output: string): string {
-  return [`$ ${command}`, output].filter(part => part.trim() !== "").join("\n\n");
-}
-
-async function streamCompletedCodexOutput(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  payloadContext: RunnerPayloadContext,
-  params: {
-    readonly turnId: string;
-    readonly sourceMessageSeq: number | undefined;
-    readonly rootSeq: number | undefined;
-    readonly message: {
-      readonly itemKey: string;
-      readonly body: string;
-      readonly structured: JsonObject;
-    };
-  },
-): Promise<void> {
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
-    return;
-  }
-
-  const session = args.options.channelSession;
-  const streamKey = streamingClientMessageId(args.instanceId, {
-    itemKey: params.message.itemKey,
-    turnId: params.turnId,
-  });
-  const streamMetadata: JsonObject = {
-    turn_id: params.turnId,
-    stream_key: streamKey,
-  };
-  const structured = structuredWithStreamKey(params.message.structured, streamKey);
-  const uploadedFileIds = await uploadedFileIdsForCodexOutput(
-    args,
-    params.message.body,
-    structured,
-  );
-
-  await pushOk(args.kandan, args.topic, "session:stream_thread_message", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: state.kandanThreadId,
-    stream_key: streamKey,
-    body: params.message.body,
-    payload: {
-      ...localRunnerPayload(
-        args.options,
-        args.instanceId,
-        "codex_output",
-        state.codexThreadId,
-        payloadContext,
-        params.sourceMessageSeq,
-        streamMetadata,
-      ),
-      ...(params.rootSeq === undefined ? {} : { reply_to_seq: params.rootSeq }),
-      ...(params.sourceMessageSeq === undefined
-        ? {}
-        : { source_message_seq: params.sourceMessageSeq }),
-      ...streamMetadata,
-      structured,
-    },
-    ...(uploadedFileIds.length === 0
-      ? {}
-      : { uploaded_file_ids: uploadedFileIds }),
-    client_message_id: streamKey,
-  });
-}
-
-function structuredWithStreamKey(
-  structured: JsonObject,
-  streamKey: string | undefined,
-): JsonObject {
-  return streamKey === undefined
-    ? structured
-    : { ...structured, stream_key: streamKey };
-}
-
-async function editStreamedCodexOutput(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  targetSeq: number,
-  itemKey: string,
-  content: string,
-  streamState: "streaming" | "completed",
-): Promise<void> {
-  await editCodexStructuredOutput(
-    args,
-    state,
-    targetSeq,
-    content,
-    codexAssistantStructuredMessage(itemKey, content, streamState),
-  );
-}
-
-async function editCodexStructuredOutput(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  targetSeq: number,
-  content: string,
-  structured: JsonObject,
-): Promise<void> {
-  if (state.kandanThreadId === undefined) {
-    return;
-  }
-
-  const session = args.options.channelSession;
-  await pushOk(args.kandan, args.topic, "session:edit_thread_message", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: state.kandanThreadId,
-    target_seq: targetSeq,
-    body: content,
-    structured,
-  });
-}
-
-async function mirrorLocalTuiInputFromNotification(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-  params: JsonObject,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  if (!isLocalTuiTurn(state, turnId)) {
-    return;
-  }
-
-  const message = codexUserInputMessageFromNotification(params);
-
-  if (message === undefined) {
-    return;
-  }
-
-  await mirrorLocalTuiInputMessage(args, state, turnId, message, payloadContext);
-}
-
-async function mirrorLocalTuiInputMessage(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-  message: CodexUserInputMessage,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  const logicalKey = tuiInputLogicalKey(turnId, message.body);
-
-  if (findMirroredTuiInputProjection(state, logicalKey) !== undefined) {
-    rememberMirroredTuiInputItemKey(state, logicalKey, message.itemKey);
-    return;
-  }
-
-  ensureKandanThreadForLocalTuiTurn(state);
-  const threadId = state.kandanThreadId;
-  const codexThreadId = state.codexThreadId;
-
-  if (threadId === undefined || codexThreadId === undefined) {
-    return;
-  }
-
-  const session = args.options.channelSession;
-  const reply = await pushOk(args.kandan, args.topic, "session:post_thread_user_message", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: threadId,
-    body: message.body,
-    payload: {
-      ...localRunnerPayload(
-        args.options,
-        args.instanceId,
-        "tui_input",
-        codexThreadId,
-        payloadContext,
-      ),
-      ...(state.rootSeq === undefined ? {} : { reply_to_seq: state.rootSeq }),
-    },
-    client_message_id: tuiInputClientMessageId(args.instanceId, turnId, message.itemKey),
-  });
-  const seq = integerValue(reply.seq);
-  if (seq !== undefined) {
-    rememberTurnReplyTarget(state, turnId, seq);
-    rememberMirroredTuiInputProjection(state, {
-      logicalKey,
-      turnId,
-      seq,
-      itemKeys: [message.itemKey],
-    });
-  }
-  args.log("kandan.tui_input_mirrored", {
-    turn_id: turnId,
-    item_key: message.itemKey,
-    actor_user_id: payloadContext.runnerIdentity.actorUserId ?? null,
-    actor_slug: payloadContext.runnerIdentity.actorUsername ?? null,
-  });
-}
-
-function tuiInputClientMessageId(
-  instanceId: string,
-  turnId: string,
-  itemKey: string,
-): string {
-  const digest = createHash("sha256")
-    .update(`${instanceId}:${turnId}:${itemKey}`)
-    .digest("hex")
-    .slice(0, 32);
-
-  return `local-codex-tui-${digest}`;
-}
-
-function tuiInputLogicalKey(turnId: string, body: string): string {
-  const digest = createHash("sha256")
-    .update(`${turnId}:${body.trim()}`)
-    .digest("hex")
-    .slice(0, 32);
-
-  return `local-codex-tui-input:${digest}`;
-}
-
-function findMirroredTuiInputProjection(
-  state: ChannelSessionState,
-  logicalKey: string,
-): MirroredTuiInputProjection | undefined {
-  return getBoundedCacheValue(state.mirroredTuiInputProjections, logicalKey);
-}
-
-function rememberMirroredTuiInputProjection(
-  state: ChannelSessionState,
-  projection: MirroredTuiInputProjection,
-): void {
-  rememberBoundedCacheValue(
-    state.mirroredTuiInputProjections,
-    projection.logicalKey,
-    projection,
-  );
-}
-
-function rememberMirroredTuiInputItemKey(
-  state: ChannelSessionState,
-  logicalKey: string,
-  itemKey: string,
-): void {
-  const existing = findMirroredTuiInputProjection(state, logicalKey);
-
-  if (existing === undefined || existing.itemKeys.includes(itemKey)) {
-    return;
-  }
-
-  rememberMirroredTuiInputProjection(state, {
-    ...existing,
-    itemKeys: [...existing.itemKeys, itemKey],
-  });
-}
-
-function findStreamingAssistantOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): StreamingAssistantOutput | undefined {
-  return getBoundedCacheValue(state.streamingAssistantOutputs, itemKey);
-}
-
-function findStreamingReasoningOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): StreamingReasoningOutput | undefined {
-  return getBoundedCacheValue(state.streamingReasoningOutputs, itemKey);
-}
-
-function findStreamingCommandOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): StreamingCommandOutput | undefined {
-  return getBoundedCacheValue(state.streamingCommandOutputs, itemKey);
-}
-
-function findStreamingFileChangeOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): StreamingFileChangeOutput | undefined {
-  return getBoundedCacheValue(state.streamingFileChangeOutputs, itemKey);
-}
-
-type StreamedStructuredOutput = {
-  readonly itemKey: string;
-  readonly seq: number;
-};
-
-function resolveStreamingStructuredOutputForCompletedMessage(
-  state: ChannelSessionState,
-  itemKey: string,
-  structured: JsonObject,
-): StreamedStructuredOutput | undefined {
-  switch (stringValue(structured.kind)) {
-    case "codex_reasoning": {
-      const output = findStreamingReasoningOutput(state, itemKey);
-      return output === undefined ? undefined : { itemKey: output.itemKey, seq: output.seq };
-    }
-    case "codex_command_execution": {
-      const output = findStreamingCommandOutput(state, itemKey);
-      return output === undefined ? undefined : { itemKey: output.itemKey, seq: output.seq };
-    }
-    case "codex_file_change": {
-      const output = findStreamingFileChangeOutput(state, itemKey);
-      return output === undefined ? undefined : { itemKey: output.itemKey, seq: output.seq };
-    }
-    default:
-      return undefined;
-  }
-}
-
-function forgetStreamingStructuredOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-  structured: JsonObject,
-): void {
-  switch (stringValue(structured.kind)) {
-    case "codex_reasoning":
-      forgetStreamingReasoningOutput(state, itemKey);
-      break;
-    case "codex_command_execution":
-      forgetStreamingCommandOutput(state, itemKey);
-      break;
-    case "codex_file_change":
-      forgetStreamingFileChangeOutput(state, itemKey);
-      break;
-  }
-}
-
-type StreamingAssistantOutputResolution =
-  | { readonly status: "matched"; readonly output: StreamingAssistantOutput }
-  | { readonly status: "none" }
-  | { readonly status: "ambiguous"; readonly candidateCount: number };
-
-class LogicalProjectionError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "LogicalProjectionError";
-  }
-}
-
-function resolveStreamingAssistantOutputForCompletedMessage(
-  state: ChannelSessionState,
-  turnId: string,
-  itemKey: string,
-  body: string,
-  structured: JsonObject,
-): StreamingAssistantOutputResolution {
-  const exact = findStreamingAssistantOutput(state, itemKey);
-
-  if (exact !== undefined) {
-    return { status: "matched", output: exact };
-  }
-
-  if (stringValue(structured.kind) !== "codex_assistant_message") {
-    return { status: "none" };
-  }
-
-  const candidates = boundedCacheValues(state.streamingAssistantOutputs).filter(
-    output => output.turnId === turnId,
-  );
-
-  switch (candidates.length) {
-    case 0:
-      return { status: "none" };
-    case 1: {
-      const [output] = candidates;
-      return output === undefined
-        ? { status: "none" }
-        : { status: "matched", output };
-    }
-    default: {
-      const contentMatched = candidates.filter(
-        output => normalizedTranscriptText(output.content) === normalizedTranscriptText(body),
-      );
-
-      if (contentMatched.length === 1) {
-        const [output] = contentMatched;
-        return output === undefined
-          ? { status: "ambiguous", candidateCount: candidates.length }
-          : { status: "matched", output };
-      }
-
-      return { status: "ambiguous", candidateCount: candidates.length };
-    }
-  }
-}
-
-function normalizedTranscriptText(value: string): string {
-  return value.trim().replace(/\s+/g, " ");
-}
-
-function turnIsFinalizingOrForwarded(
-  state: ChannelSessionState,
-  turnId: string,
-): boolean {
-  return (
-    state.forwardingTurnIds.has(turnId) ||
-    state.forwardedTurnIds.has(turnId)
-  );
-}
-
-function rememberStreamingAssistantOutput(
-  state: ChannelSessionState,
-  output: StreamingAssistantOutput,
-): void {
-  rememberBoundedCacheValue(state.streamingAssistantOutputs, output.itemKey, output);
-}
-
-function forgetStreamingAssistantOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): void {
-  forgetBoundedCacheValue(state.streamingAssistantOutputs, itemKey);
-}
-
-function rememberStreamingReasoningOutput(
-  state: ChannelSessionState,
-  output: StreamingReasoningOutput,
-): void {
-  rememberBoundedCacheValue(state.streamingReasoningOutputs, output.itemKey, output);
-}
-
-function forgetStreamingReasoningOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): void {
-  forgetBoundedCacheValue(state.streamingReasoningOutputs, itemKey);
-}
-
-function rememberStreamingCommandOutput(
-  state: ChannelSessionState,
-  output: StreamingCommandOutput,
-): void {
-  rememberBoundedCacheValue(state.streamingCommandOutputs, output.itemKey, output);
-}
-
-function forgetStreamingCommandOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): void {
-  forgetBoundedCacheValue(state.streamingCommandOutputs, itemKey);
-}
-
-function rememberStreamingFileChangeOutput(
-  state: ChannelSessionState,
-  output: StreamingFileChangeOutput,
-): void {
-  rememberBoundedCacheValue(state.streamingFileChangeOutputs, output.itemKey, output);
-}
-
-function forgetStreamingFileChangeOutput(
-  state: ChannelSessionState,
-  itemKey: string,
-): void {
-  forgetBoundedCacheValue(state.streamingFileChangeOutputs, itemKey);
-}
-
-function rememberForwardedTerminalInputKey(
-  state: ChannelSessionState,
-  itemKey: string,
-): void {
-  if (state.forwardedTerminalInputKeys.has(itemKey)) {
-    return;
-  }
-
-  rememberBoundedStringSet(state.forwardedTerminalInputKeys, itemKey, maxForwardedTurnIds);
-}
-
-function findWebSearchProgressOutput(
-  state: ChannelSessionState,
-  turnId: string,
-): WebSearchProgressOutput | undefined {
-  return getBoundedCacheValue(state.webSearchProgressOutputs, turnId);
-}
-
-function rememberWebSearchProgressOutput(
-  state: ChannelSessionState,
-  output: WebSearchProgressOutput,
-): void {
-  rememberBoundedCacheValue(state.webSearchProgressOutputs, output.turnId, output);
-}
-
-function forgetWebSearchProgressOutput(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  forgetBoundedCacheValue(state.webSearchProgressOutputs, turnId);
-}
-
-function mergeWebSearchQueries(
-  existing: readonly string[],
-  incoming: readonly string[],
-): string[] {
-  return [...existing, ...incoming].reduce<string[]>((acc, query) => {
-    if (acc.includes(query)) {
-      return acc;
-    }
-
-    return [...acc, query];
-  }, []);
-}
-
-function codexNotificationTurnId(params: JsonObject): string | undefined {
-  const turn = objectValue(params.turn);
-
-  return (
-    stringValue(turn?.id) ??
-    stringValue(params.turnId) ??
-    stringValue(params.turn_id)
-  );
-}
-
-function codexNotificationThreadId(params: JsonObject): string | undefined {
-  const thread = objectValue(params.thread);
-  const turn = objectValue(params.turn);
-
-  return (
-    stringValue(params.threadId) ??
-    stringValue(params.thread_id) ??
-    stringValue(thread?.id) ??
-    stringValue(turn?.threadId) ??
-    stringValue(turn?.thread_id)
-  );
-}
-
-function codexNotificationBelongsToSession(
-  state: ChannelSessionState,
-  threadId: string | undefined,
-  turnId: string | undefined,
-): boolean {
-  if (threadId !== undefined) {
-    return state.codexThreadId === threadId;
-  }
-
-  if (turnId === undefined) {
-    return false;
-  }
-
-  return activeTurnId(state.turn) === turnId || isLocalTuiTurn(state, turnId);
-}
-
-function rememberLocalTuiTurnIfNeeded(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  threadId: string,
-  turnId: string,
-): void {
-  if (
-    args.options.launchTui !== true ||
-    state.codexThreadId !== threadId ||
-    state.turn.status !== "idle"
-  ) {
-    return;
-  }
-
-  rememberBoundedStringSet(state.localTuiTurnIds, turnId, maxForwardedTurnIds);
-  if (state.kandanThreadId !== undefined) {
-    startCodexTypingHeartbeat(args, state, state.kandanThreadId);
-  }
-  args.log("codex.tui_turn_started", { turn_id: turnId, codex_thread_id: threadId });
-}
-
-function isLocalTuiTurn(state: ChannelSessionState, turnId: string): boolean {
-  return state.localTuiTurnIds.has(turnId);
-}
-
-function localTuiTurnIsActive(state: ChannelSessionState): boolean {
-  return state.localTuiTurnIds.size > 0;
-}
-
-function ensureKandanThreadForLocalTuiTurn(
-  state: ChannelSessionState,
-): void {
-  if (state.kandanThreadId !== undefined || state.rootSeq === undefined) {
-    return;
-  }
-
-  state.kandanThreadId = randomUUID();
-}
-
-function forgetLocalTuiTurnId(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  state.localTuiTurnIds.delete(turnId);
-}
-
-function rememberPendingTuiInputMirror(
-  state: ChannelSessionState,
-  turnId: string,
-  promise: Promise<void>,
-): void {
-  state.pendingTuiInputMirrors.delete(turnId);
-  state.pendingTuiInputMirrors.set(turnId, promise);
-  trimBoundedMap(state.pendingTuiInputMirrors, maxForwardedTurnIds);
-}
-
-function forgetPendingTuiInputMirror(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  state.pendingTuiInputMirrors.delete(turnId);
-}
-
-async function waitForPendingTuiInputMirror(
-  state: ChannelSessionState,
-  turnId: string,
-): Promise<void> {
-  const pending = state.pendingTuiInputMirrors.get(turnId);
-
-  if (pending !== undefined) {
-    await pending;
-  }
-}
-
-async function waitForStreamingForwardChains(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  flushPendingStreamingDeltas(args, state, payloadContext);
-  await Promise.all([
-    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 {
-  rememberBoundedCacheValue(state.turnReplyTargets, turnId, { turnId, replyToSeq });
-}
-
-function sourceMessageSeqForTurn(
-  state: ChannelSessionState,
-  turnId: string,
-): number | undefined {
-  return getBoundedCacheValue(state.turnReplyTargets, turnId)?.replyToSeq;
-}
-
-function fileChangePaths(structured: JsonObject): string[] {
-  const changes = arrayValue(structured.changes) ?? [];
-
-  return changes
-    .filter(isJsonObject)
-    .map(change => stringValue(change.path) ?? "")
-    .filter(path => path.trim() !== "");
-}
-
-async function postCodexThreadReboundMessage(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  payloadContext: RunnerPayloadContext,
-  oldCodexThreadId: string | undefined,
-  newCodexThreadId: string,
-): Promise<void> {
-  if (state.kandanThreadId === undefined) {
-    return;
-  }
-
-  const session = args.options.channelSession;
-  const body = [
-    "Codex reconnected.",
-    "",
-    "The previous local Codex app-server thread was not available in this process, so this runner started a new local Codex thread for this Kandan thread.",
-    "",
-    `Previous Codex thread: ${oldCodexThreadId ?? "unknown"}`,
-    `New Codex thread: ${newCodexThreadId}`,
-  ].join("\n");
-
-  await pushOk(args.kandan, args.topic, "session:post_thread_message", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: state.kandanThreadId,
-    body,
-    payload: localRunnerPayload(
-      args.options,
-      args.instanceId,
-      "availability",
-      newCodexThreadId,
-      payloadContext,
-    ),
-    client_message_id: `local-codex-rebound-${args.instanceId}-${newCodexThreadId}`,
-  });
-}
-
-function isRecoverableCodexThreadError(error: unknown): boolean {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-
-  return (
-    error.message.includes("turn/start failed: thread not found") ||
-    error.message.includes("turn/start failed: invalid thread id")
-  );
-}
-
-function turnCanForward(state: ChannelSessionState, turnId: string): boolean {
-  if (state.retryableTurnIds.has(turnId)) {
-    return true;
-  }
-
-  if (isLocalTuiTurn(state, turnId)) {
-    return true;
-  }
-
-  return turnCanForwardByState(state.turn, turnId);
-}
-
-function rememberForwardedTurnId(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  if (state.forwardedTurnIds.has(turnId)) {
-    return;
-  }
-
-  rememberBoundedStringSet(state.forwardedTurnIds, turnId, maxForwardedTurnIds);
-  forgetRetryableTurnId(state, turnId);
-}
-
-function rememberForwardingTurnId(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  rememberBoundedStringSet(state.forwardingTurnIds, turnId, maxForwardedTurnIds);
-}
-
-function forgetForwardingTurnId(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  state.forwardingTurnIds.delete(turnId);
-}
-
-function rememberRetryableTurnId(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  rememberBoundedStringSet(state.retryableTurnIds, turnId, maxForwardedTurnIds);
-}
-
-function forgetRetryableTurnId(
-  state: ChannelSessionState,
-  turnId: string,
-): void {
-  state.retryableTurnIds.delete(turnId);
-}
-
-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);
-  }
-}
-
-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(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-): Promise<void> {
-  stopCodexTypingHeartbeat(state);
-
-  if (state.kandanThreadId === undefined) {
-    return;
-  }
-
-  const session = args.options.channelSession;
-  await pushOptional(
-    args.kandan,
-    args.topic,
-    "session:typing_stop",
-    {
-      workspace: session.workspaceSlug,
-      channel: session.channelSlug,
-      thread_id: state.kandanThreadId,
-    },
-    args.log,
-  );
-}
-
-function startCodexTypingHeartbeat(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  threadId: string,
-): void {
-  const send = () => {
-    if (state.typingHeartbeatInFlight) {
-      return;
-    }
-
-    const session = args.options.channelSession;
-    state.typingHeartbeatInFlight = true;
-    void pushOptional(
-      args.kandan,
-      args.topic,
-      "session:typing_start",
-      {
-        workspace: session.workspaceSlug,
-        channel: session.channelSlug,
-        thread_id: threadId,
-      },
-      args.log,
-    )
-      .then(() => refreshActiveProcessingHeartbeat(args, state))
-      .catch(error => {
-        args.log("kandan.typing_heartbeat_failed", {
-          message: error instanceof Error ? error.message : String(error),
-        });
-      })
-      .finally(() => {
-      state.typingHeartbeatInFlight = false;
-    });
-  };
-
-  send();
-
-  if (state.typingHeartbeat === undefined) {
-    state.typingHeartbeat = setInterval(send, codexTypingHeartbeatMs);
-  }
-}
-
-function stopCodexTypingHeartbeat(state: ChannelSessionState): void {
-  if (state.typingHeartbeat !== undefined) {
-    clearInterval(state.typingHeartbeat);
-    state.typingHeartbeat = undefined;
-  }
-}
-
-async function publishKandanMessageState(
-  args: ChannelSessionContext,
-  event: KandanChatEvent,
-  state: LocalCodexMessageState,
-): Promise<void> {
-  if (event.threadId === undefined) {
-    return;
-  }
-
-  await publishMessageState(
-    args,
-    event.threadId,
-    event.seq,
-    state,
-    event.actorSlug,
-    event.actorUserId,
-  );
-}
-
-async function publishQueuedMessageState(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  message: QueuedKandanMessage,
-  messageState: LocalCodexMessageState,
-): Promise<void> {
-  if (state.kandanThreadId === undefined) {
-    return;
-  }
-
-  await publishMessageState(
-    args,
-    state.kandanThreadId,
-    message.seq,
-    messageState,
-    message.actorSlug,
-    message.actorUserId,
-  );
-}
-
-async function publishMessageState(
-  args: ChannelSessionContext,
-  threadId: string,
-  seq: number,
-  state: LocalCodexMessageState,
-  actorSlug?: string,
-  actorUserId?: number,
-): Promise<void> {
-  const session = args.options.channelSession;
-  const payload = {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: threadId,
-    seq,
-    status: state.status,
-    ...("reason" in state ? { reason: state.reason } : {}),
-    ...(state.status === "processing" && state.approval !== undefined
-      ? {
-          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 }),
-    ...(actorUserId === undefined ? {} : { actor_user_id: actorUserId }),
-  };
-
-  await pushOptional(args.kandan, args.topic, "message_state", payload, args.log);
-}
-
-function abortReason(params: JsonObject): string {
-  return (
-    stringValue(params.reason) ??
-    stringValue(params.message) ??
-    stringValue(params.error) ??
-    "codex_turn_aborted"
-  );
-}
-
-async function failActiveCodexTurn(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-  reason: string,
-  payloadContext: RunnerPayloadContext,
-): Promise<void> {
-  rejectPendingApprovalRequestsForTurn(state, turnId, new Error(reason));
-  const seq = activeQueuedSeqForTurn(state.turn, turnId);
-
-  if (seq !== undefined && state.kandanThreadId !== undefined) {
-    await publishMessageState(args, state.kandanThreadId, seq, {
-      status: "failed",
-      reason,
-    });
-    clearActiveProcessingState(state, seq);
-  }
-
-  forgetLocalTuiTurnId(state, turnId);
-  rememberForwardedTurnId(state, turnId);
-
-  if (shouldClearTurnAfterFailure(state.turn, turnId)) {
-    state.turn = { status: "idle" };
-  }
-
-  await stopCodexTyping(args, state);
-  await drainKandanMessageQueue(args, state, payloadContext);
-}
-
-async function refreshActiveProcessingState(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-  turnId: string,
-  reason: Exclude<LocalCodexProcessingReason, "awaiting approval">,
-): Promise<void> {
-  const seq = activeQueuedSeqForTurn(state.turn, turnId);
-
-  if (seq === undefined || state.kandanThreadId === undefined) {
-    return;
-  }
-
-  if (
-    state.activeProcessingState?.seq === seq &&
-    state.activeProcessingState.reason === reason
-  ) {
-    return;
-  }
-
-  state.activeProcessingState = { seq, reason };
-  await publishMessageState(args, state.kandanThreadId, seq, {
-    status: "processing",
-    reason,
-  });
-}
-
-async function refreshActiveProcessingHeartbeat(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-): Promise<void> {
-  const activeProcessingState = state.activeProcessingState;
-
-  if (
-    activeProcessingState === undefined ||
-    state.kandanThreadId === undefined
-  ) {
-    return;
-  }
-
-  await publishMessageState(
-    args,
-    state.kandanThreadId,
-    activeProcessingState.seq,
-    processingMessageStateFromActive(activeProcessingState),
-  );
-}
-
-function clearActiveProcessingState(state: ChannelSessionState, seq: number): void {
-  if (state.activeProcessingState?.seq === seq) {
-    state.activeProcessingState = undefined;
-  }
-}
-
-type DownloadedKandanAttachment = {
-  readonly fileName: string;
-  readonly contentType: string | undefined;
-  readonly sizeBytes: number | undefined;
-  readonly path: string;
-  readonly isImage: boolean;
-};
-
-async function codexInputItemsForQueuedKandanMessage(
-  args: ChannelSessionContext,
-  message: QueuedKandanMessage,
-): Promise<JsonObject[]> {
-  const attachments = await downloadQueuedKandanAttachments(args, message);
-  const text = appendDownloadedAttachmentContext(
-    codexInputForQueuedKandanMessage(message),
-    attachments,
-  );
-  const imageItems = attachments.flatMap(attachment =>
-    attachment.isImage ? [{ type: "localImage", path: attachment.path }] : [],
-  );
-
-  return [{ type: "text", text }, ...imageItems];
-}
-
-async function downloadQueuedKandanAttachments(
-  args: ChannelSessionContext,
-  message: QueuedKandanMessage,
-): Promise<DownloadedKandanAttachment[]> {
-  if (message.attachments.length === 0) {
-    return [];
-  }
-
-  const directory = join(
-    args.options.cwd,
-    ".kandan",
-    "local-codex-attachments",
-    `message-${message.seq}`,
-  );
-  await mkdir(directory, { recursive: true });
-
-  const downloaded: DownloadedKandanAttachment[] = [];
-
-  for (const [index, attachment] of message.attachments.entries()) {
-    const url = attachment.url;
-
-    if (url === undefined) {
-      throw new Error(
-        `attachment ${index + 1} for message ${message.seq} is missing a URL`,
-      );
-    }
-
-    const fileName = safeAttachmentFileName(
-      attachment.fileName ?? attachment.id ?? `attachment-${index + 1}`,
-      index,
-    );
-    const localPath = join(directory, fileName);
-    const response = await fetch(resolveKandanAttachmentUrl(args.options.kandanUrl, url), {
-      headers: {
-        authorization: `Bearer ${args.options.token}`,
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error(
-        `attachment ${fileName} download failed: ${response.status} ${response.statusText}`,
-      );
-    }
-
-    const bytes = Buffer.from(await response.arrayBuffer());
-    await writeFile(localPath, bytes);
-
-    downloaded.push({
-      fileName,
-      contentType: attachment.contentType,
-      sizeBytes: attachment.sizeBytes ?? bytes.byteLength,
-      path: localPath,
-      isImage: isImageAttachment(attachment.contentType, attachment.kind),
-    });
-  }
-
-  return downloaded;
-}
-
-function appendDownloadedAttachmentContext(
-  input: string,
-  attachments: readonly DownloadedKandanAttachment[],
-): string {
-  if (input.trimStart().startsWith("!")) {
-    return input;
-  }
-
-  const attachmentContext =
-    attachments.length === 0
-      ? []
-      : [
-          "",
-          "Kandan attachments downloaded for this message:",
-          ...attachments.map(attachment => {
-            const details = [
-              attachment.contentType,
-              attachment.sizeBytes === undefined
-                ? undefined
-                : `${attachment.sizeBytes} bytes`,
-            ].flatMap(value => (value === undefined ? [] : [value]));
-            const suffix = details.length === 0 ? "" : ` (${details.join(", ")})`;
-
-            return `- ${attachment.fileName}${suffix}: ${attachment.path}`;
-          }),
-        ];
-
-  return [
-    input,
-    ...attachmentContext,
-    "",
-    "If you create files that should be attached back to Kandan, end your assistant response with:",
-    "Kandan attachments:",
-    "- relative/or/absolute/path/to/file",
-  ].join("\n");
-}
-
-function resolveKandanAttachmentUrl(
-  kandanUrl: string | undefined,
-  url: string,
-): string {
-  const absolute = tryAbsoluteUrl(url);
-
-  if (absolute !== undefined) {
-    return absolute;
-  }
-
-  if (kandanUrl === undefined) {
-    throw new Error(
-      `relative attachment URL cannot be resolved without Kandan URL: ${url}`,
-    );
-  }
-
-  const httpBase = kandanUrl
-    .replace(/^wss:\/\//, "https://")
-    .replace(/^ws:\/\//, "http://");
-
-  return new URL(url, httpBase).toString();
-}
-
-function tryAbsoluteUrl(url: string): string | undefined {
-  try {
-    return new URL(url).toString();
-  } catch (_error) {
-    return undefined;
-  }
-}
-
-function safeAttachmentFileName(fileName: string, index: number): string {
-  const normalized = basename(fileName)
-    .replaceAll(/[^\w.\- ]/g, "_")
-    .trim();
-  const safeName =
-    normalized === "" || normalized === "." || normalized === ".."
-      ? `attachment-${index + 1}`
-      : normalized;
-
-  return `${index + 1}-${safeName}`;
-}
-
-function isImageAttachment(
-  contentType: string | undefined,
-  kind: string | undefined,
-): boolean {
-  if (
-    contentType !== undefined &&
-    contentType.toLowerCase().startsWith("image/")
-  ) {
-    return true;
-  }
-
-  return kind?.toLowerCase() === "image";
-}
-
-async function uploadedFileIdsForCodexOutput(
-  args: ChannelSessionContext,
-  body: string,
-  structured: JsonObject,
-): Promise<string[]> {
-  if (stringValue(structured.kind) !== "codex_assistant_message") {
-    return [];
-  }
-
-  const paths = extractKandanAttachmentPaths(body, args.options.cwd);
-
-  if (paths.length === 0) {
-    return [];
-  }
-
-  const files = await Promise.all(
-    paths.map(async path => {
-      const info = await stat(path);
-
-      if (!info.isFile()) {
-        throw new Error(`Kandan attachment path is not a file: ${path}`);
-      }
-
-      return {
-        path,
-        fileName: basename(path),
-        contentType: contentTypeForFileName(path),
-        sizeBytes: info.size,
-      };
-    }),
-  );
-  const session = args.options.channelSession;
-  const prepare = await pushOk(args.kandan, args.topic, "session:prepare_message_uploads", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    files: files.map(file => ({
-      file_name: file.fileName,
-      content_type: file.contentType,
-      size_bytes: file.sizeBytes,
-    })),
-  });
-  const uploads = arrayValue(prepare.uploads) ?? [];
-
-  if (uploads.length !== files.length) {
-    throw new Error("Kandan attachment prepare response count mismatch");
-  }
-
-  await Promise.all(
-    files.map(async (file, index) => {
-      const upload = objectValue(uploads[index]);
-      const uploadUrl = stringValue(upload?.upload_url);
-      const uploadMethod = stringValue(upload?.upload_method) ?? "PUT";
-
-      if (uploadUrl === undefined) {
-        throw new Error("Kandan attachment prepare response missing upload_url");
-      }
-
-      const bytes = await readFile(file.path);
-      const response = await fetch(
-        resolveKandanAttachmentUrl(args.options.kandanUrl, uploadUrl),
-        {
-          method: uploadMethod,
-          headers: { "content-type": file.contentType },
-          body: bytes,
-        },
-      );
-
-      if (!response.ok) {
-        throw new Error(
-          `Kandan attachment upload failed for ${file.fileName}: ${response.status} ${response.statusText}`,
-        );
-      }
-    }),
-  );
-
-  return uploads.map(upload => {
-    const fileId = stringValue(objectValue(upload)?.file_id);
-
-    if (fileId === undefined) {
-      throw new Error("Kandan attachment prepare response missing file_id");
-    }
-
-    return fileId;
-  });
-}
-
-function extractKandanAttachmentPaths(body: string, cwd: string): string[] {
-  const lines = body.split(/\r?\n/);
-  const headingIndex = lines.findIndex(
-    line => line.trim().toLowerCase() === "kandan attachments:",
-  );
-
-  if (headingIndex === -1) {
-    return [];
-  }
-
-  const seen = new Set<string>();
-  return lines.slice(headingIndex + 1).flatMap(line => {
-    const trimmed = line.trim();
-
-    if (!trimmed.startsWith("- ")) {
-      return [];
-    }
-
-    const rawPath = trimmed.slice(2).trim().replace(/^`|`$/g, "");
-    const resolvedPath = resolveCodexAttachmentPath(cwd, rawPath);
-
-    if (seen.has(resolvedPath)) {
-      return [];
-    }
-
-    seen.add(resolvedPath);
-    return [resolvedPath];
-  });
-}
-
-function resolveCodexAttachmentPath(cwd: string, rawPath: string): string {
-  if (rawPath === "") {
-    throw new Error("Kandan attachment path must not be empty");
-  }
-
-  const cwdPath = resolve(cwd);
-  const path = isAbsolute(rawPath) ? resolve(rawPath) : resolve(cwdPath, rawPath);
-  const relativePath = relative(cwdPath, path);
-
-  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    throw new Error(
-      `Kandan attachment path must be inside the runner cwd: ${rawPath}`,
-    );
-  }
-
-  return path;
-}
-
-function contentTypeForFileName(fileName: string): string {
-  const lower = fileName.toLowerCase();
-
-  if (lower.endsWith(".png")) {
-    return "image/png";
-  }
-
-  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) {
-    return "image/jpeg";
-  }
-
-  if (lower.endsWith(".gif")) {
-    return "image/gif";
-  }
-
-  if (lower.endsWith(".webp")) {
-    return "image/webp";
-  }
-
-  if (lower.endsWith(".csv")) {
-    return "text/csv";
-  }
-
-  if (lower.endsWith(".json")) {
-    return "application/json";
-  }
-
-  if (
-    lower.endsWith(".md") ||
-    lower.endsWith(".txt") ||
-    lower.endsWith(".log")
-  ) {
-    return "text/plain";
-  }
-
-  return "application/octet-stream";
-}
-
-function runtimeSettingsFromOptions(
-  options: ChannelSessionRunnerOptions,
-): LocalCodexRuntimeSettings {
-  return {
-    model: options.channelSession.model,
-    reasoningEffort: options.channelSession.reasoningEffort,
-    approvalPolicy: options.channelSession.approvalPolicy,
-    sandbox: options.channelSession.sandbox,
-    fast: options.fast,
-  };
-}
-
-function mergeRuntimeSettings(
-  current: LocalCodexRuntimeSettings,
-  update: Extract<KandanControl, { readonly type: "update_session_settings" }>,
-): LocalCodexRuntimeSettings {
-  return {
-    model: mergeOptionalStringRuntimeSetting(current.model, update, "model"),
-    reasoningEffort: mergeOptionalStringRuntimeSetting(
-      current.reasoningEffort,
-      update,
-      "reasoningEffort",
-    ),
-    approvalPolicy: mergeOptionalStringRuntimeSetting(
-      current.approvalPolicy,
-      update,
-      "approvalPolicy",
-    ),
-    sandbox: mergeOptionalStringRuntimeSetting(current.sandbox, update, "sandbox"),
-    fast: update.fast ?? current.fast,
-  };
-}
-
-function mergeOptionalStringRuntimeSetting(
-  current: string | undefined,
-  update: Extract<KandanControl, { readonly type: "update_session_settings" }>,
-  key: "model" | "reasoningEffort" | "approvalPolicy" | "sandbox",
-): string | undefined {
-  if (Object.prototype.hasOwnProperty.call(update, key)) {
-    return update[key] ?? undefined;
-  }
-
-  return current;
-}
-
-function runtimeOptionsForSettings(
-  options: ChannelSessionRunnerOptions,
-  settings: LocalCodexRuntimeSettings,
-): ChannelSessionRunnerOptions {
-  return {
-    ...options,
-    fast: settings.fast,
-    channelSession: {
-      ...options.channelSession,
-      model: settings.model,
-      reasoningEffort: settings.reasoningEffort,
-      approvalPolicy: settings.approvalPolicy,
-      sandbox: settings.sandbox,
-    },
-  };
-}
-
-async function publishRuntimeSettings(
-  args: ChannelSessionContext,
-  state: ChannelSessionState,
-): Promise<void> {
-  const session = args.options.channelSession;
-
-  if (state.kandanThreadId === undefined || state.codexThreadId === undefined) {
-    throw new Error("cannot publish local Codex settings before thread binding");
-  }
-
-  await pushOk(args.kandan, args.topic, "session:settings", {
-    workspace: session.workspaceSlug,
-    channel: session.channelSlug,
-    thread_id: state.kandanThreadId,
-    codex_thread_id: state.codexThreadId,
-    model: state.runtimeSettings.model ?? null,
-    reasoningEffort: state.runtimeSettings.reasoningEffort ?? null,
-    approvalPolicy: state.runtimeSettings.approvalPolicy ?? null,
-    sandbox: state.runtimeSettings.sandbox ?? null,
-    fast: state.runtimeSettings.fast ?? null,
-    updated_at: new Date().toISOString(),
-  });
-}
-
-
-function extractThreadIdFromResponse(response: JsonRpcResponse): string {
-  if ("error" in response) {
-    throw new Error(`thread/start failed: ${response.error.message}`);
-  }
-
-  const threadId = stringValue(
-    objectValue(objectValue(response.result)?.thread)?.id,
-  );
-
-  if (threadId === undefined) {
-    throw new Error("thread/start response did not include thread.id");
-  }
-
-  return threadId;
-}
-
-function extractTurnIdFromResponse(response: JsonRpcResponse): string {
-  if ("error" in response) {
-    throw new Error(`turn/start failed: ${response.error.message}`);
-  }
-
-  const turnId = stringValue(
-    objectValue(objectValue(response.result)?.turn)?.id,
-  );
-
-  if (turnId === undefined) {
-    throw new Error("turn/start response did not include turn.id");
-  }
-
-  return turnId;
-}
-
-async function startCodexThread(
-  codex: CodexAppServerClient,
-  options: ChannelSessionRunnerOptions,
-): Promise<string> {
-  const start = await codex.request("thread/start", {
-    cwd: options.cwd,
-    serviceName: "kandan-local-runner",
-    personality: "pragmatic",
-    ...codexThreadRuntimeOverrides(options),
-  });
-
-  return extractThreadIdFromResponse(start);
-}
-
-async function pushOk(
-  kandan: PhoenixClient,
-  topic: string,
-  event: string,
-  payload: JsonObject,
-): Promise<JsonObject> {
-  const reply = await kandan.push(topic, event, payload);
-
-  if (
-    isJsonObject(reply) &&
-    reply.status === "ok" &&
-    isJsonObject(reply.response)
-  ) {
-    return reply.response;
-  }
-
-  throw new Error(
-    `kandan push failed: ${event}: ${JSON.stringify(reply).slice(0, 500)}`,
-  );
-}
-
-async function pushOptional(
-  kandan: PhoenixClient,
-  topic: string,
-  event: string,
-  payload: JsonObject,
-  log: RunnerLogger,
-): Promise<void> {
-  try {
-    await pushOk(kandan, topic, event, payload);
-  } catch (error) {
-    log("kandan.optional_push_failed", {
-      event,
-      message: error instanceof Error ? error.message : String(error),
-    });
-  }
-}