march-cli 0.1.19 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",
@@ -34,7 +34,8 @@
     "node-pty": "^1.1.0",
     "typebox": "^1.0.58",
     "undici": "^7.25.0",
-    "web-tree-sitter": "^0.26.8"
+    "web-tree-sitter": "^0.26.8",
+    "ws": "^8.20.1"
   },
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.18.0"

package/src/agent/runner/codex-large-context-guard.mjs

@@ -0,0 +1,87 @@
+import {
+  getOpenAICodexWebSocketDebugStats,
+  resetOpenAICodexWebSocketDebugStats,
+} from "@earendil-works/pi-ai/openai-codex-responses";
+
+const FETCH_INSTALLED = Symbol.for("march.codex.largeContextGuard.fetchInstalled");
+const ORIGINAL_FETCH = Symbol.for("march.codex.largeContextGuard.originalFetch");
+const DEFAULT_MAX_HTTP_FALLBACK_BYTES = 512 * 1024;
+
+export function installCodexLargeContextGuard() {
+  if (!isGuardEnabled()) return;
+  if (globalThis[FETCH_INSTALLED]) return;
+  const originalFetch = globalThis.fetch;
+  if (typeof originalFetch !== "function") return;
+  globalThis[ORIGINAL_FETCH] = originalFetch;
+  globalThis.fetch = async function marchCodexLargeContextGuardedFetch(input, init) {
+    const bodyBytes = getBodyBytes(init?.body);
+    if (isCodexResponsesHttpRequest(input, init) && !isZstdEncoded(input, init) && bodyBytes > getMaxHttpFallbackBytes()) {
+      throw new Error(`Codex HTTP fallback blocked for uncompressed large payload (${bodyBytes} bytes); retrying WebSocket instead`);
+    }
+    return originalFetch.call(this, input, init);
+  };
+  globalThis[FETCH_INSTALLED] = true;
+}
+
+export function applyCodexLargeContextGuardToPayload(payload, { model, session } = {}) {
+  if (!isGuardEnabled() || !isCodexModel(model)) return payload;
+  const sessionId = session?.sessionId;
+  const stats = sessionId ? getOpenAICodexWebSocketDebugStats(sessionId) : null;
+  if (stats?.websocketFallbackActive) {
+    // pi-ai marks fallback session-wide. Clear it before retry payload assembly so WS gets another chance.
+    resetOpenAICodexWebSocketDebugStats(sessionId);
+  }
+  return payload;
+}
+
+function isGuardEnabled() {
+  const value = process.env.MARCH_CODEX_LARGE_CONTEXT_GUARD;
+  return value !== "0" && value !== "false" && value !== "no";
+}
+
+function getMaxHttpFallbackBytes() {
+  const raw = process.env.MARCH_CODEX_HTTP_FALLBACK_MAX_BYTES;
+  const parsed = raw ? Number.parseInt(raw, 10) : DEFAULT_MAX_HTTP_FALLBACK_BYTES;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_HTTP_FALLBACK_BYTES;
+}
+
+function isCodexModel(model) {
+  return model?.provider === "openai-codex" || model?.api === "openai-codex-responses";
+}
+
+function isCodexResponsesHttpRequest(input, init) {
+  const url = getRequestUrl(input);
+  if (!url || !url.includes("/codex/responses")) return false;
+  const method = init?.method ?? input?.method ?? "GET";
+  if (String(method).toUpperCase() !== "POST") return false;
+  return headerValue(init?.headers ?? input?.headers, "accept")?.includes("text/event-stream")
+    || headerValue(init?.headers ?? input?.headers, "OpenAI-Beta")?.includes("responses=experimental");
+}
+
+function getRequestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (input && typeof input.url === "string") return input.url;
+  return "";
+}
+
+function isZstdEncoded(input, init) {
+  return headerValue(init?.headers ?? input?.headers, "content-encoding").toLowerCase() === "zstd";
+}
+
+function getBodyBytes(body) {
+  if (typeof body === "string") return Buffer.byteLength(body);
+  if (body instanceof Uint8Array) return body.byteLength;
+  if (body instanceof ArrayBuffer) return body.byteLength;
+  return 0;
+}
+
+function headerValue(headers, name) {
+  if (!headers) return "";
+  if (typeof headers.get === "function") return headers.get(name) ?? headers.get(name.toLowerCase()) ?? "";
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName) return String(value ?? "");
+  }
+  return "";
+}

