@botiverse/raft-daemon 0.60.0 → 0.61.0

package/dist/{chunk-65UFKNJJ.js → chunk-XMSXOB5R.js}

@@ -1,10 +1,16 @@
 // src/core.ts
-import path16 from "path";
+import path17 from "path";
 import os8 from "os";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
 
+// ../shared/src/typeGuards.ts
+function makeIsMember(members) {
+  const set = new Set(members);
+  return (value) => typeof value === "string" && set.has(value);
+}
+
 // ../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;
@@ -28,6 +34,10 @@ 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"
 );
+var DM_MESSAGE_RE = new RegExp(
+  String.raw`^dm:@(${SLOCK_REF_DM_PEER_PATTERN})(?::(${SLOCK_REF_THREAD_SHORT_ID_PATTERN}))?\s+msg=(${SLOCK_REF_MESSAGE_ID_PATTERN})$`,
+  "iu"
+);
 
 // ../shared/src/producerFactLineage.ts
 var PRODUCER_FACT_TEXT_LABEL = "producerFactId";
@@ -1278,6 +1288,9 @@ var SERVER_CAPABILITY_MATRIX = {
 
 // ../shared/src/index.ts
 var RUNTIME_CONFIG_VERSION = 1;
+var AGENT_ACTIVITIES = ["online", "thinking", "working", "error", "offline"];
+var isAgentActivity = makeIsMember(AGENT_ACTIVITIES);
+var VALID_ACTIVITIES = new Set(AGENT_ACTIVITIES);
 var EXTERNAL_AGENT_RUNTIME_ID = "external";
 var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
 var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
@@ -1285,7 +1298,11 @@ var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
   { id: "antigravity", displayName: "Antigravity CLI", binary: "agy", supported: true },
-  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
+  // Kimi: prefer the in-process SDK (`kimi-sdk` → "Kimi Code") for new agents.
+  // The legacy `kimi` (kimi-cli child-process) entry stays for backward compat
+  // with existing `runtime=kimi` agents but is labelled deprecated.
+  { id: "kimi-sdk", displayName: "Kimi Code", binary: "", supported: true },
+  { id: "kimi", displayName: "Kimi CLI (deprecated)", binary: "kimi", supported: true },
   { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
   { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
   { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
@@ -1353,6 +1370,15 @@ var RUNTIME_MODELS = {
   // built-in option is to defer to whatever default model the CLI already uses.
   kimi: [
     { id: "default", label: "Configured Default" }
+  ],
+  // kimi-sdk runs the Kimi Code SDK in-process. Surface the canonical model
+  // first so getDefaultModel("kimi-sdk") returns it (without a static entry,
+  // useRuntimeModels falls back to Claude's list and getDefaultModel returns
+  // "sonnet" — which the SDK driver would pass through to the Kimi session
+  // and the LLM call would fail). Mirrors detectKimiSdkModels() in the daemon.
+  "kimi-sdk": [
+    { id: "kimi-code/kimi-for-coding", label: "Kimi-K2.6 (Kimi for Coding)", verified: "launchable" },
+    { id: "kimi-k2-0905-preview", label: "Kimi K2 (preview)", verified: "suggestion_only" }
   ]
 };
 function getDefaultModel(runtimeId) {
@@ -1538,10 +1564,10 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync4, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
-import path12 from "path";
+import path13 from "path";
 import os6 from "os";
 
 // src/drivers/claude.ts
@@ -3341,6 +3367,7 @@ function routeFamilyForPath(pathname) {
 function daemonUpstreamTargetHostClass(url) {
   const hostname = url.hostname.toLowerCase();
   if (hostname === "api.slock.ai") return "api.slock.ai";
+  if (hostname === "api.raft.build") return "api.raft.build";
   return "custom_server";
 }
 function upstreamLayerForProxyError(err) {
@@ -6206,11 +6233,455 @@ function detectKimiModels(home = os4.homedir()) {
   return { models, default: defaultModel };
 }
 
+// src/drivers/kimi-sdk.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { EventEmitter } from "events";
+import { mkdirSync as mkdirSync3 } from "fs";
+import path9 from "path";
+import { createRequire as createRequire2 } from "module";
+import {
+  createKimiHarness
+} from "@botiverse/kimi-code-sdk";
+var requireFromHere = createRequire2(import.meta.url);
+var KIMI_CODE_USER_AGENT_PRODUCT = "kimi-code-cli";
+var KIMI_CODE_HOST_VERSION = "0.14.3";
+function getDaemonVersion() {
+  try {
+    const pkg = requireFromHere("../../package.json");
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var KIMI_SESSION_DIR = ".kimi-sessions";
+function createKimiSdkEventMappingState(sessionId = null) {
+  return {
+    sessionId,
+    sessionAnnounced: false
+  };
+}
+function buildKimiSessionDir(workingDirectory) {
+  return path9.join(workingDirectory, KIMI_SESSION_DIR);
+}
+function kimiErrorMessage(error) {
+  if (typeof error === "string" && error.trim()) return error.trim();
+  if (error && typeof error === "object") {
+    const record = error;
+    if (typeof record.message === "string" && record.message.trim()) return record.message.trim();
+    try {
+      return JSON.stringify(error);
+    } catch {
+    }
+  }
+  return "Unknown Kimi error";
+}
+function pushSessionInitIfNeeded(state, events) {
+  if (!state.sessionAnnounced && state.sessionId) {
+    events.push({ kind: "session_init", sessionId: state.sessionId });
+    state.sessionAnnounced = true;
+  }
+}
+function mapKimiSdkEventToParsedEvents(event, state) {
+  const events = [];
+  pushSessionInitIfNeeded(state, events);
+  switch (event.type) {
+    // ── content streaming → ParsedEvent ──
+    case "thinking.delta":
+      if (typeof event.delta === "string" && event.delta.length > 0) {
+        events.push({ kind: "thinking", text: event.delta });
+      }
+      return events;
+    case "assistant.delta":
+      if (typeof event.delta === "string" && event.delta.length > 0) {
+        events.push({ kind: "text", text: event.delta });
+      }
+      return events;
+    case "tool.call.started":
+      events.push({
+        kind: "tool_call",
+        name: event.name || "unknown_tool",
+        input: event.args ?? {}
+      });
+      return events;
+    case "tool.result":
+      events.push({ kind: "tool_output", name: "" });
+      return events;
+    case "compaction.started":
+      events.push({ kind: "compaction_started" });
+      return events;
+    case "compaction.completed":
+      events.push({ kind: "compaction_finished" });
+      return events;
+    case "error":
+      events.push({ kind: "error", message: kimiErrorMessage(event) });
+      return events;
+    // ── THE single turn-triggering source class ──
+    case "turn.ended":
+      events.push({ kind: "turn_end", sessionId: state.sessionId || void 0 });
+      return events;
+    // ── explicit drops (RS-004) ──
+    // `warning` is non-fatal in the SDK's vocabulary; mapping it to
+    // ParsedEvent.kind="error" would latch the agent into APM's error state
+    // (lastRuntimeError set by `runtime.error`, then NOT cleared by the
+    // following turn_end) — so a warning would brick the agent until
+    // restart. Drop it here; the SDK's own log already records it.
+    case "warning":
+    // turn / step lifecycle (state-only, no parsed payload)
+    case "turn.started":
+    case "turn.step.started":
+    case "turn.step.completed":
+    case "turn.step.retrying":
+    case "turn.step.interrupted":
+    // tool-call progress / hooks (could elevate to internal_progress in future)
+    case "tool.call.delta":
+    case "tool.progress":
+    case "hook.result":
+    // status / meta updates
+    case "agent.status.updated":
+    case "session.meta.updated":
+    case "goal.updated":
+    case "skill.activated":
+    // MCP infra
+    case "tool.list.updated":
+    case "mcp.server.status":
+    // subagent lifecycle (v0: drop; could surface later)
+    case "subagent.spawned":
+    case "subagent.started":
+    case "subagent.suspended":
+    case "subagent.completed":
+    case "subagent.failed":
+    // compaction sub-cases
+    case "compaction.blocked":
+    case "compaction.cancelled":
+    // out-of-band
+    case "background.task.started":
+    case "background.task.terminated":
+    case "cron.fired":
+      return events;
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
+}
+var KIMI_SDK_RUNTIME_SESSION_DESCRIPTOR = {
+  transport: "sdk",
+  lifecycle: "sdk_session",
+  input: {
+    initial: "start",
+    idle: "sdk_prompt",
+    busy: "sdk_steer"
+  },
+  readiness: "sdk_ready",
+  turnBoundary: "sdk_event",
+  startPolicy: "immediate",
+  inFlightWake: "steer",
+  busyDelivery: "direct",
+  postTurn: "keep_alive"
+};
+async function createKimiAgentSessionForContext(ctx, sessionId) {
+  const sessionDir = buildKimiSessionDir(ctx.workingDirectory);
+  mkdirSync3(sessionDir, { recursive: true });
+  const cliTransport = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+  const spawnEnv = cliTransport.spawnEnv;
+  const wrapperPath = cliTransport.wrapperPath;
+  const homeDir = spawnEnv.KIMI_HOME || (process.env.HOME ? path9.join(process.env.HOME, ".kimi") : path9.join(ctx.workingDirectory, ".kimi"));
+  mkdirSync3(homeDir, { recursive: true });
+  const harness = createKimiHarness({
+    homeDir,
+    identity: {
+      userAgentProduct: KIMI_CODE_USER_AGENT_PRODUCT,
+      version: KIMI_CODE_HOST_VERSION,
+      userAgentSuffix: `slock-daemon/${getDaemonVersion()}`
+    }
+  });
+  const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+  const sessionFields = {
+    workDir: ctx.workingDirectory,
+    ...launchRuntimeFields.model && launchRuntimeFields.model !== "default" ? { model: launchRuntimeFields.model } : {}
+  };
+  let session;
+  if (ctx.config.sessionId) {
+    try {
+      session = await harness.resumeSession({ ...sessionFields, id: ctx.config.sessionId });
+    } catch (resumeError) {
+      void resumeError;
+      session = await harness.createSession(sessionFields);
+    }
+  } else {
+    session = await harness.createSession(sessionFields);
+  }
+  return { harness, session, wrapperPath };
+}
+var KimiSdkRuntimeSession = class {
+  constructor(ctx, setCurrentSessionId, sessionFactory = createKimiAgentSessionForContext) {
+    this.ctx = ctx;
+    this.setCurrentSessionId = setCurrentSessionId;
+    this.sessionFactory = sessionFactory;
+    this.mappingState = createKimiSdkEventMappingState(ctx.config.sessionId || null);
+  }
+  descriptor = KIMI_SDK_RUNTIME_SESSION_DESCRIPTOR;
+  events = new EventEmitter();
+  mappingState;
+  harness = null;
+  session = null;
+  wrapperPath = null;
+  unsubscribe = null;
+  started = false;
+  didClose = false;
+  requestedStopReason;
+  exitInfo = null;
+  get pid() {
+    return void 0;
+  }
+  get currentSessionId() {
+    return this.mappingState.sessionId;
+  }
+  get exitCode() {
+    return this.exitInfo?.code ?? null;
+  }
+  get signalCode() {
+    return this.exitInfo?.signal ?? null;
+  }
+  get closed() {
+    return this.didClose;
+  }
+  on(event, cb) {
+    this.events.on(event, cb);
+  }
+  async start(input) {
+    if (this.started) {
+      return { ok: false, reason: "runtime_error", error: "runtime session already started" };
+    }
+    if (this.didClose) return { ok: false, reason: "closed" };
+    this.started = true;
+    const sessionId = input.sessionId || this.ctx.config.sessionId || randomUUID3();
+    this.mappingState.sessionId = sessionId;
+    this.setCurrentSessionId(sessionId);
+    const { harness, session, wrapperPath } = await this.sessionFactory(
+      {
+        ...this.ctx,
+        config: {
+          ...this.ctx.config,
+          sessionId
+        }
+      },
+      sessionId
+    );
+    this.harness = harness;
+    this.session = session;
+    this.wrapperPath = wrapperPath;
+    this.mappingState.sessionId = session.id;
+    this.setCurrentSessionId(session.id);
+    session.setApprovalHandler(() => ({ decision: "approved", scope: "session" }));
+    this.unsubscribe = session.onEvent((event) => {
+      for (const parsed of mapKimiSdkEventToParsedEvents(event, this.mappingState)) {
+        this.events.emit("runtime_event", parsed);
+      }
+    });
+    this.emitSessionInit();
+    const firstTurnText = this.composeFirstTurnPreamble(input.text);
+    this.launchPrompt(firstTurnText);
+    return { ok: true, acceptedAs: "prompt" };
+  }
+  composeFirstTurnPreamble(turnText) {
+    const sections = [];
+    if (this.ctx.standingPrompt) {
+      sections.push(this.ctx.standingPrompt);
+    }
+    if (this.wrapperPath) {
+      sections.push(
+        `## CLI invocation note (Kimi SDK in-process runtime)
+
+When you run \`raft\` CLI commands from your bash tool, **use this absolute path** because PATH is not pre-injected for the in-process Kimi SDK:
+
+\`\`\`
+${this.wrapperPath}
+\`\`\`
+
+So instead of \`raft message send ...\`, run \`${this.wrapperPath} message send ...\` (every \`raft\` reference in the protocol above maps to this wrapper). The wrapper carries this agent's identity automatically; do not pass auth tokens explicitly.`
+      );
+    }
+    sections.push(turnText);
+    return sections.join("\n\n---\n\n");
+  }
+  send(input) {
+    if (this.didClose) return { ok: false, reason: "closed" };
+    const session = this.session;
+    if (!session) return { ok: false, reason: "closed" };
+    if (input.mode === "busy") {
+      this.deferSdkCall(() => session.steer(input.text));
+      return { ok: true, acceptedAs: "steer" };
+    }
+    this.launchPrompt(input.text);
+    return { ok: true, acceptedAs: "prompt" };
+  }
+  async stop(opts) {
+    if (this.didClose) return;
+    this.requestedStopReason = opts?.reason;
+    const signal = opts?.signal ?? "SIGTERM";
+    const session = this.session;
+    if (session) {
+      try {
+        await session.cancel();
+      } catch (error) {
+        this.events.emit("stderr", kimiErrorMessage(error));
+      }
+    }
+    await this.disposeSession();
+    this.emitExitAndClose(null, signal);
+  }
+  async dispose() {
+    if (this.didClose) return;
+    await this.disposeSession();
+    this.emitExitAndClose(0, null);
+  }
+  emitSessionInit() {
+    const sessionId = this.mappingState.sessionId;
+    if (!sessionId || this.mappingState.sessionAnnounced) return;
+    this.mappingState.sessionAnnounced = true;
+    this.events.emit("runtime_event", { kind: "session_init", sessionId });
+  }
+  launchPrompt(text) {
+    const session = this.session;
+    if (!session) {
+      this.events.emit("runtime_event", {
+        kind: "error",
+        message: "Kimi SDK session is not started"
+      });
+      return;
+    }
+    this.deferSdkCall(() => session.prompt(text));
+  }
+  deferSdkCall(invoke) {
+    setImmediate(() => {
+      if (this.didClose) return;
+      try {
+        void invoke().catch((error) => {
+          if (this.didClose) return;
+          this.events.emit("runtime_event", {
+            kind: "error",
+            message: kimiErrorMessage(error)
+          });
+        });
+      } catch (error) {
+        if (this.didClose) return;
+        this.events.emit("runtime_event", {
+          kind: "error",
+          message: kimiErrorMessage(error)
+        });
+      }
+    });
+  }
+  async disposeSession() {
+    const unsubscribe = this.unsubscribe;
+    this.unsubscribe = null;
+    try {
+      unsubscribe?.();
+    } catch {
+    }
+    const session = this.session;
+    this.session = null;
+    try {
+      await session?.close();
+    } catch (error) {
+      this.events.emit("stderr", kimiErrorMessage(error));
+    }
+    const harness = this.harness;
+    this.harness = null;
+    try {
+      await harness?.close();
+    } catch (error) {
+      this.events.emit("stderr", kimiErrorMessage(error));
+    }
+  }
+  emitExitAndClose(code, signal) {
+    if (this.didClose) return;
+    this.didClose = true;
+    const info = {
+      code,
+      signal,
+      reason: this.requestedStopReason ? "requested" : "runtime_exit"
+    };
+    this.exitInfo = info;
+    this.events.emit("exit", info);
+    this.events.emit("close", info);
+  }
+};
+var KIMI_SDK_DEFAULT_MODELS = [
+  // Canonical Kimi Code SDK model (matches the `default_model` upstream
+  // ships in `~/.kimi/config.toml` after `kimi login`). Mirrored as the first
+  // entry in `RUNTIME_MODELS["kimi-sdk"]` (packages/shared/src/index.ts) so
+  // both the daemon's launch resolution and the web's getDefaultModel agree.
+  { id: "kimi-code/kimi-for-coding", label: "Kimi-K2.6 (Kimi for Coding)", verified: "launchable" },
+  { id: "kimi-k2-0905-preview", label: "Kimi K2 (preview)", verified: "suggestion_only" }
+];
+function detectKimiSdkModels() {
+  return { models: KIMI_SDK_DEFAULT_MODELS };
+}
+var KimiSdkDriver = class {
+  id = "kimi-sdk";
+  supportsNativeStandingPrompt = true;
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "suggestion_only",
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
+  };
+  supportsStdinNotification = true;
+  busyDeliveryMode = "direct";
+  sessionId = null;
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  probe() {
+    return { available: true };
+  }
+  async detectModels() {
+    return detectKimiSdkModels();
+  }
+  createSession(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    return new KimiSdkRuntimeSession(ctx, (sessionId) => {
+      this.sessionId = sessionId;
+    });
+  }
+  async spawn(_ctx) {
+    throw new Error("KimiSdkDriver uses a native RuntimeSession; child-process spawn is unsupported");
+  }
+  parseLine(_line) {
+    return [];
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildCliTransportSystemPrompt(config, {
+      extraCriticalRules: [],
+      postStartupNotes: [
+        "**Kimi SDK runtime note:** Slock keeps Kimi running as a persistent SDK session. While you are working, Slock may send inbox-count notifications into the current turn; call `raft message check` at natural breakpoints."
+      ],
+      includeStdinNotificationSection: true,
+      messageNotificationStyle: "direct"
+    });
+  }
+};
+
 // src/drivers/opencode.ts
 import { spawn as spawn8, spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
 import os5 from "os";
-import path9 from "path";
+import path10 from "path";
 var SLOCK_AGENT_NAME = "slock";
 var NO_MESSAGE_PROMPT = "No new messages are pending. Stop now.";
 var FIRST_MESSAGE_TASK_PREFIX = "First message task (system-triggered):";
@@ -6239,7 +6710,7 @@ function parseUserOpenCodeConfig(ctx) {
   return parseOpenCodeConfigContent(raw);
 }
 function readLocalOpenCodeConfig(home = os5.homedir()) {
-  const configPath = path9.join(home, ".config", "opencode", "opencode.json");
+  const configPath = path10.join(home, ".config", "opencode", "opencode.json");
   try {
     return parseOpenCodeConfigContent(readFileSync4(configPath, "utf8"));
   } catch {
@@ -6437,11 +6908,11 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   };
 }
 function isWindowsCommandShim(commandPath) {
-  const ext = path9.win32.extname(commandPath).toLowerCase();
+  const ext = path10.win32.extname(commandPath).toLowerCase();
   return ext === ".cmd" || ext === ".bat";
 }
 function opencodePackageEntryCandidates(packageRoot) {
-  const winPath = path9.win32;
+  const winPath = path10.win32;
   return [
     winPath.join(packageRoot, "bin", "opencode.exe"),
     winPath.join(packageRoot, "bin", "opencode.js"),
@@ -6450,7 +6921,7 @@ function opencodePackageEntryCandidates(packageRoot) {
   ];
 }
 function openCodeSpecForEntry(entry, commandArgs) {
-  if (path9.win32.extname(entry).toLowerCase() === ".exe") {
+  if (path10.win32.extname(entry).toLowerCase() === ".exe") {
     return { command: entry, args: commandArgs, shell: false };
   }
   return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
@@ -6459,7 +6930,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
   const existsSyncFn = deps.existsSyncFn ?? existsSync8;
   const execFileSyncFn = deps.execFileSyncFn;
   const env = deps.env ?? process.env;
-  const winPath = path9.win32;
+  const winPath = path10.win32;
   const candidates = [];
   if (execFileSyncFn) {
     try {
@@ -6487,7 +6958,7 @@ function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
 function extractWindowsShimTargets(commandPath, deps = {}) {
   if (!isWindowsCommandShim(commandPath)) return [];
   const readFileSyncFn = deps.readFileSyncFn ?? readFileSync4;
-  const commandDir = path9.win32.dirname(commandPath);
+  const commandDir = path10.win32.dirname(commandPath);
   let raw;
   try {
     raw = String(readFileSyncFn(commandPath, "utf8"));
@@ -6498,7 +6969,7 @@ function extractWindowsShimTargets(commandPath, deps = {}) {
   const dp0Pattern = /%~dp0\\?([^"\r\n]*?opencode\.(?:exe|js|mjs|cjs))/gi;
   for (const match of raw.matchAll(dp0Pattern)) {
     const relative = match[1]?.replace(/^\\+/, "");
-    if (relative) candidates.push(path9.win32.normalize(path9.win32.join(commandDir, relative)));
+    if (relative) candidates.push(path10.win32.normalize(path10.win32.join(commandDir, relative)));
   }
   return candidates;
 }
@@ -6512,7 +6983,7 @@ function resolveOpenCodeSpawn(commandArgs, deps = {}) {
     };
   }
   const command = resolveCommandOnPath("opencode", deps);
-  if (command && path9.win32.extname(command).toLowerCase() === ".exe") {
+  if (command && path10.win32.extname(command).toLowerCase() === ".exe") {
     return { command, args: commandArgs, shell: false };
   }
   const packageEntry = resolveWindowsOpenCodePackageEntry(command, deps);
@@ -6682,17 +7153,16 @@ var OpenCodeDriver = class {
 };
 
 // src/drivers/pi.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { EventEmitter } from "events";
-import { mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
-import path10 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { EventEmitter as EventEmitter2 } from "events";
+import { mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
+import path11 from "path";
 import {
   AuthStorage,
   createBashTool,
-  createAgentSession,
-  DefaultResourceLoader,
+  createAgentSessionFromServices,
+  createAgentSessionServices,
   getAgentDir,
-  ModelRegistry,
   SessionManager,
   SettingsManager,
   VERSION as PI_SDK_VERSION
@@ -6712,7 +7182,7 @@ function createPiSdkEventMappingState(sessionId = null) {
   };
 }
 function buildPiSessionDir(workingDirectory) {
-  return path10.join(workingDirectory, PI_SESSION_DIR);
+  return path11.join(workingDirectory, PI_SESSION_DIR);
 }
 async function buildPiSpawnEnv(ctx) {
   return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
@@ -6734,7 +7204,7 @@ function findPiSessionFile(sessionDir, sessionId) {
   }
   const suffix = `_${sessionId}.jsonl`;
   const match = entries.find((entry) => entry.endsWith(suffix));
-  return match ? path10.join(sessionDir, match) : null;
+  return match ? path11.join(sessionDir, match) : null;
 }
 function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
@@ -6751,8 +7221,70 @@ function detectPiModelsFromRegistry(modelRegistry) {
   }
   return models.length > 0 ? { models } : null;
 }
-function detectPiModels(modelRegistry = ModelRegistry.create(AuthStorage.create())) {
-  return detectPiModelsFromRegistry(modelRegistry);
+function applyPiDaemonSettingsOverrides(settingsManager) {
+  settingsManager.applyOverrides({ compaction: { enabled: PI_SDK_COMPACTION_ENABLED } });
+}
+function logPiServiceDiagnostics(context, services) {
+  for (const diagnostic of services.diagnostics) {
+    const message = `[pi-driver] ${context} diagnostic: ${diagnostic.message}`;
+    if (diagnostic.type === "info") {
+      console.info(message);
+    } else {
+      console.warn(message);
+    }
+  }
+}
+function formatPiModelLogId(model) {
+  return model ? `${model.provider}/${model.id}` : "default";
+}
+function piServiceDiagnosticTraceAttrs(services) {
+  let info = 0;
+  let warning = 0;
+  for (const diagnostic of services.diagnostics) {
+    if (diagnostic.type === "info") {
+      info++;
+    } else {
+      warning++;
+    }
+  }
+  return {
+    diagnostics_count: services.diagnostics.length,
+    diagnostic_info_count: info,
+    diagnostic_warning_count: warning
+  };
+}
+function addPiServiceTraceEvent(span, name, services, attrs = {}) {
+  span?.addEvent(name, {
+    available_models_count: services.modelRegistry.getAvailable().length,
+    ...piServiceDiagnosticTraceAttrs(services),
+    ...attrs
+  });
+}
+async function detectPiModels(modelRegistry, traceContext = {}) {
+  if (modelRegistry) {
+    return detectPiModelsFromRegistry(modelRegistry);
+  }
+  const agentDir = getAgentDir();
+  const services = await createAgentSessionServices({
+    cwd: process.cwd(),
+    agentDir
+  });
+  logPiServiceDiagnostics("detect_models", services);
+  addPiServiceTraceEvent(traceContext.span, "daemon.pi.models.services_ready", services);
+  const result = detectPiModelsFromRegistry(services.modelRegistry);
+  traceContext.span?.addEvent("daemon.pi.models.result", {
+    available_models_count: services.modelRegistry.getAvailable().length,
+    returned_models_count: result?.models?.length ?? 0,
+    outcome: result ? "models_returned" : "no_models",
+    ...piServiceDiagnosticTraceAttrs(services)
+  });
+  console.info(
+    "[pi-driver] detect_models agentDir=%s available=%d returned=%d",
+    agentDir,
+    services.modelRegistry.getAvailable().length,
+    result?.models?.length ?? 0
+  );
+  return result;
 }
 function humanizePiSegment(value) {
   return value.split(/[-_/]/).filter(Boolean).map(formatPiLabelToken).join(" ");
@@ -6785,7 +7317,7 @@ function piErrorMessage(error) {
   }
   return "Unknown Pi error";
 }
-function pushSessionInitIfNeeded(state, events) {
+function pushSessionInitIfNeeded2(state, events) {
   if (!state.sessionAnnounced && state.sessionId) {
     events.push({ kind: "session_init", sessionId: state.sessionId });
     state.sessionAnnounced = true;
@@ -6822,7 +7354,7 @@ function mapPiAssistantMessageEvent(assistantEvent, state) {
 }
 function mapPiSdkEventToParsedEvents(event, state) {
   const events = [];
-  pushSessionInitIfNeeded(state, events);
+  pushSessionInitIfNeeded2(state, events);
   switch (event.type) {
     case "agent_start":
     case "turn_start":
@@ -6887,49 +7419,127 @@ var PI_IDLE_PROMPT_RETRY_MS = 25;
 var PI_IDLE_PROMPT_MAX_WAIT_MS = 1e3;
 async function createPiAgentSessionForContext(ctx, sessionId) {
   const sessionDir = buildPiSessionDir(ctx.workingDirectory);
-  mkdirSync3(sessionDir, { recursive: true });
-  const spawnEnv = await buildPiSpawnEnv(ctx);
-  const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
-  const authStorage = AuthStorage.create(path10.join(agentDir, "auth.json"));
-  const modelRegistry = ModelRegistry.create(authStorage, path10.join(agentDir, "models.json"));
+  mkdirSync4(sessionDir, { recursive: true });
   const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
-  const model = resolvePiModelFromRegistry(launchRuntimeFields.model, modelRegistry);
-  if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
-    throw new Error(`Pi model not found: ${launchRuntimeFields.model}`);
-  }
-  const settingsManager = SettingsManager.inMemory({ compaction: { enabled: PI_SDK_COMPACTION_ENABLED } });
-  const resourceLoader = new DefaultResourceLoader({
-    cwd: ctx.workingDirectory,
-    agentDir,
-    settingsManager,
-    systemPromptOverride: () => ctx.standingPrompt
+  const requestedModel = launchRuntimeFields.model || "default";
+  const traceSpan = ctx.tracer?.startSpan("daemon.pi.session.create", {
+    surface: "daemon",
+    kind: "internal",
+    attrs: {
+      agentId: ctx.agentId,
+      launchId: ctx.launchId || void 0,
+      runtime: ctx.config.runtime,
+      model: ctx.config.model,
+      session_id_present: Boolean(sessionId),
+      requested_model: requestedModel
+    }
   });
-  await resourceLoader.reload();
-  const existingSessionFile = ctx.config.sessionId ? findPiSessionFile(sessionDir, ctx.config.sessionId) : null;
-  const sessionManager = existingSessionFile ? SessionManager.open(existingSessionFile, sessionDir, ctx.workingDirectory) : SessionManager.create(ctx.workingDirectory, sessionDir, { id: sessionId });
-  const { session } = await createAgentSession({
-    cwd: ctx.workingDirectory,
-    agentDir,
-    model,
-    thinkingLevel: launchRuntimeFields.reasoningEffort,
-    authStorage,
-    modelRegistry,
-    resourceLoader,
-    customTools: [
-      createBashTool(ctx.workingDirectory, {
-        spawnHook: (spawnContext) => ({
-          ...spawnContext,
-          env: {
-            ...spawnContext.env,
-            ...spawnEnv
-          }
+  try {
+    const spawnEnv = await buildPiSpawnEnv(ctx);
+    const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
+    const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
+    const settingsManager = SettingsManager.create(ctx.workingDirectory, agentDir);
+    const services = await createAgentSessionServices({
+      cwd: ctx.workingDirectory,
+      agentDir,
+      authStorage,
+      settingsManager,
+      resourceLoaderOptions: {
+        systemPromptOverride: () => ctx.standingPrompt
+      }
+    });
+    applyPiDaemonSettingsOverrides(services.settingsManager);
+    logPiServiceDiagnostics("create_session", services);
+    addPiServiceTraceEvent(traceSpan, "daemon.pi.session.services_ready", services, {
+      agent_dir_source: spawnEnv.PI_CODING_AGENT_DIR ? "spawn_env" : "default"
+    });
+    const model = resolvePiModelFromRegistry(launchRuntimeFields.model, services.modelRegistry);
+    const resolvedModel = formatPiModelLogId(model);
+    traceSpan?.addEvent("daemon.pi.session.model_resolved", {
+      available_models_count: services.modelRegistry.getAvailable().length,
+      requested_model: requestedModel,
+      requested_model_explicit: requestedModel !== "default",
+      resolved_model: resolvedModel,
+      resolved_model_present: Boolean(model)
+    });
+    console.info(
+      "[pi-driver] create_session services_ready agentDir=%s available=%d requested=%s resolved=%s",
+      agentDir,
+      services.modelRegistry.getAvailable().length,
+      requestedModel,
+      resolvedModel
+    );
+    if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
+      console.warn(
+        "[pi-driver] create_session missing_model requested=%s available=%d",
+        requestedModel,
+        services.modelRegistry.getAvailable().length
+      );
+      traceSpan?.addEvent("daemon.pi.session.missing_model", {
+        available_models_count: services.modelRegistry.getAvailable().length,
+        requested_model: requestedModel
+      });
+      traceSpan?.end("error", {
+        attrs: {
+          outcome: "missing_model",
+          available_models_count: services.modelRegistry.getAvailable().length,
+          requested_model: requestedModel,
+          resolved_model_present: false,
+          ...piServiceDiagnosticTraceAttrs(services)
+        }
+      });
+      throw new Error(`Pi model not found: ${launchRuntimeFields.model}`);
+    }
+    const existingSessionFile = ctx.config.sessionId ? findPiSessionFile(sessionDir, ctx.config.sessionId) : null;
+    const sessionManager = existingSessionFile ? SessionManager.open(existingSessionFile, sessionDir, ctx.workingDirectory) : SessionManager.create(ctx.workingDirectory, sessionDir, { id: sessionId });
+    const { session } = await createAgentSessionFromServices({
+      services,
+      sessionManager,
+      model,
+      thinkingLevel: launchRuntimeFields.reasoningEffort,
+      customTools: [
+        createBashTool(ctx.workingDirectory, {
+          spawnHook: (spawnContext) => ({
+            ...spawnContext,
+            env: {
+              ...spawnContext.env,
+              ...spawnEnv
+            }
+          })
         })
-      })
-    ],
-    sessionManager,
-    settingsManager
-  });
-  return session;
+      ]
+    });
+    traceSpan?.addEvent("daemon.pi.session.started", {
+      requested_model: requestedModel,
+      resolved_model: resolvedModel,
+      session_id_present: Boolean(session.sessionId)
+    });
+    traceSpan?.end("ok", {
+      attrs: {
+        outcome: "started",
+        available_models_count: services.modelRegistry.getAvailable().length,
+        requested_model: requestedModel,
+        resolved_model: resolvedModel,
+        resolved_model_present: Boolean(model),
+        ...piServiceDiagnosticTraceAttrs(services)
+      }
+    });
+    console.info(
+      "[pi-driver] create_session started sessionId=%s requested=%s resolved=%s",
+      sessionId,
+      requestedModel,
+      resolvedModel
+    );
+    return session;
+  } catch (error) {
+    traceSpan?.end("error", {
+      attrs: {
+        outcome: "error",
+        error_class: error instanceof Error ? error.name : typeof error
+      }
+    });
+    throw error;
+  }
 }
 var PiSdkRuntimeSession = class {
   constructor(ctx, setCurrentSessionId, sessionFactory = createPiAgentSessionForContext) {
@@ -6939,7 +7549,7 @@ var PiSdkRuntimeSession = class {
     this.mappingState = createPiSdkEventMappingState(ctx.config.sessionId || null);
   }
   descriptor = PI_RUNTIME_SESSION_DESCRIPTOR;
-  events = new EventEmitter();
+  events = new EventEmitter2();
   mappingState;
   session = null;
   unsubscribe = null;
@@ -6971,7 +7581,7 @@ var PiSdkRuntimeSession = class {
     }
     if (this.didClose) return { ok: false, reason: "closed" };
     this.started = true;
-    const sessionId = input.sessionId || this.ctx.config.sessionId || randomUUID3();
+    const sessionId = input.sessionId || this.ctx.config.sessionId || randomUUID4();
     this.mappingState.sessionId = sessionId;
     this.setCurrentSessionId(sessionId);
     const session = await this.sessionFactory({
@@ -7145,8 +7755,8 @@ var PiDriver = class {
       version: PI_SDK_VERSION
     };
   }
-  async detectModels() {
-    return detectPiModels();
+  async detectModels(ctx) {
+    return detectPiModels(void 0, ctx);
   }
   createSession(ctx) {
     this.sessionId = ctx.config.sessionId || null;
@@ -7182,7 +7792,7 @@ function delay(ms) {
 }
 
 // src/drivers/runtimeSession.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 function descriptorFromDriver(driver) {
   const lifecycle = driver.lifecycle.kind === "per_turn" ? "turn_based" : "persistent_stream";
   const idle = driver.supportsStdinNotification ? "stdin" : "unsupported";
@@ -7210,7 +7820,7 @@ var ChildProcessRuntimeSession = class {
     this.descriptor = descriptorFromDriver(driver);
   }
   descriptor;
-  events = new EventEmitter2();
+  events = new EventEmitter3();
   process = null;
   started = false;
   stdoutBuffer = "";
@@ -7323,7 +7933,13 @@ var driverFactories = {
   copilot: () => new CopilotDriver(),
   cursor: () => new CursorDriver(),
   gemini: () => new GeminiDriver(),
+  // Two separate Kimi runtimes (per #proj-runtime:cc818e65 6/16 consensus):
+  //   - `kimi`     = legacy kimi-cli child-process driver. Backward-compat for
+  //                  existing `runtime=kimi` agents. Frontend marks deprecated.
+  //   - `kimi-sdk` = canonical in-process SDK driver. Frontend label "Kimi Code".
+  // No alias / no auto-migration; explicit pick at agent-create time.
   kimi: () => new KimiDriver(),
+  "kimi-sdk": () => new KimiSdkDriver(),
   opencode: () => new OpenCodeDriver(),
   pi: () => new PiDriver()
 };
@@ -7338,7 +7954,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("..");
 }
@@ -7346,7 +7962,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 {
@@ -7395,7 +8011,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);
@@ -7414,7 +8030,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 {
@@ -7965,12 +8581,12 @@ function findSessionJsonl(root, predicate) {
     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;
@@ -7983,9 +8599,9 @@ 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`);
+    const dir = path13.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync5(dir, { recursive: true });
+    const filePath = path13.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
     writeFileSync4(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
@@ -8017,7 +8633,7 @@ function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath) {
   return defaultHomeDir;
 }
 function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir) {
-  const directPath = path12.isAbsolute(sessionId) ? sessionId : null;
+  const directPath = path13.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
       if (statSync(directPath).isFile()) {
@@ -8026,7 +8642,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), f
     } 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;
@@ -8751,6 +9367,9 @@ function resumeSessionRecoveryReason(ap) {
     if (candidates.some(isOpenCodeReplayRejectedByProvider)) return "provider_replay_rejected";
     return null;
   }
+  if (ap.driver.id === "pi") {
+    return candidates.some(isPiReplayRejectedByProvider) ? "provider_replay_rejected" : null;
+  }
   if (ap.driver.id === "gemini") {
     return candidates.some(
       (text) => /Error resuming session:\s*Invalid session identifier/i.test(text) && text.includes(ap.sessionId)
@@ -8761,9 +9380,13 @@ function resumeSessionRecoveryReason(ap) {
 function isOpenCodeReplayRejectedByProvider(text) {
   return /Invalid request:\s*the message at position \d+ with role ['"]?assistant['"]? must not be empty/i.test(text);
 }
+function isPiReplayRejectedByProvider(text) {
+  return /Cannot continue from message role:\s*assistant/i.test(text);
+}
 function resumeSessionRuntimeLabel(runtimeId) {
   if (runtimeId === "opencode") return "OpenCode";
   if (runtimeId === "gemini") return "Gemini";
+  if (runtimeId === "pi") return "Pi";
   return "Claude";
 }
 function classifyActivityDetailForTrace(detail) {
@@ -9032,6 +9655,7 @@ var AgentProcessManager = class _AgentProcessManager {
   maxConcurrentAgentStarts;
   agentStartIntervalMs;
   startingInboxes = /* @__PURE__ */ new Map();
+  terminalRuntimeFailures = /* @__PURE__ */ new Map();
   pendingStartRebinds = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
@@ -9969,7 +10593,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;
@@ -9983,23 +10607,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);
           }
         }
@@ -10116,7 +10740,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         daemonApiKey: this.daemonApiKey,
         launchId: effectiveLaunchId,
         agentCredentialProxyInboxCoordinator: this.createAgentProxyInboxCoordinator(agentId),
-        cliTransportTraceDir: this.cliTransportTraceDir
+        cliTransportTraceDir: this.cliTransportTraceDir,
+        tracer: this.tracer
       };
       const runtime = driver.createSession?.(runtimeContext) ?? createChildProcessRuntimeSession(driver, runtimeContext);
       agentProcess = {
@@ -10395,10 +11020,24 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           }
         }
       });
-      const startResult = await runtime.start({ text: prompt, sessionId: effectiveConfig.sessionId || null });
+      let startResult;
+      try {
+        startResult = await runtime.start({ text: prompt, sessionId: effectiveConfig.sessionId || null });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        startResult = { ok: false, reason: "runtime_error", error: message };
+      }
       if (!startResult.ok) {
+        const diagnostics = startResult.error ? buildRuntimeErrorDiagnosticEnvelope(startResult.error) : null;
+        this.recordDaemonTrace("daemon.agent.runtime_start.failed", {
+          ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, agentProcess.launchId || void 0, wakeMessageTransient),
+          runtime_start_reason: startResult.reason,
+          error_present: Boolean(startResult.error),
+          runtime_error_class: diagnostics?.spanAttrs.runtime_error_class
+        }, "error");
         throw new Error(`Runtime session failed to start: ${startResult.reason}${startResult.error ? ` (${startResult.error})` : ""}`);
       }
+      this.terminalRuntimeFailures.delete(agentId);
       this.recordDaemonTrace("daemon.agent.spawn.created", {
         ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, agentProcess.launchId || void 0, wakeMessageTransient),
         detached: false,
@@ -10452,6 +11091,52 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
     this.agents.delete(agentId);
     this.idleAgentConfigs.delete(agentId);
+    this.terminalRuntimeFailures.delete(agentId);
+  }
+  cleanupTerminalRuntimeFailure(agentId, ap, detail) {
+    if (this.agents.get(agentId) !== ap) return;
+    ap.notifications.clear();
+    this.clearRuntimeErrorDeliveryBackoff(ap);
+    if (ap.pendingTrajectory?.timer) {
+      clearTimeout(ap.pendingTrajectory.timer);
+      ap.pendingTrajectory.timer = null;
+    }
+    if (ap.activityHeartbeat) {
+      clearInterval(ap.activityHeartbeat);
+      ap.activityHeartbeat = null;
+    }
+    this.clearCompactionWatchdog(ap);
+    this.clearRuntimeStartupTimeout(ap);
+    this.clearStalledRecoverySigtermWatchdog(ap);
+    cleanupAgentCredentialProxy(agentId, ap.launchId);
+    this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
+    this.idleAgentConfigs.delete(agentId);
+    const pending = this.startingInboxes.get(agentId) || [];
+    if (ap.inbox.length > 0) {
+      this.startingInboxes.set(agentId, [...pending, ...ap.inbox]);
+    }
+    this.terminalRuntimeFailures.set(agentId, { detail, launchId: ap.launchId });
+    this.agents.delete(agentId);
+    const diagnostics = buildRuntimeErrorDiagnosticEnvelope(detail);
+    this.recordDaemonTrace("daemon.agent.terminal_runtime_error.cleanup", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      session_id_present: Boolean(ap.sessionId),
+      process_pid_present: typeof ap.runtime.pid === "number",
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.notifications.pendingCount,
+      runtime_error_class: diagnostics.spanAttrs.runtime_error_class
+    }, "error");
+    this.runtimeExitTraceAttrs.set(ap.runtime, {
+      stop_source: "terminal_runtime_error",
+      runtime_error_class: diagnostics.spanAttrs.runtime_error_class
+    });
+    void ap.runtime.stop({ signal: "SIGTERM", reason: "terminal_runtime_error" }).catch((err) => {
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after terminal runtime error: ${reason}`);
+    });
   }
   cacheStartupTimeoutRetryConfig(agentId, ap) {
     const retryConfig = {
@@ -10690,6 +11375,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     this.cancelQueuedAgentStart(agentId, "stop requested");
     this.pendingStartRebinds.delete(agentId);
     this.idleAgentConfigs.delete(agentId);
+    this.terminalRuntimeFailures.delete(agentId);
     const ap = this.agents.get(agentId);
     if (!ap) {
       if (!silent) {
@@ -10792,6 +11478,35 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         }));
         return true;
       }
+      const terminalRuntimeFailure = this.terminalRuntimeFailures.get(agentId);
+      if (terminalRuntimeFailure) {
+        if (transientDelivery) {
+          this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+            outcome: "transient_dropped_terminal_runtime_error_no_process",
+            accepted: true,
+            process_present: false,
+            cached_idle_config_present: false,
+            terminal_runtime_failure: true,
+            launchId: terminalRuntimeFailure.launchId || void 0
+          }));
+          return true;
+        }
+        const pending = this.startingInboxes.get(agentId) || [];
+        pending.push(message);
+        this.startingInboxes.set(agentId, pending);
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "queued_terminal_runtime_error_no_process",
+          accepted: true,
+          process_present: false,
+          cached_idle_config_present: false,
+          terminal_runtime_failure: true,
+          starting_inbox_count: pending.length,
+          launchId: terminalRuntimeFailure.launchId || void 0
+        }));
+        this.sendAgentStatus(agentId, "inactive", terminalRuntimeFailure.launchId);
+        this.broadcastActivity(agentId, "error", terminalRuntimeFailure.detail, [], terminalRuntimeFailure.launchId);
+        return true;
+      }
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
         const driver = this.driverResolver(cached.config.runtime || "claude");
@@ -11135,7 +11850,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     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})`);
@@ -11196,7 +11911,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path12.join(this.dataDir, agentId);
+    const workspacePath = path13.join(this.dataDir, agentId);
     const runtimeHomeDir = resolveRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspacePath);
     return {
       agentId,
@@ -11490,7 +12205,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
   }
   // 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 {
@@ -11498,8 +12213,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     }
     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;
@@ -11507,14 +12222,14 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     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");
@@ -11550,14 +12265,14 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const idle = this.idleAgentConfigs.get(agentId);
     const config = agent?.config ?? idle?.config ?? null;
     const runtime = runtimeHint || config?.runtime || "claude";
-    const workspaceDir = path12.join(this.dataDir, agentId);
+    const workspaceDir = path13.join(this.dataDir, agentId);
     const home = config ? ensureRuntimeHomeDir(config, os6.homedir(), workspaceDir) : os6.homedir();
     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();
@@ -11586,7 +12301,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = 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);
@@ -11597,7 +12312,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(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);
@@ -12574,8 +13289,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
                 logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after auth error: ${reason}`);
               }
             } else if (stickyTerminalFailure) {
-              ap.notifications.clear();
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
+              this.cleanupTerminalRuntimeFailure(agentId, ap, stickyTerminalFailure.detail);
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} terminal runtime error requires explicit recovery`);
             } else {
               ap.notifications.clearPending();
@@ -13077,8 +13792,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);
@@ -13451,10 +14166,10 @@ var ReminderCache = class {
 };
 
 // src/machineLock.ts
-import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
+import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
 import os7 from "os";
-import path13 from "path";
+import path14 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -13476,7 +14191,7 @@ function resolveDefaultMachineStateRoot() {
   return resolveSlockHomePath("machines");
 }
 function ownerPath(lockDir) {
-  return path13.join(lockDir, "owner.json");
+  return path14.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
@@ -13506,13 +14221,13 @@ 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 token = randomUUID4();
-  mkdirSync5(machineDir, { recursive: true });
+  const machineDir = path14.join(rootDir, lockId);
+  const lockDir = path14.join(machineDir, "daemon.lock");
+  const token = randomUUID5();
+  mkdirSync6(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync5(lockDir);
+      mkdirSync6(lockDir);
       const owner = {
         pid: process.pid,
         token,
@@ -13567,8 +14282,8 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync4, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
-import path14 from "path";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync4, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync6 } 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;
@@ -13605,7 +14320,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));
@@ -13631,11 +14346,11 @@ 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`
       );
@@ -13650,7 +14365,7 @@ var LocalRotatingTraceSink = class {
     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 });
     }
   }
 };
@@ -13738,10 +14453,10 @@ function isDiagnosticErrorAttr(key) {
 }
 
 // src/traceBundleUpload.ts
-import { createHash as createHash6, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID6 } 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/chatBridgeRequest.ts
 var DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS = Number.parseInt(
@@ -13841,8 +14556,8 @@ async function executeResponseRequest(url, init, {
 }
 
 // src/directUploadCapability.ts
-function joinUrl(base, path17) {
-  return `${base.replace(/\/+$/, "")}${path17}`;
+function joinUrl(base, path18) {
+  return `${base.replace(/\/+$/, "")}${path18}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -14061,7 +14776,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);
@@ -14073,8 +14788,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);
@@ -14106,7 +14821,7 @@ var DaemonTraceBundleUploader = class {
       }
       const gzipped = gzipSync(raw);
       const bundleSha256 = sha256Hex(gzipped);
-      const bundleId = randomUUID5();
+      const bundleId = randomUUID6();
       await uploadWithSignedCapability({
         serverUrl: this.options.serverUrl,
         apiKey: this.options.apiKey,
@@ -14148,8 +14863,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 {
@@ -14161,9 +14876,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)}
@@ -14226,6 +14941,24 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
   "daemon.runtime_profile.report.sent": {
     spanAttrs: ["agentId", "launchId", "runtime", "report_source", "model_present", "session_ref_present", "workspace_ref_present"]
   },
+  "daemon.runtime_models.detect": {
+    spanAttrs: ["runtime", "requestId"],
+    eventAttrs: {
+      "daemon.pi.models.services_ready": ["available_models_count", "diagnostics_count", "diagnostic_info_count", "diagnostic_warning_count"],
+      "daemon.pi.models.result": ["available_models_count", "returned_models_count", "diagnostics_count", "diagnostic_info_count", "diagnostic_warning_count", "outcome"]
+    },
+    endAttrs: ["outcome", "models_count", "default_model_present", "verified_as", "error_class"]
+  },
+  "daemon.pi.session.create": {
+    spanAttrs: ["agentId", "launchId", "runtime", "model", "session_id_present", "requested_model"],
+    eventAttrs: {
+      "daemon.pi.session.services_ready": ["available_models_count", "diagnostics_count", "diagnostic_info_count", "diagnostic_warning_count", "agent_dir_source"],
+      "daemon.pi.session.model_resolved": ["available_models_count", "requested_model", "requested_model_explicit", "resolved_model", "resolved_model_present"],
+      "daemon.pi.session.missing_model": ["available_models_count", "requested_model"],
+      "daemon.pi.session.started": ["requested_model", "resolved_model", "session_id_present"]
+    },
+    endAttrs: ["outcome", "available_models_count", "diagnostics_count", "diagnostic_info_count", "diagnostic_warning_count", "requested_model", "resolved_model", "resolved_model_present", "error_class"]
+  },
   "daemon.connection.local_disconnect_observed": {
     spanAttrs: ["running_agents_count", "idle_agents_count"]
   }
@@ -14278,20 +15011,20 @@ function parseDaemonCliArgs(args) {
 }
 function readDaemonVersion(moduleUrl = import.meta.url) {
   try {
-    const require2 = createRequire2(moduleUrl);
+    const require2 = createRequire3(moduleUrl);
     return require2("../package.json").version;
   } catch {
     return "0.0.0-dev";
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path16.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path16.resolve(thisDir, "cli", "index.js");
+  const thisDir = path17.dirname(fileURLToPath(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;
   }
@@ -14305,7 +15038,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-JVLCJ2QO.js");
+  await import("./dist-6YUWBDWX.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -14497,7 +15230,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() {
@@ -14524,7 +15257,7 @@ var DaemonCore = class {
       sink: this.localTraceSink
     }));
     this.agentManager.setTracer(this.tracer);
-    this.agentManager.setCliTransportTraceDir(path16.join(machineDir, "traces"));
+    this.agentManager.setCliTransportTraceDir(path17.join(machineDir, "traces"));
   }
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
@@ -14926,7 +15659,15 @@ var DaemonCore = class {
         break;
       case "machine:runtime_models:detect": {
         const driver = getDriver(msg.runtime);
-        const detect = typeof driver?.detectModels === "function" ? driver.detectModels() : Promise.resolve(null);
+        const span = this.tracer.startSpan("daemon.runtime_models.detect", {
+          surface: "daemon",
+          kind: "internal",
+          attrs: {
+            runtime: msg.runtime,
+            requestId: msg.requestId
+          }
+        });
+        const detect = typeof driver?.detectModels === "function" ? driver.detectModels({ tracer: this.tracer, span }) : Promise.resolve(null);
         Promise.resolve(detect).then((result) => {
           if (result) {
             const verified = driver.model.detectedModelsVerifiedAs;
@@ -14935,12 +15676,32 @@ var DaemonCore = class {
               verified: model.verified ?? verified
             }));
             this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, models, default: result.default });
+            span.end("ok", {
+              attrs: {
+                outcome: "models_returned",
+                models_count: models.length,
+                default_model_present: Boolean(result.default),
+                verified_as: verified
+              }
+            });
           } else {
             this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, error: "unsupported" });
+            span.end("ok", {
+              attrs: {
+                outcome: "unsupported",
+                models_count: 0
+              }
+            });
           }
         }).catch((err) => {
           const reason = err instanceof Error ? err.message : String(err);
           this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, error: reason });
+          span.end("error", {
+            attrs: {
+              outcome: "error",
+              error_class: err instanceof Error ? err.name : typeof err
+            }
+          });
         });
         break;
       }