@slock-ai/daemon 0.54.2 → 0.55.1

package/dist/{chunk-7ZOPGUXT.js → chunk-QQRU3GA6.js}

@@ -9,11 +9,35 @@ import {
 
 // src/core.ts
 import path16 from "path";
-import os8 from "os";
+import os7 from "os";
 import { createRequire as createRequire2 } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } 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";
 var TRACEPARENT_VERSION = "00";
@@ -724,6 +748,7 @@ 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 },
@@ -734,6 +759,164 @@ 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" }
+  ],
+  // 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 +952,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 mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync7 } 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 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";
@@ -881,13 +1061,14 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 19. **\`slock profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--avatar-url pixel:random:<seed>\`, \`--display-name <name>\`, and \`--description <text>\`. Use \`--avatar-url pixel:random:<seed>\` when you want a new pixel avatar but do not have a local image file. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
 20. **\`slock integration list\`** \u2014 List registered third-party services and this agent's active Slock Agent Logins.
 21. **\`slock integration login\`** \u2014 Provision or reuse this agent's login for a registered third-party service.
-22. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
-23. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
-24. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
-25. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
-26. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
-27. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
-28. **\`slock action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
+22. **\`slock integration env\`** \u2014 Print per-agent local CLI environment for a manifest-backed service that requires isolated HOME/XDG state.
+23. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+24. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
+25. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
+26. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
+27. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
+28. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
+29. **\`slock action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
 
 The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints JSON to stderr:
 - failure \u2192 stderr \`{"ok":false,"code":"...","message":"..."}\` with non-zero exit
@@ -993,7 +1174,7 @@ Each channel has a **name** and optionally a **description** that define its pur
 - If unsure where something belongs, call ${serverInfoCmd} to review channel descriptions.`;
   const thirdPartyIntegrationsSection = isCli ? `### Third-party integrations
 
-If a registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first run \`slock integration list\` and match the app to a registered service before browsing the app. Use \`slock integration login --service <service>\` to provision or reuse your agent login for that service. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`slock profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.` : `### Third-party integrations
+If a registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first run \`slock integration list\` and match the app to a registered service before browsing the app. Use \`slock integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`slock integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`slock profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.` : `### Third-party integrations
 
 If a registered third-party service requires login, use Slock Agent Login through the available registered-service interface instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first inspect the registered-service interface and match the app to a registered service before browsing the app. Once the registered-service interface reports the agent login is ready, the agent-side login is ready. If that interface provides an app URL, use it as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow or treat internal request IDs as OAuth callback codes unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use your Slock profile view. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.`;
   const readingHistorySection = isCli ? `### Reading history
@@ -1368,6 +1549,17 @@ var proxyServerState = null;
 var proxyServerStartPromise = null;
 var proxyServerFactory = createProxyServer;
 var DECODED_RESPONSE_HEADERS = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding"]);
+var HOP_BY_HOP_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
 var LOCAL_HELD_CONTEXT_LIMIT = 3;
 var AGENT_CREDENTIAL_PROXY_HOST = "127.0.0.1";
 var AGENT_CREDENTIAL_PROXY_BIND_MAX_ATTEMPTS = 3;
@@ -1467,9 +1659,12 @@ async function handleProxyRequest(req, res) {
     target = new URL2(req.url ?? "/", registration.serverUrl);
     const headers = new Headers();
     for (const [name, value] of Object.entries(req.headers)) {
+      const normalizedName = name.toLowerCase();
       if (value === void 0) continue;
-      if (name.toLowerCase() === "host") continue;
-      if (name.toLowerCase() === "authorization") continue;
+      if (normalizedName === "host") continue;
+      if (normalizedName === "authorization") continue;
+      if (normalizedName === "content-length") continue;
+      if (HOP_BY_HOP_REQUEST_HEADERS.has(normalizedName)) continue;
       if (Array.isArray(value)) {
         for (const item of value) headers.append(name, item);
       } else {
@@ -1480,7 +1675,15 @@ async function handleProxyRequest(req, res) {
     headers.set("X-Agent-Id", registration.agentId);
     headers.set("X-Slock-Client", "cli");
     headers.set("X-Slock-Agent-Active-Capabilities", registration.activeCapabilities);
-    let body = method === "GET" || method === "HEAD" ? void 0 : req;
+    let body;
+    let rawBodyBuffer;
+    if (method !== "GET" && method !== "HEAD") {
+      rawBodyBuffer = await readRequestBody(req);
+      const bodyBuffer = new ArrayBuffer(rawBodyBuffer.byteLength);
+      new Uint8Array(bodyBuffer).set(rawBodyBuffer);
+      body = bodyBuffer;
+      headers.set("content-length", String(rawBodyBuffer.byteLength));
+    }
     let sendTarget;
     const sideEffectAction = agentApiSideEffectAction(target.pathname);
     if (method === "GET" && target.pathname === "/internal/agent-api/events") {
@@ -1492,7 +1695,7 @@ async function handleProxyRequest(req, res) {
       }
     }
     if (method === "POST" && sideEffectAction) {
-      const rawBody = await readRequestBody(req);
+      const rawBody = rawBodyBuffer?.toString("utf8") ?? "";
       const prepared = await prepareAgentApiSideEffectForward(registration, headers, rawBody, sideEffectAction);
       if (prepared.localResponse) {
         const responseText = JSON.stringify(prepared.localResponse);
@@ -1508,10 +1711,13 @@ async function handleProxyRequest(req, res) {
     const upstream = await daemonFetch(target, {
       method,
       headers,
-      body,
-      // Required by undici when forwarding a Node stream.
-      duplex: body ? "half" : void 0
+      body
     });
+    if (upstream.status >= 500) {
+      registration.inboxCoordinator?.recordTransportNormalizedError?.(
+        transportNormalizedErrorForHttpStatus(target, upstream.status, registration.launchId)
+      );
+    }
     if (shouldBufferJsonResponse(upstream, target.pathname, registration)) {
       const responseText = await upstream.text();
       consumeVisibleResponse(registration, target, sendTarget, responseText);
@@ -1534,9 +1740,12 @@ async function handleProxyRequest(req, res) {
   } catch (err) {
     const failure = proxyFailureForError(method, target, err);
     logger.warn(
-      `[Agent Credential Proxy] request failed (agent=${registration.agentId}, launch=${registration.launchId ?? "none"}, method=${failure.method}, path=${failure.pathname}, query_keys=${failure.queryKeys.join(",") || "none"}): ${failure.errorName}: ${failure.errorMessage}`
+      `[Agent Credential Proxy] request failed (agent=${registration.agentId}, launch=${registration.launchId ?? "none"}, method=${failure.method}, path=${failure.pathname}, query_keys=${failure.queryKeys.join(",") || "none"}): ${failure.errorName}: ${failure.errorMessage}${failure.errorCause ? ` (cause=${failure.errorCause})` : ""}`
     );
     registration.inboxCoordinator?.recordProxyFailure?.(failure);
+    registration.inboxCoordinator?.recordTransportNormalizedError?.(
+      transportNormalizedErrorForError(target, err, registration.launchId)
+    );
     writeProxyFailureResponse(res, failure);
   }
 }
@@ -1555,25 +1764,125 @@ function writeProxyFailureResponse(res, failure) {
 }
 function proxyFailureForError(method, target, err) {
   const queryKeys = target ? [.../* @__PURE__ */ new Set([...target.searchParams.keys()])].sort() : [];
-  return {
+  const cause = err instanceof Error ? err.cause : void 0;
+  const failure = {
     method,
     pathname: target?.pathname ?? "unknown",
     queryKeys,
     errorName: err instanceof Error ? err.name : typeof err,
     errorMessage: truncateProxyErrorMessage(err instanceof Error ? err.message : String(err))
   };
+  const errorCause = describeProxyErrorCause(cause);
+  if (errorCause) failure.errorCause = errorCause;
+  return failure;
+}
+function describeProxyErrorCause(cause) {
+  if (!cause) return void 0;
+  if (cause instanceof Error) {
+    const errorWithCode = cause;
+    const code = typeof errorWithCode.code === "string" ? errorWithCode.code : void 0;
+    return truncateProxyErrorMessage([code, cause.message].filter(Boolean).join(" "));
+  }
+  if (typeof cause === "object") {
+    const causeObject = cause;
+    const code = typeof causeObject.code === "string" ? causeObject.code : void 0;
+    const message = typeof causeObject.message === "string" ? causeObject.message : void 0;
+    const detail = [code, message].filter(Boolean).join(" ");
+    if (detail) return truncateProxyErrorMessage(detail);
+  }
+  return truncateProxyErrorMessage(String(cause));
 }
 function truncateProxyErrorMessage(message) {
   const normalized = message.replace(/\s+/g, " ").trim();
   return normalized.length > 500 ? `${normalized.slice(0, 497)}...` : normalized;
 }
+function transportNormalizedErrorForHttpStatus(target, status, launchId) {
+  return {
+    normalizedCode: "server_5xx",
+    routeFamily: routeFamilyForPath(target.pathname),
+    responseStarted: true,
+    upstreamLayer: "http_status",
+    upstreamStatus: status,
+    launchId,
+    targetHostClass: daemonUpstreamTargetHostClass(target),
+    // Today the local credential proxy is only used by CLI wrappers. If runtime
+    // or daemon-internal callers use it later, plumb the caller identity here.
+    downstreamCaller: "cli",
+    upstream: "server"
+  };
+}
+function transportNormalizedErrorForError(target, err, launchId) {
+  return {
+    normalizedCode: "transport_failure",
+    routeFamily: routeFamilyForPath(target?.pathname ?? "unknown"),
+    responseStarted: false,
+    upstreamLayer: target ? upstreamLayerForProxyError(err) : "unknown",
+    originalMessage: sanitizeTransportOriginalMessage(err instanceof Error ? err.message : String(err)),
+    launchId,
+    targetHostClass: target ? daemonUpstreamTargetHostClass(target) : "custom_server",
+    // Today the local credential proxy is only used by CLI wrappers. If runtime
+    // or daemon-internal callers use it later, plumb the caller identity here.
+    downstreamCaller: "cli",
+    upstream: "server"
+  };
+}
+function routeFamilyForPath(pathname) {
+  if (pathname === "/internal/agent-api/send") return "agent-api/send";
+  if (pathname === "/internal/agent-api/events") return "agent-api/events";
+  if (pathname === "/internal/agent-api/receive-ack") return "agent-api/events";
+  if (pathname === "/internal/agent-api/tasks/claim") return "tasks/claim";
+  if (pathname === "/internal/agent-api/tasks/update-status") return "tasks/update";
+  if (pathname === "/internal/agent-api/tasks" || pathname.startsWith("/internal/agent-api/tasks/")) return "tasks";
+  if (pathname.startsWith("/internal/agent-api/attachments/")) return "agent-api/attachments";
+  if (/^\/internal\/agent-api\/messages\/[^/]+\/reactions$/.test(pathname)) return "agent-api/messages/reactions";
+  if (pathname === "/internal/agent-api/server") return "server";
+  if (pathname.startsWith("/internal/agent-api/history")) return "agent-api/events";
+  if (pathname.startsWith("/internal/agent-api/search")) return "agent-api/events";
+  if (pathname.startsWith("/internal/agent-api/channel-members")) return "channel-members";
+  if (pathname.startsWith("/internal/agent-api/knowledge")) return "knowledge";
+  if (pathname === "/internal/agent-api/profile" || pathname.startsWith("/internal/agent-api/profile/")) return "profile";
+  if (pathname === "/internal/agent-api/integrations" || pathname.startsWith("/internal/agent-api/integrations/")) return "integrations";
+  if (pathname === "/internal/agent-api/upload") return "attachments/upload";
+  if (pathname === "/internal/agent-api/resolve-channel") return "resolve-channel";
+  if (pathname === "/internal/agent-api/threads/unfollow") return "threads/unfollow";
+  if (pathname === "/internal/agent-api/prepare-action") return "action/prepare";
+  if (pathname === "/internal/agent-api/reminders" || pathname.startsWith("/internal/agent-api/reminders/")) return "reminders";
+  if (/^\/internal\/agent-api\/channels\/[^/]+\/join$/.test(pathname)) return "channels/join";
+  if (/^\/internal\/agent-api\/channels\/[^/]+\/leave$/.test(pathname)) return "channels/leave";
+  return "unknown";
+}
+function daemonUpstreamTargetHostClass(url) {
+  const hostname = url.hostname.toLowerCase();
+  if (hostname === "api.slock.ai") return "api.slock.ai";
+  return "custom_server";
+}
+function upstreamLayerForProxyError(err) {
+  const code = errorCode(err).toUpperCase();
+  const message = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  if (code === "ENOTFOUND" || code === "EAI_AGAIN" || message.includes("dns")) return "dns";
+  if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "UND_ERR_SOCKET" || message.includes("socket")) return "tcp";
+  if (code.includes("TLS") || message.includes("certificate") || message.includes("tls")) return "tls";
+  if (code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT" || message.includes("timeout")) return "read_timeout";
+  if (message.includes("proxy")) return "proxy_connect";
+  if (message.includes("fly")) return "fly_edge";
+  return "unknown";
+}
+function errorCode(err) {
+  if (typeof err === "object" && err && "code" in err && typeof err.code === "string") {
+    return err.code;
+  }
+  if (typeof err === "object" && err && "cause" in err) return errorCode(err.cause);
+  return "";
+}
+function sanitizeTransportOriginalMessage(message) {
+  return truncateProxyErrorMessage(message).replace(/sk_(?:agent|machine|computer)_[A-Za-z0-9_-]+/g, "sk_[redacted]").replace(/sap_[A-Za-z0-9_-]+/g, "sap_[redacted]").replace(/https?:\/\/\S+/g, "[url]");
+}
 async function readRequestBody(req) {
-  let body = "";
-  req.setEncoding("utf8");
+  const chunks = [];
   for await (const chunk of req) {
-    body += String(chunk);
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   }
-  return body;
+  return Buffer.concat(chunks);
 }
 function messageSeq(message) {
   return Number(message.seq ?? 0);
@@ -1748,7 +2057,7 @@ async function loadRecentTargetMessages(registration, headers, target) {
   const historyHeaders = new Headers(headers);
   historyHeaders.delete("content-length");
   historyHeaders.delete("content-type");
-  const res = await daemonFetch(historyUrl, { method: "GET", headers: historyHeaders });
+  const res = await fetch(historyUrl, { method: "GET", headers: historyHeaders });
   if (!res.ok) return [];
   const parsed = await res.json().catch(() => null);
   return Array.isArray(parsed?.messages) ? normalizeVisibleMessages(parsed.messages, target) : [];
@@ -1949,8 +2258,9 @@ 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 CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
   "SLOCK_AGENT_CREDENTIAL_KEY"
@@ -2152,16 +2462,18 @@ 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),
     [SLOCK_HOME_ENV]: slockHome,
     SLOCK_AGENT_ID: ctx.agentId,
     ...ctx.launchId ? { SLOCK_AGENT_LAUNCH_ID: ctx.launchId } : {},
+    ...ctx.cliTransportTraceDir ? { [CLI_TRANSPORT_TRACE_DIR_ENV]: ctx.cliTransportTraceDir } : {},
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
@@ -2186,6 +2498,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";
@@ -2386,12 +2821,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",
@@ -2417,81 +2850,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 = {
@@ -2501,7 +2907,7 @@ var ClaudeDriver = class {
   };
   communication = {
     chat: "slock_cli",
-    runtimeControl: "mcp_runtime_actions"
+    runtimeControl: "none"
   };
   session = {
     recovery: "resume_or_fresh"
@@ -2511,107 +2917,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",
@@ -2625,99 +2961,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({
@@ -2731,7 +2975,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."
@@ -2744,8 +2988,8 @@ 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
@@ -3107,7 +3351,7 @@ var CodexEventNormalizer = class {
 
 // 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;
@@ -3125,7 +3369,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;
@@ -3147,7 +3391,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;
@@ -3299,11 +3543,15 @@ var CodexDriver = class {
       // 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 (launchRuntimeFields.reasoningEffort) {
+      threadParams.config = { model_reasoning_effort: launchRuntimeFields.reasoningEffort };
     }
-    if (ctx.config.reasoningEffort) {
-      threadParams.config = { model_reasoning_effort: ctx.config.reasoningEffort };
+    if (launchRuntimeFields.mode.kind === "fast") {
+      threadParams.serviceTier = "priority";
     }
     if (ctx.config.sessionId) {
       return {
@@ -3459,12 +3707,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) {
@@ -3481,7 +3729,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 {
@@ -3512,7 +3760,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) {
@@ -3691,11 +3939,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}`);
@@ -3795,7 +4044,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" });
@@ -3851,7 +4100,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");
@@ -3864,8 +4113,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);
@@ -4000,14 +4250,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;
@@ -4027,8 +4278,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);
@@ -4041,7 +4293,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
     return { command: resolveCommandOnPath("gemini", deps) ?? "gemini", args: commandArgs };
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
-  const existsSyncFn = deps.existsSyncFn ?? existsSync6;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync5;
   const env = deps.env ?? process.env;
   const winPath = path8.win32;
   let geminiEntry = null;
