svamp-cli 0.2.258 → 0.2.260

package/dist/{run-C1Unk4Zx.mjs → run-DggHONYC.mjs}

@@ -13,10 +13,7 @@ import { extname, resolve, join, sep, basename, dirname } from 'node:path';
 import { EventEmitter } from 'node:events';
 import os, { homedir, platform } from 'node:os';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
+import { createInterface } from 'node:readline';
 import { mkdir, rm, chmod, access, mkdtemp, copyFile, writeFile, readdir, stat, readFile as readFile$1 } from 'node:fs/promises';
 import { promisify as promisify$1 } from 'node:util';
 import { parse, stringify } from 'yaml';
@@ -1670,7 +1667,7 @@ function resolveSender(channel, input = {}) {
     const wsLc = hyphaWorkspace?.toLowerCase();
     if (id.hypha_allow.includes("*") || allowLc.includes(userLc) || wsLc && allowLc.includes(wsLc))
       return { sender: { name: hyphaUser, kind: "agent", verified: true } };
-    return { error: "caller not in hypha_allow" };
+    if (id.mode !== "per-key") return { error: "caller not in hypha_allow" };
   }
   if (id.mode === "fixed") {
     if (!id.fixed?.name) return { error: "fixed identity not configured" };
@@ -1727,6 +1724,11 @@ class ChannelOutbox {
   seqByChannel = /* @__PURE__ */ new Map();
   emitter = new EventEmitter();
   appendsSinceCompact = 0;
+  // #0362: change-detection for reload() — a long-poll receiver reuses ONE instance and only
+  // re-reads the on-disk log when it actually changed (mtime+size), instead of constructing a
+  // fresh ChannelOutbox (full sync readFileSync) every 500ms poll tick.
+  _lastMtimeMs = 0;
+  _lastSize = -1;
   constructor(projectDir) {
     const dir = join(projectDir, ".svamp", "channels");
     this.file = join(dir, "_outbox.jsonl");
@@ -1737,6 +1739,29 @@ class ChannelOutbox {
     }
     this._load();
   }
+  /** Current on-disk (mtimeMs, size), or (0, -1) if the file does not exist. */
+  _stat() {
+    try {
+      const st = statSync(this.file);
+      return { mtimeMs: st.mtimeMs, size: st.size };
+    } catch {
+      return { mtimeMs: 0, size: -1 };
+    }
+  }
+  /**
+   * Re-read the on-disk log ONLY if it changed since the last load (mtime+size), so a
+   * cross-process append (another session/daemon replying) is still picked up. Returns true
+   * if a reload happened. Cheap no-op when nothing changed — the fix for the receive() hot
+   * loop that re-instantiated + fully re-read the outbox every poll tick (#0362).
+   */
+  reload() {
+    const { mtimeMs, size } = this._stat();
+    if (mtimeMs === this._lastMtimeMs && size === this._lastSize) return false;
+    this.byChannel.clear();
+    this.seqByChannel.clear();
+    this._load();
+    return true;
+  }
   _load() {
     if (!existsSync(this.file)) return;
     const cutoff = Date.now() - TTL_MS;
@@ -1764,6 +1789,9 @@ class ChannelOutbox {
     let kept = 0;
     for (const arr of this.byChannel.values()) kept += arr.length;
     if (rawLines > kept) this._compact();
+    const s = this._stat();
+    this._lastMtimeMs = s.mtimeMs;
+    this._lastSize = s.size;
   }
   /** Rewrite _outbox.jsonl to the current in-memory (TTL/MAX-bounded) window. Best-effort. */
   _compact() {
@@ -2985,7 +3013,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-IXxyfgPn.mjs');
+        const { FrpcTunnel } = await import('./frpc-k3ZLz2Mu.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3452,7 +3480,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           }
           const deps = buildSessionDeps(rpc, { cwd, ownerEmail: owner });
           const sender = { name: context?.user?.email || context?.user?.id || "user", kind: "user", verified: true };
-          const { toolsForRole } = await import('./sideband-DMPZ-ZoR.mjs');
+          const { toolsForRole } = await import('./sideband-COyK5_4F.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3551,7 +3579,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
     const callId = "call_" + Math.random().toString(16).slice(2, 12);
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-D8l74hsL.mjs');
+    const { queryCore } = await import('./commands-BCMW-NM7.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3647,14 +3675,15 @@ ${d?.error || "not found"}`;
         if (r.error || !r.sender) return { error: r.error || "unauthorized" };
         const cursor = Math.max(0, Number(kwargs.cursor) || 0);
         const waitMs = Math.min(Math.max(0, Number(kwargs.wait ?? 25) * 1e3), 6e4);
+        const outbox = new ChannelOutbox(dir);
         const deadline = Date.now() + waitMs;
         for (; ; ) {
-          const outbox = new ChannelOutbox(dir);
           const replies = outbox.since(c.id, cursor, r.sender.name, kwargs.correlationId);
           if (replies.length || Date.now() >= deadline) {
             return { ok: true, replies, cursor: outbox.cursor(c.id) };
           }
           await new Promise((resolve) => setTimeout(resolve, 500));
+          outbox.reload();
         }
       },
       // Safety-restricted file upload (#0093). Deny-by-default: only channels whose
@@ -3798,7 +3827,10 @@ function readAwaiting(sessionId) {
 function writeAwaiting(sessionId, map) {
   try {
     mkdirSync(join(SVAMP_HOME$2, "awaiting"), { recursive: true });
-    writeFileSync(awaitPath(sessionId), JSON.stringify(map));
+    const p = awaitPath(sessionId);
+    const tmp = `${p}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(map));
+    renameSync(tmp, p);
   } catch {
   }
 }
@@ -3834,7 +3866,17 @@ function computeOutboundHop(sessionId) {
   return { hopCount: 1, fromInboxTurn: false };
 }
 const buckets = /* @__PURE__ */ new Map();
+const FULL_REFILL_MS = URGENT_BURST * URGENT_REFILL_MS;
+let lastBucketSweep = 0;
+function pruneIdleBuckets(now) {
+  if (now - lastBucketSweep < URGENT_REFILL_MS) return;
+  lastBucketSweep = now;
+  for (const [k, b] of buckets) {
+    if (now - b.last >= FULL_REFILL_MS) buckets.delete(k);
+  }
+}
 function takeUrgentToken(sender, now) {
+  pruneIdleBuckets(now);
   let b = buckets.get(sender);
   if (!b) {
     b = { tokens: URGENT_BURST, last: now };
@@ -8023,8 +8065,8 @@ var acpBackend = /*#__PURE__*/Object.freeze({
 const KNOWN_ACP_AGENTS = {
   gemini: { command: "gemini", args: ["--experimental-acp"] }
 };
-const KNOWN_MCP_AGENTS = {
-  codex: { command: "codex", args: ["mcp-server"] }
+const KNOWN_CODEX_AGENTS = {
+  codex: { command: "codex", args: ["app-server", "--listen", "stdio://"] }
 };
 function resolveAcpAgentConfig(cliArgs) {
   if (cliArgs.length === 0) {
@@ -8051,12 +8093,12 @@ function resolveAcpAgentConfig(cliArgs) {
       args: [...knownAcp.args, ...passthroughArgs]
     };
   }
-  const knownMcp = KNOWN_MCP_AGENTS[agentName];
-  if (knownMcp) {
+  const knownCodex = KNOWN_CODEX_AGENTS[agentName];
+  if (knownCodex) {
     return {
       agentName,
-      command: knownMcp.command,
-      args: [...knownMcp.args, ...cliArgs.slice(1)]
+      command: knownCodex.command,
+      args: [...knownCodex.args, ...cliArgs.slice(1)]
     };
   }
   return {
@@ -8069,7 +8111,7 @@ function resolveAcpAgentConfig(cliArgs) {
 var acpAgentConfig = /*#__PURE__*/Object.freeze({
     __proto__: null,
     KNOWN_ACP_AGENTS: KNOWN_ACP_AGENTS,
-    KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS,
+    KNOWN_CODEX_AGENTS: KNOWN_CODEX_AGENTS,
     resolveAcpAgentConfig: resolveAcpAgentConfig
 });
 
@@ -8078,12 +8120,12 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
   let turnText = "";
   let flushTimer = null;
   let bridgeStopped = false;
+  const pushAssistant = (content) => {
+    sessionService.pushMessage({ type: "assistant", message: { role: "assistant", content } }, "agent");
+  };
   function flushText() {
     if (pendingText) {
-      sessionService.pushMessage({
-        type: "assistant",
-        content: [{ type: "text", text: pendingText }]
-      }, "agent");
+      pushAssistant([{ type: "text", text: pendingText }]);
       pendingText = "";
     }
     if (flushTimer) {
@@ -8104,10 +8146,7 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
         } else if (msg.fullText) {
           turnText += msg.fullText;
           flushText();
-          sessionService.pushMessage({
-            type: "assistant",
-            content: [{ type: "text", text: msg.fullText }]
-          }, "agent");
+          pushAssistant([{ type: "text", text: msg.fullText }]);
         }
         break;
       }
@@ -8144,25 +8183,25 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
       }
       case "tool-call": {
         flushText();
-        sessionService.pushMessage({
-          type: "assistant",
-          content: [{
-            type: "tool_use",
-            id: msg.callId,
-            name: msg.toolName,
-            input: msg.args
-          }]
-        }, "agent");
+        pushAssistant([{
+          type: "tool_use",
+          id: msg.callId,
+          name: msg.toolName,
+          input: msg.args
+        }]);
         break;
       }
       case "tool-result": {
         sessionService.pushMessage({
-          type: "assistant",
-          content: [{
-            type: "tool_result",
-            tool_use_id: msg.callId,
-            content: typeof msg.result === "string" ? msg.result : JSON.stringify(msg.result)
-          }]
+          type: "user",
+          message: {
+            role: "user",
+            content: [{
+              type: "tool_result",
+              tool_use_id: msg.callId,
+              content: typeof msg.result === "string" ? msg.result : JSON.stringify(msg.result)
+            }]
+          }
         }, "agent");
         break;
       }
@@ -8205,10 +8244,7 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
         if (msg.name === "thinking") {
           const payload = msg.payload;
           const text = payload?.text || JSON.stringify(payload);
-          sessionService.pushMessage({
-            type: "assistant",
-            content: [{ type: "thinking", thinking: text }]
-          }, "agent");
+          pushAssistant([{ type: "thinking", thinking: text }]);
         } else {
           sessionService.pushMessage({
             type: "session_event",
@@ -8266,440 +8302,657 @@ class HyphaPermissionHandler {
   }
 }
 
-const DEFAULT_TIMEOUT = 14 * 24 * 60 * 60 * 1e3;
-function getCodexMcpCommand() {
+function mapCodexEventToText(event) {
+  if (!event || typeof event !== "object") return "";
+  if (typeof event.message === "string") return event.message;
+  if (typeof event.text === "string") return event.text;
+  const content = event.content;
+  if (Array.isArray(content)) {
+    return content.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join("");
+  }
+  const delta = event.delta;
+  if (delta && typeof delta === "object" && typeof delta.text === "string") return delta.text;
+  if (typeof delta === "string") return delta;
+  return "";
+}
+function normalizeNotification(method, params) {
+  if (method === "item/agentMessage/delta") {
+    return typeof params?.delta === "string" ? { type: "agent_message_delta", delta: params.delta } : null;
+  }
+  if (method === "item/reasoning/delta") {
+    return typeof params?.delta === "string" ? { type: "agent_reasoning_delta", delta: params.delta } : null;
+  }
+  if (method === "item/started" || method === "item/completed" || method === "item/updated") {
+    const item = params?.item;
+    if (!item || typeof item !== "object") return null;
+    const done = method === "item/completed";
+    switch (item.type) {
+      case "agentMessage":
+        return done && typeof item.text === "string" && item.text ? { type: "agent_message", message: item.text } : null;
+      case "reasoning": {
+        if (!done) return null;
+        const text = Array.isArray(item.content) ? item.content.join("") : Array.isArray(item.summary) ? item.summary.join("") : typeof item.text === "string" ? item.text : "";
+        return text ? { type: "agent_reasoning", text } : null;
+      }
+      case "commandExecution":
+        return done ? { type: "exec_command_end", call_id: item.id, exit_code: item.exitCode, stdout: item.aggregatedOutput ?? "", stderr: "" } : { type: "exec_command_begin", call_id: item.id, command: item.command, cwd: item.cwd };
+      case "fileChange":
+        return done ? { type: "patch_apply_end", call_id: item.id, applied: item.status === "completed" || item.status === "applied" } : { type: "patch_apply_begin", call_id: item.id, changes: item.changes };
+      case "mcpToolCall":
+        return done ? { type: "mcp_tool_call_end", call_id: item.id, tool: item.tool, result: item.result, error: item.error } : { type: "mcp_tool_call_begin", call_id: item.id, tool: item.tool, server: item.server, arguments: item.arguments };
+      case "userMessage":
+      default:
+        return null;
+    }
+  }
+  if (method === "thread/tokenUsage/updated") {
+    return { type: "token_usage", usage: params?.usage ?? params };
+  }
+  return null;
+}
+
+function parseCodexVersion(v) {
+  const m = v.match(/codex-cli\s+(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return null;
+  const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (![major, minor, patch].every(Number.isFinite)) return null;
+  return { major, minor, patch };
+}
+function codexAppServerAvailable() {
   try {
-    const version = execSync("codex --version", { encoding: "utf8" }).trim();
-    const match = version.match(/codex-cli\s+(\d+\.\d+\.\d+(?:-alpha\.\d+)?)/);
-    if (!match) return "mcp-server";
-    const versionStr = match[1];
-    const [major, minor, patch] = versionStr.split(/[-.]/).map(Number);
-    if (major > 0 || minor > 43) return "mcp-server";
-    if (minor === 43 && patch === 0) {
-      if (versionStr.includes("-alpha.")) {
-        const alphaNum = parseInt(versionStr.split("-alpha.")[1]);
-        return alphaNum >= 5 ? "mcp-server" : "mcp";
-      }
-      return "mcp-server";
-    }
-    return "mcp";
+    const v = parseCodexVersion(execSync("codex --version", { encoding: "utf8" }).trim());
+    if (!v) return false;
+    return v.major > 0 || v.minor >= 100;
   } catch {
     return null;
   }
 }
-class CodexMcpBackend {
-  listeners = [];
-  client;
-  transport = null;
-  disposed = false;
-  turnCancelled = false;
-  // set by cancel() to suppress 'idle' in sendPrompt() finally
-  turnId = 0;
-  // monotonically increasing; each sendPrompt() captures its own ID
-  codexSessionId = null;
-  conversationId = null;
-  svampSessionId = null;
-  log;
-  options;
+class CodexAppServerClient {
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.log ?? (() => {
+    });
+  }
+  process = null;
+  readline = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
   connected = false;
-  // Pending elicitation approvals
-  pendingApprovals = /* @__PURE__ */ new Map();
-  // Temp files from isolation wrapping (cleaned up on disconnect)
-  _isolationCleanupFiles = [];
-  constructor(options) {
-    this.options = options;
-    this.log = options.log || (() => {
+  _threadId = null;
+  _turnId = null;
+  // A turn is "in flight" from turn/start until task_complete / turn_aborted (or turn/completed).
+  pendingTurn = null;
+  completedTurnIds = /* @__PURE__ */ new Set();
+  log;
+  get threadId() {
+    return this._threadId;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  /** The app-server child process (for the daemon's liveness watchdog). */
+  get childProcess() {
+    return this.process;
+  }
+  // ── lifecycle ────────────────────────────────────────────────────────────
+  async start() {
+    if (this.connected) return;
+    let command = "codex";
+    let args = ["app-server", "--listen", "stdio://", ...this.opts.extraArgs ?? []];
+    if (this.opts.isolationConfig) {
+      const wrapped = wrapWithIsolation(command, args, this.opts.isolationConfig);
+      command = wrapped.command;
+      args = wrapped.args;
+    }
+    const child = spawn(command, args, {
+      cwd: this.opts.cwd,
+      // RUST_LOG mutes rollout noise on stderr; keep the rest of env for auth (~/.codex or key).
+      env: { RUST_LOG: "error", ...process.env, ...this.opts.env ?? {} },
+      stdio: ["pipe", "pipe", "pipe"]
     });
-    this.client = new Client(
-      { name: "svamp-codex-client", version: "1.0.0" },
-      { capabilities: { elicitation: {} } }
-    );
-    this.client.setNotificationHandler(z.object({
-      method: z.literal("codex/event"),
-      params: z.object({ msg: z.any() })
-    }).passthrough(), (data) => {
-      const msg = data.params.msg;
-      this.updateIdentifiersFromEvent(msg);
-      this.handleCodexEvent(msg);
+    this.process = child;
+    child.stderr?.on("data", (d) => this.log("[codex-app-server:stderr]", d.toString().trim()));
+    child.on("exit", (code) => {
+      const wasConnected = this.connected;
+      this.connected = false;
+      this.failAllPending(new Error(`codex app-server exited (code ${code})`));
+      this.resolvePendingTurn(true);
+      if (wasConnected) this.opts.onExit?.(code);
+    });
+    child.on("error", (err) => {
+      this.log("[codex-app-server] spawn error", err);
+    });
+    this.readline = createInterface({ input: child.stdout });
+    this.readline.on("line", (line) => this.onLine(line));
+    const initParams = {
+      clientInfo: { name: "svamp-codex", title: "Svamp Codex Client", version: "2.0.0" },
+      capabilities: { experimentalApi: true }
+    };
+    await this.request("initialize", initParams);
+    this.notify("initialized");
+    this.connected = true;
+    this.log("[codex-app-server] connected + initialized");
+  }
+  async startThread(o) {
+    const params = {
+      model: o.model ?? null,
+      modelProvider: null,
+      profile: null,
+      cwd: o.cwd ?? this.opts.cwd,
+      approvalPolicy: o.approvalPolicy ?? null,
+      sandbox: o.sandbox ?? null,
+      config: null,
+      baseInstructions: null,
+      developerInstructions: null,
+      compactPrompt: null,
+      includeApplyPatchTool: null,
+      experimentalRawEvents: false,
+      persistExtendedHistory: true
+    };
+    const r = await this.request("thread/start", params);
+    this._threadId = r.thread.id;
+    this._turnId = null;
+    this.log("[codex-app-server] thread started", this._threadId);
+    return { threadId: r.thread.id, model: r.model };
+  }
+  async resumeThread(o) {
+    const params = {
+      threadId: o.threadId,
+      model: o.model ?? null,
+      modelProvider: null,
+      cwd: o.cwd ?? this.opts.cwd,
+      approvalPolicy: o.approvalPolicy ?? null,
+      sandbox: o.sandbox ?? null,
+      config: null,
+      baseInstructions: null,
+      developerInstructions: null,
+      persistExtendedHistory: true
+    };
+    const r = await this.request("thread/resume", params);
+    this._threadId = r.thread.id;
+    this._turnId = null;
+    this.log("[codex-app-server] thread resumed", this._threadId);
+    return { threadId: r.thread.id, model: r.model };
+  }
+  /** Build the turn/start params (exported shape kept minimal; only set fields are sent). */
+  buildTurnParams(prompt, o) {
+    const params = { threadId: this._threadId, input: [{ type: "text", text: prompt }] };
+    if (o?.approvalPolicy) params.approvalPolicy = o.approvalPolicy;
+    if (o?.model) params.model = o.model;
+    if (o?.effort) params.effort = o.effort;
+    if (o?.sandbox) {
+      params.sandboxPolicy = { type: o.sandbox === "workspace-write" ? "workspaceWrite" : o.sandbox === "danger-full-access" ? "dangerFullAccess" : "readOnly" };
+    }
+    return params;
+  }
+  /** Start a turn; resolves immediately (completion is tracked via events / waitForTurn). */
+  async startTurn(prompt, o) {
+    if (!this._threadId) throw new Error("No active codex thread \u2014 call startThread first");
+    const result = await this.request("turn/start", this.buildTurnParams(prompt, o));
+    const id = result?.turn?.id;
+    if (typeof id === "string" && id) this._turnId = id;
+  }
+  /** Send a turn and await completion (resolves {aborted} on task_complete/turn_aborted/timeout). */
+  async sendTurnAndWait(prompt, o) {
+    const timeoutMs = o?.timeoutMs ?? 14 * 24 * 60 * 60 * 1e3;
+    let timer = null;
+    const completion = new Promise((resolve) => {
+      this.pendingTurn = { resolve };
+      timer = setTimeout(() => {
+        this.log("[codex-app-server] turn timeout");
+        this.resolvePendingTurn(true);
+      }, timeoutMs);
+      timer?.unref?.();
     });
+    try {
+      await this.startTurn(prompt, o);
+    } catch (e) {
+      if (timer) clearTimeout(timer);
+      this.pendingTurn = null;
+      throw e;
+    }
+    const aborted = await completion;
+    if (timer) clearTimeout(timer);
+    return { aborted };
   }
-  // ── AgentBackend interface ──────────────────────────────────────────
-  onMessage(handler) {
-    this.listeners.push(handler);
+  /** Interrupt the in-flight turn (real server-side abort — the old MCP path couldn't do this). */
+  async interrupt() {
+    if (!this._threadId || !this._turnId) return;
+    const params = { threadId: this._threadId, turnId: this._turnId };
+    try {
+      await this.request("turn/interrupt", params, 1e4);
+    } catch (e) {
+      this.log("[codex-app-server] interrupt err (may be benign)", e);
+    }
   }
-  offMessage(handler) {
-    const idx = this.listeners.indexOf(handler);
-    if (idx !== -1) this.listeners.splice(idx, 1);
+  async dispose() {
+    this.readline?.close();
+    this.readline = null;
+    const proc = this.process;
+    const pid = proc?.pid;
+    try {
+      proc?.stdin?.end();
+      proc?.kill("SIGTERM");
+    } catch {
+    }
+    if (pid) {
+      const t = setTimeout(() => {
+        try {
+          process.kill(pid, 0);
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }, 2e3);
+      t.unref?.();
+    }
+    this.process = null;
+    this.connected = false;
+    this._threadId = null;
+    this._turnId = null;
+    this.failAllPending(new Error("codex app-server disposed"));
+    this.resolvePendingTurn(true);
+  }
+  // ── JSON-RPC plumbing ──────────────────────────────────────────────────────
+  request(method, params, timeoutMs) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, method });
+      if (timeoutMs) {
+        const t = setTimeout(() => {
+          if (this.pending.has(id)) {
+            this.pending.delete(id);
+            reject(new Error(`codex ${method} timed out after ${timeoutMs}ms`));
+          }
+        }, timeoutMs);
+        t.unref?.();
+      }
+      this.write({ jsonrpc: "2.0", id, method, params });
+    });
   }
+  notify(method, params) {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  respond(id, result) {
+    this.write({ jsonrpc: "2.0", id, result });
+  }
+  write(obj) {
+    try {
+      this.process?.stdin?.write(JSON.stringify(obj) + "\n");
+    } catch (e) {
+      this.log("[codex-app-server] write error", e);
+    }
+  }
+  failAllPending(err) {
+    for (const [id, p] of this.pending) {
+      p.reject(err);
+      this.pending.delete(id);
+    }
+  }
+  onLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      this.log("[codex-app-server] non-JSON line", trimmed.slice(0, 200));
+      return;
+    }
+    if (msg.id !== void 0 && msg.method === void 0) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      const r = msg;
+      if (r.error) p.reject(new Error(`codex ${p.method}: ${r.error.message}`));
+      else p.resolve(r.result);
+      return;
+    }
+    if (msg.id !== void 0 && typeof msg.method === "string") {
+      void this.handleServerRequest(msg.id, msg.method, msg.params);
+      return;
+    }
+    if (typeof msg.method === "string") {
+      this.handleNotification(msg.method, msg.params);
+      return;
+    }
+  }
+  // ── server→client approval requests ────────────────────────────────────────
+  async handleServerRequest(id, method, params) {
+    const handler = this.opts.onApproval;
+    if (method === "item/commandExecution/requestApproval" || method === "execCommandApproval") {
+      const callId = String(params?.itemId ?? params?.callId ?? id);
+      const decision = handler ? await handler({ type: "exec", callId, command: Array.isArray(params?.command) ? params.command : params?.command != null ? [params.command] : [], cwd: params?.cwd, reason: params?.reason }).catch(() => "denied") : "denied";
+      this.respond(id, { decision: mapDecisionToWire(decision) });
+      return;
+    }
+    if (method === "item/fileChange/requestApproval" || method === "applyPatchApproval") {
+      const callId = String(params?.itemId ?? params?.callId ?? id);
+      const decision = handler ? await handler({ type: "patch", callId, fileChanges: params?.fileChanges, reason: params?.reason }).catch(() => "denied") : "denied";
+      this.respond(id, { decision: mapDecisionToWire(decision) });
+      return;
+    }
+    if (method === "mcpServer/elicitation/request") {
+      const callId = `${params?.serverName ?? "mcp"}:${id}`;
+      const decision = handler ? await handler({ type: "mcp", callId, serverName: params?.serverName, toolName: params?.serverName, message: params?.message, input: params?._meta?.tool_params ?? {} }).catch(() => "denied") : "denied";
+      const wire = mapDecisionToWire(decision);
+      this.respond(id, { action: wire === "acceptForSession" ? "accept" : wire });
+      return;
+    }
+    this.respond(id, {});
+  }
+  // ── notifications (events + lifecycle) ──────────────────────────────────────
+  handleNotification(method, params) {
+    if (method === "codex/event" || method.startsWith("codex/event/")) {
+      const emsg = params?.msg;
+      if (!emsg) return;
+      if (emsg.type === "task_started" && emsg.turn_id) this._turnId = String(emsg.turn_id);
+      this.opts.onEvent?.(emsg);
+      if (emsg.type === "task_complete" || emsg.type === "turn_aborted") {
+        const tid = emsg.turn_id ?? emsg.turnId ?? null;
+        if (tid) this.completedTurnIds.add(String(tid));
+        this.resolvePendingTurn(emsg.type === "turn_aborted");
+        this._turnId = null;
+      }
+      return;
+    }
+    if (method === "turn/started") {
+      const tid = params?.turn?.id ?? params?.turnId;
+      if (tid) this._turnId = String(tid);
+      return;
+    }
+    if (method === "turn/completed") {
+      const tid = params?.turn?.id ?? params?.turnId ?? null;
+      if (tid && this.completedTurnIds.has(String(tid))) return;
+      const status = params?.turn?.status ?? params?.status;
+      const aborted = typeof status === "string" && /abort|cancel|error/i.test(status);
+      this.resolvePendingTurn(aborted);
+      this._turnId = null;
+      return;
+    }
+    const normalized = normalizeNotification(method, params);
+    if (normalized) this.opts.onEvent?.(normalized);
+  }
+  resolvePendingTurn(aborted) {
+    const p = this.pendingTurn;
+    this.pendingTurn = null;
+    p?.resolve(aborted);
+  }
+}
+function mapDecisionToWire(d) {
+  switch (d) {
+    case "approved":
+      return "accept";
+    case "approved_for_session":
+      return "acceptForSession";
+    case "denied":
+      return "decline";
+    case "abort":
+      return "cancel";
+  }
+}
+
+const CODEX_PROVIDER_KEY_ENV = "SVAMP_CODEX_API_KEY";
+const PROVIDER_NAME = "svamp";
+function resolveCodexProvider(env = process.env) {
+  return {
+    apiBase: env.SVAMP_CODEX_API_BASE || env.LLM_API_BASE || void 0,
+    apiKey: env.SVAMP_CODEX_API_KEY || env.LLM_API_KEY || void 0,
+    model: env.SVAMP_CODEX_MODEL || env.LLM_MODEL || void 0
+  };
+}
+function hasCustomProvider(cfg) {
+  return !!(cfg.apiBase && cfg.apiKey);
+}
+function buildCodexProviderArgs(cfg) {
+  if (!hasCustomProvider(cfg)) {
+    return { configArgs: cfg.model ? ["-c", `model=${JSON.stringify(cfg.model)}`] : [], env: {}, model: cfg.model };
+  }
+  const configArgs = [
+    "-c",
+    `model_provider=${JSON.stringify(PROVIDER_NAME)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.name=${JSON.stringify(PROVIDER_NAME)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.base_url=${JSON.stringify(cfg.apiBase)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.env_key=${JSON.stringify(CODEX_PROVIDER_KEY_ENV)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.wire_api=${JSON.stringify("responses")}`
+  ];
+  if (cfg.model) configArgs.push("-c", `model=${JSON.stringify(cfg.model)}`);
+  return { configArgs, env: { [CODEX_PROVIDER_KEY_ENV]: cfg.apiKey }, model: cfg.model };
+}
+
+var codexProvider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CODEX_PROVIDER_KEY_ENV: CODEX_PROVIDER_KEY_ENV,
+    buildCodexProviderArgs: buildCodexProviderArgs,
+    hasCustomProvider: hasCustomProvider,
+    resolveCodexProvider: resolveCodexProvider
+});
+
+class CodexAppServerBackend {
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.log ?? (() => {
+    });
+    const provider = opts.provider ?? resolveCodexProvider();
+    const { configArgs, env: providerEnv, model: providerModel } = buildCodexProviderArgs(provider);
+    this.model = opts.model ?? providerModel;
+    this.client = new CodexAppServerClient({
+      cwd: opts.cwd,
+      env: { ...opts.env ?? {}, ...providerEnv },
+      extraArgs: configArgs,
+      log: this.log,
+      isolationConfig: opts.isolationConfig,
+      onEvent: (m) => this.handleCodexEvent(m),
+      onApproval: (r) => this.handleApproval(r),
+      onExit: (code) => this.emit({ type: "status", status: "error", detail: `codex app-server exited (code ${code})` })
+    });
+  }
+  listeners = [];
+  client;
+  sessionId = randomUUID();
+  log;
+  model;
+  started = false;
+  // Approval promises keyed by callId, resolved by respondToPermission().
+  pendingApprovals = /* @__PURE__ */ new Map();
+  // Whether we streamed any delta for the in-flight assistant message (to avoid a duplicate
+  // fullText push on the final agent_message when the model DID stream).
+  streamedThisMessage = false;
+  // Tracks the in-flight turn so waitForResponseComplete() can await it.
+  turnDone = null;
+  /** True/false if codex supports app-server; null if codex isn't installed. */
+  static available() {
+    return codexAppServerAvailable();
+  }
+  // ── AgentBackend ───────────────────────────────────────────────────────────
   async startSession(initialPrompt) {
-    const sessionId = randomUUID();
-    this.svampSessionId = sessionId;
     this.emit({ type: "status", status: "starting" });
-    await this.connect();
-    this.emit({ type: "status", status: "idle" });
-    if (initialPrompt) {
-      this.sendPrompt(sessionId, initialPrompt).catch((err) => {
-        this.log(`[Codex] Error sending initial prompt: ${err.message}`);
-        this.emit({ type: "status", status: "error", detail: err.message });
-      });
+    const avail = codexAppServerAvailable();
+    if (avail === null) throw new Error("Codex CLI not found. Install it (`npm i -g @openai/codex`) and authenticate (`svamp daemon codex-auth`).");
+    if (avail === false) throw new Error("Installed Codex is too old for app-server \u2014 upgrade to >= 0.100 (`npm i -g @openai/codex@latest`).");
+    await this.client.start();
+    if (this.opts.resumeThreadId) {
+      await this.client.resumeThread({ threadId: this.opts.resumeThreadId, model: this.model, approvalPolicy: this.opts.approvalPolicy, sandbox: this.opts.sandbox });
+    } else {
+      const r = await this.client.startThread({ model: this.model, approvalPolicy: this.opts.approvalPolicy, sandbox: this.opts.sandbox });
+      this.model = this.model ?? r.model;
     }
-    return { sessionId };
+    this.started = true;
+    this.emit({ type: "status", status: "idle" });
+    if (initialPrompt) await this.sendPrompt(this.sessionId, initialPrompt);
+    return { sessionId: this.sessionId };
   }
-  async sendPrompt(sessionId, prompt) {
-    if (!this.connected) throw new Error("Codex not connected");
-    this.turnCancelled = false;
-    const myTurnId = ++this.turnId;
+  async sendPrompt(_sessionId, prompt) {
+    if (!this.started) throw new Error("Codex session not started");
     this.emit({ type: "status", status: "running" });
-    let hadError = false;
+    this.streamedThisMessage = false;
+    let resolveTurn;
+    this.turnDone = new Promise((res) => {
+      resolveTurn = res;
+    });
     try {
-      let response;
-      if (this.codexSessionId) {
-        response = await this.continueSession(prompt);
-      } else {
-        const config = {
-          prompt,
-          cwd: this.options.cwd,
-          ...this.options.model ? { model: this.options.model } : {}
-        };
-        response = await this.startCodexSession(config);
-      }
-      if (response?.content && Array.isArray(response.content)) {
-        for (const block of response.content) {
-          if (block.type === "text" && block.text) {
-            this.emit({ type: "model-output", fullText: block.text });
-          }
-        }
-      }
+      await this.client.sendTurnAndWait(prompt, { model: this.model, approvalPolicy: this.opts.approvalPolicy, sandbox: this.opts.sandbox });
     } catch (err) {
-      hadError = true;
-      this.log(`[Codex] Error in sendPrompt: ${err.message}`);
-      this.emit({ type: "status", status: "error", detail: err.message });
-      throw err;
+      this.emit({ type: "status", status: "error", detail: err instanceof Error ? err.message : String(err) });
     } finally {
-      if (!this.turnCancelled && !hadError && this.turnId === myTurnId) {
-        this.emit({ type: "status", status: "idle" });
-      }
+      this.emit({ type: "status", status: "idle" });
+      resolveTurn();
+      this.turnDone = null;
     }
   }
   async cancel(_sessionId) {
-    this.log("[Codex] Cancel requested");
-    this.turnCancelled = true;
+    await this.client.interrupt();
     this.emit({ type: "status", status: "cancelled" });
   }
+  onMessage(handler) {
+    this.listeners.push(handler);
+  }
+  offMessage(handler) {
+    this.listeners = this.listeners.filter((h) => h !== handler);
+  }
   async respondToPermission(requestId, approved) {
-    const pending = this.pendingApprovals.get(requestId);
-    if (pending) {
+    const resolve = this.pendingApprovals.get(requestId);
+    if (resolve) {
       this.pendingApprovals.delete(requestId);
-      pending.resolve({
-        action: approved ? "accept" : "decline",
-        content: { approval: approved ? "approve" : "deny" }
-      });
-      this.emit({ type: "permission-response", id: requestId, approved });
+      resolve(approved ? "approved" : "denied");
     }
+    this.emit({ type: "permission-response", id: requestId, approved });
+  }
+  async waitForResponseComplete(timeoutMs = 14 * 24 * 60 * 60 * 1e3) {
+    if (!this.turnDone) return;
+    await Promise.race([this.turnDone, new Promise((res) => {
+      const t = setTimeout(res, timeoutMs);
+      t.unref?.();
+    })]);
   }
   async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.log("[Codex] Disposing backend");
-    for (const [, pending] of this.pendingApprovals) {
-      pending.resolve({ action: "decline" });
-    }
+    for (const [, resolve] of this.pendingApprovals) resolve("denied");
     this.pendingApprovals.clear();
-    await this.disconnect();
-    this.listeners = [];
+    await this.client.dispose();
   }
-  /** Get the transport's child process PID for tracking */
-  get pid() {
-    return this.transport?.pid ?? null;
+  /** The live Codex thread id (for the daemon to persist and resume after a restart). */
+  getThreadId() {
+    return this.client.threadId;
   }
-  /**
-   * Return a process-like object for TrackedSession.childProcess.
-   * We expose a minimal { kill } object that closes the transport.
-   */
+  /** The underlying `codex app-server` child process, for the daemon's liveness watchdog. */
   getProcess() {
-    if (!this.transport) return null;
-    const pid = this.pid;
-    return {
-      kill: (signal) => {
-        if (pid) {
-          try {
-            process.kill(pid, signal || "SIGTERM");
-          } catch {
-          }
-        }
-      }
-    };
+    return this.client.childProcess ?? void 0;
   }
-  // ── MCP connection ─────────────────────────────────────────────────
-  async connect() {
-    if (this.connected) return;
-    const mcpCommand = getCodexMcpCommand();
-    if (mcpCommand === null) {
-      throw new Error(
-        "Codex CLI not found or not executable.\n\nTo install codex:\n  npm install -g @openai/codex\n"
-      );
-    }
-    this.log(`[Codex] Connecting via: codex ${mcpCommand}`);
-    const env = {};
-    for (const key of Object.keys(process.env)) {
-      const value = process.env[key];
-      if (typeof value === "string") env[key] = value;
-    }
-    if (this.options.env) {
-      Object.assign(env, this.options.env);
-    }
-    const rolloutFilter = "codex_core::rollout::list=off";
-    const existingRustLog = env.RUST_LOG?.trim();
-    if (!existingRustLog) {
-      env.RUST_LOG = rolloutFilter;
-    } else if (!existingRustLog.includes("codex_core::rollout::list=")) {
-      env.RUST_LOG = `${existingRustLog},${rolloutFilter}`;
-    }
-    let transportCommand = "codex";
-    let transportArgs = [mcpCommand];
-    if (this.options.isolationConfig) {
-      const wrapped = wrapWithIsolation(transportCommand, transportArgs, this.options.isolationConfig);
-      transportCommand = wrapped.command;
-      transportArgs = wrapped.args;
-      if (wrapped.env) Object.assign(env, wrapped.env);
-      if (wrapped.cleanupFiles) {
-        this._isolationCleanupFiles = wrapped.cleanupFiles;
-      }
-      this.log(`[Codex] Isolation: ${this.options.isolationConfig.method}`);
-    }
-    this.transport = new StdioClientTransport({
-      command: transportCommand,
-      args: transportArgs,
-      env
-    });
-    this.registerPermissionHandlers();
-    try {
-      await this.client.connect(this.transport);
-      this.connected = true;
-      this.log("[Codex] MCP connection established");
-    } catch (err) {
-      this.transport = null;
-      throw err;
-    }
+  /** Update the model used for subsequent turns (per-turn override — no restart needed). */
+  setModel(model) {
+    this.model = model;
   }
-  async disconnect() {
-    if (!this.connected) return;
-    const pid = this.pid;
-    this.log(`[Codex] Disconnecting (pid=${pid ?? "none"})`);
-    try {
-      await this.client.close();
-    } catch {
-      try {
-        await this.transport?.close?.();
-      } catch {
-      }
-    }
-    if (pid) {
+  // ── internal ─────────────────────────────────────────────────────────────
+  emit(msg) {
+    for (const h of this.listeners) {
       try {
-        process.kill(pid, 0);
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      } catch {
+        h(msg);
+      } catch (e) {
+        this.log("[codex-backend] listener error", e);
       }
     }
-    this.transport = null;
-    this.connected = false;
-    if (this._isolationCleanupFiles.length > 0) {
-      const { rm } = await import('node:fs/promises');
-      for (const f of this._isolationCleanupFiles) rm(f, { force: true }).catch(() => {
-      });
-      this._isolationCleanupFiles = [];
-    }
   }
-  // ── Permission handling ────────────────────────────────────────────
-  registerPermissionHandlers() {
-    this.client.setRequestHandler(
-      ElicitRequestSchema,
-      async (request) => {
-        const params = request.params;
-        const callId = params.codex_call_id || randomUUID();
-        this.log(`[Codex] Elicitation request: ${params.message}`);
-        this.emit({
-          type: "permission-request",
-          id: callId,
-          reason: params.codex_command ? `Execute: ${Array.isArray(params.codex_command) ? params.codex_command.join(" ") : params.codex_command}` : params.message || "Codex requires approval",
-          payload: {
-            toolName: "CodexBash",
-            input: {
-              command: params.codex_command,
-              cwd: params.codex_cwd
-            }
-          }
-        });
-        return new Promise((resolve) => {
-          this.pendingApprovals.set(callId, { resolve });
-          setTimeout(() => {
-            if (this.pendingApprovals.has(callId)) {
-              this.pendingApprovals.delete(callId);
-              resolve({ action: "decline" });
-            }
-          }, 5 * 60 * 1e3);
-        });
-      }
-    );
+  handleApproval(req) {
+    const id = req.callId || randomUUID();
+    const reason = req.type === "exec" ? `Execute: ${(req.command ?? []).join(" ")}` : req.type === "patch" ? "Apply file changes" : req.toolName ? `Tool: ${req.toolName}` : "Codex requires approval";
+    const payload = req.type === "exec" ? { toolName: "CodexBash", input: { command: req.command, cwd: req.cwd } } : req.type === "patch" ? { toolName: "CodexPatch", input: { fileChanges: req.fileChanges } } : { toolName: req.toolName ?? "CodexTool", input: req.input };
+    this.emit({ type: "permission-request", id, reason, payload });
+    return new Promise((resolve) => {
+      this.pendingApprovals.set(id, resolve);
+      const t = setTimeout(() => {
+        if (this.pendingApprovals.delete(id)) resolve("denied");
+      }, 5 * 60 * 1e3);
+      t.unref?.();
+    });
   }
-  // ── Codex MCP tools ────────────────────────────────────────────────
-  async startCodexSession(config) {
-    const response = await this.client.callTool({
-      name: "codex",
-      arguments: config
-    }, void 0, { timeout: DEFAULT_TIMEOUT });
-    this.extractIdentifiers(response);
-    return response;
-  }
-  async continueSession(prompt) {
-    if (!this.conversationId) {
-      this.conversationId = this.codexSessionId;
-    }
-    const response = await this.client.callTool({
-      name: "codex-reply",
-      arguments: {
-        sessionId: this.codexSessionId,
-        conversationId: this.conversationId,
-        prompt
-      }
-    }, void 0, { timeout: DEFAULT_TIMEOUT });
-    this.extractIdentifiers(response);
-    return response;
-  }
-  // ── Event handling ─────────────────────────────────────────────────
   handleCodexEvent(event) {
-    if (!event || typeof event !== "object") return;
-    const eventType = event.type;
-    this.log(`[Codex] Event: ${eventType}`);
-    switch (eventType) {
+    const t = event.type;
+    switch (t) {
       case "task_started":
         this.emit({ type: "status", status: "running" });
         break;
       case "task_complete":
-        break;
       case "turn_aborted":
         break;
-      case "agent_message": {
-        const content = event.content;
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "output_text" && block.text) {
-              this.emit({ type: "model-output", fullText: block.text });
-            }
-          }
+      case "agent_message_delta": {
+        const delta = event.delta ?? (typeof event.text === "string" ? event.text : "");
+        if (delta) {
+          this.streamedThisMessage = true;
+          this.emit({ type: "model-output", textDelta: delta });
         }
         break;
       }
-      case "agent_reasoning_delta": {
-        const text = event.delta?.text || event.text;
-        if (text) {
-          this.emit({ type: "event", name: "thinking", payload: { text } });
+      case "agent_message": {
+        if (this.streamedThisMessage) {
+          this.streamedThisMessage = false;
+          break;
         }
+        const text = mapCodexEventToText(event);
+        if (text) this.emit({ type: "model-output", fullText: text });
         break;
       }
+      case "agent_reasoning_delta":
       case "agent_reasoning": {
-        const text = event.text || (Array.isArray(event.content) ? event.content.map((c) => c.text).join("") : "");
-        if (text) {
-          this.emit({ type: "event", name: "thinking", payload: { text } });
-        }
+        const text = event.delta?.text || event.text || (Array.isArray(event.content) ? event.content.map((c) => c?.text).join("") : "");
+        if (text) this.emit({ type: "event", name: "thinking", payload: { text } });
         break;
       }
       case "exec_command_begin": {
-        const callId = event.call_id || event.callId || randomUUID();
-        const command = Array.isArray(event.command) ? event.command.join(" ") : String(event.command || "");
-        this.emit({
-          type: "tool-call",
-          toolName: "CodexBash",
-          callId,
-          args: { command, cwd: event.cwd }
-        });
+        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        const command = Array.isArray(event.command) ? event.command.join(" ") : String(event.command ?? "");
+        this.emit({ type: "tool-call", toolName: "CodexBash", callId, args: { command, cwd: event.cwd } });
         break;
       }
       case "exec_command_end": {
-        const callId = event.call_id || event.callId || "";
-        this.emit({
-          type: "tool-result",
-          toolName: "CodexBash",
-          callId,
-          result: {
-            exitCode: event.exit_code ?? event.exitCode,
-            stdout: event.stdout || "",
-            stderr: event.stderr || ""
-          }
-        });
+        const callId = String(event.call_id ?? event.callId ?? "");
+        this.emit({ type: "tool-result", toolName: "CodexBash", callId, result: { exitCode: event.exit_code ?? event.exitCode, stdout: event.stdout ?? "", stderr: event.stderr ?? "" } });
         break;
       }
       case "patch_apply_begin": {
-        const callId = event.call_id || event.callId || randomUUID();
-        this.emit({
-          type: "tool-call",
-          toolName: "CodexPatch",
-          callId,
-          args: { filePath: event.file_path || event.filePath, patch: event.patch }
-        });
+        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        this.emit({ type: "tool-call", toolName: "CodexPatch", callId, args: { filePath: event.file_path ?? event.filePath, patch: event.patch } });
         break;
       }
       case "patch_apply_end": {
-        const callId = event.call_id || event.callId || "";
-        this.emit({
-          type: "tool-result",
-          toolName: "CodexPatch",
-          callId,
-          result: {
-            filePath: event.file_path || event.filePath,
-            applied: event.applied,
-            error: event.error
-          }
-        });
+        const callId = String(event.call_id ?? event.callId ?? "");
+        this.emit({ type: "tool-result", toolName: "CodexPatch", callId, result: { filePath: event.file_path ?? event.filePath, applied: event.applied, error: event.error } });
         break;
       }
-      default:
-        this.log(`[Codex] Unhandled event: ${eventType}`);
+      case "mcp_tool_call_begin": {
+        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        this.emit({ type: "tool-call", toolName: String(event.tool ?? "CodexMcpTool"), callId, args: { server: event.server, arguments: event.arguments } });
         break;
-    }
-  }
-  // ── Identifier extraction ──────────────────────────────────────────
-  updateIdentifiersFromEvent(event) {
-    if (!event || typeof event !== "object") return;
-    const candidates = [event];
-    if (event.data && typeof event.data === "object") candidates.push(event.data);
-    for (const c of candidates) {
-      const sid = c.session_id ?? c.sessionId;
-      if (sid) this.codexSessionId = sid;
-      const cid = c.conversation_id ?? c.conversationId;
-      if (cid) this.conversationId = cid;
-    }
-  }
-  extractIdentifiers(response) {
-    const meta = response?.meta || {};
-    this.codexSessionId = meta.sessionId || response?.sessionId || this.codexSessionId;
-    this.conversationId = meta.conversationId || response?.conversationId || this.conversationId;
-    const content = response?.content;
-    if (Array.isArray(content)) {
-      for (const item of content) {
-        if (!this.codexSessionId && item?.sessionId) this.codexSessionId = item.sessionId;
-        if (!this.conversationId && item?.conversationId) this.conversationId = item.conversationId;
       }
-    }
-  }
-  // ── Helpers ────────────────────────────────────────────────────────
-  emit(msg) {
-    if (this.disposed) return;
-    for (const h of this.listeners) {
-      try {
-        h(msg);
-      } catch {
+      case "mcp_tool_call_end": {
+        const callId = String(event.call_id ?? event.callId ?? "");
+        this.emit({ type: "tool-result", toolName: String(event.tool ?? "CodexMcpTool"), callId, result: { result: event.result, error: event.error } });
+        break;
+      }
+      case "token_count":
+      case "token_usage": {
+        this.emit({ type: "event", name: "usage", payload: event.usage ?? event.info ?? event });
+        break;
       }
+      case "error": {
+        const msg = event.message ?? event.error ?? "Codex error";
+        this.emit({ type: "status", status: "error", detail: String(msg) });
+        break;
+      }
+      default:
+        if (t === "_rpc/thread/tokenUsage/updated") {
+          this.emit({ type: "event", name: "usage", payload: event.params });
+        }
+        break;
     }
   }
 }
 
-var codexMcpBackend = /*#__PURE__*/Object.freeze({
+var codexAppServerBackend = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    CodexMcpBackend: CodexMcpBackend
+    CodexAppServerBackend: CodexAppServerBackend
 });
 
 const GEMINI_TIMEOUTS = {
@@ -9676,9 +9929,11 @@ class TokenCache {
       const oldest = this.cache.keys().next().value;
       if (oldest) this.cache.delete(oldest);
     }
+    const ttlExpiry = Date.now() + this.ttlMs;
+    const jwtExpMs = parseJwtExpMs(token);
     this.cache.set(token, {
       email,
-      expiresAt: Date.now() + this.ttlMs
+      expiresAt: jwtExpMs !== null ? Math.min(ttlExpiry, jwtExpMs) : ttlExpiry
     });
   }
   clear() {
@@ -9710,6 +9965,16 @@ function parseCookies(header) {
   }
   return cookies;
 }
+function parseJwtExpMs(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
+    return typeof payload.exp === "number" ? payload.exp * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
 function parseJwtEmail(token) {
   try {
     const parts = token.split(".");
@@ -9728,6 +9993,19 @@ function parseJwtEmail(token) {
     return null;
   }
 }
+function isStructurallyLiveJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return false;
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    if (payload.exp && payload.exp * 1e3 < Date.now()) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function verifyTokenViaHypha(token, hyphaServerUrl) {
   try {
     const baseUrl = hyphaServerUrl.replace(/\/$/, "");
@@ -9766,11 +10044,7 @@ class ServeAuth {
     if (!token) return null;
     const cached = this.cache.get(token);
     if (cached) return cached.email;
-    const localEmail = parseJwtEmail(token);
-    if (localEmail) {
-      this.cache.set(token, localEmail);
-      return localEmail;
-    }
+    if (!isStructurallyLiveJwt(token)) return null;
     const serverEmail = await verifyTokenViaHypha(token, this.hyphaServerUrl);
     if (serverEmail) {
       this.cache.set(token, serverEmail);
@@ -11321,7 +11595,27 @@ function escalateWorkflowFailure(projectRoot, wf, run) {
     return void 0;
   }
 }
-async function runWorkflow(projectRoot, wf, opts) {
+const inFlightRuns = /* @__PURE__ */ new Map();
+function workflowLockKey(projectRoot, name) {
+  return `${projectRoot}\0${name}`;
+}
+function runWorkflow(projectRoot, wf, opts) {
+  if (opts.allowConcurrent) return runWorkflowInner(projectRoot, wf, opts);
+  const key = workflowLockKey(projectRoot, wf.name);
+  const existing = inFlightRuns.get(key);
+  if (existing) {
+    opts.log?.(`[workflow] run coalesced "${wf.name}" in ${projectRoot} \u2014 a run of this workflow is already in flight`);
+    opts.onCoalesced?.();
+    return existing;
+  }
+  const p = runWorkflowInner(projectRoot, wf, opts);
+  inFlightRuns.set(key, p);
+  void p.finally(() => {
+    if (inFlightRuns.get(key) === p) inFlightRuns.delete(key);
+  });
+  return p;
+}
+async function runWorkflowInner(projectRoot, wf, opts) {
   const now = opts.now || (() => {
     const d = /* @__PURE__ */ new Date();
     return { iso: d.toISOString(), ms: d.getTime() };
@@ -11570,6 +11864,7 @@ function computeSoftTurnCap(hardMax, cadence) {
 const DEFAULT_LOOP_MAX_EXTENSIONS = 3;
 const DEFAULT_LOOP_EXTENSION_TURNS = 25;
 function resolveMaxExtensions(envValue) {
+  if (envValue == null || envValue.trim() === "") return DEFAULT_LOOP_MAX_EXTENSIONS;
   const n = Number(envValue);
   if (Number.isFinite(n) && n >= 0) return Math.floor(n);
   return DEFAULT_LOOP_MAX_EXTENSIONS;
@@ -11623,6 +11918,7 @@ function resolveStuckLimit(envValue) {
   return DEFAULT_LOOP_STUCK_CHECKPOINTS;
 }
 function resolveMaxAutoResumes(envValue) {
+  if (envValue == null || envValue.trim() === "") return DEFAULT_LOOP_MAX_AUTORESUMES;
   const n = Number(envValue);
   if (Number.isFinite(n) && n >= 0) return Math.floor(n);
   return DEFAULT_LOOP_MAX_AUTORESUMES;
@@ -13558,7 +13854,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-CQ89BZon.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-BSv2sDdC.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13576,7 +13872,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-IXxyfgPn.mjs');
+    const { FrpcTunnel } = await import('./frpc-k3ZLz2Mu.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13597,14 +13893,14 @@ async function startDaemon(options) {
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
   const tunnelRecreateInFlight = /* @__PURE__ */ new Set();
-  const { ServeManager } = await import('./serveManager-BszV0oIl.mjs');
+  const { ServeManager } = await import('./serveManager-BL3aySTV.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
   ensureAutoInstalledCommands(logger);
   (async () => {
     try {
-      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-DuLXaoGP.mjs');
+      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-B9O-hKxm.mjs');
       beginClaudeVersionReconcile((msg) => logger.log(msg));
     } catch (e) {
       logger.log(`[claude-version] check failed: ${e?.message || e}`);
@@ -13843,7 +14139,7 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
       }
       const sessionId = options2.sessionId || composeSessionId(generateFriendlyName(collectKnownFriendlyNames()), collectKnownSessionIds());
       const agentName = options2.agent || agentConfig.agent_type || "claude";
-      if (agentName !== "claude" && (KNOWN_ACP_AGENTS[agentName] || KNOWN_MCP_AGENTS[agentName])) {
+      if (agentName !== "claude" && (KNOWN_ACP_AGENTS[agentName] || KNOWN_CODEX_AGENTS[agentName])) {
         return await spawnAgentSession(sessionId, directory, agentName, options2, resumeSessionId);
       }
       let stagedCredentials = null;
@@ -15713,11 +16009,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D7DB3XCH.mjs');
+              const { issueRpc } = await import('./rpc-DlioTx05.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-CyACkgY1.mjs');
+              const { workflowRpc } = await import('./rpc-BXrKU30m.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16266,11 +16562,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D7DB3XCH.mjs');
+              const { issueRpc } = await import('./rpc-DlioTx05.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-CyACkgY1.mjs');
+              const { workflowRpc } = await import('./rpc-BXrKU30m.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16417,9 +16713,17 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           }
         }
         let agentBackend;
-        if (KNOWN_MCP_AGENTS[agentName]) {
-          agentBackend = new CodexMcpBackend({
+        if (KNOWN_CODEX_AGENTS[agentName]) {
+          const avail = codexAppServerAvailable();
+          if (avail === null) throw new Error("Codex CLI not found \u2014 install it (`npm i -g @openai/codex`) and authenticate (`svamp daemon codex-auth`).");
+          if (avail === false) throw new Error("Installed Codex is too old for app-server \u2014 upgrade to >= 0.100 (`npm i -g @openai/codex@latest`).");
+          const provider = resolveCodexProvider();
+          const codexModel = options2.model || agentConfig?.default_model || provider.model || void 0;
+          logger.log(`[Agent Session ${sessionId}] Codex backend: app-server (model=${codexModel ?? "default"}${provider.apiBase ? `, provider=${provider.apiBase}` : ""})`);
+          agentBackend = new CodexAppServerBackend({
             cwd: directory,
+            model: codexModel,
+            provider,
             env: options2.environmentVariables,
             log: logger.log,
             isolationConfig: agentIsoConfig
@@ -16483,6 +16787,10 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             return { ok: pending.length === 0, output: pending.length ? `${pending.length} pending: ${pending.map((i) => "#" + i.id).join(" ")}` : "No pending issues." };
           };
           try {
+            if (!ls.acp_budget_warned && ls.budget && (ls.budget.max_tokens || ls.budget.max_tokens_per_hour)) {
+              sessionService.pushMessage({ type: "message", message: "\u26A0\uFE0F A token/rate cost cap (--max-tokens / --max-tokens-per-hour) is INERT for this agent \u2014 Codex/Gemini (ACP) expose no token usage, so this loop is bounded only by --max (iterations) and --max-runtime-sec. Set one of those to cap cost.", level: "warning" }, "event");
+              ls.acp_budget_warned = true;
+            }
             const acpMaxExt = resolveMaxExtensions(process.env.SVAMP_LOOP_MAX_EXTENSIONS);
             const acpEffMax = effectiveSoftCap(ls.max_iterations, ls.extensions, acpMaxExt);
             const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: acpEffMax, ...ls.budget || {} }, now, startedAt);
@@ -16500,6 +16808,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               return;
             }
             const oracle = await runOracle();
+            if (loopCancelledDuringVerify(readLoopState(directory, sessionId))) return;
             if (!oracle.ok) {
               writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", ledger });
               dispatchAcpPrompt(`Continue toward the goal: ${ls.goal_task || ls.until || "the task"}. Not done yet \u2014 the loop oracle still reports pending work:
@@ -16521,6 +16830,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
                 log: (m) => logger.log(`[Session ${sessionId}] ${m}`)
               }
             );
+            if (loopCancelledDuringVerify(readLoopState(directory, sessionId))) return;
             if (result.action === "rekick") {
               writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", holds: holds + 1, started_at: startedAt, ledger });
               const guidance = result.guidance.replace(/\s+/g, " ").slice(0, 1200);
@@ -16700,6 +17010,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
       }
       if (!loopDir) loopDir = loadSessionIndex()[sessionId]?.directory;
       const wasInMemory = teardownTrackedSession(sessionId);
+      idleTriggerTracker.forget(sessionId);
       const markedArchived = markSessionAsArchived(sessionId);
       if (loopDir && isLoopActiveForSession(loopDir, sessionId)) {
         deactivateLoop(loopDir, sessionId);
@@ -16757,6 +17068,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
       }
       if (!loopDir) loopDir = loadSessionIndex()[sessionId]?.directory;
       teardownTrackedSession(sessionId);
+      idleTriggerTracker.forget(sessionId);
       deletePersistedSession(sessionId);
       if (loopDir && isLoopActiveForSession(loopDir, sessionId)) {
         deactivateLoop(loopDir, sessionId);
@@ -17038,7 +17350,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     }
     if (persistedSessions.length > 0) {
       try {
-        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-DuLXaoGP.mjs');
+        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-B9O-hKxm.mjs');
         await awaitClaudeVersionReady();
       } catch {
       }
@@ -17235,7 +17547,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-7wve0Fy3.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-B9WW7XGk.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -17846,4 +18158,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { downloadSkillFile as $, listRuns as A, getWorkflow as B, runWorkflow as C, setWorkflowEnabled as D, removeWorkflow as E, saveWorkflow as F, rawWorkflow as G, listWorkflows as H, isWorkflowEnabled as I, workflowCrons as J, cronMatches as K, summarize as L, workflowSteps as M, loadMachineContext as N, buildMachineInstructions as O, machineToolsForRole as P, buildMachineTools as Q, READ_ONLY_TOOLS as R, ServeAuth as S, parseFrontmatter as T, getSkillsServer as U, getSkillsWorkspaceName as V, getSkillsCollectionName as W, fetchWithTimeout as X, searchSkills as Y, SKILLS_DIR as Z, getSkillInfo as _, createSessionStore as a, listSkillFiles as a0, resolveModel as a1, formatHandle as a2, normalizeAllowedUser as a3, loadSecurityContextConfig as a4, resolveSecurityContext as a5, buildSecurityContextFromFlags as a6, mergeSecurityContexts as a7, buildSessionShareUrl as a8, computeOutboundHop as a9, registerAwaitingReply as aa, buildMachineShareUrl as ab, parseHandle as ac, handleMatchesMetadata as ad, describeMisconfiguration as ae, buildMachineDeps as af, applyClaudeProxyEnv as ag, composeSessionId as ah, generateFriendlyName as ai, generateHookSettings as aj, claudeAuth as ak, projectInfo as al, DefaultTransport$1 as am, acpBackend as an, acpAgentConfig as ao, codexMcpBackend as ap, GeminiTransport$1 as aq, instanceConfig as ar, api as as, run as at, stopDaemon as b, connectToHypha as c, daemonStatus as d, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, shortId as k, getHyphaServerUrl as l, hasCookieToken as m, resolveProjectRoot as n, getIssue as o, resumeIssue as p, pauseIssue as q, registerMachineService as r, startDaemon as s, addComment as t, updateIssue as u, addIssue as v, listIssues as w, searchIssues as x, isVisibleTo as y, getRun as z };
+export { downloadSkillFile as $, listRuns as A, getWorkflow as B, runWorkflow as C, setWorkflowEnabled as D, removeWorkflow as E, saveWorkflow as F, rawWorkflow as G, listWorkflows as H, isWorkflowEnabled as I, workflowCrons as J, cronMatches as K, summarize as L, workflowSteps as M, loadMachineContext as N, buildMachineInstructions as O, machineToolsForRole as P, buildMachineTools as Q, READ_ONLY_TOOLS as R, ServeAuth as S, parseFrontmatter as T, getSkillsServer as U, getSkillsWorkspaceName as V, getSkillsCollectionName as W, fetchWithTimeout as X, searchSkills as Y, SKILLS_DIR as Z, getSkillInfo as _, createSessionStore as a, listSkillFiles as a0, resolveModel as a1, formatHandle as a2, normalizeAllowedUser as a3, loadSecurityContextConfig as a4, resolveSecurityContext as a5, buildSecurityContextFromFlags as a6, mergeSecurityContexts as a7, buildSessionShareUrl as a8, computeOutboundHop as a9, registerAwaitingReply as aa, buildMachineShareUrl as ab, parseHandle as ac, handleMatchesMetadata as ad, describeMisconfiguration as ae, buildMachineDeps as af, applyClaudeProxyEnv as ag, composeSessionId as ah, generateFriendlyName as ai, generateHookSettings as aj, claudeAuth as ak, projectInfo as al, DefaultTransport$1 as am, acpBackend as an, acpAgentConfig as ao, codexProvider as ap, codexAppServerBackend as aq, GeminiTransport$1 as ar, instanceConfig as as, api as at, run as au, stopDaemon as b, connectToHypha as c, daemonStatus as d, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, shortId as k, getHyphaServerUrl as l, hasCookieToken as m, resolveProjectRoot as n, getIssue as o, resumeIssue as p, pauseIssue as q, registerMachineService as r, startDaemon as s, addComment as t, updateIssue as u, addIssue as v, listIssues as w, searchIssues as x, isVisibleTo as y, getRun as z };