package/src/agent/runner/codex-transport-compression.mjs

@@ -0,0 +1,180 @@
+import zlib from "node:zlib";
+import WsWebSocket from "ws";
+
+const FETCH_INSTALLED = Symbol.for("march.codex.transportCompression.fetchInstalled");
+const WEBSOCKET_INSTALLED = Symbol.for("march.codex.transportCompression.websocketInstalled");
+const ORIGINAL_FETCH = Symbol.for("march.codex.transportCompression.originalFetch");
+const ORIGINAL_WEBSOCKET = Symbol.for("march.codex.transportCompression.originalWebSocket");
+const STATS = Symbol.for("march.codex.transportCompression.stats");
+const DEFAULT_MIN_ZSTD_BYTES = 1024;
+
+export function installCodexTransportCompression() {
+  if (!isCompressionEnabled()) return;
+  installCodexHttpCompression();
+  installCodexWebSocketCompression();
+}
+
+export function getCodexTransportCompressionStats() {
+  return globalThis[STATS] ?? null;
+}
+
+function installCodexHttpCompression() {
+  if (!isHttpCompressionEnabled() || globalThis[FETCH_INSTALLED]) return;
+  const originalFetch = globalThis.fetch;
+  if (typeof originalFetch !== "function" || typeof zlib.zstdCompressSync !== "function") return;
+  globalThis[ORIGINAL_FETCH] = originalFetch;
+  globalThis.fetch = async function marchCodexCompressedFetch(input, init = {}) {
+    if (!isCodexResponsesHttpRequest(input, init) || hasHeader(init.headers ?? input?.headers, "content-encoding")) {
+      return originalFetch.call(this, input, init);
+    }
+    const body = init?.body;
+    const plain = toBuffer(body);
+    if (!plain || plain.byteLength < getMinZstdBytes()) return originalFetch.call(this, input, init);
+
+    const compressed = zlib.zstdCompressSync(plain, {
+      params: { [zlib.constants.ZSTD_c_compressionLevel]: 3 },
+    });
+    const headers = new Headers(init.headers ?? input?.headers ?? {});
+    headers.set("content-encoding", "zstd");
+    headers.set("content-type", headers.get("content-type") ?? "application/json");
+    recordHttpCompression(plain.byteLength, compressed.byteLength);
+    return originalFetch.call(this, input, { ...init, headers, body: compressed });
+  };
+  globalThis[FETCH_INSTALLED] = true;
+}
+
+function installCodexWebSocketCompression() {
+  if (!isWebSocketCompressionEnabled() || globalThis[WEBSOCKET_INSTALLED]) return;
+  const OriginalWebSocket = globalThis.WebSocket;
+  if (typeof OriginalWebSocket !== "function") return;
+  globalThis[ORIGINAL_WEBSOCKET] = OriginalWebSocket;
+
+  class MarchCodexCompressedWebSocket extends WsWebSocket {
+    constructor(url, protocolsOrOptions, maybeOptions) {
+      if (!isCodexResponsesWebSocketUrl(url)) {
+        return new OriginalWebSocket(url, protocolsOrOptions, maybeOptions);
+      }
+      const { protocols, options } = normalizeWebSocketArgs(protocolsOrOptions, maybeOptions);
+      super(url, protocols, {
+        ...options,
+        perMessageDeflate: options.perMessageDeflate ?? true,
+      });
+      recordWebSocketCompression();
+    }
+  }
+  copyReadyStateConstants(MarchCodexCompressedWebSocket, OriginalWebSocket);
+  globalThis.WebSocket = MarchCodexCompressedWebSocket;
+  globalThis[WEBSOCKET_INSTALLED] = true;
+}
+
+function normalizeWebSocketArgs(protocolsOrOptions, maybeOptions) {
+  if (isOptionsObject(protocolsOrOptions) && maybeOptions === undefined) {
+    return { protocols: [], options: protocolsOrOptions };
+  }
+  return { protocols: protocolsOrOptions ?? [], options: maybeOptions ?? {} };
+}
+
+function isOptionsObject(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value) || value instanceof String) return false;
+  return "headers" in value || "perMessageDeflate" in value || "handshakeTimeout" in value;
+}
+
+function copyReadyStateConstants(Target, OriginalWebSocket) {
+  for (const key of ["CONNECTING", "OPEN", "CLOSING", "CLOSED"]) {
+    const value = OriginalWebSocket[key] ?? WsWebSocket[key];
+    if (typeof value === "number") Object.defineProperty(Target, key, { value, enumerable: true });
+  }
+}
+
+function isCompressionEnabled() {
+  return isEnabled(process.env.MARCH_CODEX_TRANSPORT_COMPRESSION, true);
+}
+
+function isHttpCompressionEnabled() {
+  return isEnabled(process.env.MARCH_CODEX_HTTP_COMPRESSION, true);
+}
+
+function isWebSocketCompressionEnabled() {
+  return isEnabled(process.env.MARCH_CODEX_WS_COMPRESSION, true);
+}
+
+function isEnabled(value, fallback) {
+  if (value === undefined) return fallback;
+  return value !== "0" && value !== "false" && value !== "no";
+}
+
+function getMinZstdBytes() {
+  const raw = process.env.MARCH_CODEX_HTTP_COMPRESSION_MIN_BYTES;
+  const parsed = raw ? Number.parseInt(raw, 10) : DEFAULT_MIN_ZSTD_BYTES;
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_MIN_ZSTD_BYTES;
+}
+
+function isCodexResponsesHttpRequest(input, init) {
+  const url = getRequestUrl(input);
+  if (!url || !url.includes("/codex/responses")) return false;
+  const method = init?.method ?? input?.method ?? "GET";
+  if (String(method).toUpperCase() !== "POST") return false;
+  return headerValue(init?.headers ?? input?.headers, "accept").includes("text/event-stream")
+    || headerValue(init?.headers ?? input?.headers, "OpenAI-Beta").includes("responses=experimental");
+}
+
+function isCodexResponsesWebSocketUrl(url) {
+  const raw = getRequestUrl(url);
+  if (!raw || !raw.includes("/codex/responses")) return false;
+  return raw.startsWith("ws://") || raw.startsWith("wss://");
+}
+
+function getRequestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (input && typeof input.url === "string") return input.url;
+  return "";
+}
+
+function toBuffer(body) {
+  if (typeof body === "string") return Buffer.from(body);
+  if (body instanceof Uint8Array) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return null;
+}
+
+function hasHeader(headers, name) {
+  return headerValue(headers, name).length > 0;
+}
+
+function headerValue(headers, name) {
+  if (!headers) return "";
+  if (typeof headers.get === "function") return headers.get(name) ?? headers.get(name.toLowerCase()) ?? "";
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName) return String(value ?? "");
+  }
+  return "";
+}
+
+function recordHttpCompression(preBytes, postBytes) {
+  const stats = ensureStats();
+  stats.httpZstdRequests += 1;
+  stats.lastHttpPreBytes = preBytes;
+  stats.lastHttpPostBytes = postBytes;
+  stats.lastHttpRatio = Number((postBytes / preBytes).toFixed(4));
+}
+
+function recordWebSocketCompression() {
+  const stats = ensureStats();
+  stats.wsCompressedConnections += 1;
+  stats.wsPerMessageDeflate = true;
+}
+
+function ensureStats() {
+  globalThis[STATS] = globalThis[STATS] ?? {
+    httpZstdRequests: 0,
+    lastHttpPreBytes: 0,
+    lastHttpPostBytes: 0,
+    lastHttpRatio: 0,
+    wsCompressedConnections: 0,
+    wsPerMessageDeflate: false,
+  };
+  return globalThis[STATS];
+}