@@ -4214,8 +4466,8 @@ 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 { 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";
@@ -4288,7 +4540,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, [
@@ -4316,8 +4568,9 @@ var KimiDriver = class {
       "--session",
       this.sessionId
     ];
-    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);
@@ -4443,11 +4696,11 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
+function detectKimiModels(home = os3.homedir()) {
   const configPath = path9.join(home, ".kimi", "config.toml");
   let raw;
   try {
-    raw = readFileSync4(configPath, "utf8");
+    raw = readFileSync3(configPath, "utf8");
   } catch {
     return null;
   }
@@ -4471,8 +4724,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}_`;
@@ -4517,13 +4770,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 {};
@@ -4581,7 +4834,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]);
@@ -4606,7 +4859,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 = {
@@ -4622,8 +4875,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);
@@ -4704,7 +4958,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);
@@ -4744,7 +4998,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;
@@ -4774,7 +5028,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 {
@@ -4908,7 +5162,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,
@@ -5500,7 +5754,7 @@ 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;
     }
@@ -5546,11 +5800,11 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
     return null;
   }
 }
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir) {
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), fallbackDir) {
   const directPath = path12.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
-      if (statSync2(directPath).isFile()) {
+      if (statSync(directPath).isFile()) {
         return { label: sessionId, path: directPath, runtime, reachable: true };
       }
     } catch {
@@ -6494,6 +6748,7 @@ var AgentProcessManager = class _AgentProcessManager {
   driverResolver;
   defaultAgentEnvVarsProvider;
   tracer;
+  cliTransportTraceDir = null;
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
   processExitTraceAttrs = /* @__PURE__ */ new WeakMap();
   agentVisibleBoundaries = /* @__PURE__ */ new Map();
@@ -6504,7 +6759,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;
@@ -6524,6 +6779,9 @@ var AgentProcessManager = class _AgentProcessManager {
   setTracer(tracer) {
     this.tracer = tracer;
   }
+  setCliTransportTraceDir(traceDir) {
+    this.cliTransportTraceDir = traceDir;
+  }
   visibleBoundaryMap(agentId) {
     let map = this.agentVisibleBoundaries.get(agentId);
     if (!map) {
@@ -6628,6 +6886,7 @@ var AgentProcessManager = class _AgentProcessManager {
         });
       },
       recordProxyFailure: (input) => this.recordAgentProxyFailure(agentId, input),
+      recordTransportNormalizedError: (input) => this.recordAgentProxyTransportNormalizedError(agentId, input),
       recordFreshnessDecision: (input) => {
         this.recordDaemonTrace("daemon.agent.inbox.freshness_decision", {
           agentId,
@@ -6656,6 +6915,22 @@ var AgentProcessManager = class _AgentProcessManager {
       error_message: input.errorMessage
     }, "error");
   }
+  recordAgentProxyTransportNormalizedError(agentId, input) {
+    this.recordDaemonTrace("daemon.transport.normalized_error", {
+      producer: "daemon",
+      agentId,
+      normalized_code: input.normalizedCode,
+      route_family: input.routeFamily,
+      response_started: input.responseStarted,
+      upstream_layer: input.upstreamLayer,
+      ...typeof input.upstreamStatus === "number" ? { upstream_status: input.upstreamStatus } : {},
+      ...input.originalMessage ? { original_message: input.originalMessage } : {},
+      launchId: input.launchId,
+      target_host_class: input.targetHostClass,
+      downstream_caller: input.downstreamCaller,
+      upstream: input.upstream
+    }, "error");
+  }
   recordFreshnessDecisionActivity(agentId, input) {
     if (input.decision !== "local_hold" && input.decision !== "syncing_hold") return;
     const ap = this.agents.get(agentId);
@@ -7055,7 +7330,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         slockCliPath: this.slockCliPath,
         daemonApiKey: this.daemonApiKey,
         launchId: launchId || null,
-        agentCredentialProxyInboxCoordinator: this.createAgentProxyInboxCoordinator(agentId)
+        agentCredentialProxyInboxCoordinator: this.createAgentProxyInboxCoordinator(agentId),
+        cliTransportTraceDir: this.cliTransportTraceDir
       });
       this.recordDaemonTrace("daemon.agent.spawn.created", {
         ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, launchId),
@@ -7388,7 +7664,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)}`
       })
     });
