@botiverse/raft-daemon 0.60.0 → 0.61.0-play.20260616140732

package/dist/{chunk-65UFKNJJ.js → chunk-GODOOMDN.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
@@ -1579,7 +1605,7 @@ Use the \`raft\` CLI for chat / task / attachment operations (\`slock\` remains
 11. **\`raft message react\`** \u2014 Add or remove your reaction on a message. Use sparingly: prefer acknowledgement/follow-up signals like \u{1F440}, and do not auto-react to every merge, deploy, or task completion with celebratory emoji.
 12. **\`raft task list\`** \u2014 View a channel's task board.
 13. **\`raft task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
-14. **\`raft task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+14. **\`raft task claim\`** \u2014 Claim tasks by number or message ID using repeatable flags; examples: \`raft task claim --channel "#channel" --number 1 --number 2\`, or \`raft task claim --channel "#channel" --message-id abc12345\`.
 15. **\`raft task unclaim\`** \u2014 Release your claim on a task.
 16. **\`raft task update\`** \u2014 Change a task's status (e.g. to in_review or done).
 17. **\`raft attachment upload\`** \u2014 Upload a file to attach to a message. Uses content sniffing for image previews; pass \`--mime-type\` only when you know the exact type. Returns an attachment ID to pass to \`raft message send\`.
@@ -1711,7 +1737,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 **Assignee** is independent from status \u2014 a task can be claimed or unclaimed at any status except \`done\`.
 
 **Workflow:**
-1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message)
+1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message). Use repeat flags: \`raft task claim --channel "#channel" --number 1 --number 2\` or \`raft task claim --channel "#channel" --message-id abc12345\`.
 2. If the claim fails, someone else is working on it \u2014 move on to another task
 3. Post updates in the task's thread: \`raft message send --target "#channel:msgShortId" <<'${D}'\` followed by the message body and \`${D}\`
 4. When done, set status to \`in_review\` so a human can validate via \`raft task update\`
@@ -1723,7 +1749,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 - \`raft task create\` only creates the task \u2014 to own it, call \`raft task claim\` afterward.
 - Typical uses for \`raft task create\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
 - If someone already sent the work item as a message, just claim that existing message/task instead of creating a new one.
-- If the work already exists as a message, reuse it via \`raft task claim --message-id ...\`.
+- If the work already exists as a message, reuse it via \`raft task claim --channel "#channel" --message-id abc12345\`.
 
 **Creating new tasks:**
 - The task system exists to prevent duplicate work. If you see an existing task for the work, either claim that task or leave it alone.
@@ -2130,6 +2156,19 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
+// src/authEnv.ts
+var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
+var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
+function scrubDaemonAuthEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  return env;
+}
+function scrubDaemonChildEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  delete env[SLOCK_AGENT_TOKEN_ENV];
+  return env;
+}
+
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -3341,6 +3380,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) {
@@ -3617,7 +3657,9 @@ 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"
+  "SLOCK_AGENT_TOKEN",
+  "SLOCK_AGENT_CREDENTIAL_KEY",
+  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
 ];
 function deriveCliFallbackCandidates(cliPath) {
   if (!cliPath || cliPath === "__cli") return [];
@@ -3932,7 +3974,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -4367,7 +4409,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -4393,7 +4435,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -5787,11 +5829,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return withWindowsUserEnvironment({
+  return scrubDaemonChildEnv(withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps);
+  }, deps));
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -5847,7 +5889,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync6;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path7.win32;
   let geminiEntry = null;
   try {
@@ -5984,12 +6026,15 @@ 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 readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync, existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os4 from "os";
 import path8 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -5998,6 +6043,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os4.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path8.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return scrubDaemonChildEnv(spawnEnv);
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os4.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path8.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync3(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -6021,7 +6133,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -6045,21 +6175,23 @@ var KimiDriver = class {
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const launch = resolveKimiSpawn(args);
-    const proc = spawn7(launch.command, launch.args, {
+    const spawnTarget = resolveKimiSpawn(args);
+    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -6067,7 +6199,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: launch.shell
+      shell: spawnTarget.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -6180,14 +6312,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path8.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os4.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -6206,11 +6333,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 +6810,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 {
@@ -6425,7 +6996,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -6437,11 +7008,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 +7021,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 +7030,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 +7058,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 +7069,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 +7083,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 +7253,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 +7282,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 +7304,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 +7321,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 +7417,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 +7454,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 +7519,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 +7649,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 +7681,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 +7855,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 +7892,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 +7920,7 @@ var ChildProcessRuntimeSession = class {
     this.descriptor = descriptorFromDriver(driver);
   }
   descriptor;
-  events = new EventEmitter2();
+  events = new EventEmitter3();
   process = null;
   started = false;
   stdoutBuffer = "";
@@ -7323,7 +8033,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 +8054,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 +8062,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 +8111,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 +8130,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 +8681,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 +8699,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 +8733,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 +8742,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 +9467,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 +9480,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 +9755,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 +10693,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 +10707,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 +10840,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 +11120,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 +11191,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 +11475,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 +11578,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 +11950,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 +12011,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 +12305,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 +12313,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 +12322,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 +12365,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 +12401,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 +12412,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 +13389,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 +13892,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 +14266,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 +14291,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 +14321,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 +14382,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 +14420,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 +14446,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 +14465,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 +14553,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 +14656,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 +14876,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 +14888,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 +14921,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 +14963,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 +14976,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,11 +15041,29 @@ 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"]
   }
 };
-var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
+var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -14266,9 +15099,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args) {
+function parseDaemonCliArgs(args, env = {}) {
   let serverUrl = "";
-  let apiKey = "";
+  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -14278,20 +15111,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 +15138,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 +15330,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 +15357,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 +15759,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 +15776,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;
       }
@@ -15104,6 +15965,8 @@ var DaemonCore = class {
 };
 
 export {
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   subscribeDaemonLogs,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,