@ycodium-ai/agent-codex 0.2.2098

package/dist/index.js

@@ -0,0 +1,3834 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/card.ts
+var CODEX_DRIVER_KIND = "codex";
+var CODEX_DEFAULT_LAUNCH_ARGS = "app-server";
+var CODEX_CARD = {
+  driverKind: CODEX_DRIVER_KIND,
+  displayName: "Codex",
+  iconUrl: "./assets/icon.svg",
+  commandName: "codex",
+  launchArgs: CODEX_DEFAULT_LAUNCH_ARGS,
+  homeEnvVar: "CODEX_HOME",
+  environment: [],
+  install: { kind: "npm" },
+  signIn: [{ kind: "command", command: "codex login" }],
+  deviceCodeSignInArgs: ["login", "--device-auth"],
+  npmPackage: "@openai/codex",
+  homebrewFormula: "codex",
+  selfUpdateArgs: [],
+  docsUrl: "https://docs.codex.dev",
+  setupNote: "",
+  defaultModel: "gpt-5.6-sol",
+  defaultTextGenerationModel: "gpt-5.6-luna",
+  customModelIdExample: "gpt-6.7-codex-ultra-preview",
+  modelSlugAliases: {
+    "gpt-5-codex": "gpt-5.4",
+    "5.4": "gpt-5.4",
+    "5.3": "gpt-5.3-codex",
+    "gpt-5.3": "gpt-5.3-codex",
+    "5.3-spark": "gpt-5.3-codex-spark",
+    "gpt-5.3-spark": "gpt-5.3-codex-spark"
+  },
+  modelsDevProviderIds: ["openai"],
+  modelsDevSlugPrefixed: false,
+  modelSlugPrefix: "",
+  mcpTransports: ["stdio", "http"],
+  pluginManaged: true,
+  verifiedSkills: true,
+  everydayHarness: true,
+  capabilities: {
+    turnSteering: true,
+    sessionModelSwitch: "in-session",
+    exclusiveSessionWriter: true,
+    runtimeModeSwitch: "next-turn",
+    contextCompaction: "native"
+  },
+  credentialSources: [],
+  diagnostics: [],
+  configSchema: {
+    type: "object",
+    properties: {
+      authMode: { type: "string", enum: ["default", "chatgpt", "apiKey"] },
+      apiBaseUrl: { type: "string" },
+      enabled: { type: "boolean" },
+      binaryPath: { type: "string" },
+      homePath: { type: "string" },
+      shadowHomePath: { type: "string" },
+      launchArgs: { type: "string" },
+      customModels: { type: "array" },
+      driver: { type: "string" },
+      config: { type: "object" },
+      environment: { type: "array" }
+    },
+    additionalProperties: true
+  },
+  modelConnectivity: {
+    dialects: ["openai-responses"],
+    acceptsExternalEndpoints: true,
+    nativePathSuffix: "/responses",
+    credentialEnvKey: "CODEX_API_KEY",
+    supportsNativeSubscription: true
+  }
+};
+
+// src/codexInstance.ts
+import * as NodeProcess from "node:process";
+
+// src/codexAccount.ts
+import * as NodeFS from "node:fs";
+import * as NodePath from "node:path";
+var AUTH_FILE_NAME = "auth.json";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readString = (record, key) => {
+  const value = record[key];
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+var readNumber = (record, key) => {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+};
+var parseJsonRecord = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  return isRecord(parsed) ? parsed : void 0;
+};
+var directoryExists = (homePath) => {
+  try {
+    return NodeFS.statSync(homePath).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var readCredentialFile = (path) => {
+  try {
+    return NodeFS.readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+};
+var signedOutProbe = (exists) => ({
+  state: "signed-out",
+  directoryExists: exists,
+  email: void 0,
+  name: void 0,
+  expiresAt: void 0
+});
+var unreadableProbe = (exists) => ({
+  state: "unreadable",
+  directoryExists: exists,
+  email: void 0,
+  name: void 0,
+  expiresAt: void 0
+});
+var epochMillisToIso = (ms) => {
+  if (ms === void 0) return void 0;
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+};
+function decodeJwtClaims(token) {
+  if (token === void 0) return void 0;
+  const segments = token.split(".");
+  if (segments.length !== 3) return void 0;
+  try {
+    const json = Buffer.from(segments[1] ?? "", "base64url").toString("utf8");
+    return parseJsonRecord(json);
+  } catch {
+    return void 0;
+  }
+}
+var readCodexAccount = (homePath) => {
+  const exists = directoryExists(homePath);
+  const raw = readCredentialFile(NodePath.join(homePath, AUTH_FILE_NAME));
+  if (raw === void 0) return signedOutProbe(exists);
+  const parsed = parseJsonRecord(raw);
+  if (parsed === void 0 || !("OPENAI_API_KEY" in parsed || "tokens" in parsed)) {
+    return unreadableProbe(exists);
+  }
+  const tokens = parsed["tokens"];
+  const accessToken = isRecord(tokens) ? readString(tokens, "access_token") : void 0;
+  const apiKey = readString(parsed, "OPENAI_API_KEY");
+  if (accessToken === void 0 && apiKey === void 0) return signedOutProbe(exists);
+  const claims = isRecord(tokens) ? decodeJwtClaims(readString(tokens, "id_token")) : void 0;
+  const expiresAtSeconds = claims === void 0 ? void 0 : readNumber(claims, "exp");
+  const expiresAtMs = expiresAtSeconds === void 0 ? void 0 : expiresAtSeconds * 1e3;
+  const expiresAt = epochMillisToIso(expiresAtMs);
+  const nowMs = Date.now();
+  const expired = expiresAt !== void 0 && expiresAtMs !== void 0 && expiresAtMs <= nowMs;
+  return {
+    state: expired ? "expired" : "signed-in",
+    directoryExists: exists,
+    email: claims === void 0 ? void 0 : readString(claims, "email"),
+    name: void 0,
+    expiresAt
+  };
+};
+
+// src/config.ts
+var CODEX_INSTANCE_API_KEY_ENV = "YCODIUM_CODEX_API_KEY";
+var CODEX_INSTANCE_MODEL_PROVIDER = "ycodium_api";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString2(value) {
+  return typeof value === "string" ? value : "";
+}
+function readTrimmed(value) {
+  return readString2(value).trim();
+}
+function readAuthMode(value) {
+  return value === "chatgpt" || value === "apiKey" ? value : "default";
+}
+function readEnvironment(value) {
+  if (!Array.isArray(value)) return {};
+  const env = {};
+  for (const entry of value) {
+    if (!isRecord2(entry)) continue;
+    const name = readTrimmed(entry["name"]);
+    if (name.length === 0) continue;
+    env[name] = readString2(entry["value"]);
+  }
+  return env;
+}
+function parseCodexInstanceConfig(config) {
+  if (!isRecord2(config)) {
+    return {
+      binaryPath: "",
+      launchArgs: CODEX_DEFAULT_LAUNCH_ARGS,
+      homePath: "",
+      shadowHomePath: "",
+      homeEnvVar: "",
+      authMode: "default",
+      apiBaseUrl: "",
+      environment: {},
+      envelopeDriver: void 0
+    };
+  }
+  const nested = isRecord2(config["config"]) ? config["config"] : void 0;
+  const settings = nested ?? config;
+  return {
+    binaryPath: readTrimmed(settings["binaryPath"]),
+    launchArgs: readString2(settings["launchArgs"]) || CODEX_DEFAULT_LAUNCH_ARGS,
+    homePath: readTrimmed(settings["homePath"]) || readTrimmed(config["homePath"]),
+    shadowHomePath: readTrimmed(settings["shadowHomePath"]),
+    homeEnvVar: readTrimmed(settings["homeEnvVar"]) || readTrimmed(config["homeEnvVar"]),
+    authMode: readAuthMode(settings["authMode"]),
+    apiBaseUrl: readTrimmed(settings["apiBaseUrl"]),
+    environment: readEnvironment(config["environment"]),
+    envelopeDriver: readTrimmed(config["driver"]) || void 0
+  };
+}
+function tokenizeLaunchArgs(value) {
+  const input = value.trim();
+  if (!input) return [];
+  const tokens = [];
+  let current = "";
+  let quote;
+  let quoted = false;
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    if (char === void 0) continue;
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        quoted = true;
+      } else if (char === "\\" && quote === '"') {
+        const next = input[index + 1];
+        if (next !== void 0 && ['"', "\\", "$", "`"].includes(next)) {
+          current += next;
+          index++;
+        } else {
+          current += char;
+        }
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      quoted = true;
+    } else if (/\s/.test(char)) {
+      if (current || quoted) {
+        tokens.push(current);
+        current = "";
+        quoted = false;
+      }
+    } else if (char === "\\") {
+      const next = input[index + 1];
+      if (next !== void 0 && /\s/.test(next)) {
+        current += next;
+        index++;
+      } else {
+        current += char;
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current || quoted) tokens.push(current);
+  return tokens;
+}
+function codexExecLaunchArgs(launchArgs) {
+  const args = tokenizeLaunchArgs(launchArgs ?? "");
+  const execArgs = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--strict-config" || arg.startsWith("--config=") || arg.startsWith("-c=")) {
+      execArgs.push(arg);
+    } else if (arg === "--config" || arg === "-c" || arg === "--enable" || arg === "--disable") {
+      const value = args[index + 1];
+      if (value !== void 0 && !value.startsWith("-")) {
+        execArgs.push(arg, value);
+        index++;
+      }
+    } else if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
+      execArgs.push(arg);
+    }
+  }
+  return execArgs;
+}
+function hasConfiguredMcpServer(appServerArgs) {
+  return appServerArgs.some((arg) => arg.includes("mcp_servers."));
+}
+function encodeCodexConfigOverrides(overrides) {
+  return overrides.map(({ key, value }) => `-c ${JSON.stringify(`${key}=${JSON.stringify(value)}`)}`).join(" ");
+}
+function modelIdFromSelection(selection) {
+  if (typeof selection !== "object" || selection === null || Array.isArray(selection)) {
+    return void 0;
+  }
+  const model = selection["model"];
+  return typeof model === "string" ? model.trim() || void 0 : void 0;
+}
+function modelSelectionStringOption(selection, optionId) {
+  if (typeof selection !== "object" || selection === null || Array.isArray(selection)) {
+    return void 0;
+  }
+  const options = selection["options"];
+  if (!Array.isArray(options)) return void 0;
+  for (const entry of options) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
+    const id = entry["id"];
+    if (id !== optionId) continue;
+    const value = entry["value"];
+    return typeof value === "string" ? value.trim() || void 0 : void 0;
+  }
+  return void 0;
+}
+
+// src/paths.ts
+import * as NodeOS from "node:os";
+import * as NodePath2 from "node:path";
+function expandHomePath(value) {
+  if (value === "~") return NodeOS.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return NodePath2.join(NodeOS.homedir(), value.slice(2));
+  }
+  return value;
+}
+function compactEnv(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/connection.ts
+function codexApiConnectionError(recipe, environment) {
+  if (recipe.authMode !== "apiKey") return null;
+  try {
+    const url = new URL(recipe.apiBaseUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return "Codex API base URL must use HTTP or HTTPS.";
+    }
+  } catch {
+    return "Codex API base URL is missing or invalid.";
+  }
+  return environment[CODEX_INSTANCE_API_KEY_ENV]?.trim() ? null : "An API key is required for this Codex account.";
+}
+function connectionArgv(recipe, layout) {
+  const args = [...tokenizeLaunchArgs(recipe.launchArgs)];
+  const override = (key, value) => {
+    args.push("-c", `${key}=${JSON.stringify(value)}`);
+  };
+  if (layout.mode === "authOverlay" || recipe.authMode !== "default") {
+    override("sqlite_home", layout.sharedHomePath);
+  }
+  if (layout.mode === "authOverlay") {
+    override("cli_auth_credentials_store", "file");
+  }
+  if (recipe.authMode === "chatgpt") {
+    override("model_provider", "openai");
+    override("forced_login_method", "chatgpt");
+  } else if (recipe.authMode === "apiKey") {
+    override("model_provider", CODEX_INSTANCE_MODEL_PROVIDER);
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.name`, "Ycodium API");
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.base_url`, recipe.apiBaseUrl);
+    override(
+      `model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.env_key`,
+      CODEX_INSTANCE_API_KEY_ENV
+    );
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.requires_openai_auth`, false);
+    override(`model_providers.${CODEX_INSTANCE_MODEL_PROVIDER}.wire_api`, "responses");
+  }
+  return args;
+}
+function codexSpawnArgs(recipe, layout) {
+  const needsOverrides = layout.mode === "authOverlay" || recipe.authMode !== "default";
+  if (!needsOverrides) return tokenizeLaunchArgs(recipe.launchArgs);
+  return connectionArgv(recipe, layout);
+}
+function crushInheritedApiKeys(env) {
+  const out = { ...env };
+  delete out["OPENAI_API_KEY"];
+  delete out["CODEX_API_KEY"];
+  return out;
+}
+function buildCodexSpawnEnv(input) {
+  const merged = {
+    ...compactEnv(input.processEnv),
+    ...input.layout.effectiveHomePath !== void 0 ? { CODEX_HOME: input.layout.effectiveHomePath } : {},
+    ...input.recipe.environment
+  };
+  const withoutHomeOverride = { ...merged };
+  if (input.processEnv["HOME"] !== void 0) {
+    withoutHomeOverride["HOME"] = input.processEnv["HOME"];
+  } else {
+    delete withoutHomeOverride["HOME"];
+  }
+  return input.crushApiKeys ? crushInheritedApiKeys(withoutHomeOverride) : withoutHomeOverride;
+}
+function nativeLoginSpawnEnv(processEnv, isolatedHome) {
+  const merged = compactEnv(processEnv);
+  delete merged["OPENAI_API_KEY"];
+  delete merged["CODEX_API_KEY"];
+  delete merged["CODEX_HOME"];
+  merged["CODEX_HOME"] = isolatedHome;
+  return merged;
+}
+function shouldCrushApiKeys(authMode) {
+  return authMode === "chatgpt";
+}
+
+// src/homeLayout.ts
+import * as NodeFSP from "node:fs/promises";
+import * as NodeOS2 from "node:os";
+import * as NodePath3 from "node:path";
+var KNOWN_SHARED_DIRECTORIES = [
+  "sessions",
+  "archived_sessions",
+  "sqlite",
+  "shell_snapshots",
+  "worktrees",
+  "skills",
+  "plugins",
+  "cache",
+  "logs",
+  "mcp-oauth-locks"
+];
+var PRIVATE_ENTRY_NAMES = /* @__PURE__ */ new Set(["auth.json", "models_cache.json"]);
+var SHADOW_LOCAL_ENTRY_NAMES = /* @__PURE__ */ new Set(["log", "memories", "tmp"]);
+var REPLACEABLE_SHARED_RUNTIME_DIRECTORIES = /* @__PURE__ */ new Set(["mcp-oauth-locks"]);
+function resolveCodexHomeDirectory(value) {
+  const expanded = value && value.trim().length > 0 ? expandHomePath(value) : NodePath3.join(NodeOS2.homedir(), ".codex");
+  return NodePath3.resolve(expanded);
+}
+function resolveCodexHomeLayout(input) {
+  const configuredHome = input.homePath.trim() || (input.environmentHome?.trim() ?? "");
+  const sharedHomePath = resolveCodexHomeDirectory(configuredHome || void 0);
+  const shadowHomePath = input.shadowHomePath.trim();
+  if (shadowHomePath.length === 0) {
+    return {
+      mode: "direct",
+      sharedHomePath,
+      effectiveHomePath: configuredHome.length > 0 ? sharedHomePath : void 0,
+      continuationKey: `codex:home:${sharedHomePath}`
+    };
+  }
+  return {
+    mode: "authOverlay",
+    sharedHomePath,
+    effectiveHomePath: NodePath3.resolve(expandHomePath(shadowHomePath)),
+    continuationKey: `codex:home:${sharedHomePath}`
+  };
+}
+async function readLinkState(linkPath) {
+  try {
+    const target = await NodeFSP.readlink(linkPath);
+    return { _tag: "Symlink", target };
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") return { _tag: "Missing" };
+    if (code === "EINVAL") return { _tag: "NotSymlink" };
+    throw error;
+  }
+}
+async function createEntryLink(target, link) {
+  const type = await NodeFSP.stat(target).then(
+    (info) => info.isDirectory() ? "junction" : "file",
+    () => "file"
+  );
+  await NodeFSP.symlink(target, link, type);
+}
+async function removePrivateSymlink(effectiveHomePath, entryName) {
+  const privatePath = NodePath3.join(effectiveHomePath, entryName);
+  const state = await readLinkState(privatePath);
+  if (state._tag === "Symlink") await NodeFSP.rm(privatePath, { force: true });
+}
+async function ensureSymlink(input) {
+  const target = NodePath3.join(input.sharedHomePath, input.entryName);
+  const link = NodePath3.join(input.effectiveHomePath, input.entryName);
+  const state = await readLinkState(link);
+  if (state._tag === "NotSymlink") {
+    if (!REPLACEABLE_SHARED_RUNTIME_DIRECTORIES.has(input.entryName)) {
+      throw new Error(
+        `Cannot create Codex shadow home entry '${input.entryName}' because '${link}' already exists and is not a symlink.`
+      );
+    }
+    await NodeFSP.rm(link, { recursive: true, force: true });
+    await createEntryLink(target, link);
+    return;
+  }
+  if (state._tag === "Missing") {
+    await createEntryLink(target, link);
+    return;
+  }
+  const resolvedExisting = NodePath3.resolve(NodePath3.dirname(link), state.target);
+  if (resolvedExisting !== target) {
+    await NodeFSP.rm(link, { force: true });
+    await createEntryLink(target, link);
+  }
+}
+async function materializeCodexShadowHome(layout, log) {
+  if (layout.mode !== "authOverlay") return;
+  const effectiveHomePath = layout.effectiveHomePath;
+  if (!effectiveHomePath) return;
+  if (layout.sharedHomePath === effectiveHomePath) {
+    throw new Error(
+      `Codex shadow home path '${effectiveHomePath}' must be different from the shared home path '${layout.sharedHomePath}'.`
+    );
+  }
+  await NodeFSP.mkdir(layout.sharedHomePath, { recursive: true });
+  await NodeFSP.mkdir(effectiveHomePath, { recursive: true });
+  await Promise.all(
+    KNOWN_SHARED_DIRECTORIES.map(
+      (directory) => NodeFSP.mkdir(NodePath3.join(layout.sharedHomePath, directory), { recursive: true })
+    )
+  );
+  let sharedEntryNames = [];
+  try {
+    sharedEntryNames = await NodeFSP.readdir(layout.sharedHomePath);
+  } catch (error) {
+    throw new Error(
+      `Codex shadow home filesystem operation 'readDirectory' failed for '${layout.sharedHomePath}': ${String(error)}`,
+      { cause: error }
+    );
+  }
+  const entries = new Set(KNOWN_SHARED_DIRECTORIES);
+  for (const entryName of sharedEntryNames) {
+    if (!PRIVATE_ENTRY_NAMES.has(entryName) && !SHADOW_LOCAL_ENTRY_NAMES.has(entryName)) {
+      entries.add(entryName);
+    }
+  }
+  for (const entryName of PRIVATE_ENTRY_NAMES) {
+    if (entryName === "auth.json") continue;
+    await removePrivateSymlink(effectiveHomePath, entryName);
+  }
+  for (const entryName of entries) {
+    if (PRIVATE_ENTRY_NAMES.has(entryName)) continue;
+    try {
+      await ensureSymlink({
+        sharedHomePath: layout.sharedHomePath,
+        effectiveHomePath,
+        entryName
+      });
+    } catch (error) {
+      log?.warn("Codex shadow home entry left unlinked.", {
+        entryName,
+        effectiveHomePath,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const authPath = NodePath3.join(effectiveHomePath, "auth.json");
+  const authState = await readLinkState(authPath);
+  if (authState._tag === "Symlink") {
+    throw new Error(
+      `Codex shadow home private entry 'auth.json' at '${authPath}' must be a real file, not a symlink.`
+    );
+  }
+}
+function accountHomeFromLayout(layout) {
+  return layout.effectiveHomePath ?? layout.sharedHomePath;
+}
+
+// src/protocol.ts
+var CODEX_INITIALIZE_PARAMS = {
+  clientInfo: { name: "ycodium", title: "Ycodium", version: "0" },
+  capabilities: { experimentalApi: true }
+};
+var ACTIVE_WRITER_ATTEMPTS = 5;
+var ACTIVE_WRITER_DELAY_MS = 200;
+var DEFAULT_MODEL = "gpt-5.6-sol";
+var DEFAULT_TEXT_GENERATION_REASONING_EFFORT = "low";
+function runtimeModeToThreadConfig(mode) {
+  switch (mode) {
+    case "approval-required":
+      return { approvalPolicy: "untrusted", sandbox: "read-only", approvalsReviewer: "user" };
+    case "auto-accept-edits":
+      return {
+        approvalPolicy: "on-request",
+        sandbox: "workspace-write",
+        approvalsReviewer: "user"
+      };
+    case "auto":
+      return {
+        approvalPolicy: "on-request",
+        sandbox: "workspace-write",
+        approvalsReviewer: "auto_review"
+      };
+    case "full-access":
+    default:
+      return { approvalPolicy: "never", sandbox: "danger-full-access", approvalsReviewer: "user" };
+  }
+}
+function runtimeModeToTurnSandboxPolicy(mode) {
+  switch (mode) {
+    case "approval-required":
+      return { type: "readOnly" };
+    case "auto-accept-edits":
+    case "auto":
+      return { type: "workspaceWrite" };
+    case "full-access":
+    default:
+      return { type: "dangerFullAccess" };
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function decodeThreadOpen(result) {
+  const thread = isRecord3(result) ? isRecord3(result["thread"]) ? result["thread"] : result : null;
+  const id = thread ? asString(thread["id"]) : null;
+  if (!id) throw new Error("codex thread/start|resume returned no thread id");
+  return {
+    threadId: id,
+    ...asString(thread?.["cwd"]) ? { cwd: asString(thread["cwd"]) } : {},
+    ...asString(thread?.["model"]) ? { model: asString(thread["model"]) } : {}
+  };
+}
+function decodeTurnStart(result) {
+  const turn = isRecord3(result) ? isRecord3(result["turn"]) ? result["turn"] : result : null;
+  const id = turn ? asString(turn["id"]) : asString(isRecord3(result) ? result["turnId"] : null);
+  if (!id) throw new Error("codex turn/start returned no turn id");
+  return { turnId: id };
+}
+function inProgressTurnIdFromThreadRead(result) {
+  if (!isRecord3(result)) return void 0;
+  const thread = isRecord3(result["thread"]) ? result["thread"] : result;
+  const turns = Array.isArray(thread["turns"]) ? thread["turns"] : [];
+  for (const turn of turns) {
+    if (!isRecord3(turn)) continue;
+    const status = asString(turn["status"]);
+    if (status === "inProgress" || status === "in_progress" || status === "active") {
+      return asString(turn["id"]) ?? void 0;
+    }
+  }
+  const active = asString(thread["activeTurnId"]) ?? asString(thread["inProgressTurnId"]);
+  return active ?? void 0;
+}
+var RECOVERABLE_THREAD_RESUME_ERROR_SNIPPETS = [
+  "not found",
+  "missing thread",
+  "no such thread",
+  "unknown thread",
+  "does not exist",
+  "no rollout found"
+];
+function isRecoverableThreadResumeError(message) {
+  const lower = message.toLowerCase();
+  if (!lower.includes("thread")) return false;
+  return RECOVERABLE_THREAD_RESUME_ERROR_SNIPPETS.some((snippet) => lower.includes(snippet));
+}
+function isActiveWriterConflict(message) {
+  return message.toLowerCase().includes("already has an active writer");
+}
+var BENIGN_ERROR_LOG_SNIPPETS = [
+  "state db missing rollout path for thread",
+  "state db record_discrepancy: find_thread_path_by_id_str_in_subdir, falling_back"
+];
+function isBenignErrorLog(message) {
+  const lower = message.toLowerCase();
+  return BENIGN_ERROR_LOG_SNIPPETS.some((snippet) => lower.includes(snippet));
+}
+var FATAL_CODEX_STDERR_SNIPPETS = ["failed to connect to websocket"];
+function isFatalStderr(message) {
+  const lower = message.toLowerCase();
+  return FATAL_CODEX_STDERR_SNIPPETS.some((snippet) => lower.includes(snippet));
+}
+var CHILD_AGENT_EVENT_METHODS = /* @__PURE__ */ new Set([
+  "turn/started",
+  "turn/completed",
+  "thread/status/changed",
+  "thread/tokenUsage/updated",
+  "item/started",
+  "item/completed",
+  "thread/closed",
+  "error"
+]);
+var CHILD_CHATTER_METHODS = /* @__PURE__ */ new Set([
+  "item/agentMessage/delta",
+  "item/reasoning/delta",
+  "item/reasoning/summaryDelta",
+  "item/reasoning/summaryPartAdded",
+  "item/plan/delta",
+  "thread/name/updated",
+  "thread/archived",
+  "thread/unarchived",
+  "thread/compacted",
+  "thread/started"
+]);
+var MEMORY_CONSOLIDATION_NAME = "memory-consolidation";
+function isMemoryConsolidationThread(name) {
+  return (name ?? "").toLowerCase().includes(MEMORY_CONSOLIDATION_NAME);
+}
+function parseCodexResumeCursor(value) {
+  if (!isRecord3(value)) return void 0;
+  const threadId = asString(value["threadId"])?.trim();
+  return threadId ? { threadId } : void 0;
+}
+function conversationIdFromNotification(params) {
+  if (!isRecord3(params)) return void 0;
+  return asString(params["threadId"]) ?? asString(params["conversationId"]) ?? (isRecord3(params["thread"]) ? asString(params["thread"]["id"]) : null) ?? (isRecord3(params["turn"]) ? asString(params["turn"]["threadId"]) : null) ?? void 0;
+}
+function itemTypeOf(params) {
+  if (!isRecord3(params)) return void 0;
+  const item = isRecord3(params["item"]) ? params["item"] : params;
+  return asString(item["type"]) ?? asString(item["itemType"]) ?? void 0;
+}
+function jsonRpcErrorMessage(error) {
+  if (isRecord3(error) && typeof error["message"] === "string") return error["message"];
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/rpc.ts
+var STDERR_TAIL_LIMIT = 4e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var ANSI_ESCAPE_CHAR = String.fromCharCode(27);
+var ANSI_RE = new RegExp(`${ANSI_ESCAPE_CHAR}\\[[0-9;]*m`, "g");
+var CODEX_STDERR_LOG_REGEX = /\b(TRACE|DEBUG|INFO|WARN|ERROR)\b/;
+function classifyStderrLine(line) {
+  const stripped = line.replace(ANSI_RE, "").trim();
+  if (stripped.length === 0) return "drop";
+  const match = CODEX_STDERR_LOG_REGEX.exec(stripped);
+  if (match === null) return "error";
+  const level = match[1];
+  if (level === "ERROR") return "error";
+  if (level === "WARN") return "warn";
+  return "drop";
+}
+async function createCodexRpcClient(handle, handlers) {
+  const pending = /* @__PURE__ */ new Map();
+  const decoder = new TextDecoder();
+  let nextId = 1;
+  let stderrTail = "";
+  let exitReason = null;
+  let closed = false;
+  const failAll = (reason) => {
+    exitReason = reason;
+    for (const [, entry] of pending) {
+      entry.reject(new Error(`codex app-server ${entry.method} failed: ${reason}`));
+    }
+    pending.clear();
+  };
+  const dispatch = (line) => {
+    if (line.trim().length === 0) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    const typed = message;
+    const hasId = typeof typed.id === "number";
+    const hasMethod = typeof typed.method === "string";
+    if (hasId && hasMethod) {
+      handlers.onServerRequest({
+        id: typed.id,
+        method: typed.method,
+        params: typed.params
+      });
+      return;
+    }
+    if (hasId && !hasMethod) {
+      const entry = pending.get(typed.id);
+      if (entry === void 0) return;
+      pending.delete(typed.id);
+      if (typed.error !== void 0 && typed.error !== null) {
+        entry.reject(
+          new Error(`codex app-server ${entry.method} failed: ${jsonRpcErrorMessage(typed.error)}`)
+        );
+        return;
+      }
+      entry.resolve(typed.result);
+      return;
+    }
+    if (hasMethod) {
+      handlers.onNotification({ method: typed.method, params: typed.params });
+    }
+  };
+  const pumpStdout = (async () => {
+    let buffer = "";
+    for await (const chunk of handle.stdout) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        dispatch(buffer.slice(0, index));
+        buffer = buffer.slice(index + 1);
+        index = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.length > 0) dispatch(buffer);
+  })().catch(() => void 0);
+  const pumpStderr = (async () => {
+    const errorDecoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of handle.stderr) {
+      buffer += errorDecoder.decode(chunk, { stream: true });
+      stderrTail = `${stderrTail}${buffer}`.slice(-STDERR_TAIL_LIMIT);
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        handlers.onStderrLine(buffer.slice(0, index));
+        buffer = buffer.slice(index + 1);
+        index = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.length > 0) handlers.onStderrLine(buffer);
+  })().catch(() => void 0);
+  void handle.exited.then((code) => {
+    failAll(
+      `the process exited with code ${String(code)}${stderrTail.length > 0 ? `: ${stderrTail.trim()}` : ""}`
+    );
+    handlers.onExit?.(code);
+  }).catch(() => {
+    failAll("the process ended unexpectedly");
+    handlers.onExit?.(null);
+  });
+  const writeLine = async (payload, jsonRpcId) => {
+    try {
+      await handle.writeStdin(`${JSON.stringify(payload)}
+`);
+      if (jsonRpcId !== void 0) handlers.onRequestSettled?.(jsonRpcId, "written");
+    } catch (error) {
+      if (jsonRpcId !== void 0) handlers.onRequestSettled?.(jsonRpcId, "write-failed");
+      throw error;
+    }
+  };
+  const request = async (method, params, timeoutMs) => {
+    if (exitReason !== null) throw new Error(`codex app-server ${method} failed: ${exitReason}`);
+    const id = nextId;
+    nextId += 1;
+    const settled = new Promise((resolve2, reject) => {
+      pending.set(id, { resolve: resolve2, reject, method });
+    });
+    await writeLine({ id, method, ...params === void 0 ? {} : { params } });
+    const limit = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    if (limit <= 0) return await settled;
+    let timer;
+    try {
+      return await Promise.race([
+        settled,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new Error(`codex app-server ${method} timed out after ${String(limit)}ms`));
+          }, limit);
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+  const notify = async (method, params) => {
+    await writeLine({ method, ...params === void 0 ? {} : { params } });
+  };
+  const respond = async (id, result) => {
+    await writeLine({ id, result }, id);
+  };
+  const respondError = async (id, code, message) => {
+    await writeLine({ id, error: { code, message } }, id);
+  };
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    try {
+      await handle.closeStdin();
+    } catch {
+    }
+    try {
+      await handle.kill("SIGTERM");
+    } catch {
+    }
+    failAll("the client was closed");
+    await Promise.all([pumpStdout, pumpStderr]);
+  };
+  return { request, notify, respond, respondError, close, pid: handle.pid };
+}
+
+// src/approvalGrant.ts
+function codexApprovalGrantKey(kind, identity) {
+  if (kind === "mcp-elicitation") return `codex:mcp:${identity || "unknown"}`;
+  return `codex:${kind}`;
+}
+function createApprovalGrantStore() {
+  const grants = /* @__PURE__ */ new Map();
+  return {
+    remember: (key, decision) => {
+      grants.set(key, decision);
+    },
+    lookup: (key) => grants.get(key),
+    clear: () => {
+      grants.clear();
+    }
+  };
+}
+function wireDecisionFromPersist(kind, persist) {
+  if (kind === "command" || kind === "file-change") return "acceptForSession";
+  return persist;
+}
+
+// src/declineReasonRelay.ts
+function createDeclineReasonRelay() {
+  const queued = /* @__PURE__ */ new Map();
+  return {
+    queue: (threadId, reason) => {
+      const trimmed = reason.trim();
+      if (trimmed.length === 0) return;
+      const list = queued.get(threadId) ?? [];
+      list.push(trimmed);
+      queued.set(threadId, list);
+    },
+    take: (threadId) => {
+      const list = queued.get(threadId);
+      if (list === void 0 || list.length === 0) return void 0;
+      queued.delete(threadId);
+      return list.map((reason) => `I declined that request. ${reason}`).join("\n");
+    },
+    clear: (threadId) => {
+      queued.delete(threadId);
+    }
+  };
+}
+
+// src/developerInstructions.ts
+var YCODIUM_BROWSER_TOOL_INSTRUCTIONS = `
+
+## Ycodium collaborative browser
+
+You are running inside Ycodium. The \`ycodium\` MCP server is the product-native collaborative browser shared with the user. When it exposes \`preview_*\` tools, prefer those tools for browser navigation, inspection, interaction, screenshots, and recordings.
+
+For browser work, first call \`preview_status\`. If no automation-capable preview is attached, call \`preview_open\` before concluding that the browser is unavailable. Then use \`preview_navigate\`, \`preview_snapshot\`, and the focused interaction tools. Prefer snapshot-provided locators over coordinates.
+
+Do not switch to global browser skills, Chrome, Node REPL browser automation, standalone Playwright, or agent-browser merely because the preview is initially closed or a first call fails. Use an alternative browser system only when the Ycodium preview tools are absent, the user explicitly requests another browser, or \`preview_open\` returns an explicit unsupported/unavailable error. A failed Ycodium preview tool call should be inspected and retried with corrected arguments when the error is actionable.
+`;
+var YCODIUM_THREAD_TOOL_INSTRUCTIONS = `
+
+## Ycodium child threads
+
+The \`ycodium\` MCP server can start child threads on this environment. When \`start_thread\` is listed, use it to hand a self-contained piece of work to another thread \u2014 optionally on a different provider instance or model \u2014 instead of doing everything inline or spawning your own background processes.
+
+Call \`list_providers\` and \`list_models\` first when you want a specific provider, model, or effort level; passing an effort a model does not offer is rejected rather than ignored. Pass \`isolate: true\` when the child must not share your working tree.
+
+\`start_thread\` returns as soon as the child is running. You do not need to poll: a message arrives in this thread when the child finishes, fails, stops, or needs an approval, and it names the child thread id. Use \`get_thread_activity\` to read the full transcript behind a truncated summary, \`send_message\` to follow up, \`respond_to_permission\` to answer its approval requests, and \`stop_thread\` to end it. You can only steer child threads you started yourself.
+`;
+var threadToolInstructions = (threadToolsAvailable) => threadToolsAvailable ? YCODIUM_THREAD_TOOL_INSTRUCTIONS : "";
+var browserToolInstructions = (browserToolsAvailable) => browserToolsAvailable ? YCODIUM_BROWSER_TOOL_INSTRUCTIONS : "";
+var codexPlanModeDeveloperInstructions = (browserToolsAvailable, threadToolsAvailable = browserToolsAvailable) => `<collaboration_mode># Plan Mode (Conversational)
+
+You work in 3 phases, and you should *chat your way* to a great plan before finalizing it. A great plan is very detailed-intent- and implementation-wise-so that it can be handed to another engineer or agent to be implemented right away. It must be **decision complete**, where the implementer does not need to make any decisions.
+
+## Mode rules (strict)
+
+You are in **Plan Mode** until a developer message explicitly ends it.
+
+Plan Mode is not changed by user intent, tone, or imperative language. If a user asks for execution while still in Plan Mode, treat it as a request to **plan the execution**, not perform it.
+
+## Plan Mode vs update_plan tool
+
+Plan Mode is a collaboration mode that can involve requesting user input and eventually issuing a \`<proposed_plan>\` block.
+
+Separately, \`update_plan\` is a checklist/progress/TODOs tool; it does not enter or exit Plan Mode. Do not confuse it with Plan mode or try to use it while in Plan mode. If you try to use \`update_plan\` in Plan mode, it will return an error.
+
+## Execution vs. mutation in Plan Mode
+
+You may explore and execute **non-mutating** actions that improve the plan. You must not perform **mutating** actions.
+
+### Allowed (non-mutating, plan-improving)
+
+Actions that gather truth, reduce ambiguity, or validate feasibility without changing repo-tracked state. Examples:
+
+* Reading or searching files, configs, schemas, types, manifests, and docs
+* Static analysis, inspection, and repo exploration
+* Dry-run style commands when they do not edit repo-tracked files
+* Tests, builds, or checks that may write to caches or build artifacts (for example, \`target/\`, \`.cache/\`, or snapshots) so long as they do not edit repo-tracked files
+
+### Not allowed (mutating, plan-executing)
+
+Actions that implement the plan or change repo-tracked state. Examples:
+
+* Editing or writing files
+* Running formatters or linters that rewrite files
+* Applying patches, migrations, or codegen that updates repo-tracked files
+* Side-effectful commands whose purpose is to carry out the plan rather than refine it
+
+When in doubt: if the action would reasonably be described as "doing the work" rather than "planning the work," do not do it.
+
+## PHASE 1 - Ground in the environment (explore first, ask second)
+
+Begin by grounding yourself in the actual environment. Eliminate unknowns in the prompt by discovering facts, not by asking the user. Resolve all questions that can be answered through exploration or inspection. Identify missing or ambiguous details only if they cannot be derived from the environment. Silent exploration between turns is allowed and encouraged.
+
+Before asking the user any question, perform at least one targeted non-mutating exploration pass (for example: search relevant files, inspect likely entrypoints/configs, confirm current implementation shape), unless no local environment/repo is available.
+
+Exception: you may ask clarifying questions about the user's prompt before exploring, ONLY if there are obvious ambiguities or contradictions in the prompt itself. However, if ambiguity might be resolved by exploring, always prefer exploring first.
+
+Do not ask questions that can be answered from the repo or system (for example, "where is this struct?" or "which UI component should we use?" when exploration can make it clear). Only ask once you have exhausted reasonable non-mutating exploration.
+
+## PHASE 2 - Intent chat (what they actually want)
+
+* Keep asking until you can clearly state: goal + success criteria, audience, in/out of scope, constraints, current state, and the key preferences/tradeoffs.
+* Bias toward questions over guessing: if any high-impact ambiguity remains, do NOT plan yet-ask.
+
+## PHASE 3 - Implementation chat (what/how we'll build)
+
+* Once intent is stable, keep asking until the spec is decision complete: approach, interfaces (APIs/schemas/I/O), data flow, edge cases/failure modes, testing + acceptance criteria, rollout/monitoring, and any migrations/compat constraints.
+
+## Asking questions
+
+Critical rules:
+
+* Strongly prefer using the \`request_user_input\` tool to ask any questions.
+* Offer only meaningful multiple-choice options; don't include filler choices that are obviously wrong or irrelevant.
+* In rare cases where an unavoidable, important question can't be expressed with reasonable multiple-choice options (due to extreme ambiguity), you may ask it directly without the tool.
+
+You SHOULD ask many questions, but each question must:
+
+* materially change the spec/plan, OR
+* confirm/lock an assumption, OR
+* choose between meaningful tradeoffs.
+* not be answerable by non-mutating commands.
+
+Use the \`request_user_input\` tool only for decisions that materially change the plan, for confirming important assumptions, or for information that cannot be discovered via non-mutating exploration.
+
+## Two kinds of unknowns (treat differently)
+
+1. **Discoverable facts** (repo/system truth): explore first.
+
+   * Before asking, run targeted searches and check likely sources of truth (configs/manifests/entrypoints/schemas/types/constants).
+   * Ask only if: multiple plausible candidates; nothing found but you need a missing identifier/context; or ambiguity is actually product intent.
+   * If asking, present concrete candidates (paths/service names) + recommend one.
+   * Never ask questions you can answer from your environment (e.g., "where is this struct").
+
+2. **Preferences/tradeoffs** (not discoverable): ask early.
+
+   * These are intent or implementation preferences that cannot be derived from exploration.
+   * Provide 2-4 mutually exclusive options + a recommended default.
+   * If unanswered, proceed with the recommended option and record it as an assumption in the final plan.
+
+## Finalization rule
+
+Only output the final plan when it is decision complete and leaves no decisions to the implementer.
+
+When you present the official plan, wrap it in a \`<proposed_plan>\` block so the client can render it specially:
+
+1) The opening tag must be on its own line.
+2) Start the plan content on the next line (no text on the same line as the tag).
+3) The closing tag must be on its own line.
+4) Use Markdown inside the block.
+5) Keep the tags exactly as \`<proposed_plan>\` and \`</proposed_plan>\` (do not translate or rename them), even if the plan content is in another language.
+
+Example:
+
+<proposed_plan>
+plan content
+</proposed_plan>
+
+plan content should be human and agent digestible. The final plan must be plan-only, concise by default, and include:
+
+* A clear title
+* A brief summary section
+* Important changes or additions to public APIs/interfaces/types
+* Test cases and scenarios
+* Explicit assumptions and defaults chosen where needed
+
+When possible, prefer a compact structure with 3-5 short sections, usually: Summary, Key Changes or Implementation Changes, Test Plan, and Assumptions. Do not include a separate Scope section unless scope boundaries are genuinely important to avoid mistakes.
+
+Prefer grouped implementation bullets by subsystem or behavior over file-by-file inventories. Mention files only when needed to disambiguate a non-obvious change, and avoid naming more than 3 paths unless extra specificity is necessary to prevent mistakes. Prefer behavior-level descriptions over symbol-by-symbol removal lists. For v1 feature-addition plans, do not invent detailed schema, validation, precedence, fallback, or wire-shape policy unless the request establishes it or it is needed to prevent a concrete implementation mistake; prefer the intended capability and minimum interface/behavior changes.
+
+Keep bullets short and avoid explanatory sub-bullets unless they are needed to prevent ambiguity. Prefer the minimum detail needed for implementation safety, not exhaustive coverage. Within each section, compress related changes into a few high-signal bullets and omit branch-by-branch logic, repeated invariants, and long lists of unaffected behavior unless they are necessary to prevent a likely implementation mistake. Avoid repeated repo facts and irrelevant edge-case or rollout detail. For straightforward refactors, keep the plan to a compact summary, key edits, tests, and assumptions. If the user asks for more detail, then expand.
+
+Do not ask "should I proceed?" in the final output. The user can easily switch out of Plan mode and request implementation if you have included a \`<proposed_plan>\` block in your response. Alternatively, they can decide to stay in Plan mode and continue refining the plan.
+
+Only produce at most one \`<proposed_plan>\` block per turn, and only when you are presenting a complete spec.
+
+If the user stays in Plan mode and asks for revisions after a prior \`<proposed_plan>\`, any new \`<proposed_plan>\` must be a complete replacement. If the user indicates that the prior plan is not acceptable but does not provide enough information to produce a complete replacement, address the concern and continue planning without producing a \`<proposed_plan>\` block. If the follow-up neither requires changes nor calls the plan into question (e.g. clarifying question), answer it before the block, then reproduce the prior \`<proposed_plan>\` unchanged.
+${browserToolInstructions(browserToolsAvailable)}${threadToolInstructions(threadToolsAvailable)}
+</collaboration_mode>`;
+var codexDefaultModeDeveloperInstructions = (browserToolsAvailable, threadToolsAvailable = browserToolsAvailable) => `<collaboration_mode># Collaboration Mode: Default
+
+You are now in Default mode. Any previous instructions for other modes (e.g. Plan mode) are no longer active.
+
+Your active mode changes only when new developer instructions with a different \`<collaboration_mode>...</collaboration_mode>\` change it; user requests or tool descriptions do not change mode by themselves. Known mode names are Default and Plan.
+
+## request_user_input availability
+
+Use the \`request_user_input\` tool only when it is listed in the available tools for this turn.
+
+In Default mode, strongly prefer making reasonable assumptions and executing the user's request rather than stopping to ask questions. If you absolutely must ask a question because the answer cannot be discovered from local context and a reasonable assumption would be risky, ask the user directly with a concise plain-text question. Never write a multiple choice question as a textual assistant message.
+${browserToolInstructions(browserToolsAvailable)}${threadToolInstructions(threadToolsAvailable)}
+</collaboration_mode>`;
+function toSingleLine(value) {
+  return value.replaceAll(/\s+/g, " ").trim();
+}
+function buildCodexDeveloperInstructions(interactionMode, runtime, browserToolsAvailable = true, threadToolsAvailable = browserToolsAvailable) {
+  const base = interactionMode === "plan" ? codexPlanModeDeveloperInstructions(browserToolsAvailable, threadToolsAvailable) : codexDefaultModeDeveloperInstructions(browserToolsAvailable, threadToolsAvailable);
+  return `${base}
+
+<runtime_info>In case you're asked: you are running in Ycodium through the Codex harness, as ${toSingleLine(runtime.model)} with ${toSingleLine(runtime.reasoningEffort)} reasoning effort. No need to mention this otherwise.</runtime_info>`;
+}
+
+// src/imageMime.ts
+var IMAGE_EXTENSION_BY_MIME_TYPE = {
+  "image/avif": ".avif",
+  "image/bmp": ".bmp",
+  "image/gif": ".gif",
+  "image/heic": ".heic",
+  "image/heif": ".heif",
+  "image/jpeg": ".jpg",
+  "image/jpg": ".jpg",
+  "image/png": ".png",
+  "image/svg+xml": ".svg",
+  "image/tiff": ".tiff",
+  "image/webp": ".webp"
+};
+var SAFE_IMAGE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".heic",
+  ".heif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".svg",
+  ".tiff",
+  ".webp"
+]);
+function isBase64Char(code) {
+  return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 43 || code === 47 || code === 61;
+}
+function isBase64Whitespace(code) {
+  return code === 13 || code === 10 || code === 32;
+}
+function parseBase64DataUrl(dataUrl) {
+  const trimmed = dataUrl.trim();
+  if (trimmed.slice(0, 5).toLowerCase() !== "data:") return null;
+  const commaIndex = trimmed.indexOf(",");
+  if (commaIndex === -1) return null;
+  const header = trimmed.slice(5, commaIndex);
+  if (header.length === 0) return null;
+  const headerParts = [];
+  for (const part of header.split(";")) {
+    const partTrimmed = part.trim();
+    if (partTrimmed.length > 0) headerParts.push(partTrimmed);
+  }
+  if (headerParts.length < 2) return null;
+  const trailingToken = headerParts.at(-1)?.toLowerCase();
+  if (trailingToken !== "base64") return null;
+  const mimeType = headerParts[0]?.toLowerCase();
+  if (!mimeType) return null;
+  const payload = trimmed.slice(commaIndex + 1);
+  const runs = [];
+  let runStart = -1;
+  for (let index = 0; index < payload.length; index += 1) {
+    const code = payload.charCodeAt(index);
+    if (isBase64Char(code)) {
+      if (runStart === -1) runStart = index;
+      continue;
+    }
+    if (!isBase64Whitespace(code)) return null;
+    if (runStart !== -1) {
+      runs.push(payload.slice(runStart, index));
+      runStart = -1;
+    }
+  }
+  if (runStart !== -1) runs.push(payload.slice(runStart));
+  const base64 = runs.length === 1 ? runs[0] : runs.join("");
+  if (base64.length === 0 || base64.length % 4 !== 0) return null;
+  const firstPad = base64.indexOf("=");
+  if (firstPad !== -1) {
+    if (base64.length - firstPad > 2) return null;
+    for (let index = firstPad; index < base64.length; index += 1) {
+      if (base64.charCodeAt(index) !== 61) return null;
+    }
+  }
+  return { mimeType, base64 };
+}
+function inferImageExtension(input) {
+  const key = input.mimeType.toLowerCase();
+  const fromMime = Object.hasOwn(IMAGE_EXTENSION_BY_MIME_TYPE, key) ? IMAGE_EXTENSION_BY_MIME_TYPE[key] : void 0;
+  if (fromMime) return fromMime;
+  const fileName = input.fileName?.trim() ?? "";
+  const extensionMatch = /\.([a-z0-9]{1,8})$/i.exec(fileName);
+  const fileNameExtension = extensionMatch ? `.${extensionMatch[1].toLowerCase()}` : "";
+  if (SAFE_IMAGE_FILE_EXTENSIONS.has(fileNameExtension)) return fileNameExtension;
+  return ".bin";
+}
+
+// src/events.ts
+var CODEX_PROVIDER = "codex";
+var eventSeq = 0;
+function nextEventId() {
+  eventSeq += 1;
+  return `codex-evt-${eventSeq}`;
+}
+function trimText(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeItemType(value) {
+  if (!value) return "unknown";
+  return value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_/.-]+/g, " ").toLowerCase().trim();
+}
+function toCanonicalItemType(raw) {
+  const type = normalizeItemType(raw);
+  if (type.includes("user") && type.includes("message")) return "user";
+  if (type.includes("agent") && type.includes("message")) return "assistant";
+  if (type.includes("assistant")) return "assistant";
+  if (type.includes("reason") || type.includes("thought")) return "reasoning";
+  if (type.includes("plan") || type.includes("todo")) return "plan";
+  if (type.includes("command")) return "command";
+  if (type.includes("file change") || type.includes("patch") || type.includes("edit")) {
+    return "fileChange";
+  }
+  if (type.includes("mcp")) return "mcp";
+  if (type.includes("dynamic tool")) return "dynamicTool";
+  if (type.includes("collab")) return "collab";
+  if (type.includes("web search")) return "webSearch";
+  if (type.includes("image")) return "image";
+  if (type.includes("review entered")) return "reviewEntered";
+  if (type.includes("review exited")) return "reviewExited";
+  if (type.includes("compact")) return "compact";
+  if (type.includes("error")) return "error";
+  return "unknown";
+}
+function itemIdOf(params) {
+  if (!isRecord3(params)) return void 0;
+  const item = isRecord3(params["item"]) ? params["item"] : params;
+  return asString(item["id"]) ?? asString(params["itemId"]) ?? void 0;
+}
+function turnIdOf(params) {
+  if (!isRecord3(params)) return void 0;
+  return asString(params["turnId"]) ?? (isRecord3(params["turn"]) ? asString(params["turn"]["id"]) : null) ?? void 0;
+}
+function itemTitle(params) {
+  if (!isRecord3(params)) return void 0;
+  const item = isRecord3(params["item"]) ? params["item"] : params;
+  return trimText(item["title"]) ?? trimText(item["name"]) ?? trimText(item["command"]) ?? trimText(item["summary"]) ?? void 0;
+}
+function itemDetail(params) {
+  if (!isRecord3(params)) return void 0;
+  const item = isRecord3(params["item"]) ? params["item"] : params;
+  const query = isRecord3(item["action"]) ? item["action"]["queries"] : item["query"];
+  if (Array.isArray(query)) {
+    const joined = query.filter((entry) => typeof entry === "string").join(", ");
+    if (joined.length > 0) return joined;
+  }
+  return trimText(item["text"]) ?? trimText(item["summary"]) ?? trimText(item["path"]) ?? trimText(item["savedPath"]) ?? trimText(item["prompt"]) ?? (typeof query === "string" ? query : void 0);
+}
+function toTurnStatus(status) {
+  switch (status) {
+    case "failed":
+      return "failed";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    case "interrupted":
+      return "interrupted";
+    default:
+      return "completed";
+  }
+}
+function toThreadState(status) {
+  if (status === "idle") return "idle";
+  if (status === "systemError" || status === "error") return "error";
+  return "active";
+}
+function contentStreamKindFromMethod(method) {
+  if (method.includes("agentMessage")) return "assistant";
+  if (method.includes("reasoning")) return "reasoning";
+  if (method.includes("plan")) return "plan";
+  return void 0;
+}
+function normalizeCodexTokenUsage(params) {
+  if (!isRecord3(params)) return void 0;
+  const usage = isRecord3(params["usage"]) ? params["usage"] : params;
+  const last = isRecord3(usage["last"]) ? usage["last"] : usage;
+  const total = isRecord3(usage["total"]) ? usage["total"] : void 0;
+  const usedTokens = asNumber(last["totalTokens"]) ?? asNumber(last["total_tokens"]);
+  if (usedTokens === null || usedTokens <= 0) return void 0;
+  const totalProcessed = total ? asNumber(total["totalTokens"]) ?? asNumber(total["total_tokens"]) : null;
+  const payload = {
+    usedTokens,
+    compactsAutomatically: true
+  };
+  if (totalProcessed !== null && totalProcessed > usedTokens) {
+    payload["totalProcessedTokens"] = totalProcessed;
+  }
+  const maxTokens = asNumber(params["modelContextWindow"]) ?? asNumber(usage["modelContextWindow"]);
+  if (maxTokens !== null && maxTokens > 0) payload["maxTokens"] = maxTokens;
+  const lastInput = asNumber(last["inputTokens"]) ?? asNumber(last["input_tokens"]);
+  const lastOutput = asNumber(last["outputTokens"]) ?? asNumber(last["output_tokens"]);
+  if (lastInput !== null) payload["lastInputTokens"] = lastInput;
+  if (lastOutput !== null) payload["lastOutputTokens"] = lastOutput;
+  return payload;
+}
+function turnCompletedControlFlow(params) {
+  const turn = isRecord3(params) ? isRecord3(params["turn"]) ? params["turn"] : params : {};
+  const status = toTurnStatus(asString(turn["status"]) ?? void 0);
+  const error = isRecord3(turn["error"]) ? trimText(turn["error"]["message"]) : void 0;
+  return error ? { status, errorMessage: error } : { status };
+}
+function toApplyPatchFileChanges(params) {
+  if (!isRecord3(params)) return [];
+  const item = isRecord3(params["item"]) ? params["item"] : params;
+  const changes = item["changes"] ?? item["fileChanges"] ?? params["fileChanges"];
+  if (!isRecord3(changes) && !Array.isArray(changes)) return [];
+  const entries = Array.isArray(changes) ? changes : Object.entries(changes).map(([path, change]) => ({
+    path,
+    ...isRecord3(change) ? change : {}
+  }));
+  const out = [];
+  for (const entry of entries) {
+    if (!isRecord3(entry)) continue;
+    const path = asString(entry["path"]) ?? asString(entry["file"]);
+    if (!path) continue;
+    const kind = (asString(entry["type"]) ?? asString(entry["kind"]) ?? "update").toLowerCase();
+    const movePath = asString(entry["move_path"]) ?? asString(entry["movePath"]);
+    if (kind === "add") out.push({ path, kind: "add" });
+    else if (kind === "delete") out.push({ path, kind: "delete" });
+    else if (movePath) out.push({ path, kind: "rename", to: movePath });
+    else out.push({ path, kind: "modify" });
+  }
+  return out;
+}
+function toUserInputQuestions(params) {
+  if (!isRecord3(params)) return void 0;
+  const questions = Array.isArray(params["questions"]) ? params["questions"] : [];
+  const mapped = [];
+  for (const question of questions) {
+    if (!isRecord3(question)) return void 0;
+    const id = asString(question["id"]);
+    const header = asString(question["header"]);
+    const text = asString(question["question"]);
+    const options = Array.isArray(question["options"]) ? question["options"] : [];
+    if (!id || !header || !text || options.length === 0) return void 0;
+    mapped.push({
+      id,
+      header,
+      question: text,
+      options,
+      multiSelect: false
+    });
+  }
+  return mapped.length > 0 ? mapped : void 0;
+}
+function toCodexUserInputAnswers(answers) {
+  if (typeof answers === "string") return [answers];
+  if (Array.isArray(answers) && answers.every((entry) => typeof entry === "string")) {
+    return answers;
+  }
+  if (isRecord3(answers) && Array.isArray(answers["answers"])) {
+    const values = answers["answers"];
+    if (values.every((entry) => typeof entry === "string")) return values;
+  }
+  return void 0;
+}
+function pathLeaf(value) {
+  if (!value) return void 0;
+  const parts = value.split("/").filter((part) => part.length > 0);
+  return parts.at(-1);
+}
+function eventRaw(source, method, payload) {
+  return { source, method, payload };
+}
+function baseEvent(input) {
+  return {
+    eventId: nextEventId(),
+    provider: CODEX_PROVIDER,
+    threadId: input.threadId,
+    createdAt: nowIso2(),
+    type: input.type,
+    payload: input.payload,
+    ...input.providerInstanceId ? { providerInstanceId: input.providerInstanceId } : {},
+    ...input.turnId ? { turnId: input.turnId } : {},
+    ...input.itemId ? { itemId: input.itemId } : {},
+    ...input.requestId ? { requestId: input.requestId } : {},
+    ...input.method ? {
+      raw: eventRaw(
+        input.source ?? "codex.app-server.notification",
+        input.method,
+        input.payload
+      )
+    } : {}
+  };
+}
+function mapCollabAgentEvent(input) {
+  if (!isRecord3(input.params)) return [];
+  const agentThreadId = asString(input.params["agentThreadId"]) ?? asString(input.params["threadId"]);
+  if (!agentThreadId) return [];
+  const agentPath = asString(input.params["agentPath"]) ?? asString(input.params["path"]) ?? void 0;
+  const nickname = asString(input.params["agentNickname"]) ?? asString(input.params["nickname"]);
+  const role = asString(input.params["agentRole"]) ?? asString(input.params["role"]) ?? pathLeaf(agentPath) ?? "general-purpose";
+  const title = nickname ?? pathLeaf(agentPath) ?? agentThreadId;
+  const linkage = {
+    role,
+    title,
+    ...agentPath ? { agentPath } : {},
+    timelineBypass: true
+  };
+  const threadId = input.rootThreadId;
+  const method = input.method;
+  if (method === "collabAgent/started" || method === "task.started") {
+    return [
+      baseEvent({
+        type: "task.started",
+        threadId,
+        payload: { taskId: agentThreadId, ...linkage },
+        method,
+        providerInstanceId: input.providerInstanceId
+      })
+    ];
+  }
+  if (method === "collabAgent/progress" || method === "task.progress") {
+    return [
+      baseEvent({
+        type: "task.progress",
+        threadId,
+        payload: {
+          taskId: agentThreadId,
+          ...linkage,
+          detail: trimText(input.params["detail"]) ?? trimText(input.params["text"])
+        },
+        method,
+        providerInstanceId: input.providerInstanceId
+      })
+    ];
+  }
+  if (method === "collabAgent/completed" || method === "task.completed") {
+    return [
+      baseEvent({
+        type: "task.completed",
+        threadId,
+        payload: { taskId: agentThreadId, ...linkage },
+        method,
+        providerInstanceId: input.providerInstanceId
+      })
+    ];
+  }
+  if (method === "collabAgent/statusChanged") {
+    return [
+      baseEvent({
+        type: "task.updated",
+        threadId,
+        payload: {
+          taskId: agentThreadId,
+          ...linkage,
+          status: asString(input.params["status"]) ?? "running"
+        },
+        method,
+        providerInstanceId: input.providerInstanceId
+      })
+    ];
+  }
+  if (method === "collabAgent/tokenUsage") {
+    const usage = normalizeCodexTokenUsage(input.params);
+    if (!usage) return [];
+    return [
+      baseEvent({
+        type: "thread.token-usage.updated",
+        threadId: agentThreadId,
+        payload: usage,
+        method,
+        providerInstanceId: input.providerInstanceId
+      })
+    ];
+  }
+  return [];
+}
+function describeCommandApproval(params) {
+  const record = isRecord3(params) ? params : {};
+  const commandValue = record["command"];
+  const command = Array.isArray(commandValue) ? commandValue.filter((entry) => typeof entry === "string").join(" ") : asString(commandValue) ?? "";
+  const cwd = asString(record["cwd"]);
+  const reason = trimText(record["reason"]);
+  const callId = asString(record["callId"]);
+  return {
+    command,
+    ...cwd ? { cwd } : {},
+    ...reason ? { reason } : {},
+    ...callId ? { callId } : {}
+  };
+}
+function describeFileChangeApproval(params) {
+  const record = isRecord3(params) ? params : {};
+  const reason = trimText(record["reason"]);
+  const grantRoot = asString(record["grantRoot"]);
+  const callId = asString(record["callId"]);
+  return {
+    ...reason ? { reason } : {},
+    ...grantRoot ? { grantRoot } : {},
+    ...callId ? { callId } : {},
+    fileChanges: toApplyPatchFileChanges(record)
+  };
+}
+function describeMcpElicitation(params) {
+  const record = isRecord3(params) ? params : {};
+  const appName = asString(record["appName"]) ?? asString(record["serverName"]) ?? void 0;
+  const serverName = asString(record["serverName"]);
+  const message = trimText(record["message"]);
+  const url = asString(record["url"]) ?? asString(record["authorizationUrl"]);
+  const identity = appName ?? url ?? "unknown";
+  return {
+    ...appName ? { appName } : {},
+    ...serverName ? { serverName } : {},
+    ...message ? { message } : {},
+    ...url ? { url } : {},
+    identity,
+    mode: url ? "url" : "form",
+    ...record["requestedSchema"] !== void 0 ? { schema: record["requestedSchema"] } : {}
+  };
+}
+function persistFromMeta(meta) {
+  if (!isRecord3(meta)) return void 0;
+  const persist = asString(meta["persist"]) ?? asString(meta["persistence"]);
+  if (persist === "session" || persist === "acceptForSession") return "session";
+  if (persist === "always" || persist === "permanent" || persist === "forever" || persist === "persistent" || persist === "acceptAlways") {
+    return "always";
+  }
+  return void 0;
+}
+function toMcpElicitationResponse(decision, params) {
+  const described = describeMcpElicitation(params);
+  if (decision !== "allow" || described.mode === "url") {
+    return {
+      action: decision === "allow" ? "decline" : decision === "cancel" ? "cancel" : "decline"
+    };
+  }
+  const schema = isRecord3(described.schema) ? described.schema : void 0;
+  const properties = schema && isRecord3(schema["properties"]) ? schema["properties"] : {};
+  const required = schema && Array.isArray(schema["required"]) ? schema["required"] : [];
+  const content = {};
+  for (const [key, spec] of Object.entries(properties)) {
+    if (!isRecord3(spec)) continue;
+    if (Array.isArray(spec["oneOf"]) || Array.isArray(spec["enum"])) {
+      const options = Array.isArray(spec["oneOf"]) ? spec["oneOf"] : Array.isArray(spec["enum"]) ? spec["enum"] : [];
+      const first = options[0];
+      content[key] = isRecord3(first) ? first["const"] ?? first["value"] ?? first : first;
+    } else if (spec["type"] === "boolean") {
+      content[key] = true;
+    } else if (typeof spec["default"] !== "undefined") {
+      content[key] = spec["default"];
+    }
+  }
+  for (const key of required) {
+    if (typeof key === "string" && !(key in content)) {
+      return { action: "decline" };
+    }
+  }
+  const persist = persistFromMeta(isRecord3(params) ? params["_meta"] : void 0);
+  return {
+    action: "accept",
+    content,
+    ...persist ? { _meta: { persist } } : {}
+  };
+}
+function producedImages(params) {
+  if (!isRecord3(params)) return [];
+  const item = isRecord3(params["item"]) ? params["item"] : params;
+  const type = toCanonicalItemType(asString(item["type"]) ?? void 0);
+  const events = [];
+  const threadId = conversationIdFromNotification(params) ?? "";
+  const emit = (payload) => {
+    events.push(
+      baseEvent({
+        type: "assistant.attachment.produced",
+        threadId,
+        payload,
+        itemId: asString(item["id"]) ?? void 0,
+        turnId: turnIdOf(params),
+        method: "item/completed"
+      })
+    );
+  };
+  if (type === "image") {
+    const savedPath = asString(item["savedPath"]) ?? asString(item["path"]);
+    if (savedPath) emit({ path: savedPath, mimeType: "image/png" });
+  }
+  const content = Array.isArray(item["content"]) ? item["content"] : [];
+  for (const entry of content) {
+    if (!isRecord3(entry)) continue;
+    if (entry["type"] === "image" && typeof entry["data"] === "string") {
+      const mimeType = asString(entry["mimeType"]) ?? "image/png";
+      emit({
+        mimeType,
+        data: entry["data"],
+        extension: inferImageExtension({ mimeType })
+      });
+    }
+    if (entry["type"] === "inputImage" && typeof entry["imageUrl"] === "string") {
+      const parsed = parseBase64DataUrl(entry["imageUrl"]);
+      if (parsed) {
+        emit({
+          mimeType: parsed.mimeType,
+          data: parsed.base64,
+          extension: inferImageExtension({ mimeType: parsed.mimeType })
+        });
+      }
+    }
+  }
+  return events;
+}
+function mapNotificationToEvents(input) {
+  const { method, params, threadId, providerInstanceId } = input;
+  if (method.startsWith("collabAgent/")) {
+    return mapCollabAgentEvent({ method, params, rootThreadId: threadId, providerInstanceId });
+  }
+  if (method === "error") {
+    const willRetry = isRecord3(params) && params["willRetry"] === true;
+    const nested = isRecord3(params) && isRecord3(params["error"]) ? params["error"] : void 0;
+    const message = (nested ? trimText(nested["message"]) : void 0) ?? (isRecord3(params) ? trimText(params["message"]) : void 0) ?? "Codex error";
+    const payload = { message };
+    if (!willRetry) payload["class"] = "provider_error";
+    if (params !== void 0) payload["detail"] = params;
+    return [
+      baseEvent({
+        type: willRetry ? "runtime.warning" : "runtime.error",
+        threadId,
+        payload,
+        turnId: turnIdOf(params),
+        method,
+        providerInstanceId
+      })
+    ];
+  }
+  if (method === "process/stderr") {
+    const text = isRecord3(params) ? trimText(params["text"]) ?? "" : "";
+    if (!text) return [];
+    if (isFatalStderr(text)) {
+      return [
+        baseEvent({
+          type: "runtime.error",
+          threadId,
+          payload: { message: text },
+          method,
+          providerInstanceId
+        })
+      ];
+    }
+    return [
+      baseEvent({
+        type: "runtime.warning",
+        threadId,
+        payload: { message: text },
+        method,
+        providerInstanceId
+      })
+    ];
+  }
+  const turnId = turnIdOf(params);
+  const itemId = itemIdOf(params);
+  const type = itemTypeOf(params);
+  switch (method) {
+    case "thread/started":
+      return [
+        baseEvent({
+          type: "thread.started",
+          threadId,
+          payload: isRecord3(params) ? params : {},
+          method,
+          providerInstanceId
+        })
+      ];
+    case "thread/status/changed": {
+      const status = isRecord3(params) ? asString(params["status"]) : void 0;
+      return [
+        baseEvent({
+          type: "thread.state.changed",
+          threadId,
+          payload: { state: toThreadState(status ?? void 0), status },
+          method,
+          providerInstanceId
+        })
+      ];
+    }
+    case "thread/name/updated":
+      return [
+        baseEvent({
+          type: "thread.metadata.updated",
+          threadId,
+          payload: { title: isRecord3(params) ? asString(params["name"]) : null },
+          method,
+          providerInstanceId
+        })
+      ];
+    case "thread/tokenUsage/updated": {
+      const usage = normalizeCodexTokenUsage(params);
+      if (!usage) return [];
+      return [
+        baseEvent({
+          type: "thread.token-usage.updated",
+          threadId,
+          payload: usage,
+          method,
+          providerInstanceId
+        })
+      ];
+    }
+    case "thread/closed":
+    case "session/closed":
+      return [
+        baseEvent({
+          type: "session.exited",
+          threadId,
+          payload: {},
+          method,
+          providerInstanceId
+        })
+      ];
+    case "turn/started":
+      return [
+        baseEvent({
+          type: "turn.started",
+          threadId,
+          turnId,
+          payload: { turnId },
+          method,
+          providerInstanceId
+        })
+      ];
+    case "turn/completed": {
+      const flow = turnCompletedControlFlow(params);
+      const typeName = flow.status === "cancelled" || flow.status === "interrupted" ? "turn.aborted" : "turn.completed";
+      return [
+        baseEvent({
+          type: typeName,
+          threadId,
+          turnId,
+          payload: flow,
+          method,
+          providerInstanceId
+        })
+      ];
+    }
+    case "turn/plan":
+      return [
+        baseEvent({
+          type: "turn.plan.updated",
+          threadId,
+          turnId,
+          payload: params,
+          method,
+          providerInstanceId
+        })
+      ];
+    case "item/started": {
+      if (type && normalizeItemType(type).includes("compact")) {
+        return [
+          baseEvent({
+            type: "thread.state.changed",
+            threadId,
+            payload: { state: "compacting" },
+            turnId,
+            itemId,
+            method,
+            providerInstanceId
+          })
+        ];
+      }
+      return [
+        baseEvent({
+          type: "item.started",
+          threadId,
+          turnId,
+          itemId,
+          payload: {
+            itemType: toCanonicalItemType(type),
+            title: itemTitle(params),
+            detail: itemDetail(params)
+          },
+          method,
+          providerInstanceId
+        })
+      ];
+    }
+    case "item/completed": {
+      if (type && normalizeItemType(type).includes("compact")) {
+        return [
+          baseEvent({
+            type: "thread.state.changed",
+            threadId,
+            payload: { state: "compacted" },
+            turnId,
+            itemId,
+            method,
+            providerInstanceId
+          })
+        ];
+      }
+      if (type && normalizeItemType(type).includes("plan")) {
+        return [
+          baseEvent({
+            type: "turn.proposed.completed",
+            threadId,
+            turnId,
+            itemId,
+            payload: params,
+            method,
+            providerInstanceId
+          })
+        ];
+      }
+      return [
+        baseEvent({
+          type: "item.completed",
+          threadId,
+          turnId,
+          itemId,
+          payload: {
+            itemType: toCanonicalItemType(type),
+            title: itemTitle(params),
+            detail: itemDetail(params)
+          },
+          method,
+          providerInstanceId
+        }),
+        ...producedImages(params).map((event) => ({ ...event, threadId }))
+      ];
+    }
+    case "item/plan/delta":
+      return [
+        baseEvent({
+          type: "turn.proposed.delta",
+          threadId,
+          turnId,
+          itemId,
+          payload: params,
+          method,
+          providerInstanceId
+        })
+      ];
+    case "item/agentMessage/delta":
+    case "item/reasoning/delta":
+    case "item/reasoning/summaryDelta": {
+      const delta = isRecord3(params) ? asString(params["delta"]) ?? asString(params["text"]) ?? "" : "";
+      return [
+        baseEvent({
+          type: "content.delta",
+          threadId,
+          turnId,
+          itemId,
+          payload: { kind: contentStreamKindFromMethod(method), delta },
+          method,
+          providerInstanceId
+        })
+      ];
+    }
+    case "item/reasoning/summaryPartAdded":
+      return [
+        baseEvent({
+          type: "content.delta",
+          threadId,
+          turnId,
+          itemId,
+          payload: {
+            kind: "reasoning",
+            delta: "",
+            summaryIndex: isRecord3(params) ? asNumber(params["summaryIndex"]) : null
+          },
+          method,
+          providerInstanceId
+        })
+      ];
+    case "account/updated":
+    case "account/rateLimits/updated":
+      return [
+        baseEvent({
+          type: method === "account/updated" ? "account.updated" : "account.rate-limits.updated",
+          threadId,
+          payload: params,
+          method,
+          providerInstanceId
+        })
+      ];
+    case "model/rerouted":
+      return [
+        baseEvent({
+          type: "model.rerouted",
+          threadId,
+          payload: params,
+          method,
+          providerInstanceId
+        })
+      ];
+    case "config/warning":
+      return [
+        baseEvent({
+          type: "config.warning",
+          threadId,
+          payload: params,
+          method,
+          providerInstanceId
+        })
+      ];
+    case "mcp/oauth/completed":
+      return [
+        baseEvent({
+          type: "mcp.oauth.completed",
+          threadId,
+          payload: params,
+          method,
+          providerInstanceId
+        })
+      ];
+    default:
+      return [];
+  }
+}
+function mapServerRequestToEvents(input) {
+  const requestId = String(input.id);
+  if (input.method === "item/tool/requestUserInput") {
+    const questions = toUserInputQuestions(input.params);
+    if (!questions) return [];
+    return [
+      baseEvent({
+        type: "user-input.requested",
+        threadId: input.threadId,
+        requestId,
+        payload: { questions },
+        method: input.method,
+        source: "codex.app-server.request",
+        providerInstanceId: input.providerInstanceId
+      })
+    ];
+  }
+  const kind = input.method === "item/commandExecution/requestApproval" ? "command" : input.method === "item/fileChange/requestApproval" ? "file-change" : input.method === "mcpServer/elicitation/request" ? "mcp-elicitation" : input.method.includes("applyPatch") ? "apply-patch" : "command";
+  const args = kind === "command" ? describeCommandApproval(input.params) : kind === "file-change" || kind === "apply-patch" ? describeFileChangeApproval(input.params) : describeMcpElicitation(input.params);
+  return [
+    baseEvent({
+      type: "request.opened",
+      threadId: input.threadId,
+      requestId,
+      payload: {
+        kind,
+        args,
+        declineReasonRelay: "queued"
+      },
+      method: input.method,
+      source: "codex.app-server.request",
+      providerInstanceId: input.providerInstanceId
+    })
+  ];
+}
+
+// src/sessionRuntime.ts
+var sleep = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+function isRootChild(agentPath, agentThreadId, rootThreadId) {
+  if (agentThreadId === rootThreadId) return true;
+  return agentPath === "/root" || agentPath === "/";
+}
+function pathLeaf2(value) {
+  if (!value) return void 0;
+  const parts = value.split("/").filter((part) => part.length > 0);
+  return parts.at(-1);
+}
+var CodexSessionRuntime = class {
+  threadId;
+  cwd;
+  session;
+  nativeThreadId;
+  activeTurnId;
+  model;
+  runtimeMode;
+  interactionMode;
+  closed = false;
+  closeCompleted = false;
+  turns = [];
+  pendingApprovals = /* @__PURE__ */ new Map();
+  pendingUserInputs = /* @__PURE__ */ new Map();
+  writeAcks = /* @__PURE__ */ new Map();
+  grants;
+  declineRelay;
+  collabChildren = /* @__PURE__ */ new Map();
+  liveForeignTurns = /* @__PURE__ */ new Map();
+  collabReceiverTurns = /* @__PURE__ */ new Map();
+  memoryThreadIds = /* @__PURE__ */ new Set();
+  appServerArgs;
+  host;
+  rpc;
+  emit;
+  constructor(host, rpc, emit, input, cwd, appServerArgs, grants, declineRelay) {
+    this.host = host;
+    this.rpc = rpc;
+    this.emit = emit;
+    this.threadId = input.threadId;
+    this.cwd = cwd;
+    this.runtimeMode = input.runtimeMode;
+    this.appServerArgs = appServerArgs;
+    this.grants = grants ?? createApprovalGrantStore();
+    this.declineRelay = declineRelay ?? createDeclineReasonRelay();
+    const createdAt = nowIso();
+    this.session = {
+      provider: CODEX_DRIVER_KIND,
+      providerInstanceId: host.instanceId,
+      status: "idle",
+      runtimeMode: input.runtimeMode,
+      cwd,
+      threadId: input.threadId,
+      createdAt,
+      updatedAt: createdAt,
+      ...input.bindingGeneration === void 0 ? {} : { bindingGeneration: input.bindingGeneration }
+    };
+  }
+  registerWriteAck(jsonRpcId) {
+    return new Promise((resolve2) => {
+      this.writeAcks.set(jsonRpcId, { resolve: resolve2 });
+    });
+  }
+  settleNativeWrite(requestId, status) {
+    const ack = this.writeAcks.get(requestId);
+    if (!ack) return;
+    this.writeAcks.delete(requestId);
+    ack.resolve(status);
+  }
+  failPendingNativeWrites(reason) {
+    for (const [, ack] of this.writeAcks) ack.resolve("closed");
+    this.writeAcks.clear();
+    void reason;
+  }
+  async confirmAfterNativeWrite(jsonRpcId) {
+    const existing = this.writeAcks.get(jsonRpcId);
+    if (existing) {
+      return await new Promise((resolve2) => {
+        const previous = existing.resolve;
+        existing.resolve = (status) => {
+          previous(status);
+          resolve2(status);
+        };
+      });
+    }
+    return await this.registerWriteAck(jsonRpcId);
+  }
+  handleStderrLine(line) {
+    const kind = classifyStderrLine(line);
+    if (kind === "drop") return;
+    if (isFatalStderr(line)) {
+      this.emit({
+        eventId: `codex-stderr-${Date.now()}`,
+        provider: CODEX_DRIVER_KIND,
+        threadId: this.threadId,
+        createdAt: nowIso(),
+        type: "runtime.error",
+        payload: { message: line }
+      });
+      return;
+    }
+    if (kind === "error") {
+      this.host.log.error(line, { threadId: this.threadId });
+      return;
+    }
+    this.host.log.warn(line, { threadId: this.threadId });
+  }
+  handleNotification(method, params) {
+    if (this.closed) return;
+    const conversationId = conversationIdFromNotification(params);
+    if (conversationId && conversationId !== this.nativeThreadId && conversationId !== this.threadId) {
+      this.interceptCollab(method, params, conversationId);
+      return;
+    }
+    if (conversationId && this.memoryThreadIds.has(conversationId)) {
+      if (method === "serverRequest" || method === "serverRequest/resolved") {
+        this.dispatchMapped(method, params);
+      }
+      return;
+    }
+    if (method === "thread/started") {
+      const name = isRecord3(params) ? asString(params["name"]) ?? (isRecord3(params["thread"]) ? asString(params["thread"]["name"]) : null) : null;
+      if (isMemoryConsolidationThread(name ?? void 0) && conversationId) {
+        this.memoryThreadIds.add(conversationId);
+        return;
+      }
+    }
+    this.dispatchMapped(method, params);
+  }
+  dispatchMapped(method, params) {
+    for (const event of mapNotificationToEvents({
+      method,
+      params,
+      threadId: this.threadId,
+      providerInstanceId: this.host.instanceId
+    })) {
+      this.emit(event);
+    }
+    if (method === "turn/started") {
+      const turnId = isRecord3(params) ? asString(params["turnId"]) ?? (isRecord3(params["turn"]) ? asString(params["turn"]["id"]) : null) : null;
+      if (turnId) this.activeTurnId = turnId;
+    }
+    if (method === "turn/completed") {
+      this.activeTurnId = void 0;
+      const { activeTurnId: _completedTurn, ...idleSession } = this.session;
+      this.session = { ...idleSession, status: "idle", updatedAt: nowIso() };
+    }
+  }
+  interceptCollab(method, params, conversationId) {
+    const source = isRecord3(params) ? params["source"] : void 0;
+    const subAgent = isRecord3(source) ? source["subAgent"] : void 0;
+    const spawn = isRecord3(subAgent) ? subAgent["thread_spawn"] : void 0;
+    if (method === "thread/started" && isRecord3(spawn)) {
+      const agentPath = asString(spawn["agent_path"]) ?? void 0;
+      if (isRootChild(agentPath, conversationId, this.nativeThreadId ?? this.threadId)) return;
+      const existing = this.collabChildren.get(conversationId);
+      const spawnTurnId = existing?.spawnTurnId ?? this.activeTurnId;
+      const child2 = {
+        agentThreadId: conversationId,
+        ...agentPath ? { agentPath } : {},
+        ...asString(spawn["agent_role"]) ? { role: asString(spawn["agent_role"]) } : {},
+        ...asString(spawn["agent_nickname"]) ? { nickname: asString(spawn["agent_nickname"]) } : {},
+        ...spawnTurnId ? { spawnTurnId } : {}
+      };
+      this.collabChildren.set(conversationId, child2);
+      this.emitCollab("collabAgent/started", child2);
+      return;
+    }
+    const itemType = itemTypeOf(params);
+    if ((method === "item/started" || method === "item/completed") && itemType === "collabAgentToolCall") {
+      const item = isRecord3(params) ? isRecord3(params["item"]) ? params["item"] : params : {};
+      const receiver = asString(item["receiverThreadId"]) ?? asString(item["agentThreadId"]);
+      if (receiver && this.activeTurnId) this.collabReceiverTurns.set(receiver, this.activeTurnId);
+      return;
+    }
+    if ((method === "item/started" || method === "item/completed") && itemType === "subAgentActivity") {
+      const item = isRecord3(params) ? isRecord3(params["item"]) ? params["item"] : params : {};
+      const agentThreadId = asString(item["agentThreadId"]) ?? conversationId;
+      const agentPath = asString(item["agentPath"]) ?? void 0;
+      if (isRootChild(agentPath, agentThreadId, this.nativeThreadId ?? this.threadId)) return;
+      if (!this.collabChildren.has(agentThreadId)) {
+        const spawnTurnId = this.activeTurnId;
+        const child2 = {
+          agentThreadId,
+          ...agentPath ? { agentPath } : {},
+          ...spawnTurnId ? { spawnTurnId } : {}
+        };
+        this.collabChildren.set(agentThreadId, child2);
+        this.emitCollab("collabAgent/started", child2);
+      }
+    }
+    const child = this.collabChildren.get(conversationId);
+    if (method === "turn/started") {
+      const turnId = isRecord3(params) ? asString(params["turnId"]) ?? (isRecord3(params["turn"]) ? asString(params["turn"]["id"]) : null) : null;
+      if (turnId) this.liveForeignTurns.set(conversationId, turnId);
+    }
+    if (method === "turn/completed" || method === "thread/closed") {
+      this.liveForeignTurns.delete(conversationId);
+    }
+    if (!child) {
+      if (CHILD_CHATTER_METHODS.has(method) || !CHILD_AGENT_EVENT_METHODS.has(method)) return;
+      return;
+    }
+    if (method === "turn/completed") {
+      this.emitCollab("collabAgent/completed", child);
+      return;
+    }
+    if (method === "error") {
+      const willRetry = isRecord3(params) ? params["willRetry"] === true : false;
+      if (willRetry) return;
+      this.emitCollab("collabAgent/statusChanged", child, { status: "systemError" });
+      return;
+    }
+    if (method === "thread/tokenUsage/updated") {
+      this.emitCollab("collabAgent/tokenUsage", child, params);
+      return;
+    }
+    if (CHILD_CHATTER_METHODS.has(method)) return;
+    if (CHILD_AGENT_EVENT_METHODS.has(method)) {
+      this.emitCollab("collabAgent/progress", child, params);
+    }
+  }
+  emitCollab(method, child, extra) {
+    const params = {
+      agentThreadId: child.agentThreadId,
+      agentPath: child.agentPath,
+      agentRole: child.role ?? pathLeaf2(child.agentPath) ?? "general-purpose",
+      agentNickname: child.nickname,
+      ...isRecord3(extra) ? extra : {}
+    };
+    for (const event of mapNotificationToEvents({
+      method,
+      params,
+      threadId: this.threadId,
+      providerInstanceId: this.host.instanceId
+    })) {
+      this.emit(event);
+    }
+  }
+  async handleServerRequest(id, method, params) {
+    if (method === "item/commandExecution/requestApproval") {
+      await this.handleApproval(
+        id,
+        method,
+        params,
+        "command",
+        describeCommandApproval(params).command
+      );
+      return;
+    }
+    if (method === "item/fileChange/requestApproval") {
+      const described = describeFileChangeApproval(params);
+      await this.handleApproval(
+        id,
+        method,
+        params,
+        "file-change",
+        described.callId ?? "file-change"
+      );
+      return;
+    }
+    if (method === "mcpServer/elicitation/request") {
+      const described = describeMcpElicitation(params);
+      await this.handleApproval(id, method, params, "mcp-elicitation", described.identity);
+      return;
+    }
+    if (method === "item/tool/requestUserInput") {
+      const requestId = String(id);
+      const events = mapServerRequestToEvents({
+        id,
+        method,
+        params,
+        threadId: this.threadId,
+        providerInstanceId: this.host.instanceId
+      });
+      if (events.length === 0) {
+        await this.rpc.respond(id, {});
+        return;
+      }
+      await new Promise((resolve2) => {
+        this.pendingUserInputs.set(requestId, {
+          jsonRpcId: id,
+          settle: (result) => {
+            this.pendingUserInputs.delete(requestId);
+            void this.rpc.respond(id, result).finally(resolve2);
+          }
+        });
+        for (const event of events) this.emit(event);
+      });
+      return;
+    }
+    await this.rpc.respondError(id, -32601, `Method not found: ${method}`);
+  }
+  async handleApproval(id, method, params, kind, identity) {
+    const grant = this.grants.lookup(codexApprovalGrantKey(kind, identity));
+    if (grant) {
+      const decision = wireDecisionFromPersist(kind, grant);
+      await this.rpc.respond(id, { decision });
+      return;
+    }
+    const requestId = String(id);
+    const events = mapServerRequestToEvents({
+      id,
+      method,
+      params,
+      threadId: this.threadId,
+      providerInstanceId: this.host.instanceId
+    });
+    await new Promise((resolve2) => {
+      this.pendingApprovals.set(requestId, {
+        jsonRpcId: id,
+        method,
+        params,
+        kind,
+        identity,
+        settle: (decision) => {
+          this.pendingApprovals.delete(requestId);
+          void this.rpc.respond(id, decision).finally(resolve2);
+        }
+      });
+      for (const event of events) this.emit(event);
+    });
+  }
+  async respondToRequest(requestId, decision, reason, persist) {
+    const pending = this.pendingApprovals.get(requestId);
+    if (!pending) throw new Error(`unknown request ${requestId}`);
+    if (decision === "deny" && reason) this.declineRelay.queue(this.threadId, reason);
+    let wire = { decision: decision === "allow" ? "accept" : "decline" };
+    if (decision === "allow" && pending.kind === "mcp-elicitation") {
+      wire = toMcpElicitationResponse("allow", pending.params);
+    }
+    if (decision === "allow" && persist) {
+      this.grants.remember(codexApprovalGrantKey(pending.kind, pending.identity), persist);
+      if (pending.kind !== "mcp-elicitation") {
+        wire = { decision: wireDecisionFromPersist(pending.kind, persist) };
+      }
+    }
+    const ack = this.registerWriteAck(pending.jsonRpcId);
+    pending.settle(wire);
+    await ack.catch(() => "closed");
+    this.emit({
+      eventId: `codex-req-${requestId}`,
+      provider: CODEX_DRIVER_KIND,
+      threadId: this.threadId,
+      createdAt: nowIso(),
+      type: "request.resolved",
+      requestId,
+      payload: { decision }
+    });
+  }
+  async respondToUserInput(requestId, answers) {
+    const pending = this.pendingUserInputs.get(requestId);
+    if (!pending) throw new Error(`unknown user-input ${requestId}`);
+    const mapped = toCodexUserInputAnswers(answers);
+    pending.settle(mapped === void 0 ? {} : { answers: mapped });
+    this.emit({
+      eventId: `codex-ui-${requestId}`,
+      provider: CODEX_DRIVER_KIND,
+      threadId: this.threadId,
+      createdAt: nowIso(),
+      type: "user-input.resolved",
+      requestId,
+      payload: { answers: mapped ?? [] }
+    });
+  }
+  async withActiveWriterRecovery(run, allowUnsubscribe) {
+    let lastError;
+    for (let attempt = 0; attempt < ACTIVE_WRITER_ATTEMPTS; attempt += 1) {
+      try {
+        return await run();
+      } catch (error) {
+        lastError = error;
+        const message = error instanceof Error ? error.message : String(error);
+        if (!isActiveWriterConflict(message) || !this.nativeThreadId) throw error;
+        await sleep(ACTIVE_WRITER_DELAY_MS);
+        let probe;
+        try {
+          probe = await this.rpc.request("thread/read", { threadId: this.nativeThreadId }, 0);
+        } catch {
+          continue;
+        }
+        const liveTurn = inProgressTurnIdFromThreadRead(probe);
+        if (liveTurn && allowUnsubscribe) {
+          try {
+            await this.rpc.request("turn/interrupt", {
+              threadId: this.nativeThreadId,
+              turnId: liveTurn
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  threadConfigParams() {
+    const config = runtimeModeToThreadConfig(this.runtimeMode);
+    return {
+      approvalPolicy: config.approvalPolicy,
+      sandbox: config.sandbox,
+      approvalsReviewer: config.approvalsReviewer,
+      cwd: this.cwd
+    };
+  }
+  async openThread(input) {
+    const resume = input.discardResumeCursor === true ? void 0 : parseCodexResumeCursor(input.resumeCursor);
+    const requestedModel = input.launch.requestedModelId?.trim() || modelIdFromSelection(input.modelSelection);
+    const startParams = {
+      ...this.threadConfigParams(),
+      ...requestedModel ? { model: requestedModel } : {}
+    };
+    if (resume) {
+      try {
+        const result = await this.withActiveWriterRecovery(
+          () => this.rpc.request("thread/resume", { threadId: resume.threadId, ...startParams }, 0),
+          true
+        );
+        const opened = decodeThreadOpen(result);
+        this.nativeThreadId = opened.threadId;
+        this.model = opened.model ?? requestedModel;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!isRecoverableThreadResumeError(message)) throw error;
+        const result = await this.rpc.request("thread/start", startParams, 0);
+        const opened = decodeThreadOpen(result);
+        this.nativeThreadId = opened.threadId;
+        this.model = opened.model ?? requestedModel;
+      }
+    } else {
+      const result = await this.rpc.request("thread/start", startParams, 0);
+      const opened = decodeThreadOpen(result);
+      this.nativeThreadId = opened.threadId;
+      this.model = opened.model ?? requestedModel;
+    }
+    this.session = {
+      ...this.session,
+      status: "idle",
+      resumeCursor: { threadId: this.nativeThreadId },
+      updatedAt: nowIso(),
+      ...this.model ? { model: this.model } : {}
+    };
+    this.emit({
+      eventId: `codex-session-${this.threadId}`,
+      provider: CODEX_DRIVER_KIND,
+      threadId: this.threadId,
+      createdAt: nowIso(),
+      type: "session.started",
+      payload: { resumeCursor: this.session.resumeCursor }
+    });
+    return this.session;
+  }
+  developerInstructions(input) {
+    const mode = typeof input.interactionMode === "string" ? input.interactionMode : void 0;
+    this.interactionMode = mode;
+    if (mode === void 0) return void 0;
+    const tools = hasConfiguredMcpServer(this.appServerArgs);
+    const model = this.model ?? DEFAULT_MODEL;
+    const effort = modelSelectionStringOption(input.modelSelection, "reasoningEffort") ?? DEFAULT_TEXT_GENERATION_REASONING_EFFORT;
+    return buildCodexDeveloperInstructions(mode, { model, reasoningEffort: effort }, tools, tools);
+  }
+  turnInput(input) {
+    const items = [];
+    const declined = this.declineRelay.take(this.threadId);
+    const text = [declined, input.input ?? ""].filter((part) => part && part.length > 0).join("\n\n");
+    if (text.length > 0) items.push({ type: "text", text });
+    if (Array.isArray(input.attachments)) {
+      for (const attachment of input.attachments) {
+        if (!isRecord3(attachment)) continue;
+        const url = asString(attachment["dataUrl"]) ?? asString(attachment["url"]);
+        if (url) items.push({ type: "image", url });
+      }
+    }
+    return items;
+  }
+  async sendTurn(input) {
+    if (!this.nativeThreadId) throw new Error("codex session has no native thread");
+    if (hasConfiguredMcpServer(this.appServerArgs)) {
+      await this.rpc.request("mcpServer/reload", {}, 0).catch(() => void 0);
+    }
+    const sandboxPolicy = runtimeModeToTurnSandboxPolicy(this.runtimeMode);
+    const config = runtimeModeToThreadConfig(this.runtimeMode);
+    const developerInstructions = this.developerInstructions(input);
+    const requestedModel = modelIdFromSelection(input.modelSelection) ?? this.model;
+    const params = {
+      threadId: this.nativeThreadId,
+      input: this.turnInput(input),
+      approvalPolicy: config.approvalPolicy,
+      approvalsReviewer: config.approvalsReviewer,
+      sandboxPolicy,
+      ...requestedModel ? { model: requestedModel } : {},
+      ...developerInstructions ? { developerInstructions } : {}
+    };
+    if (input.interactionMode !== void 0) {
+      params["collaborationMode"] = input.interactionMode === "plan" ? "plan" : "default";
+    }
+    const isSteer = input.expectedTurnId !== void 0;
+    const result = isSteer ? await this.rpc.request(
+      "turn/steer",
+      {
+        ...params,
+        turnId: input.expectedTurnId
+      },
+      0
+    ) : await this.withActiveWriterRecovery(() => this.rpc.request("turn/start", params, 0), false);
+    const started = decodeTurnStart(result);
+    this.activeTurnId = started.turnId;
+    this.turns.push({ id: started.turnId, items: [] });
+    this.session = {
+      ...this.session,
+      status: "running",
+      activeTurnId: started.turnId,
+      updatedAt: nowIso(),
+      ...requestedModel ? { model: requestedModel } : {}
+    };
+    return {
+      threadId: this.threadId,
+      turnId: started.turnId,
+      resumeCursor: { threadId: this.nativeThreadId }
+    };
+  }
+  async interruptTurn(turnId) {
+    const childTurns = [...this.liveForeignTurns.entries()];
+    const started = Date.now();
+    await Promise.all(
+      childTurns.slice(0, 8).map(async ([thread, childTurn]) => {
+        if (Date.now() - started > 1e4) return;
+        try {
+          await Promise.race([
+            this.rpc.request("turn/interrupt", { threadId: thread, turnId: childTurn }, 0),
+            sleep(3e3)
+          ]);
+        } catch {
+        }
+      })
+    );
+    if (!this.nativeThreadId) return;
+    const target = turnId ?? this.activeTurnId;
+    if (!target) return;
+    await this.rpc.request("turn/interrupt", { threadId: this.nativeThreadId, turnId: target }, 0).catch(() => void 0);
+  }
+  async compactContext() {
+    if (!this.nativeThreadId) return;
+    await this.rpc.request("thread/compact", { threadId: this.nativeThreadId }, 0).catch(() => void 0);
+  }
+  async uploadFeedback(reason) {
+    const result = await this.rpc.request(
+      "feedback/upload",
+      {
+        threadId: this.nativeThreadId,
+        ...reason ? { reason } : {}
+      },
+      0
+    );
+    const id = (isRecord3(result) ? asString(result["feedbackId"]) : null) ?? `codex-feedback-${Date.now()}`;
+    return { feedbackId: id };
+  }
+  async readThread() {
+    if (!this.nativeThreadId) return { threadId: this.threadId, turns: this.turns };
+    try {
+      const result = await this.rpc.request(
+        "thread/read",
+        {
+          threadId: this.nativeThreadId,
+          includeTurns: true
+        },
+        0
+      );
+      const thread = isRecord3(result) && isRecord3(result["thread"]) ? result["thread"] : null;
+      const turnsRaw = thread && Array.isArray(thread["turns"]) ? thread["turns"] : [];
+      const turns = turnsRaw.flatMap((turn) => {
+        if (!isRecord3(turn)) return [];
+        const id = asString(turn["id"]);
+        if (!id) return [];
+        return [{ id, items: Array.isArray(turn["items"]) ? turn["items"] : [] }];
+      });
+      this.turns.splice(0, this.turns.length, ...turns);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!isBenignErrorLog(message)) this.host.log.warn(message, { threadId: this.threadId });
+    }
+    return { threadId: this.threadId, turns: this.turns };
+  }
+  settlePendingApprovals(decision) {
+    for (const [requestId, pending] of this.pendingApprovals) {
+      pending.settle({ decision });
+      this.pendingApprovals.delete(requestId);
+    }
+  }
+  settlePendingUserInputs(result) {
+    for (const [requestId, pending] of this.pendingUserInputs) {
+      pending.settle(result);
+      this.pendingUserInputs.delete(requestId);
+    }
+  }
+  async close() {
+    if (this.closeCompleted) return;
+    this.closed = true;
+    this.failPendingNativeWrites("session closed before write confirmation");
+    this.settlePendingApprovals("cancel");
+    this.settlePendingUserInputs({});
+    this.declineRelay.clear(this.threadId);
+    this.grants.clear();
+    try {
+      await this.rpc.close();
+    } catch {
+    }
+    this.closeCompleted = true;
+    this.emit({
+      eventId: `codex-close-${this.threadId}`,
+      provider: CODEX_DRIVER_KIND,
+      threadId: this.threadId,
+      createdAt: nowIso(),
+      type: "session.exited",
+      payload: {}
+    });
+  }
+};
+
+// src/sessions.ts
+import * as NodeFS2 from "node:fs";
+import * as NodePath4 from "node:path";
+import * as NodeReadline from "node:readline";
+var EXTENDED_LENGTH_UNC = "//?/UNC/";
+var EXTENDED_LENGTH = "//?/";
+function normalize(value, caseInsensitive) {
+  let unified = value.trim().replace(/\\/gu, "/");
+  const upper = unified.toUpperCase();
+  if (upper.startsWith(EXTENDED_LENGTH_UNC)) {
+    unified = `//${unified.slice(EXTENDED_LENGTH_UNC.length)}`;
+  } else if (upper.startsWith(EXTENDED_LENGTH)) {
+    unified = unified.slice(EXTENDED_LENGTH.length);
+  }
+  const isUnc = unified.startsWith("//");
+  unified = unified.replace(/\/+/gu, "/").replace(/\/+$/u, "");
+  if (isUnc) unified = `/${unified}`;
+  return caseInsensitive ? unified.toLowerCase() : unified;
+}
+function isWithinDirectory(candidate, root, caseInsensitive) {
+  const normalizedRoot = normalize(root, caseInsensitive);
+  if (normalizedRoot.length === 0 || normalizedRoot === "/") return false;
+  const normalizedCandidate = normalize(candidate, caseInsensitive);
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
+}
+var PAGE_LIMIT = 50;
+var MAX_PAGES = 10;
+var MAX_ROWS = 50;
+var PREVIEW_LIMIT = 200;
+function truncate(value) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.length === 0) return null;
+  return trimmed.length <= PREVIEW_LIMIT ? trimmed : `${trimmed.slice(0, PREVIEW_LIMIT)}\u2026`;
+}
+var nativeModel = (value) => {
+  const model = asString(value)?.trim();
+  return model && model !== "<synthetic>" ? model : null;
+};
+function readListPage(response) {
+  if (!response || typeof response !== "object") return { threads: [], nextCursor: null };
+  const typed = response;
+  const rows = Array.isArray(typed.data) ? typed.data : [];
+  const threads = [];
+  for (const row of rows) {
+    if (!isRecord3(row)) continue;
+    if (typeof row.id !== "string" || typeof row.cwd !== "string") continue;
+    threads.push({
+      id: row.id,
+      cwd: row.cwd,
+      name: asString(row.name),
+      preview: asString(row.preview),
+      model: asString(row.model),
+      updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : 0
+    });
+  }
+  return { threads, nextCursor: asString(typed.nextCursor) };
+}
+function readThreadTurns(response) {
+  if (!isRecord3(response)) return [];
+  const thread = isRecord3(response.thread) ? response.thread : null;
+  if (!thread) return [];
+  const turns = Array.isArray(thread.turns) ? thread.turns : [];
+  return turns.flatMap((turn) => {
+    if (!isRecord3(turn)) return [];
+    return [
+      {
+        ...typeof turn.id === "string" && turn.id.length > 0 ? { id: turn.id } : {},
+        ...typeof turn.model === "string" && turn.model.length > 0 ? { model: turn.model } : {},
+        startedAt: typeof turn.startedAt === "number" ? turn.startedAt : null,
+        items: Array.isArray(turn.items) ? turn.items : []
+      }
+    ];
+  });
+}
+function itemText(item) {
+  if (!isRecord3(item)) return void 0;
+  const type = (asString(item.type) ?? "").toLowerCase();
+  const text = asString(item.text) ?? asString(item.content) ?? (Array.isArray(item.content) ? item.content.map((entry) => isRecord3(entry) ? asString(entry.text) : null).filter((entry) => typeof entry === "string").join("\n") : null);
+  if (!text || text.trim().length === 0) return void 0;
+  if (type.includes("user")) return { role: "user", text };
+  if (type.includes("agent") || type.includes("assistant")) return { role: "assistant", text };
+  if (type.includes("system")) return { role: "system", text };
+  return void 0;
+}
+async function scanCodexSessions(input) {
+  const threads = [];
+  let cursor = null;
+  for (let page = 0; page < MAX_PAGES && threads.length < MAX_ROWS; page += 1) {
+    const listed = readListPage(
+      await input.client.request("thread/list", {
+        limit: PAGE_LIMIT,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        ...cursor === null ? {} : { cursor }
+      })
+    );
+    for (const thread of listed.threads) {
+      if (!isWithinDirectory(thread.cwd, input.directory, input.caseInsensitive)) continue;
+      threads.push(thread);
+      if (threads.length >= MAX_ROWS) break;
+    }
+    if (listed.nextCursor === null || listed.nextCursor.length === 0) break;
+    cursor = listed.nextCursor;
+  }
+  const rows = [];
+  for (const thread of threads) {
+    const turnCount = await input.client.request("thread/read", { threadId: thread.id, includeTurns: true }).then((response) => readThreadTurns(response).length).catch(() => 0);
+    rows.push({
+      nativeSessionId: thread.id,
+      cwd: thread.cwd,
+      title: truncate(thread.name),
+      preview: truncate(thread.preview),
+      model: truncate(thread.model),
+      turnCount,
+      updatedAt: thread.updatedAt * 1e3,
+      availability: "importable",
+      openElsewhere: false
+    });
+  }
+  return rows;
+}
+async function readCodexSession(input) {
+  const response = await input.client.request("thread/read", {
+    threadId: input.threadId,
+    includeTurns: true
+  });
+  const record = isRecord3(response) ? response : null;
+  const thread = record && isRecord3(record.thread) ? record.thread : null;
+  const path = input.caseInsensitive ? NodePath4.win32 : NodePath4;
+  const sameDirectory = (left, right) => isWithinDirectory(path.resolve(left), path.resolve(right), input.caseInsensitive) && isWithinDirectory(path.resolve(right), path.resolve(left), input.caseInsensitive);
+  if (!isRecord3(thread) || thread.id !== input.threadId || typeof thread.cwd !== "string" || !path.isAbsolute(thread.cwd) || !path.isAbsolute(input.cwd) || !sameDirectory(thread.cwd, input.cwd)) {
+    throw new Error("The native Codex session does not match the requested session and directory.");
+  }
+  const model = nativeModel(thread.model) ?? await readRolloutModel(
+    {
+      threadId: input.threadId,
+      cwd: input.cwd,
+      homePath: input.homePath,
+      caseInsensitive: input.caseInsensitive
+    },
+    thread.path,
+    sameDirectory
+  );
+  const messages = [];
+  for (const turn of readThreadTurns(response)) {
+    for (const item of turn.items) {
+      const mapped = itemText(item);
+      if (mapped) {
+        messages.push({
+          ...mapped,
+          ...typeof turn.startedAt === "number" ? { createdAt: turn.startedAt * 1e3 } : {}
+        });
+      }
+    }
+  }
+  return {
+    nativeSessionId: input.threadId,
+    messages,
+    resumeCursor: { threadId: input.threadId },
+    model
+  };
+}
+async function readRolloutModel(input, rolloutPath, sameDirectory) {
+  const path = input.caseInsensitive ? NodePath4.win32 : NodePath4;
+  if (typeof rolloutPath !== "string" || !path.isAbsolute(rolloutPath) || path.extname(rolloutPath).toLowerCase() !== ".jsonl") {
+    return null;
+  }
+  const resolved = path.resolve(rolloutPath);
+  const roots = input.homePath ? [path.join(input.homePath, "sessions"), path.join(input.homePath, "archived_sessions")] : [];
+  if (!roots.some((root) => isWithinDirectory(resolved, path.resolve(root), input.caseInsensitive))) {
+    return null;
+  }
+  let verified = false;
+  let model = null;
+  try {
+    const stream = NodeFS2.createReadStream(resolved, { encoding: "utf8" });
+    const rl = NodeReadline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.includes('"session_meta"') && !line.includes('"turn_context"')) continue;
+      let record;
+      try {
+        record = isRecord3(JSON.parse(line)) ? JSON.parse(line) : null;
+      } catch {
+        continue;
+      }
+      const payload = isRecord3(record?.payload) ? record.payload : null;
+      if (!record || !payload) continue;
+      if (record.type === "session_meta" && !verified) {
+        if ((payload.id ?? payload.session_id) !== input.threadId || typeof payload.cwd !== "string" || !path.isAbsolute(payload.cwd) || !sameDirectory(payload.cwd, input.cwd)) {
+          return null;
+        }
+        verified = true;
+      } else if (record.type === "turn_context" && verified) {
+        model = nativeModel(payload.model) ?? model;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return model;
+}
+
+// src/signIn.ts
+var DEVICE_CODE_URL = /https?:\/\/\S+/;
+var DEVICE_CODE_VALUE = /\b([A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+)\b/;
+var deviceCodeUrl = (output) => DEVICE_CODE_URL.exec(output)?.[0];
+var deviceCodeValue = (output) => DEVICE_CODE_VALUE.exec(output)?.[1];
+async function collectText(stream, into) {
+  const decoder = new TextDecoder();
+  for await (const chunk of stream) {
+    into.text += decoder.decode(chunk, { stream: true });
+  }
+}
+function accountToAuth(account) {
+  switch (account.state) {
+    case "signed-in":
+    case "expired":
+      return {
+        status: "authenticated",
+        ...account.email === void 0 ? {} : { email: account.email }
+      };
+    case "signed-out":
+      return { status: "unauthenticated" };
+    case "unreadable":
+      return { status: "unknown" };
+  }
+}
+async function startCodexSignIn(input) {
+  if (input.recipe.binaryPath.length === 0) {
+    throw new Error("Codex program path is not configured");
+  }
+  const isolatedHome = accountHomeFromLayout(input.layout);
+  const env = nativeLoginSpawnEnv(input.processEnv, isolatedHome);
+  const owner = { bindingId: input.host.bindingId };
+  const tryAppServer = async () => {
+    const handle2 = await input.host.process.spawn({
+      program: input.recipe.binaryPath,
+      args: tokenizeLaunchArgs(input.recipe.launchArgs),
+      owner,
+      env
+    });
+    let completed;
+    const rpc = await createCodexRpcClient(handle2, {
+      onNotification: (notification) => {
+        if (notification.method !== "account/login/completed") return;
+        const params = isRecord3(notification.params) ? notification.params : {};
+        const loginId = asString(params["loginId"]);
+        completed = loginId ? { loginId } : {};
+      },
+      onServerRequest: () => void 0,
+      onStderrLine: () => void 0
+    });
+    try {
+      await rpc.request("initialize", CODEX_INITIALIZE_PARAMS);
+      await rpc.notify("initialized");
+      const started = await rpc.request("account/login/start", { type: "chatgptDeviceCode" });
+      if (!isRecord3(started) || asString(started["type"]) !== "chatgptDeviceCode") {
+        await rpc.close();
+        return void 0;
+      }
+      const userCode2 = asString(started["userCode"]) ?? asString(started["user_code"]) ?? void 0;
+      const verificationUrl2 = asString(started["verificationUrl"]) ?? asString(started["verification_uri"]) ?? asString(started["url"]) ?? void 0;
+      const operationId2 = `codex-login-${Date.now()}`;
+      return {
+        operation: {
+          operationId: operationId2,
+          handle: handle2,
+          close: async () => {
+            void completed;
+            await rpc.close();
+          }
+        },
+        ...userCode2 ? { userCode: userCode2 } : {},
+        ...verificationUrl2 ? { verificationUrl: verificationUrl2 } : {}
+      };
+    } catch {
+      await rpc.close().catch(() => void 0);
+      return void 0;
+    }
+  };
+  const appServer = await tryAppServer();
+  if (appServer) return appServer;
+  const handle = await input.host.process.spawn({
+    program: input.recipe.binaryPath,
+    args: [...codexExecLaunchArgs(input.recipe.launchArgs), ...CODEX_CARD.deviceCodeSignInArgs],
+    owner,
+    env
+  });
+  const stdout = { text: "" };
+  const stderr = { text: "" };
+  void collectText(handle.stdout, stdout);
+  void collectText(handle.stderr, stderr);
+  const deadline = Date.now() + 3e3;
+  while (Date.now() < deadline) {
+    const combined2 = `${stdout.text}
+${stderr.text}`;
+    if (deviceCodeUrl(combined2) && deviceCodeValue(combined2)) break;
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
+  }
+  const combined = `${stdout.text}
+${stderr.text}`;
+  const operationId = `codex-login-${Date.now()}`;
+  const userCode = deviceCodeValue(combined);
+  const verificationUrl = deviceCodeUrl(combined);
+  return {
+    operation: {
+      operationId,
+      handle,
+      close: async () => {
+        try {
+          await handle.closeStdin();
+        } catch {
+        }
+        try {
+          await handle.kill("SIGTERM");
+        } catch {
+        }
+      }
+    },
+    ...userCode ? { userCode } : {},
+    ...verificationUrl ? { verificationUrl } : {}
+  };
+}
+async function verifyCodexSignIn(input) {
+  const home = accountHomeFromLayout(input.layout);
+  const auth = accountToAuth(readCodexAccount(home));
+  if (input.recipe.binaryPath.length === 0) {
+    return {
+      installed: false,
+      version: null,
+      readiness: "error",
+      auth: { status: "unknown" },
+      detail: "Codex program path is not configured"
+    };
+  }
+  const env = nativeLoginSpawnEnv(input.processEnv, home);
+  const handle = await input.host.process.spawn({
+    program: input.recipe.binaryPath,
+    args: tokenizeLaunchArgs(input.recipe.launchArgs),
+    owner: { bindingId: input.host.bindingId },
+    env
+  });
+  const rpc = await createCodexRpcClient(handle, {
+    onNotification: () => void 0,
+    onServerRequest: () => void 0,
+    onStderrLine: () => void 0
+  });
+  try {
+    await rpc.request("initialize", CODEX_INITIALIZE_PARAMS, 15e3);
+    await rpc.notify("initialized");
+    const account = await rpc.request("account/read", { refreshToken: true }, 15e3);
+    const type = isRecord3(account) ? asString(account["type"]) : null;
+    if (type !== "chatgpt") {
+      return {
+        installed: true,
+        version: null,
+        readiness: "unchecked",
+        auth: { status: "unauthenticated" }
+      };
+    }
+    await rpc.request("model/list", {}, 15e3).catch(() => void 0);
+    return {
+      installed: true,
+      version: null,
+      readiness: "ready",
+      auth
+    };
+  } catch {
+    return {
+      installed: true,
+      version: null,
+      readiness: "unchecked",
+      auth: { status: "unknown" }
+    };
+  } finally {
+    await rpc.close().catch(() => void 0);
+  }
+}
+
+// src/textGeneration.ts
+import * as NodeFSP2 from "node:fs/promises";
+import * as NodeOS3 from "node:os";
+import * as NodePath5 from "node:path";
+var CODEX_TIMEOUT_MS = 18e4;
+var EARLIER_CONTENT_TRUNCATION_MARKER = "[Earlier content truncated]\n\n";
+function limitSection(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}
+
+[truncated]`;
+}
+function sanitizeCommitSubject(raw) {
+  const singleLine = raw.trim().split(/\r?\n/g)[0]?.trim() ?? "";
+  const withoutTrailingPeriod = singleLine.replace(/[.]+$/g, "").trim();
+  if (withoutTrailingPeriod.length === 0) return "Update project files";
+  return withoutTrailingPeriod.length <= 72 ? withoutTrailingPeriod : withoutTrailingPeriod.slice(0, 72).trimEnd();
+}
+function sanitizePrTitle(raw) {
+  const singleLine = raw.trim().split(/\r?\n/g)[0]?.trim() ?? "";
+  return singleLine.length > 0 ? singleLine : "Update project changes";
+}
+function unwrapNestedTitleObject(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return raw;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isRecord3(parsed) && typeof parsed.title === "string") return parsed.title;
+  } catch {
+  }
+  return raw;
+}
+function sanitizeThreadTitle(raw) {
+  const normalized = unwrapNestedTitleObject(raw).trim().split(/\r?\n/g)[0]?.trim().replace(/^['"`]+|['"`]+$/g, "").trim().replace(/\s+/g, " ");
+  if (!normalized || normalized.trim().length === 0) return "New thread";
+  if (normalized.length <= 50) return normalized;
+  return `${normalized.slice(0, 47).trimEnd()}...`;
+}
+function sanitizeBranchFragment(raw) {
+  const normalized = raw.trim().toLowerCase().replace(/['"`]/g, "").replace(/^[./\s_-]+|[./\s_-]+$/g, "");
+  const branchFragment = normalized.replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[./_-]+|[./_-]+$/g, "").slice(0, 64).replace(/[./_-]+$/g, "");
+  return branchFragment.length > 0 ? branchFragment : "update";
+}
+function sanitizeFeatureBranchName(raw) {
+  const sanitized = sanitizeBranchFragment(raw);
+  if (sanitized.includes("/")) {
+    return sanitized.startsWith("feature/") ? sanitized : `feature/${sanitized}`;
+  }
+  return `feature/${sanitized}`;
+}
+function policyInstruction(instruction) {
+  const trimmed = instruction?.trim();
+  return trimmed ? ["", "Additional instructions:", limitSection(trimmed, 4e3)] : [];
+}
+function readStringField(record, key) {
+  return asString(record[key]) ?? "";
+}
+function schemaObject(properties, required) {
+  return { type: "object", properties, required, additionalProperties: false };
+}
+var COMMIT_SCHEMA = schemaObject({ subject: { type: "string" }, body: { type: "string" } }, [
+  "subject",
+  "body"
+]);
+var COMMIT_WITH_BRANCH_SCHEMA = schemaObject(
+  { subject: { type: "string" }, body: { type: "string" }, branch: { type: "string" } },
+  ["subject", "body", "branch"]
+);
+var PR_SCHEMA = schemaObject({ title: { type: "string" }, body: { type: "string" } }, [
+  "title",
+  "body"
+]);
+var BRANCH_SCHEMA = schemaObject({ branch: { type: "string" } }, ["branch"]);
+var TITLE_SCHEMA = schemaObject({ title: { type: "string" } }, ["title"]);
+var HANDOVER_SCHEMA = schemaObject({ summary: { type: "string" } }, ["summary"]);
+var INITIAL_THREAD_TITLE_PROMPT = `Generate a title that will help the user recognize this Ycodium thread weeks later.
+Return JSON with exactly one key: title.
+
+Before answering, silently reduce the request to:
+- Subject: What system, feature, or problem is this really about?
+- Outcome: What does the user ultimately want to understand or change?
+- Incidental instructions: What only describes how the agent should do the work?
+
+Title the subject and outcome. Discard incidental instructions.
+
+Editorial rules:
+- 3-8 words, fewer than 40 characters.
+- Use a compact noun phrase or clear action phrase.
+- Capture the umbrella goal when the request lists several symptoms or steps.
+- Name the product change, not the mock, plan, report, branch, or PR used to produce it.
+- Models, subagents, tools, output formats, and monitoring instructions do not belong in the title unless they are themselves the topic.
+- For reviews, name what is being reviewed and the relevant concern. Avoid generic titles such as "Review PR 123" when linked or attached context reveals the subject.
+- For research, name the question domain rather than the requested research process.
+- Do not claim the work is complete.
+- Do not copy and truncate the user's message.
+- Avoid project names already visible in the UI, quotes, labels, filler, and trailing punctuation.
+- Use attached images as primary context for UI issues.
+- When a URL or attachment is the only source of the subject, use available tools to inspect it. If it cannot be resolved, remain accurate rather than guessing.`;
+function regenerateThreadTitlePrompt(previousTitle) {
+  return `Regenerate the title for an existing Ycodium thread so the user can recognize it weeks later.
+The previous title was ${JSON.stringify(previousTitle)}.
+Return JSON with exactly one key: title.
+
+Determine the title in this order:
+1. Read the USER messages first. Identify the latest explicit durable goal. The original subject remains the subject until the user clearly changes what the thread is about.
+2. Use ASSISTANT messages to resolve vague links, unnamed code, and discovered product nouns. Do not promote one assistant finding into the thread subject unless the user adopts it as a new goal.
+3. Compare that subject with the previous title. Preserve accurate scope words, especially when earlier content is truncated. Replace the previous title when it is generic, artifact-based, a completion update, or contradicted by the thread.
+4. Title the durable subject and desired outcome, not the current workflow state.
+
+Editorial rules:
+- 3-8 words, fewer than 40 characters.
+- Use a compact noun phrase or clear action phrase.
+- Preserve the umbrella subject when later messages focus on one finding, provider, platform, or implementation detail.
+- A thread progressing through research, planning, implementation, review, CI, merge, and monitoring has usually not changed subjects.
+- Ignore deliverables and operations such as mocks, plans, HTML, branches, PRs, tests, CI, commits, merging, and monitoring unless they are the actual topic.
+- Models, subagents, tools, output formats, and monitoring instructions do not belong in the title unless they are themselves the topic.
+- Treat final operational follow-ups and assistant completion summaries as weak evidence of subject.
+- For reviews, name the reviewed feature or system and its durable concern, not one finding from the review.
+- For research, name the question domain rather than the research process.
+- Do not claim the work is complete.
+- Do not copy and truncate a thread message.
+- Avoid project names already visible in the UI, PR numbers, quotes, labels, filler, and trailing punctuation.
+- Use attached images as primary context for UI issues.
+- When a URL or attachment is the only source of the subject, use available tools to inspect it. If it cannot be resolved, remain accurate rather than guessing.
+- Return a meaningfully improved title, not a cosmetic paraphrase of the previous title.`;
+}
+function preserveMessageEnd(message) {
+  const alreadyTruncated = message.startsWith(EARLIER_CONTENT_TRUNCATION_MARKER);
+  const contents = alreadyTruncated ? message.slice(EARLIER_CONTENT_TRUNCATION_MARKER.length) : message;
+  if (!alreadyTruncated && contents.length <= 8e3) return contents;
+  return `${EARLIER_CONTENT_TRUNCATION_MARKER}${contents.slice(-8e3)}`;
+}
+function absoluteImagePaths(attachments) {
+  if (!Array.isArray(attachments)) return [];
+  const paths = [];
+  for (const attachment of attachments) {
+    if (!isRecord3(attachment) || attachment.type !== "image") continue;
+    const candidate = asString(attachment.path) ?? asString(attachment.filePath) ?? asString(attachment.savedPath);
+    if (candidate && NodePath5.isAbsolute(candidate)) paths.push(candidate);
+  }
+  return paths;
+}
+async function collectStream(stream) {
+  const decoder = new TextDecoder();
+  let out = "";
+  for await (const chunk of stream) out += decoder.decode(chunk, { stream: true });
+  return out;
+}
+function createCodexTextGeneration(input) {
+  const run = async (operation, cwd, prompt, schema, modelSelection, launch, imagePaths, signal) => {
+    if (input.recipe.binaryPath.length === 0) {
+      throw new Error("Codex CLI is required but not available on PATH.");
+    }
+    const tmp = await NodeFSP2.mkdtemp(NodePath5.join(NodeOS3.tmpdir(), "ycodium-codex-tg-"));
+    const schemaPath = NodePath5.join(tmp, "schema.json");
+    const outputPath = NodePath5.join(tmp, "output.json");
+    await NodeFSP2.writeFile(schemaPath, JSON.stringify(schema));
+    await NodeFSP2.writeFile(outputPath, "");
+    const launchRecord = isRecord3(launch) ? launch : {};
+    const processEnv = isRecord3(launchRecord.processEnv) ? Object.fromEntries(
+      Object.entries(launchRecord.processEnv).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : {};
+    const overlay = Array.isArray(launchRecord.launchArgOverrides) && launchRecord.launchArgOverrides.length > 0 ? encodeCodexConfigOverrides(
+      launchRecord.launchArgOverrides.flatMap((entry) => {
+        if (!isRecord3(entry) || typeof entry.key !== "string") return [];
+        const value = entry.value;
+        if (typeof value !== "string" && typeof value !== "boolean") return [];
+        return [{ key: entry.key, value }];
+      })
+    ) : "";
+    const launchArgs = [input.recipe.launchArgs, overlay].filter((value) => value.length > 0).join(" ");
+    const reasoningEffort = modelSelectionStringOption(modelSelection, "reasoningEffort") ?? DEFAULT_TEXT_GENERATION_REASONING_EFFORT;
+    const serviceTier = modelSelectionStringOption(modelSelection, "serviceTier");
+    const model = asString(launchRecord.requestedModelId) ?? modelIdFromSelection(modelSelection) ?? "gpt-5.6-luna";
+    const env = {
+      ...processEnv,
+      ...input.recipe.environment,
+      ...input.layout.effectiveHomePath ? { CODEX_HOME: input.layout.effectiveHomePath } : input.recipe.homePath.trim() ? { CODEX_HOME: expandHomePath(input.recipe.homePath) } : {}
+    };
+    if (input.recipe.environment[CODEX_INSTANCE_API_KEY_ENV]) {
+      env[CODEX_INSTANCE_API_KEY_ENV] = input.recipe.environment[CODEX_INSTANCE_API_KEY_ENV];
+    }
+    const args = [
+      "exec",
+      ...codexExecLaunchArgs(launchArgs),
+      "--ephemeral",
+      "--skip-git-repo-check",
+      "-s",
+      "read-only",
+      "--model",
+      model,
+      "--config",
+      `model_reasoning_effort="${reasoningEffort}"`,
+      ...serviceTier ? ["--config", `service_tier="${serviceTier}"`] : [],
+      "--output-schema",
+      schemaPath,
+      "--output-last-message",
+      outputPath,
+      ...imagePaths.flatMap((imagePath) => ["--image", imagePath]),
+      "-"
+    ];
+    const handle = await input.host.process.spawn({
+      program: input.recipe.binaryPath,
+      args,
+      cwd,
+      env,
+      owner: { bindingId: input.host.bindingId }
+    });
+    const onAbort = () => {
+      void handle.kill("SIGTERM").catch(() => void 0);
+    };
+    signal?.addEventListener("abort", onAbort);
+    let timer;
+    try {
+      await handle.writeStdin(prompt);
+      await handle.closeStdin();
+      const timedOut = await Promise.race([
+        handle.exited.then(() => false),
+        new Promise((resolve2) => {
+          timer = setTimeout(() => resolve2(true), CODEX_TIMEOUT_MS);
+        })
+      ]);
+      if (timedOut) {
+        await handle.kill("SIGTERM").catch(() => void 0);
+        throw new Error("Codex CLI request timed out.");
+      }
+      const [stdout, stderr, exitCode] = await Promise.all([
+        collectStream(handle.stdout),
+        collectStream(handle.stderr),
+        handle.exited
+      ]);
+      if (exitCode !== 0) {
+        const detail = stderr.trim() || stdout.trim();
+        throw new Error(
+          detail.length > 0 ? `Codex CLI command failed: ${detail}` : `Codex CLI command failed with code ${String(exitCode)}.`
+        );
+      }
+      const raw = await NodeFSP2.readFile(outputPath, "utf8");
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (cause) {
+        throw new Error("Codex returned invalid structured output.", { cause });
+      }
+      if (!isRecord3(parsed)) throw new Error("Codex returned invalid structured output.");
+      return parsed;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      await NodeFSP2.rm(tmp, { recursive: true, force: true }).catch(() => void 0);
+      void operation;
+    }
+  };
+  return {
+    generateCommitMessage: async (raw, signal) => {
+      const inputRecord = isRecord3(raw) ? raw : {};
+      const includeBranch = inputRecord.includeBranch === true;
+      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const prompt = [
+        "You write concise git commit messages.",
+        includeBranch ? "Return a JSON object with keys: subject, body, branch." : "Return a JSON object with keys: subject, body.",
+        "Rules:",
+        "- subject must be imperative, <= 72 chars, and no trailing period",
+        "- body can be empty string or short bullet points",
+        ...includeBranch ? ["- branch must be a short semantic git branch fragment for this change"] : [],
+        "- capture the primary user-visible or developer-visible change",
+        ...policyInstruction(asString(policy.commitInstructions) ?? void 0),
+        "",
+        `Branch: ${asString(inputRecord.branch) ?? "(detached)"}`,
+        "",
+        "Staged files:",
+        limitSection(asString(inputRecord.stagedSummary) ?? "", 6e3),
+        "",
+        "Staged patch:",
+        limitSection(asString(inputRecord.stagedPatch) ?? "", 4e4)
+      ].join("\n");
+      const generated = await run(
+        "generateCommitMessage",
+        asString(inputRecord.cwd) ?? ".",
+        prompt,
+        includeBranch ? COMMIT_WITH_BRANCH_SCHEMA : COMMIT_SCHEMA,
+        inputRecord.modelSelection,
+        inputRecord.launch,
+        [],
+        signal
+      );
+      return {
+        subject: sanitizeCommitSubject(readStringField(generated, "subject")),
+        body: readStringField(generated, "body").trim(),
+        ...typeof generated.branch === "string" ? { branch: sanitizeFeatureBranchName(generated.branch) } : {}
+      };
+    },
+    generatePrContent: async (raw, signal) => {
+      const inputRecord = isRecord3(raw) ? raw : {};
+      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const template = asString(inputRecord.changeRequestTemplate)?.trim();
+      const bodyRules = template ? [
+        "- body must be markdown and follow the repository change request template structure",
+        "- fill in the template sections appropriately for this change",
+        "- drop HTML comments from the template in the generated body",
+        "- keep the template's markdown structure"
+      ] : [
+        "- body must be markdown and include headings '## Summary' and '## Testing'",
+        "- under Summary, provide short bullet points",
+        "- under Testing, include bullet points with concrete checks or 'Not run' where appropriate"
+      ];
+      const prompt = [
+        "You write source control change request content.",
+        "Return a JSON object with keys: title, body.",
+        "Rules:",
+        "- title should be concise and specific",
+        ...bodyRules,
+        ...policyInstruction(asString(policy.changeRequestInstructions) ?? void 0),
+        ...template ? ["", "Repository change request template:", limitSection(template, 8e3)] : [],
+        "",
+        `Base branch: ${asString(inputRecord.baseBranch) ?? ""}`,
+        `Head branch: ${asString(inputRecord.headBranch) ?? ""}`,
+        "",
+        "Commits:",
+        limitSection(asString(inputRecord.commitSummary) ?? "", 12e3),
+        "",
+        "Diff stat:",
+        limitSection(asString(inputRecord.diffSummary) ?? "", 12e3),
+        "",
+        "Diff patch:",
+        limitSection(asString(inputRecord.diffPatch) ?? "", 4e4)
+      ].join("\n");
+      const generated = await run(
+        "generatePrContent",
+        asString(inputRecord.cwd) ?? ".",
+        prompt,
+        PR_SCHEMA,
+        inputRecord.modelSelection,
+        inputRecord.launch,
+        [],
+        signal
+      );
+      return {
+        title: sanitizePrTitle(readStringField(generated, "title")),
+        body: readStringField(generated, "body").trim()
+      };
+    },
+    generateBranchName: async (raw, signal) => {
+      const inputRecord = isRecord3(raw) ? raw : {};
+      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const attachments = Array.isArray(inputRecord.attachments) ? inputRecord.attachments : [];
+      const attachmentLines = attachments.flatMap((attachment) => {
+        if (!isRecord3(attachment)) return [];
+        const name = asString(attachment.name) ?? "attachment";
+        const mime = asString(attachment.mimeType) ?? "application/octet-stream";
+        const size = typeof attachment.sizeBytes === "number" ? attachment.sizeBytes : 0;
+        return [`- ${name} (${mime}, ${size} bytes)`];
+      });
+      const prompt = [
+        "You generate concise git branch names.",
+        "Return a JSON object with key: branch.",
+        "Rules:",
+        "- Branch should describe the requested work from the user message.",
+        "- Keep it short and specific (2-6 words).",
+        "- Use plain words only, no issue prefixes and no punctuation-heavy text.",
+        "- If images are attached, use them as primary context for visual/UI issues.",
+        "",
+        "User message:",
+        limitSection(asString(inputRecord.message) ?? "", 8e3),
+        ...policyInstruction(asString(policy.branchInstructions) ?? void 0),
+        ...attachmentLines.length > 0 ? ["", "Attachment metadata:", limitSection(attachmentLines.join("\n"), 4e3)] : []
+      ].join("\n");
+      const generated = await run(
+        "generateBranchName",
+        asString(inputRecord.cwd) ?? ".",
+        prompt,
+        BRANCH_SCHEMA,
+        inputRecord.modelSelection,
+        inputRecord.launch,
+        absoluteImagePaths(attachments),
+        signal
+      );
+      return { branch: sanitizeBranchFragment(readStringField(generated, "branch")) };
+    },
+    generateThreadTitle: async (raw, signal) => {
+      const inputRecord = isRecord3(raw) ? raw : {};
+      const policy = isRecord3(inputRecord.policy) ? inputRecord.policy : {};
+      const attachments = Array.isArray(inputRecord.attachments) ? inputRecord.attachments : [];
+      const attachmentLines = attachments.flatMap((attachment) => {
+        if (!isRecord3(attachment)) return [];
+        const name = asString(attachment.name) ?? "attachment";
+        const mime = asString(attachment.mimeType) ?? "application/octet-stream";
+        const size = typeof attachment.sizeBytes === "number" ? attachment.sizeBytes : 0;
+        return [`- ${name} (${mime}, ${size} bytes)`];
+      });
+      const extra = [
+        ...policyInstruction(asString(policy.threadTitleInstructions) ?? void 0),
+        ...attachmentLines.length > 0 ? ["", "Attachment metadata:", limitSection(attachmentLines.join("\n"), 4e3)] : []
+      ].join("\n");
+      const previousTitle = asString(inputRecord.previousTitle);
+      const prompt = previousTitle === null ? `${INITIAL_THREAD_TITLE_PROMPT}
+
+User message:
+${limitSection(asString(inputRecord.message) ?? "", 8e3)}${extra ? `
+${extra}` : ""}` : `${regenerateThreadTitlePrompt(previousTitle)}
+
+Thread contents:
+${preserveMessageEnd(asString(inputRecord.message) ?? "")}${extra ? `
+${extra}` : ""}`;
+      const generated = await run(
+        "generateThreadTitle",
+        asString(inputRecord.cwd) ?? ".",
+        prompt,
+        TITLE_SCHEMA,
+        inputRecord.modelSelection,
+        inputRecord.launch,
+        absoluteImagePaths(attachments),
+        signal
+      );
+      return { title: sanitizeThreadTitle(readStringField(generated, "title")) };
+    },
+    summarizeHandover: async (raw, signal) => {
+      const inputRecord = isRecord3(raw) ? raw : {};
+      const prompt = [
+        "You write handover notes so a different coding agent can pick up work already in progress.",
+        "Return a JSON object with exactly one key: summary.",
+        "Rules:",
+        "- summary is markdown, at most 400 words",
+        "- state the goal the user is pursuing, in their terms",
+        "- list what has already been done, including files and commands that matter",
+        "- list what is still open, and any decision the user made that must be respected",
+        "- record constraints, conventions, and failed approaches so they are not retried",
+        "- write for the agent taking over, not for the user; no greeting and no sign-off",
+        "- never invent work that the transcript does not show",
+        "",
+        "Thread transcript (oldest first):",
+        limitSection(asString(inputRecord.transcript) ?? "", 6e4)
+      ].join("\n");
+      const generated = await run(
+        "summarizeHandover",
+        asString(inputRecord.cwd) ?? ".",
+        prompt,
+        HANDOVER_SCHEMA,
+        inputRecord.modelSelection,
+        inputRecord.launch,
+        [],
+        signal
+      );
+      return { summary: readStringField(generated, "summary").trim() };
+    }
+  };
+}
+
+// src/codexInstance.ts
+var yieldTick = () => new Promise((resolve2) => {
+  setImmediate(resolve2);
+});
+var EventBus = class {
+  #queued = [];
+  #waiters = [];
+  #closed = false;
+  push(event) {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter({ done: false, value: event });
+      return;
+    }
+    this.#queued.push(event);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    while (this.#waiters.length > 0) {
+      this.#waiters.shift()?.({ done: true, value: void 0 });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const queued = this.#queued.shift();
+        if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
+        if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
+        return new Promise((resolve2) => {
+          this.#waiters.push(resolve2);
+        });
+      }
+    };
+  }
+};
+function accountToAuth2(account) {
+  switch (account.state) {
+    case "signed-in":
+    case "expired":
+      return {
+        status: "authenticated",
+        ...account.email === void 0 ? {} : { email: account.email }
+      };
+    case "signed-out":
+      return { status: "unauthenticated" };
+    case "unreadable":
+      return { status: "unknown" };
+  }
+}
+function layoutFor(recipe, launchHome) {
+  const environmentHome = recipe.environment["CODEX_HOME"];
+  return resolveCodexHomeLayout({
+    homePath: launchHome?.trim() || recipe.homePath,
+    shadowHomePath: recipe.shadowHomePath,
+    ...environmentHome === void 0 ? {} : { environmentHome }
+  });
+}
+var createCodexInstance = (config, host) => {
+  const recipe = parseCodexInstanceConfig(config);
+  const events = new EventBus();
+  const threads = /* @__PURE__ */ new Map();
+  const signInOperations = /* @__PURE__ */ new Map();
+  const live = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const requireThread = (threadId) => {
+    const booked = threads.get(threadId);
+    if (!booked) throw new Error(`unknown thread ${threadId}`);
+    return booked;
+  };
+  const probeAuth = () => accountToAuth2(readCodexAccount(accountHomeFromLayout(layoutFor(recipe))));
+  const trackHandle = (handle, command, threadId) => {
+    live.set(handle.pid, { command, ...threadId === void 0 ? {} : { threadId } });
+    void handle.exited.finally(() => {
+      live.delete(handle.pid);
+    });
+  };
+  const stopBooked = async (booked) => {
+    await booked.runtime.close().catch(() => void 0);
+  };
+  const instance = {
+    probe: async () => {
+      if (recipe.binaryPath.length === 0) {
+        return {
+          installed: false,
+          version: null,
+          readiness: "error",
+          auth: { status: "unknown" },
+          detail: "Codex program path is not configured"
+        };
+      }
+      const connectionError = codexApiConnectionError(recipe, recipe.environment);
+      if (connectionError) {
+        return {
+          installed: true,
+          version: null,
+          readiness: "error",
+          auth: probeAuth(),
+          detail: connectionError
+        };
+      }
+      return {
+        installed: true,
+        version: null,
+        readiness: "unchecked",
+        auth: probeAuth()
+      };
+    },
+    startSession: async (input, signal) => {
+      if (disposed) throw new Error("instance disposed");
+      if (signal?.aborted) throw new Error("aborted");
+      if (recipe.binaryPath.length === 0) {
+        throw new Error("Codex program path is not configured");
+      }
+      const cwd = input.cwd ?? host.workspacePath(input.threadId);
+      if (cwd.trim() === "") throw new Error("workspace path missing");
+      const existing = threads.get(input.threadId);
+      if (existing !== void 0) {
+        await stopBooked(existing);
+        threads.delete(input.threadId);
+      }
+      const layout = layoutFor(recipe, input.launch.homePath);
+      await materializeCodexShadowHome(layout, host.log);
+      const env = buildCodexSpawnEnv({
+        recipe,
+        layout,
+        processEnv: input.launch.processEnv,
+        crushApiKeys: shouldCrushApiKeys(recipe.authMode)
+      });
+      const args = [...codexSpawnArgs(recipe, layout)];
+      const handle = await host.process.spawn({
+        program: recipe.binaryPath,
+        args,
+        cwd,
+        owner: { bindingId: host.bindingId },
+        ...Object.keys(env).length > 0 ? { env } : {}
+      });
+      trackHandle(handle, [recipe.binaryPath, ...args].join(" "), input.threadId);
+      let runtime;
+      const rpc = await createCodexRpcClient(handle, {
+        onNotification: (notification) => {
+          runtime?.handleNotification(notification.method, notification.params);
+        },
+        onServerRequest: (request) => {
+          void runtime?.handleServerRequest(request.id, request.method, request.params);
+        },
+        onStderrLine: (line) => {
+          runtime?.handleStderrLine(line);
+        },
+        onRequestSettled: (id, status) => {
+          runtime?.settleNativeWrite(id, status);
+        },
+        onExit: () => {
+          if (runtime && !runtime.closed) {
+            void runtime.close().catch(() => void 0);
+          }
+        }
+      });
+      runtime = new CodexSessionRuntime(host, rpc, (event) => events.push(event), input, cwd, args);
+      try {
+        await rpc.request("initialize", CODEX_INITIALIZE_PARAMS);
+        await rpc.notify("initialized");
+        const session = await runtime.openThread(input);
+        await yieldTick();
+        threads.set(input.threadId, { runtime, rpc, handle });
+        host.log.info("session started", {
+          threadId: input.threadId,
+          nativeThreadId: runtime.nativeThreadId
+        });
+        return session;
+      } catch (error) {
+        await runtime.close().catch(() => void 0);
+        throw error;
+      }
+    },
+    sendTurn: async (input, signal) => {
+      if (disposed) throw new Error("instance disposed");
+      const booked = requireThread(input.threadId);
+      if (signal?.aborted) throw new Error("aborted");
+      const onAbort = () => {
+        void booked.runtime.interruptTurn(input.expectedTurnId).catch(() => void 0);
+      };
+      signal?.addEventListener("abort", onAbort);
+      try {
+        return await booked.runtime.sendTurn(input);
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+      }
+    },
+    interruptTurn: async (threadId, turnId) => {
+      const booked = threads.get(threadId);
+      if (booked === void 0) return;
+      host.log.info("interrupt turn", { threadId, turnId });
+      await booked.runtime.interruptTurn(turnId);
+    },
+    respondToRequest: async (threadId, requestId, decision, reason) => {
+      const booked = requireThread(threadId);
+      await booked.runtime.respondToRequest(requestId, decision, reason);
+    },
+    respondToUserInput: async (threadId, requestId, answers) => {
+      const booked = requireThread(threadId);
+      await booked.runtime.respondToUserInput(requestId, answers);
+    },
+    setRuntimeMode: async (threadId, runtimeMode) => {
+      const booked = requireThread(threadId);
+      booked.runtime.runtimeMode = runtimeMode;
+      booked.runtime.session = {
+        ...booked.runtime.session,
+        runtimeMode,
+        updatedAt: nowIso()
+      };
+    },
+    compactContext: async (threadId) => {
+      const booked = requireThread(threadId);
+      await booked.runtime.compactContext();
+    },
+    stopSession: async (threadId) => {
+      const booked = threads.get(threadId);
+      if (booked === void 0) return;
+      threads.delete(threadId);
+      await stopBooked(booked);
+    },
+    readThread: async (threadId) => {
+      const booked = requireThread(threadId);
+      return await booked.runtime.readThread();
+    },
+    uploadFeedback: async (input) => {
+      const booked = requireThread(input.threadId);
+      return await booked.runtime.uploadFeedback(input.reason);
+    },
+    events,
+    dispose: async () => {
+      if (disposed) return;
+      disposed = true;
+      const operations = [...signInOperations.values()];
+      signInOperations.clear();
+      for (const operation of operations) {
+        await operation.close().catch(() => void 0);
+      }
+      const booked = [...threads.values()];
+      threads.clear();
+      await Promise.all(booked.map((entry) => stopBooked(entry)));
+      events.close();
+    },
+    textGeneration: createCodexTextGeneration({
+      host,
+      recipe,
+      layout: layoutFor(recipe)
+    }),
+    sessions: {
+      scan: async (input) => {
+        if (recipe.binaryPath.length === 0) {
+          throw new Error("Codex program path is not configured");
+        }
+        const layout = layoutFor(recipe);
+        const env = buildCodexSpawnEnv({
+          recipe,
+          layout,
+          processEnv: {},
+          crushApiKeys: shouldCrushApiKeys(recipe.authMode)
+        });
+        const args = [...codexSpawnArgs(recipe, layout)];
+        const handle = await host.process.spawn({
+          program: recipe.binaryPath,
+          args,
+          cwd: input.directory ?? host.workspacePath(input.projectId),
+          owner: { bindingId: host.bindingId },
+          ...Object.keys(env).length > 0 ? { env } : {}
+        });
+        trackHandle(handle, [recipe.binaryPath, ...args].join(" "));
+        const rpc = await createCodexRpcClient(handle, {
+          onNotification: () => void 0,
+          onServerRequest: () => void 0,
+          onStderrLine: () => void 0
+        });
+        try {
+          await rpc.request("initialize", CODEX_INITIALIZE_PARAMS);
+          await rpc.notify("initialized");
+          const candidates = await scanCodexSessions({
+            client: rpc,
+            directory: input.directory ?? host.workspacePath(input.projectId),
+            caseInsensitive: NodeProcess.platform === "win32"
+          });
+          return { candidates };
+        } finally {
+          await rpc.close().catch(() => void 0);
+        }
+      },
+      read: async (input) => {
+        if (recipe.binaryPath.length === 0) {
+          throw new Error("Codex program path is not configured");
+        }
+        const layout = layoutFor(recipe);
+        const env = buildCodexSpawnEnv({
+          recipe,
+          layout,
+          processEnv: {},
+          crushApiKeys: shouldCrushApiKeys(recipe.authMode)
+        });
+        const args = [...codexSpawnArgs(recipe, layout)];
+        const handle = await host.process.spawn({
+          program: recipe.binaryPath,
+          args,
+          cwd: input.cwd,
+          owner: { bindingId: host.bindingId },
+          ...Object.keys(env).length > 0 ? { env } : {}
+        });
+        trackHandle(handle, [recipe.binaryPath, ...args].join(" "));
+        const rpc = await createCodexRpcClient(handle, {
+          onNotification: () => void 0,
+          onServerRequest: () => void 0,
+          onStderrLine: () => void 0
+        });
+        try {
+          await rpc.request("initialize", CODEX_INITIALIZE_PARAMS);
+          await rpc.notify("initialized");
+          return await readCodexSession({
+            client: rpc,
+            threadId: input.nativeSessionId,
+            cwd: input.cwd,
+            homePath: accountHomeFromLayout(layout),
+            caseInsensitive: NodeProcess.platform === "win32"
+          });
+        } finally {
+          await rpc.close().catch(() => void 0);
+        }
+      }
+    },
+    signIn: {
+      start: async () => {
+        const started = await startCodexSignIn({
+          host,
+          recipe,
+          layout: layoutFor(recipe),
+          processEnv: process.env
+        });
+        signInOperations.set(started.operation.operationId, started.operation);
+        trackHandle(started.operation.handle, "codex login --device-auth");
+        return {
+          operationId: started.operation.operationId,
+          ...started.userCode === void 0 ? {} : { userCode: started.userCode },
+          ...started.verificationUrl === void 0 ? {} : { verificationUrl: started.verificationUrl }
+        };
+      },
+      cancel: async (operationId) => {
+        const operation = signInOperations.get(operationId);
+        if (operation === void 0) return;
+        signInOperations.delete(operationId);
+        await operation.close().catch(() => void 0);
+      },
+      verify: async () => verifyCodexSignIn({
+        host,
+        recipe,
+        layout: layoutFor(recipe),
+        processEnv: process.env
+      })
+    },
+    listLiveProcesses: async () => [...live.entries()].map(([pid, entry]) => ({
+      pid,
+      command: entry.command,
+      ...entry.threadId === void 0 ? {} : { threadId: entry.threadId },
+      bindingId: host.bindingId
+    })),
+    drain: async (signal) => {
+      const waiters = [...live.keys()].map((pid) => {
+        const booked = [...threads.values()].find((entry) => entry.handle.pid === pid);
+        return booked?.handle.exited ?? Promise.resolve(null);
+      });
+      if (signal.aborted) return;
+      await Promise.race([
+        Promise.all(waiters),
+        new Promise((resolve2) => {
+          const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            resolve2();
+          };
+          signal.addEventListener("abort", onAbort);
+        })
+      ]);
+    },
+    forceStop: async () => {
+      for (const booked of threads.values()) {
+        await booked.handle.kill("SIGKILL").catch(() => void 0);
+      }
+      for (const operation of signInOperations.values()) {
+        await operation.handle.kill("SIGKILL").catch(() => void 0);
+      }
+    }
+  };
+  return instance;
+};
+
+// src/index.ts
+var executors = [
+  {
+    card: CODEX_CARD,
+    createInstance: async (config, host) => {
+      host.log.info("createInstance");
+      return createCodexInstance(config, host);
+    }
+  }
+];
+var index_default = definePlugin({
+  id: "agent-codex",
+  apiVersion: 2,
+  executors,
+  activate(ctx) {
+    ctx.log.info("codex executor ready");
+  }
+});
+export {
+  index_default as default
+};