package/src/agent/runner/codex-transport-debug.mjs

@@ -1,4 +1,6 @@
 import { getOpenAICodexWebSocketDebugStats } from "@earendil-works/pi-ai/openai-codex-responses";
+import { getCodexTransportCompressionStats } from "./codex-transport-compression.mjs";
+import { getCodexWebSocketLastEvent } from "./codex-websocket-event-debug.mjs";
 
 export function getCodexTransportDebugSnapshot(session) {
   if (!isCodexTransportDebugEnabled()) return null;
@@ -12,7 +14,7 @@ export function dumpCodexTransportDebug({ before, session, ui, logger }) {
   const after = sessionId ? (getOpenAICodexWebSocketDebugStats(sessionId) ?? null) : null;
   const fields = formatCodexTransportDebugFields(sessionId, before, after);
   logger?.event("codex.transport", fields);
-  writeCodexTransportDebug(ui, formatCodexTransportDebugLines(fields));
+  writeCodexTransportDebug(ui, formatCodexTransportDebugLines(fields, logger?.path));
 }
 
 function isCodexTransportDebugEnabled() {
@@ -20,6 +22,11 @@ function isCodexTransportDebugEnabled() {
   return value === "1" || value === "true" || value === "yes";
 }
 
+function isCodexTransportDebugEventsVisible() {
+  const value = process.env.MARCH_CODEX_TRANSPORT_DEBUG_EVENTS;
+  return value === "1" || value === "true" || value === "yes";
+}
+
 function formatCodexTransportDebugFields(sessionId, before, after) {
   const delta = (key) => (after?.[key] ?? 0) - (before?.[key] ?? 0);
   return {
@@ -38,13 +45,15 @@ function formatCodexTransportDebugFields(sessionId, before, after) {
     lastInputItems: after?.lastInputItems ?? 0,
     lastDeltaInputItems: after?.lastDeltaInputItems ?? 0,
     lastWebSocketError: after?.lastWebSocketError ?? null,
+    compression: getCodexTransportCompressionStats(),
+    lastWebSocketEvent: getCodexWebSocketLastEvent(sessionId),
     hasStats: Boolean(after),
   };
 }
 
-function formatCodexTransportDebugLines(fields) {
+function formatCodexTransportDebugLines(fields, logPath) {
   if (!fields.hasStats) return [`[codex-transport] sessionId=${fields.sessionId} no Codex WebSocket stats`];
-  return [
+  const lines = [
     `[codex-transport] sessionId=${fields.sessionId}`,
     `  requests=${fields.requests} totalRequests=${fields.totalRequests}`,
     `  wsConnections created=${fields.connectionsCreated} reused=${fields.connectionsReused}`,
@@ -52,7 +61,36 @@ function formatCodexTransportDebugLines(fields) {
     `  fallback websocketFailures=${fields.websocketFailures} sseFallbacks=${fields.sseFallbacks} active=${fields.websocketFallbackActive}`,
     `  error lastWebSocketError=${formatDebugValue(fields.lastWebSocketError)}`,
     `  lastInputItems=${fields.lastInputItems} lastDeltaInputItems=${fields.lastDeltaInputItems}`,
+    `  compression httpZstd=${formatDebugValue(fields.compression?.httpZstdRequests ?? 0)} lastBytes=${formatDebugValue(fields.compression ? `${fields.compression.lastHttpPreBytes}->${fields.compression.lastHttpPostBytes}` : null)} ratio=${formatDebugValue(fields.compression?.lastHttpRatio)} wsDeflate=${formatDebugValue(fields.compression?.wsPerMessageDeflate)} wsConnections=${formatDebugValue(fields.compression?.wsCompressedConnections ?? 0)}`,
   ];
+  if (isCodexTransportDebugEventsVisible()) {
+    lines.push(...formatWebSocketEventLines(fields.lastWebSocketEvent));
+  } else if (fields.lastWebSocketEvent && logPath) {
+    lines.push(`  rawWebSocketEventLog=${formatDebugValue(logPath)}`);
+  }
+  return lines;
+}
+
+function formatWebSocketEventLines(events) {
+  if (!events) return ["  wsEvent none"];
+  return [
+    ...formatSingleWebSocketEvent("wsEvent", events.lastEvent),
+    ...formatSingleWebSocketEvent("wsError", events.lastErrorEvent),
+    ...formatSingleWebSocketCloseEvent(events.lastCloseEvent),
+  ];
+}
+
+function formatSingleWebSocketEvent(prefix, event) {
+  if (!event) return [`  ${prefix} none`];
+  return [
+    `  ${prefix} phase=${formatDebugValue(event.phase)} type=${formatDebugValue(event.type)} keys=${formatDebugValue(event.eventKeys)} readyState=${formatDebugValue(event.readyState)}`,
+    `  ${prefix} errorName=${formatDebugValue(event.errorName)} errorMessage=${formatDebugValue(event.errorMessage)} errorCode=${formatDebugValue(event.errorCode)} errorString=${formatDebugValue(event.errorString)} eventMessage=${formatDebugValue(event.eventMessage)}`,
+  ];
+}
+
+function formatSingleWebSocketCloseEvent(event) {
+  if (!event) return ["  wsClose none"];
+  return [`  wsClose code=${formatDebugValue(event.closeCode)} reason=${formatDebugValue(event.closeReason)} wasClean=${formatDebugValue(event.closeWasClean)} readyState=${formatDebugValue(event.readyState)}`];
 }
 
 function formatDebugValue(value) {

package/src/agent/runner/codex-websocket-event-debug.mjs

@@ -0,0 +1,130 @@
+const SOCKET_SESSION_ID = Symbol.for("march.codex.websocket.sessionId");
+const SOCKET_LISTENERS = Symbol.for("march.codex.websocket.listeners");
+const DEBUG_EVENTS_KEY = Symbol.for("march.codex.websocket.debugEvents");
+const ORIGINAL_WEBSOCKET_KEY = Symbol.for("march.codex.websocket.originalConstructor");
+
+export function installCodexWebSocketEventDebug() {
+  if (!isCodexTransportDebugEnabled()) return;
+  const OriginalWebSocket = globalThis.WebSocket;
+  if (typeof OriginalWebSocket !== "function") return;
+  if (globalThis[ORIGINAL_WEBSOCKET_KEY]) return;
+
+  globalThis[DEBUG_EVENTS_KEY] = globalThis[DEBUG_EVENTS_KEY] ?? new Map();
+  globalThis[ORIGINAL_WEBSOCKET_KEY] = OriginalWebSocket;
+
+  class MarchDebugWebSocket extends OriginalWebSocket {
+    constructor(...args) {
+      super(...args);
+      this[SOCKET_SESSION_ID] = extractSessionId(args[1]) ?? extractSessionId(args[2]) ?? null;
+      this[SOCKET_LISTENERS] = new Map();
+    }
+
+    addEventListener(type, listener, options) {
+      if ((type !== "error" && type !== "close") || !listener) {
+        return super.addEventListener(type, listener, options);
+      }
+      const wrapped = wrapListener(this, type, listener);
+      rememberWrappedListener(this, type, listener, wrapped);
+      return super.addEventListener(type, wrapped, options);
+    }
+
+    removeEventListener(type, listener, options) {
+      const wrapped = takeWrappedListener(this, type, listener) ?? listener;
+      return super.removeEventListener(type, wrapped, options);
+    }
+  }
+
+  globalThis.WebSocket = MarchDebugWebSocket;
+}
+
+export function getCodexWebSocketLastEvent(sessionId) {
+  if (!sessionId) return null;
+  return globalThis[DEBUG_EVENTS_KEY]?.get(sessionId) ?? null;
+}
+
+function isCodexTransportDebugEnabled() {
+  const value = process.env.MARCH_CODEX_TRANSPORT_DEBUG;
+  return value === "1" || value === "true" || value === "yes";
+}
+
+function extractSessionId(options) {
+  const headers = options?.headers;
+  if (!headers || typeof headers !== "object") return null;
+  const value = headers.session_id ?? headers["session_id"] ?? headers["x-client-request-id"] ?? headers["X-Client-Request-Id"];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function wrapListener(socket, type, listener) {
+  return function marchCodexWebSocketDebugListener(event) {
+    recordWebSocketEvent(socket, type, event);
+    if (typeof listener === "function") return listener.call(this, event);
+    return listener.handleEvent?.(event);
+  };
+}
+
+function rememberWrappedListener(socket, type, listener, wrapped) {
+  let byType = socket[SOCKET_LISTENERS].get(type);
+  if (!byType) {
+    byType = new Map();
+    socket[SOCKET_LISTENERS].set(type, byType);
+  }
+  byType.set(listener, wrapped);
+}
+
+function takeWrappedListener(socket, type, listener) {
+  const byType = socket[SOCKET_LISTENERS]?.get(type);
+  if (!byType) return null;
+  const wrapped = byType.get(listener);
+  byType.delete(listener);
+  return wrapped ?? null;
+}
+
+function recordWebSocketEvent(socket, type, event) {
+  const sessionId = socket[SOCKET_SESSION_ID];
+  if (!sessionId) return;
+  const events = globalThis[DEBUG_EVENTS_KEY].get(sessionId) ?? {};
+  const summary = summarizeWebSocketEvent(socket, type, event);
+  events.lastEvent = summary;
+  if (type === "error") events.lastErrorEvent = summary;
+  if (type === "close") events.lastCloseEvent = summary;
+  globalThis[DEBUG_EVENTS_KEY].set(sessionId, events);
+}
+
+function summarizeWebSocketEvent(socket, type, event) {
+  const nestedError = event && typeof event === "object" && "error" in event ? event.error : null;
+  return {
+    phase: type,
+    type: readString(event, "type") ?? type,
+    eventKeys: getEventKeys(event),
+    eventMessage: readString(event, "message"),
+    errorName: readString(nestedError, "name"),
+    errorMessage: readString(nestedError, "message"),
+    errorCode: readString(nestedError, "code") ?? readNumber(nestedError, "code"),
+    errorString: nestedError ? String(nestedError) : undefined,
+    closeCode: readNumber(event, "code"),
+    closeReason: readString(event, "reason"),
+    closeWasClean: readBoolean(event, "wasClean"),
+    readyState: typeof socket.readyState === "number" ? socket.readyState : undefined,
+  };
+}
+
+function getEventKeys(event) {
+  if (!event || typeof event !== "object") return [];
+  return [...new Set([...Object.keys(event), "type", "message", "error", "code", "reason", "wasClean"].filter((key) => key in event))];
+}
+
+function readString(value, key) {
+  const field = value && typeof value === "object" ? value[key] : undefined;
+  return typeof field === "string" && field.length > 0 ? field : undefined;
+}
+
+function readNumber(value, key) {
+  const field = value && typeof value === "object" ? value[key] : undefined;
+  return typeof field === "number" ? field : undefined;
+}
+
+function readBoolean(value, key) {
+  const field = value && typeof value === "object" ? value[key] : undefined;
+  return typeof field === "boolean" ? field : undefined;
+}
+

package/src/agent/runner.mjs

@@ -13,6 +13,9 @@ import { createRuntimeUiBridge } from "./runtime/ui-event-bridge.mjs";
 import { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
 import { notifyTurnEndBestEffort, notifyTurnEndDetached, providerContextToPayload } from "./runner/runner-utils.mjs";
 import { dumpCodexTransportDebug, getCodexTransportDebugSnapshot } from "./runner/codex-transport-debug.mjs";
+import { installCodexWebSocketEventDebug } from "./runner/codex-websocket-event-debug.mjs";
+import { installCodexTransportCompression } from "./runner/codex-transport-compression.mjs";
+import { applyCodexLargeContextGuardToPayload, installCodexLargeContextGuard } from "./runner/codex-large-context-guard.mjs";
 import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
 import { createSessionBinding } from "./session/session-binding.mjs";
 import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
@@ -23,11 +26,13 @@ import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastPro
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
 import { registerCustomProviders } from "../provider/custom-provider.mjs";
 import { injectHostedTools } from "../provider/hosted-tools.mjs";
-export { MARCH_BASE_TOOL_NAMES };
-export { installModelPayloadDumper } from "./model-payload-dumper.mjs";
+export { MARCH_BASE_TOOL_NAMES, installModelPayloadDumper };
 export { createDefaultSessionManager, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 export { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
 export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, profilePaths = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, logger = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null, hostedTools = {} }) {
+  installCodexLargeContextGuard();
+  installCodexTransportCompression();
+  installCodexWebSocketEventDebug();
   if (!useRuntimeHost && extensionPaths.length > 0) {
     throw new Error("--extension requires the default pi runtime host path");
   }
@@ -287,6 +292,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       ? payload
       : replaceProviderContextMessages(payload, engine.buildProviderContext(currentPromptForContext));
     nextPayload = injectHostedTools(nextPayload, model, hostedTools);
+    nextPayload = applyCodexLargeContextGuardToPayload(nextPayload, { model, session: sessionBinding.get() });
     if (_currentFastEntry) nextPayload = { ...nextPayload, service_tier: "priority" };
     return nextPayload;
   }