flockbay 0.10.15

package/dist/runCodex-D3eT-TvB.cjs

@@ -0,0 +1,3449 @@
+'use strict';
+
+var ink = require('ink');
+var React = require('react');
+var types = require('./types-C-jnUdn_.cjs');
+var index_js = require('@modelcontextprotocol/sdk/client/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
+var z = require('zod');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var node_crypto = require('node:crypto');
+var fs = require('node:fs');
+var os = require('node:os');
+var path = require('node:path');
+var node_child_process = require('node:child_process');
+var index = require('./index--o4BPz5o.cjs');
+var flockbayScreenshotGate = require('./flockbayScreenshotGate-DkxU24cR.cjs');
+require('axios');
+require('chalk');
+require('fs');
+require('node:fs/promises');
+require('tweetnacl');
+require('node:events');
+require('socket.io-client');
+require('child_process');
+require('fs/promises');
+require('crypto');
+require('path');
+require('url');
+require('node:process');
+require('os');
+require('node:net');
+require('expo-server-sdk');
+require('node:readline');
+require('node:url');
+require('ps-list');
+require('cross-spawn');
+require('tmp');
+require('qrcode-terminal');
+require('open');
+require('fastify');
+require('fastify-type-provider-zod');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('node:http');
+require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+require('http');
+require('util');
+
+function normalizeRequestedSchema(value) {
+  const unwrap = (obj) => {
+    const candidates = [
+      obj?.schema,
+      obj?.jsonSchema,
+      obj?.json_schema,
+      obj?.requestedSchema,
+      obj?.requested_schema
+    ];
+    for (const c of candidates) {
+      if (c !== void 0) return c;
+    }
+    return obj;
+  };
+  const parseJsonIfString = (v) => {
+    if (typeof v !== "string") return v;
+    try {
+      return JSON.parse(v);
+    } catch {
+      return null;
+    }
+  };
+  const resolveRef = (ref, root2) => {
+    if (!ref.startsWith("#/")) return null;
+    const parts = ref.slice(2).split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let cur = root2;
+    for (const p of parts) {
+      if (!cur || typeof cur !== "object") return null;
+      cur = cur[p];
+    }
+    return cur ?? null;
+  };
+  const isObjectSchemaWithProperties = (s2) => {
+    return s2 && typeof s2 === "object" && s2.type === "object" && s2.properties && typeof s2.properties === "object" && Object.keys(s2.properties).length > 0;
+  };
+  const unionStrings = (a, b) => {
+    const out = /* @__PURE__ */ new Set();
+    const add = (v) => {
+      if (!Array.isArray(v)) return;
+      for (const x of v) if (typeof x === "string") out.add(x);
+    };
+    add(a);
+    add(b);
+    return Array.from(out);
+  };
+  const extract = (schema, root2, depth) => {
+    if (depth > 6) return null;
+    let s2 = parseJsonIfString(schema);
+    if (!s2 || typeof s2 !== "object") return null;
+    s2 = unwrap(s2);
+    if (typeof s2?.$ref === "string") {
+      const resolved = resolveRef(s2.$ref, root2);
+      if (!resolved) return null;
+      return extract(resolved, root2, depth + 1);
+    }
+    if (isObjectSchemaWithProperties(s2)) return s2;
+    const oneOf = Array.isArray(s2.oneOf) ? s2.oneOf : [];
+    const anyOf = Array.isArray(s2.anyOf) ? s2.anyOf : [];
+    const allOf = Array.isArray(s2.allOf) ? s2.allOf : [];
+    for (const child of oneOf) {
+      const found = extract(child, root2, depth + 1);
+      if (found) return found;
+    }
+    for (const child of anyOf) {
+      const found = extract(child, root2, depth + 1);
+      if (found) return found;
+    }
+    if (allOf.length > 0) {
+      const merged = { type: "object", properties: {}, required: [] };
+      let saw = false;
+      for (const child of allOf) {
+        const found = extract(child, root2, depth + 1);
+        if (!found || typeof found !== "object") continue;
+        if (found.type !== "object" || !found.properties || typeof found.properties !== "object") continue;
+        Object.assign(merged.properties, found.properties);
+        merged.required = unionStrings(merged.required, found.required);
+        saw = saw || Object.keys(found.properties).length > 0;
+      }
+      if (saw && Object.keys(merged.properties).length > 0) return merged;
+    }
+    if (s2?.type === "object" && s2.properties && typeof s2.properties === "object") return s2;
+    return null;
+  };
+  let root = parseJsonIfString(value);
+  if (!root || typeof root !== "object") return null;
+  root = unwrap(root);
+  const s = extract(root, root, 0);
+  if (!s || typeof s !== "object") return null;
+  if (s.type !== "object") return null;
+  if (!s.properties || typeof s.properties !== "object") return null;
+  const required = Array.isArray(s.required) ? s.required.filter((k) => typeof k === "string") : void 0;
+  return { type: "object", properties: s.properties, required };
+}
+function summarizeRequestedSchemaForLogs(requestedSchemaRaw) {
+  const schema = normalizeRequestedSchema(requestedSchemaRaw);
+  if (!schema) return { ok: false, propertyCount: 0, properties: [], required: [] };
+  const properties = Object.keys(schema.properties || {});
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  return { ok: true, propertyCount: properties.length, properties, required };
+}
+function buildAskUserQuestionPromptFromRequestedSchema(requestedSchemaRaw, message) {
+  const schema = normalizeRequestedSchema(requestedSchemaRaw);
+  if (!schema) return null;
+  const questions = [];
+  const keys = Object.keys(schema.properties || {});
+  if (keys.length === 0) return null;
+  for (const key of keys) {
+    const prop = schema.properties[key];
+    if (!prop || typeof prop !== "object") return null;
+    if (prop.type === "string") {
+      const options = Array.isArray(prop.enum) ? prop.enum.filter((v) => typeof v === "string" && v.length > 0) : [];
+      if (options.length === 0) return null;
+      const enumDescriptions = Array.isArray(prop.enumDescriptions) ? prop.enumDescriptions.filter((v) => typeof v === "string") : Array.isArray(prop["x-enumDescriptions"]) ? prop["x-enumDescriptions"].filter((v) => typeof v === "string") : [];
+      questions.push({
+        key,
+        header: typeof prop.title === "string" && prop.title.trim().length > 0 ? String(prop.title).trim() : key,
+        question: typeof prop.description === "string" && prop.description.trim().length > 0 ? String(prop.description).trim() : typeof message === "string" && message.trim().length > 0 ? message.trim() : key,
+        options: options.map((label, idx) => ({
+          label,
+          description: typeof enumDescriptions[idx] === "string" ? String(enumDescriptions[idx]) : ""
+        })),
+        multiSelect: false
+      });
+      continue;
+    }
+    if (prop.type === "array") {
+      const items = prop.items;
+      if (!items || typeof items !== "object" || items.type !== "string") return null;
+      const options = Array.isArray(items.enum) ? items.enum.filter((v) => typeof v === "string" && v.length > 0) : [];
+      if (options.length === 0) return null;
+      const enumDescriptions = Array.isArray(items.enumDescriptions) ? items.enumDescriptions.filter((v) => typeof v === "string") : Array.isArray(items["x-enumDescriptions"]) ? items["x-enumDescriptions"].filter((v) => typeof v === "string") : [];
+      questions.push({
+        key,
+        header: typeof prop.title === "string" && prop.title.trim().length > 0 ? String(prop.title).trim() : key,
+        question: typeof prop.description === "string" && prop.description.trim().length > 0 ? String(prop.description).trim() : typeof message === "string" && message.trim().length > 0 ? message.trim() : key,
+        options: options.map((label, idx) => ({
+          label,
+          description: typeof enumDescriptions[idx] === "string" ? String(enumDescriptions[idx]) : ""
+        })),
+        multiSelect: true
+      });
+      continue;
+    }
+    return null;
+  }
+  if (questions.length === 0) return null;
+  return { questions };
+}
+function pickEnumValue(options, preferred) {
+  if (!options || options.length === 0) return void 0;
+  for (const want of preferred) {
+    const found = options.find((v) => typeof v === "string" && v.toLowerCase() === want.toLowerCase());
+    if (found) return found;
+  }
+  return options[0];
+}
+function looksPositive(value) {
+  const v = value.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "y" || v === "allow" || v === "accept" || v === "approved" || v === "approve" || v === "ok";
+}
+function looksNegative(value) {
+  const v = value.trim().toLowerCase();
+  return v === "0" || v === "false" || v === "no" || v === "n" || v === "deny" || v === "denied" || v === "decline" || v === "reject" || v === "abort" || v === "cancel";
+}
+function guessValue(key, schema, allow) {
+  const k = key.toLowerCase();
+  switch (schema.type) {
+    case "boolean":
+      return allow;
+    case "number":
+      return allow ? 1 : 0;
+    case "array":
+      return [];
+    case "string": {
+      const enumVal = pickEnumValue(
+        schema.enum,
+        allow ? ["allow", "approve", "approved", "accept", "yes", "true", "y"] : ["deny", "denied", "decline", "no", "false", "n"]
+      );
+      if (enumVal) return enumVal;
+      if (schema.enum && schema.enum.length > 0) {
+        const values = schema.enum.filter((v) => typeof v === "string");
+        if (allow) {
+          const positive = values.find(looksPositive);
+          if (positive) return positive;
+          const nonNegative = values.find((v) => !looksNegative(v));
+          if (nonNegative) return nonNegative;
+        } else {
+          const negative = values.find(looksNegative);
+          if (negative) return negative;
+          const nonPositive = values.find((v) => !looksPositive(v));
+          if (nonPositive) return nonPositive;
+        }
+        return values[0] ?? (allow ? "yes" : "no");
+      }
+      if (k.includes("decision")) return allow ? "approved" : "denied";
+      if (k.includes("action")) return allow ? "accept" : "decline";
+      if (k.includes("allow") || k.includes("approve") || k.includes("confirm")) return allow ? "true" : "false";
+      return allow ? "yes" : "no";
+    }
+  }
+}
+function buildMcpElicitationResult(decision, requestedSchemaRaw, options) {
+  const allow = decision === "approved" || decision === "approved_for_session";
+  const action = "accept";
+  const codexDecision = allow ? decision === "approved_for_session" ? "approved_for_session" : "approved" : "denied";
+  const formatDeniedReasonForModel = (value) => {
+    const raw = value.trim();
+    if (!raw) return "";
+    if (/^Blocked\b/.test(raw)) return raw;
+    if (raw === "ledger_read_required") {
+      return "Blocked by policy (automatic; not the user): read the ledger before making file edits. Next: call mcp__flockbay__ledger_read, then retry the edit.";
+    }
+    if (raw === "docs_index_read_required") {
+      return "Blocked by policy (automatic; not the user): read the game Documentation index before making edits. Next: call mcp__flockbay__docs_index_read, then retry the edit.";
+    }
+    if (raw.startsWith("file_claim_required:")) {
+      const withoutPrefix = raw.slice("file_claim_required:".length);
+      const file = withoutPrefix.split("(")[0]?.trim() || "the file";
+      return `Blocked by policy (automatic; not the user): claim ${file} before editing it. Next: claim the file via mcp__flockbay__ledger_claim (or mcp__flockbay__coordination_claim_files), then retry the edit.`;
+    }
+    if (raw === "read_only_mode") {
+      return "Blocked by policy (automatic; not the user): this session is in read-only mode. Next: switch permission mode to allow edits, then retry.";
+    }
+    return `Blocked: ${raw}`;
+  };
+  const deniedReasonRaw = typeof options?.deniedReason === "string" ? options.deniedReason : "";
+  const deniedReason = !allow ? formatDeniedReasonForModel(deniedReasonRaw) : "";
+  const requestedSchema = normalizeRequestedSchema(requestedSchemaRaw);
+  if (!requestedSchema) {
+    if (!allow && deniedReason) {
+      return { action, decision: codexDecision, content: { reason: deniedReason } };
+    }
+    return { action, decision: codexDecision };
+  }
+  const keys = Object.keys(requestedSchema.properties || {});
+  const required = Array.isArray(requestedSchema.required) ? requestedSchema.required : [];
+  const content = {};
+  const provided = options?.content && typeof options.content === "object" ? options.content : null;
+  if (provided) {
+    for (const [k, v] of Object.entries(provided)) {
+      content[k] = v;
+    }
+  }
+  for (const key of required) {
+    if (key in content) continue;
+    const schema = requestedSchema.properties?.[key];
+    if (!schema) continue;
+    content[key] = guessValue(key, schema, allow);
+  }
+  for (const key of keys) {
+    if (key in content) continue;
+    const schema = requestedSchema.properties?.[key];
+    if (!schema) continue;
+    content[key] = guessValue(key, schema, allow);
+  }
+  if (!allow && deniedReason) {
+    const isFreeformString = (schema) => {
+      return Boolean(schema && schema.type === "string" && (!("enum" in schema) || !schema.enum || schema.enum.length === 0));
+    };
+    let didSet = false;
+    for (const key of keys) {
+      const schema = requestedSchema.properties?.[key];
+      if (!isFreeformString(schema)) continue;
+      const lower = key.toLowerCase();
+      if (lower.includes("reason") || lower.includes("error") || lower.includes("message") || lower.includes("detail") || lower.includes("explain") || lower.includes("why")) {
+        content[key] = deniedReason;
+        didSet = true;
+      }
+    }
+    if (!didSet) {
+      const fallbackKey = keys.find((k) => isFreeformString(requestedSchema.properties?.[k]));
+      if (fallbackKey) {
+        content[fallbackKey] = deniedReason;
+        didSet = true;
+      }
+    }
+    if (!didSet) {
+      content.reason = deniedReason;
+    }
+  }
+  if (decision === "approved_for_session") {
+    for (const key of keys) {
+      const schema = requestedSchema.properties?.[key];
+      if (!schema || schema.type !== "boolean") continue;
+      const lower = key.toLowerCase();
+      if (lower.includes("remember") || lower.includes("persist") || lower.includes("session") || lower.includes("always") || lower.includes("dontask") || lower.includes("dont_ask") || lower.includes("skip")) {
+        content[key] = true;
+      }
+    }
+  }
+  if (Object.keys(content).length === 0) return { action, decision: codexDecision };
+  return { action, content, decision: codexDecision };
+}
+
+const DEFAULT_TIMEOUT = 14 * 24 * 60 * 60 * 1e3;
+function getCodexMcpCommand() {
+  try {
+    const codexBin = resolveCodexBin();
+    const versionRes = node_child_process.spawnSync(codexBin, ["--version"], {
+      encoding: "utf8",
+      env: buildCodexSpawnEnv(codexBin),
+      timeout: 4e3
+    });
+    const version = String(versionRes.stdout || "").trim();
+    if (versionRes.status !== 0 || !version) {
+      return "mcp-server";
+    }
+    const match = version.match(/codex-cli\s+(\d+\.\d+\.\d+(?:-alpha\.\d+)?)/);
+    if (!match) return "mcp-server";
+    const versionStr = match[1];
+    const [major, minor, patch] = versionStr.split(/[-.]/).map(Number);
+    if (major > 0 || minor > 43) return "mcp-server";
+    if (minor === 43 && patch === 0) {
+      if (versionStr.includes("-alpha.")) {
+        const alphaNum = parseInt(versionStr.split("-alpha.")[1]);
+        return alphaNum >= 5 ? "mcp-server" : "mcp";
+      }
+      return "mcp-server";
+    }
+    return "mcp";
+  } catch (error) {
+    types.logger.debug("[CodexMCP] Error detecting codex version, defaulting to mcp-server:", error);
+    return "mcp-server";
+  }
+}
+function buildCodexSpawnEnv(codexBin) {
+  const env = Object.keys(process.env).reduce((acc, key) => {
+    const value = process.env[key];
+    if (typeof value === "string") acc[key] = value;
+    return acc;
+  }, {});
+  const existingPath = env.PATH || "";
+  const existingParts = existingPath.split(":").filter(Boolean);
+  const prepend = [];
+  const add = (p) => {
+    if (!p) return;
+    if (!prepend.includes(p) && !existingParts.includes(p)) prepend.push(p);
+  };
+  if (codexBin && codexBin.includes("/")) {
+    add(path.dirname(codexBin));
+  }
+  add(path.dirname(process.execPath));
+  add("/opt/homebrew/bin");
+  add("/usr/local/bin");
+  add("/usr/bin");
+  add("/bin");
+  add("/usr/sbin");
+  add("/sbin");
+  env.PATH = [...prepend, ...existingParts].join(":");
+  return env;
+}
+function resolveCodexBin() {
+  const explicit = String(process.env.FLOCKBAY_CODEX_BIN || "").trim();
+  if (explicit) return explicit;
+  const existsExecutable = (p) => {
+    try {
+      fs.accessSync(p, fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const candidates = [
+    path.join(os.homedir(), ".nvm", "versions", "node", "current", "bin", "codex"),
+    path.join(os.homedir(), ".local", "bin", "codex"),
+    "/opt/homebrew/bin/codex",
+    "/usr/local/bin/codex"
+  ];
+  for (const c of candidates) {
+    if (c && existsExecutable(c)) return c;
+  }
+  try {
+    const nvmRoot = path.join(os.homedir(), ".nvm", "versions", "node");
+    const versions = fs.readdirSync(nvmRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => name.startsWith("v"));
+    const parse = (v) => {
+      const m = v.match(/^v(\d+)\.(\d+)\.(\d+)/);
+      if (!m) return null;
+      return [Number(m[1]), Number(m[2]), Number(m[3])];
+    };
+    versions.sort((a, b) => {
+      const pa = parse(a);
+      const pb = parse(b);
+      if (!pa || !pb) return a.localeCompare(b);
+      if (pa[0] !== pb[0]) return pb[0] - pa[0];
+      if (pa[1] !== pb[1]) return pb[1] - pa[1];
+      return pb[2] - pa[2];
+    });
+    for (const v of versions) {
+      const p = path.join(nvmRoot, v, "bin", "codex");
+      if (existsExecutable(p)) return p;
+    }
+  } catch {
+  }
+  const tryShell = (shellPath, args) => {
+    try {
+      const res = node_child_process.spawnSync(shellPath, args, {
+        encoding: "utf8",
+        env: process.env,
+        timeout: 4e3
+      });
+      const out = String(res.stdout || "").trim();
+      if (res.status === 0 && out) return out.split("\n")[0].trim();
+    } catch {
+    }
+    return null;
+  };
+  const fromZsh = tryShell("/bin/zsh", ["-lc", "command -v codex"]);
+  if (fromZsh) return fromZsh;
+  const fromBash = tryShell("/bin/bash", ["-lc", "command -v codex"]);
+  if (fromBash) return fromBash;
+  return "codex";
+}
+function normalizeRelativePath(input) {
+  const raw = typeof input === "string" ? input.trim() : String(input ?? "").trim();
+  if (!raw) return null;
+  let candidate = raw.replace(/^['"`]+/, "").replace(/['"`]+$/, "");
+  if (!candidate) return null;
+  candidate = candidate.replace(/\\/g, "/");
+  try {
+    if (path.isAbsolute(candidate)) {
+      const rel = path.relative(process.cwd(), candidate).replace(/\\/g, "/");
+      candidate = rel;
+    }
+  } catch {
+  }
+  candidate = candidate.replace(/^\.\/+/, "").replace(/^\/+/, "");
+  if (!candidate) return null;
+  if (candidate.includes("..")) return null;
+  return candidate;
+}
+function extractLikelyFilePathsFromMessage(message) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (v) => {
+    const norm = normalizeRelativePath(v);
+    if (!norm) return;
+    if (!norm.includes("/")) return;
+    if (norm.includes(" ")) return;
+    if (norm.startsWith("http://") || norm.startsWith("https://")) return;
+    if (seen.has(norm)) return;
+    seen.add(norm);
+    out.push(norm);
+  };
+  for (const m of message.matchAll(/`([^`]+)`/g)) {
+    push(m[1]);
+  }
+  for (const m of message.matchAll(/(?:^|\s)([./~A-Za-z0-9_-][A-Za-z0-9_./~ -]*\/[A-Za-z0-9_./~-]+)(?=\s|$)/g)) {
+    push(m[1]);
+  }
+  return out;
+}
+function inferElicitationToolName(params, requestedSchemaRaw) {
+  const extractCommandFromMessage = (message2) => {
+    const text = String(message2 || "");
+    if (!text.trim()) return [];
+    const firstNonEmptyLine = (value) => {
+      for (const raw of value.split(/\r?\n/)) {
+        const line = raw.trimEnd();
+        if (line.trim()) return line;
+      }
+      return null;
+    };
+    const fence = text.match(/```(?:bash|sh|zsh)?\s*\n([\s\S]*?)```/i);
+    if (fence?.[1]) {
+      const line = firstNonEmptyLine(fence[1]);
+      if (line) return [line.replace(/^\$\s+/, "").trim()];
+    }
+    const tick = text.match(/`([^`]+)`/);
+    if (tick?.[1]) {
+      const cmd = tick[1].trim();
+      if (cmd) return [cmd];
+    }
+    const dollar = text.match(/(?:^|\n)\$\s+([^\n]+)/);
+    if (dollar?.[1]) {
+      const cmd = dollar[1].trim();
+      if (cmd) return [cmd];
+    }
+    const section = text.match(/(?:^|\n)Command:\s*\n+([^\n]+)/i);
+    if (section?.[1]) {
+      const cmd = section[1].trim();
+      if (cmd) return [cmd];
+    }
+    return [];
+  };
+  const asStringArray = (value) => {
+    if (Array.isArray(value)) {
+      const out = value.map((v) => typeof v === "string" ? v.trim() : "").filter((v) => v.length > 0);
+      return out.length > 0 ? out : void 0;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      return trimmed.length > 0 ? [trimmed] : void 0;
+    }
+    return void 0;
+  };
+  const extractCommandFromParams = (root) => {
+    const candidates = [
+      root?.codex_command,
+      root?.command,
+      root?.cmd,
+      root?.args,
+      root?.argv,
+      root?.input?.codex_command,
+      root?.input?.command,
+      root?.input?.cmd,
+      root?.input?.args,
+      root?.input?.argv,
+      root?.arguments?.codex_command,
+      root?.arguments?.command,
+      root?.arguments?.cmd,
+      root?.arguments?.args,
+      root?.arguments?.argv,
+      root?.tool?.command,
+      root?.tool?.cmd,
+      root?.tool?.args,
+      root?.tool?.input?.command,
+      root?.tool?.input?.cmd,
+      root?.tool?.input?.args,
+      root?.request?.command,
+      root?.request?.cmd,
+      root?.request?.args,
+      root?.command?.command,
+      root?.command?.cmd,
+      root?.command?.args,
+      root?.exec?.command,
+      root?.exec?.cmd,
+      root?.exec?.args
+    ];
+    for (const candidate of candidates) {
+      const arr = asStringArray(candidate);
+      if (arr) return arr;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (value, depth) => {
+      if (depth > 5) return null;
+      if (!value || typeof value !== "object") return null;
+      if (seen.has(value)) return null;
+      seen.add(value);
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          const found = visit(v, depth + 1);
+          if (found?.length) return found;
+        }
+        return null;
+      }
+      const obj = value;
+      for (const key of Object.keys(obj)) {
+        const lower = key.toLowerCase();
+        if (lower === "command" || lower === "cmd" || lower === "args" || lower === "argv" || lower === "codex_command") {
+          const arr = asStringArray(obj[key]);
+          if (arr) return arr;
+        }
+      }
+      for (const key of Object.keys(obj)) {
+        const found = visit(obj[key], depth + 1);
+        if (found?.length) return found;
+      }
+      return null;
+    };
+    return visit(root, 0) ?? [];
+  };
+  const extractedCmd = extractCommandFromParams(params);
+  if (extractedCmd.length > 0) return "CodexBash";
+  const message = typeof params?.message === "string" ? params.message : "";
+  const cmdFromMessage = message ? extractCommandFromMessage(message) : [];
+  if (cmdFromMessage.length > 0) return "CodexBash";
+  if (Array.isArray(params?.files) || params?.changes || params?.patch || params?.diff) return "CodexPatch";
+  const schemaSummary = summarizeRequestedSchemaForLogs(requestedSchemaRaw);
+  const schemaKeys = schemaSummary.ok ? schemaSummary.properties.map((k) => k.toLowerCase()) : [];
+  const patchySchemaKeys = /* @__PURE__ */ new Set([
+    "changes",
+    "files",
+    "patch",
+    "diff",
+    "unified_diff"
+  ]);
+  if (schemaKeys.some((k) => patchySchemaKeys.has(k))) return "CodexPatch";
+  return "CodexBash";
+}
+class CodexMcpClient {
+  client;
+  transport = null;
+  connected = false;
+  sessionId = null;
+  conversationId = null;
+  handler = null;
+  permissionHandler = null;
+  authSnapshot = null;
+  reconnectPromise = null;
+  latestUnifiedDiff = null;
+  latestPatchApplyBegin = null;
+  latestExecApproval = null;
+  constructor() {
+    this.client = this.createClient();
+  }
+  createClient() {
+    const client = new index_js.Client(
+      { name: "flockbay-codex-client", version: "1.0.0" },
+      { capabilities: { elicitation: {} } }
+    );
+    client.setNotificationHandler(z.z.object({
+      method: z.z.literal("codex/event"),
+      params: z.z.object({
+        msg: z.z.any()
+      })
+    }).passthrough(), (data) => {
+      const msg = data.params.msg;
+      this.updateIdentifiersFromEvent(msg);
+      this.captureLatestDiff(msg);
+      this.handler?.(msg);
+    });
+    return client;
+  }
+  captureLatestDiff(event) {
+    try {
+      if (!event || typeof event !== "object") return;
+      const type = typeof event.type === "string" ? event.type : "";
+      const now = Date.now();
+      if (type === "turn_diff") {
+        const diff = typeof event.unified_diff === "string" ? String(event.unified_diff) : "";
+        if (!diff.trim()) return;
+        this.latestUnifiedDiff = { diff, updatedAt: now };
+        return;
+      }
+      if (type === "patch_apply_begin") {
+        const changes = event.changes;
+        if (!changes || typeof changes !== "object") return;
+        this.latestPatchApplyBegin = { changes, updatedAt: now };
+        return;
+      }
+      if (type === "exec_approval_request" || type === "exec_command_begin") {
+        const cmd = typeof event.command === "string" ? String(event.command).trim() : "";
+        if (!cmd) return;
+        const cwd = typeof event.cwd === "string" ? String(event.cwd).trim() : void 0;
+        this.latestExecApproval = { command: cmd, cwd, updatedAt: now };
+        return;
+      }
+    } catch {
+    }
+  }
+  getCodexAuthSnapshot() {
+    const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    const authFilePath = path.join(codexHome, "auth.json");
+    let mtimeMs = null;
+    let size = null;
+    let accountId = null;
+    try {
+      const stat = fs.statSync(authFilePath);
+      mtimeMs = Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : null;
+      size = Number.isFinite(stat.size) ? stat.size : null;
+    } catch {
+      return { authFilePath, mtimeMs, size, accountId };
+    }
+    try {
+      const raw = fs.readFileSync(authFilePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const candidate = parsed?.tokens?.account_id ?? parsed?.tokens?.accountId ?? parsed?.account_id ?? parsed?.accountId;
+      accountId = typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : null;
+    } catch {
+    }
+    return { authFilePath, mtimeMs, size, accountId };
+  }
+  didAuthChange(prev, next) {
+    if (!prev) return false;
+    if (prev.authFilePath !== next.authFilePath) return true;
+    if (prev.mtimeMs !== next.mtimeMs) return true;
+    if (prev.size !== next.size) return true;
+    if (prev.accountId && next.accountId && prev.accountId !== next.accountId) return true;
+    return false;
+  }
+  async reconnectForAuthChange(context) {
+    if (this.reconnectPromise) {
+      await this.reconnectPromise;
+      return;
+    }
+    this.reconnectPromise = (async () => {
+      types.logger.debug("[CodexMCP] Reconnecting to pick up Codex auth changes", {
+        context,
+        authFilePath: this.authSnapshot?.authFilePath,
+        prevAccountId: this.authSnapshot?.accountId
+      });
+      await this.disconnect();
+      this.client = this.createClient();
+      await this.connect();
+    })();
+    try {
+      await this.reconnectPromise;
+    } finally {
+      this.reconnectPromise = null;
+    }
+  }
+  getToolErrorMessage(response) {
+    if (!response || typeof response !== "object") {
+      return "Invalid tool response";
+    }
+    const asAny = response;
+    if (typeof asAny.error === "string" && asAny.error.trim().length > 0) {
+      try {
+        const parsed = JSON.parse(asAny.error);
+        if (parsed && typeof parsed === "object" && typeof parsed.detail === "string" && parsed.detail.trim().length > 0) {
+          return parsed.detail;
+        }
+      } catch {
+      }
+      return asAny.error;
+    }
+    if (asAny.isError === true) {
+      const content = Array.isArray(asAny.content) ? asAny.content : [];
+      const text = content.map((item) => item?.type === "text" ? item?.text : void 0).filter((v) => typeof v === "string" && v.trim().length > 0).join("\n");
+      return text || "Tool returned an error";
+    }
+    return null;
+  }
+  assertToolSuccess(response, context) {
+    const errorMessage = this.getToolErrorMessage(response);
+    if (!errorMessage) {
+      return;
+    }
+    const withHint = this.addUsageLimitHint(errorMessage);
+    throw new Error(`${context}: ${withHint}`);
+  }
+  addUsageLimitHint(message) {
+    if (!/hit your usage limit/i.test(message)) {
+      return message;
+    }
+    return [
+      message.trimEnd(),
+      "",
+      "Tip: If you have another ChatGPT account with Codex usage, re-run `flockbay connect codex` and sign into that account."
+    ].join("\n");
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  /**
+   * Set the permission handler for tool approval
+   */
+  setPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  async connect() {
+    if (this.connected) return;
+    const mcpCommand = getCodexMcpCommand();
+    const codexBin = resolveCodexBin();
+    types.logger.debug(`[CodexMCP] Connecting to Codex MCP server using command: ${codexBin} ${mcpCommand}`);
+    const env = buildCodexSpawnEnv(codexBin);
+    this.transport = new stdio_js.StdioClientTransport({
+      command: codexBin,
+      args: [mcpCommand],
+      env
+    });
+    this.registerPermissionHandlers();
+    const connectTimeoutMsRaw = String(process.env.FLOCKBAY_CODEX_CONNECT_TIMEOUT_MS || "").trim();
+    const connectTimeoutMs = Math.max(
+      1e3,
+      Number.isFinite(Number(connectTimeoutMsRaw)) && Number(connectTimeoutMsRaw) > 0 ? Number(connectTimeoutMsRaw) : 2e4
+    );
+    try {
+      const connectPromise = this.client.connect(this.transport);
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(
+            new Error(
+              `Timed out connecting to Codex MCP server after ${connectTimeoutMs}ms. This usually means the \`codex\` process failed to start (PATH) or is waiting for login/auth.`
+            )
+          );
+        }, connectTimeoutMs);
+        timer.unref?.();
+        connectPromise.then(() => resolve()).catch(reject).finally(() => clearTimeout(timer));
+      });
+    } catch (error) {
+      try {
+        await this.transport?.close?.();
+      } catch {
+      }
+      this.transport = null;
+      throw error;
+    }
+    this.connected = true;
+    this.authSnapshot = this.getCodexAuthSnapshot();
+    types.logger.debug("[CodexMCP] Connected to Codex");
+  }
+  registerPermissionHandlers() {
+    this.client.setRequestHandler(
+      types_js.ElicitRequestSchema,
+      async (request) => {
+        const params = request.params || {};
+        const requestedSchemaRaw = params?.requestedSchema ?? request.params?.requestedSchema;
+        types.logger.debug("[CodexMCP] Received elicitation request", {
+          paramKeys: Object.keys(params || {}),
+          hasRequestedSchema: !!params?.requestedSchema,
+          messagePreview: typeof params?.message === "string" ? params.message.slice(0, 160) : void 0,
+          requestedSchema: summarizeRequestedSchemaForLogs(requestedSchemaRaw)
+        });
+        const asNonEmptyString = (value) => {
+          return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+        };
+        const asStringArray = (value) => {
+          if (Array.isArray(value)) {
+            const out = value.map((v) => typeof v === "string" ? v.trim() : "").filter((v) => v.length > 0);
+            return out.length > 0 ? out : void 0;
+          }
+          if (typeof value === "string" && value.trim().length > 0) return [value.trim()];
+          return void 0;
+        };
+        const uniq = (values) => {
+          const out = [];
+          const seen = /* @__PURE__ */ new Set();
+          for (const v of values) {
+            const s = asNonEmptyString(v);
+            if (!s) continue;
+            if (seen.has(s)) continue;
+            seen.add(s);
+            out.push(s);
+          }
+          return out;
+        };
+        if (!this.permissionHandler) {
+          types.logger.debug("[CodexMCP] No permission handler set, denying by default");
+          return {
+            action: "decline"
+          };
+        }
+        try {
+          const extractPathsFromUnifiedDiff = (diffText) => {
+            const out = [];
+            const seen = /* @__PURE__ */ new Set();
+            const push = (raw) => {
+              if (typeof raw !== "string") return;
+              let s = raw.trim();
+              if (!s) return;
+              s = s.replace(/^a\//, "").replace(/^b\//, "");
+              if (s === "/dev/null") return;
+              if (s.startsWith("/")) return;
+              if (seen.has(s)) return;
+              seen.add(s);
+              out.push(s);
+            };
+            for (const m of diffText.matchAll(/^diff --git a\/(.+?) b\/(.+?)$/gm)) {
+              push(m[1]);
+              push(m[2]);
+            }
+            for (const m of diffText.matchAll(/^\+\+\+\s+b\/(.+)$/gm)) push(m[1]);
+            for (const m of diffText.matchAll(/^---\s+a\/(.+)$/gm)) push(m[1]);
+            return out;
+          };
+          const candidateIds = uniq([
+            params.codex_mcp_tool_call_id,
+            params.codexMcpToolCallId,
+            params.mcp_tool_call_id,
+            params.mcpToolCallId,
+            params.tool_call_id,
+            params.toolCallId,
+            params.codex_call_id,
+            params.codexCallId,
+            params.call_id,
+            params.callId,
+            params.id,
+            params.requestId,
+            params.codex_event_id,
+            params.codexEventId,
+            params.event_id,
+            params.eventId,
+            request?.id
+          ]);
+          const primaryId = candidateIds[0] ?? node_crypto.randomUUID();
+          const aliases = candidateIds.filter((id) => id !== primaryId);
+          const extractCommandFromMessage = (message2) => {
+            const text = String(message2 || "");
+            if (!text.trim()) return [];
+            const firstNonEmptyLine = (value) => {
+              for (const raw of value.split(/\r?\n/)) {
+                const line = raw.trimEnd();
+                if (line.trim()) return line;
+              }
+              return null;
+            };
+            const fence = text.match(/```(?:bash|sh|zsh)?\s*\n([\s\S]*?)```/i);
+            if (fence?.[1]) {
+              const line = firstNonEmptyLine(fence[1]);
+              if (line) return [line.replace(/^\$\s+/, "").trim()];
+            }
+            const tick = text.match(/`([^`]+)`/);
+            if (tick?.[1]) {
+              const cmd = tick[1].trim();
+              if (cmd) return [cmd];
+            }
+            const dollar = text.match(/(?:^|\n)\$\s+([^\n]+)/);
+            if (dollar?.[1]) {
+              const cmd = dollar[1].trim();
+              if (cmd) return [cmd];
+            }
+            const section = text.match(/(?:^|\n)Command:\s*\n+([^\n]+)/i);
+            if (section?.[1]) {
+              const cmd = section[1].trim();
+              if (cmd) return [cmd];
+            }
+            return [];
+          };
+          const extractCommandFromParams = (root) => {
+            const candidates = [
+              { source: "params.codex_command", value: root?.codex_command },
+              { source: "params.command", value: root?.command },
+              { source: "params.cmd", value: root?.cmd },
+              { source: "params.args", value: root?.args },
+              { source: "params.argv", value: root?.argv },
+              { source: "params.input.command", value: root?.input?.command },
+              { source: "params.input.cmd", value: root?.input?.cmd },
+              { source: "params.input.args", value: root?.input?.args },
+              { source: "params.input.argv", value: root?.input?.argv },
+              { source: "params.arguments.command", value: root?.arguments?.command },
+              { source: "params.arguments.cmd", value: root?.arguments?.cmd },
+              { source: "params.arguments.args", value: root?.arguments?.args },
+              { source: "params.arguments.argv", value: root?.arguments?.argv },
+              { source: "params.tool.input.command", value: root?.tool?.input?.command },
+              { source: "params.tool.input.cmd", value: root?.tool?.input?.cmd },
+              { source: "params.tool.input.args", value: root?.tool?.input?.args },
+              { source: "params.request.command", value: root?.request?.command },
+              { source: "params.request.cmd", value: root?.request?.cmd },
+              { source: "params.request.args", value: root?.request?.args },
+              { source: "params.command.command", value: root?.command?.command },
+              { source: "params.command.cmd", value: root?.command?.cmd },
+              { source: "params.command.args", value: root?.command?.args },
+              { source: "params.exec.command", value: root?.exec?.command },
+              { source: "params.exec.cmd", value: root?.exec?.cmd },
+              { source: "params.exec.args", value: root?.exec?.args }
+            ];
+            for (const { source, value } of candidates) {
+              const cmd = asStringArray(value);
+              if (cmd) return { command: cmd, source };
+            }
+            const seen = /* @__PURE__ */ new Set();
+            const visit = (value, depth) => {
+              if (depth > 5) return null;
+              if (!value || typeof value !== "object") return null;
+              if (seen.has(value)) return null;
+              seen.add(value);
+              if (Array.isArray(value)) {
+                for (const v of value) {
+                  const found = visit(v, depth + 1);
+                  if (found) return found;
+                }
+                return null;
+              }
+              const obj = value;
+              for (const key of Object.keys(obj)) {
+                const lower = key.toLowerCase();
+                if (lower === "command" || lower === "cmd" || lower === "args" || lower === "argv" || lower === "codex_command") {
+                  const cmd = asStringArray(obj[key]);
+                  if (cmd) return { command: cmd, source: `deep:${key}` };
+                }
+              }
+              for (const key of Object.keys(obj)) {
+                const found = visit(obj[key], depth + 1);
+                if (found) return found;
+              }
+              return null;
+            };
+            return visit(root, 0) ?? { command: [], source: "none" };
+          };
+          const extracted = extractCommandFromParams(params);
+          const cwd = asNonEmptyString(params.codex_cwd ?? params.cwd);
+          const message = typeof params?.message === "string" ? params.message : void 0;
+          let command = extracted.command.length > 0 ? extracted.command : message ? extractCommandFromMessage(message) : [];
+          const askUserQuestion = buildAskUserQuestionPromptFromRequestedSchema(requestedSchemaRaw, message);
+          const isApprovalish = (() => {
+            if (!askUserQuestion) return false;
+            const keys = askUserQuestion.questions.map((q) => String(q.key || "")).filter(Boolean);
+            if (keys.some((k) => /(^|_)ok$|^ok(_|$)|patch_ok|exec_ok|approve_ok|permission_ok/i.test(k))) return true;
+            const flat = [
+              message || "",
+              ...askUserQuestion.questions.flatMap((q) => [
+                q.key,
+                q.header,
+                q.question,
+                ...Array.isArray(q.options) ? q.options.flatMap((o) => [o.label, o.description]) : []
+              ])
+            ].filter((v) => typeof v === "string" && v.trim().length > 0).join("\n");
+            return /apply patch|code patch|exec(ution)?|permission|policy|approve|approved|allow|deny|confirm|click approve/i.test(flat);
+          })();
+          const hasRichOptions = askUserQuestion && (askUserQuestion.questions.length > 1 || askUserQuestion.questions.some((q) => q.options.length >= 3));
+          if (askUserQuestion && hasRichOptions && !isApprovalish) {
+            types.logger.debug("[CodexMCP] Elicitation looks like user question; emitting AskUserQuestion card", {
+              primaryId,
+              questionCount: askUserQuestion.questions.length,
+              keys: askUserQuestion.questions.map((q) => q.key).slice(0, 20)
+            });
+            await this.permissionHandler.handleElicitation(primaryId, askUserQuestion, {
+              decision: "approved"
+            });
+            return buildMcpElicitationResult("denied", requestedSchemaRaw, {
+              deniedReason: "awaiting_user_message"
+            });
+          }
+          let toolName = inferElicitationToolName(params, requestedSchemaRaw);
+          if (toolName === "CodexBash" && command.length === 0 && this.latestExecApproval) {
+            const ageMs = Date.now() - this.latestExecApproval.updatedAt;
+            if (ageMs >= 0 && ageMs < 2 * 6e4) {
+              command = [this.latestExecApproval.command];
+            }
+          }
+          if (toolName === "CodexBash" && command.length === 0) {
+            const diffAgeMs2 = this.latestUnifiedDiff ? Date.now() - this.latestUnifiedDiff.updatedAt : null;
+            const patchAgeMs = this.latestPatchApplyBegin ? Date.now() - this.latestPatchApplyBegin.updatedAt : null;
+            const hasRecentPatchContext = diffAgeMs2 != null && diffAgeMs2 >= 0 && diffAgeMs2 < 5 * 6e4 || patchAgeMs != null && patchAgeMs >= 0 && patchAgeMs < 5 * 6e4;
+            if (hasRecentPatchContext) {
+              toolName = "CodexPatch";
+            }
+          }
+          const patchFilesFromChanges = toolName === "CodexPatch" && params?.changes && typeof params.changes === "object" ? Object.keys(params.changes) : [];
+          const patchFiles = toolName === "CodexPatch" ? [
+            ...Array.isArray(params?.files) ? params.files : [],
+            ...patchFilesFromChanges,
+            ...typeof message === "string" ? extractLikelyFilePathsFromMessage(message) : []
+          ].map(normalizeRelativePath).filter((v) => Boolean(v)) : [];
+          let diffFiles = [];
+          let diffAgeMs = null;
+          if (toolName === "CodexPatch" && patchFiles.length === 0 && this.latestUnifiedDiff?.diff) {
+            diffAgeMs = Date.now() - this.latestUnifiedDiff.updatedAt;
+            if (diffAgeMs >= 0 && diffAgeMs < 5 * 6e4) {
+              diffFiles = extractPathsFromUnifiedDiff(this.latestUnifiedDiff.diff).map(normalizeRelativePath).filter((v) => Boolean(v));
+            }
+          }
+          let patchBeginFiles = [];
+          let patchBeginAgeMs = null;
+          if (toolName === "CodexPatch" && patchFiles.length === 0 && diffFiles.length === 0 && this.latestPatchApplyBegin?.changes) {
+            patchBeginAgeMs = Date.now() - this.latestPatchApplyBegin.updatedAt;
+            if (patchBeginAgeMs >= 0 && patchBeginAgeMs < 5 * 6e4) {
+              patchBeginFiles = Object.keys(this.latestPatchApplyBegin.changes).map(normalizeRelativePath).filter((v) => Boolean(v));
+            }
+          }
+          const patchFilesFinal = toolName === "CodexPatch" && patchFiles.length === 0 ? diffFiles.length > 0 ? diffFiles : patchBeginFiles : patchFiles;
+          const patchChanges = toolName === "CodexPatch" && patchFilesFinal.length > 0 ? Object.fromEntries(patchFilesFinal.map((p) => [p, { op: "update" }])) : void 0;
+          const result = await this.permissionHandler.handleToolCall(
+            primaryId,
+            toolName,
+            {
+              command,
+              cwd,
+              message,
+              ...patchChanges ? { changes: patchChanges } : null,
+              ...patchFilesFinal.length > 0 ? { files: patchFilesFinal } : null,
+              ...toolName === "CodexPatch" && this.latestUnifiedDiff?.diff && diffFiles.length > 0 ? { unified_diff: this.latestUnifiedDiff.diff } : null,
+              _permissionDebug: {
+                primaryId,
+                aliases,
+                paramsKeys: Object.keys(params || {}),
+                hasCommand: command.length > 0,
+                commandSource: extracted.source,
+                inferredTool: toolName,
+                patchFiles: patchFilesFinal.slice(0, 25),
+                diffPreviewUsed: diffFiles.length > 0,
+                diffFileCount: diffFiles.length,
+                diffAgeMs,
+                patchApplyBeginUsed: patchBeginFiles.length > 0,
+                patchApplyBeginFileCount: patchBeginFiles.length,
+                patchApplyBeginAgeMs: patchBeginAgeMs,
+                latestExecApprovalAgeMs: toolName === "CodexBash" && this.latestExecApproval ? Date.now() - this.latestExecApproval.updatedAt : null,
+                conversationId: this.conversationId,
+                sessionId: this.sessionId,
+                requestedSchema: summarizeRequestedSchemaForLogs(requestedSchemaRaw)
+              }
+            },
+            aliases
+          );
+          types.logger.debug("[CodexMCP] Permission result:", result);
+          const elicitationResult = buildMcpElicitationResult(result.decision, requestedSchemaRaw, {
+            deniedReason: result.reason
+          });
+          types.logger.debug("[CodexMCP] Elicitation response:", {
+            decision: result.decision,
+            action: elicitationResult.action,
+            codexDecision: elicitationResult.decision,
+            contentKeys: elicitationResult.content ? Object.keys(elicitationResult.content) : [],
+            content: elicitationResult.content
+          });
+          return elicitationResult;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const stack = error instanceof Error ? error.stack : void 0;
+          types.logger.debug("[CodexMCP] Error handling permission request:", { message, stack });
+          return {
+            action: "decline"
+          };
+        }
+      }
+    );
+    types.logger.debug("[CodexMCP] Permission handlers registered");
+  }
+  async startSession(config, options) {
+    if (!this.connected) await this.connect();
+    if (this.sessionId) {
+      types.logger.debug("[CodexMCP] startSession called with active session; continuing instead", {
+        sessionId: this.sessionId,
+        hasConversationId: !!this.conversationId
+      });
+      return this.continueSession(config.prompt, options);
+    }
+    if (this.connected && !this.sessionId) {
+      const nextAuth = this.getCodexAuthSnapshot();
+      if (this.didAuthChange(this.authSnapshot, nextAuth)) {
+        await this.reconnectForAuthChange("startSession:auth-changed");
+      } else if (!this.authSnapshot) {
+        this.authSnapshot = nextAuth;
+      }
+    }
+    types.logger.debug("[CodexMCP] Starting Codex session:", config);
+    const response = await this.client.callTool({
+      name: "codex",
+      arguments: config
+    }, void 0, {
+      signal: options?.signal,
+      timeout: DEFAULT_TIMEOUT
+      // maxTotalTimeout: 10000000000 
+    });
+    types.logger.debug("[CodexMCP] startSession response:", response);
+    try {
+      this.assertToolSuccess(response, "[CodexMCP] startSession failed");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (/hit your usage limit/i.test(message)) {
+        const nextAuth = this.getCodexAuthSnapshot();
+        if (this.didAuthChange(this.authSnapshot, nextAuth)) {
+          await this.reconnectForAuthChange("startSession:usage-limit:auth-changed");
+          const retry = await this.client.callTool({
+            name: "codex",
+            arguments: config
+          }, void 0, {
+            signal: options?.signal,
+            timeout: DEFAULT_TIMEOUT
+          });
+          types.logger.debug("[CodexMCP] startSession retry response:", retry);
+          this.assertToolSuccess(retry, "[CodexMCP] startSession failed");
+          this.extractIdentifiers(retry);
+          return retry;
+        }
+      }
+      throw error;
+    }
+    this.extractIdentifiers(response);
+    return response;
+  }
+  async continueSession(prompt, options) {
+    if (!this.connected) await this.connect();
+    if (!this.sessionId) {
+      throw new Error("No active session. Call startSession first.");
+    }
+    if (!this.conversationId) {
+      this.conversationId = this.sessionId;
+      types.logger.debug("[CodexMCP] conversationId missing, defaulting to sessionId:", this.conversationId);
+    }
+    const args = { sessionId: this.sessionId, conversationId: this.conversationId, prompt };
+    types.logger.debug("[CodexMCP] Continuing Codex session:", args);
+    const response = await this.client.callTool({
+      name: "codex-reply",
+      arguments: args
+    }, void 0, {
+      signal: options?.signal,
+      timeout: DEFAULT_TIMEOUT
+    });
+    types.logger.debug("[CodexMCP] continueSession response:", response);
+    this.assertToolSuccess(response, "[CodexMCP] continueSession failed");
+    this.extractIdentifiers(response);
+    return response;
+  }
+  updateIdentifiersFromEvent(event) {
+    if (!event || typeof event !== "object") {
+      return;
+    }
+    const candidates = [event];
+    if (event.data && typeof event.data === "object") {
+      candidates.push(event.data);
+    }
+    for (const candidate of candidates) {
+      const sessionId = candidate.session_id ?? candidate.sessionId;
+      if (sessionId) {
+        this.sessionId = sessionId;
+        types.logger.debug("[CodexMCP] Session ID extracted from event:", this.sessionId);
+      }
+      const conversationId = candidate.conversation_id ?? candidate.conversationId;
+      if (conversationId) {
+        this.conversationId = conversationId;
+        types.logger.debug("[CodexMCP] Conversation ID extracted from event:", this.conversationId);
+      }
+    }
+  }
+  extractIdentifiers(response) {
+    const meta = response?.meta || {};
+    const sessionId = meta.session_id ?? meta.sessionId ?? response?.session_id ?? response?.sessionId;
+    if (sessionId) {
+      this.sessionId = sessionId;
+      types.logger.debug("[CodexMCP] Session ID extracted:", this.sessionId);
+    }
+    const conversationId = meta.conversation_id ?? meta.conversationId ?? response?.conversation_id ?? response?.conversationId;
+    if (conversationId) {
+      this.conversationId = conversationId;
+      types.logger.debug("[CodexMCP] Conversation ID extracted:", this.conversationId);
+    }
+    const content = response?.content;
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        const contentSessionId = item?.session_id ?? item?.sessionId;
+        if (!this.sessionId && contentSessionId) {
+          this.sessionId = contentSessionId;
+          types.logger.debug("[CodexMCP] Session ID extracted from content:", this.sessionId);
+        }
+        const contentConversationId = item?.conversation_id ?? item?.conversationId;
+        if (!this.conversationId && contentConversationId) {
+          this.conversationId = contentConversationId;
+          types.logger.debug("[CodexMCP] Conversation ID extracted from content:", this.conversationId);
+        }
+      }
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getConversationId() {
+    return this.conversationId;
+  }
+  hasActiveSession() {
+    return this.sessionId !== null;
+  }
+  clearSession() {
+    const previousSessionId = this.sessionId;
+    this.sessionId = null;
+    this.conversationId = null;
+    types.logger.debug("[CodexMCP] Session cleared, previous sessionId:", previousSessionId);
+  }
+  /**
+   * Store the current session ID without clearing it, useful for abort handling
+   */
+  storeSessionForResume() {
+    types.logger.debug("[CodexMCP] Storing session for potential resume:", this.sessionId);
+    return this.sessionId;
+  }
+  /**
+   * Store the current conversation ID, useful for resuming from the local Codex transcript.
+   */
+  storeConversationForResume() {
+    types.logger.debug("[CodexMCP] Storing conversation for potential resume:", this.conversationId);
+    return this.conversationId;
+  }
+  async disconnect() {
+    if (!this.connected) return;
+    const pid = this.transport?.pid ?? null;
+    types.logger.debug(`[CodexMCP] Disconnecting; child pid=${pid ?? "none"}`);
+    try {
+      types.logger.debug("[CodexMCP] client.close begin");
+      await this.client.close();
+      types.logger.debug("[CodexMCP] client.close done");
+    } catch (e) {
+      types.logger.debug("[CodexMCP] Error closing client, attempting transport close directly", e);
+      try {
+        types.logger.debug("[CodexMCP] transport.close begin");
+        await this.transport?.close?.();
+        types.logger.debug("[CodexMCP] transport.close done");
+      } catch (error) {
+        console.error("[CodexMCP] Error closing transport:", error);
+        types.logger.debug("[CodexMCP] Error closing transport:", error);
+      }
+    }
+    if (pid) {
+      try {
+        process.kill(pid, 0);
+        types.logger.debug("[CodexMCP] Child still alive, sending SIGKILL");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch (error) {
+          const e = error;
+          if (e?.code !== "ESRCH") {
+            console.error("[CodexMCP] Failed to SIGKILL child process:", pid, error);
+            types.logger.debug("[CodexMCP] Failed to SIGKILL child process:", pid, error);
+          }
+        }
+      } catch (error) {
+        const e = error;
+        if (e?.code !== "ESRCH") {
+          console.error("[CodexMCP] Failed to check child process status:", pid, error);
+          types.logger.debug("[CodexMCP] Failed to check child process status:", pid, error);
+        }
+      }
+    }
+    this.transport = null;
+    this.connected = false;
+    this.sessionId = null;
+    this.conversationId = null;
+    this.authSnapshot = null;
+    types.logger.debug("[CodexMCP] Disconnected");
+  }
+}
+
+class CodexPermissionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  aliasToPrimary = /* @__PURE__ */ new Map();
+  session;
+  permissionMode = "default";
+  elicitationHub = null;
+  constructor(session, options) {
+    this.session = session;
+    this.elicitationHub = options?.elicitationHub ?? null;
+    this.setupRpcHandler();
+  }
+  setPermissionMode(mode) {
+    this.permissionMode = mode;
+  }
+  /**
+   * Handle a tool permission request
+   * @param toolCallId - The unique ID of the tool call
+   * @param toolName - The name of the tool being called
+   * @param input - The input parameters for the tool
+   * @param aliases - Additional IDs that might be used by clients when responding
+   * @returns Promise resolving to permission result
+   */
+  async handleToolCall(toolCallId, toolName, input, aliases = []) {
+    const enforced = this.enforceCoordinationGate(toolName, input);
+    if (enforced) {
+      this.emitPolicyCard(toolCallId, toolName, input, enforced);
+      this.recordCompletedDecision(toolCallId, toolName, input, enforced);
+      return enforced;
+    }
+    const auto = this.autoDecisionForToolCall(toolName, input);
+    if (auto) {
+      if (typeof auto?.then === "function") {
+        const res2 = await auto;
+        this.emitPolicyCard(toolCallId, toolName, input, res2);
+        if (res2.decision !== "approved" && res2.decision !== "approved_for_session") {
+          this.recordCompletedDecision(toolCallId, toolName, input, res2);
+        }
+        return res2;
+      }
+      const res = auto;
+      this.emitPolicyCard(toolCallId, toolName, input, res);
+      if (res.decision !== "approved" && res.decision !== "approved_for_session") {
+        this.recordCompletedDecision(toolCallId, toolName, input, res);
+      }
+      return res;
+    }
+    this.emitPolicyCard(toolCallId, toolName, input, {
+      decision: "abort",
+      reason: "permission_prompt_required"
+    });
+    return new Promise((resolve, reject) => {
+      const normalizedAliases = aliases.filter((id) => typeof id === "string" && id.length > 0 && id !== toolCallId);
+      const allIds = [toolCallId, ...normalizedAliases];
+      const pending = {
+        resolve,
+        reject,
+        toolName,
+        input,
+        ids: allIds
+      };
+      for (const id of allIds) {
+        this.pendingRequests.set(id, pending);
+        this.aliasToPrimary.set(id, toolCallId);
+      }
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [toolCallId]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now()
+          }
+        }
+      }));
+      types.logger.debug(`[Codex] Permission request sent for tool: ${toolName} (${toolCallId})`);
+    });
+  }
+  /**
+   * Handle a structured user-input elicitation request (e.g. AskUserQuestion).
+   * Returns an MCP-compatible elicitation result to send back to codex-cli.
+   */
+  async handleElicitation(toolCallId, input, options) {
+    const callId = toolCallId || node_crypto.randomUUID();
+    if (!this.elicitationHub) {
+      throw new Error("Elicitation hub not configured for this session");
+    }
+    this.session.sendCodexMessage({
+      type: "tool-call",
+      name: "AskUserQuestion",
+      callId,
+      input: input ?? {},
+      id: node_crypto.randomUUID()
+    });
+    this.session.sendCodexMessage({
+      type: "tool-call-result",
+      callId,
+      output: {
+        status: "awaiting_user_message",
+        hint: "User will answer via a new chat message when ready."
+      },
+      is_error: false,
+      id: node_crypto.randomUUID()
+    });
+    return { action: "accept", decision: "denied" };
+  }
+  autoDecisionForToolCall(toolName, input) {
+    const mode = this.permissionMode;
+    if (mode === "always-ask") {
+      return null;
+    }
+    if (mode === "default") {
+      return null;
+    }
+    if (mode === "read-only") {
+      return { decision: "denied", reason: "read_only_mode" };
+    }
+    if (mode === "safe-yolo" || mode === "yolo") {
+      return this.autoApproveWithQuota(toolName, input);
+    }
+    return null;
+  }
+  async autoApproveWithQuota(toolName, _input) {
+    const decision = "approved_for_session";
+    if (index.shouldCountToolCall(toolName)) {
+      try {
+        const quota = await index.consumeToolQuota({ token: this.session.getAuthToken(), toolName });
+        if (quota.allowed !== true) {
+          return { decision: "denied", reason: index.formatQuotaDeniedReason(quota) };
+        }
+      } catch (err) {
+        return { decision: "denied", reason: err?.message || "Tool quota check failed" };
+      }
+    }
+    return { decision };
+  }
+  /**
+   * Setup RPC handler for permission responses
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const responseId = response?.id;
+        const primaryId = (responseId && this.aliasToPrimary.get(responseId)) ?? responseId;
+        const pending = (primaryId && this.pendingRequests.get(primaryId)) ?? (responseId && this.pendingRequests.get(responseId));
+        if (!pending) {
+          types.logger.debug("[Codex] Permission request not found or already resolved");
+          return { ok: true };
+        }
+        for (const id of pending.ids) {
+          this.pendingRequests.delete(id);
+          this.aliasToPrimary.delete(id);
+        }
+        let approved = response.approved;
+        let reason;
+        let deniedByQuota = false;
+        if (approved && index.shouldCountToolCall(pending.toolName)) {
+          try {
+            const quota = await index.consumeToolQuota({ token: this.session.getAuthToken(), toolName: pending.toolName });
+            if (quota.allowed !== true) {
+              approved = false;
+              reason = index.formatQuotaDeniedReason(quota);
+              deniedByQuota = true;
+            }
+          } catch (err) {
+            approved = false;
+            reason = err?.message || "Tool quota check failed";
+            deniedByQuota = true;
+          }
+        }
+        const decision = approved ? response.decision === "approved_for_session" ? "approved_for_session" : "approved" : deniedByQuota ? "denied" : response.decision === "denied" ? "denied" : "abort";
+        const result = { decision, reason };
+        this.emitPolicyCard(primaryId ?? responseId ?? pending.ids[0] ?? node_crypto.randomUUID(), pending.toolName, pending.input, result);
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const requestKey = primaryId ?? responseId;
+          if (!requestKey) return currentState;
+          const request = currentState.requests?.[requestKey];
+          if (!request) return currentState;
+          const remainingRequests = { ...currentState.requests || {} };
+          delete remainingRequests[requestKey];
+          let res = {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [requestKey]: {
+                ...request,
+                completedAt: Date.now(),
+                status: approved ? "approved" : "denied",
+                decision: result.decision,
+                reason
+              }
+            }
+          };
+          return res;
+        });
+        types.logger.debug(`[Codex] Permission ${approved ? "approved" : "denied"} for ${pending.toolName}`);
+        return { ok: true };
+      }
+    );
+  }
+  /**
+   * Reset state for new sessions
+   */
+  reset() {
+    for (const [id, pending] of this.pendingRequests.entries()) {
+      pending.reject(new Error("Session reset"));
+    }
+    this.pendingRequests.clear();
+    this.aliasToPrimary.clear();
+    this.session.updateAgentState((currentState) => {
+      const pendingRequests = currentState.requests || {};
+      const completedRequests = { ...currentState.completedRequests };
+      for (const [id, request] of Object.entries(pendingRequests)) {
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason: "Session reset"
+        };
+      }
+      return {
+        ...currentState,
+        requests: {},
+        completedRequests
+      };
+    });
+    types.logger.debug("[Codex] Permission handler reset");
+  }
+  enforceCoordinationGate(toolName, input) {
+    const hasContext = typeof this.session?.hasCoordinationContext === "function" ? this.session.hasCoordinationContext() : false;
+    if (!hasContext) return null;
+    if (toolName !== "CodexPatch") {
+      return null;
+    }
+    const didReadDocsIndex = typeof this.session?.didReadDocsIndexWithin === "function" ? this.session.didReadDocsIndexWithin(365 * 24 * 60 * 6e4) : false;
+    if (!didReadDocsIndex) {
+      return {
+        decision: "denied",
+        reason: "docs_index_read_required"
+      };
+    }
+    const maxAgeMs = 15 * 6e4;
+    const didReadLedger = typeof this.session?.didReadCoordinationLedgerWithin === "function" ? this.session.didReadCoordinationLedgerWithin(maxAgeMs) : false;
+    if (!didReadLedger) {
+      return {
+        decision: "denied",
+        reason: "ledger_read_required"
+      };
+    }
+    const changes = input?.changes ?? input?.input?.changes;
+    const filePaths = changes && typeof changes === "object" ? Object.keys(changes).map(normalizeToolFilePath).filter((v) => Boolean(v)) : [];
+    if (filePaths.length === 0) return null;
+    const guard = this.session?.coordinationLeaseGuard;
+    const hasClaim = (filePath) => {
+      try {
+        return Boolean(guard && typeof guard.has === "function" && guard.has(filePath));
+      } catch (error) {
+        console.error("[permissionHandler] coordinationLeaseGuard.has threw:", error);
+        types.logger.debug("[permissionHandler] coordinationLeaseGuard.has threw:", error);
+        return false;
+      }
+    };
+    const missing = filePaths.filter((p) => !hasClaim(p));
+    if (missing.length > 0) {
+      let debugClaims = "";
+      try {
+        const snapshot = guard && typeof guard.snapshot === "function" ? guard.snapshot() : [];
+        const sample = Array.isArray(snapshot) ? snapshot.slice(0, 12).map((v) => String(v?.file ?? v)).filter(Boolean) : [];
+        if (sample.length > 0) debugClaims = ` (have=${sample.join(", ")})`;
+      } catch (error) {
+        console.error("[permissionHandler] Failed to snapshot coordination lease guard:", error);
+        types.logger.debug("[permissionHandler] Failed to snapshot coordination lease guard:", error);
+      }
+      return {
+        decision: "denied",
+        reason: `file_claim_required:${missing[0]}${debugClaims}`
+      };
+    }
+    return null;
+  }
+  recordCompletedDecision(toolCallId, toolName, input, result) {
+    const status = result.decision === "approved" || result.decision === "approved_for_session" ? "approved" : "denied";
+    const completedAt = Date.now();
+    const reason = result.reason;
+    const decision = result.decision;
+    this.session.updateAgentState((currentState) => ({
+      ...currentState,
+      completedRequests: {
+        ...currentState.completedRequests || {},
+        [toolCallId]: {
+          tool: toolName,
+          arguments: input,
+          createdAt: completedAt,
+          completedAt,
+          status,
+          decision,
+          reason
+        }
+      }
+    }));
+  }
+  emitPolicyCard(toolCallId, toolName, input, result) {
+    const decision = result.decision;
+    const hasContext = typeof this.session?.hasCoordinationContext === "function" ? this.session.hasCoordinationContext() : false;
+    const readAt = typeof this.session?.getCoordinationLedgerReadAt === "function" ? this.session.getCoordinationLedgerReadAt() : 0;
+    const ageMs = readAt > 0 ? Date.now() - readAt : null;
+    let claims = [];
+    try {
+      const guard = this.session?.coordinationLeaseGuard;
+      claims = guard && typeof guard.snapshot === "function" ? guard.snapshot().slice(0, 50) : [];
+    } catch {
+      claims = [];
+    }
+    const gate = describeCoordinationGate({
+      hasCoordinationContext: hasContext,
+      toolName,
+      input,
+      ledgerReadAt: readAt || null,
+      claimSnapshot: claims
+    });
+    const hint = buildPolicyHint(result.reason, decision, gate);
+    const callId = `policy:${toolCallId}:${node_crypto.randomUUID().slice(0, 8)}`;
+    const kind = decision === "approved" || decision === "approved_for_session" ? "policy_allow" : decision === "abort" && result.reason === "permission_prompt_required" ? "policy_prompt" : "policy_block";
+    const payload = {
+      kind,
+      blockedTool: toolName,
+      summary: hint.summary,
+      nextSteps: hint.nextSteps,
+      toolName,
+      decision,
+      reason: result.reason,
+      permissionMode: this.permissionMode,
+      hasCoordinationContext: hasContext,
+      ledgerReadAt: readAt || null,
+      ledgerReadAgeMs: ageMs,
+      claimSnapshot: claims,
+      claimedFiles: formatClaimSnapshotFiles(claims),
+      coordinationGate: gate,
+      inputPreviewKeys: input && typeof input === "object" ? Object.keys(input).slice(0, 20) : null
+    };
+    try {
+      this.session.sendCodexMessage({
+        type: "tool-call",
+        name: "FlockbayPolicy",
+        callId,
+        input: payload,
+        id: node_crypto.randomUUID()
+      });
+      this.session.sendCodexMessage({
+        type: "tool-call-result",
+        callId,
+        output: payload,
+        is_error: kind === "policy_block",
+        id: node_crypto.randomUUID()
+      });
+    } catch (err) {
+      types.logger.debug("[Codex] Failed to emit inline policy card", err);
+    }
+  }
+}
+function normalizeToolFilePath(input) {
+  const raw = typeof input === "string" ? input.trim() : String(input ?? "").trim();
+  if (!raw) return null;
+  let candidate = raw.replace(/\\/g, "/");
+  candidate = candidate.replace(/^\.\/+/, "").replace(/^\/+/, "");
+  if (!candidate) return null;
+  if (candidate.includes("..")) return null;
+  return candidate;
+}
+function buildPolicyHint(reason, decision, gate) {
+  const raw = typeof reason === "string" ? reason.trim() : "";
+  if (!raw) {
+    if (decision === "approved" || decision === "approved_for_session") {
+      return {
+        summary: "Allowed.",
+        nextSteps: []
+      };
+    }
+    return {
+      summary: "Blocked by policy.",
+      nextSteps: []
+    };
+  }
+  if (raw === "permission_prompt_required") {
+    return {
+      summary: "Waiting for permission to run this tool.",
+      nextSteps: []
+    };
+  }
+  if (raw === "ledger_read_required") {
+    return {
+      summary: "Blocked by policy (automatic; not the user): read the ledger before making file edits.",
+      nextSteps: [
+        "Call `mcp__flockbay__ledger_read` (or `mcp__flockbay__coordination_ledger_snapshot`).",
+        "Then retry the file edit."
+      ]
+    };
+  }
+  if (raw === "docs_index_read_required") {
+    return {
+      summary: "Blocked by policy (automatic; not the user): read the game Documentation index before making edits.",
+      nextSteps: [
+        "Call `mcp__flockbay__docs_index_read`.",
+        "Then retry the edit."
+      ]
+    };
+  }
+  if (raw.startsWith("file_claim_required:")) {
+    const withoutPrefix = raw.slice("file_claim_required:".length);
+    const file = withoutPrefix.split("(")[0]?.trim() || "the file";
+    return {
+      summary: `Blocked by policy (automatic; not the user): claim \`${file}\` before editing it.`,
+      nextSteps: [
+        `Claim the file via \`mcp__flockbay__ledger_claim\` or \`mcp__flockbay__coordination_claim_files\` (files: ["${file}"]).`,
+        "Then retry the file edit."
+      ]
+    };
+  }
+  if (raw === "read_only_mode") {
+    return {
+      summary: "Blocked by policy (automatic; not the user): this session is in read-only mode.",
+      nextSteps: [
+        "Switch permission mode to allow edits (disable read-only).",
+        "Then retry the action."
+      ]
+    };
+  }
+  if (raw.toLowerCase().includes("quota")) {
+    return {
+      summary: `Blocked: tool quota denied (${raw}).`,
+      nextSteps: [
+        "Wait and retry later, or switch to a different model/provider."
+      ]
+    };
+  }
+  if (decision === "approved" || decision === "approved_for_session") {
+    if (gate.hasCoordinationContext && gate.toolName === "CodexPatch") {
+      const files = gate.requestedFiles.length > 0 ? ` (${gate.requestedFiles.join(", ")})` : "";
+      return {
+        summary: `Allowed: file edit passed ledger + claim checks${files}.`,
+        nextSteps: []
+      };
+    }
+    return { summary: "Allowed.", nextSteps: [] };
+  }
+  return {
+    summary: `Blocked: ${raw}`,
+    nextSteps: []
+  };
+}
+function formatClaimSnapshotFiles(snapshot) {
+  if (!Array.isArray(snapshot)) return [];
+  const files = [];
+  for (const entry of snapshot) {
+    if (!entry) continue;
+    if (typeof entry === "string") {
+      files.push(entry);
+      continue;
+    }
+    const file = entry?.file;
+    if (typeof file === "string" && file.trim()) files.push(file.trim());
+  }
+  return files.slice(0, 50);
+}
+function describeCoordinationGate(args) {
+  const ledgerReadAt = typeof args.ledgerReadAt === "number" && args.ledgerReadAt > 0 ? args.ledgerReadAt : null;
+  const ledgerReadAgeMs = ledgerReadAt ? Date.now() - ledgerReadAt : null;
+  const changes = args.input?.changes ?? args.input?.input?.changes;
+  const requestedFiles = changes && typeof changes === "object" ? Object.keys(changes).map(normalizeToolFilePath).filter((v) => Boolean(v)) : [];
+  const claimedFilesAll = formatClaimSnapshotFiles(args.claimSnapshot);
+  const claimedSet = new Set(claimedFilesAll);
+  const missingClaims = requestedFiles.filter((p) => !claimedSet.has(p));
+  const claimedFilesSample = claimedFilesAll.slice(0, 12);
+  return {
+    hasCoordinationContext: args.hasCoordinationContext,
+    toolName: args.toolName,
+    ledgerReadAt,
+    ledgerReadAgeMs,
+    requestedFiles,
+    missingClaims,
+    claimedFilesSample
+  };
+}
+
+class ReasoningProcessor {
+  accumulator = "";
+  inTitleCapture = false;
+  titleBuffer = "";
+  contentBuffer = "";
+  hasTitle = false;
+  currentCallId = null;
+  toolCallStarted = false;
+  currentTitle = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+    this.reset();
+  }
+  /**
+   * Set the message callback for sending messages directly
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
+  }
+  /**
+   * Process a reasoning section break - indicates a new reasoning section is starting
+   */
+  handleSectionBreak() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+    types.logger.debug("[ReasoningProcessor] Section break - reset state");
+  }
+  /**
+   * Process a reasoning delta and accumulate content
+   */
+  processDelta(delta) {
+    this.accumulator += delta;
+    if (!this.inTitleCapture && !this.hasTitle && !this.contentBuffer) {
+      if (this.accumulator.startsWith("**")) {
+        this.inTitleCapture = true;
+        this.titleBuffer = this.accumulator.substring(2);
+        types.logger.debug("[ReasoningProcessor] Started title capture");
+      } else if (this.accumulator.length > 0) {
+        this.contentBuffer = this.accumulator;
+      }
+    } else if (this.inTitleCapture) {
+      this.titleBuffer = this.accumulator.substring(2);
+      const titleEndIndex = this.titleBuffer.indexOf("**");
+      if (titleEndIndex !== -1) {
+        const title = this.titleBuffer.substring(0, titleEndIndex);
+        const afterTitle = this.titleBuffer.substring(titleEndIndex + 2);
+        this.hasTitle = true;
+        this.inTitleCapture = false;
+        this.currentTitle = title;
+        this.contentBuffer = afterTitle;
+        this.currentCallId = node_crypto.randomUUID();
+        types.logger.debug(`[ReasoningProcessor] Title captured: "${title}"`);
+        this.sendToolCallStart(title);
+      }
+    } else if (this.hasTitle) {
+      this.contentBuffer = this.accumulator.substring(
+        this.accumulator.indexOf("**") + 2 + this.currentTitle.length + 2
+      );
+    } else {
+      this.contentBuffer = this.accumulator;
+    }
+  }
+  /**
+   * Send the tool call start message
+   */
+  sendToolCallStart(title) {
+    if (!this.currentCallId || this.toolCallStarted) {
+      return;
+    }
+    const toolCall = {
+      type: "tool-call",
+      name: "CodexReasoning",
+      callId: this.currentCallId,
+      input: {
+        title
+      },
+      id: node_crypto.randomUUID()
+    };
+    types.logger.debug(`[ReasoningProcessor] Sending tool call start for: "${title}"`);
+    this.onMessage?.(toolCall);
+    this.toolCallStarted = true;
+  }
+  /**
+   * Complete the reasoning section with final text
+   */
+  complete(fullText) {
+    let title;
+    let content = fullText;
+    if (fullText.startsWith("**")) {
+      const titleEndIndex = fullText.indexOf("**", 2);
+      if (titleEndIndex !== -1) {
+        title = fullText.substring(2, titleEndIndex);
+        content = fullText.substring(titleEndIndex + 2).trim();
+      }
+    }
+    types.logger.debug(`[ReasoningProcessor] Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
+    if (title && !this.toolCallStarted) {
+      this.currentCallId = this.currentCallId || node_crypto.randomUUID();
+      this.sendToolCallStart(title);
+    }
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content,
+          status: "completed"
+        },
+        id: node_crypto.randomUUID()
+      };
+      types.logger.debug("[ReasoningProcessor] Sending tool call result");
+      this.onMessage?.(toolResult);
+    } else {
+      const reasoningMessage = {
+        type: "reasoning",
+        message: content,
+        id: node_crypto.randomUUID()
+      };
+      types.logger.debug("[ReasoningProcessor] Sending reasoning message");
+      this.onMessage?.(reasoningMessage);
+    }
+    this.resetState();
+  }
+  /**
+   * Abort the current reasoning section
+   */
+  abort() {
+    types.logger.debug("[ReasoningProcessor] Abort called");
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+  }
+  /**
+   * Reset the processor state
+   */
+  reset() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+  }
+  /**
+   * Finish current tool call if one is in progress
+   */
+  finishCurrentToolCall(status) {
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content: this.contentBuffer || "",
+          status
+        },
+        id: node_crypto.randomUUID()
+      };
+      types.logger.debug(`[ReasoningProcessor] Sending tool call result with status: ${status}`);
+      this.onMessage?.(toolResult);
+    }
+  }
+  /**
+   * Reset internal state
+   */
+  resetState() {
+    this.accumulator = "";
+    this.inTitleCapture = false;
+    this.titleBuffer = "";
+    this.contentBuffer = "";
+    this.hasTitle = false;
+    this.currentCallId = null;
+    this.toolCallStarted = false;
+    this.currentTitle = null;
+  }
+  /**
+   * Get the current call ID for tool result matching
+   */
+  getCurrentCallId() {
+    return this.currentCallId;
+  }
+  /**
+   * Check if a tool call has been started
+   */
+  hasStartedToolCall() {
+    return this.toolCallStarted;
+  }
+}
+
+class DiffProcessor {
+  previousDiff = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+  }
+  /**
+   * Process a turn_diff message and check if the unified_diff has changed
+   */
+  processDiff(unifiedDiff) {
+    if (this.previousDiff !== unifiedDiff) {
+      types.logger.debug("[DiffProcessor] Unified diff changed, sending CodexDiff tool call");
+      const callId = node_crypto.randomUUID();
+      const toolCall = {
+        type: "tool-call",
+        name: "CodexDiff",
+        callId,
+        input: {
+          unified_diff: unifiedDiff
+        },
+        id: node_crypto.randomUUID()
+      };
+      this.onMessage?.(toolCall);
+      const toolResult = {
+        type: "tool-call-result",
+        callId,
+        output: {
+          status: "completed"
+        },
+        id: node_crypto.randomUUID()
+      };
+      this.onMessage?.(toolResult);
+    }
+    this.previousDiff = unifiedDiff;
+    types.logger.debug("[DiffProcessor] Updated stored diff");
+  }
+  /**
+   * Reset the processor state (called on task_complete or turn_aborted)
+   */
+  reset() {
+    types.logger.debug("[DiffProcessor] Resetting diff state");
+    this.previousDiff = null;
+  }
+  /**
+   * Set the message callback for sending messages directly
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
+  }
+  /**
+   * Get the current diff value
+   */
+  getCurrentDiff() {
+    return this.previousDiff;
+  }
+}
+
+const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
+  const [messages, setMessages] = React.useState([]);
+  const [confirmationMode, setConfirmationMode] = React.useState(false);
+  const [actionInProgress, setActionInProgress] = React.useState(false);
+  const confirmationTimeoutRef = React.useRef(null);
+  const { stdout } = ink.useStdout();
+  const terminalWidth = stdout.columns || 80;
+  const terminalHeight = stdout.rows || 24;
+  React.useEffect(() => {
+    setMessages(messageBuffer.getMessages());
+    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
+      setMessages(newMessages);
+    });
+    return () => {
+      unsubscribe();
+      if (confirmationTimeoutRef.current) {
+        clearTimeout(confirmationTimeoutRef.current);
+      }
+    };
+  }, [messageBuffer]);
+  const resetConfirmation = React.useCallback(() => {
+    setConfirmationMode(false);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+      confirmationTimeoutRef.current = null;
+    }
+  }, []);
+  const setConfirmationWithTimeout = React.useCallback(() => {
+    setConfirmationMode(true);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+    }
+    confirmationTimeoutRef.current = setTimeout(() => {
+      resetConfirmation();
+    }, 15e3);
+  }, [resetConfirmation]);
+  ink.useInput(React.useCallback(async (input, key) => {
+    if (actionInProgress) return;
+    if (key.ctrl && input === "c") {
+      if (confirmationMode) {
+        resetConfirmation();
+        setActionInProgress(true);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onExit?.();
+      } else {
+        setConfirmationWithTimeout();
+      }
+      return;
+    }
+    if (confirmationMode) {
+      resetConfirmation();
+    }
+  }, [confirmationMode, actionInProgress, onExit, setConfirmationWithTimeout, resetConfirmation]));
+  const getMessageColor = (type) => {
+    switch (type) {
+      case "user":
+        return "magenta";
+      case "assistant":
+        return "cyan";
+      case "system":
+        return "blue";
+      case "tool":
+        return "yellow";
+      case "result":
+        return "green";
+      case "status":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+  const formatMessage = (msg) => {
+    const lines = msg.content.split("\n");
+    const maxLineLength = terminalWidth - 10;
+    return lines.map((line) => {
+      if (line.length <= maxLineLength) return line;
+      const chunks = [];
+      for (let i = 0; i < line.length; i += maxLineLength) {
+        chunks.push(line.slice(i, i + maxLineLength));
+      }
+      return chunks.join("\n");
+    }).join("\n");
+  };
+  return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    ink.Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "\u{1F916} Codex Agent Messages"), /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
+      // Show only the last messages that fit in the available space
+      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(ink.Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    ink.Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode ? "red" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+function hashCodexSessionMode(mode) {
+  return index.hashObject({
+    model: mode.model ?? null,
+    appendSystemPrompt: mode.appendSystemPrompt ?? null
+  });
+}
+function hashCodexSessionModeFromEnhancedMode(mode) {
+  return hashCodexSessionMode({ model: mode.model, appendSystemPrompt: mode.appendSystemPrompt });
+}
+
+function readCodexAuthIsChatGptAccount() {
+  try {
+    const authPath = path.join(os.homedir(), ".codex", "auth.json");
+    const raw = fs.readFileSync(authPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const accessToken = parsed?.tokens?.access_token;
+    if (typeof accessToken !== "string" || !accessToken) return false;
+    return Boolean(parsed?.tokens?.account_id) && parsed?.OPENAI_API_KEY === null;
+  } catch {
+    return false;
+  }
+}
+function parseEffortSuffix(model) {
+  const m = String(model || "").trim();
+  if (!m) return null;
+  if (m.endsWith("-low")) return "low";
+  if (m.endsWith("-medium")) return "medium";
+  if (m.endsWith("-high")) return "high";
+  return null;
+}
+function resolveCodexModelOverride(rawModel) {
+  const model = typeof rawModel === "string" ? rawModel.trim() : "";
+  if (!model) return {};
+  const isChatGptAuth = readCodexAuthIsChatGptAccount();
+  if (!isChatGptAuth) {
+    return { config: { model } };
+  }
+  const effort = parseEffortSuffix(model);
+  if (model === "gpt-5-minimal" || model.startsWith("gpt-5-codex-") || model.startsWith("gpt-5-")) {
+    const nextEffort = effort ?? "medium";
+    return {
+      config: {
+        model: "gpt-5.2",
+        model_reasoning_effort: nextEffort
+      }
+    };
+  }
+  return { config: { model } };
+}
+
+function emitReadyIfIdle({ pending, queueSize, shouldExit, sendReady, notify }) {
+  if (shouldExit) {
+    return false;
+  }
+  if (pending) {
+    return false;
+  }
+  if (queueSize() > 0) {
+    return false;
+  }
+  sendReady();
+  notify?.();
+  if (process.env.FLOCKBAY_AUTO_EXIT_ON_IDLE === "1") {
+    setTimeout(() => process.exit(0), 50).unref();
+  }
+  return true;
+}
+const FLOCKBAY_CODEX_BASE_INSTRUCTIONS = index.trimIdent(`
+    You have access to external tools via MCP (e.g. mcp__flockbay__*).
+
+    MCP tool naming rules:
+    - MCP tools are named like \`mcp__flockbay__unreal_latest_screenshots\` (no \`functions.\` prefix).
+    - If the user writes \`functions.mcp__...\`, treat it as a request for the MCP tool \`mcp__...\` (strip \`functions.\`) and call the tool.
+
+    Tool integrity rules:
+    - Do NOT claim you called a tool unless you actually called it.
+    - Do NOT fabricate tool outputs (including JSON payloads like { "views": [...] }).
+    - When the user asks you to call a tool, you must call it instead of "simulating" results.
+    - If you cannot call the requested tool, say so explicitly and stop (do not "approximate" the result).
+    - If a tool output contains huge base64 blobs, do not paste them into chat; rely on the tool result card/UI instead.
+
+    Terminal rules:
+    - If the user says "Do NOT use Terminal", do NOT call \`CodexBash\`. Use MCP tools only.
+`);
+function sanitizeCodexInstructions(input) {
+  return input.replace(/\r\n/g, "\n").replace(/\t/g, "    ").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+}
+function normalizeUserToolAliases(text) {
+  return String(text).replace(/\bfunctions\.mcp__/g, "mcp__");
+}
+async function runCodex(opts) {
+  const sessionTag = node_crypto.randomUUID();
+  const api = await types.ApiClient.create(opts.credentials);
+  types.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}`);
+  const settings = await types.readSettings();
+  let machineId = settings?.machineId;
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Support: coming soon.`);
+    process.exit(1);
+  }
+  types.logger.debug(`Using machineId: ${machineId}`);
+  try {
+    const existing = await api.getMachine(machineId);
+    await api.getOrCreateMachine({
+      machineId,
+      metadata: { ...existing.metadata || {}, ...index.initialMachineMetadata }
+    });
+  } catch (error) {
+    const status = error?.response?.status;
+    if (status === 404) {
+      await api.getOrCreateMachine({ machineId, metadata: index.initialMachineMetadata });
+    } else {
+      throw error;
+    }
+  }
+  let state = {
+    controlledByUser: false
+  };
+  const coordinationProjectRootPath = process.env.FLOCKBAY_COORDINATION_PROJECT_ROOT_PATH || void 0;
+  const coordinationWorkspaceProjectId = process.env.FLOCKBAY_COORDINATION_WORKSPACE_PROJECT_ID || void 0;
+  const coordinationFeatureId = process.env.FLOCKBAY_COORDINATION_FEATURE_ID || void 0;
+  const coordinationWorkItemId = process.env.FLOCKBAY_COORDINATION_WORK_ITEM_ID || void 0;
+  let metadata = {
+    path: process.cwd(),
+    projectRootPath: coordinationProjectRootPath,
+    host: os.hostname(),
+    version: types.packageJson.version,
+    os: os.platform(),
+    machineId,
+    workspaceProjectId: coordinationWorkspaceProjectId,
+    featureId: coordinationFeatureId,
+    workItemId: coordinationWorkItemId,
+    homeDir: os.homedir(),
+    flockbayHomeDir: types.configuration.flockbayHomeDir,
+    flockbayLibDir: types.projectPath(),
+    flockbayToolsDir: path.resolve(types.projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: opts.startedBy || "terminal",
+    // Initialize lifecycle state
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: "codex"
+  };
+  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  const session = api.sessionSyncClient(response);
+  const elicitationHub = new index.ElicitationHub();
+  const permissionHandler = new CodexPermissionHandler(session, { elicitationHub });
+  try {
+    types.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await index.notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      types.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
+      types.logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    types.logger.debug("[START] Failed to report to daemon (may not be running):", error);
+  }
+  const messageQueue = new index.MessageQueue2((mode) => hashCodexSessionModeFromEnhancedMode(mode));
+  const autoPrompt = String(process.env.FLOCKBAY_AUTO_PROMPT || "").trim();
+  if (autoPrompt) {
+    messageQueue.push(autoPrompt, {
+      permissionMode: "default",
+      model: void 0,
+      appendSystemPrompt: index.PLATFORM_SYSTEM_PROMPT
+    });
+  }
+  const bypassUeGates = String(process.env.FLOCKBAY_DEV_BYPASS_UE_GATES || "") === "1";
+  let currentPermissionMode = void 0;
+  let currentModel = void 0;
+  const defaultAppendSystemPrompt = index.PLATFORM_SYSTEM_PROMPT;
+  let currentAppendSystemPrompt = defaultAppendSystemPrompt;
+  session.onUserMessage((message) => {
+    const images = Array.isArray(message.meta?.attachments?.images) ? message.meta.attachments.images : [];
+    if (images.length > 0) {
+      index.setLatestUserImages(images);
+    }
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      const validModes = ["default", "always-ask", "read-only", "safe-yolo", "yolo"];
+      if (validModes.includes(message.meta.permissionMode)) {
+        messagePermissionMode = message.meta.permissionMode;
+        currentPermissionMode = messagePermissionMode;
+        permissionHandler.setPermissionMode(currentPermissionMode);
+        types.logger.debug(`[Codex] Permission mode updated from user message to: ${currentPermissionMode}`);
+      } else {
+        types.logger.debug(`[Codex] Invalid permission mode received: ${message.meta.permissionMode}`);
+      }
+    } else {
+      types.logger.debug(`[Codex] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
+    }
+    let messageModel = currentModel;
+    if (message.meta?.hasOwnProperty("model")) {
+      messageModel = message.meta.model || void 0;
+      currentModel = messageModel;
+      types.logger.debug(`[Codex] Model updated from user message: ${messageModel || "reset to default"}`);
+    } else {
+      types.logger.debug(`[Codex] User message received with no model override, using current: ${currentModel || "default"}`);
+    }
+    let messageAppendSystemPrompt = currentAppendSystemPrompt;
+    if (message.meta?.hasOwnProperty("appendSystemPrompt")) {
+      const raw = message.meta.appendSystemPrompt;
+      messageAppendSystemPrompt = typeof raw === "string" && raw.trim().length > 0 ? raw : defaultAppendSystemPrompt;
+      currentAppendSystemPrompt = messageAppendSystemPrompt;
+      types.logger.debug(`[Codex] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to default"}`);
+    } else {
+      types.logger.debug(`[Codex] User message received with no appendSystemPrompt override, using current: ${currentAppendSystemPrompt ? "set" : "default"}`);
+    }
+    const enhancedMode = {
+      permissionMode: messagePermissionMode || "default",
+      model: messageModel,
+      appendSystemPrompt: messageAppendSystemPrompt
+    };
+    const rawText = normalizeUserToolAliases(message.content.text);
+    const promptText = images.length > 0 ? index.withUserImagesMarker(
+      [
+        `User attached ${images.length} image${images.length === 1 ? "" : "s"}.`,
+        `You MUST call \`mcp__flockbay__latest_user_images\` with {"limit": ${images.length}} BEFORE replying.`,
+        `If the tool call fails or returns no images, reply exactly: image-attachment-missing`,
+        `Then answer the user's message:`,
+        rawText
+      ].join("\n\n"),
+      images.length
+    ) : rawText;
+    messageQueue.push(promptText, enhancedMode, images.length > 0 ? { isolate: true } : void 0);
+  });
+  let thinking = false;
+  session.keepAlive(thinking, "remote");
+  const keepAliveInterval = setInterval(() => {
+    session.keepAlive(thinking, "remote");
+  }, 2e3);
+  const sendReady = () => {
+    session.sendSessionEvent({ type: "ready" });
+    try {
+      api.push().sendToAllDevices(
+        "It's ready!",
+        "Codex is waiting for your command",
+        { sessionId: session.sessionId }
+      );
+    } catch (pushError) {
+      types.logger.debug("[Codex] Failed to send ready push", pushError);
+    }
+  };
+  function logActiveHandles(tag) {
+    if (!process.env.DEBUG) return;
+    const anyProc = process;
+    const handles = typeof anyProc._getActiveHandles === "function" ? anyProc._getActiveHandles() : [];
+    const requests = typeof anyProc._getActiveRequests === "function" ? anyProc._getActiveRequests() : [];
+    types.logger.debug(`[codex][handles] ${tag}: handles=${handles.length} requests=${requests.length}`);
+    try {
+      const kinds = handles.map((h) => h && h.constructor ? h.constructor.name : typeof h);
+      types.logger.debug(`[codex][handles] kinds=${JSON.stringify(kinds)}`);
+    } catch (error) {
+      console.error("[codex][handles] Failed to serialize active handles:", error);
+      types.logger.debug("[codex][handles] Failed to serialize active handles:", error);
+    }
+  }
+  let abortController = new AbortController();
+  let shouldExit = false;
+  let storedConversationIdForRecovery = null;
+  async function handleAbort() {
+    types.logger.debug("[Codex] Abort requested - stopping current task");
+    try {
+      abortController.abort();
+      messageQueue.reset();
+      permissionHandler.reset();
+      reasoningProcessor.abort();
+      diffProcessor.reset();
+      types.logger.debug("[Codex] Abort completed - session remains active");
+    } catch (error) {
+      types.logger.debug("[Codex] Error during abort:", error);
+    } finally {
+      abortController = new AbortController();
+    }
+  }
+  const handleKillSession = async () => {
+    types.logger.debug("[Codex] Kill session requested - terminating process");
+    await handleAbort();
+    types.logger.debug("[Codex] Abort completed, proceeding with termination");
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      index.stopCaffeinate();
+      flockbayServer.stop();
+      types.logger.debug("[Codex] Session termination complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      types.logger.debug("[Codex] Error during session termination:", error);
+      process.exit(1);
+    }
+  };
+  session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  index.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
+  const messageBuffer = new index.MessageBuffer();
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  let inkInstance = null;
+  if (hasTTY) {
+    console.clear();
+    inkInstance = ink.render(React.createElement(CodexDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? types.logger.getLogPath() : void 0,
+      onExit: async () => {
+        types.logger.debug("[codex]: Exiting agent via Ctrl-C");
+        shouldExit = true;
+        await handleAbort();
+      }
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.setEncoding("utf8");
+  }
+  const client = new CodexMcpClient();
+  function findCodexResumeFile(conversationId) {
+    if (!conversationId) return null;
+    try {
+      let collectFilesRecursive2 = function(dir, acc = []) {
+        let entries;
+        try {
+          entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+          return acc;
+        }
+        for (const entry of entries) {
+          const full = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            collectFilesRecursive2(full, acc);
+          } else if (entry.isFile()) {
+            acc.push(full);
+          }
+        }
+        return acc;
+      };
+      var collectFilesRecursive = collectFilesRecursive2;
+      const codexHomeDir = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+      const rootDir = path.join(codexHomeDir, "sessions");
+      const allJsonl = collectFilesRecursive2(rootDir).filter((full) => full.endsWith(".jsonl")).filter((full) => {
+        try {
+          return fs.statSync(full).isFile();
+        } catch {
+          return false;
+        }
+      });
+      const candidates = allJsonl.filter((full) => full.includes(conversationId)).sort((a, b) => {
+        const sa = fs.statSync(a).mtimeMs;
+        const sb = fs.statSync(b).mtimeMs;
+        return sb - sa;
+      });
+      if (candidates.length === 0 && process.env.DEBUG) {
+        types.logger.debug("[Codex] No resume transcript match", {
+          conversationId,
+          rootDir,
+          jsonlCount: allJsonl.length
+        });
+      }
+      return candidates[0] || null;
+    } catch {
+      return null;
+    }
+  }
+  const reasoningProcessor = new ReasoningProcessor((message) => {
+    session.sendCodexMessage(message);
+  });
+  const diffProcessor = new DiffProcessor((message) => {
+    session.sendCodexMessage(message);
+  });
+  const codexToolCallIds = /* @__PURE__ */ new Map();
+  const isScreenshotToolName = (name) => {
+    const n = typeof name === "string" ? name : "";
+    return /unreal_(latest_screenshots|headless_screenshot|fast_preview)/i.test(n);
+  };
+  const summarizeScreenshotOutput = (output) => {
+    try {
+      const views = Array.isArray(output?.views) ? output.views : null;
+      if (!views || views.length === 0) return { views: 0, firstUrl: null };
+      const firstUrl = typeof views[0]?.url === "string" ? String(views[0].url) : typeof views[0]?.imageId === "string" ? String(views[0].imageId) : null;
+      return { views: views.length, firstUrl };
+    } catch {
+      return null;
+    }
+  };
+  const screenshotGate = {
+    paths: [],
+    seen: /* @__PURE__ */ new Set(),
+    hasImageBlocks: false,
+    inAutoReview: false
+  };
+  const resetScreenshotGateForTurn = () => {
+    screenshotGate.paths = [];
+    screenshotGate.seen.clear();
+    screenshotGate.hasImageBlocks = false;
+    screenshotGate.inAutoReview = false;
+  };
+  const collectScreenshotsForGate = (output) => {
+    if (!output) return;
+    const cwdHint = output?.cwd;
+    const cwd = typeof cwdHint === "string" && cwdHint.trim().length > 0 ? cwdHint.trim() : process.cwd();
+    const detected = flockbayScreenshotGate.detectScreenshotsForGate({ output, cwd });
+    if (detected.paths.length === 0) return;
+    if (detected.hasImageBlocks) screenshotGate.hasImageBlocks = true;
+    for (const p of detected.paths) {
+      const trimmed = String(p || "").trim();
+      if (!trimmed) continue;
+      if (screenshotGate.seen.has(trimmed)) continue;
+      screenshotGate.seen.add(trimmed);
+      screenshotGate.paths.push(trimmed);
+    }
+  };
+  const buildScreenshotAutoReviewPrompt = (paths) => {
+    const unique = Array.from(new Set(paths.map((p) => String(p || "").trim()).filter(Boolean)));
+    const toolArgs = JSON.stringify({
+      paths: unique,
+      limit: unique.length,
+      upload: false,
+      includeToolImages: true
+    }, null, 2);
+    return index.trimIdent(`
+            You just generated ${unique.length} screenshot${unique.length === 1 ? "" : "s"}.
+
+            Before doing anything else, call \`mcp__flockbay__read_images\` with:
+            ${toolArgs}
+
+            Then visually inspect EVERY screenshot and report:
+            - One short bullet per image ("Image N: ...") describing what you see
+            - Whether the screenshots match the user's request
+
+            Do not run any other tools in this step.
+        `);
+  };
+  client.setPermissionHandler(permissionHandler);
+  const execInflight = /* @__PURE__ */ new Set();
+  const execAliasToCallId = /* @__PURE__ */ new Map();
+  client.setHandler((msg) => {
+    try {
+      const preview = typeof msg?.type === "string" ? msg.type : "unknown";
+      types.logger.debug(`[Codex] MCP message: type=${preview}`);
+    } catch {
+      types.logger.debug("[Codex] MCP message received");
+    }
+    const extractCallId = (event) => {
+      if (!event || typeof event !== "object") return null;
+      const asIdString = (value) => {
+        if (typeof value === "string") {
+          const trimmed = value.trim();
+          if (!trimmed || trimmed === "undefined") return null;
+          return trimmed;
+        }
+        if (typeof value === "number" && Number.isFinite(value)) return String(value);
+        if (typeof value === "bigint") return String(value);
+        return null;
+      };
+      const nestedCandidates = [
+        event?.command?.call_id,
+        event?.command?.callId,
+        event?.command?.command_id,
+        event?.command?.commandId,
+        event?.command?.exec_id,
+        event?.command?.execId,
+        event?.command?.id,
+        event?.request?.call_id,
+        event?.request?.callId,
+        event?.request?.id,
+        event?.request?.uuid,
+        event?.request_id,
+        event?.requestId,
+        event?.tool_use_id,
+        event?.toolUseId,
+        event?.tool_use_uuid,
+        event?.toolUseUuid,
+        event?.tool_call_id,
+        event?.toolCallId,
+        event?.tool_call_uuid,
+        event?.toolCallUuid,
+        event?.tool?.call_id,
+        event?.tool?.callId,
+        event?.tool?.id,
+        event?.tool?.uuid,
+        event?.params?.call_id,
+        event?.params?.callId,
+        event?.params?.id,
+        event?.params?.uuid,
+        event?.data?.call_id,
+        event?.data?.callId,
+        event?.data?.id,
+        event?.data?.uuid
+      ];
+      const candidates = [
+        event.call_id,
+        event.callId,
+        event.codex_call_id,
+        event.codexCallId,
+        event.tool_call_id,
+        event.toolCallId,
+        event.command_id,
+        event.commandId,
+        event.exec_id,
+        event.execId,
+        event.id,
+        event.uuid,
+        event.event_id,
+        event.eventId,
+        ...nestedCandidates
+      ];
+      for (const value of candidates) {
+        const id = asIdString(value);
+        if (id) return id;
+      }
+      return null;
+    };
+    const getCallIdAliases = (event) => {
+      if (!event || typeof event !== "object") return [];
+      const raw = [
+        event.call_id,
+        event.callId,
+        event.codex_call_id,
+        event.codexCallId,
+        event.tool_call_id,
+        event.toolCallId,
+        event.command_id,
+        event.commandId,
+        event.exec_id,
+        event.execId,
+        event.id,
+        event?.command?.call_id,
+        event?.command?.callId,
+        event?.command?.command_id,
+        event?.command?.commandId,
+        event?.command?.exec_id,
+        event?.command?.execId,
+        event?.command?.id,
+        event?.request?.call_id,
+        event?.request?.callId,
+        event?.request?.id,
+        event?.request_id,
+        event?.requestId,
+        event?.tool_use_id,
+        event?.toolUseId
+      ];
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const v of raw) {
+        if (typeof v !== "string") continue;
+        const s = v.trim();
+        if (!s || s === "undefined") continue;
+        if (seen.has(s)) continue;
+        seen.add(s);
+        out.push(s);
+      }
+      return out;
+    };
+    const rememberExecAliases = (canonicalCallId, event) => {
+      for (const alias of getCallIdAliases(event)) {
+        execAliasToCallId.set(alias, canonicalCallId);
+      }
+    };
+    const resolveExecCallId = (event, allowCreate) => {
+      const aliases = getCallIdAliases(event);
+      for (const a of aliases) {
+        const mapped = execAliasToCallId.get(a);
+        if (mapped) return mapped;
+      }
+      const extracted = extractCallId(event);
+      if (extracted) return extracted;
+      if (!allowCreate) return null;
+      return null;
+    };
+    const markExecStarted = (callId, event) => {
+      rememberExecAliases(callId, event);
+      if (execInflight.has(callId)) return;
+      execInflight.add(callId);
+    };
+    const markExecFinished = (callId) => {
+      execInflight.delete(callId);
+      for (const [alias, mapped] of execAliasToCallId.entries()) {
+        if (mapped === callId) execAliasToCallId.delete(alias);
+      }
+    };
+    const flushInflightExecCalls = (opts2) => {
+      if (execInflight.size === 0) return;
+      for (const callId of Array.from(execInflight)) {
+        session.sendCodexMessage({
+          type: "tool-call-result",
+          callId,
+          output: { ok: !opts2.isError, reason: opts2.reason, missing_exec_command_end: true },
+          is_error: opts2.isError,
+          id: node_crypto.randomUUID()
+        });
+        markExecFinished(callId);
+      }
+    };
+    const normalizeMcpToolName = (serverName, toolName) => {
+      const rawName = toolName.trim();
+      if (!rawName) return "unknown";
+      if (rawName.startsWith("mcp__") || rawName.startsWith("functions.mcp__")) return rawName.replace(/^functions\./, "");
+      const separatorMatch = rawName.match(/^([A-Za-z0-9_-]+)[:.](.+)$/);
+      if (separatorMatch) {
+        const [, server, tool] = separatorMatch;
+        return `mcp__${server}__${tool}`;
+      }
+      if (serverName) {
+        return `mcp__${serverName}__${rawName}`;
+      }
+      return rawName;
+    };
+    const extractMcpServerName = (event) => {
+      const candidates = [
+        event?.server_name,
+        event?.serverName,
+        event?.mcp_server,
+        event?.mcpServer,
+        event?.server,
+        event?.tool?.server_name,
+        event?.tool?.serverName,
+        event?.tool?.server,
+        event?.params?.server_name,
+        event?.params?.serverName,
+        event?.params?.server,
+        event?.data?.server_name,
+        event?.data?.serverName,
+        event?.data?.server
+      ];
+      for (const value of candidates) {
+        if (typeof value === "string" && value.trim().length > 0) return value;
+      }
+      return null;
+    };
+    const extractMcpToolName = (event) => {
+      const candidates = [
+        event?.tool_name,
+        event?.toolName,
+        event?.mcp_tool_name,
+        event?.mcpToolName,
+        event?.name,
+        event?.tool?.name,
+        event?.tool?.tool_name,
+        event?.tool?.toolName,
+        event?.params?.tool_name,
+        event?.params?.toolName,
+        event?.params?.name,
+        event?.data?.tool_name,
+        event?.data?.toolName,
+        event?.data?.name
+      ];
+      for (const value of candidates) {
+        if (typeof value === "string" && value.trim().length > 0) return value;
+      }
+      return null;
+    };
+    const extractToolInput = (event) => {
+      const candidates = [
+        event?.arguments,
+        event?.args,
+        event?.input,
+        event?.params,
+        event?.tool_arguments,
+        event?.toolArguments,
+        event?.tool?.arguments,
+        event?.tool?.args,
+        event?.tool?.input,
+        event?.params?.arguments,
+        event?.params?.args,
+        event?.params?.input,
+        event?.data?.arguments,
+        event?.data?.args,
+        event?.data?.input
+      ];
+      for (const value of candidates) {
+        if (value !== void 0) return value;
+      }
+      return void 0;
+    };
+    const extractToolOutput = (event) => {
+      const candidates = [
+        event?.output,
+        event?.result,
+        event?.data,
+        event?.response,
+        event?.tool_result,
+        event?.toolResult,
+        event?.tool?.output,
+        event?.tool?.result,
+        event?.params?.output,
+        event?.params?.result,
+        event?.params?.response
+      ];
+      for (const value of candidates) {
+        if (value !== void 0) return value;
+      }
+      return void 0;
+    };
+    const shouldConsiderMcpToolEvent = (event) => {
+      if (!event || typeof event !== "object") return false;
+      if (event.type === "exec_command_begin" || event.type === "exec_approval_request" || event.type === "exec_command_end") return false;
+      if (event.type === "patch_apply_begin" || event.type === "patch_apply_end") return false;
+      if (event.type === "token_count") return false;
+      const toolNameRaw = extractMcpToolName(event);
+      if (!toolNameRaw) return false;
+      if (toolNameRaw === "CodexBash" || toolNameRaw === "CodexPatch") return false;
+      const serverName = extractMcpServerName(event);
+      if (serverName) return true;
+      if (toolNameRaw.startsWith("mcp__") || toolNameRaw.startsWith("functions.mcp__")) return true;
+      if (/^([A-Za-z0-9_-]+)[:.].+$/.test(toolNameRaw)) return true;
+      return /unreal_(latest_screenshots|headless_screenshot|fast_preview)|flockbay__/i.test(toolNameRaw);
+    };
+    const isMcpToolResultLike = (event) => {
+      if (!shouldConsiderMcpToolEvent(event)) return false;
+      const hasOutput = extractToolOutput(event) !== void 0 || event && typeof event === "object" && ("content" in event || "stdout" in event || "stderr" in event);
+      const type = typeof event?.type === "string" ? event.type : "";
+      return Boolean(hasOutput) || /(result|end|finished|complete)/i.test(type);
+    };
+    const isMcpToolBeginLike = (event) => {
+      if (!shouldConsiderMcpToolEvent(event)) return false;
+      if (isMcpToolResultLike(event)) return false;
+      const hasInput = extractToolInput(event) !== void 0;
+      const type = typeof event?.type === "string" ? event.type : "";
+      return Boolean(hasInput) || /(begin|start|call)/i.test(type);
+    };
+    const maybeEmitMcpToolCall = (event) => {
+      const callId = extractCallId(event);
+      if (!callId) return;
+      const toolNameRaw = extractMcpToolName(event);
+      if (!toolNameRaw) return;
+      const serverName = extractMcpServerName(event);
+      const toolName = normalizeMcpToolName(serverName, toolNameRaw);
+      const input = extractToolInput(event) ?? {};
+      codexToolCallIds.set(callId, toolName);
+      if (isScreenshotToolName(toolName)) {
+        console.error("[screenshots-diag] emit tool-call", { callId, toolName });
+      }
+      session.sendCodexMessage({
+        type: "tool-call",
+        name: toolName,
+        callId,
+        input,
+        id: node_crypto.randomUUID()
+      });
+    };
+    const maybeEmitMcpToolResult = (event) => {
+      const callId = extractCallId(event);
+      if (!callId) return;
+      const toolNameRaw = extractMcpToolName(event);
+      const serverName = extractMcpServerName(event);
+      const toolName = toolNameRaw ? normalizeMcpToolName(serverName, toolNameRaw) : codexToolCallIds.get(callId) ?? null;
+      if (toolName && !codexToolCallIds.has(callId)) {
+        codexToolCallIds.set(callId, toolName);
+        session.sendCodexMessage({
+          type: "tool-call",
+          name: toolName,
+          callId,
+          input: extractToolInput(event) ?? {},
+          id: node_crypto.randomUUID()
+        });
+      }
+      const output = extractToolOutput(event) ?? event;
+      const is_error = Boolean(event?.is_error ?? event?.isError ?? event?.error);
+      collectScreenshotsForGate(output);
+      try {
+        index.applyCoordinationSideEffectsFromMcpToolResult({
+          session,
+          toolName,
+          output,
+          isError: is_error
+        });
+      } catch (err) {
+        types.logger.debug("[codex] Failed applying coordination side effects from MCP tool result", {
+          toolName,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      if (isScreenshotToolName(toolName ?? void 0)) {
+        console.error("[screenshots-diag] emit tool-call-result", {
+          callId,
+          toolName,
+          is_error,
+          ...summarizeScreenshotOutput(output)
+        });
+      }
+      session.sendCodexMessage({
+        type: "tool-call-result",
+        callId,
+        output,
+        is_error,
+        id: node_crypto.randomUUID()
+      });
+    };
+    const MAX_TOOL_RESULT_CHARS = 512e3;
+    const tailTruncate = (value) => {
+      if (typeof value !== "string") return { value, truncated: false };
+      if (value.length <= MAX_TOOL_RESULT_CHARS) return { value, truncated: false };
+      return { value: value.slice(-MAX_TOOL_RESULT_CHARS), truncated: true };
+    };
+    const sanitizeExecCommandEndOutput = (output) => {
+      const next = { ...output };
+      const truncatedFields = [];
+      for (const [key, value] of Object.entries(next)) {
+        const { value: clipped, truncated } = tailTruncate(value);
+        if (truncated) {
+          next[key] = clipped;
+          truncatedFields.push(key);
+        }
+      }
+      if (typeof next.output === "string" && typeof next.stdout !== "string" && typeof next.stderr !== "string") {
+        next.stdout = next.output;
+        next.stdoutFromOutput = true;
+      }
+      if (truncatedFields.length) {
+        next.outputTruncated = true;
+        next.truncatedFields = truncatedFields;
+      }
+      return next;
+    };
+    if (msg.type === "agent_message") {
+      messageBuffer.addMessage(msg.message, "assistant");
+    } else if (msg.type === "agent_reasoning_delta") ; else if (msg.type === "agent_reasoning") {
+      messageBuffer.addMessage(`[Thinking] ${msg.text.substring(0, 100)}...`, "system");
+    } else if (msg.type === "exec_command_begin") {
+      messageBuffer.addMessage(`Executing: ${msg.command}`, "tool");
+    } else if (msg.type === "exec_command_end") {
+      const output = msg.output || msg.error || "Command completed";
+      const truncatedOutput = output.substring(0, 200);
+      messageBuffer.addMessage(
+        `Result: ${truncatedOutput}${output.length > 200 ? "..." : ""}`,
+        "result"
+      );
+    } else if (msg.type === "task_started") {
+      messageBuffer.addMessage("Starting task...", "status");
+    } else if (msg.type === "task_complete") {
+      messageBuffer.addMessage("Task completed", "status");
+      flushInflightExecCalls({ isError: false, reason: "task_complete" });
+      sendReady();
+    } else if (msg.type === "turn_aborted") {
+      messageBuffer.addMessage("Turn aborted", "status");
+      flushInflightExecCalls({ isError: true, reason: "turn_aborted" });
+      sendReady();
+    }
+    if (msg.type === "task_started") {
+      if (!thinking) {
+        types.logger.debug("thinking started");
+        thinking = true;
+        session.keepAlive(thinking, "remote");
+      }
+    }
+    if (msg.type === "task_complete" || msg.type === "turn_aborted") {
+      if (thinking) {
+        types.logger.debug("thinking completed");
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+      }
+      diffProcessor.reset();
+    }
+    if (msg.type === "agent_reasoning_section_break") {
+      reasoningProcessor.handleSectionBreak();
+    }
+    if (msg.type === "agent_reasoning_delta") {
+      reasoningProcessor.processDelta(msg.delta);
+    }
+    if (msg.type === "agent_reasoning") {
+      reasoningProcessor.complete(msg.text);
+    }
+    if (msg.type === "agent_message") {
+      session.sendCodexMessage({
+        type: "message",
+        message: msg.message,
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "exec_command_begin" || msg.type === "exec_approval_request") {
+      const callId = resolveExecCallId(msg, true);
+      if (!callId) {
+        console.error("[codexbash-diag] Missing call id for exec begin/approval event", {
+          type: msg.type,
+          keys: Object.keys(msg || {})
+        });
+        throw new Error("Missing call id for exec begin/approval event");
+      }
+      if (msg.type === "exec_command_begin") {
+        try {
+          console.error("[codexbash-diag] exec begin callId", { callId, aliases: getCallIdAliases(msg) });
+        } catch {
+        }
+      }
+      markExecStarted(callId, msg);
+      let { call_id, callId: _callId, type, ...inputs } = msg;
+      session.sendCodexMessage({
+        type: "tool-call",
+        name: "CodexBash",
+        callId,
+        input: inputs,
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "exec_command_end") {
+      const callId = resolveExecCallId(msg, false);
+      if (!callId) {
+        console.error("[codexbash-diag] Missing call id for exec end event", {
+          keys: Object.keys(msg || {})
+        });
+        throw new Error("Missing call id for exec end event");
+      }
+      rememberExecAliases(callId, msg);
+      try {
+        console.error("[codexbash-diag] exec end callId", { callId, aliases: getCallIdAliases(msg) });
+      } catch {
+      }
+      let { call_id, callId: _callId, type, ...output } = msg;
+      const sanitized = sanitizeExecCommandEndOutput(output);
+      collectScreenshotsForGate({ ...sanitized, cwd: output?.cwd ?? sanitized?.cwd ?? msg?.cwd });
+      session.sendCodexMessage({
+        type: "tool-call-result",
+        callId,
+        output: sanitized,
+        is_error: Boolean(sanitized?.error) || sanitized?.success === false,
+        id: node_crypto.randomUUID()
+      });
+      markExecFinished(callId);
+    }
+    if (msg.type === "token_count") {
+      return;
+    }
+    if (msg.type === "patch_apply_begin") {
+      const callId = extractCallId(msg);
+      if (!callId) {
+        types.logger.debug("[Codex] Missing call id for patch apply begin", { keys: Object.keys(msg || {}) });
+        return;
+      }
+      let { call_id, callId: _callId, auto_approved, changes } = msg;
+      const changeCount = Object.keys(changes).length;
+      const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
+      messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
+      session.sendCodexMessage({
+        type: "tool-call",
+        name: "CodexPatch",
+        callId,
+        input: {
+          auto_approved,
+          changes
+        },
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "patch_apply_end") {
+      const callId = extractCallId(msg);
+      if (!callId) {
+        types.logger.debug("[Codex] Missing call id for patch apply end", { keys: Object.keys(msg || {}) });
+        return;
+      }
+      let { call_id, callId: _callId, stdout, stderr, success } = msg;
+      if (success) {
+        const message = stdout || "Files modified successfully";
+        messageBuffer.addMessage(message.substring(0, 200), "result");
+      } else {
+        const errorMsg = stderr || "Failed to modify files";
+        messageBuffer.addMessage(`Error: ${errorMsg.substring(0, 200)}`, "result");
+      }
+      session.sendCodexMessage({
+        type: "tool-call-result",
+        callId,
+        output: {
+          stdout,
+          stderr,
+          success
+        },
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "turn_diff") {
+      if (msg.unified_diff) {
+        diffProcessor.processDiff(msg.unified_diff);
+      }
+    }
+    if (isMcpToolBeginLike(msg)) {
+      maybeEmitMcpToolCall(msg);
+    }
+    if (isMcpToolResultLike(msg)) {
+      maybeEmitMcpToolResult(msg);
+    }
+  });
+  const flockbayServer = await index.startFlockbayServer(session, { elicitationHub });
+  const bridgeCommand = path.join(types.projectPath(), "bin", "flockbay-mcp.mjs");
+  const mcpServers = {
+    flockbay: {
+      command: bridgeCommand,
+      args: ["--url", flockbayServer.url]
+    }
+  };
+  let first = true;
+  try {
+    types.logger.debug("[codex]: client.connect begin");
+    try {
+      await client.connect();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const details = error instanceof Error ? error.stack : void 0;
+      types.logger.warn("[codex]: client.connect failed", { message, details });
+      session.sendCodexMessage({
+        type: "message",
+        message: `Codex can\u2019t start on this machine because the \`codex\` CLI isn\u2019t available in the daemon\u2019s environment.
+
+Fix:
+- Install Codex CLI (or ensure it\u2019s on PATH for launchd/daemon)
+- Or set \`FLOCKBAY_CODEX_BIN\` to the full path of the \`codex\` binary
+- Or switch this session to Claude/Gemini
+
+Error: ${message}`,
+        id: node_crypto.randomUUID()
+      });
+      sendReady();
+      await session.flush();
+      return;
+    }
+    types.logger.debug("[codex]: client.connect done");
+    let wasCreated = false;
+    let currentModeHash = null;
+    let pending = null;
+    let nextExperimentalResume = null;
+    while (!shouldExit) {
+      logActiveHandles("loop-top");
+      let message = pending;
+      pending = null;
+      if (!message) {
+        const waitSignal = abortController.signal;
+        const batch = await messageQueue.waitForMessagesAndGetAsString(waitSignal);
+        if (!batch) {
+          if (waitSignal.aborted && !shouldExit) {
+            types.logger.debug("[codex]: Wait aborted while idle; ignoring and continuing");
+            continue;
+          }
+          types.logger.debug(`[codex]: batch=${!!batch}, shouldExit=${shouldExit}`);
+          break;
+        }
+        message = batch;
+      }
+      if (!message) {
+        break;
+      }
+      if (wasCreated && currentModeHash && message.hash !== currentModeHash) {
+        types.logger.debug("[Codex] Mode changed \u2013 restarting Codex session");
+        messageBuffer.addMessage("\u2550".repeat(40), "status");
+        messageBuffer.addMessage("Starting new Codex session (mode changed)...", "status");
+        try {
+          const prevConversationId = client.getConversationId() || client.getSessionId();
+          nextExperimentalResume = findCodexResumeFile(prevConversationId);
+          if (nextExperimentalResume) {
+            types.logger.debug(`[Codex] Found resume file for conversation ${prevConversationId}: ${nextExperimentalResume}`);
+            messageBuffer.addMessage("Resuming previous context\u2026", "status");
+          } else {
+            types.logger.debug("[Codex] No resume file found for previous session");
+          }
+        } catch (e) {
+          types.logger.debug("[Codex] Error while searching resume file", e);
+        }
+        client.clearSession();
+        wasCreated = false;
+        currentModeHash = null;
+        pending = message;
+        permissionHandler.reset();
+        reasoningProcessor.abort();
+        diffProcessor.reset();
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+        continue;
+      }
+      messageBuffer.addMessage(message.message, "user");
+      currentModeHash = message.hash;
+      let skipAutoFinalize = false;
+      try {
+        resetScreenshotGateForTurn();
+        const overrides = { approvalPolicy: "untrusted", sandbox: "workspace-write" };
+        if (!bypassUeGates) {
+          const detection = await index.detectUnrealProject(process.cwd());
+          if (!detection.ok) {
+            session.sendCodexMessage({
+              type: "message",
+              message: "Select an Unreal project folder (the folder containing a *.uproject) to continue.",
+              id: node_crypto.randomUUID()
+            });
+            if (wasCreated) {
+              client.clearSession();
+              wasCreated = false;
+              currentModeHash = null;
+            }
+            continue;
+          }
+        }
+        if (!wasCreated) {
+          const projectCapsule = await index.buildProjectCapsule({ startDir: process.cwd() });
+          const modelOverride = resolveCodexModelOverride(message.mode.model);
+          const startConfig = {
+            prompt: message.message,
+            config: { mcp_servers: mcpServers }
+          };
+          startConfig.sandbox = overrides.sandbox;
+          startConfig["approval-policy"] = overrides.approvalPolicy;
+          if (modelOverride.config && typeof startConfig.config === "object" && startConfig.config) {
+            startConfig.config = { ...startConfig.config, ...modelOverride.config };
+          }
+          startConfig["developer-instructions"] = sanitizeCodexInstructions(
+            [
+              FLOCKBAY_CODEX_BASE_INSTRUCTIONS,
+              message.mode.appendSystemPrompt,
+              projectCapsule
+            ].filter((v) => typeof v === "string" && v.trim().length > 0).join("\n\n")
+          );
+          let resumeFile = null;
+          if (nextExperimentalResume) {
+            resumeFile = nextExperimentalResume;
+            nextExperimentalResume = null;
+            types.logger.debug("[Codex] Using resume file from mode change:", resumeFile);
+          } else if (storedConversationIdForRecovery) {
+            const recoveryResumeFile = findCodexResumeFile(storedConversationIdForRecovery);
+            if (recoveryResumeFile) {
+              resumeFile = recoveryResumeFile;
+              types.logger.debug("[Codex] Using resume file from previous session (error recovery):", resumeFile);
+            }
+            storedConversationIdForRecovery = null;
+          }
+          if (resumeFile) {
+            startConfig.config.experimental_resume = resumeFile;
+          }
+          await client.startSession(
+            startConfig,
+            { signal: abortController.signal }
+          );
+          wasCreated = true;
+          first = false;
+        } else {
+          const response2 = await client.continueSession(
+            message.message,
+            { signal: abortController.signal }
+          );
+          types.logger.debug("[Codex] continueSession response:", response2);
+        }
+        if (!screenshotGate.inAutoReview && screenshotGate.paths.length > 0 && !screenshotGate.hasImageBlocks) {
+          screenshotGate.inAutoReview = true;
+          messageBuffer.addMessage("Auto-reviewing screenshots\u2026", "status");
+          const reviewPrompt = buildScreenshotAutoReviewPrompt(screenshotGate.paths);
+          await client.continueSession(reviewPrompt, { signal: abortController.signal });
+          screenshotGate.inAutoReview = false;
+        }
+      } catch (error) {
+        types.logger.warn("Error in codex session:", error);
+        const isAbortError = error instanceof Error && error.name === "AbortError";
+        if (isAbortError) {
+          skipAutoFinalize = true;
+          messageBuffer.addMessage("Aborted by user", "status");
+          session.sendSessionEvent({ type: "message", message: "Aborted by user" });
+          if (!client.hasActiveSession()) {
+            wasCreated = false;
+            currentModeHash = null;
+            types.logger.debug("[Codex] Abort occurred with no active session; will restart on next message");
+          } else {
+            wasCreated = true;
+            types.logger.debug("[Codex] Abort completed; keeping active session for next message");
+          }
+        } else {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          messageBuffer.addMessage(`Error: ${errorMessage}`, "status");
+          session.sendSessionEvent({ type: "message", message: `Error: ${errorMessage}` });
+          if (client.hasActiveSession()) {
+            storedConversationIdForRecovery = client.storeConversationForResume() || client.storeSessionForResume();
+            types.logger.debug("[Codex] Stored conversation after error:", storedConversationIdForRecovery);
+          }
+          client.clearSession();
+          wasCreated = false;
+          currentModeHash = null;
+        }
+      } finally {
+        permissionHandler.reset();
+        reasoningProcessor.abort();
+        diffProcessor.reset();
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+        if (!skipAutoFinalize) {
+          try {
+            const finalizeRes = await index.autoFinalizeCoordinationWorkItem({
+              token: session.getAuthToken(),
+              cwd: process.cwd(),
+              summary: message?.message ?? null
+            });
+            if (!finalizeRes.ok) {
+              const msg = `Auto-finalize failed: ${finalizeRes.error}`;
+              messageBuffer.addMessage(msg, "status");
+              session.sendSessionEvent({ type: "message", message: msg });
+            }
+          } catch (err) {
+            const msg = `Auto-finalize failed: ${err instanceof Error ? err.message : String(err)}`;
+            messageBuffer.addMessage(msg, "status");
+            session.sendSessionEvent({ type: "message", message: msg });
+          }
+        }
+        emitReadyIfIdle({
+          pending,
+          queueSize: () => messageQueue.size(),
+          shouldExit,
+          sendReady
+        });
+        logActiveHandles("after-turn");
+      }
+    }
+  } finally {
+    types.logger.debug("[codex]: Final cleanup start");
+    logActiveHandles("cleanup-start");
+    try {
+      types.logger.debug("[codex]: sendSessionDeath");
+      session.sendSessionDeath();
+      types.logger.debug("[codex]: flush begin");
+      await session.flush();
+      types.logger.debug("[codex]: flush done");
+      types.logger.debug("[codex]: session.close begin");
+      await session.close();
+      types.logger.debug("[codex]: session.close done");
+    } catch (e) {
+      types.logger.debug("[codex]: Error while closing session", e);
+    }
+    types.logger.debug("[codex]: client.disconnect begin");
+    await client.disconnect();
+    types.logger.debug("[codex]: client.disconnect done");
+    types.logger.debug("[codex]: flockbayServer.stop");
+    flockbayServer.stop();
+    if (process.stdin.isTTY) {
+      types.logger.debug("[codex]: setRawMode(false)");
+      try {
+        process.stdin.setRawMode(false);
+      } catch (error) {
+        console.error("[codex] Failed to setRawMode(false) during cleanup:", error);
+        types.logger.debug("[codex] Failed to setRawMode(false) during cleanup:", error);
+      }
+    }
+    if (hasTTY) {
+      types.logger.debug("[codex]: stdin.pause()");
+      try {
+        process.stdin.pause();
+      } catch (error) {
+        console.error("[codex] Failed to pause stdin during cleanup:", error);
+        types.logger.debug("[codex] Failed to pause stdin during cleanup:", error);
+      }
+    }
+    types.logger.debug("[codex]: clearInterval(keepAlive)");
+    clearInterval(keepAliveInterval);
+    if (inkInstance) {
+      types.logger.debug("[codex]: inkInstance.unmount()");
+      inkInstance.unmount();
+    }
+    messageBuffer.clear();
+    logActiveHandles("cleanup-end");
+    types.logger.debug("[codex]: Final cleanup completed");
+  }
+}
+
+exports.emitReadyIfIdle = emitReadyIfIdle;
+exports.runCodex = runCodex;