@@ -8199,7 +8475,7 @@ 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 home = os5.homedir();
     const workspaceDir = path12.join(this.dataDir, agentId);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
     const globalResults = await Promise.all(
@@ -9626,8 +9902,8 @@ 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 { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import os6 from "os";
 import path13 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
@@ -9654,14 +9930,14 @@ function ownerPath(lockDir) {
 }
 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;
   }
@@ -9690,7 +9966,7 @@ function acquireDaemonMachineLock(options) {
       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)
@@ -9733,7 +10009,7 @@ 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 { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
 import path14 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
@@ -9757,7 +10033,8 @@ var DIAGNOSTIC_ERROR_ATTRS = /* @__PURE__ */ new Set([
   "runtime_error_message_present",
   "runtime_error_message_length_bucket",
   "runtime_error_message_truncated",
-  "runtime_error_message_excerpt"
+  "runtime_error_message_excerpt",
+  "original_message"
 ]);
 var LocalRotatingTraceSink = class {
   traceDir;
@@ -9805,13 +10082,13 @@ var LocalRotatingTraceSink = class {
         `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;
+      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)) {
@@ -9851,14 +10128,13 @@ function sanitizeAttrs(attrs) {
   if (!attrs) return void 0;
   const sanitized = {};
   for (const [key, value] of Object.entries(attrs)) {
+    if (value === null || value === void 0 || value === "") continue;
     if (isDiagnosticIdAttr(key)) {
-      if (value === null || value === void 0 || value === "") continue;
       sanitized[key] = sanitizeValue(value);
       continue;
     }
     if (isDiagnosticErrorAttr(key)) {
-      if (value === null || value === void 0 || value === "") continue;
-      sanitized[key] = sanitizeValue(value);
+      sanitized[key] = sanitizeDiagnosticErrorValue(key, value);
       continue;
     }
     if (shouldDropAttr(key)) continue;
@@ -9878,6 +10154,11 @@ function sanitizeValue(value) {
   }
   return String(value);
 }
+function sanitizeDiagnosticErrorValue(key, value) {
+  if (key !== "original_message" || typeof value !== "string") return sanitizeValue(value);
+  const normalized = value.replace(/sk_(?:agent|machine|computer)_[A-Za-z0-9_-]+/g, "sk_[redacted]").replace(/sap_[A-Za-z0-9_-]+/g, "sap_[redacted]").replace(/https?:\/\/\S+/g, "[url]").replace(/\s+/g, " ").trim();
+  return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
 function shouldDropAttr(key) {
   const normalized = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
   if (/(^|_)(api_key|auth_token|token|secret|password|cookie|credential)(_|$)/i.test(normalized)) {
@@ -10246,7 +10527,7 @@ 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>";
@@ -10525,6 +10806,7 @@ var DaemonCore = class {
       sink: this.localTraceSink
     });
     this.agentManager.setTracer(this.tracer);
+    this.agentManager.setCliTransportTraceDir(path16.join(machineDir, "traces"));
   }
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
@@ -10947,8 +11229,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", {