@runuai/host 0.9.94 → 0.9.95

package/lib/engine-accounts.ts

@@ -345,6 +345,46 @@ export function pickEngineAccount(
   return selectAccount(accounts, { exclude: opts.exclude, now: opts.now });
 }
 
+/**
+ * ADR-076 + codex-cli 0.152.0: two codex agents sharing one account share one
+ * CODEX_HOME, and codex's sqlite state runtime cannot be opened by two
+ * concurrent processes. These pure helpers give each codex agent its own
+ * home (a copy of the account's) — the orchestrator wraps them with the
+ * container exec. Only codex config-dir homes under /home/node/.codex are
+ * isolated; ambient/env accounts and other kinds are left untouched.
+ */
+export function codexHomeIsolatable(
+  kind: string,
+  codexHome: string | undefined,
+): codexHome is string {
+  return (
+    kind === "codex" &&
+    typeof codexHome === "string" &&
+    codexHome.startsWith("/home/node/.codex")
+  );
+}
+
+/** The per-agent home for a shared account home. Agent id is sanitized so it
+ *  is always a safe path segment. */
+export function codexPerAgentHome(codexHome: string, agentId: string): string {
+  const safe = agentId.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${codexHome}-agent-${safe}`;
+}
+
+/** The idempotent seed command: copy the account home into the per-agent home
+ *  ONCE (only when the per-agent home is still empty), node-owned. */
+export function codexHomeSeedCommand(
+  codexHome: string,
+  perAgentHome: string,
+): string {
+  return (
+    `set -e; mkdir -p "${perAgentHome}"; ` +
+    `if [ -z "$(ls -A "${perAgentHome}" 2>/dev/null)" ]; then ` +
+    `cp -a "${codexHome}/." "${perAgentHome}/" 2>/dev/null || true; fi; ` +
+    `chown -R node:node "${perAgentHome}"`
+  );
+}
+
 /** Test hook: clear in-memory rotation state. */
 export function resetRotationState(): void {
   rotationState.clear();

package/lib/orchestrator.ts

@@ -111,6 +111,9 @@ import {
   pickEngineAccount,
   provisionEngineAccounts,
   resolveEngineAccounts,
+  codexHomeIsolatable,
+  codexPerAgentHome,
+  codexHomeSeedCommand,
   type ResolvedEngineAccount,
 } from "./engine-accounts";
 import { clearTaskGatewayAcl, setupMcpTaskConfig } from "./mcp-gateway";
@@ -1612,15 +1615,74 @@ export class Orchestrator {
     return operation;
   }
 
+  /**
+   * Per-agent CODEX_HOME (see the call site). Returns `args` unchanged unless
+   * this is a codex agent with a config-dir CODEX_HOME; then it seeds
+   * `<home>-agent-<agentId>` from `<home>` once (in-container cp as root,
+   * node-owned) and points this agent's env there. Best-effort: a seed
+   * failure logs and falls back to the shared home rather than blocking the
+   * session — one shared home is the pre-fix behavior, not a regression.
+   */
+  private async isolateCodexHome(
+    environment: TaskEnvironmentHandle<unknown>,
+    agentId: string,
+    args: Omit<Parameters<AgentSessionFactory["create"]>[0], "environment">,
+  ): Promise<Omit<Parameters<AgentSessionFactory["create"]>[0], "environment">> {
+    const home = args.agentEnv?.CODEX_HOME;
+    if (!codexHomeIsolatable(args.agent?.kind ?? "", home)) return args;
+    const perAgent = codexPerAgentHome(home, agentId);
+    try {
+      const res = await environment.exec({
+        argv: ["/bin/sh", "-c", codexHomeSeedCommand(home, perAgent)],
+        user: "root",
+        env: RUNTIME_AUTHORITY_ENV,
+        timeoutMs: 30_000,
+        maxOutputBytes: 8 * 1024,
+      });
+      if (res.exitCode !== 0) {
+        console.warn(
+          `[codex] ${agentId}: could not isolate CODEX_HOME (exit ${res.exitCode}); using shared home`,
+        );
+        return args;
+      }
+    } catch (err) {
+      console.warn(
+        `[codex] ${agentId}: CODEX_HOME isolation errored (${
+          err instanceof Error ? err.message : String(err)
+        }); using shared home`,
+      );
+      return args;
+    }
+    return {
+      ...args,
+      agentEnv: { ...(args.agentEnv ?? {}), CODEX_HOME: perAgent },
+    };
+  }
+
   private async createAndBindStableSessionCore(
     channel: Channel,
     agentId: string,
     args: Omit<Parameters<AgentSessionFactory["create"]>[0], "environment">,
   ): Promise<AgentSession | null> {
     const environment = await this.agentEnvironment(channel);
+    // ADR-076 + codex-cli 0.152.0: two codex agents that resolve to the SAME
+    // account share one CODEX_HOME, and codex's new sqlite state runtime
+    // cannot be opened by two concurrent processes — the second agent dies
+    // with "failed to initialize sqlite state runtime under <CODEX_HOME>"
+    // (live 2026-09-04, a task with two codex agents on one account). Give
+    // each codex agent its OWN CODEX_HOME, seeded once from the resolved
+    // account's dir, so their state runtimes never collide. Single-codex
+    // tasks are unaffected beyond a one-time in-container copy.
+    // Only codex agents take the isolation path; everything else uses args
+    // directly, WITHOUT an extra await — a stray microtask here reordered the
+    // Claude re-spawn's prompt re-delivery.
+    const boundArgs =
+      args.agent?.kind === "codex"
+        ? await this.isolateCodexHome(environment, agentId, args)
+        : args;
     while (this.isActiveChannel(channel)) {
       const generation = channel.configGeneration;
-      const session = await this.factory.create({ ...args, environment });
+      const session = await this.factory.create({ ...boundArgs, environment });
       if (!this.isActiveChannel(channel)) {
         await session.close().catch(() => {});
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.94",
+  "version": "0.9.95",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",