@slock-ai/daemon 0.55.5 → 0.55.7-play.20260602150229

package/dist/{chunk-NXNXMFLC.js → chunk-OV4XD66N.js}

@@ -360,6 +360,40 @@ var NoopActiveSpan = class {
   }
 };
 var noopTracer = new NoopTracer();
+function createScopedTracer(tracer, scopeAttrs) {
+  if (!Object.keys(scopeAttrs).length) return tracer;
+  return new ScopedTracer(tracer, scopeAttrs);
+}
+var ScopedTracer = class {
+  constructor(tracer, scopeAttrs) {
+    this.tracer = tracer;
+    this.scopeAttrs = scopeAttrs;
+  }
+  startSpan(name, options) {
+    const span = this.tracer.startSpan(name, {
+      ...options,
+      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+    });
+    return new ScopedActiveSpan(span, this.scopeAttrs);
+  }
+};
+var ScopedActiveSpan = class {
+  constructor(span, scopeAttrs) {
+    this.span = span;
+    this.scopeAttrs = scopeAttrs;
+    this.context = span.context;
+  }
+  context;
+  addEvent(name, attrs) {
+    this.span.addEvent(name, mergeAttrs(attrs, this.scopeAttrs));
+  }
+  end(status, options) {
+    this.span.end(status, options ? {
+      ...options,
+      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+    } : void 0);
+  }
+};
 var BasicTracer = class {
   sink;
   clock;
@@ -904,6 +938,26 @@ var actionCardActionSchema = z.discriminatedUnion("type", [
   channelAddMemberOperationSchema
 ]);
 
+// ../shared/src/agentInbox.ts
+function formatAgentInboxDelta(rows) {
+  if (rows.length === 0) return "Inbox update: no pending targets";
+  return [
+    `Inbox update: ${rows.length} changed target${rows.length === 1 ? "" : "s"}`,
+    ...rows.map((row) => `${row.target}  ${formatAgentInboxRowDetails(row)}`)
+  ].join("\n");
+}
+function formatAgentInboxRowDetails(row) {
+  const parts = [`pending: ${row.pendingCount} message${row.pendingCount === 1 ? "" : "s"}`];
+  if (row.firstPendingMsgId) parts.push(`first msg=${shortMessageId(row.firstPendingMsgId)}`);
+  if (row.latestSenderName) parts.push(`latest @${row.latestSenderName}`);
+  if (row.latestMsgId) parts.push(`latest msg=${shortMessageId(row.latestMsgId)}`);
+  parts.push(...row.flags);
+  return parts.join(" \xB7 ");
+}
+function shortMessageId(value) {
+  return value.slice(0, 8);
+}
+
 // ../shared/src/translationLanguages.ts
 var SUPPORTED_TRANSLATION_LANGUAGE_CODES = [
   "en",
@@ -996,7 +1050,7 @@ var RUNTIMES = [
   { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
   { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
   { id: "opencode", displayName: "OpenCode", binary: "opencode", supported: true },
-  { id: "pi", displayName: "Pi CLI", binary: "pi", supported: true }
+  { id: "pi", displayName: "Pi", binary: "pi", supported: true }
 ];
 var RUNTIME_MODELS = {
   claude: [
@@ -1049,9 +1103,7 @@ var RUNTIME_MODELS = {
     { id: "fusecode/opus[1m]", label: "Opus 1M via FuseCode", verified: "suggestion_only" }
   ],
   pi: [
-    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
-    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro (Pi)", verified: "suggestion_only" },
-    { id: "deepseek/deepseek-v4-flash", label: "DeepSeek V4 Flash (Pi)", verified: "suggestion_only" }
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" }
   ],
   // Kimi CLI resolves model keys from each user's local config, so the safest
   // built-in option is to defer to whatever default model the CLI already uses.
@@ -1208,7 +1260,7 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync5, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
 import path13 from "path";
@@ -1806,6 +1858,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";
@@ -2061,6 +2126,80 @@ function reduceApmGatedFlushReadiness(state, input) {
   };
 }
 
+// src/agentInboxProjection.ts
+function projectAgentInboxSnapshot(messages) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const target = formatInboxMessageTarget(message);
+    if (!target) continue;
+    const bucket = buckets.get(target) ?? [];
+    bucket.push(message);
+    buckets.set(target, bucket);
+  }
+  return [...buckets.entries()].map(([target, bucket]) => projectBucket(target, bucket)).sort((a, b) => (b.latestSeq ?? 0) - (a.latestSeq ?? 0) || a.target.localeCompare(b.target));
+}
+function projectBucket(target, messages) {
+  const sorted = [...messages].sort(compareInboxMessages);
+  const first = sorted[0];
+  const latest = sorted[sorted.length - 1];
+  const flags = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.channel_type === "thread") flags.add("thread");
+    if (message.channel_type === "dm") flags.add("dm");
+    if (message.task_number || message.task_status) flags.add("task");
+    if (message.mention === true || message.mentioned === true) flags.add("mention");
+  }
+  return stripUndefined({
+    target,
+    channelId: latest.channel_id ?? latest.parent_channel_id,
+    channelType: latest.channel_type,
+    pendingCount: messages.length,
+    firstPendingMsgId: messageId(first),
+    firstPendingSeq: messageSeq(first),
+    latestMsgId: messageId(latest),
+    latestSeq: messageSeq(latest),
+    latestSenderName: latest.sender_name ?? latest.senderName,
+    latestSenderType: normalizeSenderType(latest.sender_type ?? latest.senderType),
+    flags: [...flags].sort()
+  });
+}
+function compareInboxMessages(a, b) {
+  return (messageSeq(a) ?? 0) - (messageSeq(b) ?? 0) || (messageId(a) ?? "").localeCompare(messageId(b) ?? "");
+}
+function formatInboxMessageTarget(message) {
+  if (message.channel_type === "thread" && message.parent_channel_name && message.channel_name) {
+    const shortId = shortMessageId2(String(message.channel_name).startsWith("thread-") ? String(message.channel_name).slice("thread-".length) : String(message.channel_name));
+    if (message.parent_channel_type === "dm") return `dm:@${message.parent_channel_name}:${shortId}`;
+    return `#${message.parent_channel_name}:${shortId}`;
+  }
+  if (message.channel_type === "dm" && message.channel_name) return `dm:@${message.channel_name}`;
+  if (message.channel_name) return `#${message.channel_name}`;
+  return null;
+}
+function messageId(message) {
+  if (!message) return void 0;
+  return nonEmptyString(message.message_id) ?? nonEmptyString(message.id);
+}
+function messageSeq(message) {
+  if (!message || typeof message.seq !== "number" || !Number.isFinite(message.seq) || message.seq <= 0) return void 0;
+  return Math.floor(message.seq);
+}
+function shortMessageId2(value) {
+  return value.slice(0, 8);
+}
+function normalizeSenderType(value) {
+  return value === "human" || value === "agent" || value === "system" ? value : void 0;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function stripUndefined(value) {
+  for (const key of Object.keys(value)) {
+    if (value[key] === void 0) delete value[key];
+  }
+  return value;
+}
+
 // src/agentCredentialProxy.ts
 var registrations = /* @__PURE__ */ new Map();
 var proxyServerState = null;
@@ -2204,6 +2343,14 @@ async function handleProxyRequest(req, res) {
     }
     let sendTarget;
     const sideEffectAction = agentApiSideEffectAction(target.pathname);
+    if (method === "GET" && target.pathname === "/internal/agent-api/inbox") {
+      const localInbox = localAgentApiInboxResponse(registration);
+      if (localInbox) {
+        res.writeHead(localInbox.status, { "content-type": "application/json" });
+        res.end(JSON.stringify(localInbox.body));
+        return;
+      }
+    }
     if (method === "GET" && target.pathname === "/internal/agent-api/events") {
       const localEvents = localAgentApiEventsResponse(registration, target);
       if (localEvents) {
@@ -2347,6 +2494,7 @@ function transportNormalizedErrorForError(target, err, launchId) {
 function routeFamilyForPath(pathname) {
   if (pathname === "/internal/agent-api/send") return "agent-api/send";
   if (pathname === "/internal/agent-api/events") return "agent-api/events";
+  if (pathname === "/internal/agent-api/inbox") return "agent-api/inbox";
   if (pathname === "/internal/agent-api/receive-ack") return "agent-api/events";
   if (pathname === "/internal/agent-api/tasks/claim") return "tasks/claim";
   if (pathname === "/internal/agent-api/tasks/update-status") return "tasks/update";
@@ -2403,13 +2551,13 @@ async function readRequestBody(req) {
   }
   return Buffer.concat(chunks);
 }
-function messageSeq(message) {
+function messageSeq2(message) {
   return Number(message.seq ?? 0);
 }
 function maxMessageSeq(messages) {
   let maxSeq = 0;
   for (const message of messages) {
-    const seq = Math.floor(messageSeq(message));
+    const seq = Math.floor(messageSeq2(message));
     if (Number.isFinite(seq) && seq > 0) maxSeq = Math.max(maxSeq, seq);
   }
   return maxSeq > 0 ? maxSeq : void 0;
@@ -2423,7 +2571,7 @@ function isSelfAuthoredMessage(registration, message) {
   return messageSenderId(message) === registration.agentId;
 }
 function isMessageModelSeen(coordinator, target, message) {
-  const seq = Math.floor(messageSeq(message));
+  const seq = Math.floor(messageSeq2(message));
   const boundary = coordinator.getBoundary(target);
   if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= seq) return true;
   return coordinator.isMessageModelSeen?.({ target, message }) === true;
@@ -2433,12 +2581,31 @@ function resolveFreshnessBoundary(messages) {
   return typeof seenUpToSeq === "number" ? { ok: true, seenUpToSeq } : { ok: false, reason: "missing_seq_boundary" };
 }
 function sortBySeq(messages) {
-  return [...messages].sort((a, b) => messageSeq(a) - messageSeq(b));
+  return [...messages].sort((a, b) => messageSeq2(a) - messageSeq2(b));
 }
 function latestVisibleMessages(messages, limit) {
   const sorted = sortBySeq(messages);
   return sorted.slice(Math.max(0, sorted.length - limit));
 }
+function localAgentApiInboxResponse(registration) {
+  const coordinator = registration.inboxCoordinator;
+  if (!coordinator) return void 0;
+  const pending = coordinator.getAllPendingMessages?.() ?? [];
+  const rows = projectAgentInboxSnapshot(pending);
+  coordinator.recordInboxSnapshot?.({
+    source: "agent_api_inbox_check",
+    rows,
+    pendingMessageCount: pending.length
+  });
+  return {
+    status: 200,
+    body: {
+      rows,
+      pending_targets: rows.length,
+      pending_messages: pending.length
+    }
+  };
+}
 function parseAgentApiEventsQuery(target) {
   const limit = Math.min(Math.max(Number(target.searchParams.get("limit")) || 50, 1), 200);
   const sinceRaw = target.searchParams.get("since")?.trim() ?? "";
@@ -2469,7 +2636,7 @@ function localAgentApiEventsResponse(registration, target) {
   if (pending.length === 0) return void 0;
   const normalized = sortBySeq(normalizeVisibleMessages(pending));
   const filtered = parsedQuery.sinceSeq !== null ? normalized.filter((message) => {
-    const seq = messageSeq(message);
+    const seq = messageSeq2(message);
     return Number.isFinite(seq) && seq > parsedQuery.sinceSeq;
   }) : normalized;
   const events = filtered.slice(0, parsedQuery.limit);
@@ -2794,12 +2961,12 @@ function consumeVisibleResponse(registration, targetUrl, sendTarget, responseTex
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/send" && parsed.state === "sent") {
-    const messageSeq2 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
-    if (sendTarget && messageSeq2 && messageSeq2 > 0) {
+    const messageSeq3 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
+    if (sendTarget && messageSeq3 && messageSeq3 > 0) {
       coordinator.consumeVisibleMessages({
         target: sendTarget,
-        messages: normalizeVisibleMessages([{ seq: messageSeq2, id: parsed.messageId }], sendTarget),
-        boundarySeq: messageSeq2,
+        messages: normalizeVisibleMessages([{ seq: messageSeq3, id: parsed.messageId }], sendTarget),
+        boundarySeq: messageSeq3,
         source: "agent_api_send_commit"
       });
     }
@@ -2859,7 +3026,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"
 ];
 var cachedOpencliBinPath;
 function resolveOpencliBinPath() {
@@ -3074,7 +3243,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -3175,7 +3344,7 @@ function collectModelUsageAttrs(value) {
     modelUsageMaxOutputTokens: aggregate.maxOutputTokens
   });
 }
-function parseClaudeResultUsageTelemetry(event) {
+function parseClaudeResultUsageTelemetry(event, sessionId) {
   const usage = event.usage && typeof event.usage === "object" ? event.usage : void 0;
   const totalCostUsd = finiteNumber(event.total_cost_usd);
   const modelUsageAttrs = collectModelUsageAttrs(event.modelUsage);
@@ -3224,12 +3393,16 @@ function parseClaudeResultUsageTelemetry(event) {
     name: "token_usage",
     source: "claude_result_usage",
     usageKind: "per_turn",
-    ...typeof event.session_id === "string" && event.session_id ? { sessionId: event.session_id } : {},
+    ...sessionId ? { sessionId } : {},
     ...typeof event.uuid === "string" && event.uuid ? { runtimeResultId: event.uuid } : {},
     attrs
   };
 }
 var ClaudeEventNormalizer = class {
+  currentSession = null;
+  get currentSessionId() {
+    return this.currentSession;
+  }
   normalizeLine(line) {
     let event;
     try {
@@ -3238,13 +3411,17 @@ var ClaudeEventNormalizer = class {
       return [];
     }
     const events = [];
+    const eventSessionId = finiteString(event.session_id);
+    if (eventSessionId) {
+      this.currentSession = eventSessionId;
+    }
     const pushResultError = (message, fallback) => {
       events.push({ kind: "error", message: collectResultErrorDetail(message, fallback) });
     };
     switch (event.type) {
       case "system":
-        if (event.subtype === "init" && event.session_id) {
-          events.push({ kind: "session_init", sessionId: event.session_id });
+        if (event.subtype === "init" && eventSessionId) {
+          events.push({ kind: "session_init", sessionId: eventSessionId });
         }
         if (event.subtype === "status" && event.status === "compacting") {
           events.push({ kind: "compaction_started" });
@@ -3303,7 +3480,8 @@ var ClaudeEventNormalizer = class {
       case "result": {
         const subtype = typeof event.subtype === "string" ? event.subtype : "success";
         const stopReason = typeof event.stop_reason === "string" ? event.stop_reason : null;
-        const usageTelemetry = parseClaudeResultUsageTelemetry(event);
+        const resultSessionId = eventSessionId ?? this.currentSession;
+        const usageTelemetry = parseClaudeResultUsageTelemetry(event, resultSessionId);
         switch (subtype) {
           case "success":
             if (event.is_error && stopReason !== "max_tokens") {
@@ -3326,7 +3504,7 @@ var ClaudeEventNormalizer = class {
             break;
         }
         if (usageTelemetry) events.push(usageTelemetry);
-        events.push({ kind: "turn_end", sessionId: event.session_id });
+        events.push({ kind: "turn_end", sessionId: resultSessionId || void 0 });
         break;
       }
     }
@@ -3494,7 +3672,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn, existsSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync2;
   if (platform === "win32") {
@@ -3520,7 +3698,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"], {
@@ -3680,6 +3858,9 @@ var ClaudeDriver = class {
   parseLine(line) {
     return this.eventNormalizer.normalizeLine(line);
   }
+  get currentSessionId() {
+    return this.eventNormalizer.currentSessionId;
+  }
   encodeStdinMessage(text, sessionId, _opts) {
     return JSON.stringify({
       type: "user",
@@ -3861,6 +4042,9 @@ function rawResponseItemProgressEvent(message) {
     payloadBytes
   };
 }
+function nonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 var CodexEventNormalizer = class {
   mcpToolPrefix;
   currentThreadId = null;
@@ -3913,10 +4097,17 @@ var CodexEventNormalizer = class {
     }
     const telemetry = parseCodexTelemetryEvent(message);
     if (telemetry) {
+      const telemetrySessionId = nonEmptyString2(message.params?.threadId) ?? nonEmptyString2(message.params?.thread?.id) ?? nonEmptyString2(message.params?.sessionId);
+      const telemetryTurnId = nonEmptyString2(message.params?.turnId) ?? nonEmptyString2(message.params?.turn?.id);
+      if (telemetrySessionId) {
+        this.currentThreadId = telemetrySessionId;
+      }
+      const sessionId = telemetrySessionId ?? this.currentThreadId ?? void 0;
+      const turnId = telemetryTurnId ?? this.turnState.activeTurnId ?? void 0;
       events.push({
         ...telemetry,
-        ...this.currentThreadId ? { sessionId: this.currentThreadId } : {},
-        ...this.turnState.activeTurnId ? { turnId: this.turnState.activeTurnId } : {}
+        ...sessionId ? { sessionId } : {},
+        ...turnId ? { turnId } : {}
       });
       return { events };
     }
@@ -4365,6 +4556,9 @@ var CodexDriver = class {
     }
     return result.events;
   }
+  get currentSessionId() {
+    return this.normalizer.threadId;
+  }
   encodeStdinMessage(text, sessionId, opts) {
     if (!this.normalizer.threadId && sessionId) {
       this.normalizer.adoptThreadId(sessionId);
@@ -4967,11 +5161,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"], {
@@ -5027,7 +5221,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -5199,13 +5393,16 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
 import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -5214,6 +5411,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os3.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return scrubDaemonChildEnv(spawnEnv);
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -5237,7 +5501,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -5291,6 +5573,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -5299,15 +5582,16 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--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,
@@ -5315,7 +5599,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",
@@ -5429,14 +5713,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir()) {
-  const configPath = path9.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os3.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -5700,7 +5979,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"
@@ -5961,12 +6240,23 @@ var OpenCodeDriver = class {
 
 // src/drivers/pi.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { spawn as spawn9, spawnSync as spawnSync3 } from "child_process";
-import { mkdirSync as mkdirSync4 } from "fs";
+import { EventEmitter } from "events";
+import { mkdirSync as mkdirSync4, readdirSync } from "fs";
+import { PassThrough, Writable } from "stream";
 import path11 from "path";
+import {
+  AuthStorage,
+  createBashTool,
+  createAgentSession,
+  DefaultResourceLoader,
+  getAgentDir,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+  VERSION as PI_SDK_VERSION
+} from "@earendil-works/pi-coding-agent";
 var PI_SESSION_DIR = ".pi-sessions";
 var PI_PROVIDER_LABELS = {
-  deepseek: "DeepSeek",
   google: "Google",
   openai: "OpenAI",
   openrouter: "OpenRouter"
@@ -5974,69 +6264,51 @@ var PI_PROVIDER_LABELS = {
 function buildPiSessionDir(workingDirectory) {
   return path11.join(workingDirectory, PI_SESSION_DIR);
 }
-function buildPiRpcArgs(ctx, sessionId) {
-  const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
-  const args = [
-    "--mode",
-    "rpc",
-    "--session-dir",
-    buildPiSessionDir(ctx.workingDirectory),
-    "--system-prompt",
-    ctx.standingPrompt
-  ];
-  if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
-    args.push("--model", launchRuntimeFields.model);
-  }
-  if (launchRuntimeFields.reasoningEffort) {
-    args.push("--thinking", launchRuntimeFields.reasoningEffort);
+async function buildPiSpawnEnv(ctx) {
+  return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
+}
+function resolvePiModelFromRegistry(modelId, modelRegistry) {
+  if (!modelId || modelId === "default") return void 0;
+  const [provider, ...modelParts] = modelId.split("/");
+  if (provider && modelParts.length > 0) {
+    return modelRegistry.find(provider, modelParts.join("/"));
   }
-  if (sessionId) {
-    args.push("--session-id", sessionId);
+  return modelRegistry.getAll().find((model) => model.id === modelId);
+}
+function findPiSessionFile(sessionDir, sessionId) {
+  let entries;
+  try {
+    entries = readdirSync(sessionDir);
+  } catch {
+    return null;
   }
-  return args;
+  const suffix = `_${sessionId}.jsonl`;
+  const match = entries.find((entry) => entry.endsWith(suffix));
+  return match ? path11.join(sessionDir, match) : null;
 }
-async function buildPiSpawnEnv(ctx) {
-  return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
+function piSdkEventToJsonLine(event) {
+  if (event.type === "agent_end") {
+    return JSON.stringify({ type: "agent_end" });
+  }
+  return JSON.stringify(event);
 }
-function parsePiModelsOutput(output) {
-  const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
+function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const rawLine of stripAnsi(output).split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || /^provider\s+model\s+/i.test(line) || /^[-\s]+$/.test(line)) continue;
-    const columns = line.split(/\s+/);
-    const provider = columns[0];
-    const model = columns[1];
-    if (!provider || !model || provider.startsWith("-") || model.startsWith("-")) continue;
-    if (/^(yes|no)$/i.test(model)) continue;
-    const id = `${provider}/${model}`;
+  for (const model of modelRegistry.getAvailable()) {
+    const id = `${model.provider}/${model.id}`;
     if (seen.has(id)) continue;
     seen.add(id);
     models.push({
       id,
-      label: `${humanizePiSegment(model)} \xB7 ${PI_PROVIDER_LABELS[provider] || humanizePiSegment(provider)}`,
+      label: `${model.name || humanizePiSegment(model.id)} \xB7 ${PI_PROVIDER_LABELS[model.provider] || humanizePiSegment(model.provider)}`,
       verified: "launchable"
     });
   }
   return models.length > 0 ? { models } : null;
 }
-function detectPiModels(runCommand = runPiModelsCommand) {
-  const result = runCommand();
-  if (result.error || result.status !== 0) return null;
-  return parsePiModelsOutput(result.stdout);
-}
-function runPiModelsCommand() {
-  const result = spawnSync3("pi", ["--list-models"], {
-    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
-    encoding: "utf8",
-    timeout: 5e3
-  });
-  return {
-    status: result.status,
-    stdout: String(result.stdout || ""),
-    error: result.error
-  };
+function detectPiModels(modelRegistry = ModelRegistry.create(AuthStorage.create())) {
+  return detectPiModelsFromRegistry(modelRegistry);
 }
 function humanizePiSegment(value) {
   return value.split(/[-_/]/).filter(Boolean).map(formatPiLabelToken).join(" ");
@@ -6046,7 +6318,6 @@ function formatPiLabelToken(token) {
   const specialCases = {
     ai: "AI",
     api: "API",
-    deepseek: "DeepSeek",
     flash: "Flash",
     gpt: "GPT",
     pro: "Pro",
@@ -6070,6 +6341,116 @@ function piErrorMessage(error) {
   }
   return "Unknown Pi error";
 }
+var PiSdkProcess = class extends EventEmitter {
+  constructor(session) {
+    super();
+    this.session = session;
+    this.stdin = new Writable({
+      write: (chunk, _encoding, callback) => {
+        this.handleInput(String(chunk)).then(
+          () => callback(),
+          (error) => {
+            this.writeError(error);
+            callback();
+          }
+        );
+      }
+    });
+    this.session.subscribe((event) => {
+      this.writeStdout(piSdkEventToJsonLine(event));
+    });
+  }
+  stdout = new PassThrough();
+  stderr = new PassThrough();
+  stdin;
+  pid = void 0;
+  exitCode = null;
+  signalCode = null;
+  killed = false;
+  buffer = "";
+  closed = false;
+  kill(signal = "SIGTERM") {
+    if (this.closed) return false;
+    this.killed = true;
+    this.signalCode = typeof signal === "string" ? signal : null;
+    void this.shutdown(null, this.signalCode);
+    return true;
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  async handleInput(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim() || this.closed) continue;
+      await this.handleCommand(line);
+    }
+  }
+  async handleCommand(raw) {
+    let command;
+    try {
+      command = JSON.parse(raw);
+    } catch (error) {
+      this.writeError(error);
+      return;
+    }
+    const id = typeof command.id === "string" ? command.id : void 0;
+    try {
+      if (command.type === "prompt") {
+        await this.session.prompt(String(command.message ?? ""));
+        this.writeStdout(JSON.stringify({ id, type: "response", command: "prompt", success: true }));
+      } else if (command.type === "steer") {
+        await this.session.steer(String(command.message ?? ""));
+        this.writeStdout(JSON.stringify({ id, type: "response", command: "steer", success: true }));
+      } else {
+        throw new Error(`Unsupported Pi SDK command: ${command.type || "unknown"}`);
+      }
+    } catch (error) {
+      this.writeStdout(JSON.stringify({
+        id,
+        type: "response",
+        command: command.type || "unknown",
+        success: false,
+        error: piErrorMessage(error)
+      }));
+    }
+  }
+  writeStdout(line) {
+    if (this.closed) return;
+    this.stdout.write(line + "\n");
+  }
+  writeError(error) {
+    if (this.closed) return;
+    this.stderr.write(piErrorMessage(error) + "\n");
+  }
+  async shutdown(code, signal) {
+    if (this.closed) return;
+    this.closed = true;
+    this.exitCode = code;
+    this.signalCode = signal;
+    try {
+      if (this.session.isStreaming) {
+        await this.session.abort();
+      }
+    } catch (error) {
+      this.stderr.write(piErrorMessage(error) + "\n");
+    }
+    try {
+      this.session.dispose();
+    } catch {
+    }
+    this.stdin.destroy();
+    this.stdout.end();
+    this.stderr.end();
+    this.emit("exit", code, signal);
+    this.emit("close", code, signal);
+  }
+};
 var PiDriver = class {
   id = "pi";
   supportsNativeStandingPrompt = true;
@@ -6087,7 +6468,7 @@ var PiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -6099,11 +6480,9 @@ var PiDriver = class {
   requestId = 0;
   process = null;
   probe() {
-    const command = resolveCommandOnPath("pi");
-    if (!command) return { available: false };
     return {
       available: true,
-      version: readCommandVersion(command) ?? void 0
+      version: PI_SDK_VERSION
     };
   }
   async detectModels() {
@@ -6114,15 +6493,57 @@ var PiDriver = class {
     this.sessionAnnounced = false;
     this.sawTextDelta = false;
     this.requestId = 0;
-    mkdirSync4(buildPiSessionDir(ctx.workingDirectory), { recursive: true });
-    const proc = spawn9(resolveCommandOnPath("pi") ?? "pi", buildPiRpcArgs(ctx, this.sessionId), {
+    const sessionDir = buildPiSessionDir(ctx.workingDirectory);
+    mkdirSync4(sessionDir, { recursive: true });
+    const spawnEnv = await buildPiSpawnEnv(ctx);
+    const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
+    const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
+    const modelRegistry = ModelRegistry.create(authStorage, path11.join(agentDir, "models.json"));
+    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: false } });
+    const resourceLoader = new DefaultResourceLoader({
       cwd: ctx.workingDirectory,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: await buildPiSpawnEnv(ctx),
-      shell: process.platform === "win32"
+      agentDir,
+      settingsManager,
+      systemPromptOverride: () => ctx.standingPrompt
+    });
+    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: this.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
+            }
+          })
+        })
+      ],
+      sessionManager,
+      settingsManager
     });
+    this.sessionId = session.sessionId;
+    const proc = new PiSdkProcess(session);
     this.process = proc;
-    this.sendRpcCommand("prompt", { message: ctx.prompt });
+    setImmediate(() => {
+      if (this.process === proc && !proc.killed) {
+        this.sendRpcCommand("prompt", { message: ctx.prompt });
+      }
+    });
     return { process: proc };
   }
   parseLine(line) {
@@ -6211,7 +6632,7 @@ var PiDriver = class {
       toolPrefix: "",
       extraCriticalRules: [],
       postStartupNotes: [
-        "**Pi runtime note:** Slock keeps Pi running in RPC mode. While you are working, Slock may send inbox-count notifications into the current turn; call `slock message check` at natural breakpoints."
+        "**Pi runtime note:** Slock keeps Pi running as a persistent SDK session. While you are working, Slock may send inbox-count notifications into the current turn; call `slock message check` at natural breakpoints."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -6506,7 +6927,7 @@ function runtimeDisplayName(runtimeId) {
     case "opencode":
       return "OpenCode";
     case "pi":
-      return "Pi CLI";
+      return "Pi";
     default:
       return runtimeId || "This runtime";
   }
@@ -6752,8 +7173,8 @@ function formatVisibleMessageTarget(message) {
   }
   return null;
 }
-function getMessageShortId(messageId) {
-  return messageId.startsWith("thread-") ? messageId.slice(7) : messageId.slice(0, 8);
+function getMessageShortId(messageId2) {
+  return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
 }
 var RESPONSE_TARGET_HINT = "Reply in the channel or create/reply in a thread as appropriate; use each message's `target` and `msg` fields to choose the exact target.";
 function findSessionJsonl(root, predicate) {
@@ -6764,7 +7185,7 @@ function findSessionJsonl(root, predicate) {
     if (depth < 0 || visited >= maxEntries) return null;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
     } catch {
       return null;
     }
@@ -7724,6 +8145,30 @@ function runtimeTraceCounterAttrs(ap) {
     runtime_thinking_events_count: ap.runtimeTraceCounters.thinkingEvents
   };
 }
+var RUNTIME_TELEMETRY_RESERVED_ATTR_KEYS = /* @__PURE__ */ new Set([
+  "agentId",
+  "launchId",
+  "runtime",
+  "model",
+  "telemetry_name",
+  "source",
+  "usageKind",
+  "sessionId",
+  "turnId",
+  "runtimeResultId",
+  "daemonVersion",
+  "daemon_version",
+  "computerVersion",
+  "computer_version"
+]);
+function sanitizeRuntimeTelemetryPayloadAttrs(attrs) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (RUNTIME_TELEMETRY_RESERVED_ATTR_KEYS.has(key)) continue;
+    sanitized[key] = value;
+  }
+  return sanitized;
+}
 function getMessageDeliveryText(driver) {
   return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
 }
@@ -7934,6 +8379,13 @@ var AgentProcessManager = class _AgentProcessManager {
       getPendingMessages: (target) => this.pendingVisibleMessages(agentId, target),
       isMessageModelSeen: ({ target, message }) => this.isVisibleMessageModelSeen(agentId, target, message),
       getAllPendingMessages: () => this.allPendingVisibleMessages(agentId),
+      recordInboxSnapshot: (input) => {
+        this.recordDaemonTrace("daemon.agent.inbox_projection.snapshot", {
+          agentId,
+          source: input.source,
+          ...this.inboxProjectionTraceAttrs(input.rows, input.pendingMessageCount)
+        });
+      },
       consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input),
       recordDrainOutcome: (input) => {
         this.recordDaemonTrace("daemon.agent.drain.outcome", {
@@ -9860,6 +10312,29 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ...messageProducerFactTraceAttrs(messages)
     };
   }
+  inboxProjectionTraceAttrs(rows, pendingMessageCount) {
+    let maxPendingCount = 0;
+    let mentionTargetCount = 0;
+    let threadTargetCount = 0;
+    let dmTargetCount = 0;
+    let taskTargetCount = 0;
+    for (const row of rows) {
+      maxPendingCount = Math.max(maxPendingCount, row.pendingCount);
+      if (row.flags.includes("mention")) mentionTargetCount += 1;
+      if (row.flags.includes("thread")) threadTargetCount += 1;
+      if (row.flags.includes("dm")) dmTargetCount += 1;
+      if (row.flags.includes("task")) taskTargetCount += 1;
+    }
+    return {
+      inbox_target_count: rows.length,
+      pending_message_count: pendingMessageCount,
+      max_pending_per_target: maxPendingCount,
+      mention_target_count: mentionTargetCount,
+      thread_target_count: threadTargetCount,
+      dm_target_count: dmTargetCount,
+      task_target_count: taskTargetCount
+    };
+  }
   runtimeProfileTurnControlTraceAttrs(control) {
     if (!control) return {};
     const pendingAgeMs = Math.max(0, Date.now() - control.injectedAtMs);
@@ -10458,11 +10933,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   recordRuntimeTelemetry(agentId, ap, event) {
+    const sessionId = ap.driver.currentSessionId ?? event.sessionId;
+    const payloadAttrs = sanitizeRuntimeTelemetryPayloadAttrs(event.attrs);
     const telemetryAttrs = {
-      ...event.attrs,
+      ...payloadAttrs,
       ...event.source ? { source: event.source } : {},
       ...event.usageKind ? { usageKind: event.usageKind } : {},
-      ...event.sessionId ? { sessionId: event.sessionId } : {},
+      ...sessionId ? { sessionId } : {},
       ...event.turnId ? { turnId: event.turnId } : {},
       ...event.runtimeResultId ? { runtimeResultId: event.runtimeResultId } : {}
     };
@@ -10548,11 +11025,29 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const notification = `[Slock inbox notice: You have ${inboxCount} pending inbox message${inboxCount > 1 ? "s" : ""}. Call check_messages to read ${inboxCount > 1 ? "them" : "it"} when you're ready.]`;
-    logger.info(`[Agent ${agentId}] Sending stdin notification: ${inboxCount} pending inbox message(s)`);
+    const inboxRows = projectAgentInboxSnapshot(ap.inbox);
+    const notification = `[Slock inbox notice:
+${formatAgentInboxDelta(inboxRows)}]`;
+    const notificationByteCount = Buffer.byteLength(notification, "utf8");
+    const projectionAttrs = this.inboxProjectionTraceAttrs(inboxRows, inboxCount);
+    this.recordDaemonTrace("daemon.agent.inbox_projection.delta", {
+      agentId,
+      source: "busy_stdin_notification",
+      ...projectionAttrs
+    });
+    logger.info(`[Agent ${agentId}] Sending stdin inbox update: ${inboxRows.length} changed target(s), ${inboxCount} pending message(s)`);
     const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     if (encoded) {
       ap.process.stdin?.write(encoded + "\n");
+      this.recordDaemonTrace("daemon.agent.inbox_update.pushed", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        mode: "busy",
+        notification_byte_count: notificationByteCount,
+        ...projectionAttrs
+      });
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -10562,6 +11057,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         mode: "busy",
         pending_notification_count: count,
         inbox_count: inboxCount,
+        inbox_target_count: inboxRows.length,
         session_id_present: true
       });
       return true;
@@ -10579,6 +11075,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         retry_scheduled: retryScheduled,
         notification_timer_present: ap.notifications.hasTimer,
         inbox_count: inboxCount,
+        inbox_target_count: inboxRows.length,
         session_id_present: true
       }, "error");
       return false;
@@ -11116,7 +11613,7 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
 import path15 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
@@ -11195,7 +11692,7 @@ var LocalRotatingTraceSink = class {
     }
   }
   pruneOldFiles() {
-    const files = readdirSync2(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
+    const files = readdirSync3(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
@@ -11637,7 +12134,7 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
-var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
+var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -11673,9 +12170,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];
@@ -11864,7 +12361,7 @@ var DaemonCore = class {
     this.slockHome = resolveSlockHome();
     process.env[SLOCK_HOME_ENV] = this.slockHome;
     this.injectedTracer = Boolean(options.tracer);
-    this.tracer = options.tracer ?? noopTracer;
+    this.tracer = this.withDaemonTraceScope(options.tracer ?? noopTracer);
     this.runtimeDetector = options.runtimeDetector ?? (() => detectRuntimes(this.tracer));
     this.reminderCache = new ReminderCache({
       clock: options.reminderClock,
@@ -11915,9 +12412,9 @@ var DaemonCore = class {
       maxFileAgeJitterMs: jitter.maxFileAgeJitterMs,
       maxFiles: this.options.localTraceMaxFiles ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILES", 8)
     });
-    this.tracer = new BasicTracer({
+    this.tracer = this.withDaemonTraceScope(new BasicTracer({
       sink: this.localTraceSink
-    });
+    }));
     this.agentManager.setTracer(this.tracer);
     this.agentManager.setCliTransportTraceDir(path17.join(machineDir, "traces"));
   }
@@ -12011,6 +12508,23 @@ var DaemonCore = class {
     });
     span.end(status);
   }
+  withDaemonTraceScope(tracer) {
+    return createScopedTracer(tracer, this.daemonTraceScopeAttrs());
+  }
+  daemonTraceScopeAttrs() {
+    return {
+      daemonVersion: this.daemonVersion,
+      daemon_version: this.daemonVersion,
+      daemon_version_present: Boolean(this.daemonVersion),
+      ...this.computerVersion ? {
+        computerVersion: this.computerVersion,
+        computer_version: this.computerVersion,
+        computer_version_present: true
+      } : {
+        computer_version_present: false
+      }
+    };
+  }
   async requestRunnerCredentialOnce(agentId, config) {
     const url = new URL(`/internal/computer/runners/${encodeURIComponent(agentId)}/credentials`, this.options.serverUrl);
     const res = await daemonFetch(url, {
@@ -12371,8 +12885,7 @@ var DaemonCore = class {
       runtimes_count: runtimes.length,
       running_agents_count: runningAgentIds.length,
       idle_agents_count: idleAgentSessions.length,
-      runtime_profile_reports_count: runtimeProfileReports.length,
-      daemon_version_present: Boolean(this.daemonVersion)
+      runtime_profile_reports_count: runtimeProfileReports.length
     });
     for (const agentId of runningAgentIds) {
       const sessionId = this.agentManager.getAgentSessionId(agentId);
@@ -12426,6 +12939,8 @@ var DaemonCore = class {
 };
 
 export {
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,