@akagilnc/pi-workflow-roles 0.1.3999 → 0.1.4021

package/dist/headless-host/production-host.js

@@ -417,7 +417,7 @@ function normalizeReviewComment(raw) {
 function createGhApiRunner(options = {}) {
   const spawnImpl = options.spawnImpl ?? spawn;
   return async (args, runOptions = {}) => {
-    return await new Promise((resolve20, reject) => {
+    return await new Promise((resolve21, reject) => {
       const signal = runOptions.signal;
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
@@ -490,11 +490,11 @@ function createGhApiRunner(options = {}) {
               const value = line2.slice(idx + 1).trim();
               headers[name] = value;
             }
-            resolve20({ status, headers, bodyText });
+            resolve21({ status, headers, bodyText });
             return;
           }
           if (code === 0) {
-            resolve20({ status: 200, headers: {}, bodyText: stdout });
+            resolve21({ status: 200, headers: {}, bodyText: stdout });
             return;
           }
           const failure2 = new Error(
@@ -1549,7 +1549,7 @@ async function spawnEngineDetourOnce(input) {
   }
   const command = input.argv[0];
   const args = input.argv.slice(1);
-  return await new Promise((resolve20, reject) => {
+  return await new Promise((resolve21, reject) => {
     let settled = false;
     const signal = input.signal;
     const child = spawn2(command, args, {
@@ -1579,7 +1579,7 @@ async function spawnEngineDetourOnce(input) {
       if (signal !== void 0) {
         signal.removeEventListener("abort", onAbort);
       }
-      resolve20(result);
+      resolve21(result);
     };
     const onAbort = () => {
       fail4(signal !== void 0 ? abortReasonError(signal) : new Error("aborted"));
@@ -3195,6 +3195,7 @@ var init_host_descriptions = __esm({
     });
     HEADLESS_HOST_DESCRIPTIONS = Object.freeze({
       "claude": Object.freeze({
+        protocol: "claude-print",
         binaryFromHome: Object.freeze([".local", "bin", "claude"]),
         sessionBindingFile: "claude-headless-session.json",
         fixedArgs: Object.freeze([
@@ -3220,6 +3221,15 @@ var init_host_descriptions = __esm({
         mcpConfigFlag: "--mcp-config",
         sessionIdFlag: "--session-id",
         resumeFlag: "--resume"
+      }),
+      /**
+       * Codex headless (#646). Binary under operator home; auth stays in CODEX_HOME.
+       * Argv/parse/schema-close are codex-exec helpers — not Claude flag mapping.
+       */
+      "codex": Object.freeze({
+        protocol: "codex-exec",
+        binaryFromHome: Object.freeze([".local", "bin", "codex"]),
+        sessionBindingFile: "codex-headless-session.json"
       })
     });
   }
@@ -10976,12 +10986,12 @@ function createSystemCollectorClock() {
   return {
     wallNow: () => /* @__PURE__ */ new Date(),
     monoNow: () => Number(process.hrtime.bigint() - start) / 1e6,
-    sleep: (ms, signal) => new Promise((resolve20, reject) => {
+    sleep: (ms, signal) => new Promise((resolve21, reject) => {
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
         return;
       }
-      const timer = setTimeout(resolve20, ms);
+      const timer = setTimeout(resolve21, ms);
       const onAbort = () => {
         clearTimeout(timer);
         reject(signal?.reason ?? new Error("aborted"));
@@ -14515,10 +14525,10 @@ function presentFailureTerminal(terminal, io) {
 }
 function defaultNavigatorGraceSleep() {
   let timer;
-  const sleep = ((ms) => new Promise((resolve20) => {
+  const sleep = ((ms) => new Promise((resolve21) => {
     timer = setTimeout(() => {
       timer = void 0;
-      resolve20();
+      resolve21();
     }, ms);
   }));
   sleep.cancel = () => {
@@ -14530,7 +14540,7 @@ function defaultNavigatorGraceSleep() {
   return sleep;
 }
 function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep = defaultNavigatorGraceSleep()) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     let settled = false;
     const finish = (action) => {
       if (settled) return;
@@ -14539,11 +14549,11 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep
       action();
     };
     void work.then(
-      (value) => finish(() => resolve20({ status: "done", value })),
+      (value) => finish(() => resolve21({ status: "done", value })),
       (error) => finish(() => reject(error))
     );
     void sleep(graceMs).then(() => {
-      finish(() => resolve20({ status: "timeout" }));
+      finish(() => resolve21({ status: "timeout" }));
     });
   });
 }
@@ -22946,11 +22956,11 @@ function buildSkillExpansion(methodSkills, prompt) {
   });
 }
 async function listen(server, path) {
-  await new Promise((resolve20, reject) => {
+  await new Promise((resolve21, reject) => {
     server.once("error", reject);
     server.listen(path, () => {
       server.off("error", reject);
-      resolve20();
+      resolve21();
     });
   });
 }
@@ -23345,8 +23355,8 @@ async function prepareRoleEnvelope(options) {
     try {
       const closeAll = server.closeAllConnections;
       if (typeof closeAll === "function") closeAll.call(server);
-      await new Promise((resolve20, reject) => {
-        server.close((error) => error ? reject(error) : resolve20());
+      await new Promise((resolve21, reject) => {
+        server.close((error) => error ? reject(error) : resolve21());
       });
     } catch (error) {
       cleanupFailures.push(error);
@@ -23478,6 +23488,12 @@ init_session_identity();
 
 // src/headless-host/description.ts
 import { join as join37 } from "node:path";
+function isClaudePrintDescription(description) {
+  return description.protocol === "claude-print";
+}
+function isCodexExecDescription(description) {
+  return description.protocol === "codex-exec";
+}
 function resolveHeadlessBinary(description, operatorHome) {
   return join37(operatorHome, ...description.binaryFromHome);
 }
@@ -23508,6 +23524,214 @@ function headlessTurnArgs(options) {
   }
   return args;
 }
+function codexTomlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function codexTomlStringArray(values) {
+  return `[${values.map(codexTomlString).join(",")}]`;
+}
+function codexTomlStringTable(entries) {
+  const parts = Object.entries(entries).map(
+    ([key, value]) => `${key}=${codexTomlString(value)}`
+  );
+  return `{${parts.join(",")}}`;
+}
+var CODEX_JSON_VALUE_DEF = "codexJsonValue";
+var CODEX_JSON_VALUE_REF = `#/$defs/${CODEX_JSON_VALUE_DEF}`;
+var CODEX_JSON_VALUE_SCHEMA = Object.freeze({
+  anyOf: Object.freeze([
+    Object.freeze({ type: "string" }),
+    Object.freeze({ type: "number" }),
+    Object.freeze({ type: "boolean" }),
+    Object.freeze({ type: "null" }),
+    Object.freeze({ type: "array", items: Object.freeze({ $ref: CODEX_JSON_VALUE_REF }) }),
+    Object.freeze({
+      type: "object",
+      properties: Object.freeze({}),
+      required: Object.freeze([]),
+      additionalProperties: Object.freeze({ $ref: CODEX_JSON_VALUE_REF })
+    })
+  ])
+});
+function closeJsonSchemaForCodex(schema) {
+  const closed = closeSchemaNode(schema);
+  const existingDefs = isPlainObject(closed.$defs) ? closed.$defs : {};
+  return {
+    ...closed,
+    $defs: {
+      ...existingDefs,
+      [CODEX_JSON_VALUE_DEF]: CODEX_JSON_VALUE_SCHEMA
+    }
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPureNullTypeSchema(value) {
+  if (!isPlainObject(value)) return false;
+  if (value.type === "null") return true;
+  if (Array.isArray(value.type) && value.type.length > 0 && value.type.every((t) => t === "null")) {
+    return true;
+  }
+  return false;
+}
+function stripNullFromLeafType(leaf) {
+  if (!isPlainObject(leaf) || !Array.isArray(leaf.type)) return leaf;
+  const nonNull = leaf.type.filter((t) => t !== "null");
+  if (nonNull.length === leaf.type.length) return leaf;
+  if (nonNull.length === 0) return { ...leaf, type: "null" };
+  if (nonNull.length === 1) return { ...leaf, type: nonNull[0] };
+  return { ...leaf, type: nonNull };
+}
+function flattenUnionLeaves(schema) {
+  if (!isPlainObject(schema)) return [schema];
+  if (Array.isArray(schema.anyOf)) {
+    return schema.anyOf.flatMap(flattenUnionLeaves);
+  }
+  return [schema];
+}
+function nonNullLeaves(schema) {
+  return flattenUnionLeaves(schema).map(stripNullFromLeafType).filter((leaf) => !isPureNullTypeSchema(leaf));
+}
+function closePropertySchema(schema, optional) {
+  const leaves = nonNullLeaves(schema).map(closeSchemaNode);
+  if (leaves.length === 0) return { type: "null" };
+  if (!optional) {
+    return leaves.length === 1 ? leaves[0] : { anyOf: leaves };
+  }
+  return { anyOf: [...leaves, { type: "null" }] };
+}
+function ensureTypedLeaf(schema) {
+  if (schema.type !== void 0) return schema;
+  if (typeof schema.$ref === "string") return schema;
+  if (isPlainObject(schema.properties) || schema.additionalProperties !== void 0) {
+    return { ...schema, type: "object" };
+  }
+  if (schema.items !== void 0) {
+    return { ...schema, type: "array" };
+  }
+  if (schema.const !== void 0) {
+    const value = schema.const;
+    if (value === null) return { ...schema, type: "null" };
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return { ...schema, type: typeof value };
+    }
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const sample = schema.enum.find((item) => item !== null);
+    if (typeof sample === "string" || typeof sample === "number" || typeof sample === "boolean") {
+      return { ...schema, type: typeof sample };
+    }
+  }
+  return { $ref: CODEX_JSON_VALUE_REF };
+}
+function originalRequiredNames(node) {
+  if (!Array.isArray(node.required)) return /* @__PURE__ */ new Set();
+  return new Set(node.required.filter((item) => typeof item === "string"));
+}
+function closeSchemaNode(node) {
+  if (!isPlainObject(node)) return node;
+  if (typeof node.$ref === "string") return node;
+  if (Array.isArray(node.anyOf)) {
+    const leaves = nonNullLeaves(node).map(closeSchemaNode);
+    if (leaves.length === 0) return { type: "null" };
+    if (leaves.length === 1) return leaves[0];
+    return { anyOf: leaves };
+  }
+  let out = { ...node };
+  if (node.items !== void 0) {
+    out.items = closeSchemaNode(node.items);
+  }
+  if (isPlainObject(node.$defs)) {
+    out.$defs = Object.fromEntries(
+      Object.entries(node.$defs).map(([key, value]) => [key, closeSchemaNode(value)])
+    );
+  }
+  const hasProperties = isPlainObject(node.properties);
+  const isObjectType = node.type === "object" || Array.isArray(node.type) && node.type.includes("object") || hasProperties || node.additionalProperties !== void 0;
+  if (hasProperties) {
+    const props = node.properties;
+    const wasRequired = originalRequiredNames(node);
+    const closedProps = {};
+    const required = [];
+    for (const [name, propSchema] of Object.entries(props)) {
+      required.push(name);
+      closedProps[name] = closePropertySchema(propSchema, !wasRequired.has(name));
+    }
+    out.properties = closedProps;
+    out.required = required;
+    out.additionalProperties = false;
+    if (out.type === void 0) out.type = "object";
+    delete out.anyOf;
+  } else if (isObjectType) {
+    out.additionalProperties = false;
+    if (!Array.isArray(out.required)) out.required = [];
+    if (out.type === void 0) out.type = "object";
+  } else {
+    out = ensureTypedLeaf(out);
+  }
+  return out;
+}
+function stringEnvironment(value) {
+  const entries = Array.isArray(value) ? value.flatMap((item) => {
+    if (!isPlainObject(item) || typeof item.name !== "string" || typeof item.value !== "string") return [];
+    return [[item.name, item.value]];
+  }) : isPlainObject(value) ? Object.entries(value).filter((entry) => typeof entry[1] === "string") : [];
+  return entries.length === 0 ? void 0 : Object.fromEntries(entries);
+}
+function codexMcpConfigArgs(mcpServers) {
+  const args = [];
+  for (const row of mcpServers) {
+    const name = typeof row.name === "string" ? row.name : void 0;
+    const command = typeof row.command === "string" ? row.command : void 0;
+    if (name === void 0 || name === "" || command === void 0 || command === "") continue;
+    const prefix = `mcp_servers.${name}`;
+    args.push("-c", `${prefix}.command=${codexTomlString(command)}`);
+    args.push("-c", `${prefix}.required=true`);
+    if (Array.isArray(row.args) && row.args.every((item) => typeof item === "string")) {
+      args.push("-c", `${prefix}.args=${codexTomlStringArray(row.args)}`);
+    }
+    const env = stringEnvironment(row.env);
+    if (env !== void 0) {
+      args.push("-c", `${prefix}.env=${codexTomlStringTable(env)}`);
+    }
+  }
+  return args;
+}
+function codexTurnArgs(options) {
+  const args = ["exec", "--approve-for-me"];
+  if (options.session.kind === "resume") {
+    args.push("resume", options.session.id);
+  }
+  args.push("--json");
+  args.push("--ignore-user-config", "--ignore-rules");
+  const roots = (options.writableRoots ?? []).filter((root) => root !== "");
+  if (roots.length > 0) {
+    args.push(
+      "-c",
+      `sandbox_workspace_write.writable_roots=${codexTomlStringArray(roots)}`
+    );
+    if (options.session.kind === "new") {
+      for (const root of roots) {
+        args.push("--add-dir", root);
+      }
+    }
+  }
+  args.push("-c", `model_instructions_file=${codexTomlString(options.systemPromptPath)}`);
+  args.push("--output-schema", options.outputSchemaPath);
+  args.push(...codexMcpConfigArgs(options.mcpServers));
+  if (options.model !== void 0 && options.model !== "") {
+    args.push("-m", options.model);
+  }
+  if (options.effort !== void 0 && options.effort !== "") {
+    args.push("-c", `model_reasoning_effort=${codexTomlString(options.effort)}`);
+  }
+  if (options.skipGitRepoCheck === true) {
+    args.push("--skip-git-repo-check");
+  }
+  args.push("--", options.prompt);
+  return args;
+}
 function headlessMcpConfigDocument(mcpServers) {
   const servers = {};
   for (const row of mcpServers) {
@@ -23516,29 +23740,19 @@ function headlessMcpConfigDocument(mcpServers) {
     if (name === void 0 || name === "" || command === void 0 || command === "") continue;
     const entry = { command };
     if (Array.isArray(row.args)) entry.args = row.args;
-    if (Array.isArray(row.env)) {
-      const env = {};
-      for (const item of row.env) {
-        if (typeof item !== "object" || item === null) continue;
-        const record4 = item;
-        if (typeof record4.name === "string" && typeof record4.value === "string") {
-          env[record4.name] = record4.value;
-        }
-      }
-      if (Object.keys(env).length > 0) entry.env = env;
-    } else if (typeof row.env === "object" && row.env !== null && !Array.isArray(row.env)) {
-      entry.env = row.env;
-    }
+    const env = stringEnvironment(row.env);
+    if (env !== void 0) entry.env = env;
     servers[name] = entry;
   }
   return Object.freeze({ mcpServers: Object.freeze(servers) });
 }
 
 // src/headless-host/role-turn-host.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn4, spawnSync } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
+import { existsSync as existsSync12 } from "node:fs";
 import { writeFile as writeFile11 } from "node:fs/promises";
-import { join as join38 } from "node:path";
+import { dirname as dirname21, isAbsolute as isAbsolute11, join as join38, resolve as resolve20 } from "node:path";
 
 // src/external-host-turn-loop.ts
 var EXTERNAL_ROLE_TURN_ROUND_LIMIT = 8;
@@ -23667,7 +23881,7 @@ function failure(cause, name, code, details, diagnostic) {
   };
 }
 function isHeadlessResultCandidate(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  if (!isPlainObject(value)) return false;
   const record4 = value;
   return record4.type === void 0 || record4.type === "result" || record4.structured_output !== void 0;
 }
@@ -23685,7 +23899,7 @@ function parseHeadlessCliStdout(stdout) {
     if (text === "") continue;
     try {
       const value = JSON.parse(text);
-      if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+      if (!isPlainObject(value)) continue;
       const record4 = value;
       if (record4.type === "result" || record4.structured_output !== void 0) {
         last = record4;
@@ -23705,8 +23919,87 @@ function resultCandidateText(line2) {
     return void 0;
   }
 }
+function createCodexExecTurnObserver() {
+  let threadId;
+  let finalMessage;
+  let failureDiagnostic;
+  let turnCompleted = false;
+  return {
+    observe(value) {
+      if (!isPlainObject(value)) return;
+      const type = typeof value.type === "string" ? value.type : void 0;
+      if (type === "thread.started" && typeof value.thread_id === "string" && value.thread_id !== "") {
+        threadId = value.thread_id;
+      } else if (type === "item.completed" && isPlainObject(value.item)) {
+        if (value.item.type === "agent_message" && typeof value.item.text === "string") {
+          finalMessage = value.item.text;
+        }
+      } else if (type === "turn.completed") {
+        turnCompleted = true;
+        failureDiagnostic = void 0;
+      } else if (type === "turn.failed") {
+        turnCompleted = false;
+        failureDiagnostic = formatCodexFailurePayload(value.error ?? value);
+      }
+    },
+    result() {
+      return {
+        ...threadId === void 0 ? {} : { threadId },
+        ...finalMessage === void 0 ? {} : { finalMessage },
+        ...failureDiagnostic === void 0 ? {} : { failureDiagnostic },
+        turnCompleted
+      };
+    }
+  };
+}
+function formatCodexFailurePayload(payload) {
+  if (typeof payload === "string" && payload.trim() !== "") return payload;
+  if (isPlainObject(payload)) {
+    if (typeof payload.message === "string" && payload.message.trim() !== "") return payload.message;
+    try {
+      return JSON.stringify(payload);
+    } catch {
+      return "codex turn failed";
+    }
+  }
+  return String(payload);
+}
+function cwdIsGitWorkTree(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    if (existsSync12(join38(dir, ".git"))) return true;
+    const parent = dirname21(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+function resolveGitCommonDir(cwd) {
+  if (!cwdIsGitWorkTree(cwd)) return void 0;
+  let result;
+  try {
+    result = spawnSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd,
+      encoding: "utf8"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`git rev-parse --git-common-dir failed: ${message}`);
+  }
+  if (result.error !== void 0) {
+    throw new Error(`git rev-parse --git-common-dir failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || `exit ${String(result.status)}`;
+    throw new Error(`git rev-parse --git-common-dir failed: ${detail}`);
+  }
+  const raw = result.stdout.trim();
+  if (raw === "") {
+    throw new Error("git rev-parse --git-common-dir returned empty stdout");
+  }
+  return isAbsolute11(raw) ? raw : resolve20(cwd, raw);
+}
 function spawnHeadlessTurn(options) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve21, reject) => {
     if (options.signal?.aborted) {
       reject(hostAbortedError("headless host aborted"));
       return;
@@ -23765,7 +24058,7 @@ function spawnHeadlessTurn(options) {
       settled = true;
       if (timer !== void 0) clearTimeout(timer);
       options.signal?.removeEventListener("abort", onAbort);
-      resolve20({ code, stdout: resultStdout, stderr, timedOut });
+      resolve21({ code, stdout: resultStdout, stderr, timedOut });
     };
     const onAbort = () => {
       child.kill("SIGTERM");
@@ -23821,28 +24114,70 @@ function terminalFromSpawned(spawned, knownFailure) {
     }
   };
 }
+function buildTurnArgs(options) {
+  if (isCodexExecDescription(options.description)) {
+    if (options.sessionKind === "resume" && !options.sessionId) {
+      throw new Error("codex resume requires a bound thread_id");
+    }
+    if (options.outputSchemaPath === void 0) throw new Error("codex requires an output schema path");
+    return codexTurnArgs({
+      prompt: options.prompt,
+      systemPromptPath: options.systemPromptPath,
+      outputSchemaPath: options.outputSchemaPath,
+      mcpServers: options.mcpServers,
+      ...options.model === void 0 ? {} : { model: options.model },
+      ...options.effort === void 0 ? {} : { effort: options.effort },
+      session: options.sessionKind === "resume" ? { kind: "resume", id: options.sessionId } : { kind: "new" },
+      skipGitRepoCheck: !cwdIsGitWorkTree(options.cwd),
+      ...!options.writableRoots?.length ? {} : { writableRoots: options.writableRoots }
+    });
+  }
+  if (!isClaudePrintDescription(options.description)) throw new Error("unsupported headless host protocol");
+  if (!options.sessionId) throw new Error("claude print-mode requires a session id");
+  if (options.mcpConfigPath === void 0) throw new Error("claude print-mode requires an MCP config path");
+  return headlessTurnArgs({
+    description: options.description,
+    prompt: options.prompt,
+    systemPromptPath: options.systemPromptPath,
+    jsonSchema: options.jsonSchema,
+    mcpConfigPath: options.mcpConfigPath,
+    ...options.model === void 0 ? {} : { model: options.model },
+    ...options.effort === void 0 ? {} : { effort: options.effort },
+    session: { kind: options.sessionKind, id: options.sessionId }
+  });
+}
 function createHeadlessRoleTurnHost(config) {
   return createSerializedRoleTurnHost(async (request) => {
     const prepared = await config.prepare(request);
     const systemPrompt = renderSystemPromptOverride(prepared.systemPrompt);
+    const codex = isCodexExecDescription(config.description);
     let outcome = failure("session", "HeadlessNoOutcome", "no-outcome");
     try {
       let sessionId = await config.sessionIdentity.load(request.principal);
       let sessionKind = request.continuation.kind === "resume" && sessionId !== void 0 && sessionId !== "" ? "resume" : "new";
-      if (sessionKind === "new") {
+      if (sessionKind === "new" && !codex) {
         sessionId = randomUUID8();
         await config.sessionIdentity.bind(request.principal, sessionId);
       }
       const env = { ...process.env, ...config.env ?? {} };
       const systemPromptPath = join38(request.runDirectory, "headless-system-prompt.txt");
       await writeFile11(systemPromptPath, systemPrompt, "utf8");
-      const mcpConfigPath = join38(request.runDirectory, "headless-mcp-config.json");
-      await writeFile11(
-        mcpConfigPath,
-        `${JSON.stringify(headlessMcpConfigDocument(prepared.mcpServers), null, 2)}
+      let mcpConfigPath;
+      let outputSchemaPath;
+      if (codex) {
+        outputSchemaPath = join38(request.runDirectory, "headless-output-schema.json");
+        const closed = closeJsonSchemaForCodex(prepared.jsonSchema);
+        await writeFile11(outputSchemaPath, `${JSON.stringify(closed, null, 2)}
+`, "utf8");
+      } else {
+        mcpConfigPath = join38(request.runDirectory, "headless-mcp-config.json");
+        await writeFile11(
+          mcpConfigPath,
+          `${JSON.stringify(headlessMcpConfigDocument(prepared.mcpServers), null, 2)}
 `,
-        "utf8"
-      );
+          "utf8"
+        );
+      }
       const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
       outcome = await driveExternalRoleTurnRounds(prepared, request, {
         roundLimitName: "HeadlessRoundLimit",
@@ -23851,16 +24186,32 @@ function createHeadlessRoleTurnHost(config) {
           sessionKind = "resume";
         },
         async runRound({ prompt, abortSignal }) {
-          const args = headlessTurnArgs({
-            description: config.description,
-            prompt,
-            systemPromptPath,
-            jsonSchema: prepared.jsonSchema,
-            mcpConfigPath,
-            ...request.model?.model !== void 0 ? { model: request.model.model } : {},
-            ...request.model?.thinking !== void 0 ? { effort: request.model.thinking } : {},
-            session: sessionKind === "new" ? { kind: "new", id: sessionId } : { kind: "resume", id: sessionId }
-          });
+          let args;
+          try {
+            const gitCommonDir = codex ? resolveGitCommonDir(request.cwd) : void 0;
+            args = buildTurnArgs({
+              description: config.description,
+              prompt,
+              systemPromptPath,
+              jsonSchema: prepared.jsonSchema,
+              mcpServers: prepared.mcpServers,
+              ...mcpConfigPath === void 0 ? {} : { mcpConfigPath },
+              ...outputSchemaPath === void 0 ? {} : { outputSchemaPath },
+              ...request.model?.model !== void 0 ? { model: request.model.model } : {},
+              ...request.model?.thinking !== void 0 ? { effort: request.model.thinking } : {},
+              sessionId,
+              sessionKind,
+              cwd: request.cwd,
+              ...gitCommonDir === void 0 ? {} : { writableRoots: [gitCommonDir] }
+            });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              status: "terminal",
+              result: failure("session", "HeadlessArgvFailure", "argv-failed", { diagnostic: message }, message)
+            };
+          }
+          const codexObserver = codex ? createCodexExecTurnObserver() : void 0;
           let spawned;
           try {
             spawned = await spawnHeadlessTurn({
@@ -23886,6 +24237,7 @@ function createHeadlessRoleTurnHost(config) {
                   source: "headless-host",
                   event
                 });
+                codexObserver?.observe(event);
               }
             });
           } catch (error) {
@@ -23919,6 +24271,64 @@ function createHeadlessRoleTurnHost(config) {
               details: { sessionId }
             });
           }
+          if (codex) {
+            const observation = codexObserver.result();
+            if (observation.threadId === void 0 || observation.threadId === "") {
+              return terminalFromSpawned(spawned, {
+                cause: "session",
+                identity: { name: "HeadlessMissingThreadId", code: "missing-thread-id" },
+                diagnostic: "codex exec emitted no thread.started thread_id",
+                details: { sessionId, exitCode: spawned.code }
+              });
+            }
+            sessionId = observation.threadId;
+            await config.sessionIdentity.bind(request.principal, sessionId);
+            if (observation.failureDiagnostic !== void 0) {
+              return terminalFromSpawned(spawned, {
+                cause: "output",
+                identity: { name: "HeadlessCliError", code: "codex-turn-failed" },
+                diagnostic: observation.failureDiagnostic,
+                details: { sessionId, exitCode: spawned.code }
+              });
+            }
+            if (spawned.code !== 0 && spawned.code !== null) {
+              return terminalFromSpawned(spawned, {
+                cause: "output",
+                identity: { name: "HeadlessCliError", code: "codex-nonzero-exit" },
+                diagnostic: spawned.stderr.trim() || `codex exec exited ${String(spawned.code)}`,
+                details: { sessionId, exitCode: spawned.code }
+              });
+            }
+            if (!observation.turnCompleted) {
+              return terminalFromSpawned(spawned, {
+                cause: "output",
+                identity: { name: "HeadlessCliError", code: "codex-missing-terminal-event" },
+                diagnostic: "codex exec exited without turn.completed",
+                details: { sessionId, exitCode: spawned.code }
+              });
+            }
+            if (observation.finalMessage === void 0) {
+              return terminalFromSpawned(spawned, {
+                cause: "output",
+                identity: { name: "HeadlessEmptyOutput", code: "empty-stdout" },
+                diagnostic: spawned.stderr.trim() || "codex exec produced no agent_message",
+                details: { sessionId, exitCode: spawned.code }
+              });
+            }
+            let receipt;
+            try {
+              receipt = JSON.parse(observation.finalMessage);
+            } catch {
+              return terminalFromSpawned(spawned, {
+                cause: "output",
+                identity: { name: "HeadlessEmptyOutput", code: "unparseable-final-message" },
+                diagnostic: "codex final agent_message was not JSON",
+                details: { sessionId, exitCode: spawned.code }
+              });
+            }
+            await prepared.ingestStructuredOutput(receipt);
+            return { status: "delivered", stderr: spawned.stderr };
+          }
           const envelope = parseHeadlessCliStdout(spawned.stdout);
           if (envelope === void 0) {
             return terminalFromSpawned(spawned, {