hankweave 0.5.7 → 0.6.2

package/dist/shims/codex/index.js

@@ -1,230 +1,19 @@
 #!/usr/bin/env node
 
-// ../common/src/args.ts
-var VALID_SANDBOX_LEVELS = ["none", "standard", "strict"];
-function parseArgs(argv, aliases) {
-  const args = {
-    model: "",
-    verbose: false,
-    idleTimeout: 120,
-    sandbox: "none",
-    selfTest: false,
-    version: false,
-    help: false
-  };
-  for (let i = 0; i < argv.length; i++) {
-    let arg = argv[i];
-    if (arg.includes("=")) {
-      const [key, value] = arg.split("=", 2);
-      argv.splice(i, 1, key, value);
-      arg = key;
-    }
-    if (aliases && arg in aliases) {
-      arg = aliases[arg];
-    }
-    switch (arg) {
-      case "--model":
-        args.model = argv[++i];
-        break;
-      case "--resume":
-        args.resume = argv[++i];
-        break;
-      case "--verbose":
-        args.verbose = true;
-        break;
-      case "--append-system-prompt":
-        args.appendSystemPrompt = argv[++i];
-        break;
-      case "--debug-dir":
-        args.debugDir = argv[++i];
-        break;
-      case "--idle-timeout": {
-        const val = Number(argv[++i]);
-        if (!Number.isFinite(val) || val <= 0) {
-          console.error("Invalid --idle-timeout value: must be a positive number");
-          process.exit(1);
-        }
-        args.idleTimeout = val;
-        break;
-      }
-      case "--sandbox": {
-        const level = argv[++i];
-        if (!VALID_SANDBOX_LEVELS.includes(level)) {
-          console.error(
-            `Invalid --sandbox value: must be one of ${VALID_SANDBOX_LEVELS.join(", ")}`
-          );
-          process.exit(1);
-        }
-        args.sandbox = level;
-        break;
-      }
-      case "--self-test":
-        args.selfTest = true;
-        break;
-      case "--version":
-        args.version = true;
-        break;
-      case "--help":
-        args.help = true;
-        break;
-    }
-  }
-  return args;
-}
-
-// src/selftest.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { isAbsolute } from "path";
-
-// src/utils/auth.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-function getAuthFilePath() {
-  const homeDir = os.homedir();
-  return path.join(homeDir, ".codex", "auth.json");
-}
-function readAuthFile() {
-  try {
-    const authPath = getAuthFilePath();
-    if (!fs.existsSync(authPath)) {
-      return null;
-    }
-    return fs.readFileSync(authPath, "utf8");
-  } catch {
-    return null;
-  }
-}
-function getApiKey() {
-  const authFileKey = readAuthFile();
-  if (authFileKey) {
-    return { apiKey: authFileKey, source: "env" };
-  }
-  if (process.env.CODEX_API_KEY) {
-    return { apiKey: process.env.CODEX_API_KEY, source: "CODEX_API_KEY" };
-  }
-  if (process.env.OPENAI_API_KEY) {
-    return { apiKey: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
-  }
-  return { apiKey: null, source: "none" };
-}
-
-// src/selftest.ts
-async function isCodexInstalled() {
-  return new Promise((resolve) => {
-    const isWindows = process.platform === "win32";
-    const codexCommand = process.env.CODEX_PATH_OVERRIDE || "codex";
-    if (isAbsolute(codexCommand)) {
-      if (existsSync2(codexCommand)) {
-        const versionProc = spawn(codexCommand, ["--version"], { shell: isWindows });
-        let version = "unknown";
-        versionProc.stdout.on("data", (data) => {
-          version = data.toString().trim();
-        });
-        versionProc.on("close", () => {
-          resolve({ found: true, version });
-        });
-      } else {
-        resolve({ found: false, version: "N/A" });
-      }
-      return;
-    }
-    const whichCommand = isWindows ? "where" : "which";
-    const proc = spawn(whichCommand, [codexCommand], { shell: isWindows });
-    let found = false;
-    proc.on("close", (code) => {
-      if (code === 0) {
-        found = true;
-      }
-      if (found) {
-        const versionProc = spawn(codexCommand, ["--version"], { shell: isWindows });
-        let version = "unknown";
-        versionProc.stdout.on("data", (data) => {
-          version = data.toString().trim();
-        });
-        versionProc.on("close", () => {
-          resolve({ found: true, version });
-        });
-      } else {
-        resolve({ found: false, version: "N/A" });
-      }
-    });
-  });
-}
-function checkApiKey() {
-  const authConfig = getApiKey();
-  if (authConfig.apiKey) {
-    const sourceMessages = {
-      env: "API key found in ~/.codex/auth.json",
-      CODEX_API_KEY: "CODEX_API_KEY found in environment",
-      OPENAI_API_KEY: "OPENAI_API_KEY found in environment",
-      none: "No API key found"
-    };
-    return {
-      passed: true,
-      message: sourceMessages[authConfig.source] || "API key found"
-    };
-  } else {
-    return {
-      passed: false,
-      message: "No API key found. Set CODEX_API_KEY or OPENAI_API_KEY environment variable, or create ~/.codex/auth.json with apiKey field."
-    };
-  }
-}
-async function runSelfTest() {
-  const checks = [];
-  const codexStatus = await isCodexInstalled();
-  checks.push({
-    name: "codex_cli_found",
-    passed: codexStatus.found,
-    message: codexStatus.found ? `Codex CLI found (version: ${codexStatus.version})` : "Codex CLI not found in PATH. Install from https://developers.openai.com/codex/"
-  });
-  const apiKeyStatus = checkApiKey();
-  checks.push({
-    name: "api_key",
-    passed: apiKeyStatus.passed,
-    message: apiKeyStatus.message
-  });
-  const nodeVersion = process.version;
-  const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0]);
-  const nodeVersionOk = majorVersion >= 18;
-  checks.push({
-    name: "node_version",
-    passed: nodeVersionOk,
-    message: nodeVersionOk ? `Node.js version ${nodeVersion} is compatible` : `Node.js version ${nodeVersion} is too old. Requires Node.js 18+`
-  });
-  const allPassed = checks.every((c) => c.passed);
-  return {
-    shim: {
-      name: "codex-shim",
-      version: "1.0.0"
-    },
-    agent: {
-      name: "Codex",
-      version: codexStatus.version,
-      found: codexStatus.found
-    },
-    checks,
-    overall: {
-      passed: allPassed,
-      message: allPassed ? "All checks passed" : "Some checks failed"
-    }
-  };
-}
-
 // src/shim.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-
