@slock-ai/daemon 0.54.1 → 0.54.2-play.20260528162546

package/dist/{chunk-X366KJGT.js → chunk-MWGRDZGK.js}

@@ -8,11 +8,35 @@ import {
 } from "./chunk-VOZJ2ELH.js";
 
 // src/core.ts
-import path16 from "path";
-import os8 from "os";
+import path17 from "path";
+import os7 from "os";
 import { createRequire as createRequire2 } from "module";
 import { accessSync } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../shared/src/slockRefs.ts
+var SLOCK_REF_CHANNEL_NAME_PATTERN = String.raw`[\p{L}\p{N}_-]+`;
+var SLOCK_REF_USER_NAME_PATTERN = SLOCK_REF_CHANNEL_NAME_PATTERN;
+var SLOCK_REF_DM_PEER_PATTERN = String.raw`[\w-]+`;
+var SLOCK_REF_THREAD_SHORT_ID_PATTERN = String.raw`[\da-f]{6,8}`;
+var SLOCK_REF_MESSAGE_ID_PATTERN = String.raw`[A-Za-z0-9][A-Za-z0-9-]{1,63}`;
+var SLOCK_REF_TASK_NUMBER_PATTERN = String.raw`[1-9]\d*`;
+var USER_RE = new RegExp(String.raw`^@(${SLOCK_REF_USER_NAME_PATTERN})$`, "u");
+var CHANNEL_RE = new RegExp(String.raw`^#(${SLOCK_REF_CHANNEL_NAME_PATTERN})$`, "u");
+var CHANNEL_THREAD_RE = new RegExp(
+  String.raw`^#(${SLOCK_REF_CHANNEL_NAME_PATTERN}):(${SLOCK_REF_THREAD_SHORT_ID_PATTERN})$`,
+  "iu"
+);
+var DM_RE = new RegExp(String.raw`^dm:@(${SLOCK_REF_DM_PEER_PATTERN})$`, "iu");
+var DM_THREAD_RE = new RegExp(
+  String.raw`^dm:@(${SLOCK_REF_DM_PEER_PATTERN}):(${SLOCK_REF_THREAD_SHORT_ID_PATTERN})$`,
+  "iu"
+);
+var TASK_RE = new RegExp(String.raw`^task\s+#(${SLOCK_REF_TASK_NUMBER_PATTERN})$`, "iu");
+var CHANNEL_MESSAGE_RE = new RegExp(
+  String.raw`^#(${SLOCK_REF_CHANNEL_NAME_PATTERN})(?::(${SLOCK_REF_THREAD_SHORT_ID_PATTERN}))?\s+msg=(${SLOCK_REF_MESSAGE_ID_PATTERN})$`,
+  "iu"
+);
 
 // ../shared/src/tracing/index.ts
 var DEFAULT_TRACE_FLAGS = "00";
@@ -724,9 +748,11 @@ var SERVER_CAPABILITY_MATRIX = {
 };
 
 // ../shared/src/index.ts
+var RUNTIME_CONFIG_VERSION = 1;
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
+  { id: "pi", displayName: "Pi", binary: "pi", supported: true },
   { id: "antigravity", displayName: "Antigravity CLI", binary: "agy", supported: true },
   { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
   { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
@@ -734,6 +760,171 @@ var RUNTIMES = [
   { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
   { id: "opencode", displayName: "OpenCode", binary: "opencode", supported: true }
 ];
+var RUNTIME_MODELS = {
+  claude: [
+    { id: "opus", label: "Opus" },
+    { id: "sonnet", label: "Sonnet" },
+    { id: "haiku", label: "Haiku" }
+  ],
+  codex: [
+    { id: "gpt-5.5", label: "GPT-5.5" },
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+    { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark" },
+    { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
+    { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+    { id: "gpt-5-codex", label: "GPT-5 Codex" },
+    { id: "gpt-5", label: "GPT-5" }
+  ],
+  antigravity: [
+    { id: "default", label: "AGY configured default", verified: "suggestion_only" }
+  ],
+  copilot: [
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "claude-4-sonnet", label: "Claude 4 Sonnet" },
+    { id: "claude-4.5-sonnet", label: "Claude 4.5 Sonnet" }
+  ],
+  cursor: [
+    { id: "composer-2-fast", label: "Composer 2 Fast" },
+    { id: "composer-2", label: "Composer 2" },
+    { id: "auto", label: "Auto" }
+  ],
+  gemini: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
+    { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)" },
+    { id: "gemini-3-flash-preview", label: "Gemini 3 Flash (Preview)" },
+    { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+    { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+  ],
+  opencode: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
+    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro (OpenCode)", verified: "suggestion_only" },
+    { id: "openrouter/anthropic/claude-opus-4.5", label: "Claude Opus 4.5 via OpenRouter", verified: "suggestion_only" },
+    { id: "fusecode/opus[1m]", label: "Opus 1M via FuseCode", verified: "suggestion_only" }
+  ],
+  pi: [
+    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro" },
+    { id: "deepseek/deepseek-v4-flash", label: "DeepSeek V4 Flash" },
+    { id: "kimi-coding/kimi-for-coding", label: "Kimi for Coding" },
+    { id: "zai/glm-5.1", label: "GLM-5.1" },
+    { id: "zai/glm-4.7", label: "GLM-4.7" }
+  ],
+  // Kimi CLI resolves model keys from each user's local config, so the safest
+  // built-in option is to defer to whatever default model the CLI already uses.
+  kimi: [
+    { id: "default", label: "Configured Default" }
+  ]
+};
+function getDefaultModel(runtimeId) {
+  const models = RUNTIME_MODELS[runtimeId];
+  return models?.[0]?.id ?? "sonnet";
+}
+var CONTROLLED_RUNTIME_ENV_KEYS = {
+  claude: ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_CUSTOM_MODEL_OPTION"]
+};
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeEnvVars(envVars) {
+  if (!isPlainRecord(envVars)) return null;
+  const normalized = {};
+  for (const [key, value] of Object.entries(envVars)) {
+    if (typeof key === "string" && typeof value === "string") {
+      normalized[key] = value;
+    }
+  }
+  return Object.keys(normalized).length > 0 ? normalized : null;
+}
+function getControlledRuntimeEnvKeys(runtime) {
+  return CONTROLLED_RUNTIME_ENV_KEYS[runtime] ?? [];
+}
+function stripControlledRuntimeEnvVars(runtime, envVars) {
+  const normalized = normalizeEnvVars(envVars);
+  if (!normalized) return null;
+  const controlled = new Set(getControlledRuntimeEnvKeys(runtime));
+  for (const key of controlled) {
+    delete normalized[key];
+  }
+  return Object.keys(normalized).length > 0 ? normalized : null;
+}
+function isPresetRuntimeModel(runtime, model) {
+  return (RUNTIME_MODELS[runtime] ?? []).some((candidate) => candidate.id === model);
+}
+function modelConfigFromLegacy(runtime, model) {
+  return isPresetRuntimeModel(runtime, model) ? { kind: "preset", id: model } : { kind: "custom", name: model };
+}
+function parseProviderConfig(runtime, value) {
+  if (runtime !== "claude") return void 0;
+  if (!isPlainRecord(value)) return { kind: "default" };
+  if (value.kind === "custom" && typeof value.apiUrl === "string" && value.apiUrl.trim() && typeof value.apiKey === "string" && value.apiKey.trim()) {
+    return { kind: "custom", apiUrl: value.apiUrl.trim(), apiKey: value.apiKey.trim() };
+  }
+  return { kind: "default" };
+}
+function parseModelConfig(runtime, value, fallback) {
+  if (!isPlainRecord(value)) return modelConfigFromLegacy(runtime, fallback);
+  if (value.kind === "custom" && typeof value.name === "string" && value.name.trim()) {
+    return { kind: "custom", name: value.name.trim() };
+  }
+  if (value.kind === "preset" && typeof value.id === "string" && value.id.trim()) {
+    return { kind: "preset", id: value.id.trim() };
+  }
+  return modelConfigFromLegacy(runtime, fallback);
+}
+function parseModeConfig(value) {
+  if (!isPlainRecord(value)) return { kind: "default" };
+  if (value.kind === "fast") return { kind: "fast" };
+  return { kind: "default" };
+}
+function hydrateRuntimeConfig(input) {
+  const stored = isPlainRecord(input.runtimeConfig) && input.runtimeConfig.version === RUNTIME_CONFIG_VERSION ? input.runtimeConfig : null;
+  const runtime = typeof stored?.runtime === "string" && stored.runtime.trim() || typeof input.runtime === "string" && input.runtime.trim() || "claude";
+  const fallbackModel = typeof input.model === "string" && input.model.trim() || getDefaultModel(runtime);
+  const legacyEnvVars = normalizeEnvVars(input.envVars);
+  const storedEnvVars = normalizeEnvVars(stored?.envVars);
+  const legacyClaudeApiUrl = runtime === "claude" ? legacyEnvVars?.ANTHROPIC_BASE_URL : void 0;
+  const legacyClaudeApiKey = runtime === "claude" ? legacyEnvVars?.ANTHROPIC_API_KEY : void 0;
+  const provider = stored ? parseProviderConfig(runtime, stored.provider) : runtime === "claude" && legacyClaudeApiUrl && legacyClaudeApiKey ? { kind: "custom", apiUrl: legacyClaudeApiUrl, apiKey: legacyClaudeApiKey } : runtime === "claude" ? { kind: "default" } : void 0;
+  return {
+    version: RUNTIME_CONFIG_VERSION,
+    runtime,
+    ...provider ? { provider } : {},
+    model: stored ? parseModelConfig(runtime, stored.model, fallbackModel) : modelConfigFromLegacy(runtime, fallbackModel),
+    mode: stored ? parseModeConfig(stored.mode) : { kind: "default" },
+    reasoningEffort: stored?.reasoningEffort ?? input.reasoningEffort ?? null,
+    envVars: stripControlledRuntimeEnvVars(runtime, stored ? storedEnvVars : legacyEnvVars)
+  };
+}
+function runtimeConfigModelValue(config) {
+  return config.model.kind === "custom" ? config.model.name : config.model.id;
+}
+function runtimeConfigToLaunchFields(config) {
+  const normalized = isPlainRecord(config) && config.version === RUNTIME_CONFIG_VERSION ? hydrateRuntimeConfig({ runtimeConfig: config }) : hydrateRuntimeConfig(config);
+  const generatedEnvVars = {};
+  if (normalized.runtime === "claude") {
+    if (normalized.provider?.kind === "custom") {
+      generatedEnvVars.ANTHROPIC_BASE_URL = normalized.provider.apiUrl;
+      generatedEnvVars.ANTHROPIC_API_KEY = normalized.provider.apiKey;
+    }
+    if (normalized.model.kind === "custom") {
+      generatedEnvVars.ANTHROPIC_CUSTOM_MODEL_OPTION = normalized.model.name;
+    }
+  }
+  const envVars = {
+    ...normalized.envVars ?? {},
+    ...generatedEnvVars
+  };
+  return {
+    runtime: normalized.runtime,
+    model: runtimeConfigModelValue(normalized),
+    mode: normalized.mode,
+    reasoningEffort: normalized.reasoningEffort ?? null,
+    envVars: Object.keys(envVars).length > 0 ? envVars : null
+  };
+}
 var PLAN_CONFIG = {
   free: {
     displayName: "Hobby",
@@ -769,17 +960,14 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync4, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync5, readdirSync, statSync, writeFileSync as writeFileSync8 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import path12 from "path";
-import os6 from "os";
+import path13 from "path";
+import os5 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import os2 from "os";
-import path4 from "path";
 
 // src/drivers/cliTransport.ts
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
@@ -1359,6 +1547,19 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
+// src/authEnv.ts
+var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
+var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
+function scrubDaemonAuthEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  return env;
+}
+function scrubDaemonChildEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  delete env[SLOCK_AGENT_TOKEN_ENV];
+  return env;
+}
+
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -1949,10 +2150,13 @@ function unregisterAgentCredentialProxyForLaunch(input) {
 // src/drivers/cliTransport.ts
 var shellSingleQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
 var powershellSingleQuote = (value) => `'${value.replace(/'/g, "''")}'`;
-var DEFAULT_ACTIVE_CAPABILITIES = "send,read,mentions,tasks,reactions,server,channels";
+var DEFAULT_ACTIVE_CAPABILITIES = "send,read,mentions,tasks,reactions,server,channels,knowledge";
+var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_CREDENTIAL_KEY"
+  "SLOCK_AGENT_TOKEN",
+  "SLOCK_AGENT_CREDENTIAL_KEY",
+  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
 ];
 var cachedOpencliBinPath;
 function resolveOpencliBinPath() {
@@ -1996,6 +2200,34 @@ function windowsUtf8Env() {
     LC_ALL: "C.UTF-8"
   };
 }
+function posixLoopbackNoProxyPrelude() {
+  return [
+    `SLOCK_LOOPBACK_NO_PROXY=${shellSingleQuote(LOOPBACK_NO_PROXY)}`,
+    `SLOCK_EXISTING_NO_PROXY="\${NO_PROXY:-}"`,
+    `if [ -n "\${no_proxy:-}" ]; then SLOCK_EXISTING_NO_PROXY="\${SLOCK_EXISTING_NO_PROXY:+$SLOCK_EXISTING_NO_PROXY,}$no_proxy"; fi`,
+    `NO_PROXY="\${SLOCK_LOOPBACK_NO_PROXY}\${SLOCK_EXISTING_NO_PROXY:+,$SLOCK_EXISTING_NO_PROXY}"`,
+    `no_proxy="$NO_PROXY"`,
+    "export NO_PROXY no_proxy"
+  ].join("\n");
+}
+function cmdLoopbackNoProxyLines() {
+  return [
+    `set "SLOCK_LOOPBACK_NO_PROXY=${LOOPBACK_NO_PROXY}"`,
+    `set "SLOCK_EXISTING_NO_PROXY=%NO_PROXY%"`,
+    `if defined no_proxy (if defined SLOCK_EXISTING_NO_PROXY (set "SLOCK_EXISTING_NO_PROXY=%SLOCK_EXISTING_NO_PROXY%,%no_proxy%") else set "SLOCK_EXISTING_NO_PROXY=%no_proxy%")`,
+    `if defined SLOCK_EXISTING_NO_PROXY (set "NO_PROXY=%SLOCK_LOOPBACK_NO_PROXY%,%SLOCK_EXISTING_NO_PROXY%") else set "NO_PROXY=%SLOCK_LOOPBACK_NO_PROXY%"`,
+    `set "no_proxy=%NO_PROXY%"`
+  ];
+}
+function powershellLoopbackNoProxyLines() {
+  return [
+    `$loopbackNoProxy = ${powershellSingleQuote(LOOPBACK_NO_PROXY)}`,
+    "$existingNoProxy = @($env:NO_PROXY, $env:no_proxy) | Where-Object { $_ }",
+    `if ($existingNoProxy.Count -gt 0) { $mergedNoProxy = "$loopbackNoProxy,$($existingNoProxy -join ',')" } else { $mergedNoProxy = $loopbackNoProxy }`,
+    "$env:NO_PROXY = $mergedNoProxy",
+    "$env:no_proxy = $mergedNoProxy"
+  ];
+}
 function runtimeContextEnv(config) {
   const ctx = config.runtimeContext;
   if (!ctx) return {};
@@ -2045,6 +2277,7 @@ async function prepareCliTransport(ctx, extraEnv = {}, platform = process.platfo
   const posixWrapper = path2.join(slockDir, "slock");
   const posixCredentialPrefix = agentCredentialProxy ? `SLOCK_AGENT_PROXY_URL=${shellSingleQuote(agentCredentialProxy.proxyUrl)} SLOCK_AGENT_PROXY_TOKEN_FILE=${shellSingleQuote(agentCredentialProxyTokenFile)} SLOCK_AGENT_ACTIVE_CAPABILITIES=${shellSingleQuote(DEFAULT_ACTIVE_CAPABILITIES)} ` : "";
   const posixBody = `#!/usr/bin/env bash
+${posixLoopbackNoProxyPrelude()}
 ${posixCredentialPrefix}exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(ctx.slockCliPath)} "$@"
 `;
   writeFileSync(posixWrapper, posixBody, { mode: 493 });
@@ -2061,6 +2294,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
       "set LANG=C.UTF-8",
       "set LC_ALL=C.UTF-8",
       "chcp 65001 >NUL 2>NUL",
+      ...cmdLoopbackNoProxyLines(),
       cmdCredentialLine.trimEnd(),
       `"${process.execPath}" "${ctx.slockCliPath}" %*`,
       ""
@@ -2081,6 +2315,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
       "$env:PYTHONUTF8 = '1'",
       "$env:LANG = 'C.UTF-8'",
       "$env:LC_ALL = 'C.UTF-8'",
+      ...powershellLoopbackNoProxyLines(),
       ...psCredentialLines,
       `$node = ${powershellSingleQuote(process.execPath)}`,
       `$cli = ${powershellSingleQuote(ctx.slockCliPath)}`,
@@ -2120,10 +2355,11 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     }
   }
   const wrapperPath = platform === "win32" ? path2.join(slockDir, "slock.cmd") : posixWrapper;
+  const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
   const spawnEnv = {
     ...process.env,
     FORCE_COLOR: "0",
-    ...ctx.config.envVars || {},
+    ...launchRuntimeFields.envVars || {},
     ...extraEnv,
     ...platform === "win32" ? windowsUtf8Env() : {},
     ...runtimeContextEnv(ctx.config),
@@ -2134,7 +2370,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -2154,6 +2390,129 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
   };
 }
 
+// src/drivers/claudeEventNormalizer.ts
+function collectResultErrorDetail(message, fallback) {
+  const parts = [];
+  if (Array.isArray(message.errors)) {
+    for (const err of message.errors) {
+      if (typeof err === "string" && err.trim()) parts.push(err.trim());
+    }
+  }
+  if (typeof message.result === "string" && message.result.trim()) {
+    parts.push(message.result.trim());
+  }
+  return parts.join(" | ") || fallback;
+}
+function isProviderApiFailureText(value, hasToolUse) {
+  return !hasToolUse && /^\s*API Error:/i.test(value) && (/\b(?:ECONNRESET|EPIPE|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(value) || /\bUnable to connect to API\b/i.test(value) || /\b(?:timed out|timeout)\b/i.test(value) || /\b5\d{2}\b/.test(value));
+}
+var ClaudeEventNormalizer = class {
+  normalizeLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    const pushResultError = (message, fallback) => {
+      events.push({ kind: "error", message: collectResultErrorDetail(message, fallback) });
+    };
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init" && event.session_id) {
+          events.push({ kind: "session_init", sessionId: event.session_id });
+        }
+        if (event.subtype === "status" && event.status === "compacting") {
+          events.push({ kind: "compaction_started" });
+        }
+        if (event.subtype === "status" && event.status === "requesting") {
+          events.push({
+            kind: "internal_progress",
+            source: "claude_system_status",
+            itemType: "requesting",
+            payloadBytes: Buffer.byteLength(line, "utf8")
+          });
+        }
+        if (event.subtype === "compact_boundary") {
+          events.push({ kind: "compaction_finished" });
+        }
+        break;
+      case "stream_event":
+        events.push({
+          kind: "internal_progress",
+          source: "claude_stream_event",
+          itemType: typeof event.event?.type === "string" && event.event.type.length > 0 ? event.event.type : "unknown",
+          payloadBytes: Buffer.byteLength(line, "utf8")
+        });
+        break;
+      case "assistant": {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          const hasToolUse = content.some((block) => block?.type === "tool_use");
+          for (const block of content) {
+            if (block.type === "thinking" && block.thinking) {
+              events.push({ kind: "thinking", text: block.thinking });
+            } else if (block.type === "text" && block.text) {
+              if (isProviderApiFailureText(block.text, hasToolUse)) {
+                events.push({ kind: "error", message: block.text });
+              } else {
+                events.push({ kind: "text", text: block.text });
+              }
+            } else if (block.type === "tool_use") {
+              events.push({ kind: "tool_call", name: block.name || "unknown_tool", input: block.input });
+            }
+          }
+        }
+        break;
+      }
+      case "user": {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              events.push({ kind: "tool_output", name: block.name || block.tool_use_id || "tool_result" });
+            }
+          }
+        }
+        break;
+      }
+      case "result": {
+        const subtype = typeof event.subtype === "string" ? event.subtype : "success";
+        const stopReason = typeof event.stop_reason === "string" ? event.stop_reason : null;
+        switch (subtype) {
+          case "success":
+            if (event.is_error && stopReason !== "max_tokens") {
+              pushResultError(event, "Execution failed");
+            }
+            break;
+          case "error_during_execution":
+            if (stopReason !== "max_tokens") {
+              pushResultError(event, "Execution failed");
+            }
+            break;
+          case "error_max_budget_usd":
+            pushResultError(event, "Budget limit exceeded");
+            break;
+          case "error_max_turns":
+            pushResultError(event, "Max turns exceeded");
+            break;
+          case "error_max_structured_output_retries":
+            pushResultError(event, "Structured output retries exceeded");
+            break;
+        }
+        events.push({ kind: "turn_end", sessionId: event.session_id });
+        break;
+      }
+    }
+    return events;
+  }
+};
+
+// src/drivers/claudeLaunch.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import path4 from "path";
+
 // src/drivers/probe.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync2 } from "fs";
