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

package/dist/{chunk-E5YOBAA3.js → chunk-XMSXOB5R.js}

@@ -1,7 +1,7 @@
 // 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";
 
@@ -1298,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 },
@@ -1366,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) {
@@ -1551,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
@@ -2143,19 +2156,6 @@ 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";
@@ -3367,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) {
@@ -3643,9 +3644,7 @@ 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_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 function deriveCliFallbackCandidates(cliPath) {
   if (!cliPath || cliPath === "__cli") return [];
@@ -3960,7 +3959,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -4395,7 +4394,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -4421,7 +4420,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -5815,11 +5814,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -5875,7 +5874,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync6;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path7.win32;
   let geminiEntry = null;
   try {
@@ -6012,15 +6011,12 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { 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 {
@@ -6029,73 +6025,6 @@ 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",
@@ -6119,25 +6048,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    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
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -6161,23 +6072,21 @@ 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,
-      ...launch.args
+      this.sessionId
     ];
     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 spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -6185,7 +6094,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: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -6298,9 +6207,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os4.homedir()) {
+  const configPath = path8.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -6319,11 +6233,455 @@ function detectKimiModels(home = os4.homedir(), opts = {}) {
   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):";
@@ -6352,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 {
@@ -6538,7 +6896,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -6550,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"),
@@ -6563,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 };
@@ -6572,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 {
@@ -6600,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"));
@@ -6611,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;
 }
@@ -6625,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);
@@ -6795,10 +7153,10 @@ 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,
@@ -6824,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;
@@ -6846,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 = [];
@@ -6959,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;
@@ -6996,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":
@@ -7061,7 +7419,7 @@ var PI_IDLE_PROMPT_RETRY_MS = 25;
 var PI_IDLE_PROMPT_MAX_WAIT_MS = 1e3;
 async function createPiAgentSessionForContext(ctx, sessionId) {
   const sessionDir = buildPiSessionDir(ctx.workingDirectory);
-  mkdirSync3(sessionDir, { recursive: true });
+  mkdirSync4(sessionDir, { recursive: true });
   const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
   const requestedModel = launchRuntimeFields.model || "default";
   const traceSpan = ctx.tracer?.startSpan("daemon.pi.session.create", {
@@ -7079,7 +7437,7 @@ async function createPiAgentSessionForContext(ctx, sessionId) {
   try {
     const spawnEnv = await buildPiSpawnEnv(ctx);
     const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
-    const authStorage = AuthStorage.create(path10.join(agentDir, "auth.json"));
+    const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
     const settingsManager = SettingsManager.create(ctx.workingDirectory, agentDir);
     const services = await createAgentSessionServices({
       cwd: ctx.workingDirectory,
@@ -7191,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;
@@ -7223,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({
@@ -7434,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";
@@ -7462,7 +7820,7 @@ var ChildProcessRuntimeSession = class {
     this.descriptor = descriptorFromDriver(driver);
   }
   descriptor;
-  events = new EventEmitter2();
+  events = new EventEmitter3();
   process = null;
   started = false;
   stdoutBuffer = "";
@@ -7575,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()
 };
@@ -7590,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("..");
 }
@@ -7598,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 {
@@ -7647,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);
@@ -7666,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 {
@@ -8217,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;
@@ -8235,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,
@@ -8269,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()) {
@@ -8278,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;
@@ -10229,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;
@@ -10243,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);
           }
         }
@@ -11486,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})`);
@@ -11547,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,
@@ -11841,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 {
@@ -11849,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;
@@ -11858,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");
@@ -11901,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();
@@ -11937,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);
@@ -11948,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);
@@ -13428,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);
@@ -13802,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";
@@ -13827,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 {
@@ -13857,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,
@@ -13918,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;
@@ -13956,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));
@@ -13982,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`
       );
@@ -14001,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 });
     }
   }
 };
@@ -14089,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(
@@ -14192,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 {
@@ -14412,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);
@@ -14424,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);
@@ -14457,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,
@@ -14499,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 {
@@ -14512,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)}
@@ -14599,7 +14963,7 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["running_agents_count", "idle_agents_count"]
   }
 };
-var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -14635,9 +14999,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   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];
@@ -14647,20 +15011,20 @@ function parseDaemonCliArgs(args, env = {}) {
 }
 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;
   }
@@ -14674,7 +15038,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-GKTG7LRO.js");
+  await import("./dist-6YUWBDWX.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -14866,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() {
@@ -14893,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;
@@ -15501,8 +15865,6 @@ var DaemonCore = class {
 };
 
 export {
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
   subscribeDaemonLogs,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,