-// ../../node_modules/.bun/@openai+codex-sdk@0.98.0/node_modules/@openai/codex-sdk/dist/index.js
-import { promises as fs2 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import fs4 from "fs";
 import os2 from "os";
+import path6 from "path";
+
+// node_modules/@openai/codex-sdk/dist/index.js
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+import { spawn } from "child_process";
 import path2 from "path";
-import { spawn as spawn2 } from "child_process";
-import path22 from "path";
 import readline from "readline";
-import { fileURLToPath } from "url";
+import { createRequire } from "module";
 async function createOutputSchemaFile(schema) {
   if (schema === void 0) {
     return { cleanup: async () => {
@@ -233,16 +22,16 @@ async function createOutputSchemaFile(schema) {
   if (!isJsonObject(schema)) {
     throw new Error("outputSchema must be a plain JSON object");
   }
-  const schemaDir = await fs2.mkdtemp(path2.join(os2.tmpdir(), "codex-output-schema-"));
-  const schemaPath = path2.join(schemaDir, "schema.json");
+  const schemaDir = await fs.mkdtemp(path.join(os.tmpdir(), "codex-output-schema-"));
+  const schemaPath = path.join(schemaDir, "schema.json");
   const cleanup = async () => {
     try {
-      await fs2.rm(schemaDir, { recursive: true, force: true });
+      await fs.rm(schemaDir, { recursive: true, force: true });
     } catch {
     }
   };
   try {
-    await fs2.writeFile(schemaPath, JSON.stringify(schema), "utf8");
+    await fs.writeFile(schemaPath, JSON.stringify(schema), "utf8");
     return { schemaPath, cleanup };
   } catch (error) {
     await cleanup();
@@ -355,6 +144,16 @@ function normalizeInput(input) {
 }
 var INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
 var TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts";
+var CODEX_NPM_NAME = "@openai/codex";
+var PLATFORM_PACKAGE_BY_TARGET = {
+  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
+  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
+  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
+  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
+};
+var moduleRequire = createRequire(import.meta.url);
 var CodexExec = class {
   executablePath;
   envOverride;
@@ -437,7 +236,7 @@ var CodexExec = class {
     if (args.apiKey) {
       env.CODEX_API_KEY = args.apiKey;
     }
-    const child = spawn2(this.executablePath, commandArgs, {
+    const child = spawn(this.executablePath, commandArgs, {
       env,
       signal: args.signal
     });
@@ -567,8 +366,6 @@ function formatTomlKey(key) {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var scriptFileName = fileURLToPath(import.meta.url);
-var scriptDirName = path22.dirname(scriptFileName);
 function findCodexPath() {
   const { platform, arch } = process;
   let targetTriple = null;
@@ -616,10 +413,24 @@ function findCodexPath() {
   if (!targetTriple) {
     throw new Error(`Unsupported platform: ${platform} (${arch})`);
   }
-  const vendorRoot = path22.join(scriptDirName, "..", "vendor");
-  const archRoot = path22.join(vendorRoot, targetTriple);
+  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+  if (!platformPackage) {
+    throw new Error(`Unsupported target triple: ${targetTriple}`);
+  }
+  let vendorRoot;
+  try {
+    const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`);
+    const codexRequire = createRequire(codexPackageJsonPath);
+    const platformPackageJsonPath = codexRequire.resolve(`${platformPackage}/package.json`);
+    vendorRoot = path2.join(path2.dirname(platformPackageJsonPath), "vendor");
+  } catch {
+    throw new Error(
+      `Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`
+    );
+  }
+  const archRoot = path2.join(vendorRoot, targetTriple);
   const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-  const binaryPath = path22.join(archRoot, "codex", codexBinaryName);
+  const binaryPath = path2.join(archRoot, "codex", codexBinaryName);
   return binaryPath;
 }
 var Codex = class {
@@ -649,9 +460,81 @@ var Codex = class {
   }
 };
 
-// ../common/src/sessions.ts
+// node_modules/@shims/common/src/args.ts
+var VALID_SANDBOX_LEVELS = ["none", "standard", "strict"];
+function parseArgs(argv, aliases) {
+  const args = {
+    model: "",
+    verbose: false,
+    idleTimeout: 120,
+    sandbox: "none",
+    selfTest: false,
+    version: false,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    let arg = argv[i];
+    if (arg.includes("=")) {
+      const [key, value] = arg.split("=", 2);
+      argv.splice(i, 1, key, value);
+      arg = key;
+    }
+    if (aliases && arg in aliases) {
+      arg = aliases[arg];
+    }
+    switch (arg) {
+      case "--model":
+        args.model = argv[++i];
+        break;
+      case "--resume":
+        args.resume = argv[++i];
+        break;
+      case "--verbose":
+        args.verbose = true;
+        break;
+      case "--append-system-prompt":
+        args.appendSystemPrompt = argv[++i];
+        break;
+      case "--debug-dir":
+        args.debugDir = argv[++i];
+        break;
+      case "--idle-timeout": {
+        const val = Number(argv[++i]);
+        if (!Number.isFinite(val) || val <= 0) {
+          console.error("Invalid --idle-timeout value: must be a positive number");
+          process.exit(1);
+        }
+        args.idleTimeout = val;
+        break;
+      }
+      case "--sandbox": {
+        const level = argv[++i];
+        if (!VALID_SANDBOX_LEVELS.includes(level)) {
+          console.error(
+            `Invalid --sandbox value: must be one of ${VALID_SANDBOX_LEVELS.join(", ")}`
+          );
+          process.exit(1);
+        }
+        args.sandbox = level;
+        break;
+      }
+      case "--self-test":
+        args.selfTest = true;
+        break;
+      case "--version":
+        args.version = true;
+        break;
+      case "--help":
+        args.help = true;
+        break;
+    }
+  }
+  return args;
+}
+
+// node_modules/@shims/common/src/sessions.ts
 import { randomUUID } from "crypto";
-import fs3 from "fs";
+import fs2 from "fs";
 import path3 from "path";
 var SessionManager = class {
   sessionsDir;
@@ -665,7 +548,6 @@ var SessionManager = class {
       }
       this.sessionsDir = path3.join(home, ".shim", "sessions");
     }
-    fs3.mkdirSync(this.sessionsDir, { recursive: true });
   }
   /**
    * Generate a new UUID v4 session ID
@@ -677,8 +559,9 @@ var SessionManager = class {
    * Save session data
    */
   saveSession(data) {
+    this.ensureSessionsDir();
     const sessionPath = path3.join(this.sessionsDir, `${data.sessionId}.json`);
-    fs3.writeFileSync(sessionPath, JSON.stringify(data, null, 2), "utf8");
+    fs2.writeFileSync(sessionPath, JSON.stringify(data, null, 2), "utf8");
   }
   /**
    * Load session data by session ID
@@ -687,7 +570,7 @@ var SessionManager = class {
   loadSession(sessionId) {
     const sessionPath = path3.join(this.sessionsDir, `${sessionId}.json`);
     try {
-      const content = fs3.readFileSync(sessionPath, "utf8");
+      const content = fs2.readFileSync(sessionPath, "utf8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -701,7 +584,7 @@ var SessionManager = class {
    */
   sessionExists(sessionId) {
     const sessionPath = path3.join(this.sessionsDir, `${sessionId}.json`);
-    return fs3.existsSync(sessionPath);
+    return fs2.existsSync(sessionPath);
   }
   /**
    * Delete session data
@@ -709,7 +592,7 @@ var SessionManager = class {
   deleteSession(sessionId) {
     const sessionPath = path3.join(this.sessionsDir, `${sessionId}.json`);
     try {
-      fs3.unlinkSync(sessionPath);
+      fs2.unlinkSync(sessionPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -721,7 +604,7 @@ var SessionManager = class {
    */
   listSessions() {
     try {
-      const files = fs3.readdirSync(this.sessionsDir);
+      const files = fs2.readdirSync(this.sessionsDir);
       return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -736,9 +619,12 @@ var SessionManager = class {
   getSessionsDir() {
     return this.sessionsDir;
   }
+  ensureSessionsDir() {
+    fs2.mkdirSync(this.sessionsDir, { recursive: true });
+  }
 };
 
-// ../common/src/timeout.ts
+// node_modules/@shims/common/src/timeout.ts
 var IdleTimeoutError = class extends Error {
   timeoutMs;
   constructor(timeoutMs) {
@@ -747,21 +633,49 @@ var IdleTimeoutError = class extends Error {
     this.timeoutMs = timeoutMs;
   }
 };
-async function* withIdleTimeout(events, timeoutMs) {
+var BusyStepTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Busy-step stall timeout: no observed activity for ${timeoutMs}ms`);
+    this.name = "BusyStepTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+async function* withAdaptiveTimeout(events, options) {
   const iterator = events[Symbol.asyncIterator]();
+  let state = "idle";
+  const busyTimeoutMs = Math.max(
+    options.busyTimeoutMs ?? options.idleTimeoutMs,
+    options.idleTimeoutMs
+  );
+  const controller = {
+    markBusy() {
+      state = "busy";
+    },
+    markIdle() {
+      state = "idle";
+    },
+    get state() {
+      return state;
+    }
+  };
   try {
     while (true) {
+      const timeoutMs = state === "busy" ? busyTimeoutMs : options.idleTimeoutMs;
       let timeoutId;
       try {
         const result = await Promise.race([
           iterator.next(),
           new Promise((_, reject) => {
             timeoutId = setTimeout(() => {
-              reject(new IdleTimeoutError(timeoutMs));
+              reject(
+                state === "busy" ? new BusyStepTimeoutError(timeoutMs) : new IdleTimeoutError(timeoutMs)
+              );
             }, timeoutMs);
           })
         ]);
         if (result.done) break;
+        options.onEvent?.(result.value, controller);
         yield result.value;
       } finally {
         clearTimeout(timeoutId);
@@ -772,812 +686,1082 @@ async function* withIdleTimeout(events, timeoutMs) {
   }
 }
 
-// src/utils/ids.ts
+// src/debug.ts
+import fs3 from "fs";
+import path4 from "path";
+var DebugRecorder = class {
+  debugDir;
+  rawJsonlPath;
+  rawLogPath;
+  constructor(debugDir) {
+    this.debugDir = debugDir;
+  }
+  setSession(sessionId, init) {
+    if (!this.debugDir) {
+      return;
+    }
+    fs3.mkdirSync(this.debugDir, { recursive: true });
+    this.rawJsonlPath = path4.join(this.debugDir, `session-${sessionId}.raw.jsonl`);
+    this.rawLogPath = path4.join(this.debugDir, `session-${sessionId}.raw.log`);
+    this.touch(this.rawJsonlPath);
+    this.touch(this.rawLogPath);
+    this.logJson({
+      type: "init",
+      session_id: sessionId,
+      cwd: init.cwd,
+      model: init.model,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  logSdkEvent(event) {
+    this.logJson(event);
+  }
+  logResult(status, extra = {}) {
+    this.logJson({
+      type: "result",
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...extra
+    });
+  }
+  logLine(line) {
+    if (!this.rawLogPath) {
+      return;
+    }
+    fs3.appendFileSync(this.rawLogPath, line.endsWith("\n") ? line : `${line}
+`, "utf8");
+  }
+  static logStartupError(debugDir, line) {
+    if (!debugDir) {
+      return;
+    }
+    fs3.mkdirSync(debugDir, { recursive: true });
+    const rawLogPath = path4.join(debugDir, "session-unknown.raw.log");
+    fs3.appendFileSync(rawLogPath, line.endsWith("\n") ? line : `${line}
+`, "utf8");
+  }
+  logJson(value) {
+    if (!this.rawJsonlPath) {
+      return;
+    }
+    fs3.appendFileSync(this.rawJsonlPath, `${JSON.stringify(value)}
+`, "utf8");
+  }
+  touch(filePath) {
+    fs3.closeSync(fs3.openSync(filePath, "a"));
+  }
+};
+
+// src/utils.ts
+import { randomBytes, randomUUID as randomUUID2 } from "crypto";
+import path5 from "path";
+var NIL_UUID = "00000000-0000-0000-0000-000000000000";
+var SESSION_ID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function generateSessionId() {
+  return randomUUID2();
+}
 function generateMessageId() {
-  return `msg_${Date.now().toString(36)}${Math.random().toString(36).substring(2, 10)}`;
+  return `msg_${Date.now().toString(36)}${randomBytes(6).toString("hex")}`;
 }
 function generateToolUseId() {
-  return `toolu_${Date.now().toString(36)}${Math.random().toString(36).substring(2, 12)}`;
+  return `toolu_${Date.now().toString(36)}${randomBytes(8).toString("hex")}`;
 }
-var NIL_UUID = "00000000-0000-0000-0000-000000000000";
-
-// src/utils/models.ts
-var MODEL_SHORTNAMES = {
-  codex: "openai/gpt-5.1-codex-max",
-  "codex-max": "openai/gpt-5.1-codex-max",
-  "o4-mini": "openai/o4-mini"
-};
-var VALID_REASONING_EFFORTS = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-function isValidReasoningEffort(value) {
-  return VALID_REASONING_EFFORTS.includes(value);
+function isValidSessionId(value) {
+  return typeof value === "string" && SESSION_ID_REGEX.test(value);
 }
-function resolveModel(input) {
-  let modelInput = input;
-  let reasoningEffort;
-  const lastHyphenIndex = input.lastIndexOf("-");
-  if (lastHyphenIndex !== -1) {
-    const potentialEffort = input.substring(lastHyphenIndex + 1);
-    const baseModel = input.substring(0, lastHyphenIndex);
-    if (isValidReasoningEffort(potentialEffort)) {
-      modelInput = baseModel;
-      reasoningEffort = potentialEffort;
-    }
-  }
-  const fullModel = MODEL_SHORTNAMES[modelInput.toLowerCase()] || modelInput;
-  if (fullModel.includes("/")) {
-    const [providerID, modelID] = fullModel.split("/", 2);
-    return { providerID, modelID, reasoningEffort };
+function resolveModel(modelFromArgs) {
+  const requestedModel = modelFromArgs?.trim() || process.env.MODEL?.trim() || "gpt-5.1-codex-max";
+  let sdkModel = requestedModel;
+  if (sdkModel.includes("/")) {
+    const [provider, model] = sdkModel.split("/", 2);
+    if (provider.toLowerCase() === "openai" && model) {
+      sdkModel = model;
+    }
   }
+  let reasoningEffort = "high";
+  const effortMatch = sdkModel.match(/^(.*)-(minimal|low|medium|high|xhigh)$/);
+  if (effortMatch) {
+    sdkModel = effortMatch[1];
+    reasoningEffort = effortMatch[2];
+  }
+  const publicModel = `openai/${sdkModel}`;
   return {
-    providerID: "openai",
-    modelID: fullModel,
+    requestedModel,
+    publicModel,
+    sdkModel,
     reasoningEffort
   };
 }
-function formatModelOutput(spec) {
-  return `${spec.providerID}/${spec.modelID}`;
+function mapSandbox(level) {
+  switch (level) {
+    case "strict":
+      return "read-only";
+    case "standard":
+      return "workspace-write";
+    case "none":
+    default:
+      return "danger-full-access";
+  }
+}
+function getCodexPathOverride() {
+  const value = process.env.CODEX_PATH_OVERRIDE?.trim();
+  return value ? value : void 0;
 }
-function getCodexModelId(spec) {
-  return spec.modelID;
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-
-// src/utils/output.ts
-function emit(message) {
-  console.log(JSON.stringify(message));
+function camelToSnakeKey(key) {
+  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
-function verboseLog(verbose, ...args) {
-  if (verbose) {
-    console.error("[codex-shim]", ...args);
+function topLevelCamelToSnake(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
   }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    result[camelToSnakeKey(key)] = entry;
+  }
+  return result;
 }
 async function flushStdout() {
-  return new Promise((resolve) => {
-    const written = process.stdout.write("");
-    if (written) {
-      resolve();
-    } else {
-      process.stdout.once("drain", resolve);
+  await new Promise((resolve, reject) => {
+    const done = (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+    if (process.stdout.write("")) {
+      done();
+      return;
     }
+    process.stdout.once("drain", () => done());
+    process.stdout.once("error", (error) => done(error));
   });
 }
-
-// src/utils/tools.ts
-var STANDARD_TOOLS = ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "LS"];
-function normalizeToolName(name) {
-  const lowerName = name.toLowerCase();
-  const toolMap = {
-    read: "Read",
-    file_read: "Read",
-    readfile: "Read",
-    read_text_file: "Read",
-    write: "Write",
-    file_write: "Write",
-    writefile: "Write",
-    write_text_file: "Write",
-    edit: "Edit",
-    str_replace_editor: "Edit",
-    edit_text_file: "Edit",
-    bash: "Bash",
-    shell: "Bash",
-    execute_bash: "Bash",
-    exec: "Bash",
-    glob: "Glob",
-    find_files: "Glob",
-    grep: "Grep",
-    search_files: "Grep",
-    ls: "LS",
-    list: "LS",
-    list_directory: "LS"
-  };
-  return toolMap[lowerName] || name;
+function makeAbsoluteCwd(cwd) {
+  return path5.resolve(cwd);
 }
-function camelToSnake(str) {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+function toRelativePath(filePath, cwd) {
+  const absoluteCwd = path5.resolve(cwd);
+  const absolutePath = path5.resolve(filePath);
+  const relative = path5.relative(absoluteCwd, absolutePath);
+  return relative && !relative.startsWith("..") ? relative : absolutePath;
 }
-function normalizeToolInput(input) {
-  const normalized = {};
-  for (const [key, value] of Object.entries(input)) {
-    normalized[camelToSnake(key)] = value;
+
+// src/tools.ts
+function normalizeToolUse(item, cwd) {
+  switch (item.type) {
+    case "command_execution":
+      return normalizeCommandExecution(item);
+    case "file_change":
+      return normalizeFileChange(item, cwd);
+    case "mcp_tool_call":
+      return normalizeMcpToolCall(item);
+    case "web_search":
+      return normalizeWebSearch(item);
+    default:
+      return null;
+  }
+}
+function normalizeToolResult(item, cwd) {
+  switch (item.type) {
+    case "command_execution":
+      return normalizeCommandExecutionResult(item);
+    case "file_change":
+      return normalizeFileChangeResult(item, cwd);
+    case "mcp_tool_call":
+      return normalizeMcpToolCallResult(item);
+    case "web_search":
+      return {
+        isError: false,
+        content: `Web search completed for query: ${item.query}`
+      };
+    default:
+      return null;
+  }
+}
+function normalizeCommandExecution(item) {
+  const innerCommand = extractInnerCommand(item.command);
+  const simpleWrite = parseSimpleShellWrite(innerCommand);
+  if (simpleWrite) {
+    return {
+      name: "Write",
+      input: {
+        file_path: simpleWrite.filePath,
+        content: simpleWrite.content
+      }
+    };
+  }
+  const readMatch = innerCommand.match(/^cat\s+([^\s;&|]+)$/);
+  if (readMatch) {
+    return {
+      name: "Read",
+      input: { file_path: stripQuotes(readMatch[1]) }
+    };
+  }
+  const lsMatch = innerCommand.match(/^ls(?:\s+(-[A-Za-z-]+))*?(?:\s+([^;&|]+))?$/);
+  if (lsMatch) {
+    const target = lsMatch[2]?.trim();
+    return {
+      name: "LS",
+      input: target ? { path: stripQuotes(target) } : void 0
+    };
+  }
+  const grepMatch = innerCommand.match(/^(?:rg|grep)\b(.*)$/);
+  if (grepMatch) {
+    return {
+      name: "Grep",
+      input: { command: innerCommand }
+    };
+  }
+  const globMatch = innerCommand.match(/^(?:find|fd)\b(.*)$/);
+  if (globMatch) {
+    return {
+      name: "Glob",
+      input: { command: innerCommand }
+    };
+  }
+  return {
+    name: "Bash",
+    input: { command: innerCommand }
+  };
+}
+function normalizeCommandExecutionResult(item) {
+  const output = item.aggregated_output;
+  const innerCommand = extractInnerCommand(item.command);
+  const simpleWrite = parseSimpleShellWrite(innerCommand);
+  if (item.status === "failed" || typeof item.exit_code === "number" && item.exit_code !== 0) {
+    return {
+      isError: true,
+      content: {
+        is_error: true,
+        error: output.trim() || `Command failed with exit code ${item.exit_code ?? "unknown"}`
+      }
+    };
+  }
+  if (output.trim().length > 0) {
+    return {
+      isError: false,
+      content: output
+    };
+  }
+  if (simpleWrite) {
+    return {
+      isError: false,
+      content: `Wrote ${simpleWrite.filePath}`
+    };
+  }
+  return {
+    isError: false,
+    content: `Command completed with exit code ${item.exit_code ?? 0} (no output).`
+  };
+}
+function normalizeFileChange(item, cwd) {
+  const paths = item.changes.map((change) => toRelativePath(change.path, cwd));
+  const allAdds = item.changes.every((change) => change.kind === "add");
+  return {
+    name: allAdds ? "Write" : "Edit",
+    input: paths.length === 1 ? { file_path: paths[0] } : { paths }
+  };
+}
+function normalizeFileChangeResult(item, cwd) {
+  const summary = item.changes.map((change) => `${change.kind} ${toRelativePath(change.path, cwd)}`).join(", ");
+  if (item.status === "failed") {
+    return {
+      isError: true,
+      content: {
+        is_error: true,
+        error: summary || "File change failed"
+      }
+    };
+  }
+  return {
+    isError: false,
+    content: summary ? `Applied file change: ${summary}` : "Applied file change."
+  };
+}
+function normalizeMcpToolCall(item) {
+  const lowerServer = item.server.toLowerCase();
+  const lowerTool = item.tool.toLowerCase();
+  if (lowerTool.includes("search") || lowerServer.includes("search") || lowerServer.includes("web")) {
+    return {
+      name: "WebSearch",
+      input: topLevelCamelToSnake(item.arguments) ?? { arguments: item.arguments }
+    };
+  }
+  if (lowerTool.includes("fetch") || lowerTool.includes("browse")) {
+    return {
+      name: "WebFetch",
+      input: topLevelCamelToSnake(item.arguments) ?? { arguments: item.arguments }
+    };
+  }
+  return {
+    name: `${item.server}:${item.tool}`,
+    input: topLevelCamelToSnake(item.arguments) ?? { arguments: item.arguments }
+  };
+}
+function normalizeMcpToolCallResult(item) {
+  if (item.status === "failed") {
+    return {
+      isError: true,
+      content: {
+        is_error: true,
+        error: item.error?.message || "MCP tool call failed"
+      }
+    };
+  }
+  const textParts = item.result?.content?.map((block) => {
+    if (block.type === "text") {
+      return block.text;
+    }
+    return JSON.stringify(block);
+  }).filter((value) => typeof value === "string" && value.length > 0);
+  const combinedText = textParts?.join("\n").trim();
+  return {
+    isError: false,
+    content: combinedText || (item.result?.structured_content !== void 0 ? JSON.stringify(item.result.structured_content) : `${item.server}:${item.tool} completed successfully.`)
+  };
+}
+function normalizeWebSearch(item) {
+  return {
+    name: "WebSearch",
+    input: { query: item.query }
+  };
+}
+function shouldTreatAsToolItem(item) {
+  return item.type === "command_execution" || item.type === "file_change" || item.type === "mcp_tool_call" || item.type === "web_search";
+}
+function extractInnerCommand(command) {
+  const trimmed = command.trim();
+  const zshMatch = trimmed.match(/-lc\s+([\s\S]+)$/);
+  const shellCommand = zshMatch ? stripQuotes(zshMatch[1].trim()) : trimmed;
+  return stripLeadingCdPrefix(shellCommand);
+}
+function stripLeadingCdPrefix(command) {
+  const match = command.match(/^cd\s+(.+?)\s*&&\s*([\s\S]+)$/);
+  if (!match) {
+    return command;
+  }
+  return match[2].trim();
+}
+function parseSimpleShellWrite(command) {
+  return parseHereDocShellWrite(command) ?? parseRedirectShellWrite(command);
+}
+function parseHereDocShellWrite(command) {
+  const redirectFirst = command.match(
+    /^cat\s*>\s*("(?:[^"\\]|\\.)+"|'(?:[^'\\]|\\.)+'|[^\s;&|]+)\s*<<['"]?([A-Za-z0-9_-]+)['"]?\n([\s\S]*?)\n\2$/
+  );
+  if (redirectFirst) {
+    const [, rawFilePath, , body] = redirectFirst;
+    return {
+      filePath: stripQuotes(rawFilePath.trim()),
+      content: `${body}
+`
+    };
+  }
+  const heredocFirst = command.match(
+    /^cat\s*<<['"]?([A-Za-z0-9_-]+)['"]?\s*>\s*("(?:[^"\\]|\\.)+"|'(?:[^'\\]|\\.)+'|[^\s;&|]+)\n([\s\S]*?)\n\1$/
+  );
+  if (heredocFirst) {
+    const [, , rawFilePath, body] = heredocFirst;
+    return {
+      filePath: stripQuotes(rawFilePath.trim()),
+      content: `${body}
+`
+    };
+  }
+  return null;
+}
+function parseRedirectShellWrite(command) {
+  const match = command.match(
+    /^(printf|echo)(?:\s+(-n))?\s+([\s\S]+?)\s*>\s*("(?:[^"\\]|\\.)+"|'(?:[^'\\]|\\.)+'|[^\s;&|]+)$/
+  );
+  if (!match) {
+    return null;
+  }
+  const [, commandName, noNewlineFlag, rawContent, rawFilePath] = match;
+  const parsedContent = parseSimpleShellTextLiteral(rawContent.trim());
+  if (parsedContent === void 0) {
+    return null;
+  }
+  const content = commandName === "printf" ? decodePrintfEscapes(parsedContent) : noNewlineFlag === "-n" ? parsedContent : `${parsedContent}
+`;
+  return {
+    filePath: stripQuotes(rawFilePath.trim()),
+    content
+  };
+}
+function parseSimpleShellTextLiteral(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return stripQuotes(trimmed);
+  }
+  if (/^[^\s;&|<>]+$/.test(trimmed)) {
+    return trimmed;
+  }
+  return void 0;
+}
+function decodePrintfEscapes(value) {
+  return value.replace(/\\\\/g, "\\").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	");
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+// src/timeout-state.ts
+function shouldTreatTurnStartAsBusy(idleTimeoutMs) {
+  return idleTimeoutMs > 1e3;
+}
+function updateCodexTimeoutState(event, controller, idleTimeoutMs) {
+  const turnBusy = shouldTreatTurnStartAsBusy(idleTimeoutMs);
+  switch (event.type) {
+    case "turn.started": {
+      if (turnBusy) {
+        controller.markBusy();
+      }
+      return;
+    }
+    case "item.started":
+    case "item.updated":
+    case "item.completed": {
+      if (turnBusy || shouldTreatAsToolItem(event.item)) {
+        controller.markBusy();
+      }
+      return;
+    }
+    case "turn.completed":
+    case "turn.failed": {
+      controller.markIdle();
+      return;
+    }
+    default:
+      return;
   }
-  return normalized;
 }
 
+// package.json
+var package_default = {
+  name: "codex-shim",
+  version: "0.1.0",
+  private: true,
+  description: "Self-contained Hankweave shim for OpenAI Codex via @openai/codex-sdk",
+  type: "module",
+  bin: {
+    "codex-shim": "./index.js"
+  },
+  files: [
+    "index.js",
+    "dist",
+    "src",
+    "tests",
+    "common",
+    "docs",
+    "README.md",
+    "rebuild.sh",
+    "VERSION",
+    "THIRDPARTY.md",
+    "tsconfig.json",
+    "tsup.config.ts",
+    "bun.lock"
+  ],
+  engines: {
+    node: ">=18",
+    bun: ">=1.1.0"
+  },
+  scripts: {
+    build: "tsup",
+    rebuild: "./rebuild.sh",
+    test: "bun test",
+    typecheck: "tsc --noEmit -p tsconfig.json",
+    clean: `node -e "const fs=require('fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('index.js',{force:true});"`
+  },
+  dependencies: {
+    "@openai/codex-sdk": "^0.112.0",
+    "@shims/common": "file:./common"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/node": "^20.10.0",
+    tsup: "^8.0.1",
+    typescript: "^5.3.0"
+  }
+};
+
 // src/shim.ts
+var DEFAULT_TOOLS = ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "LS", "WebSearch"];
+var HELP_TEXT = `codex-shim
+
+Usage:
+  codex-shim --model <model> [options]
+
+Options:
+  -p
+  --model <model>
+  --resume <session_id>
+  --verbose
+  --append-system-prompt <text>
+  --idle-timeout <seconds>
+  --debug-dir <path>
+  --sandbox <none|standard|strict>
+  --self-test
+  --version
+  --help
+`;
+function emit(message) {
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+}
+function usageToTokenUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  return {
+    input_tokens: usage.input_tokens,
+    output_tokens: usage.output_tokens,
+    cache_read_input_tokens: usage.cached_input_tokens
+  };
+}
+function createSystemMessage(cwd, sessionId, model, apiKeySource) {
+  return {
+    type: "system",
+    subtype: "init",
+    cwd,
+    session_id: sessionId,
+    tools: DEFAULT_TOOLS,
+    model,
+    permissionMode: "bypassPermissions",
+    apiKeySource,
+    mcp_servers: []
+  };
+}
+function createAssistantMessage(model, content, stopReason = null, usage, id = generateMessageId()) {
+  return {
+    type: "assistant",
+    message: {
+      id,
+      type: "message",
+      role: "assistant",
+      model,
+      content,
+      stop_reason: stopReason,
+      ...usage ? { usage } : {}
+    }
+  };
+}
+function createToolResultMessage(toolUseId, content) {
+  return {
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content
+        }
+      ]
+    }
+  };
+}
+function createResultMessage(ok, durationMs, durationApiMs, numTurns, summary, sessionId, usage) {
+  return {
+    type: "result",
+    subtype: ok ? "success" : "error",
+    is_error: !ok,
+    duration_ms: durationMs,
+    duration_api_ms: durationApiMs,
+    num_turns: numTurns,
+    result: summary,
+    session_id: sessionId,
+    ...usage ? { usage } : {}
+  };
+}
+function composePrompt(prompt, appendSystemPrompt) {
+  if (!appendSystemPrompt?.trim()) {
+    return prompt;
+  }
+  return [
+    "<SYSTEM_INSTRUCTIONS>",
+    appendSystemPrompt.trim(),
+    "</SYSTEM_INSTRUCTIONS>",
+    "",
+    "<USER_REQUEST>",
+    prompt,
+    "</USER_REQUEST>"
+  ].join("\n");
+}
+function classifyRuntimeError(error) {
+  if (error instanceof IdleTimeoutError || error instanceof BusyStepTimeoutError) {
+    return `Agent Error: ${error.message}`;
+  }
+  const message = toErrorMessage(error);
+  if (/rate limit|authentication|not supported|invalid model|insufficient|quota|api|unsupported/i.test(
+    message
+  )) {
+    return `API Error: ${message}`;
+  }
+  return `Agent Error: ${message}`;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+function writeStartupError(message, debugDir) {
+  DebugRecorder.logStartupError(debugDir, message);
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+}
+function findVendoredCodexExe(npmPrefix) {
+  const arch = process.arch === "arm64" ? "aarch64-pc-windows-msvc" : "x86_64-pc-windows-msvc";
+  const pkgName = process.arch === "arm64" ? "@openai/codex-win32-arm64" : "@openai/codex-win32-x64";
+  const tail = path6.join(...pkgName.split("/"), "vendor", arch, "codex", "codex.exe");
+  const candidates = [
+    path6.join(npmPrefix, "node_modules", tail),
+    path6.join(npmPrefix, "node_modules", "@openai", "codex", "node_modules", tail)
+  ];
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+async function resolveCodexPath(command) {
+  const isWindows = process.platform === "win32";
+  if (path6.isAbsolute(command) || command.includes(path6.sep)) {
+    if (fs4.existsSync(command)) return command;
+    if (isWindows) {
+      for (const ext of [".cmd", ".exe"]) {
+        if (fs4.existsSync(command + ext)) return command + ext;
+      }
+    }
+    return null;
+  }
+  const whichCommand = isWindows ? "where" : "which";
+  const resolved = await new Promise((resolve) => {
+    const proc = spawn2(whichCommand, [command], {
+      shell: isWindows,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: process.env
+    });
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.on("error", () => resolve(null));
+    proc.on("close", (code) => {
+      if (code === 0 && stdout.trim()) {
+        resolve(stdout.trim().split(/\r?\n/)[0]);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+  if (!resolved) return null;
+  if (isWindows) {
+    const npmPrefix = path6.dirname(resolved);
+    const vendored = findVendoredCodexExe(npmPrefix);
+    if (vendored) return vendored;
+  }
+  return resolved;
+}
+async function resolveAgentVersion(codexPath) {
+  const isWindows = process.platform === "win32";
+  return await new Promise((resolve) => {
+    const proc = spawn2(codexPath, ["--version"], {
+      shell: isWindows,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", () => resolve("unknown"));
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim() || stderr.trim() || package_default.dependencies["@openai/codex-sdk"] || "unknown");
+      } else {
+        resolve("unknown");
+      }
+    });
+  });
+}
 var CodexShim = class {
   args;
-  codex;
+  prompt;
   cwd;
-  startTime;
-  apiStartTime;
-  interrupted = false;
+  debug;
+  model;
   sessionManager;
-  authConfig;
-  constructor(args) {
+  runtime = {
+    numTurns: 0,
+    finalText: ""
+  };
+  toolIdMap = /* @__PURE__ */ new Map();
+  codex;
+  sessionId;
+  interrupted = false;
+  currentAbortController;
+  constructor(args, prompt) {
     this.args = args;
-    this.cwd = process.cwd();
-    this.startTime = Date.now();
-    this.apiStartTime = 0;
+    this.prompt = prompt;
+    this.cwd = makeAbsoluteCwd(process.cwd());
+    this.debug = new DebugRecorder(args.debugDir);
+    this.model = resolveModel(this.args.model);
     this.sessionManager = new SessionManager({ debugDir: args.debugDir });
-    this.authConfig = getApiKey();
+    this.sessionId = args.resume || generateSessionId();
+  }
+  get resolvedApiKey() {
+    return process.env.OPENAI_API_KEY || process.env.CODEX_API_KEY || void 0;
+  }
+  get apiKeySource() {
+    if (process.env.OPENAI_API_KEY) return "OPENAI_API_KEY";
+    if (process.env.CODEX_API_KEY) return "CODEX_API_KEY";
+    if (fs4.existsSync(path6.join(os2.homedir(), ".codex", "auth.json"))) return "~/.codex/auth.json";
+    return "none";
+  }
+  get isAuthConfigured() {
+    return this.apiKeySource !== "none";
+  }
+  async runSelfTest() {
+    const override = getCodexPathOverride() || "codex";
+    const resolvedPath = await resolveCodexPath(override);
+    const agentFound = resolvedPath !== null;
+    const agentVersion = resolvedPath ? await resolveAgentVersion(resolvedPath) : "unknown";
+    const checks = [
+      {
+        name: "agent_found",
+        passed: agentFound,
+        message: agentFound ? `Found codex at ${resolvedPath}` : `Could not find codex via ${override}`
+      },
+      {
+        name: "api_key",
+        passed: this.isAuthConfigured,
+        message: this.isAuthConfigured ? `Authentication source available: ${this.apiKeySource}` : "No OPENAI_API_KEY, CODEX_API_KEY, or ~/.codex/auth.json found"
+      }
+    ];
+    const overallPassed = checks.every((check) => check.passed);
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          shim: { name: "codex-shim", version: package_default.version },
+          agent: { name: "codex", version: agentVersion, found: agentFound },
+          checks,
+          overall: {
+            passed: overallPassed,
+            message: overallPassed ? "All checks passed" : "One or more checks failed"
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+    return overallPassed ? 0 : 1;
+  }
+  async run() {
+    const codexPath = await resolveCodexPath(getCodexPathOverride() || "codex");
+    if (!codexPath) {
+      writeStartupError("Agent not found: could not locate codex via CODEX_PATH_OVERRIDE or PATH", this.args.debugDir);
+    }
+    if (!this.isAuthConfigured) {
+      writeStartupError("Missing API key: set OPENAI_API_KEY, CODEX_API_KEY, or ~/.codex/auth.json", this.args.debugDir);
+    }
     this.codex = new Codex({
-      apiKey: this.authConfig.source !== "env" && this.authConfig.apiKey ? this.authConfig.apiKey : void 0,
-      env: process.env,
-      // Use system-installed codex instead of vendored binary
-      codexPathOverride: process.env.CODEX_PATH_OVERRIDE || "codex"
+      apiKey: this.resolvedApiKey,
+      codexPathOverride: codexPath,
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((entry) => entry[1] !== void 0)
+      )
     });
-    this.setupSignalHandlers();
-  }
-  setupSignalHandlers() {
-    const handleSignal = () => {
-      if (!this.interrupted) {
-        this.interrupted = true;
-        verboseLog(this.args.verbose, "Received interrupt signal, shutting down gracefully");
-        process.exit(0);
-      }
-    };
-    process.on("SIGINT", handleSignal);
-    process.on("SIGTERM", handleSignal);
-  }
-  async run(prompt) {
-    const modelSpec = resolveModel(this.args.model);
-    const modelOutput = formatModelOutput(modelSpec);
-    const codexModelId = getCodexModelId(modelSpec);
-    verboseLog(this.args.verbose, `Resolved model: ${modelOutput}`);
-    verboseLog(this.args.verbose, `Codex model ID: ${codexModelId}`);
     let thread;
-    let sessionId = null;
-    try {
-      if (this.args.resume) {
-        const resumeSessionId = this.args.resume;
-        verboseLog(this.args.verbose, `Resuming session: ${resumeSessionId}`);
-        const sessionData = this.sessionManager.loadSession(resumeSessionId);
-        const threadId = sessionData.agentSessionId;
-        verboseLog(
-          this.args.verbose,
-          `Found thread ID: ${threadId} for session: ${resumeSessionId}`
-        );
-        const home = process.env.HOME || process.env.USERPROFILE || "";
-        const codexSessionDir = path4.join(home, ".codex", "sessions");
-        let threadExists = false;
-        try {
-          const { spawnSync } = await import("child_process");
-          const result = spawnSync("find", [codexSessionDir, "-name", `*${threadId}*`], {
-            encoding: "utf8"
-          });
-          threadExists = result.stdout.trim().length > 0 && result.status === 0;
-        } catch (error) {
-          verboseLog(this.args.verbose, `Thread validation error: ${error}`);
-        }
-        if (!threadExists) {
-          throw new Error(
-            `Thread not found for session ${resumeSessionId}. Cannot resume non-existent conversation.`
-          );
-        }
-        thread = this.codex.resumeThread(threadId, this.getThreadOptions());
-        sessionId = resumeSessionId;
-      } else {
-        verboseLog(this.args.verbose, `Starting new session`);
-        sessionId = this.sessionManager.generateSessionId();
-        thread = this.codex.startThread(this.getThreadOptions());
+    if (this.args.resume) {
+      if (!isValidSessionId(this.args.resume)) {
+        writeStartupError(`Invalid session ID: ${this.args.resume}`, this.args.debugDir);
       }
-    } catch (error) {
-      verboseLog(this.args.verbose, "Pre-init error:", error);
-      if (this.args.debugDir) {
-        this.savePreInitError(error);
+      let sessionData;
+      try {
+        sessionData = this.sessionManager.loadSession(this.args.resume);
+      } catch (error) {
+        writeStartupError(toErrorMessage(error), this.args.debugDir);
       }
-      throw error;
-    }
-    if (!sessionId) {
-      throw new Error("Failed to determine session ID");
-    }
-    const state = {
-      sessionId,
-      thread,
-      startTime: this.startTime,
-      apiStartTime: 0,
-      numTurns: 0,
-      totalUsage: {
-        input_tokens: 0,
-        output_tokens: 0
-      },
-      workStarted: false,
-      hasReceivedDeltas: false,
-      lastEmittedAssistantText: "",
-      lastEmittedReasoningByItemId: /* @__PURE__ */ new Map(),
-      emittedToolIds: /* @__PURE__ */ new Set(),
-      toolIdMapping: /* @__PURE__ */ new Map()
-    };
+      this.logVerbose(`Resuming session ${this.args.resume} -> ${sessionData.agentSessionId}`);
+      thread = this.codex.resumeThread(sessionData.agentSessionId, this.getThreadOptions());
+      this.sessionId = this.args.resume;
+    } else {
+      thread = this.codex.startThread(this.getThreadOptions());
+    }
+    const systemMessage = createSystemMessage(this.cwd, this.sessionId, this.model.publicModel, this.apiKeySource);
+    emit(systemMessage);
+    this.debug.setSession(this.sessionId, { cwd: this.cwd, model: this.model.publicModel });
+    const startedAt = Date.now();
+    const apiStartedAt = Date.now();
+    this.installSignalHandlers();
     try {
-      await this.processPrompt(state, prompt, modelOutput);
-      this.emitResult(state, false, "Completed successfully");
+      const prompt = composePrompt(this.prompt, this.args.appendSystemPrompt);
+      const stream = await thread.runStreamed(prompt, { signal: this.getAbortController().signal });
+      await this.consumeEvents(stream.events);
+      const durationMs = Date.now() - startedAt;
+      const durationApiMs = Date.now() - apiStartedAt;
+      const resultMessage = createResultMessage(
+        true,
+        durationMs,
+        durationApiMs,
+        Math.max(this.runtime.numTurns, 1),
+        this.runtime.finalText || "Completed successfully.",
+        this.sessionId,
+        this.runtime.lastUsage
+      );
+      emit(resultMessage);
+      this.debug.logResult("success", {
+        session_id: this.sessionId,
+        usage: this.runtime.lastUsage
+      });
+      await flushStdout();
+      return 0;
     } catch (error) {
-      verboseLog(this.args.verbose, "Error during execution:", error);
-      if (this.args.debugDir) {
-        this.saveRuntimeError(state.sessionId, error);
-      }
-      this.emitSyntheticError(error, modelOutput);
-      this.emitResult(state, true, error instanceof Error ? error.message : String(error));
+      const summary = classifyRuntimeError(error);
+      const durationMs = Date.now() - startedAt;
+      const durationApiMs = Date.now() - apiStartedAt;
+      emit(
+        createAssistantMessage(
+          "<synthetic>",
+          [{ type: "text", text: summary }],
+          null,
+          void 0,
+          NIL_UUID
+        )
+      );
+      const resultMessage = createResultMessage(
+        false,
+        durationMs,
+        durationApiMs,
+        Math.max(this.runtime.numTurns, 1),
+        summary,
+        this.sessionId,
+        this.runtime.lastUsage
+      );
+      emit(resultMessage);
+      this.debug.logLine(summary);
+      this.debug.logResult("error", {
+        session_id: this.sessionId,
+        error: summary
+      });
       await flushStdout();
-      process.exit(1);
+      return 1;
     }
-    await flushStdout();
-    process.exit(0);
   }
   getThreadOptions() {
-    const modelSpec = resolveModel(this.args.model);
-    const sandboxModeMap = {
-      none: "danger-full-access",
-      standard: "workspace-write",
-      strict: "read-only"
-    };
-    const options = {
+    return {
+      model: this.model.sdkModel,
+      modelReasoningEffort: this.model.reasoningEffort,
+      sandboxMode: mapSandbox(this.args.sandbox),
       workingDirectory: this.cwd,
       skipGitRepoCheck: true,
-      model: getCodexModelId(modelSpec),
-      // Auto-approve all operations (no user present)
-      approvalPolicy: "never",
-      sandboxMode: sandboxModeMap[this.args.sandbox],
-      networkAccessEnabled: true,
-      webSearchEnabled: true,
-      modelReasoningEffort: modelSpec.reasoningEffort || "high"
+      approvalPolicy: "never"
     };
-    return options;
-  }
-  emitSystemInit(sessionId, model) {
-    let apiKeySource;
-    switch (this.authConfig.source) {
-      case "env":
-      case "CODEX_API_KEY":
-      case "OPENAI_API_KEY":
-        apiKeySource = "env";
-        break;
-      default:
-        apiKeySource = "none";
-    }
-    const message = {
-      type: "system",
-      subtype: "init",
-      cwd: this.cwd,
-      session_id: sessionId,
-      tools: [...STANDARD_TOOLS],
-      model,
-      permissionMode: "bypassPermissions",
-      apiKeySource,
-      mcp_servers: []
-    };
-    emit(message);
-    verboseLog(this.args.verbose, "Emitted system init");
   }
-  async processPrompt(state, prompt, model) {
-    let finalPrompt = prompt;
-    if (this.args.appendSystemPrompt) {
-      finalPrompt = `${prompt}
-
-${this.args.appendSystemPrompt}`;
-    }
-    verboseLog(this.args.verbose, `Sending prompt: ${finalPrompt.substring(0, 100)}...`);
-    state.apiStartTime = Date.now();
-    this.apiStartTime = state.apiStartTime;
-    const { events } = await state.thread.runStreamed(finalPrompt);
-    const timedEvents = withIdleTimeout(events, this.args.idleTimeout * 1e3);
-    const currentMessageContent = [];
-    let currentMessageId = generateMessageId();
-    const pendingToolResults = /* @__PURE__ */ new Map();
-    let systemInitEmitted = false;
+  async consumeEvents(events) {
+    const idleTimeoutMs = this.args.idleTimeout * 1e3;
+    const timedEvents = withAdaptiveTimeout(events, {
+      idleTimeoutMs,
+      busyTimeoutMs: Math.max(idleTimeoutMs, 3e5),
+      onEvent: (event, controller) => {
+        updateCodexTimeoutState(event, controller, idleTimeoutMs);
+      }
+    });
     for await (const event of timedEvents) {
-      if (this.interrupted) {
-        verboseLog(this.args.verbose, "Interrupted, stopping event processing");
+      this.debug.logSdkEvent(event);
+      this.logVerbose(`SDK event: ${event.type}`);
+      await this.handleEvent(event);
+    }
+  }
+  async handleEvent(event) {
+    switch (event.type) {
+      case "thread.started": {
+        this.sessionManager.saveSession({
+          sessionId: this.sessionId,
+          agentSessionId: event.thread_id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          metadata: {
+            model: this.model.publicModel,
+            cwd: this.cwd
+          }
+        });
         break;
       }
-      verboseLog(this.args.verbose, `Event: ${event.type}`);
-      if (this.args.debugDir && state.sessionId) {
-        this.saveRawEvent(state.sessionId, event);
-        if (event.type === "thread.started") {
-          this.createRawLogFile(state.sessionId);
-        }
+      case "turn.started": {
+        break;
       }
-      if (!state.workStarted) {
-        if (event.type === "item.started" || event.type === "item.updated" || event.type === "turn.started") {
-          state.workStarted = true;
-        }
+      case "turn.completed": {
+        this.runtime.numTurns += 1;
+        this.runtime.lastUsage = usageToTokenUsage(event.usage);
+        break;
       }
-      switch (event.type) {
-        case "thread.started":
-          if (event.thread_id) {
-            verboseLog(this.args.verbose, `Thread started with Codex ID: ${event.thread_id}`);
-            verboseLog(this.args.verbose, `Using session ID: ${state.sessionId}`);
-            if (!systemInitEmitted) {
-              this.emitSystemInit(state.sessionId, model);
-              systemInitEmitted = true;
-            }
-          }
-          break;
-        case "turn.started":
-          state.numTurns++;
-          verboseLog(this.args.verbose, `Turn ${state.numTurns} started`);
-          break;
-        case "item.started":
-        case "item.updated":
-        case "item.completed":
-          this.handleItemEvent(
-            event.item,
-            state,
-            currentMessageContent,
-            pendingToolResults,
-            model,
-            currentMessageId,
-            event.type === "item.completed"
-          );
-          break;
-        case "turn.completed": {
-          if (event.usage) {
-            state.totalUsage.input_tokens += event.usage.input_tokens;
-            state.totalUsage.output_tokens += event.usage.output_tokens;
-            if (event.usage.cached_input_tokens) {
-              state.totalUsage.cache_read_input_tokens = (state.totalUsage.cache_read_input_tokens || 0) + event.usage.cached_input_tokens;
-            }
-          }
-          verboseLog(this.args.verbose, "Turn completed", event.usage);
-          const completionContent = state.hasReceivedDeltas ? [] : currentMessageContent;
-          if (completionContent.length > 0 || event.usage) {
-            this.emitAssistantMessage(
-              currentMessageId,
-              model,
-              completionContent,
-              event.usage,
-              "end_turn"
-            );
-          }
-          for (const result of pendingToolResults.values()) {
-            this.emitToolResult(result);
-          }
-          pendingToolResults.clear();
-          currentMessageContent.length = 0;
-          state.hasReceivedDeltas = false;
-          state.lastEmittedAssistantText = "";
-          state.lastEmittedReasoningByItemId.clear();
-          currentMessageId = generateMessageId();
-          break;
-        }
-        case "turn.failed":
-          verboseLog(this.args.verbose, "Turn failed:", event.error);
-          if (this.args.debugDir) {
-            this.saveRuntimeError(
-              state.sessionId,
-              new Error(`Turn failed: ${event.error.message}`)
-            );
-          }
-          throw new Error(`Turn failed: ${event.error.message}`);
-        case "error":
-          verboseLog(this.args.verbose, `Thread error: ${event.message}`);
-          if (this.args.debugDir) {
-            this.saveRuntimeError(state.sessionId, new Error(`Thread error: ${event.message}`));
-          }
-          break;
+      case "turn.failed": {
+        this.runtime.numTurns += 1;
+        throw new Error(event.error.message);
       }
-    }
-    if (state.thread.id) {
-      this.saveSession(state.thread.id, state);
-    }
-    if (this.args.debugDir) {
-      this.createRawLogFile(state.sessionId);
-    }
-  }
-  handleItemEvent(item, state, currentMessageContent, pendingToolResults, model, currentMessageId, _isCompleted = false) {
-    switch (item.type) {
-      case "agent_message":
-        if (item.text) {
-          const previousText = state.lastEmittedAssistantText || "";
-          const deltaText = item.text.startsWith(previousText) ? item.text.slice(previousText.length) : item.text;
-          if (deltaText) {
-            this.emitAssistantMessage(
-              currentMessageId,
-              model,
-              [{ type: "text", text: deltaText }],
-              void 0,
-              null
-            );
-            state.hasReceivedDeltas = true;
-          }
-          state.lastEmittedAssistantText = item.text;
-          const existing = currentMessageContent.find((c) => c.type === "text");
-          if (existing && existing.type === "text") {
-            existing.text = item.text;
-          } else {
-            currentMessageContent.push({ type: "text", text: item.text });
-          }
+      case "error": {
+        throw new Error(event.message);
+      }
+      case "item.started": {
+        if (event.item.type !== "web_search") {
+          await this.emitToolUseIfNeeded(event.item);
         }
         break;
-      case "reasoning":
-        if (item.text) {
-          const reasoningItemId = item.id || "reasoning";
-          const previousReasoning = state.lastEmittedReasoningByItemId.get(reasoningItemId) || "";
-          const deltaThinking = item.text.startsWith(previousReasoning) ? item.text.slice(previousReasoning.length) : item.text;
-          if (deltaThinking) {
-            this.emitAssistantMessage(
-              currentMessageId,
-              model,
-              [{ type: "thinking", thinking: deltaThinking }],
-              void 0,
-              null
-            );
-            state.hasReceivedDeltas = true;
-          }
-          state.lastEmittedReasoningByItemId.set(reasoningItemId, item.text);
-          currentMessageContent.push({ type: "thinking", thinking: item.text });
+      }
+      case "item.updated": {
+        if (event.item.type !== "web_search") {
+          await this.emitToolUseIfNeeded(event.item);
         }
         break;
-      case "command_execution":
-        this.handleCommandExecution(
-          item,
-          state,
-          currentMessageContent,
-          pendingToolResults,
-          model,
-          currentMessageId
-        );
-        break;
-      case "mcp_tool_call":
-        this.handleMcpToolCall(
-          item,
-          state,
-          currentMessageContent,
-          pendingToolResults,
-          model,
-          currentMessageId
-        );
+      }
+      case "item.completed": {
+        await this.handleCompletedItem(event.item);
         break;
-      case "file_change":
-        this.handleFileChange(
-          item,
-          state,
-          currentMessageContent,
-          pendingToolResults,
-          model,
-          currentMessageId
-        );
+      }
+      default:
         break;
     }
   }
-  handleCommandExecution(item, state, currentMessageContent, pendingToolResults, model, currentMessageId) {
-    if (!state.emittedToolIds.has(item.id)) {
-      const toolUseId2 = generateToolUseId();
-      state.emittedToolIds.add(item.id);
-      state.toolIdMapping.set(item.id, toolUseId2);
-      const toolUse = {
-        type: "tool_use",
-        id: toolUseId2,
-        name: "Bash",
-        input: { command: item.command }
-      };
-      currentMessageContent.push(toolUse);
-      this.emitAssistantMessage(currentMessageId, model, [toolUse], void 0, null);
-      state.hasReceivedDeltas = true;
-    }
-    const toolUseId = state.toolIdMapping.get(item.id);
-    if (!toolUseId) return;
-    let content = item.aggregated_output || "";
-    if (!content && item.status === "completed" && item.exit_code === 0) {
-      content = `Command executed successfully (exit code: 0)`;
-    } else if (!content && item.status === "failed") {
-      content = `Command failed (exit code: ${item.exit_code || "unknown"})`;
-    }
-    pendingToolResults.set(item.id, {
-      type: "tool_result",
-      tool_use_id: toolUseId,
-      content: item.status === "failed" ? { is_error: true, error: content } : content
-    });
-  }
-  handleMcpToolCall(item, state, currentMessageContent, pendingToolResults, model, currentMessageId) {
-    if (!state.emittedToolIds.has(item.id)) {
-      const toolUseId2 = generateToolUseId();
-      state.emittedToolIds.add(item.id);
-      state.toolIdMapping.set(item.id, toolUseId2);
-      const toolName = normalizeToolName(item.tool);
-      const toolUse = {
-        type: "tool_use",
-        id: toolUseId2,
-        name: toolName,
-        input: normalizeToolInput(item.arguments || {})
-      };
-      currentMessageContent.push(toolUse);
-      this.emitAssistantMessage(currentMessageId, model, [toolUse], void 0, null);
-      state.hasReceivedDeltas = true;
-    }
-    const toolUseId = state.toolIdMapping.get(item.id);
-    if (!toolUseId) return;
-    let content = "";
-    if (item.result?.content) {
-      content = item.result.content.map((block) => {
-        if (block.type === "text") return block.text;
-        return JSON.stringify(block);
-      }).join("\n");
-    }
-    pendingToolResults.set(item.id, {
-      type: "tool_result",
-      tool_use_id: toolUseId,
-      content: item.status === "failed" ? { is_error: true, error: item.error?.message || "Failed" } : content
-    });
-  }
-  handleFileChange(item, state, currentMessageContent, pendingToolResults, model, currentMessageId) {
-    if (!state.emittedToolIds.has(item.id)) {
-      const toolUseId2 = generateToolUseId();
-      state.emittedToolIds.add(item.id);
-      state.toolIdMapping.set(item.id, toolUseId2);
-      const change2 = item.changes[0];
-      const toolName = change2.kind === "add" ? "Write" : "Edit";
-      const toolUse = {
-        type: "tool_use",
-        id: toolUseId2,
-        name: toolName,
-        input: { file_path: change2.path }
-      };
-      currentMessageContent.push(toolUse);
-      this.emitAssistantMessage(currentMessageId, model, [toolUse], void 0, null);
-      state.hasReceivedDeltas = true;
-    }
-    const toolUseId = state.toolIdMapping.get(item.id);
-    if (!toolUseId) return;
-    const change = item.changes[0];
-    const content = `${change.kind}: ${change.path}`;
-    pendingToolResults.set(item.id, {
-      type: "tool_result",
-      tool_use_id: toolUseId,
-      content: item.status === "failed" ? { is_error: true, error: "File change failed" } : content
-    });
-  }
-  emitAssistantMessage(messageId, model, content, usage, stopReason) {
-    const message = {
-      type: "assistant",
-      message: {
-        id: messageId,
-        type: "message",
-        role: "assistant",
-        model,
-        content,
-        usage: usage ? {
-          input_tokens: usage.input_tokens,
-          output_tokens: usage.output_tokens,
-          cache_read_input_tokens: usage.cached_input_tokens
-        } : void 0,
-        stop_reason: stopReason || null
-      }
-    };
-    emit(message);
-    verboseLog(this.args.verbose, "Emitted assistant message");
-  }
-  emitToolResult(result) {
-    const message = {
-      type: "user",
-      message: {
-        role: "user",
-        content: [result]
-      }
-    };
-    emit(message);
-    verboseLog(this.args.verbose, "Emitted tool result");
-  }
-  emitSyntheticError(error, _model) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const message = {
-      type: "assistant",
-      message: {
-        id: NIL_UUID,
-        type: "message",
-        role: "assistant",
-        model: "<synthetic>",
-        content: [
+  async handleCompletedItem(item) {
+    if (item.type === "reasoning") {
+      emit(
+        createAssistantMessage(this.model.publicModel, [
+          {
+            type: "thinking",
+            thinking: item.text
+          }
+        ])
+      );
+      return;
+    }
+    if (item.type === "agent_message") {
+      this.runtime.finalText = item.text;
+      emit(
+        createAssistantMessage(this.model.publicModel, [
           {
             type: "text",
-            text: `API Error: ${errorMessage}`
+            text: item.text
           }
-        ],
-        stop_reason: null
+        ], "end_turn")
+      );
+      return;
+    }
+    if (item.type === "error") {
+      this.logVerbose(`Codex non-fatal error item: ${item.message}`);
+      return;
+    }
+    if (shouldTreatAsToolItem(item)) {
+      const toolId = await this.emitToolUseIfNeeded(item);
+      const normalizedResult = normalizeToolResult(item, this.cwd);
+      if (!toolId || !normalizedResult) {
+        return;
       }
-    };
-    emit(message);
-    verboseLog(this.args.verbose, "Emitted synthetic error");
-  }
-  emitResult(state, isError, result) {
-    const duration = Date.now() - state.startTime;
-    const apiDuration = state.apiStartTime > 0 ? Date.now() - state.apiStartTime : 0;
-    const message = {
-      type: "result",
-      subtype: isError ? "error" : "success",
-      is_error: isError,
-      duration_ms: duration,
-      duration_api_ms: apiDuration,
-      num_turns: state.numTurns,
-      result,
-      session_id: state.sessionId,
-      usage: state.totalUsage
-    };
-    emit(message);
-    verboseLog(this.args.verbose, "Emitted result");
-  }
-  saveSession(threadId, state) {
-    try {
-      const sessionData = {
-        sessionId: state.sessionId,
-        agentSessionId: threadId,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        metadata: {
-          totalUsage: state.totalUsage,
-          numTurns: state.numTurns
-        }
-      };
-      this.sessionManager.saveSession(sessionData);
-      verboseLog(this.args.verbose, `Saved session to ${this.sessionManager.getSessionsDir()}`);
-    } catch (error) {
-      verboseLog(this.args.verbose, `Failed to save session: ${error}`);
+      emit(createToolResultMessage(toolId, normalizedResult.content));
     }
   }
-  saveRawEvent(sessionId, event) {
-    try {
-      if (!this.args.debugDir) return;
-      fs4.mkdirSync(this.args.debugDir, { recursive: true });
-      const rawLogPath = path4.join(this.args.debugDir, `session-${sessionId}.raw.jsonl`);
-      fs4.appendFileSync(rawLogPath, `${JSON.stringify(event)}
-`);
-      this.createRawLogFile(sessionId);
-    } catch (error) {
-      verboseLog(this.args.verbose, `Failed to save raw event: ${error}`);
-    }
+  async emitToolUseIfNeeded(item) {
+    if (!shouldTreatAsToolItem(item)) {
+      return void 0;
+    }
+    const existing = this.toolIdMap.get(item.id);
+    if (existing) {
+      return existing;
+    }
+    const normalizedTool = normalizeToolUse(item, this.cwd);
+    if (!normalizedTool) {
+      return void 0;
+    }
+    const publicId = generateToolUseId();
+    this.toolIdMap.set(item.id, publicId);
+    emit(
+      createAssistantMessage(this.model.publicModel, [
+        {
+          type: "tool_use",
+          id: publicId,
+          name: normalizedTool.name,
+          ...normalizedTool.input ? { input: normalizedTool.input } : {}
+        }
+      ], "tool_use")
+    );
+    return publicId;
   }
-  savePreInitError(error) {
-    try {
-      if (!this.args.debugDir) return;
-      fs4.mkdirSync(this.args.debugDir, { recursive: true });
-      const errorLogPath = path4.join(this.args.debugDir, "session-unknown.raw.log");
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      fs4.appendFileSync(errorLogPath, `[${timestamp}] ${errorMessage}
-`);
-    } catch (err) {
-      verboseLog(this.args.verbose, `Failed to save pre-init error: ${err}`);
+  getAbortController() {
+    if (!this.currentAbortController) {
+      this.currentAbortController = new AbortController();
     }
+    return this.currentAbortController;
   }
-  saveRuntimeError(sessionId, error) {
-    try {
-      if (!this.args.debugDir) return;
-      fs4.mkdirSync(this.args.debugDir, { recursive: true });
-      const errorLogPath = path4.join(this.args.debugDir, `session-${sessionId}.raw.log`);
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const errorStack = error instanceof Error ? error.stack : void 0;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      let logEntry = `[${timestamp}] RUNTIME ERROR: ${errorMessage}
-`;
-      if (errorStack) {
-        logEntry += `Stack trace:
-${errorStack}
-`;
+  installSignalHandlers() {
+    const handle = (signal) => {
+      if (this.interrupted) {
+        return;
       }
-      fs4.appendFileSync(errorLogPath, logEntry);
-    } catch (err) {
-      verboseLog(this.args.verbose, `Failed to save runtime error: ${err}`);
-    }
+      this.interrupted = true;
+      this.logVerbose(`Received ${signal}, aborting current turn`);
+      this.debug.logLine(`Received ${signal}, aborting current turn`);
+      this.currentAbortController?.abort();
+    };
+    process.once("SIGINT", () => handle("SIGINT"));
+    process.once("SIGTERM", () => handle("SIGTERM"));
   }
-  createRawLogFile(sessionId) {
-    try {
-      if (!this.args.debugDir) return;
-      const rawLogPath = path4.join(this.args.debugDir, `session-${sessionId}.raw.log`);
-      if (!fs4.existsSync(rawLogPath)) {
-        fs4.writeFileSync(
-          rawLogPath,
-          `# Codex SDK raw log (session ${sessionId})
-# Note: SDK doesn't expose agent stderr
-`
-        );
-      }
-    } catch (error) {
-      verboseLog(this.args.verbose, `Failed to create raw log file: ${error}`);
+  logVerbose(message) {
+    if (!this.args.verbose) {
+      return;
     }
+    process.stderr.write(`${message}
+`);
+    this.debug.logLine(message);
   }
 };
-
-// src/utils/args.ts
-async function readStdin() {
-  return new Promise((resolve, reject) => {
-    let data = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => {
-      resolve(data.trim());
-    });
-    process.stdin.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-function printVersion() {
-  console.log("codex-shim 1.0.0");
-}
-function printHelp() {
-  console.log(`
-codex-shim - OpenAI Codex shim for standardized agent interface
-
-USAGE:
-  echo "prompt" | codex-shim --model <model>[-<reasoning>] [options]
-
-REQUIRED:
-  --model <model>           OpenAI model identifier (shortname, openai/model, or full ID)
-                            Optionally append reasoning effort:
-                            -minimal, -low, -medium, -high, or -xhigh
-
-OPTIONS:
-  -p                        Indicates prompt via stdin (optional, stdin always read)
-  --resume <session_id>     Continue existing session
-  --verbose                 Enable verbose logging to stderr
-  --append-system-prompt    Additional system prompt to append
-  --idle-timeout <seconds>  Max seconds between agent events before aborting (default: 120)
-  --debug-dir <path>        Directory for debug logs and session data
-  --sandbox <level>         Sandbox level: none (default), standard, or strict
-  --self-test               Run environment verification
-  --version                 Print version and exit
-  --help                    Print this help and exit
-
-ENVIRONMENT:
-  MODEL                     Default model if --model not provided
-  OPENAI_API_KEY            OpenAI API key for authentication
-  CODEX_API_KEY             Codex-specific API key (alternative)
-
-EXAMPLES:
-  echo "Hello" | codex-shim --model codex
-  echo "Complex task" | codex-shim --model codex-high --verbose
-  echo "Fix bug" | codex-shim --model gpt-5.2-xhigh
-  echo "Continue" | codex-shim --model codex --resume <session-id>
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv, { "-h": "--help" });
+  if (args.help) {
+    process.stdout.write(HELP_TEXT);
+    return 0;
+  }
+  if (args.version) {
+    process.stdout.write(`${package_default.version}
 `);
+    return 0;
+  }
+  if (args.selfTest) {
+    return await new CodexShim(args, "").runSelfTest();
+  }
+  const prompt = await readStdin();
+  if (!prompt) {
+    return 0;
+  }
+  const shim = new CodexShim(args, prompt);
+  return await shim.run();
 }
-
-// src/index.ts
-async function main() {
+async function runCli() {
   try {
-    const args = parseArgs(process.argv.slice(2));
-    if (!args.model && !args.selfTest && !args.version && !args.help) {
-      args.model = process.env.MODEL || "codex";
-    }
-    if (args.version) {
-      printVersion();
-      process.exit(0);
-    }
-    if (args.help) {
-      printHelp();
-      process.exit(0);
-    }
-    if (args.selfTest) {
-      const result = await runSelfTest();
-      console.log(JSON.stringify(result, null, 2));
-      process.exit(result.overall.passed ? 0 : 1);
-    }
-    if (!args.model) {
-      console.error("Error: --model argument is required");
-      process.exit(1);
-    }
-    const prompt = await readStdin();
-    if (!prompt) {
-      verboseLog(args.verbose, "Empty prompt, exiting silently");
-      process.exit(0);
-    }
-    verboseLog(args.verbose, "Starting Codex shim");
-    verboseLog(args.verbose, `Model: ${args.model}`);
-    verboseLog(args.verbose, `Prompt length: ${prompt.length} characters`);
-    if (args.resume) {
-      verboseLog(args.verbose, `Resuming session: ${args.resume}`);
-    }
-    const shim = new CodexShim(args);
-    await shim.run(prompt);
+    const exitCode = await main();
+    await flushStdout();
+    process.exit(exitCode);
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`Error: ${errorMessage}`);
+    const message = toErrorMessage(error);
+    process.stderr.write(`${message}
+`);
+    await flushStdout();
     process.exit(1);
   }
 }
-main();
+
+// src/index.ts
+await runCli();