@@ -2310,7 +2669,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn, existsSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync2;
   if (platform === "win32") {
@@ -2336,7 +2695,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -2354,12 +2713,10 @@ function resolveHomePath(relativePath, deps = {}) {
   return path3.join(homeDir, relativePath);
 }
 
-// src/drivers/claude.ts
+// src/drivers/claudeLaunch.ts
 var CLAUDE_DESKTOP_CLI_RELATIVE_PATH = path4.join("Applications", "Claude Code URL Handler.app", "Contents", "MacOS", "claude");
 var CLAUDE_DESKTOP_CLI_SYSTEM_PATH = "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude";
 var CLAUDE_SYSTEM_PROMPT_FILE = "claude-system-prompt.md";
-var CLAUDE_MCP_CONFIG_FILE = "claude-mcp-config.json";
-var SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME = "chat";
 var CLAUDE_DISALLOWED_TOOLS = [
   "EnterPlanMode",
   "ExitPlanMode",
@@ -2385,81 +2742,54 @@ function probeClaude(deps = {}) {
     version: readCommandVersion(command, [], deps) ?? void 0
   };
 }
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function expandClaudeMcpConfigVariables(raw, vars) {
-  let expanded = raw;
-  for (const [name, value] of Object.entries(vars)) {
-    const escapedValue = process.platform === "win32" ? value.replace(/\\/g, "\\\\") : value;
-    expanded = expanded.replaceAll(`\${${name}}`, escapedValue);
+function buildClaudeArgs(config, opts) {
+  const launchRuntimeFields = runtimeConfigToLaunchFields(config);
+  const args = [
+    "--allow-dangerously-skip-permissions",
+    "--dangerously-skip-permissions",
+    "--verbose",
+    "--permission-mode",
+    "bypassPermissions",
+    "--output-format",
+    "stream-json",
+    "--input-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--model",
+    launchRuntimeFields.model || "sonnet",
+    "--disallowed-tools",
+    CLAUDE_DISALLOWED_TOOLS,
+    "--append-system-prompt-file",
+    opts.standingPromptFilePath
+  ];
+  if (launchRuntimeFields.reasoningEffort) {
+    args.push("--effort", launchRuntimeFields.reasoningEffort);
   }
-  return expanded;
-}
-function readClaudeMcpServers(configPath, vars = {}) {
-  try {
-    const parsed = JSON.parse(
-      expandClaudeMcpConfigVariables(readFileSync2(configPath, "utf8"), vars)
-    );
-    if (!isRecord(parsed) || !isRecord(parsed.mcpServers)) return null;
-    return parsed.mcpServers;
-  } catch (err) {
-    logger.warn(
-      `[Claude] failed to read MCP config ${configPath}: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return null;
+  if (launchRuntimeFields.mode.kind === "fast") {
+    args.push("--bare");
   }
+  if (config.sessionId) {
+    args.push("--resume", config.sessionId);
+  }
+  return args;
 }
-function resolveClaudeConfigDir(ctx, home) {
-  const configured = ctx.config.envVars?.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR;
-  return configured && path4.isAbsolute(configured) ? configured : path4.join(home, ".claude");
+function writeClaudeSystemPromptFile(standingPrompt, slockDir) {
+  const systemPromptPath = path4.join(slockDir, CLAUDE_SYSTEM_PROMPT_FILE);
+  writeFileSync2(systemPromptPath, standingPrompt, { mode: 384 });
+  return systemPromptPath;
 }
-function collectClaudeMcpConfigFiles(ctx, home) {
-  const files = [];
-  const pushIfFile = (candidate) => {
-    try {
-      if (existsSync3(candidate) && statSync(candidate).isFile()) {
-        files.push({ path: candidate });
-      }
-    } catch {
-    }
+function buildClaudeSpawnSpec(claudeCommand, platform = process.platform) {
+  const lowerClaudeCommand = claudeCommand?.toLowerCase();
+  const isBatchFile = Boolean(
+    platform === "win32" && lowerClaudeCommand && (lowerClaudeCommand.endsWith(".cmd") || lowerClaudeCommand.endsWith(".bat"))
+  );
+  return {
+    command: claudeCommand ?? "claude",
+    shell: platform === "win32" && (!claudeCommand || isBatchFile)
   };
-  pushIfFile(path4.join(home, ".claude.json"));
-  pushIfFile(path4.join(ctx.workingDirectory, ".mcp.json"));
-  const pluginRoot = path4.join(resolveClaudeConfigDir(ctx, home), "plugins");
-  try {
-    for (const entry of readdirSync(pluginRoot)) {
-      const pluginPath = path4.join(pluginRoot, entry);
-      const configPath = path4.join(pluginPath, ".mcp.json");
-      try {
-        if (existsSync3(configPath) && statSync(configPath).isFile()) {
-          files.push({
-            path: configPath,
-            vars: { CLAUDE_PLUGIN_ROOT: pluginPath }
-          });
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return files;
-}
-function buildClaudeUserMcpServers(ctx, home) {
-  const servers = /* @__PURE__ */ Object.create(null);
-  for (const configFile of collectClaudeMcpConfigFiles(ctx, home)) {
-    const mcpServers = readClaudeMcpServers(configFile.path, configFile.vars);
-    if (!mcpServers) continue;
-    for (const [name, server] of Object.entries(mcpServers)) {
-      if (!isRecord(server)) {
-        logger.warn(`[Claude] ignoring invalid MCP server "${name}" in ${configFile.path}`);
-        continue;
-      }
-      servers[name] = server;
-    }
-  }
-  return servers;
 }
+
+// src/drivers/claude.ts
 var ClaudeDriver = class {
   id = "claude";
   lifecycle = {
@@ -2469,7 +2799,7 @@ var ClaudeDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -2479,107 +2809,37 @@ var ClaudeDriver = class {
     toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
-  mcpToolPrefix = "mcp__chat__";
+  mcpToolPrefix = "";
   usesSlockCliForCommunication = true;
   // Claude Code supports same-turn steering, but raw stdin injection at an
   // arbitrary busy instant can collide with active signed thinking blocks. The
   // daemon therefore gates busy delivery on Claude stream-json boundaries.
   busyDeliveryMode = "gated";
   supportsNativeStandingPrompt = true;
+  eventNormalizer = new ClaudeEventNormalizer();
   probe() {
     return probeClaude();
   }
-  buildClaudeArgs(config, standingPrompt, opts = {}) {
-    const args = [
-      "--allow-dangerously-skip-permissions",
-      "--dangerously-skip-permissions",
-      "--verbose",
-      "--permission-mode",
-      "bypassPermissions",
-      "--output-format",
-      "stream-json",
-      "--input-format",
-      "stream-json",
-      "--model",
-      config.model || "sonnet",
-      "--disallowed-tools",
-      CLAUDE_DISALLOWED_TOOLS
-    ];
-    if (opts.standingPromptFilePath) {
-      args.push("--append-system-prompt-file", opts.standingPromptFilePath);
-    } else {
-      args.push("--append-system-prompt", standingPrompt);
-    }
-    if (config.sessionId) {
-      args.push("--resume", config.sessionId);
-    }
-    return args;
-  }
-  buildRuntimeActionsMcpServer(ctx) {
-    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
-    const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
-    return {
-      command,
-      args: [
-        ...bridgeArgs,
-        "--agent-id",
-        ctx.agentId,
-        "--server-url",
-        ctx.config.serverUrl,
-        "--auth-token",
-        ctx.config.authToken || ctx.daemonApiKey,
-        "--runtime",
-        this.id,
-        ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-        "--runtime-actions-only"
-      ]
-    };
-  }
-  buildRuntimeActionsMcpConfig(ctx, home = os2.homedir()) {
-    const userMcpServers = buildClaudeUserMcpServers(ctx, home);
-    if (Object.prototype.hasOwnProperty.call(userMcpServers, SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME)) {
-      logger.warn(
-        `[Agent ${ctx.agentId}] Claude user MCP server "${SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME}" is reserved by Slock runtime actions and will be ignored`
-      );
-    }
-    return JSON.stringify({
-      mcpServers: {
-        ...userMcpServers,
-        [SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME]: this.buildRuntimeActionsMcpServer(ctx)
-      }
-    });
-  }
-  writeClaudeLaunchFiles(ctx, slockDir, home = os2.homedir()) {
-    const systemPromptPath = path4.join(slockDir, CLAUDE_SYSTEM_PROMPT_FILE);
-    const mcpConfigPath = path4.join(slockDir, CLAUDE_MCP_CONFIG_FILE);
-    writeFileSync2(systemPromptPath, ctx.standingPrompt, { mode: 384 });
-    writeFileSync2(mcpConfigPath, this.buildRuntimeActionsMcpConfig(ctx, home), { mode: 384 });
-    return { systemPromptPath, mcpConfigPath };
+  buildClaudeArgs(config, opts) {
+    return buildClaudeArgs(config, opts);
   }
   async spawn(ctx) {
     const { slockDir, tokenFile, spawnEnv } = await prepareCliTransport(ctx);
-    const { systemPromptPath, mcpConfigPath } = this.writeClaudeLaunchFiles(ctx, slockDir);
-    const args = this.buildClaudeArgs(ctx.config, ctx.standingPrompt, {
+    const systemPromptPath = writeClaudeSystemPromptFile(ctx.standingPrompt, slockDir);
+    const args = this.buildClaudeArgs(ctx.config, {
       standingPromptFilePath: systemPromptPath
     });
-    args.push("--mcp-config", mcpConfigPath, "--strict-mcp-config");
     delete spawnEnv.CLAUDECODE;
     logger.info(
       `[Agent ${ctx.agentId}] transport=cli cli=${ctx.slockCliPath} token_file=${tokenFile}`
     );
     const claudeCommand = resolveClaudeCommand();
-    const isWindows = process.platform === "win32";
-    const lowerClaudeCommand = claudeCommand?.toLowerCase();
-    const isBatchFile = Boolean(
-      isWindows && lowerClaudeCommand && (lowerClaudeCommand.endsWith(".cmd") || lowerClaudeCommand.endsWith(".bat"))
-    );
-    const useShell = isWindows && (!claudeCommand || isBatchFile);
-    const proc = spawn(claudeCommand ?? "claude", args, {
+    const spawnSpec = buildClaudeSpawnSpec(claudeCommand);
+    const proc = spawn(spawnSpec.command, args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
-      shell: useShell
+      shell: spawnSpec.shell
     });
     const stdinMsg = JSON.stringify({
       type: "user",
@@ -2593,99 +2853,7 @@ var ClaudeDriver = class {
     return { process: proc };
   }
   parseLine(line) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      return [];
-    }
-    const events = [];
-    const pushResultError = (message, fallback) => {
-      const parts = [];
-      if (Array.isArray(message.errors)) {
-        for (const err of message.errors) {
-          if (typeof err === "string" && err.trim()) parts.push(err.trim());
-        }
-      }
-      if (typeof message.result === "string" && message.result.trim()) {
-        parts.push(message.result.trim());
-      }
-      const detail = parts.join(" | ") || fallback;
-      events.push({ kind: "error", message: detail });
-    };
-    const isProviderApiFailureText = (value, hasToolUse) => !hasToolUse && /^\s*API Error:/i.test(value) && (/\b(?:ECONNRESET|EPIPE|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(value) || /\bUnable to connect to API\b/i.test(value) || /\b(?:timed out|timeout)\b/i.test(value) || /\b5\d{2}\b/.test(value));
-    switch (event.type) {
-      case "system":
-        if (event.subtype === "init" && event.session_id) {
-          events.push({ kind: "session_init", sessionId: event.session_id });
-        }
-        if (event.subtype === "status" && event.status === "compacting") {
-          events.push({ kind: "compaction_started" });
-        }
-        if (event.subtype === "compact_boundary") {
-          events.push({ kind: "compaction_finished" });
-        }
-        break;
-      case "assistant": {
-        const content = event.message?.content;
-        if (Array.isArray(content)) {
-          const hasToolUse = content.some((block) => block?.type === "tool_use");
-          for (const block of content) {
-            if (block.type === "thinking" && block.thinking) {
-              events.push({ kind: "thinking", text: block.thinking });
-            } else if (block.type === "text" && block.text) {
-              if (isProviderApiFailureText(block.text, hasToolUse)) {
-                events.push({ kind: "error", message: block.text });
-              } else {
-                events.push({ kind: "text", text: block.text });
-              }
-            } else if (block.type === "tool_use") {
-              events.push({ kind: "tool_call", name: block.name || "unknown_tool", input: block.input });
-            }
-          }
-        }
-        break;
-      }
-      case "user": {
-        const content = event.message?.content;
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "tool_result") {
-              events.push({ kind: "tool_output", name: block.name || block.tool_use_id || "tool_result" });
-            }
-          }
-        }
-        break;
-      }
-      case "result": {
-        const subtype = typeof event.subtype === "string" ? event.subtype : "success";
-        const stopReason = typeof event.stop_reason === "string" ? event.stop_reason : null;
-        switch (subtype) {
-          case "success":
-            if (event.is_error && stopReason !== "max_tokens") {
-              pushResultError(event, "Execution failed");
-            }
-            break;
-          case "error_during_execution":
-            if (stopReason !== "max_tokens") {
-              pushResultError(event, "Execution failed");
-            }
-            break;
-          case "error_max_budget_usd":
-            pushResultError(event, "Budget limit exceeded");
-            break;
-          case "error_max_turns":
-            pushResultError(event, "Max turns exceeded");
-            break;
-          case "error_max_structured_output_retries":
-            pushResultError(event, "Structured output retries exceeded");
-            break;
-        }
-        events.push({ kind: "turn_end", sessionId: event.session_id });
-        break;
-      }
-    }
-    return events;
+    return this.eventNormalizer.normalizeLine(line);
   }
   encodeStdinMessage(text, sessionId, _opts) {
     return JSON.stringify({
@@ -2699,7 +2867,7 @@ var ClaudeDriver = class {
   }
   buildSystemPrompt(config, _agentId) {
     return buildCliTransportSystemPrompt(config, {
-      toolPrefix: "mcp__chat__",
+      toolPrefix: "",
       extraCriticalRules: [],
       postStartupNotes: [
         "**Claude runtime note:** While you are busy, Slock batches inbox-count notifications instead of injecting message content. Use `slock message check` at natural breakpoints to pull the pending messages before side-effect actions that depend on current context."
@@ -2712,9 +2880,117 @@ var ClaudeDriver = class {
 
 // src/drivers/codex.ts
 import { spawn as spawn2, execFileSync as execFileSync2, execSync } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import os3 from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import os2 from "os";
 import path5 from "path";
+
+// src/runtimeTurnState.ts
+var RuntimeTurnState = class {
+  currentTurnId = null;
+  /**
+   * Post-tool window where the app-server may not yet accept stdin steering.
+   * Gate busy-mode delivery until turn/completed or next progress.
+   */
+  steeringGateActive = false;
+  reset() {
+    this.currentTurnId = null;
+    this.steeringGateActive = false;
+  }
+  get activeTurnId() {
+    return this.currentTurnId;
+  }
+  get canSteerBusy() {
+    return Boolean(this.currentTurnId && !this.steeringGateActive);
+  }
+  markTurnStarted(turnId) {
+    if (turnId !== void 0 && turnId !== null) {
+      this.currentTurnId = turnId;
+    }
+    this.steeringGateActive = false;
+  }
+  adoptTurnId(turnId) {
+    this.currentTurnId = turnId;
+  }
+  markProgress() {
+    this.steeringGateActive = false;
+  }
+  markToolBoundary() {
+    this.steeringGateActive = true;
+  }
+  markTurnCompleted() {
+    this.currentTurnId = null;
+    this.steeringGateActive = false;
+  }
+};
+
+// src/drivers/codexTelemetrySidecar.ts
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function finiteString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function ratio(numerator, denominator) {
+  if (numerator === void 0 || denominator === void 0 || denominator <= 0) return void 0;
+  return Number((numerator / denominator).toFixed(6));
+}
+function withDefined(attrs) {
+  return Object.fromEntries(Object.entries(attrs).filter(([, value]) => value !== void 0));
+}
+function parseTokenUsageTelemetry(message) {
+  const usage = message.params?.tokenUsage;
+  const total = usage?.total;
+  if (!total || typeof total !== "object") return null;
+  const inputTokens = finiteNumber(total.inputTokens);
+  const cachedInputTokens = finiteNumber(total.cachedInputTokens);
+  const totalTokens = finiteNumber(total.totalTokens);
+  const modelContextWindow = finiteNumber(usage.modelContextWindow);
+  const attrs = withDefined({
+    totalTokens,
+    inputTokens,
+    cachedInputTokens,
+    outputTokens: finiteNumber(total.outputTokens),
+    reasoningOutputTokens: finiteNumber(total.reasoningOutputTokens),
+    modelContextWindow,
+    cachedInputRatio: ratio(cachedInputTokens, inputTokens),
+    contextUtilization: ratio(totalTokens, modelContextWindow)
+  });
+  if (Object.keys(attrs).length === 0) return null;
+  return { kind: "telemetry", name: "token_usage", attrs };
+}
+function parseRateLimitTelemetry(message) {
+  const rateLimits = message.params?.rateLimits;
+  const primary = rateLimits?.primary;
+  if (!rateLimits || typeof rateLimits !== "object" || !primary || typeof primary !== "object") return null;
+  const attrs = withDefined({
+    limitId: finiteString(rateLimits.limitId),
+    planType: finiteString(rateLimits.planType),
+    usedPercent: finiteNumber(primary.usedPercent),
+    windowDurationMins: finiteNumber(primary.windowDurationMins),
+    resetsAt: finiteNumber(primary.resetsAt)
+  });
+  if (Object.keys(attrs).length === 0) return null;
+  return { kind: "telemetry", name: "rate_limits", attrs };
+}
+function parseCodexTelemetryEvent(message) {
+  switch (message.method) {
+    case "thread/tokenUsage/updated":
+      return parseTokenUsageTelemetry(message);
+    case "account/rateLimits/updated":
+      return parseRateLimitTelemetry(message);
+    default:
+      return null;
+  }
+}
+
+// src/drivers/codexEventNormalizer.ts
+function parseCodexJsonRpcLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
 function getCodexNotificationErrorMessage(params) {
   const topLevelMessage = params?.message;
   if (typeof topLevelMessage === "string" && topLevelMessage.trim()) {
@@ -2726,8 +3002,248 @@ function getCodexNotificationErrorMessage(params) {
   }
   return null;
 }
+function joinReasoningText(item) {
+  const summary = Array.isArray(item.summary) ? item.summary.filter((entry) => typeof entry === "string") : [];
+  const content = Array.isArray(item.content) ? item.content.filter((entry) => typeof entry === "string") : [];
+  return [...summary, ...content].join("\n").trim();
+}
+function rawResponseItemProgressEvent(message) {
+  if (message.method !== "rawResponseItem/completed") return null;
+  const item = message.params?.item ?? message.params?.responseItem ?? message.params?.rawItem ?? message.params;
+  if (!item || typeof item !== "object") return null;
+  const itemType = typeof item.type === "string" ? item.type : void 0;
+  let payloadBytes;
+  try {
+    payloadBytes = Buffer.byteLength(JSON.stringify(item), "utf8");
+  } catch {
+    payloadBytes = void 0;
+  }
+  return {
+    kind: "internal_progress",
+    source: "codex_raw_response_item",
+    itemType,
+    payloadBytes
+  };
+}
+var CodexEventNormalizer = class {
+  mcpToolPrefix;
+  currentThreadId = null;
+  sessionAnnounced = false;
+  streamedAgentMessageIds = /* @__PURE__ */ new Set();
+  streamedReasoningIds = /* @__PURE__ */ new Set();
+  turnState = new RuntimeTurnState();
+  constructor(opts) {
+    this.mcpToolPrefix = opts.mcpToolPrefix;
+  }
+  reset(opts = {}) {
+    this.currentThreadId = opts.threadId ?? null;
+    this.turnState.reset();
+    this.sessionAnnounced = false;
+    this.streamedAgentMessageIds.clear();
+    this.streamedReasoningIds.clear();
+  }
+  get threadId() {
+    return this.currentThreadId;
+  }
+  get activeTurnId() {
+    return this.turnState.activeTurnId;
+  }
+  get canSteerBusy() {
+    return this.turnState.canSteerBusy;
+  }
+  adoptThreadId(threadId) {
+    this.currentThreadId = threadId;
+  }
+  normalizeMessage(message) {
+    const events = [];
+    if (message.result) {
+      const thread = message.result.thread;
+      if (thread && typeof thread.id === "string") {
+        return this.handleThreadReady(thread.id, events);
+      }
+      const turn = message.result.turn;
+      if (turn && typeof turn.id === "string") {
+        this.turnState.adoptTurnId(turn.id);
+        return { events };
+      }
+      if (typeof message.result.turnId === "string") {
+        this.turnState.adoptTurnId(message.result.turnId);
+        return { events };
+      }
+    }
+    if (message.error) {
+      events.push({ kind: "error", message: message.error.message || "Codex app-server request failed" });
+      return { events };
+    }
+    const telemetry = parseCodexTelemetryEvent(message);
+    if (telemetry) {
+      events.push(telemetry);
+      return { events };
+    }
+    const rawProgress = rawResponseItemProgressEvent(message);
+    if (rawProgress) {
+      events.push(rawProgress);
+      return { events };
+    }
+    switch (message.method) {
+      case "thread/started": {
+        const threadId = message.params?.thread?.id;
+        if (typeof threadId === "string") {
+          return this.handleThreadReady(threadId, events);
+        }
+        break;
+      }
+      case "turn/started": {
+        const turnId = message.params?.turn?.id;
+        this.turnState.markTurnStarted(typeof turnId === "string" ? turnId : null);
+        events.push({ kind: "thinking", text: "" });
+        break;
+      }
+      case "item/agentMessage/delta": {
+        const delta = message.params?.delta;
+        const itemId = message.params?.itemId;
+        if (typeof itemId === "string") {
+          this.streamedAgentMessageIds.add(itemId);
+        }
+        if (typeof delta === "string" && delta.length > 0) {
+          this.turnState.markProgress();
+          events.push({ kind: "text", text: delta });
+        }
+        break;
+      }
+      case "item/reasoning/summaryTextDelta":
+      case "item/reasoning/textDelta": {
+        const delta = message.params?.delta;
+        const itemId = message.params?.itemId;
+        if (typeof itemId === "string") {
+          this.streamedReasoningIds.add(itemId);
+        }
+        if (typeof delta === "string" && delta.length > 0) {
+          this.turnState.markProgress();
+          events.push({ kind: "thinking", text: delta });
+        }
+        break;
+      }
+      case "item/started":
+      case "item/completed": {
+        const item = message.params?.item;
+        if (!item || typeof item !== "object" || typeof item.type !== "string") break;
+        const itemType = item.type;
+        const isStarted = message.method === "item/started";
+        const isCompleted = message.method === "item/completed";
+        switch (itemType) {
+          case "reasoning":
+            if (isCompleted && typeof item.id === "string" && !this.streamedReasoningIds.has(item.id)) {
+              const text = joinReasoningText(item);
+              if (text) {
+                this.turnState.markProgress();
+                events.push({ kind: "thinking", text });
+              }
+            }
+            if (isCompleted && typeof item.id === "string") {
+              this.streamedReasoningIds.delete(item.id);
+            }
+            break;
+          case "agentMessage":
+            if (isCompleted && typeof item.id === "string" && !this.streamedAgentMessageIds.has(item.id) && typeof item.text === "string" && item.text.length > 0) {
+              this.turnState.markProgress();
+              events.push({ kind: "text", text: item.text });
+            }
+            if (isCompleted && typeof item.id === "string") {
+              this.streamedAgentMessageIds.delete(item.id);
+            }
+            break;
+          case "commandExecution":
+            if (isStarted && typeof item.command === "string") {
+              events.push({ kind: "tool_call", name: "shell", input: { command: item.command } });
+            }
+            if (isCompleted) {
+              events.push({ kind: "tool_output", name: "shell" });
+              this.turnState.markToolBoundary();
+            }
+            break;
+          case "contextCompaction":
+            if (isStarted) {
+              events.push({ kind: "compaction_started" });
+            }
+            if (isCompleted) {
+              events.push({ kind: "compaction_finished" });
+            }
+            break;
+          case "fileChange":
+            if (isStarted && Array.isArray(item.changes)) {
+              for (const change of item.changes) {
+                events.push({
+                  kind: "tool_call",
+                  name: "file_change",
+                  input: { path: change?.path, kind: change?.kind }
+                });
+              }
+            }
+            break;
+          case "mcpToolCall":
+            if (isStarted) {
+              const toolName = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}`;
+              events.push({ kind: "tool_call", name: toolName, input: item.arguments });
+            }
+            if (isCompleted) {
+              const toolName = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}`;
+              events.push({ kind: "tool_output", name: toolName });
+              this.turnState.markToolBoundary();
+            }
+            break;
+          case "collabAgentToolCall":
+            if (isStarted) {
+              events.push({ kind: "tool_call", name: "collab_tool_call", input: { tool: item.tool, prompt: item.prompt } });
+            }
+            if (isCompleted) {
+              this.turnState.markToolBoundary();
+            }
+            break;
+          case "webSearch":
+            if (isStarted) {
+              events.push({ kind: "tool_call", name: "web_search", input: { query: item.query } });
+            }
+            if (isCompleted) {
+              this.turnState.markToolBoundary();
+            }
+            break;
+        }
+        break;
+      }
+      case "turn/completed": {
+        const turn = message.params?.turn;
+        if (turn?.status === "failed" && turn?.error?.message) {
+          events.push({ kind: "error", message: turn.error.message });
+        }
+        this.turnState.markTurnCompleted();
+        this.streamedAgentMessageIds.clear();
+        this.streamedReasoningIds.clear();
+        events.push({ kind: "turn_end", sessionId: this.currentThreadId || void 0 });
+        break;
+      }
+      case "error":
+        events.push({
+          kind: "error",
+          message: getCodexNotificationErrorMessage(message.params) || "Unknown Codex app-server error"
+        });
+        break;
+    }
+    return { events };
+  }
+  handleThreadReady(threadId, events) {
+    this.currentThreadId = threadId;
+    if (!this.sessionAnnounced) {
+      events.push({ kind: "session_init", sessionId: threadId });
+      this.sessionAnnounced = true;
+    }
+    return { events, threadReady: threadId };
+  }
+};
+
+// src/drivers/codex.ts
 function ensureGitRepoForCodex(workingDirectory, deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync4;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   const execSyncFn = deps.execSyncFn ?? execSync;
   const gitDir = path5.join(workingDirectory, ".git");
   if (existsSyncFn(gitDir)) return;
@@ -2745,7 +3261,7 @@ function isWindowsSandboxRunner(commandPath) {
   return path5.basename(commandPath).toLowerCase().startsWith("codex-command-runner");
 }
 function resolveWindowsNpmCodexEntry(deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync4;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync2;
   const env = deps.env ?? process.env;
   const winPath = path5.win32;
@@ -2767,7 +3283,7 @@ function resolveWindowsNpmCodexEntry(deps = {}) {
   return null;
 }
 function resolveWindowsCodexDesktopEntry(deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync4;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   const env = deps.env ?? process.env;
   const homeDir = deps.homeDir;
   const winPath = path5.win32;
@@ -2839,11 +3355,6 @@ function resolveCodexSpawn(commandArgs, deps = {}) {
     "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."
   );
 }
-function joinReasoningText(item) {
-  const summary = Array.isArray(item.summary) ? item.summary.filter((entry) => typeof entry === "string") : [];
-  const content = Array.isArray(item.content) ? item.content.filter((entry) => typeof entry === "string") : [];
-  return [...summary, ...content].join("\n").trim();
-}
 var CodexDriver = class {
   id = "codex";
   lifecycle = {
@@ -2919,13 +3430,20 @@ var CodexDriver = class {
       cwd: ctx.workingDirectory,
       approvalPolicy: "never",
       sandbox: "danger-full-access",
-      developerInstructions: ctx.standingPrompt
+      developerInstructions: ctx.standingPrompt,
+      // Raw response items are used only as payload-free liveness signals in
+      // the daemon. They replace the previous transcript-mtime heuristic.
+      experimentalRawEvents: true
     };
-    if (ctx.config.model) {
-      threadParams.model = ctx.config.model;
+    const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+    if (launchRuntimeFields.model) {
+      threadParams.model = launchRuntimeFields.model;
     }
-    if (ctx.config.reasoningEffort) {
-      threadParams.config = { model_reasoning_effort: ctx.config.reasoningEffort };
+    if (launchRuntimeFields.reasoningEffort) {
+      threadParams.config = { model_reasoning_effort: launchRuntimeFields.reasoningEffort };
+    }
+    if (launchRuntimeFields.mode.kind === "fast") {
+      threadParams.serviceTier = "priority";
     }
     if (ctx.config.sessionId) {
       return {
@@ -2943,35 +3461,21 @@ var CodexDriver = class {
   }
   process = null;
   requestId = 0;
-  threadId = null;
-  activeTurnId = null;
   pendingInitialPrompt = null;
   initializeRequestId = null;
   pendingThreadRequest = null;
   initialTurnStarted = false;
-  sessionAnnounced = false;
-  streamedAgentMessageIds = /* @__PURE__ */ new Set();
-  streamedReasoningIds = /* @__PURE__ */ new Set();
-  /**
-   * Post-tool window where the app-server may not yet accept stdin steering.
-   * Gate busy-mode delivery until turn/completed or next progress.
-   */
-  steeringGateActive = false;
+  normalizer = new CodexEventNormalizer({ mcpToolPrefix: this.mcpToolPrefix });
   async spawn(ctx) {
     ensureGitRepoForCodex(ctx.workingDirectory);
     const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
     this.process = null;
     this.requestId = 0;
-    this.threadId = ctx.config.sessionId || null;
-    this.activeTurnId = null;
     this.pendingInitialPrompt = ctx.prompt;
     this.initializeRequestId = null;
     this.pendingThreadRequest = null;
     this.initialTurnStarted = false;
-    this.sessionAnnounced = false;
-    this.streamedAgentMessageIds.clear();
-    this.streamedReasoningIds.clear();
-    this.steeringGateActive = false;
+    this.normalizer.reset({ threadId: ctx.config.sessionId || null });
     const args = ["app-server", "--listen", "stdio://"];
     args.push(...this.buildRuntimeActionsConfigArgs(ctx));
     const { command, args: spawnArgs } = resolveCodexSpawn(args);
@@ -2992,10 +3496,8 @@ var CodexDriver = class {
     return { process: proc };
   }
   parseLine(line) {
-    let message;
-    try {
-      message = JSON.parse(line);
-    } catch {
+    const message = parseCodexJsonRpcLine(line);
+    if (!message) {
       return [];
     }
     const events = [];
@@ -3009,194 +3511,34 @@ var CodexDriver = class {
         }
         return events;
       }
-      const thread = message.result.thread;
-      if (thread && typeof thread.id === "string") {
-        this.handleThreadReady(thread.id, events);
-        return events;
-      }
-      const turn = message.result.turn;
-      if (turn && typeof turn.id === "string") {
-        this.activeTurnId = turn.id;
-        return events;
-      }
-      if (typeof message.result.turnId === "string") {
-        this.activeTurnId = message.result.turnId;
-        return events;
-      }
     }
-    if (message.error) {
-      if (message.id === this.initializeRequestId) {
-        this.initializeRequestId = null;
-        this.pendingThreadRequest = null;
-      }
+    if (message.error && message.id === this.initializeRequestId) {
+      this.initializeRequestId = null;
+      this.pendingThreadRequest = null;
       events.push({ kind: "error", message: message.error.message || "Codex app-server request failed" });
       return events;
     }
-    switch (message.method) {
-      case "thread/started": {
-        const threadId = message.params?.thread?.id;
-        if (typeof threadId === "string") {
-          this.handleThreadReady(threadId, events);
-        }
-        break;
-      }
-      case "turn/started": {
-        const turnId = message.params?.turn?.id;
-        if (typeof turnId === "string") {
-          this.activeTurnId = turnId;
-        }
-        this.steeringGateActive = false;
-        events.push({ kind: "thinking", text: "" });
-        break;
-      }
-      case "item/agentMessage/delta": {
-        const delta = message.params?.delta;
-        const itemId = message.params?.itemId;
-        if (typeof itemId === "string") {
-          this.streamedAgentMessageIds.add(itemId);
-        }
-        if (typeof delta === "string" && delta.length > 0) {
-          this.steeringGateActive = false;
-          events.push({ kind: "text", text: delta });
-        }
-        break;
-      }
-      case "item/reasoning/summaryTextDelta":
-      case "item/reasoning/textDelta": {
-        const delta = message.params?.delta;
-        const itemId = message.params?.itemId;
-        if (typeof itemId === "string") {
-          this.streamedReasoningIds.add(itemId);
-        }
-        if (typeof delta === "string" && delta.length > 0) {
-          this.steeringGateActive = false;
-          events.push({ kind: "thinking", text: delta });
-        }
-        break;
-      }
-      case "item/started":
-      case "item/completed": {
-        const item = message.params?.item;
-        if (!item || typeof item !== "object" || typeof item.type !== "string") break;
-        const itemType = item.type;
-        const isStarted = message.method === "item/started";
-        const isCompleted = message.method === "item/completed";
-        switch (itemType) {
-          case "reasoning":
-            if (isCompleted && typeof item.id === "string" && !this.streamedReasoningIds.has(item.id)) {
-              const text = joinReasoningText(item);
-              if (text) {
-                this.steeringGateActive = false;
-                events.push({ kind: "thinking", text });
-              }
-            }
-            if (isCompleted && typeof item.id === "string") {
-              this.streamedReasoningIds.delete(item.id);
-            }
-            break;
-          case "agentMessage":
-            if (isCompleted && typeof item.id === "string" && !this.streamedAgentMessageIds.has(item.id) && typeof item.text === "string" && item.text.length > 0) {
-              this.steeringGateActive = false;
-              events.push({ kind: "text", text: item.text });
-            }
-            if (isCompleted && typeof item.id === "string") {
-              this.streamedAgentMessageIds.delete(item.id);
-            }
-            break;
-          case "commandExecution":
-            if (isStarted && typeof item.command === "string") {
-              events.push({ kind: "tool_call", name: "shell", input: { command: item.command } });
-            }
-            if (isCompleted) {
-              events.push({ kind: "tool_output", name: "shell" });
-              this.steeringGateActive = true;
-            }
-            break;
-          case "contextCompaction":
-            if (isStarted) {
-              events.push({ kind: "compaction_started" });
-            }
-            if (isCompleted) {
-              events.push({ kind: "compaction_finished" });
-            }
-            break;
-          case "fileChange":
-            if (isStarted && Array.isArray(item.changes)) {
-              for (const change of item.changes) {
-                events.push({
-                  kind: "tool_call",
-                  name: "file_change",
-                  input: { path: change?.path, kind: change?.kind }
-                });
-              }
-            }
-            break;
-          case "mcpToolCall":
-            if (isStarted) {
-              const toolName = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}`;
-              events.push({ kind: "tool_call", name: toolName, input: item.arguments });
-            }
-            if (isCompleted) {
-              const toolName = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}`;
-              events.push({ kind: "tool_output", name: toolName });
-              this.steeringGateActive = true;
-            }
-            break;
-          case "collabAgentToolCall":
-            if (isStarted) {
-              events.push({ kind: "tool_call", name: "collab_tool_call", input: { tool: item.tool, prompt: item.prompt } });
-            }
-            if (isCompleted) {
-              this.steeringGateActive = true;
-            }
-            break;
-          case "webSearch":
-            if (isStarted) {
-              events.push({ kind: "tool_call", name: "web_search", input: { query: item.query } });
-            }
-            if (isCompleted) {
-              this.steeringGateActive = true;
-            }
-            break;
-        }
-        break;
-      }
-      case "turn/completed": {
-        const turn = message.params?.turn;
-        if (turn?.status === "failed" && turn?.error?.message) {
-          events.push({ kind: "error", message: turn.error.message });
-        }
-        this.activeTurnId = null;
-        this.streamedAgentMessageIds.clear();
-        this.streamedReasoningIds.clear();
-        this.steeringGateActive = false;
-        events.push({ kind: "turn_end", sessionId: this.threadId || void 0 });
-        break;
-      }
-      case "error":
-        events.push({
-          kind: "error",
-          message: getCodexNotificationErrorMessage(message.params) || "Unknown Codex app-server error"
-        });
-        break;
+    const result = this.normalizer.normalizeMessage(message);
+    if (result.threadReady) {
+      this.startInitialTurn();
     }
-    return events;
+    return result.events;
   }
   encodeStdinMessage(text, sessionId, opts) {
-    if (!this.threadId && sessionId) {
-      this.threadId = sessionId;
+    if (!this.normalizer.threadId && sessionId) {
+      this.normalizer.adoptThreadId(sessionId);
     }
-    if (!this.threadId) return null;
+    if (!this.normalizer.threadId) return null;
     const mode = opts?.mode || "busy";
     if (mode === "busy") {
-      if (!this.activeTurnId || this.steeringGateActive) return null;
+      if (!this.normalizer.canSteerBusy) return null;
       return JSON.stringify({
         jsonrpc: "2.0",
         id: this.nextRequestId(),
         method: "turn/steer",
         params: {
-          threadId: this.threadId,
-          expectedTurnId: this.activeTurnId,
+          threadId: this.normalizer.threadId,
+          expectedTurnId: this.normalizer.activeTurnId,
           input: [{ type: "text", text }]
         }
       });
@@ -3206,7 +3548,7 @@ var CodexDriver = class {
       id: this.nextRequestId(),
       method: "turn/start",
       params: {
-        threadId: this.threadId,
+        threadId: this.normalizer.threadId,
         input: [{ type: "text", text }]
       }
     });
@@ -3226,21 +3568,13 @@ var CodexDriver = class {
     this.requestId += 1;
     return this.requestId;
   }
-  handleThreadReady(threadId, events) {
-    this.threadId = threadId;
-    if (!this.sessionAnnounced) {
-      events.push({ kind: "session_init", sessionId: threadId });
-      this.sessionAnnounced = true;
-    }
-    this.startInitialTurn();
-  }
   startInitialTurn() {
-    if (this.initialTurnStarted || !this.pendingInitialPrompt || !this.threadId) return;
+    if (this.initialTurnStarted || !this.pendingInitialPrompt || !this.normalizer.threadId) return;
     this.initialTurnStarted = true;
     const prompt = this.pendingInitialPrompt;
     this.pendingInitialPrompt = null;
     this.sendRequest("turn/start", {
-      threadId: this.threadId,
+      threadId: this.normalizer.threadId,
       input: [{ type: "text", text: prompt }]
     });
   }
@@ -3265,12 +3599,12 @@ var CodexDriver = class {
     return detectCodexModels();
   }
 };
-function detectCodexModels(home = os3.homedir()) {
+function detectCodexModels(home = os2.homedir()) {
   const cachePath = path5.join(home, ".codex", "models_cache.json");
   const configPath = path5.join(home, ".codex", "config.toml");
   let models = [];
   try {
-    const raw = readFileSync3(cachePath, "utf8");
+    const raw = readFileSync2(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     const entries = Array.isArray(parsed?.models) ? parsed.models : [];
     for (const entry of entries) {
@@ -3287,7 +3621,7 @@ function detectCodexModels(home = os3.homedir()) {
   if (models.length === 0) return null;
   let defaultModel;
   try {
-    const raw = readFileSync3(configPath, "utf8");
+    const raw = readFileSync2(configPath, "utf8");
     const match = raw.match(/^\s*model\s*=\s*"([^"]+)"/m);
     if (match) defaultModel = match[1];
   } catch {
@@ -3318,7 +3652,7 @@ function buildAntigravityArgs(ctx) {
   const args = [
     "--print",
     "--print-timeout",
-    ctx.config.envVars?.ANTIGRAVITY_PRINT_TIMEOUT || DEFAULT_PRINT_TIMEOUT,
+    runtimeConfigToLaunchFields(ctx.config).envVars?.ANTIGRAVITY_PRINT_TIMEOUT || DEFAULT_PRINT_TIMEOUT,
     "--dangerously-skip-permissions"
   ];
   if (ctx.config.sessionId) {
@@ -3497,11 +3831,12 @@ var CopilotDriver = class {
       "-p",
       ctx.prompt
     ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
+    const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+    if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
+      args.push("--model", launchRuntimeFields.model);
     }
-    if (ctx.config.reasoningEffort) {
-      args.push("--effort", ctx.config.reasoningEffort);
+    if (launchRuntimeFields.reasoningEffort) {
+      args.push("--effort", launchRuntimeFields.reasoningEffort);
     }
     if (ctx.config.sessionId) {
       args.push(`--resume=${ctx.config.sessionId}`);
@@ -3601,7 +3936,7 @@ var CopilotDriver = class {
 
 // src/drivers/cursor.ts
 import { spawn as spawn5, spawnSync } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
 import path7 from "path";
 async function buildCursorSpawnEnv(ctx, deps = {}) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" });
@@ -3657,7 +3992,7 @@ var CursorDriver = class {
   }
   async spawn(ctx) {
     const cursorDir = path7.join(ctx.workingDirectory, ".cursor");
-    if (!existsSync5(cursorDir)) {
+    if (!existsSync4(cursorDir)) {
       mkdirSync2(cursorDir, { recursive: true });
     }
     const mcpConfigPath = path7.join(cursorDir, "mcp.json");
@@ -3670,8 +4005,9 @@ var CursorDriver = class {
       "--approve-mcps",
       "--trust"
     ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
+    const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+    if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
+      args.push("--model", launchRuntimeFields.model);
     }
     if (ctx.config.sessionId) {
       args.push("--resume", ctx.config.sessionId);
@@ -3790,11 +4126,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return withWindowsUserEnvironment({
+  return scrubDaemonChildEnv(withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps);
+  }, deps));
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -3806,14 +4142,15 @@ function runCursorModelsCommand() {
 
 // src/drivers/gemini.ts
 import { execFileSync as execFileSync3, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import path8 from "path";
 async function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   const { spawnEnv } = await prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
-  if (!Object.prototype.hasOwnProperty.call(ctx.config.envVars ?? {}, "GEMINI_CLI_TRUST_WORKSPACE")) {
+  const launchEnvVars = runtimeConfigToLaunchFields(ctx.config).envVars;
+  if (!Object.prototype.hasOwnProperty.call(launchEnvVars ?? {}, "GEMINI_CLI_TRUST_WORKSPACE")) {
     spawnEnv.GEMINI_CLI_TRUST_WORKSPACE = "true";
   }
-  if (platform === "win32" && !Object.prototype.hasOwnProperty.call(ctx.config.envVars ?? {}, "GEMINI_PTY_INFO")) {
+  if (platform === "win32" && !Object.prototype.hasOwnProperty.call(launchEnvVars ?? {}, "GEMINI_PTY_INFO")) {
     spawnEnv.GEMINI_PTY_INFO = "child_process";
   }
   return spawnEnv;
@@ -3833,8 +4170,9 @@ function buildGeminiArgs(config) {
     "-p",
     ""
   ];
-  if (config.model && config.model !== "default") {
-    args.push("--model", config.model);
+  const launchRuntimeFields = runtimeConfigToLaunchFields(config);
+  if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
+    args.push("--model", launchRuntimeFields.model);
   }
   if (config.sessionId) {
     args.push("--resume", config.sessionId);
@@ -3847,8 +4185,8 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
     return { command: resolveCommandOnPath("gemini", deps) ?? "gemini", args: commandArgs };
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
-  const existsSyncFn = deps.existsSyncFn ?? existsSync6;
-  const env = deps.env ?? process.env;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync5;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -4020,13 +4358,16 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync6 } from "fs";
-import os4 from "os";
+import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import os3 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";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -4035,6 +4376,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os3.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return scrubDaemonChildEnv(spawnEnv);
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -4058,7 +4466,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -4094,7 +4520,7 @@ var KimiDriver = class {
     const systemPromptPath = path9.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
     const agentFilePath = path9.join(ctx.workingDirectory, KIMI_AGENT_FILE);
     const mcpConfigPath = path9.join(ctx.workingDirectory, KIMI_MCP_FILE);
-    if (!isResume || !existsSync7(systemPromptPath)) {
+    if (!isResume || !existsSync6(systemPromptPath)) {
       writeFileSync6(systemPromptPath, ctx.prompt, "utf8");
     }
     writeFileSync6(agentFilePath, [
@@ -4112,6 +4538,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -4120,14 +4547,16 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
+    const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+    if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
+      args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const launch = resolveKimiSpawn(args);
-    const proc = spawn7(launch.command, launch.args, {
+    const spawnTarget = resolveKimiSpawn(args);
+    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -4135,7 +4564,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: launch.shell
+      shell: spawnTarget.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -4249,14 +4678,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path9.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync4(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os3.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -4277,8 +4701,8 @@ function detectKimiModels(home = os4.homedir()) {
 
 // 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 { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import os4 from "os";
 import path10 from "path";
 var CHAT_MCP_SERVER_NAME = "chat";
 var CHAT_MCP_TOOL_PREFIX = `${CHAT_MCP_SERVER_NAME}_`;
@@ -4323,13 +4747,13 @@ function parseOpenCodeConfigContent(raw) {
   return {};
 }
 function parseUserOpenCodeConfig(ctx) {
-  const raw = ctx.config.envVars?.OPENCODE_CONFIG_CONTENT;
+  const raw = runtimeConfigToLaunchFields(ctx.config).envVars?.OPENCODE_CONFIG_CONTENT;
   return parseOpenCodeConfigContent(raw);
 }
-function readLocalOpenCodeConfig(home = os5.homedir()) {
+function readLocalOpenCodeConfig(home = os4.homedir()) {
   const configPath = path10.join(home, ".config", "opencode", "opencode.json");
   try {
-    return parseOpenCodeConfigContent(readFileSync5(configPath, "utf8"));
+    return parseOpenCodeConfigContent(readFileSync4(configPath, "utf8"));
   } catch {
   }
   return {};
@@ -4387,7 +4811,7 @@ function mergeOpenCodeConfigs(localConfig, envConfig) {
     }
   };
 }
-function buildOpenCodeConfig(ctx, home = os5.homedir()) {
+function buildOpenCodeConfig(ctx, home = os4.homedir()) {
   const userConfig = mergeOpenCodeConfigs(readLocalOpenCodeConfig(home), parseUserOpenCodeConfig(ctx));
   const userAgents = recordField(userConfig.agent);
   const userSlockAgent = recordField(userAgents[SLOCK_AGENT_NAME]);
@@ -4412,7 +4836,7 @@ function buildOpenCodeConfig(ctx, home = os5.homedir()) {
     }
   };
 }
-async function buildOpenCodeLaunchOptions(ctx, home = os5.homedir(), version = null) {
+async function buildOpenCodeLaunchOptions(ctx, home = os4.homedir(), version = null) {
   const slock = await prepareCliTransport(ctx, { NO_COLOR: "1" });
   const config = buildOpenCodeConfig(ctx, home);
   const env = {
@@ -4428,8 +4852,9 @@ async function buildOpenCodeLaunchOptions(ctx, home = os5.homedir(), version = n
     "--dir",
     ctx.workingDirectory
   ];
-  if (ctx.config.model && ctx.config.model !== "default") {
-    args.push("--model", ctx.config.model);
+  const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+  if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
+    args.push("--model", launchRuntimeFields.model);
   }
   if (requiresAgentCliFlag(version)) {
     args.push("--agent", SLOCK_AGENT_NAME);
@@ -4510,7 +4935,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 = os4.homedir(), runCommand = runOpenCodeModelsCommand) {
   const commandResult = runCommand(home);
   if (commandResult.error || commandResult.status !== 0) return null;
   return parseOpenCodeModelsOutput(commandResult.stdout);
@@ -4519,7 +4944,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -4550,7 +4975,7 @@ function openCodeSpecForEntry(entry, commandArgs) {
   return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
 }
 function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync8;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync7;
   const execFileSyncFn = deps.execFileSyncFn;
   const env = deps.env ?? process.env;
   const winPath = path10.win32;
@@ -4580,7 +5005,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
 }
 function extractWindowsShimTargets(commandPath, deps = {}) {
   if (!isWindowsCommandShim(commandPath)) return [];
-  const readFileSyncFn = deps.readFileSyncFn ?? readFileSync5;
+  const readFileSyncFn = deps.readFileSyncFn ?? readFileSync4;
   const commandDir = path10.win32.dirname(commandPath);
   let raw;
   try {
@@ -4714,7 +5139,7 @@ var OpenCodeDriver = class {
     if (unsupportedMessage) {
       throw new Error(unsupportedMessage);
     }
-    const launch = await buildOpenCodeLaunchOptions(ctx, os5.homedir(), version);
+    const launch = await buildOpenCodeLaunchOptions(ctx, os4.homedir(), version);
     const spawnSpec = resolveOpenCodeSpawn(launch.args);
     const proc = spawn8(spawnSpec.command, spawnSpec.args, {
       cwd: ctx.workingDirectory,
@@ -4778,6 +5203,297 @@ var OpenCodeDriver = class {
   }
 };
 
+// src/drivers/pi.ts
+import { spawn as spawn9 } from "child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7 } from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+import { getAgentDir, VERSION as PI_SDK_VERSION } from "@earendil-works/pi-coding-agent";
+var CHAT_MCP_TOOL_PREFIX2 = "chat_";
+var NO_MESSAGE_PROMPT2 = "No new messages are pending. Stop now.";
+var FIRST_MESSAGE_TASK_PREFIX2 = "First message task (system-triggered):";
+var MIN_SUPPORTED_PI_VERSION = "0.74.0";
+function parseSemver2(version) {
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isSupportedPiVersion(version) {
+  if (!version) return true;
+  const actual = parseSemver2(version);
+  const minimum = parseSemver2(MIN_SUPPORTED_PI_VERSION);
+  if (!actual || !minimum) return true;
+  for (let i = 0; i < 3; i += 1) {
+    if (actual[i] > minimum[i]) return true;
+    if (actual[i] < minimum[i]) return false;
+  }
+  return true;
+}
+function unsupportedPiVersionMessage(version) {
+  if (!version || isSupportedPiVersion(version)) return null;
+  return `Pi SDK ${version} is unsupported; requires @earendil-works/pi-coding-agent >= ${MIN_SUPPORTED_PI_VERSION}. Upgrade the daemon Pi dependency before starting this runtime.`;
+}
+function probePi(version = PI_SDK_VERSION) {
+  const unsupportedMessage = unsupportedPiVersionMessage(version);
+  if (unsupportedMessage) {
+    return {
+      available: false,
+      version: `${version} (requires @earendil-works/pi-coding-agent >= ${MIN_SUPPORTED_PI_VERSION})`
+    };
+  }
+  return { available: true, version };
+}
+function resolvePiSdkRunnerPath(moduleUrl = import.meta.url) {
+  const moduleDir = path11.dirname(fileURLToPath(moduleUrl));
+  const sourceSibling = path11.join(moduleDir, "piSdkRunner.ts");
+  if (existsSync8(sourceSibling)) return sourceSibling;
+  const bundledEntry = path11.join(moduleDir, "drivers", "piSdkRunner.js");
+  if (existsSync8(bundledEntry)) return bundledEntry;
+  return path11.join(moduleDir, "piSdkRunner.js");
+}
+function buildPiSdkNodeArgs(runnerPath = resolvePiSdkRunnerPath()) {
+  if (runnerPath.endsWith(".ts")) {
+    return [...process.execArgv, runnerPath];
+  }
+  return [runnerPath];
+}
+async function buildPiLaunchOptions(ctx, opts = {}) {
+  const command = opts.command ?? process.execPath;
+  const piDir = path11.join(ctx.workingDirectory, ".slock", "pi");
+  const sessionDir = path11.join(piDir, "sessions");
+  mkdirSync4(sessionDir, { recursive: true });
+  const slock = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+  const runnerPath = opts.runnerPath ?? resolvePiSdkRunnerPath();
+  const agentDir = opts.agentDir ?? getAgentDir();
+  const runnerConfigPath = path11.join(
+    piDir,
+    `sdk-run-${(ctx.launchId || "launch").replace(/[^a-zA-Z0-9_.-]/g, "_")}.json`
+  );
+  const turnPrompt = ctx.prompt === ctx.standingPrompt ? NO_MESSAGE_PROMPT2 : ctx.prompt;
+  const runnerConfig = {
+    cwd: ctx.workingDirectory,
+    agentDir,
+    sessionDir,
+    sessionId: ctx.config.sessionId || null,
+    standingPrompt: ctx.standingPrompt,
+    prompt: turnPrompt,
+    model: ctx.config.model && ctx.config.model !== "default" ? ctx.config.model : null
+  };
+  writeFileSync7(runnerConfigPath, `${JSON.stringify(runnerConfig)}
+`, { encoding: "utf8", mode: 384 });
+  const args = [
+    ...buildPiSdkNodeArgs(runnerPath),
+    "--config",
+    runnerConfigPath
+  ];
+  return {
+    command,
+    args,
+    env: slock.spawnEnv,
+    sessionDir,
+    agentDir,
+    runnerConfigPath,
+    sdkVersion: PI_SDK_VERSION
+  };
+}
+function isSystemFirstMessageTask2(message) {
+  return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX2);
+}
+function buildPiSystemPrompt(config) {
+  return buildCliTransportSystemPrompt(config, {
+    toolPrefix: CHAT_MCP_TOOL_PREFIX2,
+    extraCriticalRules: [
+      "- Runtime Profile migration controls are not available in the Pi runtime yet. If asked to acknowledge a runtime migration, explain the blocker instead of inventing a command."
+    ],
+    postStartupNotes: [
+      "**Pi runtime note:** Slock launches you as a per-turn process. Complete the current wake using `slock` CLI commands, then stop; the daemon will restart you when new messages arrive."
+    ],
+    includeStdinNotificationSection: false,
+    messageNotificationStyle: "poll"
+  });
+}
+function contentText(content) {
+  if (!content) return "";
+  const chunks = [];
+  for (const item of content) {
+    if (item.type === "text" && typeof item.text === "string") {
+      chunks.push(item.text);
+    }
+  }
+  return chunks.join("");
+}
+function apiKeyErrorMessage(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  if (/no api key found/i.test(trimmed)) return trimmed;
+  if (/api key.+required/i.test(trimmed)) return trimmed;
+  if (/no models available/i.test(trimmed)) return trimmed;
+  return null;
+}
+var PiDriver = class {
+  id = "pi";
+  lifecycle = {
+    kind: "per_turn",
+    start: "defer_until_concrete_message",
+    exit: "terminate_on_turn_end",
+    inFlightWake: "coalesce_into_pending"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: async (modelId, ctx) => {
+      if (!ctx) return modelId && modelId !== "default" ? { args: ["--model", modelId] } : { args: [] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = await buildPiLaunchOptions(launchCtx);
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: [launch.runnerConfigPath],
+        params: {
+          agentDir: launch.agentDir,
+          sessionDir: launch.sessionDir,
+          sdkVersion: launch.sdkVersion,
+          resources: "extensions/skills/prompt-templates/themes/context-files disabled by Slock policy"
+        }
+      };
+    }
+  };
+  supportsStdinNotification = false;
+  mcpToolPrefix = CHAT_MCP_TOOL_PREFIX2;
+  busyDeliveryMode = "none";
+  terminateProcessOnTurnEnd = true;
+  deferSpawnUntilMessage = true;
+  usesSlockCliForCommunication = true;
+  sessionId = null;
+  sessionAnnounced = false;
+  apiKeyErrorAnnounced = false;
+  turnEnded = false;
+  assistantTextByMessageId = /* @__PURE__ */ new Map();
+  shouldDeferWakeMessage(message) {
+    return isSystemFirstMessageTask2(message);
+  }
+  probe() {
+    return probePi();
+  }
+  async detectModels() {
+    return null;
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    this.apiKeyErrorAnnounced = false;
+    this.turnEnded = false;
+    this.assistantTextByMessageId.clear();
+    const unsupportedMessage = unsupportedPiVersionMessage(PI_SDK_VERSION);
+    if (unsupportedMessage) throw new Error(unsupportedMessage);
+    const launch = await buildPiLaunchOptions(ctx);
+    const proc = spawn9(launch.command, launch.args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: launch.env,
+      shell: false
+    });
+    proc.stdin?.end();
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      if (this.apiKeyErrorAnnounced) return [];
+      const message = apiKeyErrorMessage(line);
+      if (!message) return [];
+      this.apiKeyErrorAnnounced = true;
+      this.turnEnded = true;
+      return [
+        { kind: "error", message },
+        { kind: "turn_end", sessionId: this.sessionId || void 0 }
+      ];
+    }
+    const events = [];
+    if (event.type === "session" && event.id) {
+      this.sessionId = event.id;
+    }
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    switch (event.type) {
+      case "agent_start":
+      case "turn_start":
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "message_update":
+      case "message_end":
+        if (event.message?.role === "assistant") {
+          const key = event.message.id || "current";
+          const currentText = contentText(event.message.content);
+          const previousText = this.assistantTextByMessageId.get(key) ?? "";
+          if (currentText.length > previousText.length && currentText.startsWith(previousText)) {
+            events.push({ kind: "text", text: currentText.slice(previousText.length) });
+          } else if (currentText && currentText !== previousText) {
+            events.push({ kind: "text", text: currentText });
+          }
+          this.assistantTextByMessageId.set(key, currentText);
+          if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
+            events.push({ kind: "error", message: event.message.errorMessage || `Request ${event.message.stopReason}` });
+          }
+        }
+        break;
+      case "tool_execution_start":
+        events.push({
+          kind: "tool_call",
+          name: event.toolName || "unknown_tool",
+          input: event.args
+        });
+        break;
+      case "tool_execution_end":
+        events.push({
+          kind: "tool_output",
+          name: event.toolName || "unknown_tool"
+        });
+        if (event.isError) {
+          events.push({ kind: "error", message: `Pi tool ${event.toolName || "unknown_tool"} failed` });
+        }
+        break;
+      case "compaction_start":
+        events.push({ kind: "compaction_started" });
+        break;
+      case "compaction_end":
+        events.push({ kind: "compaction_finished" });
+        if (event.errorMessage) events.push({ kind: "error", message: event.errorMessage });
+        break;
+      case "turn_end":
+      case "agent_end":
+        if (!this.turnEnded) {
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+          this.turnEnded = true;
+        }
+        break;
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildPiSystemPrompt(config);
+  }
+};
+
 // src/drivers/index.ts
 var driverFactories = {
   claude: () => new ClaudeDriver(),
@@ -4787,7 +5503,8 @@ var driverFactories = {
   cursor: () => new CursorDriver(),
   gemini: () => new GeminiDriver(),
   kimi: () => new KimiDriver(),
-  opencode: () => new OpenCodeDriver()
+  opencode: () => new OpenCodeDriver(),
+  pi: () => new PiDriver()
 };
 function getDriver(runtimeId) {
   const createDriver = driverFactories[runtimeId];
@@ -4800,7 +5517,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -4808,7 +5525,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path11.join(dataDir, directoryName);
+  return path12.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -4857,7 +5574,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path11.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path12.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -4876,7 +5593,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path11.join(dataDir, entry.name);
+      const dirPath = path12.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -5079,6 +5796,87 @@ function redactUrlQuery(value) {
   }
 }
 
+// src/runtimeProgressState.ts
+var RuntimeProgressState = class {
+  lastEventAtMs;
+  lastEventKindValue = null;
+  staleSinceMs = null;
+  constructor(nowMs = Date.now()) {
+    this.lastEventAtMs = nowMs;
+  }
+  get lastEventAt() {
+    return this.lastEventAtMs;
+  }
+  get lastEventKind() {
+    return this.lastEventKindValue;
+  }
+  get staleSince() {
+    return this.staleSinceMs;
+  }
+  get isStale() {
+    return this.staleSinceMs !== null;
+  }
+  ageMs(nowMs = Date.now()) {
+    return nowMs - this.lastEventAtMs;
+  }
+  noteRuntimeEvent(eventKind, nowMs = Date.now()) {
+    this.lastEventAtMs = nowMs;
+    this.lastEventKindValue = eventKind ?? null;
+    this.staleSinceMs = null;
+  }
+  noteInternalProgress(observedAtMs = Date.now()) {
+    this.lastEventAtMs = observedAtMs;
+    this.staleSinceMs = null;
+  }
+  markStale(nowMs = Date.now()) {
+    this.staleSinceMs ??= nowMs;
+    return this.staleSinceMs;
+  }
+};
+
+// src/runtimeNotificationState.ts
+var RuntimeNotificationState = class {
+  timerValue = null;
+  pendingCountValue = 0;
+  get pendingCount() {
+    return this.pendingCountValue;
+  }
+  get timer() {
+    return this.timerValue;
+  }
+  get hasTimer() {
+    return this.timerValue !== null;
+  }
+  add(count = 1) {
+    this.pendingCountValue += count;
+    return this.pendingCountValue;
+  }
+  clearPending() {
+    this.pendingCountValue = 0;
+  }
+  clearTimer() {
+    if (this.timerValue) {
+      clearTimeout(this.timerValue);
+      this.timerValue = null;
+    }
+  }
+  clear() {
+    this.clearPending();
+    this.clearTimer();
+  }
+  schedule(callback, delayMs) {
+    if (this.timerValue) return false;
+    this.timerValue = setTimeout(callback, delayMs);
+    return true;
+  }
+  takePendingAndClearTimer() {
+    const count = this.pendingCountValue;
+    this.pendingCountValue = 0;
+    this.clearTimer();
+    return count;
+  }
+};
+
 // src/agentProcessManager.ts
 var DEFAULT_MAX_CONCURRENT_AGENT_STARTS = 5;
 var DEFAULT_AGENT_START_INTERVAL_MS = 500;
@@ -5225,19 +6023,19 @@ function findSessionJsonl(root, predicate) {
     if (depth < 0 || visited >= maxEntries) return null;
     let entries;
     try {
-      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+      entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
     } catch {
       return null;
     }
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isFile() || !predicate(entry.name)) continue;
-      return path12.join(dir, entry.name);
+      return path13.join(dir, entry.name);
     }
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isDirectory()) continue;
-      const found = visit(path12.join(dir, entry.name), depth - 1);
+      const found = visit(path13.join(dir, entry.name), depth - 1);
       if (found) return found;
     }
     return null;
@@ -5250,10 +6048,10 @@ function safeSessionFilename(value) {
 }
 function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   try {
-    const dir = path12.join(fallbackDir, ".slock", "runtime-sessions");
-    mkdirSync4(dir, { recursive: true });
-    const filePath = path12.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
-    writeFileSync7(filePath, JSON.stringify({
+    const dir = path13.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync5(dir, { recursive: true });
+    const filePath = path13.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    writeFileSync8(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
       sessionId,
@@ -5271,17 +6069,17 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
     return null;
   }
 }
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir) {
-  const directPath = path12.isAbsolute(sessionId) ? sessionId : null;
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), fallbackDir) {
+  const directPath = path13.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
-      if (statSync2(directPath).isFile()) {
+      if (statSync(directPath).isFile()) {
         return { label: sessionId, path: directPath, runtime, reachable: true };
       }
     } catch {
     }
   }
-  const resolvedPath = runtime === "claude" ? findSessionJsonl(path12.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path12.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
+  const resolvedPath = runtime === "claude" ? findSessionJsonl(path13.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path13.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
   if (!resolvedPath && fallbackDir) {
     const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
     if (fallback) return fallback;
@@ -5297,6 +6095,36 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), f
   }
   return ref;
 }
+function classifySpawnFailure(error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const lower = detail.toLowerCase();
+  if (lower.includes("agent credential proxy") && lower.includes("failed to bind")) {
+    return {
+      reason: "agent_proxy_bind_failed",
+      detail,
+      userMessage: "Local agent proxy could not start. Check if another daemon or service is using the required local port."
+    };
+  }
+  if (lower.includes("runner_credential_mint") || error instanceof RunnerCredentialMintError) {
+    return {
+      reason: "runner_credential_mint_failed",
+      detail,
+      userMessage: "Runner credential mint failed. Ensure the server is deployed and the daemon binary is compatible."
+    };
+  }
+  if (lower.includes("enoent") || lower.includes("cannot resolve") || lower.includes("not found")) {
+    return {
+      reason: "runtime_not_found",
+      detail,
+      userMessage: "Runtime executable not found. Ensure the required CLI is installed and available on PATH."
+    };
+  }
+  return {
+    reason: "runtime_spawn_failed",
+    detail,
+    userMessage: `Start failed: ${detail}`
+  };
+}
 function formatSenderHandle(message) {
   return message.sender_description ? `@${message.sender_name} \u2014 ${message.sender_description}` : `@${message.sender_name}`;
 }
@@ -5945,26 +6773,29 @@ function hasDirectStdinRecoveryEvidence(ap) {
     (text) => /write_stdin failed|stdin is closed|closed for this session|session.*closed/i.test(text)
   );
 }
-function isMissingResumeSession(ap) {
-  if (!ap.sessionId) return false;
+function resumeSessionRecoveryReason(ap) {
+  if (!ap.sessionId) return null;
   const candidates = [
     ap.lastRuntimeError,
     ...ap.recentStderr
   ].filter((value) => !!value);
   if (ap.driver.id === "claude") {
-    return candidates.some((text) => /No conversation found with session ID/i.test(text));
+    return candidates.some((text) => /No conversation found with session ID/i.test(text)) ? "missing" : null;
   }
   if (ap.driver.id === "opencode") {
-    return candidates.some(
-      (text) => /Session not found/i.test(text) && text.includes(ap.sessionId)
-    );
+    if (candidates.some((text) => /Session not found/i.test(text) && text.includes(ap.sessionId))) return "missing";
+    if (candidates.some(isOpenCodeReplayRejectedByProvider)) return "provider_replay_rejected";
+    return null;
   }
   if (ap.driver.id === "gemini") {
     return candidates.some(
       (text) => /Error resuming session:\s*Invalid session identifier/i.test(text) && text.includes(ap.sessionId)
-    );
+    ) ? "missing" : null;
   }
-  return false;
+  return null;
+}
+function isOpenCodeReplayRejectedByProvider(text) {
+  return /Invalid request:\s*the message at position \d+ with role ['"]?assistant['"]? must not be empty/i.test(text);
 }
 function resumeSessionRuntimeLabel(runtimeId) {
   if (runtimeId === "opencode") return "OpenCode";
@@ -6021,7 +6852,7 @@ function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
       launchId: ap.launchId || void 0,
       sessionIdPresent: Boolean(ap.sessionId),
       inboxCount: ap.inbox.length,
-      pendingNotificationCount: ap.pendingNotificationCount,
+      pendingNotificationCount: ap.notifications.pendingCount,
       processPidPresent: typeof ap.process.pid === "number",
       busyDeliveryMode: ap.driver.busyDeliveryMode,
       supportsStdinNotification: ap.driver.supportsStdinNotification,
@@ -6035,7 +6866,7 @@ function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
   };
 }
 function classifyRuntimeStallReason(ap) {
-  if (ap.lastRuntimeEventKind === "tool_output" && ap.gatedSteering.outstandingToolUses === 0) {
+  if (ap.runtimeProgress.lastEventKind === "tool_output" && ap.gatedSteering.outstandingToolUses === 0) {
     return "harness_post_tool_silent_wedge";
   }
   return "no_runtime_events";
@@ -6196,7 +7027,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
     this.dataDir = opts.dataDir || resolveSlockHomePath("agents");
-    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os6.homedir();
+    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os5.homedir();
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
@@ -6608,7 +7439,7 @@ var AgentProcessManager = class _AgentProcessManager {
         );
         wakeMessage = void 0;
       }
-      const agentDataDir = path12.join(this.dataDir, agentId);
+      const agentDataDir = path13.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       let runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
       const legacyRuntimeProfileControl = runtimeConfig.runtimeProfileControl?.kind === "migration" ? runtimeConfig.runtimeProfileControl : null;
@@ -6622,23 +7453,23 @@ var AgentProcessManager = class _AgentProcessManager {
         );
         runtimeConfig = { ...runtimeConfig, runtimeProfileControl: null };
       }
-      const memoryMdPath = path12.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path13.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
         const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      const notesDir = path12.join(agentDataDir, "notes");
+      const notesDir = path13.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 = path12.join(agentDataDir, relativePath);
+          const fullPath = path13.join(agentDataDir, relativePath);
           try {
             await access(fullPath);
           } catch {
-            await mkdir(path12.dirname(fullPath), { recursive: true });
+            await mkdir(path13.dirname(fullPath), { recursive: true });
             await writeFile(fullPath, content);
           }
         }
@@ -6766,16 +7597,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         startupUnreadSummary: unreadSummary,
         startupResumePrompt: resumePrompt,
         isIdle: false,
-        notificationTimer: null,
-        pendingNotificationCount: 0,
+        notifications: new RuntimeNotificationState(),
         activityHeartbeat: null,
         startupTimeoutTimer: null,
         startupTimedOut: false,
         compactionWatchdog: null,
         compactionStartedAt: null,
-        lastRuntimeEventAt: Date.now(),
-        lastRuntimeEventKind: null,
-        runtimeProgressStaleSince: null,
+        runtimeProgress: new RuntimeProgressState(Date.now()),
         runtimeTraceSpan: null,
         runtimeTraceCounters: createRuntimeTraceCounters(),
         lastActivity: "",
@@ -6884,7 +7712,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           clean_exit: code === 0,
           runtime_trace_active: Boolean(current?.runtimeTraceSpan),
           inbox_count: current?.inbox.length ?? 0,
-          pending_notification_count: current?.pendingNotificationCount ?? 0,
+          pending_notification_count: current?.notifications.pendingCount ?? 0,
           ...this.processExitTraceAttrs.get(proc)
         });
         logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
@@ -6893,9 +7721,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (this.agents.has(agentId)) {
           const ap = this.agents.get(agentId);
           if (ap.process !== proc) return;
-          if (ap.notificationTimer) {
-            clearTimeout(ap.notificationTimer);
-          }
+          ap.notifications.clearTimer();
           if (ap.pendingTrajectory?.timer) {
             clearTimeout(ap.pendingTrajectory.timer);
           }
@@ -6909,7 +7735,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           const expectedTermination = Boolean(ap.expectedTerminationReason) || ap.startupTimedOut;
           const processEndedCleanly = finalCode === 0 || expectedTermination && !ap.lastRuntimeError;
           const terminalFailureDetail = processEndedCleanly ? null : classifyTerminalFailure(ap);
-          const missingResumeSession = isMissingResumeSession(ap);
+          const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
+          const shouldColdStartResumeSession = resumeRecoveryReason !== null;
           const summary = summarizeCrash(finalCode, finalSignal);
           this.endRuntimeTrace(ap, processEndedCleanly ? "ok" : "error", {
             outcome: processEndedCleanly ? "process-exit" : "process-crash",
@@ -6923,20 +7750,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           cleanupAgentCredentialProxy(agentId, ap.launchId);
           this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
           this.agents.delete(agentId);
-          if (missingResumeSession) {
+          if (shouldColdStartResumeSession) {
             const staleSessionId = ap.sessionId;
             const runtimeLabel = resumeSessionRuntimeLabel(ap.driver.id);
             const restartConfig = { ...stripManagedRunnerCredential(ap.config), sessionId: null };
+            const reasonText = resumeRecoveryReason === "provider_replay_rejected" ? "was rejected by the provider during replay" : "is unavailable locally";
+            const activityText = resumeRecoveryReason === "provider_replay_rejected" ? `Stored ${runtimeLabel} session replay rejected; cold-starting a new session\u2026` : `Stored ${runtimeLabel} session missing; cold-starting a new session\u2026`;
             logger.warn(
-              `[Agent ${agentId}] Stored ${runtimeLabel} session ${staleSessionId} is unavailable locally; falling back to cold start`
+              `[Agent ${agentId}] Stored ${runtimeLabel} session ${staleSessionId} ${reasonText}; falling back to cold start`
             );
             this.broadcastActivity(
               agentId,
               "working",
-              `Stored ${runtimeLabel} session missing; cold-starting a new session\u2026`,
+              activityText,
               [{
                 kind: "text",
-                text: `Stored ${runtimeLabel} session ${staleSessionId} was not found locally. Falling back to a cold start; earlier runtime context may not be restored.`
+                text: `Stored ${runtimeLabel} session ${staleSessionId} ${reasonText}. Falling back to a cold start; earlier runtime context may not be restored.`
               }]
             );
             this.startAgent(
@@ -7082,7 +7911,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         "X-Slock-Client": "daemon-server-session-worker"
       },
       body: JSON.stringify({
-        scopes: ["send", "read", "mentions", "tasks", "reactions", "server", "channels"],
+        scopes: ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"],
         name: `runner:${config.runtime}:${agentId.slice(0, 8)}`
       })
     });
@@ -7205,15 +8034,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   enqueueRuntimeProfileNotification(agentId, ap, message, kind, key) {
     ap.inbox.push(message);
     if (ap.driver.supportsStdinNotification && ap.sessionId) {
-      ap.pendingNotificationCount++;
+      ap.notifications.add();
       if (ap.driver.busyDeliveryMode === "gated") {
         this.recordGatedSteeringEvent(agentId, ap, "buffer", {
           reason: "runtime_profile",
           kind,
           pendingMessages: ap.inbox.length
         });
-      } else if (!ap.notificationTimer) {
-        ap.notificationTimer = setTimeout(() => {
+      } else if (!ap.notifications.hasTimer) {
+        ap.notifications.schedule(() => {
           this.sendStdinNotification(agentId);
         }, 3e3);
       }
@@ -7228,7 +8057,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       session_id_present: Boolean(ap.sessionId),
       launchId: ap.launchId || void 0,
       inbox_count: ap.inbox.length,
-      pending_notification_count: ap.pendingNotificationCount,
+      pending_notification_count: ap.notifications.pendingCount,
       busy_delivery_mode: ap.driver.busyDeliveryMode,
       supports_stdin_notification: ap.driver.supportsStdinNotification
     });
@@ -7266,9 +8095,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
       return;
     }
-    if (ap.notificationTimer) {
-      clearTimeout(ap.notificationTimer);
-    }
+    ap.notifications.clearTimer();
     if (ap.activityHeartbeat) {
       clearInterval(ap.activityHeartbeat);
     }
@@ -7449,11 +8276,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       return true;
     }
     if (ap.gatedSteering.compacting) {
-      ap.pendingNotificationCount++;
-      if (ap.notificationTimer) {
-        clearTimeout(ap.notificationTimer);
-        ap.notificationTimer = null;
-      }
+      ap.notifications.add();
+      ap.notifications.clearTimer();
       if (ap.driver.busyDeliveryMode === "gated") {
         this.recordGatedSteeringEvent(agentId, ap, "buffer", {
           reason: "compaction_boundary",
@@ -7461,7 +8285,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         });
       }
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.compaction_boundary.delivery_buffered", {
-        pendingNotificationCount: ap.pendingNotificationCount,
+        pendingNotificationCount: ap.notifications.pendingCount,
         pendingMessages: ap.inbox.length,
         busyDeliveryMode: ap.driver.busyDeliveryMode
       });
@@ -7473,16 +8297,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         session_id_present: true,
         launchId: ap.launchId || void 0,
         inbox_count: ap.inbox.length,
-        pending_notification_count: ap.pendingNotificationCount,
+        pending_notification_count: ap.notifications.pendingCount,
         busy_delivery_mode: ap.driver.busyDeliveryMode,
         notification_timer_present: false
       }));
       return true;
     }
     if (ap.driver.busyDeliveryMode === "gated") {
-      ap.pendingNotificationCount++;
-      if (!ap.notificationTimer) {
-        ap.notificationTimer = setTimeout(() => {
+      ap.notifications.add();
+      if (!ap.notifications.hasTimer) {
+        ap.notifications.schedule(() => {
           this.sendStdinNotification(agentId);
         }, 3e3);
       }
@@ -7498,14 +8322,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         session_id_present: true,
         launchId: ap.launchId || void 0,
         inbox_count: ap.inbox.length,
-        pending_notification_count: ap.pendingNotificationCount,
-        notification_timer_present: Boolean(ap.notificationTimer)
+        pending_notification_count: ap.notifications.pendingCount,
+        notification_timer_present: ap.notifications.hasTimer
       }));
       return true;
     }
-    ap.pendingNotificationCount++;
-    if (!ap.notificationTimer) {
-      ap.notificationTimer = setTimeout(() => {
+    ap.notifications.add();
+    if (!ap.notifications.hasTimer) {
+      ap.notifications.schedule(() => {
         this.sendStdinNotification(agentId);
       }, 3e3);
     }
@@ -7516,13 +8340,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       runtime: ap.config.runtime,
       session_id_present: true,
       inbox_count: ap.inbox.length,
-      pending_notification_count: ap.pendingNotificationCount,
-      notification_timer_present: Boolean(ap.notificationTimer)
+      pending_notification_count: ap.notifications.pendingCount,
+      notification_timer_present: ap.notifications.hasTimer
     }));
     return true;
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path12.join(this.dataDir, agentId);
+    const agentDataDir = path13.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -7583,7 +8407,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path12.join(this.dataDir, agentId);
+    const workspacePath = path13.join(this.dataDir, agentId);
     return {
       agentId,
       launchId,
@@ -7840,7 +8664,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path12.join(this.dataDir, agentId);
+    const agentDir = path13.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -7848,8 +8672,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path12.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path12.sep) && resolved !== agentDir) {
+      const resolved = path13.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path13.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -7857,14 +8681,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path12.join(this.dataDir, agentId);
-    const resolved = path12.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path12.sep) && resolved !== agentDir) {
+    const agentDir = path13.join(this.dataDir, agentId);
+    const resolved = path13.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path13.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 = path12.extname(resolved).toLowerCase();
+    const ext = path13.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");
@@ -7898,14 +8722,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   async listSkills(agentId, runtimeHint) {
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
-    const home = os6.homedir();
-    const workspaceDir = path12.join(this.dataDir, agentId);
+    const home = os5.homedir();
+    const workspaceDir = path13.join(this.dataDir, agentId);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
     const globalResults = await Promise.all(
-      paths.global.map((p) => this.scanSkillsDir(path12.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path13.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path12.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path13.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -7934,7 +8758,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path12.join(dir, entry.name, "SKILL.md");
+        const skillMd = path13.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -7945,7 +8769,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path12.join(dir, entry.name), "utf-8");
+          const content = await readFile(path13.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -8312,40 +9136,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.startRuntimeTrace(agentId, ap, "runtime-progress").addEvent(name, attrs);
   }
   noteRuntimeProgress(ap, eventKind) {
-    ap.lastRuntimeEventAt = Date.now();
-    ap.lastRuntimeEventKind = eventKind ?? null;
-    ap.runtimeProgressStaleSince = null;
-  }
-  observeRuntimeTranscriptProgress(agentId, ap, staleForMs, source) {
-    if (ap.config.runtime !== "codex" || !ap.sessionId) return false;
-    const ref = resolveRuntimeSessionRef(ap.config.runtime, ap.sessionId, this.runtimeSessionHomeDir);
-    if (!ref.reachable || !ref.path) return false;
-    let mtimeMs;
-    try {
-      const stats = statSync2(ref.path);
-      if (!stats.isFile()) return false;
-      mtimeMs = stats.mtimeMs;
-    } catch {
-      return false;
-    }
-    if (mtimeMs <= ap.lastRuntimeEventAt) return false;
-    const now = Date.now();
-    const transcriptAgeMs = Math.max(0, now - mtimeMs);
-    if (transcriptAgeMs >= RUNTIME_PROGRESS_STALE_MS) return false;
-    ap.lastRuntimeEventAt = mtimeMs;
-    ap.runtimeProgressStaleSince = null;
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.internal_observed", {
-      turn_outcome: "held",
-      turn_subtype: "runtime_progress",
-      turn_reason: "internal_activity_observed",
-      signal: "runtime_transcript_mtime",
-      source,
-      runtime: ap.config.runtime,
-      sessionRefReachable: true,
-      transcriptAgeMs,
-      previousStaleForMs: staleForMs
-    });
-    return true;
+    ap.runtimeProgress.noteRuntimeEvent(eventKind);
   }
   recordGatedSteeringEvent(agentId, ap, event, attrs = {}) {
     if (ap.driver.busyDeliveryMode !== "gated") return;
@@ -8376,13 +9167,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       return this.sendStdinNotification(agentId);
     }
     const pendingMessages = ap.inbox.length;
-    const pendingNotificationCount = ap.pendingNotificationCount;
+    const pendingNotificationCount = ap.notifications.pendingCount;
     const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-    ap.pendingNotificationCount = 0;
-    if (ap.notificationTimer) {
-      clearTimeout(ap.notificationTimer);
-      ap.notificationTimer = null;
-    }
+    ap.notifications.clear();
     ap.gatedSteering.lastFlushReason = reason;
     if (reason !== "turn_end") {
       ap.gatedSteering.inFlightBatch = {
@@ -8405,16 +9192,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (reason !== "turn_end") {
       ap.gatedSteering.inFlightBatch = null;
     }
-    ap.pendingNotificationCount += pendingNotificationCount || pendingMessages;
+    ap.notifications.add(pendingNotificationCount || pendingMessages);
     return false;
   }
   flushCompactionBoundaryMessages(agentId, ap) {
     if (!ap.sessionId || !ap.driver.supportsStdinNotification || ap.inbox.length === 0) return false;
-    if (ap.pendingNotificationCount > 0) {
-      if (ap.notificationTimer) {
-        clearTimeout(ap.notificationTimer);
-        ap.notificationTimer = null;
-      }
+    if (ap.notifications.pendingCount > 0) {
+      ap.notifications.clearTimer();
       this.sendStdinNotification(agentId);
       return true;
     }
@@ -8442,7 +9226,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   handleRuntimeStartupTimeout(agentId, ap, timeoutMs) {
     const current = this.agents.get(agentId);
     if (current !== ap) return;
-    if (ap.lastRuntimeEventKind) {
+    if (ap.runtimeProgress.lastEventKind) {
       this.clearRuntimeStartupTimeout(ap);
       return;
     }
@@ -8451,8 +9235,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const detail = terminalFailureDetail?.detail ?? formatRuntimeStartTimeoutMessage(ap.driver.id);
     ap.startupTimedOut = true;
     ap.lastRuntimeError = detail;
-    ap.runtimeProgressStaleSince = Date.now();
-    const staleForMs = Math.max(timeoutMs, Date.now() - ap.lastRuntimeEventAt);
+    ap.runtimeProgress.markStale();
+    const staleForMs = Math.max(timeoutMs, ap.runtimeProgress.ageMs());
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, Math.max(1, Math.floor(staleForMs / 6e4)));
     this.recordRuntimeTraceEvent(agentId, ap, "runtime.start.timeout", {
       turn_outcome: "failed",
@@ -8491,7 +9275,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const batch = ap.gatedSteering.inFlightBatch;
     ap.gatedSteering.inFlightBatch = null;
     ap.inbox.unshift(...batch.messages);
-    ap.pendingNotificationCount += batch.messages.length;
+    ap.notifications.add(batch.messages.length);
     this.recordGatedSteeringEvent(agentId, ap, "requeue", {
       reason,
       originalFlushReason: batch.reason,
@@ -8503,11 +9287,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   markRuntimeProgressStaleIfNeeded(agentId, ap) {
     if (ap.lastActivity !== "working" && ap.lastActivity !== "thinking") return false;
-    if (ap.runtimeProgressStaleSince) return true;
-    const staleForMs = Date.now() - ap.lastRuntimeEventAt;
+    if (ap.runtimeProgress.isStale) return true;
+    const staleForMs = ap.runtimeProgress.ageMs();
     if (staleForMs < RUNTIME_PROGRESS_STALE_MS) return false;
-    if (this.observeRuntimeTranscriptProgress(agentId, ap, staleForMs, "activity_heartbeat")) return false;
-    ap.runtimeProgressStaleSince = Date.now();
+    ap.runtimeProgress.markStale();
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
     const turnReason = classifyRuntimeStallReason(ap);
@@ -8540,11 +9323,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const canRestartDirectStdinProcess = directStdinRuntime && Boolean(ap.sessionId) && (ap.gatedSteering.outstandingToolUses === 0 || hasDirectStdinRecoveryEvidence(ap));
     const canRestartStalledProcess = !ap.driver.supportsStdinNotification || canRestartDirectStdinProcess;
     if (!canRestartStalledProcess) return false;
-    const staleForMs = Date.now() - ap.lastRuntimeEventAt;
-    if (staleForMs < RUNTIME_PROGRESS_STALE_MS && !ap.runtimeProgressStaleSince) return false;
-    if (this.observeRuntimeTranscriptProgress(agentId, ap, staleForMs, "queued_recovery")) return false;
+    const staleForMs = ap.runtimeProgress.ageMs();
+    if (staleForMs < RUNTIME_PROGRESS_STALE_MS && !ap.runtimeProgress.isStale) return false;
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
-    ap.runtimeProgressStaleSince ??= Date.now();
+    ap.runtimeProgress.markStale();
     const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
     const turnReason = classifyRuntimeStallReason(ap);
     this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
@@ -8593,14 +9375,38 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   /** Handle a single ParsedEvent from any runtime driver */
   handleParsedEvent(agentId, event, driver) {
     const ap = this.agents.get(agentId);
+    if (event.kind === "telemetry") {
+      if (ap) this.recordRuntimeTelemetry(agentId, ap, event);
+      return;
+    }
     if (ap) {
-      const wasStalled = Boolean(ap.runtimeProgressStaleSince);
+      const wasStalled = ap.runtimeProgress.isStale;
       this.clearRuntimeStartupTimeout(ap);
       this.noteRuntimeTraceCounter(ap, event);
-      this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", { kind: event.kind });
+      const eventAttrs = event.kind === "internal_progress" ? {
+        kind: event.kind,
+        source: event.source,
+        itemType: event.itemType,
+        payloadBytes: event.payloadBytes
+      } : { kind: event.kind };
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", eventAttrs);
       if (wasStalled) {
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.observed", { afterStall: true });
       }
+      if (event.kind === "internal_progress") {
+        ap.runtimeProgress.noteInternalProgress();
+        this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.internal_observed", {
+          turn_outcome: "held",
+          turn_subtype: "runtime_progress",
+          turn_reason: "internal_activity_observed",
+          signal: event.source,
+          source: "runtime_event",
+          runtime: ap.config.runtime,
+          itemType: event.itemType,
+          payloadBytes: event.payloadBytes
+        });
+        return;
+      }
       this.noteRuntimeProgress(ap, event.kind);
     }
     switch (event.kind) {
@@ -8704,11 +9510,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           this.setGatedSteeringPhase(agentId, ap, "idle", { event: "turn_end" });
           if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
             const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-            ap.pendingNotificationCount = 0;
-            if (ap.notificationTimer) {
-              clearTimeout(ap.notificationTimer);
-              ap.notificationTimer = null;
-            }
+            ap.notifications.clear();
             if (ap.driver.busyDeliveryMode === "gated") {
               ap.gatedSteering.lastFlushReason = "turn_end";
               this.recordGatedSteeringEvent(agentId, ap, "flush", {
@@ -8802,11 +9604,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               }
             } else {
               ap.isIdle = true;
-              ap.pendingNotificationCount = 0;
-              if (ap.notificationTimer) {
-                clearTimeout(ap.notificationTimer);
-                ap.notificationTimer = null;
-              }
+              ap.notifications.clear();
               logger.info(`[Agent ${agentId}] Marked ${ap.driver.id} wakeable after terminal runtime error`);
             }
           }
@@ -8818,6 +9616,18 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
     }
   }
+  recordRuntimeTelemetry(agentId, ap, event) {
+    const attrs = {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      telemetry_name: event.name,
+      ...event.attrs
+    };
+    ap.runtimeTraceSpan?.addEvent(`runtime.telemetry.${event.name}`, event.attrs);
+    this.recordDaemonTrace(`daemon.runtime.telemetry.${event.name}`, attrs);
+  }
   sendAgentStatus(agentId, status, launchId) {
     this.sendToServer({ type: "agent:status", agentId, status, launchId: launchId || void 0 });
   }
@@ -8871,12 +9681,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   sendStdinNotification(agentId) {
     const ap = this.agents.get(agentId);
     if (!ap) return false;
-    const count = ap.pendingNotificationCount;
-    ap.pendingNotificationCount = 0;
-    if (ap.notificationTimer) {
-      clearTimeout(ap.notificationTimer);
-      ap.notificationTimer = null;
-    }
+    const count = ap.notifications.takePendingAndClearTimer();
     if (count === 0) return false;
     if (ap.isIdle) return false;
     if (!ap.sessionId) return false;
@@ -8886,7 +9691,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         pendingMessages: ap.inbox.length,
         busyDeliveryMode: ap.driver.busyDeliveryMode
       });
-      ap.pendingNotificationCount += count;
+      ap.notifications.add(count);
       logger.info(
         `[Agent ${agentId}] Suppressing stdin delivery until context compaction finishes; pending=${ap.inbox.length}`
       );
@@ -8912,7 +9717,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       });
       return true;
     } else {
-      ap.pendingNotificationCount += count;
+      ap.notifications.add(count);
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -8963,7 +9768,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       messages_count: messages.length,
       session_id_present: Boolean(ap.sessionId),
       inbox_count: ap.inbox.length,
-      pending_notification_count: ap.pendingNotificationCount,
+      pending_notification_count: ap.notifications.pendingCount,
       busy_delivery_mode: ap.driver.busyDeliveryMode,
       supports_stdin_notification: ap.driver.supportsStdinNotification,
       ...this.messagesTraceAttrs(messages)
@@ -9038,8 +9843,8 @@ ${RESPONSE_TARGET_HINT}`);
     const nodes = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path12.join(dir, entry.name);
-      const relativePath = path12.relative(rootDir, fullPath);
+      const fullPath = path13.join(dir, entry.name);
+      const relativePath = path13.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -9344,9 +10149,9 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
-import os7 from "os";
-import path13 from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
+import os6 from "os";
+import path14 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -9368,18 +10173,18 @@ function resolveDefaultMachineStateRoot() {
   return resolveSlockHomePath("machines");
 }
 function ownerPath(lockDir) {
-  return path13.join(lockDir, "owner.json");
+  return path14.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
-    return JSON.parse(readFileSync6(ownerPath(lockDir), "utf8"));
+    return JSON.parse(readFileSync5(ownerPath(lockDir), "utf8"));
   } catch {
     return null;
   }
 }
 function lockAgeMs(lockDir) {
   try {
-    return Date.now() - statSync3(lockDir).mtimeMs;
+    return Date.now() - statSync2(lockDir).mtimeMs;
   } catch {
     return null;
   }
@@ -9398,23 +10203,23 @@ function acquireDaemonMachineLock(options) {
   const rootDir = options.rootDir ?? resolveDefaultMachineStateRoot();
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
-  const machineDir = path13.join(rootDir, lockId);
-  const lockDir = path13.join(machineDir, "daemon.lock");
+  const machineDir = path14.join(rootDir, lockId);
+  const lockDir = path14.join(machineDir, "daemon.lock");
   const token = randomUUID3();
-  mkdirSync5(machineDir, { recursive: true });
+  mkdirSync6(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync5(lockDir);
+      mkdirSync6(lockDir);
       const owner = {
         pid: process.pid,
         token,
-        hostname: os7.hostname(),
+        hostname: os6.hostname(),
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         serverUrl: options.serverUrl,
         apiKeyFingerprint: fingerprint.slice(0, 16)
       };
       try {
-        writeFileSync8(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+        writeFileSync9(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
 `, { mode: 384 });
       } catch (err) {
         rmSync3(lockDir, { recursive: true, force: true });
@@ -9451,8 +10256,8 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
-import path14 from "path";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync10 } from "fs";
+import path15 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
 var DEFAULT_MAX_FILES = 8;
@@ -9488,7 +10293,7 @@ var LocalRotatingTraceSink = class {
   currentSize = 0;
   sequence = 0;
   constructor(options) {
-    this.traceDir = path14.join(options.machineDir, "traces");
+    this.traceDir = path15.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));
@@ -9514,26 +10319,26 @@ var LocalRotatingTraceSink = class {
     return this.currentFile;
   }
   ensureFile(nextBytes) {
-    mkdirSync6(this.traceDir, { recursive: true, mode: 448 });
+    mkdirSync7(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 = path14.join(
+      this.currentFile = path15.join(
         this.traceDir,
         `daemon-trace-${safeTimestamp(nowMs)}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
       );
-      writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
-      this.currentSize = statSync4(this.currentFile).size;
+      writeFileSync10(this.currentFile, "", { flag: "a", mode: 384 });
+      this.currentSize = statSync3(this.currentFile).size;
       this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
     }
   }
   pruneOldFiles() {
-    const files = readdirSync3(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
+    const files = readdirSync2(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
-      rmSync4(path14.join(this.traceDir, file), { force: true });
+      rmSync4(path15.join(this.traceDir, file), { force: true });
     }
   }
 };
@@ -9620,11 +10425,11 @@ function isDiagnosticErrorAttr(key) {
 import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
 import { gzipSync } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 
 // src/directUploadCapability.ts
-function joinUrl(base, path17) {
-  return `${base.replace(/\/+$/, "")}${path17}`;
+function joinUrl(base, path18) {
+  return `${base.replace(/\/+$/, "")}${path18}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -9843,7 +10648,7 @@ var DaemonTraceBundleUploader = class {
     }, nextMs);
   }
   async findUploadCandidates() {
-    const traceDir = path15.join(this.options.machineDir, "traces");
+    const traceDir = path16.join(this.options.machineDir, "traces");
     let names;
     try {
       names = await readdir3(traceDir);
@@ -9855,8 +10660,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 = path15.join(traceDir, name);
-      if (currentFile && path15.resolve(file) === path15.resolve(currentFile)) continue;
+      const file = path16.join(traceDir, name);
+      if (currentFile && path16.resolve(file) === path16.resolve(currentFile)) continue;
       if (await this.isUploaded(file)) continue;
       try {
         const info = await stat3(file);
@@ -9930,8 +10735,8 @@ var DaemonTraceBundleUploader = class {
     }
   }
   uploadStatePath(file) {
-    const stateDir = path15.join(this.options.machineDir, "trace-uploads");
-    return path15.join(stateDir, `${path15.basename(file)}.uploaded.json`);
+    const stateDir = path16.join(this.options.machineDir, "trace-uploads");
+    return path16.join(stateDir, `${path16.basename(file)}.uploaded.json`);
   }
   async isUploaded(file) {
     try {
@@ -9943,9 +10748,9 @@ var DaemonTraceBundleUploader = class {
   }
   async markUploaded(file, metadata) {
     const stateFile = this.uploadStatePath(file);
-    await mkdir2(path15.dirname(stateFile), { recursive: true, mode: 448 });
+    await mkdir2(path16.dirname(stateFile), { recursive: true, mode: 448 });
     await writeFile2(stateFile, `${JSON.stringify({
-      file: path15.basename(file),
+      file: path16.basename(file),
       uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...metadata
     }, null, 2)}
@@ -9964,10 +10769,10 @@ function readPositiveIntegerEnv2(name, fallback) {
 
 // src/core.ts
 var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
-var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels"];
+var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
-var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
+var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -10003,9 +10808,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args) {
+function parseDaemonCliArgs(args, env = {}) {
   let serverUrl = "";
-  let apiKey = "";
+  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -10022,23 +10827,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path16.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path16.resolve(dirname, "chat-bridge.js");
+  const dirname = path17.dirname(fileURLToPath2(moduleUrl));
+  const jsPath = path17.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path16.resolve(dirname, "chat-bridge.ts");
+    return path17.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path16.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path16.resolve(thisDir, "cli", "index.js");
+  const thisDir = path17.dirname(fileURLToPath2(moduleUrl));
+  const bundledDistPath = path17.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path16.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path17.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -10217,7 +11022,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path16.join(path16.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path17.join(path17.dirname(this.options.dataDir), "machines");
     return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
@@ -10443,10 +11248,19 @@ var DaemonCore = class {
       case "agent:start":
         logger.info(`[Agent ${msg.agentId}] Start requested (runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`);
         this.startAgentFromMessage(msg).catch((err) => {
-          const reason = err instanceof Error ? err.message : String(err);
-          logger.error(`[Agent ${msg.agentId}] Start failed (${reason})`);
+          const classification = classifySpawnFailure(err);
+          logger.error(`[Agent ${msg.agentId}] Start failed (${classification.reason}): ${classification.detail}`);
+          this.recordDaemonTrace("daemon.agent.spawn.failed", {
+            agentId: msg.agentId,
+            launchId: msg.launchId,
+            runtime: msg.config.runtime,
+            model: msg.config.model,
+            failure_reason: classification.reason,
+            failure_detail: classification.detail,
+            session_id_present: Boolean(msg.config.sessionId)
+          }, "error");
           this.connection.send({ type: "agent:status", agentId: msg.agentId, status: "inactive", launchId: msg.launchId });
-          this.connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: `Start failed: ${reason}`, launchId: msg.launchId });
+          this.connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: classification.userMessage, launchId: msg.launchId });
         });
         break;
       case "agent:stop":
@@ -10656,8 +11470,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 ?? os7.hostname(),
+      os: this.options.osDescription ?? `${os7.platform()} ${os7.arch()}`,
       daemonVersion: this.daemonVersion
     });
     this.recordDaemonTrace("daemon.ready.sent", {
@@ -10719,6 +11533,8 @@ var DaemonCore = class {
 };
 
 export {
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,