@botiverse/raft-daemon 0.62.0 → 0.63.0

package/dist/{chunk-H3G23UPM.js → chunk-W2KSMJ4G.js}

@@ -1,6 +1,6 @@
 // src/core.ts
-import path17 from "path";
-import os8 from "os";
+import path18 from "path";
+import os9 from "os";
 import { createRequire as createRequire3 } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
@@ -1599,12 +1599,12 @@ var DISPLAY_PLAN_CONFIG = {
 var FREE_MONTHLY_FILE_UPLOAD_LIMIT_BYTES = 100 * 1024 * 1024;
 
 // src/agentProcessManager.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2, lstat, realpath, open } from "fs/promises";
 import { createHash as createHash3, randomUUID as randomUUID5 } from "crypto";
-import path13 from "path";
+import path14 from "path";
 import { gzipSync } from "zlib";
-import os6 from "os";
+import os7 from "os";
 
 // src/proxy.ts
 import { HttpsProxyAgent } from "https-proxy-agent";
@@ -1873,8 +1873,8 @@ async function executeResponseRequest(url, init, {
 }
 
 // src/directUploadCapability.ts
-function joinUrl(base, path18) {
-  return `${base.replace(/\/+$/, "")}${path18}`;
+function joinUrl(base, path19) {
+  return `${base.replace(/\/+$/, "")}${path19}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -3024,7 +3024,7 @@ function projectApmRuntimeStallDiagnostic(input) {
       gatedPhase: input.runtimeDescriptorBusyDelivery === "gated" ? input.gatedPhase : void 0,
       outstandingToolUses: input.outstandingToolUses,
       compacting: input.compacting,
-      reviewing: input.reviewing === true ? true : void 0,
+      ...input.reviewing === true ? { reviewing: true } : {},
       recentStderrCount: input.recentStderrCount,
       recentStdoutCount: input.recentStdoutCount,
       ...input.runtimeTraceCounterAttrs ?? {}
@@ -4150,6 +4150,17 @@ var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
   "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
+var WORKSPACE_CLI_TRANSPORT_FILENAMES = [
+  "agent-token",
+  "slock",
+  "slock.cmd",
+  "slock.ps1",
+  "raft",
+  "raft.cmd",
+  "raft.ps1",
+  "opencli",
+  "opencli.cmd"
+];
 function deriveCliFallbackCandidates(cliPath) {
   if (!cliPath || cliPath === "__cli") return [];
   const normalized = cliPath.split(path2.sep).join("/");
@@ -4210,6 +4221,18 @@ function resolveOpencliBinPath() {
     return null;
   }
 }
+function buildCliTransportDir(slockHome, agentId, launchId) {
+  return path2.join(slockHome, "cli-transport", safePathPart(agentId), buildCliTransportLaunchPart(launchId));
+}
+function buildCliTransportLaunchPart(launchId) {
+  return safePathPart(launchId || `pid-${process.pid}`);
+}
+function cleanupWorkspaceCliTransportFiles(workingDirectory) {
+  const legacySlockDir = path2.join(workingDirectory, ".slock");
+  for (const filename of WORKSPACE_CLI_TRANSPORT_FILENAMES) {
+    rmSync(path2.join(legacySlockDir, filename), { force: true });
+  }
+}
 function writeOpencliWrapper(slockDir, opencliBinPath, platform = process.platform) {
   const fallbacks = deriveOpencliFallbackCandidates(opencliBinPath);
   let binPath = opencliBinPath;
@@ -4340,9 +4363,10 @@ async function prepareCliTransport(ctx, extraEnv = {}, platform = process.platfo
       );
     }
   }
-  const slockDir = path2.join(ctx.workingDirectory, ".slock");
+  const slockHome = ctx.slockHome ? path2.resolve(ctx.slockHome) : resolveSlockHome();
+  cleanupWorkspaceCliTransportFiles(ctx.workingDirectory);
+  const slockDir = buildCliTransportDir(slockHome, ctx.agentId, ctx.launchId);
   mkdirSync(slockDir, { recursive: true });
-  const slockHome = resolveSlockHome();
   const tokenFile = path2.join(slockDir, "agent-token");
   const agentCredentialKey = ctx.config.agentCredentialKey;
   let agentCredentialProxy = null;
@@ -4357,7 +4381,7 @@ async function prepareCliTransport(ctx, extraEnv = {}, platform = process.platfo
       activeCapabilities: DEFAULT_ACTIVE_CAPABILITIES,
       inboxCoordinator: ctx.agentCredentialProxyInboxCoordinator
     });
-    const launchPart = safePathPart(ctx.launchId || `pid-${process.pid}`);
+    const launchPart = buildCliTransportLaunchPart(ctx.launchId);
     const proxyTokenDir = path2.join(slockHome, "agent-proxy-tokens", safePathPart(ctx.agentId));
     mkdirSync(proxyTokenDir, { recursive: true, mode: 448 });
     agentCredentialProxyTokenFile = path2.join(proxyTokenDir, `${launchPart}.token`);
@@ -4474,7 +4498,6 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     ...ctx.launchId ? { SLOCK_AGENT_LAUNCH_ID: ctx.launchId } : {},
     ...ctx.cliTransportTraceDir ? { [CLI_TRANSPORT_TRACE_DIR_ENV]: ctx.cliTransportTraceDir } : {},
     SLOCK_SERVER_URL: ctx.config.serverUrl,
-    ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
   delete spawnEnv.SLOCK_AGENT_TOKEN;
@@ -4485,9 +4508,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
   delete spawnEnv.SLOCK_AGENT_PROXY_TOKEN;
   delete spawnEnv.SLOCK_AGENT_PROXY_TOKEN_FILE;
   delete spawnEnv.SLOCK_AGENT_ACTIVE_CAPABILITIES;
-  if (agentCredentialProxy) {
-    delete spawnEnv.SLOCK_AGENT_TOKEN_FILE;
-  }
+  delete spawnEnv.SLOCK_AGENT_TOKEN_FILE;
   return {
     slockDir,
     tokenFile,
@@ -5177,8 +5198,77 @@ var ClaudeDriver = class {
 // src/drivers/codex.ts
 import { spawn as spawn2, execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import os4 from "os";
+import path7 from "path";
+
+// src/drivers/codexHome.ts
 import os3 from "os";
+import { mkdirSync as mkdirSync3 } from "fs";
 import path6 from "path";
+function readConfiguredCodexHome(env) {
+  const raw = env.CODEX_HOME;
+  return typeof raw === "string" && raw.trim().length > 0 ? raw : null;
+}
+function readNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function safeCodexHomePathPart(value) {
+  const safe = value.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return safe.length > 0 ? safe : "agent";
+}
+function resolveSlockManagedCodexHome(slockHome, agentId) {
+  return path6.join(path6.resolve(slockHome), "codex-home", safeCodexHomePathPart(agentId));
+}
+function resolveDefaultCodexHomeRootForAgent(agentId, opts = {}) {
+  return resolveSlockManagedCodexHome(readNonEmpty(opts.slockHome) ?? resolveSlockHome(opts.env), agentId);
+}
+function applyDefaultCodexHomeToEnv(env, agentId, opts = {}) {
+  if (readConfiguredCodexHome(env)) return null;
+  const codexHome = resolveDefaultCodexHomeRootForAgent(agentId, {
+    slockHome: readNonEmpty(opts.slockHome) ?? readNonEmpty(env.SLOCK_HOME) ?? void 0,
+    env
+  });
+  mkdirSync3(codexHome, { recursive: true });
+  env.CODEX_HOME = codexHome;
+  return codexHome;
+}
+function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
+  const raw = readConfiguredCodexHome(env);
+  if (raw) {
+    return path6.resolve(opts.cwd ?? process.cwd(), raw);
+  }
+  return path6.join(opts.defaultHomeDir ?? os3.homedir(), ".codex");
+}
+function hasConfiguredCodexHome(config, baseEnv = process.env) {
+  const launchRuntimeFields = config ? runtimeConfigToLaunchFields(config) : null;
+  return Boolean(readConfiguredCodexHome({
+    ...baseEnv,
+    ...launchRuntimeFields?.envVars || {}
+  }));
+}
+function resolveCodexHomeRootFromConfig(config, defaultHomeDir, cwd, baseEnv = process.env, opts = {}) {
+  const launchRuntimeFields = runtimeConfigToLaunchFields(config);
+  const env = {
+    ...baseEnv,
+    ...launchRuntimeFields.envVars || {}
+  };
+  if (readConfiguredCodexHome(env)) {
+    return resolveCodexHomeRootFromEnv(env, { defaultHomeDir, cwd });
+  }
+  if (opts.agentId) {
+    return resolveDefaultCodexHomeRootForAgent(opts.agentId, { slockHome: opts.slockHome, env });
+  }
+  return resolveCodexHomeRootFromEnv(env, { defaultHomeDir, cwd });
+}
+function codexStateRootCandidates(homeDirOrCodexRoot) {
+  return [
+    homeDirOrCodexRoot,
+    path6.join(homeDirOrCodexRoot, ".codex")
+  ];
+}
+function codexSessionRootCandidates(homeDirOrCodexRoot) {
+  return codexStateRootCandidates(homeDirOrCodexRoot).map((root) => path6.join(root, "sessions"));
+}
 
 // src/runtimeTurnState.ts
 var RuntimeTurnState = class {
@@ -5359,7 +5449,7 @@ function codexNotificationDiagnosticEvent(message) {
       return null;
   }
   const sessionId = codexMessageThreadId(message);
-  const path18 = boundedString(params.path);
+  const path19 = boundedString(params.path);
   return {
     kind: "runtime_diagnostic",
     severity: "warning",
@@ -5367,12 +5457,42 @@ function codexNotificationDiagnosticEvent(message) {
     itemType: message.method,
     message: diagnosticMessage,
     ...details ? { details } : {},
-    ...path18 ? { path: path18 } : {},
+    ...path19 ? { path: path19 } : {},
     ...params.range !== void 0 ? { range: params.range } : {},
     payloadBytes: payloadBytes(params),
     ...sessionId ? { sessionId } : {}
   };
 }
+function codexThreadStatusChangedEvent(message) {
+  if (message.method !== "thread/status/changed") return null;
+  const params = message.params ?? {};
+  const status = params.status ?? params.thread?.status;
+  if (!status || typeof status !== "object") return null;
+  const statusType = nonEmptyString2(status.type);
+  const sessionId = codexMessageThreadId(message);
+  if (statusType === "systemError") {
+    const statusMessage = boundedString(status.message) ?? boundedString(status.error?.message) ?? getCodexNotificationErrorMessage(params) ?? "Codex thread entered system error state";
+    return {
+      kind: "error",
+      message: statusMessage
+    };
+  }
+  if (statusType !== "active" || !Array.isArray(status.activeFlags)) return null;
+  const activeFlags = status.activeFlags.filter((flag) => typeof flag === "string");
+  const waitFlags = activeFlags.filter((flag) => flag === "waitingOnApproval" || flag === "waitingOnUserInput");
+  if (waitFlags.length === 0) return null;
+  const waitLabel = waitFlags.includes("waitingOnApproval") && waitFlags.includes("waitingOnUserInput") ? "approval and user input" : waitFlags.includes("waitingOnApproval") ? "approval" : "user input";
+  return {
+    kind: "runtime_diagnostic",
+    severity: "warning",
+    source: "codex_app_server_notification",
+    itemType: "thread/status/changed",
+    message: `Codex thread is waiting on ${waitLabel}`,
+    details: `Active flags: ${waitFlags.join(", ")}`,
+    payloadBytes: payloadBytes(params),
+    ...sessionId ? { sessionId } : {}
+  };
+}
 function joinReasoningSummaryText(item) {
   const summary = Array.isArray(item.summary) ? item.summary.filter((entry) => typeof entry === "string") : [];
   return summary.join("\n").trim();
@@ -5400,10 +5520,27 @@ function codexMcpToolName(item) {
 function codexMessageThreadId(message) {
   return nonEmptyString2(message.params?.threadId) ?? nonEmptyString2(message.params?.thread?.id) ?? nonEmptyString2(message.params?.sessionId);
 }
+function codexAgentMessagePhase(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function codexAgentMessageDeltaPhase(message) {
+  return codexAgentMessagePhase(message.params?.phase) ?? codexAgentMessagePhase(message.params?.item?.phase);
+}
+function isUserVisibleAgentMessagePhase(phase) {
+  return phase === null || phase === "final_answer";
+}
+function codexSuppressedAgentMessageEvent(itemType, phase, text, itemId) {
+  return codexNotificationProgressEvent(itemType, {
+    ...typeof itemId === "string" ? { itemId } : {},
+    ...phase ? { phase } : {},
+    bytes: Buffer.byteLength(text, "utf8")
+  });
+}
 var CodexEventNormalizer = class {
   currentThreadId = null;
   sessionAnnounced = false;
   streamedAgentMessageIds = /* @__PURE__ */ new Set();
+  agentMessagePhases = /* @__PURE__ */ new Map();
   streamedReasoningIds = /* @__PURE__ */ new Set();
   fileChangeToolCallCounts = /* @__PURE__ */ new Map();
   turnState = new RuntimeTurnState();
@@ -5412,6 +5549,7 @@ var CodexEventNormalizer = class {
     this.turnState.reset();
     this.sessionAnnounced = false;
     this.streamedAgentMessageIds.clear();
+    this.agentMessagePhases.clear();
     this.streamedReasoningIds.clear();
     this.fileChangeToolCallCounts.clear();
   }
@@ -5489,12 +5627,17 @@ var CodexEventNormalizer = class {
       case "item/agentMessage/delta": {
         const delta = message.params?.delta;
         const itemId = message.params?.itemId;
+        const phase = codexAgentMessageDeltaPhase(message) ?? (typeof itemId === "string" ? this.agentMessagePhases.get(itemId) ?? null : null);
         if (typeof itemId === "string") {
           this.streamedAgentMessageIds.add(itemId);
         }
         if (typeof delta === "string" && delta.length > 0) {
           this.turnState.markProgress();
-          events.push({ kind: "text", text: delta });
+          if (isUserVisibleAgentMessagePhase(phase)) {
+            events.push({ kind: "text", text: delta });
+          } else {
+            events.push(codexSuppressedAgentMessageEvent("agent_message_non_final_delta", phase, delta, itemId));
+          }
         }
         break;
       }
@@ -5545,6 +5688,13 @@ var CodexEventNormalizer = class {
         }
         break;
       }
+      case "thread/status/changed": {
+        const event = codexThreadStatusChangedEvent(message);
+        if (event) {
+          events.push(event);
+        }
+        break;
+      }
       case "item/started":
       case "item/completed": {
         const item = message.params?.item;
@@ -5566,12 +5716,21 @@ var CodexEventNormalizer = class {
             }
             break;
           case "agentMessage":
+            if ((isStarted || isCompleted) && typeof item.id === "string") {
+              this.agentMessagePhases.set(item.id, codexAgentMessagePhase(item.phase));
+            }
             if (isCompleted && typeof item.id === "string" && !this.streamedAgentMessageIds.has(item.id) && typeof item.text === "string" && item.text.length > 0) {
+              const phase = codexAgentMessagePhase(item.phase);
               this.turnState.markProgress();
-              events.push({ kind: "text", text: item.text });
+              if (isUserVisibleAgentMessagePhase(phase)) {
+                events.push({ kind: "text", text: item.text });
+              } else {
+                events.push(codexSuppressedAgentMessageEvent("agent_message_non_final_completed", phase, item.text, item.id));
+              }
             }
             if (isCompleted && typeof item.id === "string") {
               this.streamedAgentMessageIds.delete(item.id);
+              this.agentMessagePhases.delete(item.id);
             }
             break;
           case "commandExecution":
@@ -5710,14 +5869,15 @@ var CodexEventNormalizer = class {
 
 // src/drivers/codex.ts
 var CODEX_DESKTOP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
+var CODEX_APP_SERVER_PROBE_ARGS = ["app-server", "--help"];
 function isWindowsSandboxRunner(commandPath) {
-  return path6.basename(commandPath).toLowerCase().startsWith("codex-command-runner");
+  return path7.basename(commandPath).toLowerCase().startsWith("codex-command-runner");
 }
 function resolveWindowsNpmCodexEntry(deps = {}) {
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync2;
   const env = deps.env ?? process.env;
-  const winPath = path6.win32;
+  const winPath = path7.win32;
   try {
     const globalRoot = String(execFileSyncFn("npm", ["root", "-g"], {
       encoding: "utf8",
@@ -5739,7 +5899,7 @@ function resolveWindowsCodexDesktopEntry(deps = {}) {
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
   const env = deps.env ?? process.env;
   const homeDir = deps.homeDir;
-  const winPath = path6.win32;
+  const winPath = path7.win32;
   const candidates = [
     env.LOCALAPPDATA ? winPath.join(env.LOCALAPPDATA, "OpenAI", "Codex", "bin", "codex.exe") : null,
     env.USERPROFILE ? winPath.join(env.USERPROFILE, "AppData", "Local", "OpenAI", "Codex", "bin", "codex.exe") : null,
@@ -5750,69 +5910,158 @@ function resolveWindowsCodexDesktopEntry(deps = {}) {
   }
   return null;
 }
-function resolveCodexCommand(deps = {}) {
+function codexSpawnCandidates(deps = {}) {
   const platform = deps.platform ?? process.platform;
   if (platform === "win32") {
+    const candidates2 = [];
     const npmEntry = resolveWindowsNpmCodexEntry(deps);
-    if (npmEntry) return npmEntry;
+    if (npmEntry) {
+      candidates2.push({
+        source: "npm_global",
+        command: process.execPath,
+        argsPrefix: [npmEntry],
+        shell: false
+      });
+    }
     const command = resolveCommandOnPath("codex", deps);
-    if (command && !isWindowsSandboxRunner(command)) return command;
-    return resolveWindowsCodexDesktopEntry(deps);
+    if (command && !isWindowsSandboxRunner(command)) {
+      candidates2.push({
+        source: "path",
+        command,
+        argsPrefix: [],
+        shell: requiresWindowsShell(command, platform)
+      });
+    }
+    const desktopEntry = resolveWindowsCodexDesktopEntry(deps);
+    if (desktopEntry && !candidates2.some((candidate) => candidate.command === desktopEntry)) {
+      candidates2.push({
+        source: "desktop_install",
+        command: desktopEntry,
+        argsPrefix: [],
+        shell: false
+      });
+    }
+    return candidates2;
   }
+  const candidates = [];
   const pathCommand = resolveCommandOnPath("codex", deps);
-  if (pathCommand) return pathCommand;
+  if (pathCommand) {
+    candidates.push({
+      source: "path",
+      command: pathCommand,
+      argsPrefix: [],
+      shell: false
+    });
+  }
   if (platform === "darwin") {
-    return firstExistingPath([CODEX_DESKTOP_BUNDLE_PATH], deps);
+    const bundleCommand = firstExistingPath([CODEX_DESKTOP_BUNDLE_PATH], deps);
+    if (bundleCommand && !candidates.some((candidate) => candidate.command === bundleCommand)) {
+      candidates.push({
+        source: "desktop_bundle",
+        command: bundleCommand,
+        argsPrefix: [],
+        shell: false
+      });
+    }
   }
-  return null;
+  return candidates;
+}
+function formatCodexCandidate(candidate) {
+  return [candidate.command, ...candidate.argsPrefix].join(" ");
+}
+function describeCodexProbeFailure(error) {
+  if (error && typeof error === "object") {
+    const candidate = error;
+    if (typeof candidate.status === "number") return `exit status ${candidate.status}`;
+    if (typeof candidate.signal === "string") return `terminated by ${candidate.signal}`;
+    if (typeof candidate.code === "string") return candidate.code;
+  }
+  return "probe failed";
+}
+function validateCodexAppServer(candidate, deps = {}) {
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync2;
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  try {
+    execFileSyncFn(candidate.command, [...candidate.argsPrefix, ...CODEX_APP_SERVER_PROBE_ARGS], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 5e3,
+      shell: candidate.shell
+    });
+    return null;
+  } catch (error) {
+    return describeCodexProbeFailure(error);
+  }
+}
+function readCodexCandidateVersion(candidate, deps = {}) {
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync2;
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  try {
+    const output = execFileSyncFn(candidate.command, [...candidate.argsPrefix, "--version"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 5e3,
+      shell: candidate.shell
+    });
+    return (Buffer.isBuffer(output) ? output.toString("utf8") : String(output ?? "")).trim().split(/\r?\n/)[0] || null;
+  } catch {
+    return null;
+  }
+}
+function resolveCompatibleCodexCandidate(deps = {}) {
+  const rejected = [];
+  for (const candidate of codexSpawnCandidates(deps)) {
+    const failure = validateCodexAppServer(candidate, deps);
+    if (!failure) return { candidate, rejected };
+    rejected.push(`${candidate.source} ${formatCodexCandidate(candidate)} rejected: app-server probe ${failure}`);
+  }
+  return { candidate: null, rejected };
 }
 function probeCodex(deps = {}) {
-  if ((deps.platform ?? process.platform) === "win32") {
-    try {
-      const resolved = resolveCodexSpawn([], deps);
-      return {
-        available: true,
-        version: readCommandVersion(resolved.command, resolved.args, deps) ?? void 0
-      };
-    } catch {
-      return { available: false };
-    }
+  const { candidate, rejected } = resolveCompatibleCodexCandidate(deps);
+  const diagnostic = rejected.length > 0 ? rejected.join("; ") : void 0;
+  if (!candidate) {
+    return {
+      available: false,
+      diagnostic: diagnostic ?? "No Codex CLI app-server candidate was found."
+    };
   }
-  const command = resolveCodexCommand(deps);
-  if (!command) return { available: false };
   return {
     available: true,
-    version: readCommandVersion(command, [], deps) ?? void 0
+    version: readCodexCandidateVersion(candidate, deps) ?? void 0,
+    ...diagnostic ? { diagnostic } : {}
   };
 }
 function resolveCodexSpawn(commandArgs, deps = {}) {
-  if ((deps.platform ?? process.platform) !== "win32") {
-    return { command: resolveCodexCommand(deps) ?? "codex", args: commandArgs, shell: false };
+  const { candidate, rejected } = resolveCompatibleCodexCandidate(deps);
+  if (candidate) {
+    return { command: candidate.command, args: [...candidate.argsPrefix, ...commandArgs], shell: candidate.shell };
   }
-  const codexEntry = resolveWindowsNpmCodexEntry(deps);
-  if (codexEntry) {
-    return {
-      command: process.execPath,
-      args: [codexEntry, ...commandArgs],
-      shell: false
-    };
-  }
-  const command = resolveCommandOnPath("codex", deps);
-  if (command && !isWindowsSandboxRunner(command)) {
-    return { command, args: commandArgs, shell: requiresWindowsShell(command, deps.platform) };
-  }
-  const desktopEntry = resolveWindowsCodexDesktopEntry(deps);
-  if (desktopEntry) {
-    return { command: desktopEntry, args: commandArgs, shell: false };
+  const diagnostic = rejected.length > 0 ? ` Rejected candidates: ${rejected.join("; ")}.` : "";
+  if ((deps.platform ?? process.platform) === "win32") {
+    throw new Error(
+      "Cannot resolve a compatible Codex CLI app-server entry point on Windows. Install Codex Desktop or install @openai/codex globally via npm (npm i -g @openai/codex). Ignoring .codex/.sandbox-bin/codex-command-runner because it is a sandbox helper, not the Codex CLI." + diagnostic
+    );
   }
-  throw new Error(
-    "Cannot resolve Codex CLI entry point on Windows. Install Codex Desktop or install @openai/codex globally via npm (npm i -g @openai/codex). Ignoring .codex/.sandbox-bin/codex-command-runner because it is a sandbox helper, not the Codex CLI."
-  );
+  throw new Error(`Cannot resolve a compatible Codex CLI app-server entry point.${diagnostic}`);
 }
 function isCodexMissingRolloutError(message) {
   return /\bno\s+rollout\s+found\b/i.test(message) || /\bmissing\s+rollout\b/i.test(message) || /\brollout\b.*\b(not found|missing)\b/i.test(message) || /\bthread\b.*\b(not found|missing)\b/i.test(message) || /\bmissing\s+thread\b/i.test(message);
 }
-function classifyCodexResumeError(message) {
+function codexMissingRolloutRecoveryMessage() {
+  return "Codex could not resume its previous thread; Slock started a fresh Codex thread.";
+}
+function codexMissingRolloutRecoveryDetails() {
+  return "Use Slock conversation history and local MEMORY.md/notes as the recovery point; do not assume prior Codex thread context is loaded.";
+}
+function prependCodexRecoveryNotice(prompt, recovery) {
+  return `${recovery.message}
+
+${recovery.details}
+
+${prompt}`;
+}
+function classifyCodexResumeError(message, requestedSessionId) {
   if (isCodexMissingRolloutError(message)) {
     return {
       kind: "missing_rollout",
@@ -5826,6 +6075,15 @@ function classifyCodexResumeError(message) {
           resume_error_class: "missing_rollout",
           recovery_action: "fallback_fresh_thread"
         }
+      },
+      recovery: {
+        kind: "runtime_recovery",
+        source: "codex_resume_missing_rollout",
+        resumeErrorClass: "missing_rollout",
+        recoveryAction: "fallback_fresh_thread",
+        message: codexMissingRolloutRecoveryMessage(),
+        details: codexMissingRolloutRecoveryDetails(),
+        ...requestedSessionId ? { requestedSessionId } : {}
       }
     };
   }
@@ -5849,6 +6107,26 @@ function isJsonRpcResponse(message) {
 function isCodexServerRequest(message) {
   return message.id !== void 0 && typeof message.method === "string" && !isJsonRpcResponse(message);
 }
+function payloadBytes2(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function extractCodexHome(result) {
+  if (!result || typeof result !== "object") return null;
+  const candidate = result.codexHome;
+  return typeof candidate === "string" && candidate.trim().length > 0 ? candidate : null;
+}
+function isCompatibleInitializeResult(result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return false;
+  const userAgent = result.userAgent;
+  return typeof userAgent === "string" && userAgent.trim().length > 0;
+}
+function unsupportedInitializeResultMessage() {
+  return "Codex app-server initialize response is missing the expected userAgent handshake field; upgrade Codex CLI to a compatible app-server build.";
+}
 var CodexDriver = class {
   id = "codex";
   lifecycle = {
@@ -5919,11 +6197,19 @@ var CodexDriver = class {
   pendingThreadRequestId = null;
   pendingThreadRequestMethod = null;
   pendingResumeFallbackParams = null;
+  pendingResumeThreadId = null;
   pendingInitialTurnRequestId = null;
+  pendingDeliveryRequests = /* @__PURE__ */ new Map();
   initialTurnStarted = false;
   normalizer = new CodexEventNormalizer();
+  codexHomeRoot = null;
+  spawnWorkingDirectory = null;
+  get currentRuntimeHomeDir() {
+    return this.codexHomeRoot;
+  }
   async spawn(ctx) {
     const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+    applyDefaultCodexHomeToEnv(spawnEnv, ctx.agentId, { slockHome: ctx.slockHome });
     this.process = null;
     this.requestId = 0;
     this.pendingInitialPrompt = ctx.prompt;
@@ -5932,9 +6218,16 @@ var CodexDriver = class {
     this.pendingThreadRequestId = null;
     this.pendingThreadRequestMethod = null;
     this.pendingResumeFallbackParams = null;
+    this.pendingResumeThreadId = null;
     this.pendingInitialTurnRequestId = null;
+    this.pendingDeliveryRequests.clear();
     this.initialTurnStarted = false;
     this.normalizer.reset();
+    this.spawnWorkingDirectory = ctx.workingDirectory;
+    this.codexHomeRoot = resolveCodexHomeRootFromEnv(spawnEnv, {
+      defaultHomeDir: os4.homedir(),
+      cwd: ctx.workingDirectory
+    });
     const args = ["app-server", "--listen", "stdio://"];
     const { command, args: spawnArgs, shell } = resolveCodexSpawn(args);
     const proc = spawn2(command, spawnArgs, {
@@ -5969,6 +6262,24 @@ var CodexDriver = class {
     const isResponse = isJsonRpcResponse(message);
     if (isResponse && hasJsonRpcField(message, "result")) {
       if (message.id === this.initializeRequestId) {
+        if (!isCompatibleInitializeResult(message.result)) {
+          this.initializeRequestId = null;
+          this.pendingThreadRequest = null;
+          this.pendingThreadRequestId = null;
+          this.pendingThreadRequestMethod = null;
+          this.pendingResumeFallbackParams = null;
+          this.pendingResumeThreadId = null;
+          events.push({
+            kind: "error",
+            message: unsupportedInitializeResultMessage(),
+            startupRequestMethod: "initialize"
+          });
+          return events;
+        }
+        const codexHome = extractCodexHome(message.result);
+        if (codexHome) {
+          this.codexHomeRoot = path7.resolve(this.spawnWorkingDirectory ?? process.cwd(), codexHome);
+        }
         this.initializeRequestId = null;
         this.sendNotification("initialized", {});
         if (this.pendingThreadRequest) {
@@ -5984,6 +6295,7 @@ var CodexDriver = class {
       this.pendingThreadRequestId = null;
       this.pendingThreadRequestMethod = null;
       this.pendingResumeFallbackParams = null;
+      this.pendingResumeThreadId = null;
       events.push({
         kind: "error",
         message: message.error?.message || "Codex app-server request failed",
@@ -5995,9 +6307,16 @@ var CodexDriver = class {
       if (hasJsonRpcField(message, "error")) {
         const errorMessage = message.error?.message || "Codex app-server request failed";
         const requestMethod = this.pendingThreadRequestMethod;
-        const resumeErrorClassification = requestMethod === "thread/resume" ? classifyCodexResumeError(errorMessage) : null;
+        const resumeErrorClassification = requestMethod === "thread/resume" ? classifyCodexResumeError(errorMessage, this.pendingResumeThreadId || void 0) : null;
         if (this.pendingResumeFallbackParams && resumeErrorClassification?.kind === "missing_rollout") {
           events.push(resumeErrorClassification.telemetry);
+          events.push(resumeErrorClassification.recovery);
+          if (this.pendingInitialPrompt) {
+            this.pendingInitialPrompt = prependCodexRecoveryNotice(
+              this.pendingInitialPrompt,
+              resumeErrorClassification.recovery
+            );
+          }
           this.sendThreadRequest("thread/start", this.pendingResumeFallbackParams);
           this.pendingResumeFallbackParams = null;
           return events;
@@ -6005,12 +6324,14 @@ var CodexDriver = class {
         this.pendingThreadRequestId = null;
         this.pendingThreadRequestMethod = null;
         this.pendingResumeFallbackParams = null;
+        this.pendingResumeThreadId = null;
         events.push(requestMethod ? { kind: "error", message: errorMessage, startupRequestMethod: requestMethod } : { kind: "error", message: errorMessage });
         return events;
       }
       this.pendingThreadRequestId = null;
       this.pendingThreadRequestMethod = null;
       this.pendingResumeFallbackParams = null;
+      this.pendingResumeThreadId = null;
     }
     if (isResponse && message.id === this.pendingInitialTurnRequestId) {
       this.pendingInitialTurnRequestId = null;
@@ -6025,6 +6346,21 @@ var CodexDriver = class {
       }
       return events;
     }
+    if (isResponse && message.id !== void 0 && this.pendingDeliveryRequests.has(message.id)) {
+      const requestMethod = this.pendingDeliveryRequests.get(message.id);
+      this.pendingDeliveryRequests.delete(message.id);
+      if (hasJsonRpcField(message, "error")) {
+        const params = message.error ?? {};
+        events.push({
+          kind: "delivery_error",
+          message: message.error?.message || "Codex app-server request failed",
+          requestMethod,
+          source: "codex_app_server_response",
+          payloadBytes: payloadBytes2(params)
+        });
+      }
+      return events;
+    }
     const result = this.normalizer.normalizeMessage(message);
     if (result.turnStarted) {
       this.pendingInitialTurnRequestId = null;
@@ -6043,9 +6379,11 @@ var CodexDriver = class {
     const mode = opts?.mode || "busy";
     if (mode === "busy") {
       if (!this.normalizer.canSteerBusy) return null;
+      const id2 = this.nextRequestId();
+      this.pendingDeliveryRequests.set(id2, "turn/steer");
       return JSON.stringify({
         jsonrpc: "2.0",
-        id: this.nextRequestId(),
+        id: id2,
         method: "turn/steer",
         params: {
           threadId: this.normalizer.threadId,
@@ -6054,9 +6392,11 @@ var CodexDriver = class {
         }
       });
     }
+    const id = this.nextRequestId();
+    this.pendingDeliveryRequests.set(id, "turn/start");
     return JSON.stringify({
       jsonrpc: "2.0",
-      id: this.nextRequestId(),
+      id,
       method: "turn/start",
       params: {
         threadId: this.normalizer.threadId,
@@ -6112,9 +6452,11 @@ var CodexDriver = class {
     this.pendingThreadRequestId = id;
     this.pendingThreadRequestMethod = method;
     this.pendingResumeFallbackParams = null;
+    this.pendingResumeThreadId = null;
     if (method === "thread/resume") {
       const { threadId: _threadId, ...freshParams } = params;
       this.pendingResumeFallbackParams = freshParams;
+      this.pendingResumeThreadId = typeof _threadId === "string" && _threadId.trim() ? _threadId.trim() : null;
     }
     return id;
   }
@@ -6126,12 +6468,194 @@ var CodexDriver = class {
     }) + "\n");
   }
   async detectModels() {
-    return detectCodexModels();
+    return await detectCodexModelsFromAppServer() ?? detectCodexModels(resolveCodexHomeRootFromEnv());
   }
 };
-function detectCodexModels(home = os3.homedir()) {
-  const cachePath = path6.join(home, ".codex", "models_cache.json");
-  const configPath = path6.join(home, ".codex", "config.toml");
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function modelListPage(result) {
+  if (!result || typeof result !== "object") return null;
+  const object = result;
+  const entries = Array.isArray(object.data) ? object.data : Array.isArray(object.models) ? object.models : null;
+  if (!entries) return null;
+  return {
+    entries,
+    nextCursor: asNonEmptyString(object.nextCursor)
+  };
+}
+function modelListRequestParams(cursor) {
+  return cursor ? { cursor } : {};
+}
+function stringArray(values, read) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const item = read(value);
+    if (!item || seen.has(item)) continue;
+    seen.add(item);
+    result.push(item);
+  }
+  return result;
+}
+function codexReasoningEfforts(value) {
+  if (!Array.isArray(value)) return [];
+  return stringArray(value, (entry) => {
+    if (typeof entry === "string") return asNonEmptyString(entry);
+    if (!entry || typeof entry !== "object") return null;
+    const object = entry;
+    return asNonEmptyString(object.reasoningEffort) ?? asNonEmptyString(object.id);
+  });
+}
+function codexServiceTierIds(value) {
+  if (!Array.isArray(value)) return [];
+  return stringArray(value, (entry) => {
+    if (typeof entry === "string") return asNonEmptyString(entry);
+    if (!entry || typeof entry !== "object") return null;
+    const object = entry;
+    return asNonEmptyString(object.id) ?? asNonEmptyString(object.serviceTier);
+  });
+}
+function codexModelInfoFromAppServer(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+  const object = entry;
+  if (object.hidden === true) return null;
+  const id = asNonEmptyString(object.id) ?? asNonEmptyString(object.model) ?? asNonEmptyString(object.slug);
+  if (!id) return null;
+  const label = asNonEmptyString(object.displayName) ?? asNonEmptyString(object.display_name) ?? asNonEmptyString(object.label) ?? id;
+  const supportedReasoningEfforts = codexReasoningEfforts(object.supportedReasoningEfforts);
+  const serviceTiers = codexServiceTierIds(object.serviceTiers);
+  const additionalSpeedTiers = codexServiceTierIds(object.additionalSpeedTiers);
+  const runtimeServiceTiers = serviceTiers.length > 0 ? serviceTiers : additionalSpeedTiers;
+  const defaultReasoningEffort = asNonEmptyString(object.defaultReasoningEffort);
+  const defaultServiceTier = asNonEmptyString(object.defaultServiceTier);
+  return {
+    id,
+    label,
+    verified: "launchable",
+    ...supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts } : {},
+    ...defaultReasoningEffort ? { defaultReasoningEffort } : {},
+    ...runtimeServiceTiers.length > 0 ? { serviceTiers: runtimeServiceTiers } : {},
+    ...defaultServiceTier ? { defaultServiceTier } : {}
+  };
+}
+function codexModelSetFromAppServerEntries(entries) {
+  const models = [];
+  let defaultModel;
+  for (const entry of entries) {
+    const model = codexModelInfoFromAppServer(entry);
+    if (!model) continue;
+    models.push(model);
+    if (!defaultModel && typeof entry === "object" && entry && entry.isDefault === true) {
+      defaultModel = model.id;
+    }
+  }
+  return models.length > 0 ? { models, default: defaultModel } : null;
+}
+async function detectCodexModelsFromAppServer(options = {}) {
+  const env = options.env ?? process.env;
+  let launch;
+  try {
+    launch = resolveCodexSpawn(["app-server", "--listen", "stdio://"], { env });
+  } catch {
+    return null;
+  }
+  return await new Promise((resolve) => {
+    const timeoutMs = options.timeoutMs ?? 5e3;
+    const proc = spawn2(launch.command, launch.args, {
+      cwd: options.cwd ?? process.cwd(),
+      stdio: ["pipe", "pipe", "ignore"],
+      env,
+      shell: launch.shell
+    });
+    let settled = false;
+    let buffer = "";
+    let requestId = 0;
+    let initializeRequestId = null;
+    let modelListRequestId = null;
+    let pageCount = 0;
+    const entries = [];
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      proc.kill();
+      resolve(result);
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const sendRequest = (method, params) => {
+      requestId += 1;
+      const id = requestId;
+      proc.stdin?.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+      return id;
+    };
+    const sendNotification = (method, params) => {
+      proc.stdin?.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+    };
+    const requestModelPage = (cursor) => {
+      pageCount += 1;
+      modelListRequestId = sendRequest("model/list", modelListRequestParams(cursor));
+    };
+    proc.once("error", () => finish(null));
+    proc.once("exit", () => finish(null));
+    proc.stdout?.on("data", (chunk) => {
+      if (settled) return;
+      buffer += chunk.toString();
+      for (; ; ) {
+        const newline = buffer.indexOf("\n");
+        if (newline === -1) break;
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        const message = parseCodexJsonRpcLine(line);
+        if (!message || !isJsonRpcResponse(message)) continue;
+        if (message.id === initializeRequestId) {
+          if (!hasJsonRpcField(message, "result") || !isCompatibleInitializeResult(message.result)) {
+            finish(null);
+            return;
+          }
+          sendNotification("initialized", {});
+          requestModelPage(null);
+          continue;
+        }
+        if (message.id === modelListRequestId) {
+          if (!hasJsonRpcField(message, "result")) {
+            finish(null);
+            return;
+          }
+          const page = modelListPage(message.result);
+          if (!page) {
+            finish(null);
+            return;
+          }
+          entries.push(...page.entries);
+          if (page.nextCursor && pageCount < 5) {
+            requestModelPage(page.nextCursor);
+            continue;
+          }
+          finish(codexModelSetFromAppServerEntries(entries));
+          return;
+        }
+      }
+    });
+    initializeRequestId = sendRequest("initialize", {
+      clientInfo: { name: "slock-daemon", version: "1.0.0" },
+      capabilities: { experimentalApi: true }
+    });
+  });
+}
+function detectCodexModels(home = resolveCodexHomeRootFromEnv()) {
+  let cachePath = null;
+  let configPath = null;
+  for (const root of codexStateRootCandidates(home)) {
+    const candidate = path7.join(root, "models_cache.json");
+    if (existsSync5(candidate)) {
+      cachePath = candidate;
+      configPath = path7.join(root, "config.toml");
+      break;
+    }
+  }
+  if (!cachePath || !configPath) return null;
   let models = [];
   try {
     const raw = readFileSync2(cachePath, "utf8");
@@ -6601,7 +7125,7 @@ function runCursorModelsCommand() {
 // src/drivers/gemini.ts
 import { execFileSync as execFileSync3, spawn as spawn6 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
-import path7 from "path";
+import path8 from "path";
 async function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
   const launchEnvVars = runtimeConfigToLaunchFields(ctx.config).envVars;
@@ -6645,7 +7169,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync6;
   const env = deps.env ?? process.env;
-  const winPath = path7.win32;
+  const winPath = path8.win32;
   let geminiEntry = null;
   try {
     const globalRoot = normalizeExecOutput2(execFileSyncFn("npm", ["root", "-g"], {
@@ -6782,8 +7306,8 @@ var GeminiDriver = class {
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import os4 from "os";
-import path8 from "path";
+import os5 from "os";
+import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
@@ -6830,8 +7354,8 @@ var KimiDriver = class {
     this.sessionId = ctx.config.sessionId || randomUUID2();
     this.sessionAnnounced = false;
     this.promptRequestId = randomUUID2();
-    const systemPromptPath = path8.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
-    const agentFilePath = path8.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    const systemPromptPath = path9.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path9.join(ctx.workingDirectory, KIMI_AGENT_FILE);
     if (!isResume || !existsSync7(systemPromptPath)) {
       writeFileSync3(systemPromptPath, ctx.prompt, "utf8");
     }
@@ -6977,8 +7501,8 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path8.join(home, ".kimi", "config.toml");
+function detectKimiModels(home = os5.homedir()) {
+  const configPath = path9.join(home, ".kimi", "config.toml");
   let raw;
   try {
     raw = readFileSync3(configPath, "utf8");
@@ -7006,8 +7530,8 @@ function detectKimiModels(home = os4.homedir()) {
 // src/drivers/kimi-sdk.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter } from "events";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "fs";
-import path9 from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
+import path10 from "path";
 import { createRequire as createRequire2 } from "module";
 import {
   createKimiHarness,
@@ -7032,7 +7556,7 @@ function createKimiSdkEventMappingState(sessionId = null) {
   };
 }
 function buildKimiSessionDir(workingDirectory) {
-  return path9.join(workingDirectory, KIMI_SESSION_DIR);
+  return path10.join(workingDirectory, KIMI_SESSION_DIR);
 }
 function kimiErrorMessage(error) {
   if (typeof error === "string" && error.trim()) return error.trim();
@@ -7155,12 +7679,12 @@ var KIMI_SDK_RUNTIME_SESSION_DESCRIPTOR = {
 };
 async function createKimiAgentSessionForContext(ctx, sessionId) {
   const sessionDir = buildKimiSessionDir(ctx.workingDirectory);
-  mkdirSync3(sessionDir, { recursive: true });
+  mkdirSync4(sessionDir, { recursive: true });
   const cliTransport = await prepareCliTransport(ctx, { NO_COLOR: "1" });
   const spawnEnv = cliTransport.spawnEnv;
   const wrapperPath = cliTransport.wrapperPath;
-  const homeDir = spawnEnv.KIMI_HOME || (process.env.HOME ? path9.join(process.env.HOME, ".kimi") : path9.join(ctx.workingDirectory, ".kimi"));
-  mkdirSync3(homeDir, { recursive: true });
+  const homeDir = spawnEnv.KIMI_HOME || (process.env.HOME ? path10.join(process.env.HOME, ".kimi") : path10.join(ctx.workingDirectory, ".kimi"));
+  mkdirSync4(homeDir, { recursive: true });
   const harness = createKimiHarness({
     homeDir,
     identity: {
@@ -7384,7 +7908,7 @@ So instead of \`raft message send ...\`, run \`${this.wrapperPath} message send
 };
 function detectKimiSdkModels(home = resolveKimiHome(), ctx = {}) {
   const span = ctx.span;
-  const configPath = path9.join(home, "config.toml");
+  const configPath = path10.join(home, "config.toml");
   const homeFromEnv = Boolean(process.env.KIMI_CODE_HOME);
   const emit2 = (outcome, extra = {}) => {
     span?.addEvent("daemon.kimi_sdk.models.config", {
@@ -7492,8 +8016,8 @@ var KimiSdkDriver = class {
 // src/drivers/opencode.ts
 import { spawn as spawn8, spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import os5 from "os";
-import path10 from "path";
+import os6 from "os";
+import path11 from "path";
 var SLOCK_AGENT_NAME = "slock";
 var NO_MESSAGE_PROMPT = "No new messages are pending. Stop now.";
 var FIRST_MESSAGE_TASK_PREFIX = "First message task (system-triggered):";
@@ -7521,8 +8045,8 @@ function parseUserOpenCodeConfig(ctx) {
   const raw = runtimeConfigToLaunchFields(ctx.config).envVars?.OPENCODE_CONFIG_CONTENT;
   return parseOpenCodeConfigContent(raw);
 }
-function readLocalOpenCodeConfig(home = os5.homedir()) {
-  const configPath = path10.join(home, ".config", "opencode", "opencode.json");
+function readLocalOpenCodeConfig(home = os6.homedir()) {
+  const configPath = path11.join(home, ".config", "opencode", "opencode.json");
   try {
     return parseOpenCodeConfigContent(readFileSync5(configPath, "utf8"));
   } catch {
@@ -7582,7 +8106,7 @@ function mergeOpenCodeConfigs(localConfig, envConfig) {
     }
   };
 }
-function buildOpenCodeConfig(ctx, home = os5.homedir()) {
+function buildOpenCodeConfig(ctx, home = os6.homedir()) {
   const userConfig = mergeOpenCodeConfigs(readLocalOpenCodeConfig(home), parseUserOpenCodeConfig(ctx));
   const userAgents = recordField(userConfig.agent);
   const userSlockAgent = recordField(userAgents[SLOCK_AGENT_NAME]);
@@ -7600,7 +8124,7 @@ function buildOpenCodeConfig(ctx, home = os5.homedir()) {
     mcp: recordField(userConfig.mcp)
   };
 }
-async function buildOpenCodeLaunchOptions(ctx, home = os5.homedir(), version = null) {
+async function buildOpenCodeLaunchOptions(ctx, home = os6.homedir(), version = null) {
   const slock = await prepareCliTransport(ctx, { NO_COLOR: "1" });
   const config = buildOpenCodeConfig(ctx, home);
   const env = {
@@ -7699,7 +8223,7 @@ function formatOpenCodeLabelToken(token) {
   if (/^\d/.test(token)) return token;
   return normalized.charAt(0).toUpperCase() + normalized.slice(1);
 }
-function detectOpenCodeModels(home = os5.homedir(), runCommand = runOpenCodeModelsCommand) {
+function detectOpenCodeModels(home = os6.homedir(), runCommand = runOpenCodeModelsCommand) {
   const commandResult = runCommand(home);
   if (commandResult.error || commandResult.status !== 0) return null;
   return parseOpenCodeModelsOutput(commandResult.stdout);
@@ -7720,11 +8244,11 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   };
 }
 function isWindowsCommandShim(commandPath) {
-  const ext = path10.win32.extname(commandPath).toLowerCase();
+  const ext = path11.win32.extname(commandPath).toLowerCase();
   return ext === ".cmd" || ext === ".bat";
 }
 function opencodePackageEntryCandidates(packageRoot) {
-  const winPath = path10.win32;
+  const winPath = path11.win32;
   return [
     winPath.join(packageRoot, "bin", "opencode.exe"),
     winPath.join(packageRoot, "bin", "opencode.js"),
@@ -7733,7 +8257,7 @@ function opencodePackageEntryCandidates(packageRoot) {
   ];
 }
 function openCodeSpecForEntry(entry, commandArgs) {
-  if (path10.win32.extname(entry).toLowerCase() === ".exe") {
+  if (path11.win32.extname(entry).toLowerCase() === ".exe") {
     return { command: entry, args: commandArgs, shell: false };
   }
   return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
@@ -7742,7 +8266,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
   const existsSyncFn = deps.existsSyncFn ?? existsSync8;
   const execFileSyncFn = deps.execFileSyncFn;
   const env = deps.env ?? process.env;
-  const winPath = path10.win32;
+  const winPath = path11.win32;
   const candidates = [];
   if (execFileSyncFn) {
     try {
@@ -7770,7 +8294,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
 function extractWindowsShimTargets(commandPath, deps = {}) {
   if (!isWindowsCommandShim(commandPath)) return [];
   const readFileSyncFn = deps.readFileSyncFn ?? readFileSync5;
-  const commandDir = path10.win32.dirname(commandPath);
+  const commandDir = path11.win32.dirname(commandPath);
   let raw;
   try {
     raw = String(readFileSyncFn(commandPath, "utf8"));
@@ -7781,7 +8305,7 @@ function extractWindowsShimTargets(commandPath, deps = {}) {
   const dp0Pattern = /%~dp0\\?([^"\r\n]*?opencode\.(?:exe|js|mjs|cjs))/gi;
   for (const match of raw.matchAll(dp0Pattern)) {
     const relative = match[1]?.replace(/^\\+/, "");
-    if (relative) candidates.push(path10.win32.normalize(path10.win32.join(commandDir, relative)));
+    if (relative) candidates.push(path11.win32.normalize(path11.win32.join(commandDir, relative)));
   }
   return candidates;
 }
@@ -7795,7 +8319,7 @@ function resolveOpenCodeSpawn(commandArgs, deps = {}) {
     };
   }
   const command = resolveCommandOnPath("opencode", deps);
-  if (command && path10.win32.extname(command).toLowerCase() === ".exe") {
+  if (command && path11.win32.extname(command).toLowerCase() === ".exe") {
     return { command, args: commandArgs, shell: false };
   }
   const packageEntry = resolveWindowsOpenCodePackageEntry(command, deps);
@@ -7900,7 +8424,7 @@ var OpenCodeDriver = class {
     if (unsupportedMessage) {
       throw new Error(unsupportedMessage);
     }
-    const launch = await buildOpenCodeLaunchOptions(ctx, os5.homedir(), version);
+    const launch = await buildOpenCodeLaunchOptions(ctx, os6.homedir(), version);
     const spawnSpec = resolveOpenCodeSpawn(launch.args);
     const proc = spawn8(spawnSpec.command, spawnSpec.args, {
       cwd: ctx.workingDirectory,
@@ -7967,8 +8491,8 @@ var OpenCodeDriver = class {
 // src/drivers/pi.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-import { mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
-import path11 from "path";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync2 } from "fs";
+import path12 from "path";
 import {
   AuthStorage,
   createBashTool,
@@ -7995,7 +8519,7 @@ function createPiSdkEventMappingState(sessionId = null) {
   };
 }
 function buildPiSessionDir(workingDirectory) {
-  return path11.join(workingDirectory, PI_SESSION_DIR);
+  return path12.join(workingDirectory, PI_SESSION_DIR);
 }
 async function buildPiSpawnEnv(ctx) {
   return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
@@ -8017,7 +8541,7 @@ function findPiSessionFile(sessionDir, sessionId) {
   }
   const suffix = `_${sessionId}.jsonl`;
   const match = entries.find((entry) => entry.endsWith(suffix));
-  return match ? path11.join(sessionDir, match) : null;
+  return match ? path12.join(sessionDir, match) : null;
 }
 function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
@@ -8235,7 +8759,7 @@ var PI_IDLE_PROMPT_RETRY_MS = 25;
 var PI_IDLE_PROMPT_MAX_WAIT_MS = 1e3;
 async function createPiAgentSessionForContext(ctx, sessionId) {
   const sessionDir = buildPiSessionDir(ctx.workingDirectory);
-  mkdirSync4(sessionDir, { recursive: true });
+  mkdirSync5(sessionDir, { recursive: true });
   const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
   const requestedModel = launchRuntimeFields.model || "default";
   const traceSpan = ctx.tracer?.startSpan("daemon.pi.session.create", {
@@ -8253,7 +8777,7 @@ async function createPiAgentSessionForContext(ctx, sessionId) {
   try {
     const spawnEnv = await buildPiSpawnEnv(ctx);
     const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
-    const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
+    const authStorage = AuthStorage.create(path12.join(agentDir, "auth.json"));
     const settingsManager = SettingsManager.create(ctx.workingDirectory, agentDir);
     const services = await createAgentSessionServices({
       cwd: ctx.workingDirectory,
@@ -8652,6 +9176,9 @@ var ChildProcessRuntimeSession = class {
   get currentSessionId() {
     return this.driver.currentSessionId;
   }
+  get currentRuntimeHomeDir() {
+    return this.driver.currentRuntimeHomeDir;
+  }
   get exitCode() {
     return this.process?.exitCode ?? null;
   }
@@ -8775,7 +9302,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -8783,7 +9310,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path12.join(dataDir, directoryName);
+  return path13.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -8832,7 +9359,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path12.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path13.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -8851,7 +9378,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path12.join(dataDir, entry.name);
+      const dirPath = path13.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -9400,17 +9927,17 @@ function allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir) {
   const roots = [workspaceDir];
   switch (runtime) {
     case "claude":
-      roots.push(path13.join(homeDir, ".claude"));
+      roots.push(path14.join(homeDir, ".claude"));
       break;
     case "codex":
-      roots.push(path13.join(homeDir, ".codex"));
+      roots.push(homeDir, path14.join(homeDir, ".codex"));
       break;
     case "kimi":
     case "kimi-sdk":
-      roots.push(path13.join(homeDir, ".kimi"));
+      roots.push(path14.join(homeDir, ".kimi"));
       break;
     case "pi":
-      roots.push(path13.join(homeDir, ".pi"), path13.join(homeDir, ".pi", "agent"));
+      roots.push(path14.join(homeDir, ".pi"), path14.join(homeDir, ".pi", "agent"));
       break;
   }
   return roots;
@@ -9421,8 +9948,8 @@ async function isPathWithinAllowedRoots(filePath, roots) {
   for (const root of roots) {
     const realRoot = await realpath(root).catch(() => null);
     if (!realRoot) continue;
-    const rel = path13.relative(realRoot, real);
-    if (!rel.startsWith("..") && !path13.isAbsolute(rel)) return true;
+    const rel = path14.relative(realRoot, real);
+    if (!rel.startsWith("..") && !path14.isAbsolute(rel)) return true;
   }
   return false;
 }
@@ -9469,12 +9996,12 @@ function findSessionJsonl(root, predicate) {
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isFile() || !predicate(entry.name)) continue;
-      return path13.join(dir, entry.name);
+      return path14.join(dir, entry.name);
     }
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isDirectory()) continue;
-      const found = visit(path13.join(dir, entry.name), depth - 1);
+      const found = visit(path14.join(dir, entry.name), depth - 1);
       if (found) return found;
     }
     return null;
@@ -9482,7 +10009,7 @@ function findSessionJsonl(root, predicate) {
   return visit(root, maxDepth);
 }
 function findKimiSdkSessionDir(sessionId, agentId, homeDir) {
-  const indexPath = path13.join(homeDir, ".kimi", "session_index.jsonl");
+  const indexPath = path14.join(homeDir, ".kimi", "session_index.jsonl");
   try {
     const index = readFileSync6(indexPath, "utf8");
     for (const line of index.split("\n")) {
@@ -9497,12 +10024,12 @@ function findKimiSdkSessionDir(sessionId, agentId, homeDir) {
     }
   } catch {
   }
-  const sessionsRoot = path13.join(homeDir, ".kimi", "sessions");
+  const sessionsRoot = path14.join(homeDir, ".kimi", "sessions");
   try {
     const prefix = agentId ? `wd_${agentId}_` : `wd_`;
     for (const entry of readdirSync3(sessionsRoot, { withFileTypes: true })) {
       if (!entry.isDirectory() || !entry.name.startsWith(prefix)) continue;
-      const candidate = path13.join(sessionsRoot, entry.name, `session_${sessionId}`);
+      const candidate = path14.join(sessionsRoot, entry.name, `session_${sessionId}`);
       if (existsSync9(candidate)) return candidate;
     }
   } catch {
@@ -9511,16 +10038,16 @@ function findKimiSdkSessionDir(sessionId, agentId, homeDir) {
 }
 function findPiSessionFile2(sessionId, workingDirectory, homeDir) {
   if (workingDirectory) {
-    const piSessionsDir = path13.join(workingDirectory, ".pi-sessions");
+    const piSessionsDir = path14.join(workingDirectory, ".pi-sessions");
     try {
-      const files = readdirSync3(piSessionsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => ({ name: e.name, path: path13.join(piSessionsDir, e.name), stat: statSync(path13.join(piSessionsDir, e.name)) })).filter((f) => f.stat.isFile() && f.name.includes(sessionId)).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+      const files = readdirSync3(piSessionsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => ({ name: e.name, path: path14.join(piSessionsDir, e.name), stat: statSync(path14.join(piSessionsDir, e.name)) })).filter((f) => f.stat.isFile() && f.name.includes(sessionId)).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
       if (files[0]) return files[0].path;
     } catch {
     }
   }
   const legacyRoots = [
-    path13.join(homeDir, ".pi", "agent"),
-    path13.join(homeDir, ".pi")
+    path14.join(homeDir, ".pi", "agent"),
+    path14.join(homeDir, ".pi")
   ];
   for (const root of legacyRoots) {
     const found = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
@@ -9534,9 +10061,9 @@ function safeSessionFilename(value) {
 }
 function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   try {
-    const dir = path13.join(fallbackDir, ".slock", "runtime-sessions");
-    mkdirSync5(dir, { recursive: true });
-    const filePath = path13.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    const dir = path14.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync6(dir, { recursive: true });
+    const filePath = path14.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
     writeFileSync4(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
@@ -9555,27 +10082,40 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
     return null;
   }
 }
-function resolveRuntimeHomeDir(config, defaultHomeDir, workspacePath) {
+function resolveRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {}) {
   if (isClaudeCustomProviderConfig(config)) {
     return getClaudeProviderStatePaths(workspacePath).home;
   }
+  if (config.runtime === "codex") {
+    return resolveCodexHomeRootFromConfig(config, defaultHomeDir, workspacePath, process.env, opts);
+  }
   return defaultHomeDir;
 }
-function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath) {
+function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {}) {
   if (isClaudeCustomProviderConfig(config)) {
     return ensureClaudeProviderStatePaths(workspacePath).home;
   }
+  if (config.runtime === "codex") {
+    const home = resolveCodexHomeRootFromConfig(config, defaultHomeDir, workspacePath, process.env, opts);
+    if (opts.agentId) {
+      mkdirSync6(home, { recursive: true });
+    }
+    return home;
+  }
   return defaultHomeDir;
 }
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir, opts) {
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os7.homedir(), fallbackDir, opts) {
   let resolvedPath = null;
   let lookupMethod = "none";
   if (runtime === "claude") {
     lookupMethod = "claude_jsonl";
-    resolvedPath = findSessionJsonl(path13.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`);
+    resolvedPath = findSessionJsonl(path14.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`);
   } else if (runtime === "codex") {
     lookupMethod = "codex_jsonl";
-    resolvedPath = findSessionJsonl(path13.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
+    for (const root of codexSessionRootCandidates(homeDir)) {
+      resolvedPath = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
+      if (resolvedPath) break;
+    }
   } else if (runtime === "kimi-sdk" || runtime === "kimi") {
     lookupMethod = "kimi_sdk_index";
     resolvedPath = findKimiSdkSessionDir(sessionId, opts?.agentId, homeDir);
@@ -10312,6 +10852,28 @@ function runtimeDiagnosticTraceAttrs(event) {
     session_id_present: Boolean(event.sessionId)
   };
 }
+function runtimeRecoveryTrajectoryEntry(event) {
+  const lines = [event.message];
+  if (event.details && event.details !== event.message) {
+    lines.push(event.details);
+  }
+  return {
+    kind: "system",
+    title: "Codex resume recovery",
+    text: lines.join("\n")
+  };
+}
+function runtimeRecoveryTraceAttrs(event) {
+  return {
+    kind: event.kind,
+    source: event.source,
+    resume_error_class: event.resumeErrorClass,
+    recovery_action: event.recoveryAction,
+    requested_session_id_present: Boolean(event.requestedSessionId),
+    message_present: Boolean(event.message),
+    details_present: Boolean(event.details)
+  };
+}
 function currentErrorCandidates(ap) {
   return [
     ap.runtimeErrorSinceProgress ? ap.lastRuntimeError : null,
@@ -10635,6 +11197,7 @@ var AgentProcessManager = class _AgentProcessManager {
   sendToServer;
   daemonApiKey;
   serverUrl;
+  slockHome;
   dataDir;
   runtimeSessionHomeDir;
   driverResolver;
@@ -10664,8 +11227,9 @@ var AgentProcessManager = class _AgentProcessManager {
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
-    this.dataDir = opts.dataDir || resolveSlockHomePath("agents");
-    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os6.homedir();
+    this.slockHome = opts.slockHome ? path14.resolve(opts.slockHome) : resolveSlockHome();
+    this.dataDir = opts.dataDir || resolveSlockHomePath("agents", this.slockHome);
+    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os7.homedir();
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
@@ -10794,6 +11358,70 @@ var AgentProcessManager = class _AgentProcessManager {
       this.sendStdinNotification(agentId);
     }, delayMs);
   }
+  flushAsyncRejectedIdleDelivery(agentId) {
+    const ap = this.agents.get(agentId);
+    if (!ap) return false;
+    const count = ap.notifications.takePendingAndClearTimer();
+    if (count === 0) return false;
+    if (!ap.driver.supportsStdinNotification || !ap.sessionId || ap.inbox.length === 0) {
+      ap.notifications.add(count);
+      this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected.retry", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        mode: "idle",
+        outcome: "queued_without_stdin",
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.notifications.pendingCount,
+        session_id_present: Boolean(ap.sessionId),
+        supports_stdin_notification: ap.driver.supportsStdinNotification
+      });
+      return false;
+    }
+    if (!this.isApmIdle(ap)) {
+      ap.notifications.add(count);
+      return this.sendStdinNotification(agentId, { forceUnsupportedRetry: true });
+    }
+    ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+    const messages = ap.notifications.filterUncontributedMessages(ap.inbox, ap.sessionId);
+    if (messages.length === 0) {
+      this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected.retry", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        mode: "idle",
+        outcome: "suppressed_already_contributed",
+        inbox_count: ap.inbox.length,
+        pending_notification_count: count,
+        session_id_present: true
+      });
+      return false;
+    }
+    this.commitApmIdleState(agentId, ap, false);
+    this.startRuntimeTrace(agentId, ap, "async-rejected-idle-delivery-retry", messages);
+    this.broadcastActivity(agentId, "working", "Message received");
+    const accepted = this.deliverInboxUpdateViaStdin(
+      agentId,
+      ap,
+      messages,
+      "idle",
+      "async_rejected_idle_delivery_retry"
+    );
+    this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected.retry", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      mode: "idle",
+      outcome: accepted ? "written" : "not_written",
+      inbox_count: ap.inbox.length,
+      messages_count: messages.length,
+      session_id_present: true
+    });
+    return accepted;
+  }
   isApmIdle(ap) {
     return ap.gatedSteering.isIdle;
   }
@@ -11252,6 +11880,23 @@ var AgentProcessManager = class _AgentProcessManager {
       ...runtimeDiagnosticTraceAttrs(event)
     });
   }
+  recordRuntimeRecoveryActivity(agentId, ap, event) {
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity: ap.lastActivity || "online",
+      detail: ap.lastActivityDetail || "",
+      entries: [runtimeRecoveryTrajectoryEntry(event)],
+      launchId: ap.launchId || void 0,
+      clientSeq: this.nextActivityClientSeq(agentId)
+    });
+    this.recordDaemonTrace("daemon.runtime.recovery.visible", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      ...runtimeRecoveryTraceAttrs(event)
+    });
+  }
   recordDaemonTrace(name, attrs, status = "ok", parentTraceparent) {
     const span = this.tracer.startSpan(name, {
       parent: parseTraceparent(parentTraceparent),
@@ -11589,26 +12234,26 @@ var AgentProcessManager = class _AgentProcessManager {
     let pendingStartRebind;
     const originalLaunchId = launchId || null;
     try {
-      const agentDataDir = path13.join(this.dataDir, agentId);
+      const agentDataDir = path14.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       const initialRuntimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
-      const memoryMdPath = path13.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path14.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
         const initialMemoryMd = buildInitialMemoryMd(initialRuntimeConfig);
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      const notesDir = path13.join(agentDataDir, "notes");
+      const notesDir = path14.join(agentDataDir, "notes");
       await mkdir(notesDir, { recursive: true });
       if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
         const seedFiles = buildOnboardingSeedFiles();
         for (const { relativePath, content } of seedFiles) {
-          const fullPath = path13.join(agentDataDir, relativePath);
+          const fullPath = path14.join(agentDataDir, relativePath);
           try {
             await access(fullPath);
           } catch {
-            await mkdir(path13.dirname(fullPath), { recursive: true });
+            await mkdir(path14.dirname(fullPath), { recursive: true });
             await writeFile(fullPath, content);
           }
         }
@@ -11762,6 +12407,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         workingDirectory: agentDataDir,
         slockCliPath: this.slockCliPath,
         daemonApiKey: this.daemonApiKey,
+        slockHome: this.slockHome,
         launchId: effectiveLaunchId,
         agentCredentialProxyInboxCoordinator: this.createAgentProxyInboxCoordinator(agentId),
         cliTransportTraceDir: this.cliTransportTraceDir,
@@ -12921,7 +13567,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     return true;
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path13.join(this.dataDir, agentId);
+    const agentDataDir = path14.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -12981,9 +13627,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     }
     return result;
   }
-  buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path13.join(this.dataDir, agentId);
-    const runtimeHomeDir = resolveRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspacePath);
+  buildRuntimeProfileReport(agentId, config, sessionId, launchId, observedRuntimeHomeDir) {
+    const workspacePath = path14.join(this.dataDir, agentId);
+    const runtimeHomeDir = observedRuntimeHomeDir || resolveRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspacePath, { agentId, slockHome: this.slockHome });
     return {
       agentId,
       launchId,
@@ -13004,7 +13650,13 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
   getAgentRuntimeProfileReport(agentId) {
     const running = this.agents.get(agentId);
     if (running) {
-      return this.buildRuntimeProfileReport(agentId, running.config, running.sessionId, running.launchId);
+      return this.buildRuntimeProfileReport(
+        agentId,
+        running.config,
+        running.sessionId,
+        running.launchId,
+        running.runtime.currentRuntimeHomeDir
+      );
     }
     const idle = this.idleAgentConfigs.get(agentId);
     if (idle) {
@@ -13277,7 +13929,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path13.join(this.dataDir, agentId);
+    const agentDir = path14.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -13285,8 +13937,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path13.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path13.sep) && resolved !== agentDir) {
+      const resolved = path14.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path14.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -13294,14 +13946,14 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path13.join(this.dataDir, agentId);
-    const resolved = path13.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path13.sep) && resolved !== agentDir) {
+    const agentDir = path14.join(this.dataDir, agentId);
+    const resolved = path14.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path14.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
-    const ext = path13.extname(resolved).toLowerCase();
+    const ext = path14.extname(resolved).toLowerCase();
     if (WORKSPACE_TEXT_EXTENSIONS.has(ext) || ext === "") {
       if (info.size > WORKSPACE_TEXT_FILE_MAX_BYTES) throw new Error("File too large");
       const content = await readFile(resolved, "utf-8");
@@ -13352,8 +14004,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       };
     }
     const runtime = config.runtime;
-    const workspaceDir = path13.join(this.dataDir, agentId);
-    const homeDir = ensureRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspaceDir);
+    const workspaceDir = path14.join(this.dataDir, agentId);
+    const homeDir = agent?.runtime.currentRuntimeHomeDir || ensureRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspaceDir, { agentId, slockHome: this.slockHome });
     if (!actualSessionId) {
       return {
         runtime,
@@ -13391,7 +14043,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     let redacted = false;
     if (ref.reachable && ref.path) {
       try {
-        const resolved = path13.resolve(ref.path);
+        const resolved = path14.resolve(ref.path);
         const allowedRoots = allowedTranscriptRootsForRuntime(runtime, homeDir, workspaceDir);
         if (!await isPathWithinAllowedRoots(resolved, allowedRoots)) {
           throw new Error("resolved session path is outside allowed runtime directories");
@@ -13402,7 +14054,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           throw new Error("symbolic links are not allowed");
         }
         if (info.isDirectory()) {
-          targetPath = path13.join(resolved, "state.json");
+          targetPath = path14.join(resolved, "state.json");
         }
         if (!await isPathWithinAllowedRoots(targetPath, allowedRoots)) {
           throw new Error("resolved session state path is outside allowed runtime directories");
@@ -13514,14 +14166,22 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const idle = this.idleAgentConfigs.get(agentId);
     const config = agent?.config ?? idle?.config ?? null;
     const runtime = runtimeHint || config?.runtime || "claude";
-    const workspaceDir = path13.join(this.dataDir, agentId);
-    const home = config ? ensureRuntimeHomeDir(config, os6.homedir(), workspaceDir) : os6.homedir();
+    const workspaceDir = path14.join(this.dataDir, agentId);
+    const hostHome = os7.homedir();
+    const home = agent?.runtime.currentRuntimeHomeDir || (config ? ensureRuntimeHomeDir(config, hostHome, workspaceDir, { agentId, slockHome: this.slockHome }) : runtime === "codex" ? resolveDefaultCodexHomeRootForAgent(agentId, { slockHome: this.slockHome }) : hostHome);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
+    const globalDirs = runtime === "codex" ? [
+      path14.join(home, "skills"),
+      path14.join(home, "skills", ".system"),
+      path14.join(home, ".agents", "skills"),
+      ...hasConfiguredCodexHome(config) ? [] : [path14.join(hostHome, ".agents", "skills")]
+    ] : paths.global.map((p) => path14.join(home, p));
+    const workspaceDirs = paths.workspace.map((p) => path14.join(workspaceDir, p));
     const globalResults = await Promise.all(
-      paths.global.map((p) => this.scanSkillsDir(path13.join(home, p)))
+      globalDirs.map((dir) => this.scanSkillsDir(dir))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path13.join(workspaceDir, p)))
+      workspaceDirs.map((dir) => this.scanSkillsDir(dir))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -13550,7 +14210,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path13.join(dir, entry.name, "SKILL.md");
+        const skillMd = path14.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -13561,7 +14221,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path13.join(dir, entry.name), "utf-8");
+          const content = await readFile(path14.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -13982,6 +14642,43 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
   recordRuntimeTraceEvent(agentId, ap, name, attrs) {
     this.startRuntimeTrace(agentId, ap, "runtime-progress").addEvent(name, attrs);
   }
+  restoreRuntimeDeliveryAfterAsyncRejection(agentId, ap, event) {
+    const pendingBefore = ap.notifications.pendingCount;
+    const restoredMessages = ap.inbox.filter(
+      (message) => ap.notifications.hasContributedMessage(message, ap.sessionId)
+    );
+    ap.notifications.clearNoticeFingerprint();
+    const restoredNotificationCount = ap.driver.supportsStdinNotification && ap.sessionId && restoredMessages.length > 0 ? ap.notifications.add(restoredMessages.length) : 0;
+    if (event.requestMethod === "turn/start") {
+      this.commitApmIdleState(agentId, ap, true);
+    }
+    const idleRetryScheduled = event.requestMethod === "turn/start" && restoredNotificationCount > 0 ? ap.notifications.schedule(() => {
+      this.flushAsyncRejectedIdleDelivery(agentId);
+    }, this.stdinNotificationRetryMs) : false;
+    const attrs = {
+      request_method: event.requestMethod,
+      source: event.source,
+      payloadBytes: event.payloadBytes,
+      inbox_count: ap.inbox.length,
+      restored_messages_count: restoredMessages.length,
+      pending_notification_count_before: pendingBefore,
+      pending_notification_count_after: ap.notifications.pendingCount,
+      restored_notification_count: restoredNotificationCount,
+      session_id_present: Boolean(ap.sessionId),
+      supports_stdin_notification: ap.driver.supportsStdinNotification,
+      busy_delivery_mode: ap.driver.busyDeliveryMode,
+      restored_idle_state: event.requestMethod === "turn/start",
+      idle_retry_scheduled: idleRetryScheduled
+    };
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.delivery.async_rejected", attrs);
+    this.recordDaemonTrace("daemon.agent.stdin_delivery.async_rejected", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      ...attrs
+    }, "error");
+  }
   noteRuntimeProgress(ap, eventKind) {
     ap.runtimeProgress.noteRuntimeEvent(eventKind);
     this.invalidateRecoveryErrorView(ap);
@@ -14170,7 +14867,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     if ((ap.driver.startupReadiness ?? "first_event") !== "initial_turn") {
       return true;
     }
-    return event.kind !== "session_init" && event.kind !== "internal_progress" && event.kind !== "runtime_diagnostic";
+    return event.kind !== "session_init" && event.kind !== "internal_progress" && event.kind !== "runtime_diagnostic" && event.kind !== "runtime_recovery";
   }
   handleRuntimeStartupTimeout(agentId, ap, timeoutMs) {
     const current = this.agents.get(agentId);
@@ -14366,6 +15063,21 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       if (ap) this.recordRuntimeTelemetry(agentId, ap, event);
       return;
     }
+    if (event.kind === "delivery_error") {
+      if (ap) {
+        this.restoreRuntimeDeliveryAfterAsyncRejection(agentId, ap, event);
+      } else {
+        this.recordDaemonTrace("daemon.agent.delivery_error.received_without_process", {
+          agentId,
+          event_kind: event.kind,
+          runtime: driver.id,
+          request_method: event.requestMethod,
+          source: event.source,
+          payloadBytes: event.payloadBytes
+        });
+      }
+      return;
+    }
     if (ap && isStartupRequestErrorEvent(event)) {
       this.handleRuntimeStartupRequestError(agentId, ap, event);
       return;
@@ -14382,13 +15094,15 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         source: event.source,
         itemType: event.itemType,
         payloadBytes: event.payloadBytes
-      } : event.kind === "runtime_diagnostic" ? runtimeDiagnosticTraceAttrs(event) : { kind: event.kind };
+      } : event.kind === "runtime_diagnostic" ? runtimeDiagnosticTraceAttrs(event) : event.kind === "runtime_recovery" ? runtimeRecoveryTraceAttrs(event) : { kind: event.kind };
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", eventAttrs);
-      if (wasStalled) {
+      const recordProgressObservedAfterStall = () => {
+        if (!wasStalled) return;
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.observed", { afterStall: true });
-      }
+      };
       if (event.kind === "internal_progress") {
         ap.runtimeProgress.noteInternalProgress();
+        recordProgressObservedAfterStall();
         this.invalidateRecoveryErrorView(ap);
         this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.internal_observed", {
@@ -14405,11 +15119,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       }
       if (event.kind === "runtime_diagnostic") {
         this.noteRuntimeProgress(ap, event.kind);
+        recordProgressObservedAfterStall();
         this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
         this.recordRuntimeDiagnosticActivity(agentId, ap, event);
         return;
       }
+      if (event.kind === "runtime_recovery") {
+        this.recordRuntimeRecoveryActivity(agentId, ap, event);
+        return;
+      }
       this.noteRuntimeProgress(ap, event.kind);
+      recordProgressObservedAfterStall();
     } else if (event.kind !== "internal_progress") {
       this.recordDaemonTrace("daemon.agent.event.received_without_process", {
         agentId,
@@ -15166,8 +15886,8 @@ ${RESPONSE_TARGET_HINT}`);
     const nodes = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path13.join(dir, entry.name);
-      const relativePath = path13.relative(rootDir, fullPath);
+      const fullPath = path14.join(dir, entry.name);
+      const relativePath = path14.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -15541,9 +16261,9 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash as createHash4, randomUUID as randomUUID6 } from "crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync7, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
-import os7 from "os";
-import path14 from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import os8 from "os";
+import path15 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -15565,7 +16285,7 @@ function resolveDefaultMachineStateRoot() {
   return resolveSlockHomePath("machines");
 }
 function ownerPath(lockDir) {
-  return path14.join(lockDir, "owner.json");
+  return path15.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
@@ -15595,17 +16315,17 @@ function acquireDaemonMachineLock(options) {
   const rootDir = options.rootDir ?? resolveDefaultMachineStateRoot();
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
-  const machineDir = path14.join(rootDir, lockId);
-  const lockDir = path14.join(machineDir, "daemon.lock");
+  const machineDir = path15.join(rootDir, lockId);
+  const lockDir = path15.join(machineDir, "daemon.lock");
   const token = randomUUID6();
-  mkdirSync6(machineDir, { recursive: true });
+  mkdirSync7(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync6(lockDir);
+      mkdirSync7(lockDir);
       const owner = {
         pid: process.pid,
         token,
-        hostname: os7.hostname(),
+        hostname: os8.hostname(),
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         serverUrl: options.serverUrl,
         apiKeyFingerprint: fingerprint.slice(0, 16)
@@ -15656,8 +16376,8 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync4, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
-import path15 from "path";
+import { appendFileSync, mkdirSync as mkdirSync8, readdirSync as readdirSync4, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import path16 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
@@ -15694,7 +16414,7 @@ var LocalRotatingTraceSink = class {
   currentSize = 0;
   sequence = 0;
   constructor(options) {
-    this.traceDir = path15.join(options.machineDir, "traces");
+    this.traceDir = path16.join(options.machineDir, "traces");
     this.maxFileBytes = Math.max(1024, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
     const baseAgeMs = Math.max(1e3, Math.floor(options.maxFileAgeMs ?? DEFAULT_MAX_FILE_AGE_MS));
     const ageJitterMs = Math.max(0, Math.floor(options.maxFileAgeJitterMs ?? 0));
@@ -15720,11 +16440,11 @@ var LocalRotatingTraceSink = class {
     return this.currentFile;
   }
   ensureFile(nextBytes) {
-    mkdirSync7(this.traceDir, { recursive: true, mode: 448 });
+    mkdirSync8(this.traceDir, { recursive: true, mode: 448 });
     const nowMs = this.nowMsProvider();
     const shouldRotateForAge = this.currentFileOpenedAtMs !== null && nowMs - this.currentFileOpenedAtMs >= this.maxFileAgeMs;
     if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes || shouldRotateForAge) {
-      this.currentFile = path15.join(
+      this.currentFile = path16.join(
         this.traceDir,
         `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
@@ -15739,7 +16459,7 @@ var LocalRotatingTraceSink = class {
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
-      rmSync4(path15.join(this.traceDir, file), { force: true });
+      rmSync4(path16.join(this.traceDir, file), { force: true });
     }
   }
 };
@@ -15830,7 +16550,7 @@ function isDiagnosticErrorAttr(key) {
 import { createHash as createHash6, randomUUID as randomUUID7 } from "crypto";
 import { gzipSync as gzipSync2 } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 
 // src/traceJitter.ts
 import { createHash as createHash5 } from "crypto";
@@ -15929,7 +16649,7 @@ var DaemonTraceBundleUploader = class {
     }, nextMs);
   }
   async findUploadCandidates() {
-    const traceDir = path16.join(this.options.machineDir, "traces");
+    const traceDir = path17.join(this.options.machineDir, "traces");
     let names;
     try {
       names = await readdir3(traceDir);
@@ -15941,8 +16661,8 @@ var DaemonTraceBundleUploader = class {
     const currentFile = this.options.currentFileProvider?.();
     const candidates = [];
     for (const name of names.filter((entry) => entry.startsWith("daemon-trace-") && entry.endsWith(".jsonl")).sort()) {
-      const file = path16.join(traceDir, name);
-      if (currentFile && path16.resolve(file) === path16.resolve(currentFile)) continue;
+      const file = path17.join(traceDir, name);
+      if (currentFile && path17.resolve(file) === path17.resolve(currentFile)) continue;
       if (await this.isUploaded(file)) continue;
       try {
         const info = await stat3(file);
@@ -16016,8 +16736,8 @@ var DaemonTraceBundleUploader = class {
     }
   }
   uploadStatePath(file) {
-    const stateDir = path16.join(this.options.machineDir, "trace-uploads");
-    return path16.join(stateDir, `${path16.basename(file)}.uploaded.json`);
+    const stateDir = path17.join(this.options.machineDir, "trace-uploads");
+    return path17.join(stateDir, `${path17.basename(file)}.uploaded.json`);
   }
   async isUploaded(file) {
     try {
@@ -16029,9 +16749,9 @@ var DaemonTraceBundleUploader = class {
   }
   async markUploaded(file, metadata) {
     const stateFile = this.uploadStatePath(file);
-    await mkdir2(path16.dirname(stateFile), { recursive: true, mode: 448 });
+    await mkdir2(path17.dirname(stateFile), { recursive: true, mode: 448 });
     await writeFile2(stateFile, `${JSON.stringify({
-      file: path16.basename(file),
+      file: path17.basename(file),
       uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...metadata
     }, null, 2)}
@@ -16180,13 +16900,13 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path17.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path17.resolve(thisDir, "cli", "index.js");
+  const thisDir = path18.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path18.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path17.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path18.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -16200,11 +16920,12 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-DSRBN3VD.js");
+  await import("./dist-5BEASCX5.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
   const versions = {};
+  const diagnostics = {};
   const span = tracer.startSpan("daemon.runtime.detect", {
     surface: "daemon",
     kind: "internal",
@@ -16220,20 +16941,26 @@ function detectRuntimes(tracer = noopTracer) {
         const probe = driver.probe();
         if (!probe.available) {
           if (probe.version) versions[runtime.id] = probe.version;
+          if (probe.diagnostic) diagnostics[runtime.id] = probe.diagnostic;
           span.addEvent("daemon.runtime.detect.checked", {
             runtime: runtime.id,
             outcome: "unavailable",
             version_present: Boolean(probe.version),
+            diagnostic_present: Boolean(probe.diagnostic),
+            ...probe.diagnostic ? { diagnostic: probe.diagnostic } : {},
             binary_path_present: false
           });
           continue;
         }
         ids.push(runtime.id);
         if (probe.version) versions[runtime.id] = probe.version;
+        if (probe.diagnostic) diagnostics[runtime.id] = probe.diagnostic;
         span.addEvent("daemon.runtime.detect.checked", {
           runtime: runtime.id,
           outcome: "available",
           version_present: Boolean(probe.version),
+          diagnostic_present: Boolean(probe.diagnostic),
+          ...probe.diagnostic ? { diagnostic: probe.diagnostic } : {},
           binary_path_present: false
         });
         continue;
@@ -16276,7 +17003,7 @@ function detectRuntimes(tracer = noopTracer) {
       detected_runtime_count: ids.length
     }
   });
-  return { ids, versions };
+  return { ids, versions, ...Object.keys(diagnostics).length > 0 ? { diagnostics } : {} };
 }
 function readPositiveIntegerEnv3(name, fallback) {
   const raw = process.env[name];
@@ -16398,7 +17125,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path17.join(path17.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path18.join(path18.dirname(this.options.dataDir), "machines");
     return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
@@ -16425,7 +17152,7 @@ var DaemonCore = class {
       sink: this.localTraceSink
     }));
     this.agentManager.setTracer(this.tracer);
-    this.agentManager.setCliTransportTraceDir(path17.join(machineDir, "traces"));
+    this.agentManager.setCliTransportTraceDir(path18.join(machineDir, "traces"));
   }
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
@@ -16973,9 +17700,12 @@ var DaemonCore = class {
     });
   }
   handleConnect() {
-    const { ids: runtimes, versions: runtimeVersions } = this.runtimeDetector();
+    const { ids: runtimes, versions: runtimeVersions, diagnostics: runtimeDiagnostics = {} } = this.runtimeDetector();
     const runtimeInfo = runtimes.map((id) => runtimeVersions[id] ? `${id} (${runtimeVersions[id]})` : id);
     logger.info(`[Daemon] Detected runtimes: ${runtimeInfo.join(", ") || "none"}`);
+    for (const [runtime, diagnostic] of Object.entries(runtimeDiagnostics)) {
+      logger.warn(`[Daemon] Runtime ${runtime} diagnostic: ${diagnostic}`);
+    }
     if (!this.opencliWrappersRegenerated) {
       this.opencliWrappersRegenerated = true;
       try {
@@ -16995,8 +17725,8 @@ var DaemonCore = class {
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
       runningAgents: runningAgentIds,
-      hostname: this.options.hostname ?? os8.hostname(),
-      os: this.options.osDescription ?? `${os8.platform()} ${os8.arch()}`,
+      hostname: this.options.hostname ?? os9.hostname(),
+      os: this.options.osDescription ?? `${os9.platform()} ${os9.arch()}`,
       daemonVersion: this.daemonVersion,
       ...this.computerVersion ? { computerVersion: this.computerVersion } : {}
     });