@slock-ai/daemon 0.55.2 → 0.55.3-play.20260602082442

package/dist/{chunk-IDDG4Q4Q.js → chunk-2UNHLLT6.js}

@@ -8,11 +8,11 @@ import {
 } from "./chunk-M2KQBJR3.js";
 
 // src/core.ts
-import path16 from "path";
+import path17 from "path";
 import os7 from "os";
 import { createRequire as createRequire2 } from "module";
 import { accessSync } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../shared/src/slockRefs.ts
 var SLOCK_REF_CHANNEL_NAME_PATTERN = String.raw`[\p{L}\p{N}_-]+`;
@@ -990,6 +990,7 @@ var RUNTIME_CONFIG_VERSION = 1;
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
+  { id: "pi", displayName: "Pi", binary: "pi", supported: true },
   { id: "antigravity", displayName: "Antigravity CLI", binary: "agy", supported: true },
   { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
   { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
@@ -999,9 +1000,14 @@ var RUNTIMES = [
 ];
 var RUNTIME_MODELS = {
   claude: [
-    { id: "opus", label: "Opus" },
-    { id: "sonnet", label: "Sonnet" },
-    { id: "haiku", label: "Haiku" }
+    { id: "opus", label: "Claude Opus" },
+    { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
+    { id: "claude-opus-4-7", label: "Claude Opus 4.7" },
+    { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+    { id: "sonnet", label: "Claude Sonnet" },
+    { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+    { id: "haiku", label: "Claude Haiku" },
+    { id: "claude-haiku-4-5", label: "Claude Haiku 4.5" }
   ],
   codex: [
     { id: "gpt-5.5", label: "GPT-5.5" },
@@ -1042,6 +1048,13 @@ var RUNTIME_MODELS = {
     { id: "openrouter/anthropic/claude-opus-4.5", label: "Claude Opus 4.5 via OpenRouter", verified: "suggestion_only" },
     { id: "fusecode/opus[1m]", label: "Opus 1M via FuseCode", verified: "suggestion_only" }
   ],
+  pi: [
+    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro" },
+    { id: "deepseek/deepseek-v4-flash", label: "DeepSeek V4 Flash" },
+    { id: "kimi-coding/kimi-for-coding", label: "Kimi for Coding" },
+    { id: "zai/glm-5.1", label: "GLM-5.1" },
+    { id: "zai/glm-4.7", label: "GLM-4.7" }
+  ],
   // Kimi CLI resolves model keys from each user's local config, so the safest
   // built-in option is to defer to whatever default model the CLI already uses.
   kimi: [
@@ -1086,22 +1099,28 @@ function isPresetRuntimeModel(runtime, model) {
 function modelConfigFromLegacy(runtime, model) {
   return isPresetRuntimeModel(runtime, model) ? { kind: "preset", id: model } : { kind: "custom", name: model };
 }
-function parseProviderConfig(runtime, value) {
+function parseProviderConfig(runtime, value, legacyApiUrl, legacyApiKey) {
   if (runtime !== "claude") return void 0;
   if (!isPlainRecord(value)) return { kind: "default" };
   if (value.kind === "custom" && typeof value.apiUrl === "string" && value.apiUrl.trim() && typeof value.apiKey === "string" && value.apiKey.trim()) {
     return { kind: "custom", apiUrl: value.apiUrl.trim(), apiKey: value.apiKey.trim() };
   }
+  if (value.kind === "custom" && legacyApiUrl?.trim() && legacyApiKey?.trim()) {
+    return { kind: "custom", apiUrl: legacyApiUrl.trim(), apiKey: legacyApiKey.trim() };
+  }
   return { kind: "default" };
 }
-function parseModelConfig(runtime, value, fallback) {
+function parseModelConfig(runtime, value, fallback, provider, legacyCustomModel) {
   if (!isPlainRecord(value)) return modelConfigFromLegacy(runtime, fallback);
   if (value.kind === "custom" && typeof value.name === "string" && value.name.trim()) {
     return { kind: "custom", name: value.name.trim() };
   }
-  if (value.kind === "preset" && typeof value.id === "string" && value.id.trim()) {
+  if (value.kind === "preset" && typeof value.id === "string" && value.id.trim() && isPresetRuntimeModel(runtime, value.id.trim())) {
     return { kind: "preset", id: value.id.trim() };
   }
+  if (provider?.kind === "custom" && runtime === "claude" && legacyCustomModel?.trim()) {
+    return { kind: "custom", name: legacyCustomModel.trim() };
+  }
   return modelConfigFromLegacy(runtime, fallback);
 }
 function parseModeConfig(value) {
@@ -1117,12 +1136,13 @@ function hydrateRuntimeConfig(input) {
   const storedEnvVars = normalizeEnvVars(stored?.envVars);
   const legacyClaudeApiUrl = runtime === "claude" ? legacyEnvVars?.ANTHROPIC_BASE_URL : void 0;
   const legacyClaudeApiKey = runtime === "claude" ? legacyEnvVars?.ANTHROPIC_API_KEY : void 0;
-  const provider = stored ? parseProviderConfig(runtime, stored.provider) : runtime === "claude" && legacyClaudeApiUrl && legacyClaudeApiKey ? { kind: "custom", apiUrl: legacyClaudeApiUrl, apiKey: legacyClaudeApiKey } : runtime === "claude" ? { kind: "default" } : void 0;
+  const legacyClaudeCustomModel = runtime === "claude" ? legacyEnvVars?.ANTHROPIC_CUSTOM_MODEL_OPTION : void 0;
+  const provider = stored ? parseProviderConfig(runtime, stored.provider, legacyClaudeApiUrl, legacyClaudeApiKey) : runtime === "claude" && legacyClaudeApiUrl && legacyClaudeApiKey ? { kind: "custom", apiUrl: legacyClaudeApiUrl, apiKey: legacyClaudeApiKey } : runtime === "claude" ? { kind: "default" } : void 0;
   return {
     version: RUNTIME_CONFIG_VERSION,
     runtime,
     ...provider ? { provider } : {},
-    model: stored ? parseModelConfig(runtime, stored.model, fallbackModel) : modelConfigFromLegacy(runtime, fallbackModel),
+    model: stored ? parseModelConfig(runtime, stored.model, fallbackModel, provider, legacyClaudeCustomModel) : modelConfigFromLegacy(runtime, fallbackModel),
     mode: stored ? parseModeConfig(stored.mode) : { kind: "default" },
     reasoningEffort: stored?.reasoningEffort ?? input.reasoningEffort ?? null,
     envVars: stripControlledRuntimeEnvVars(runtime, stored ? storedEnvVars : legacyEnvVars)
@@ -1190,10 +1210,10 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync5, readdirSync, statSync, writeFileSync as writeFileSync8 } 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 os5 from "os";
 
 // src/drivers/claude.ts
@@ -1374,19 +1394,19 @@ If Slock says a message was not sent and was saved as a draft, choose one path:
 
 Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
 
-- **Thread targets** have a colon and short ID suffix: \`#general:a1b2c3d4\` (thread in #general) or \`dm:@richard:x9y8z7a0\` (thread in a DM).
+- **Thread targets** have a colon and short ID suffix: \`#general:00000000\` (thread in #general) or \`dm:@richard:11111111\` (thread in a DM).
 - When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
-- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=a1b2c3d4 ...]\`, reply with \`slock message send --target "#general:a1b2c3d4" <<'${messageHeredocDelimiter}'\` followed by the message body and \`${messageHeredocDelimiter}\`. The thread will be auto-created if it doesn't exist yet.
+- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=00000000 ...]\`, reply with \`slock message send --target "#general:00000000" <<'${messageHeredocDelimiter}'\` followed by the message body and \`${messageHeredocDelimiter}\`. The thread will be auto-created if it doesn't exist yet. Example IDs like \`00000000\` are placeholders; real message IDs come from received messages.
 - When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
-- You can read thread history: \`slock message read --channel "#general:a1b2c3d4"\`
-- You can stop receiving ordinary delivery for a thread with \`slock thread unfollow --target "#general:a1b2c3d4"\`. Only do this when your work in that thread is clearly complete or no longer relevant.
+- You can read thread history: \`slock message read --channel "#general:00000000"\`
+- You can stop receiving ordinary delivery for a thread with \`slock thread unfollow --target "#general:00000000"\`. Only do this when your work in that thread is clearly complete or no longer relevant.
 - Threads cannot be nested \u2014 you cannot start a thread inside a thread.` : `### Threads
 
 Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
 
-- **Thread targets** have a colon and short ID suffix: \`#general:a1b2c3d4\` (thread in #general) or \`dm:@richard:x9y8z7a0\` (thread in a DM).
+- **Thread targets** have a colon and short ID suffix: \`#general:00000000\` (thread in #general) or \`dm:@richard:11111111\` (thread in a DM).
 - When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
-- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=a1b2c3d4 ...]\`, call \`${t("send_message")}(target="#general:a1b2c3d4", content="...")\`. The thread will be auto-created if it doesn't exist yet.
+- **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=00000000 ...]\`, call \`${t("send_message")}(target="#general:00000000", content="...")\`. The thread will be auto-created if it doesn't exist yet. Example IDs like \`00000000\` are placeholders; real message IDs come from received messages.
 - When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
 - You can read thread history via ${readCmd} with the same thread target.
 - Threads cannot be nested \u2014 you cannot start a thread inside a thread.`;
@@ -1552,13 +1572,18 @@ ${opts.postStartupNotes.join("\n")}`;
 Messages you receive have a single RFC 5424-style structured data header followed by the sender and content:
 
 \`\`\`
-[target=#general msg=a1b2c3d4 time=2026-03-15T01:00:00 type=human] @richard: hello everyone
-[target=#general msg=e5f6a7b8 time=2026-03-15T01:00:01 type=agent] @Alice: hi there
-[target=dm:@richard msg=c9d0e1f2 time=2026-03-15T01:00:02 type=human] @richard: hey, can you help?
-[target=#general:a1b2c3d4 msg=f3a4b5c6 time=2026-03-15T01:00:03 type=human] @richard: thread reply
-[target=dm:@richard:x9y8z7a0 msg=d7e8f9a0 time=2026-03-15T01:00:04 type=human] @richard: DM thread reply
+[target=#general msg=00000000 time=2026-03-15T01:00:00 type=human] @richard: hello everyone
+[target=#general msg=11111111 time=2026-03-15T01:00:01 type=agent] @Alice: hi there
+[target=dm:@richard msg=22222222 time=2026-03-15T01:00:02 type=human] @richard: hey, can you help?
+[target=#general:00000000 msg=33333333 time=2026-03-15T01:00:03 type=human] @richard: thread reply
+[target=dm:@richard:22222222 msg=44444444 time=2026-03-15T01:00:04 type=human] @richard: DM thread reply
 \`\`\`
 
+Prompt examples use obvious placeholder IDs such as \`00000000\`, \`11111111\`,
+and \`22222222\`. They show the shape of a real message ID but are not actual
+messages. Do not cite them as evidence; use only IDs from messages you actually
+received or read.
+
 Header fields:
 - \`target=\` \u2014 where the message came from. Reuse as the \`target\` parameter when replying.
 - \`msg=\` \u2014 message short ID (first 8 chars of UUID). Use as thread suffix to start/reply in a thread.
@@ -1712,12 +1737,12 @@ How to handle these:
 - Call ${checkCmd} at the next safe breakpoint to materialize the pending messages before taking side-effect actions that depend on current context.
 - If the new message is higher priority, pivot after reading it. If not, continue your current work.`;
     } else {
-      const notifyExample = isCli ? `\`[System notification: You have N new message(s) waiting. Call slock message check to read them when you're ready.]\`` : `\`[System notification: You have N new message(s) waiting. Call ${t("check_messages")} to read them when you're ready.]\``;
+      const notifyExample = isCli ? `\`[Slock inbox notice: You have N pending inbox message(s). Call slock message check to read them when you're ready.]\`` : `\`[Slock inbox notice: You have N pending inbox message(s). Call ${t("check_messages")} to read them when you're ready.]\``;
       prompt += `
 
 ## Message Notifications
 
-While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, you will receive a system notification like:
+While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, the daemon may write a Slock inbox notice like:
 
 ${notifyExample}
 
@@ -1778,6 +1803,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";
@@ -2172,7 +2210,7 @@ async function handleProxyRequest(req, res) {
       const bodyBuffer = new ArrayBuffer(rawBodyBuffer.byteLength);
       new Uint8Array(bodyBuffer).set(rawBodyBuffer);
       body = bodyBuffer;
-      headers.set("content-length", String(rawBodyBuffer.byteLength));
+      headers.delete("content-length");
     }
     let sendTarget;
     const sideEffectAction = agentApiSideEffectAction(target.pathname);
@@ -2196,7 +2234,7 @@ async function handleProxyRequest(req, res) {
       body = prepared.bodyText;
       if (sideEffectAction === "send") sendTarget = prepared.target;
       headers.set("content-type", "application/json");
-      headers.set("content-length", String(Buffer.byteLength(prepared.bodyText)));
+      headers.delete("content-length");
     }
     const upstream = await daemonFetch(target, {
       method,
@@ -2385,6 +2423,20 @@ function maxMessageSeq(messages) {
   }
   return maxSeq > 0 ? maxSeq : void 0;
 }
+function messageSenderId(message) {
+  if (typeof message.sender_id === "string" && message.sender_id.length > 0) return message.sender_id;
+  if (typeof message.senderId === "string" && message.senderId.length > 0) return message.senderId;
+  return void 0;
+}
+function isSelfAuthoredMessage(registration, message) {
+  return messageSenderId(message) === registration.agentId;
+}
+function isMessageModelSeen(coordinator, target, message) {
+  const seq = Math.floor(messageSeq(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;
+}
 function resolveFreshnessBoundary(messages) {
   const seenUpToSeq = maxMessageSeq(messages);
   return typeof seenUpToSeq === "number" ? { ok: true, seenUpToSeq } : { ok: false, reason: "missing_seq_boundary" };
@@ -2525,7 +2577,7 @@ function parseTargetFields(target) {
 }
 function normalizeVisibleMessage(message, target) {
   const targetFields = target ? parseTargetFields(target) : {};
-  return {
+  const normalized = {
     ...targetFields,
     ...message,
     message_id: message.message_id ?? message.id,
@@ -2534,6 +2586,9 @@ function normalizeVisibleMessage(message, target) {
     sender_name: message.sender_name ?? message.senderName,
     sender_description: message.sender_description ?? message.senderDescription ?? null
   };
+  const senderId = messageSenderId(message);
+  if (senderId) normalized.sender_id = senderId;
+  return normalized;
 }
 function normalizeVisibleMessages(messages, target) {
   return messages.map((message) => normalizeVisibleMessage(message, target));
@@ -2634,6 +2689,9 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
   }
   const recent = await loadRecentTargetMessages(registration, headers, target);
   if (recent.length > 0) {
+    const unconsumedCounterparty = recent.filter(
+      (message) => !isSelfAuthoredMessage(registration, message) && !isMessageModelSeen(coordinator, target, message)
+    );
     const boundary2 = resolveFreshnessBoundary(recent);
     if (!boundary2.ok) {
       recordFreshnessDecision(coordinator, {
@@ -2647,6 +2705,39 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
       });
       return { bodyText: JSON.stringify(body), target };
     }
+    if (unconsumedCounterparty.length === 0) {
+      const { seenUpToSeq: seenUpToSeq2 } = boundary2;
+      if (action === "send") body.seenUpToSeq = seenUpToSeq2;
+      coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq2, source: "side_effect_preflight_context" });
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "forward",
+        target,
+        inboxTrustState: "untrusted",
+        reason: "target_first_touch_recent_context_already_seen",
+        pendingCount: 0,
+        pendingMaxSeq: seenUpToSeq2,
+        modelSeenSeq: seenUpToSeq2,
+        heldMessageCount: 0,
+        omittedMessageCount: 0
+      });
+      return { bodyText: JSON.stringify(body), target };
+    }
+    const heldBoundary = resolveFreshnessBoundary(unconsumedCounterparty);
+    if (!heldBoundary.ok) {
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "forward",
+        target,
+        inboxTrustState: "untrusted",
+        reason: "target_first_touch_counterparty_context_without_seq_boundary",
+        pendingCount: 0,
+        modelSeenSeq: 0
+      });
+      return { bodyText: JSON.stringify(body), target };
+    }
+    const heldMessages = latestVisibleMessages(unconsumedCounterparty, LOCAL_HELD_CONTEXT_LIMIT);
+    const omittedMessageCount = Math.max(0, unconsumedCounterparty.length - heldMessages.length);
     const { seenUpToSeq } = boundary2;
     coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "side_effect_preflight_context" });
     const decision = {
@@ -2656,10 +2747,10 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
       inboxTrustState: "untrusted",
       reason: "target_first_touch_recent_context",
       pendingCount: 0,
-      pendingMaxSeq: seenUpToSeq,
+      pendingMaxSeq: heldBoundary.seenUpToSeq,
       modelSeenSeq: 0,
-      heldMessageCount: recent.length,
-      omittedMessageCount: 0
+      heldMessageCount: heldMessages.length,
+      omittedMessageCount
     };
     const producerFactId = buildApmFreshnessDecisionProducerFactId(registration.agentId, decision);
     recordFreshnessDecision(coordinator, { ...decision, producerFactId });
@@ -2669,9 +2760,9 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
       localResponse: projectApmHeldFreshnessEnvelope({
         producerFactId,
         action,
-        heldMessages: recent,
-        newMessageCount: recent.length,
-        omittedMessageCount: 0,
+        heldMessages,
+        newMessageCount: unconsumedCounterparty.length,
+        omittedMessageCount,
         seenUpToSeq
       }).body
     };
@@ -2777,7 +2868,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() {
@@ -2992,7 +3085,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];
   }
@@ -3026,7 +3119,126 @@ function collectResultErrorDetail(message, fallback) {
   return parts.join(" | ") || fallback;
 }
 function isProviderApiFailureText(value, hasToolUse) {
-  return !hasToolUse && /^\s*API Error:/i.test(value) && (/\b(?:ECONNRESET|EPIPE|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(value) || /\bUnable to connect to API\b/i.test(value) || /\b(?:timed out|timeout)\b/i.test(value) || /\b5\d{2}\b/.test(value));
+  return !hasToolUse && /^\s*API Error:/i.test(value) && (/\b(?:ECONNRESET|EPIPE|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(value) || /\bUnable to connect to API\b/i.test(value) || /\b(?:timed out|timeout)\b/i.test(value) || /\b4\d{2}\b/.test(value) || /\b5\d{2}\b/.test(value));
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function finiteString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function withDefined(attrs) {
+  return Object.fromEntries(Object.entries(attrs).filter(([, value]) => value !== void 0));
+}
+function collectNumericFields(value, fields) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const attrs = {};
+  for (const [sourceKey, attrKey] of Object.entries(fields)) {
+    const numberValue = finiteNumber(value[sourceKey]);
+    if (numberValue !== void 0) attrs[attrKey] = numberValue;
+  }
+  return attrs;
+}
+function collectModelUsageAttrs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const sanitized = {};
+  const aggregate = {};
+  const knownNumericFields = [
+    "inputTokens",
+    "outputTokens",
+    "cacheReadInputTokens",
+    "cacheCreationInputTokens",
+    "webSearchRequests",
+    "costUSD",
+    "contextWindow",
+    "maxOutputTokens"
+  ];
+  for (const [modelName, rawUsage] of Object.entries(value)) {
+    if (!rawUsage || typeof rawUsage !== "object" || Array.isArray(rawUsage)) continue;
+    const modelUsage = {};
+    for (const field of knownNumericFields) {
+      const numberValue = finiteNumber(rawUsage[field]);
+      if (numberValue === void 0) continue;
+      modelUsage[field] = numberValue;
+      const aggregateKey = field === "costUSD" ? "costUsd" : field;
+      if (field === "contextWindow" || field === "maxOutputTokens") {
+        aggregate[aggregateKey] = Math.max(aggregate[aggregateKey] ?? 0, numberValue);
+      } else {
+        aggregate[aggregateKey] = (aggregate[aggregateKey] ?? 0) + numberValue;
+      }
+    }
+    if (Object.keys(modelUsage).length > 0) sanitized[modelName] = modelUsage;
+  }
+  const modelNames = Object.keys(sanitized).sort();
+  if (modelNames.length === 0) return {};
+  const orderedSanitized = Object.fromEntries(modelNames.map((modelName) => [modelName, sanitized[modelName]]));
+  return withDefined({
+    modelUsageModelCount: modelNames.length,
+    modelUsageModels: modelNames.join(","),
+    modelUsageJson: JSON.stringify(orderedSanitized),
+    modelUsageInputTokens: aggregate.inputTokens,
+    modelUsageOutputTokens: aggregate.outputTokens,
+    modelUsageCachedInputTokens: aggregate.cacheReadInputTokens,
+    modelUsageCacheCreationInputTokens: aggregate.cacheCreationInputTokens,
+    modelUsageWebSearchRequests: aggregate.webSearchRequests,
+    modelUsageCostUsd: aggregate.costUsd,
+    modelUsageMaxContextWindow: aggregate.contextWindow,
+    modelUsageMaxOutputTokens: aggregate.maxOutputTokens
+  });
+}
+function parseClaudeResultUsageTelemetry(event) {
+  const usage = event.usage && typeof event.usage === "object" ? event.usage : void 0;
+  const totalCostUsd = finiteNumber(event.total_cost_usd);
+  const modelUsageAttrs = collectModelUsageAttrs(event.modelUsage);
+  const hasTelemetrySource = usage !== void 0 || totalCostUsd !== void 0 || Object.keys(modelUsageAttrs).length > 0;
+  if (!hasTelemetrySource) return null;
+  const inputTokens = finiteNumber(usage?.input_tokens);
+  const outputTokens = finiteNumber(usage?.output_tokens);
+  const cachedInputTokens = finiteNumber(usage?.cache_read_input_tokens);
+  const cacheCreationInputTokens = finiteNumber(usage?.cache_creation_input_tokens);
+  const attrs = {
+    ...withDefined({
+      totalCostUsd,
+      durationMs: finiteNumber(event.duration_ms),
+      durationApiMs: finiteNumber(event.duration_api_ms),
+      numTurns: finiteNumber(event.num_turns),
+      resultSubtype: finiteString(event.subtype),
+      stopReason: finiteString(event.stop_reason),
+      resultIsError: typeof event.is_error === "boolean" ? event.is_error : void 0,
+      fastModeState: finiteString(event.fast_mode_state),
+      permissionDenialsCount: Array.isArray(event.permission_denials) ? event.permission_denials.length : void 0,
+      serviceTier: finiteString(usage?.service_tier),
+      inferenceGeo: finiteString(usage?.inference_geo),
+      usageSpeed: finiteString(usage?.speed),
+      usageIterationsCount: Array.isArray(usage?.iterations) ? usage.iterations.length : void 0
+    }),
+    ...collectNumericFields(usage?.server_tool_use, {
+      web_search_requests: "serverToolUseWebSearchRequests",
+      web_fetch_requests: "serverToolUseWebFetchRequests"
+    }),
+    ...collectNumericFields(usage?.cache_creation, {
+      ephemeral_1h_input_tokens: "cacheCreationEphemeral1hInputTokens",
+      ephemeral_5m_input_tokens: "cacheCreationEphemeral5mInputTokens"
+    }),
+    ...modelUsageAttrs
+  };
+  if (inputTokens !== void 0) attrs.inputTokens = inputTokens;
+  if (outputTokens !== void 0) attrs.outputTokens = outputTokens;
+  if (cachedInputTokens !== void 0) attrs.cachedInputTokens = cachedInputTokens;
+  if (cacheCreationInputTokens !== void 0) attrs.cacheCreationInputTokens = cacheCreationInputTokens;
+  const tokenComponents = [inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens];
+  const totalTokens = tokenComponents.reduce((sum, value) => sum + (value ?? 0), 0);
+  if (tokenComponents.some((value) => value !== void 0)) attrs.totalTokens = totalTokens;
+  if (Object.keys(attrs).length === 0) return null;
+  return {
+    kind: "telemetry",
+    name: "token_usage",
+    source: "claude_result_usage",
+    usageKind: "per_turn",
+    ...typeof event.session_id === "string" && event.session_id ? { sessionId: event.session_id } : {},
+    ...typeof event.uuid === "string" && event.uuid ? { runtimeResultId: event.uuid } : {},
+    attrs
+  };
 }
 var ClaudeEventNormalizer = class {
   normalizeLine(line) {
@@ -3102,6 +3314,7 @@ 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);
         switch (subtype) {
           case "success":
             if (event.is_error && stopReason !== "max_tokens") {
@@ -3123,6 +3336,7 @@ var ClaudeEventNormalizer = class {
             pushResultError(event, "Structured output retries exceeded");
             break;
         }
+        if (usageTelemetry) events.push(usageTelemetry);
         events.push({ kind: "turn_end", sessionId: event.session_id });
         break;
       }
@@ -3291,7 +3505,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") {
@@ -3317,7 +3531,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"], {
@@ -3388,7 +3602,7 @@ function buildClaudeArgs(config, opts) {
     args.push("--effort", launchRuntimeFields.reasoningEffort);
   }
   if (launchRuntimeFields.mode.kind === "fast") {
-    args.push("--bare");
+    args.push("--settings", JSON.stringify({ fastMode: true }));
   }
   if (config.sessionId) {
     args.push("--resume", config.sessionId);
@@ -3546,53 +3760,64 @@ var RuntimeTurnState = class {
 };
 
 // src/drivers/codexTelemetrySidecar.ts
-function finiteNumber(value) {
+function finiteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function finiteString(value) {
+function finiteString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function ratio(numerator, denominator) {
   if (numerator === void 0 || denominator === void 0 || denominator <= 0) return void 0;
   return Number((numerator / denominator).toFixed(6));
 }
-function withDefined(attrs) {
+function withDefined2(attrs) {
   return Object.fromEntries(Object.entries(attrs).filter(([, value]) => value !== void 0));
 }
 function parseTokenUsageTelemetry(message) {
   const usage = message.params?.tokenUsage;
   const total = usage?.total;
   if (!total || typeof total !== "object") return null;
-  const inputTokens = finiteNumber(total.inputTokens);
-  const cachedInputTokens = finiteNumber(total.cachedInputTokens);
-  const totalTokens = finiteNumber(total.totalTokens);
-  const modelContextWindow = finiteNumber(usage.modelContextWindow);
-  const attrs = withDefined({
+  const inputTokens = finiteNumber2(total.inputTokens);
+  const cachedInputTokens = finiteNumber2(total.cachedInputTokens);
+  const totalTokens = finiteNumber2(total.totalTokens);
+  const modelContextWindow = finiteNumber2(usage.modelContextWindow);
+  const attrs = withDefined2({
     totalTokens,
     inputTokens,
     cachedInputTokens,
-    outputTokens: finiteNumber(total.outputTokens),
-    reasoningOutputTokens: finiteNumber(total.reasoningOutputTokens),
+    outputTokens: finiteNumber2(total.outputTokens),
+    reasoningOutputTokens: finiteNumber2(total.reasoningOutputTokens),
     modelContextWindow,
     cachedInputRatio: ratio(cachedInputTokens, inputTokens),
     contextUtilization: ratio(totalTokens, modelContextWindow)
   });
   if (Object.keys(attrs).length === 0) return null;
-  return { kind: "telemetry", name: "token_usage", attrs };
+  return {
+    kind: "telemetry",
+    name: "token_usage",
+    source: "codex_thread_token_usage_updated",
+    usageKind: "cumulative_session",
+    attrs
+  };
 }
 function parseRateLimitTelemetry(message) {
   const rateLimits = message.params?.rateLimits;
   const primary = rateLimits?.primary;
   if (!rateLimits || typeof rateLimits !== "object" || !primary || typeof primary !== "object") return null;
-  const attrs = withDefined({
-    limitId: finiteString(rateLimits.limitId),
-    planType: finiteString(rateLimits.planType),
-    usedPercent: finiteNumber(primary.usedPercent),
-    windowDurationMins: finiteNumber(primary.windowDurationMins),
-    resetsAt: finiteNumber(primary.resetsAt)
+  const attrs = withDefined2({
+    limitId: finiteString2(rateLimits.limitId),
+    planType: finiteString2(rateLimits.planType),
+    usedPercent: finiteNumber2(primary.usedPercent),
+    windowDurationMins: finiteNumber2(primary.windowDurationMins),
+    resetsAt: finiteNumber2(primary.resetsAt)
   });
   if (Object.keys(attrs).length === 0) return null;
-  return { kind: "telemetry", name: "rate_limits", attrs };
+  return {
+    kind: "telemetry",
+    name: "rate_limits",
+    source: "codex_account_rate_limits_updated",
+    attrs
+  };
 }
 function parseCodexTelemetryEvent(message) {
   switch (message.method) {
@@ -3699,7 +3924,11 @@ var CodexEventNormalizer = class {
     }
     const telemetry = parseCodexTelemetryEvent(message);
     if (telemetry) {
-      events.push(telemetry);
+      events.push({
+        ...telemetry,
+        ...this.currentThreadId ? { sessionId: this.currentThreadId } : {},
+        ...this.turnState.activeTurnId ? { turnId: this.turnState.activeTurnId } : {}
+      });
       return { events };
     }
     const rawProgress = rawResponseItemProgressEvent(message);
@@ -4052,6 +4281,7 @@ var CodexDriver = class {
       cwd: ctx.workingDirectory,
       approvalPolicy: "never",
       sandbox: "danger-full-access",
+      sandbox_mode: "danger-full-access",
       developerInstructions: ctx.standingPrompt,
       // Raw response items are used only as payload-free liveness signals in
       // the daemon. They replace the previous transcript-mtime heuristic.
@@ -4748,11 +4978,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"], {
@@ -4808,7 +5038,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 {
@@ -4980,13 +5210,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 {
@@ -4995,6 +5228,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",
@@ -5018,7 +5318,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 = "";
@@ -5072,6 +5390,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -5080,15 +5399,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,
@@ -5096,7 +5416,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",
@@ -5210,14 +5530,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;
@@ -5481,7 +5796,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"
@@ -5740,6 +6055,297 @@ var OpenCodeDriver = class {
   }
 };
 
+// src/drivers/pi.ts
+import { spawn as spawn9 } from "child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7 } from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+import { getAgentDir, VERSION as PI_SDK_VERSION } from "@earendil-works/pi-coding-agent";
+var CHAT_MCP_TOOL_PREFIX2 = "chat_";
+var NO_MESSAGE_PROMPT2 = "No new messages are pending. Stop now.";
+var FIRST_MESSAGE_TASK_PREFIX2 = "First message task (system-triggered):";
+var MIN_SUPPORTED_PI_VERSION = "0.74.0";
+function parseSemver2(version) {
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isSupportedPiVersion(version) {
+  if (!version) return true;
+  const actual = parseSemver2(version);
+  const minimum = parseSemver2(MIN_SUPPORTED_PI_VERSION);
+  if (!actual || !minimum) return true;
+  for (let i = 0; i < 3; i += 1) {
+    if (actual[i] > minimum[i]) return true;
+    if (actual[i] < minimum[i]) return false;
+  }
+  return true;
+}
+function unsupportedPiVersionMessage(version) {
+  if (!version || isSupportedPiVersion(version)) return null;
+  return `Pi SDK ${version} is unsupported; requires @earendil-works/pi-coding-agent >= ${MIN_SUPPORTED_PI_VERSION}. Upgrade the daemon Pi dependency before starting this runtime.`;
+}
+function probePi(version = PI_SDK_VERSION) {
+  const unsupportedMessage = unsupportedPiVersionMessage(version);
+  if (unsupportedMessage) {
+    return {
+      available: false,
+      version: `${version} (requires @earendil-works/pi-coding-agent >= ${MIN_SUPPORTED_PI_VERSION})`
+    };
+  }
+  return { available: true, version };
+}
+function resolvePiSdkRunnerPath(moduleUrl = import.meta.url) {
+  const moduleDir = path11.dirname(fileURLToPath(moduleUrl));
+  const sourceSibling = path11.join(moduleDir, "piSdkRunner.ts");
+  if (existsSync8(sourceSibling)) return sourceSibling;
+  const bundledEntry = path11.join(moduleDir, "drivers", "piSdkRunner.js");
+  if (existsSync8(bundledEntry)) return bundledEntry;
+  return path11.join(moduleDir, "piSdkRunner.js");
+}
+function buildPiSdkNodeArgs(runnerPath = resolvePiSdkRunnerPath()) {
+  if (runnerPath.endsWith(".ts")) {
+    return [...process.execArgv, runnerPath];
+  }
+  return [runnerPath];
+}
+async function buildPiLaunchOptions(ctx, opts = {}) {
+  const command = opts.command ?? process.execPath;
+  const piDir = path11.join(ctx.workingDirectory, ".slock", "pi");
+  const sessionDir = path11.join(piDir, "sessions");
+  mkdirSync4(sessionDir, { recursive: true });
+  const slock = await prepareCliTransport(ctx, { NO_COLOR: "1" });
+  const runnerPath = opts.runnerPath ?? resolvePiSdkRunnerPath();
+  const agentDir = opts.agentDir ?? getAgentDir();
+  const runnerConfigPath = path11.join(
+    piDir,
+    `sdk-run-${(ctx.launchId || "launch").replace(/[^a-zA-Z0-9_.-]/g, "_")}.json`
+  );
+  const turnPrompt = ctx.prompt === ctx.standingPrompt ? NO_MESSAGE_PROMPT2 : ctx.prompt;
+  const runnerConfig = {
+    cwd: ctx.workingDirectory,
+    agentDir,
+    sessionDir,
+    sessionId: ctx.config.sessionId || null,
+    standingPrompt: ctx.standingPrompt,
+    prompt: turnPrompt,
+    model: ctx.config.model && ctx.config.model !== "default" ? ctx.config.model : null
+  };
+  writeFileSync7(runnerConfigPath, `${JSON.stringify(runnerConfig)}
+`, { encoding: "utf8", mode: 384 });
+  const args = [
+    ...buildPiSdkNodeArgs(runnerPath),
+    "--config",
+    runnerConfigPath
+  ];
+  return {
+    command,
+    args,
+    env: slock.spawnEnv,
+    sessionDir,
+    agentDir,
+    runnerConfigPath,
+    sdkVersion: PI_SDK_VERSION
+  };
+}
+function isSystemFirstMessageTask2(message) {
+  return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX2);
+}
+function buildPiSystemPrompt(config) {
+  return buildCliTransportSystemPrompt(config, {
+    toolPrefix: CHAT_MCP_TOOL_PREFIX2,
+    extraCriticalRules: [
+      "- Runtime Profile migration controls are not available in the Pi runtime yet. If asked to acknowledge a runtime migration, explain the blocker instead of inventing a command."
+    ],
+    postStartupNotes: [
+      "**Pi runtime note:** Slock launches you as a per-turn process. Complete the current wake using `slock` CLI commands, then stop; the daemon will restart you when new messages arrive."
+    ],
+    includeStdinNotificationSection: false,
+    messageNotificationStyle: "poll"
+  });
+}
+function contentText(content) {
+  if (!content) return "";
+  const chunks = [];
+  for (const item of content) {
+    if (item.type === "text" && typeof item.text === "string") {
+      chunks.push(item.text);
+    }
+  }
+  return chunks.join("");
+}
+function apiKeyErrorMessage(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  if (/no api key found/i.test(trimmed)) return trimmed;
+  if (/api key.+required/i.test(trimmed)) return trimmed;
+  if (/no models available/i.test(trimmed)) return trimmed;
+  return null;
+}
+var PiDriver = class {
+  id = "pi";
+  lifecycle = {
+    kind: "per_turn",
+    start: "defer_until_concrete_message",
+    exit: "terminate_on_turn_end",
+    inFlightWake: "coalesce_into_pending"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "none"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: async (modelId, ctx) => {
+      if (!ctx) return modelId && modelId !== "default" ? { args: ["--model", modelId] } : { args: [] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = await buildPiLaunchOptions(launchCtx);
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: [launch.runnerConfigPath],
+        params: {
+          agentDir: launch.agentDir,
+          sessionDir: launch.sessionDir,
+          sdkVersion: launch.sdkVersion,
+          resources: "extensions/skills/prompt-templates/themes/context-files disabled by Slock policy"
+        }
+      };
+    }
+  };
+  supportsStdinNotification = false;
+  mcpToolPrefix = CHAT_MCP_TOOL_PREFIX2;
+  busyDeliveryMode = "none";
+  terminateProcessOnTurnEnd = true;
+  deferSpawnUntilMessage = true;
+  usesSlockCliForCommunication = true;
+  sessionId = null;
+  sessionAnnounced = false;
+  apiKeyErrorAnnounced = false;
+  turnEnded = false;
+  assistantTextByMessageId = /* @__PURE__ */ new Map();
+  shouldDeferWakeMessage(message) {
+    return isSystemFirstMessageTask2(message);
+  }
+  probe() {
+    return probePi();
+  }
+  async detectModels() {
+    return null;
+  }
+  async spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    this.apiKeyErrorAnnounced = false;
+    this.turnEnded = false;
+    this.assistantTextByMessageId.clear();
+    const unsupportedMessage = unsupportedPiVersionMessage(PI_SDK_VERSION);
+    if (unsupportedMessage) throw new Error(unsupportedMessage);
+    const launch = await buildPiLaunchOptions(ctx);
+    const proc = spawn9(launch.command, launch.args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: launch.env,
+      shell: false
+    });
+    proc.stdin?.end();
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      if (this.apiKeyErrorAnnounced) return [];
+      const message = apiKeyErrorMessage(line);
+      if (!message) return [];
+      this.apiKeyErrorAnnounced = true;
+      this.turnEnded = true;
+      return [
+        { kind: "error", message },
+        { kind: "turn_end", sessionId: this.sessionId || void 0 }
+      ];
+    }
+    const events = [];
+    if (event.type === "session" && event.id) {
+      this.sessionId = event.id;
+    }
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    switch (event.type) {
+      case "agent_start":
+      case "turn_start":
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "message_update":
+      case "message_end":
+        if (event.message?.role === "assistant") {
+          const key = event.message.id || "current";
+          const currentText = contentText(event.message.content);
+          const previousText = this.assistantTextByMessageId.get(key) ?? "";
+          if (currentText.length > previousText.length && currentText.startsWith(previousText)) {
+            events.push({ kind: "text", text: currentText.slice(previousText.length) });
+          } else if (currentText && currentText !== previousText) {
+            events.push({ kind: "text", text: currentText });
+          }
+          this.assistantTextByMessageId.set(key, currentText);
+          if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
+            events.push({ kind: "error", message: event.message.errorMessage || `Request ${event.message.stopReason}` });
+          }
+        }
+        break;
+      case "tool_execution_start":
+        events.push({
+          kind: "tool_call",
+          name: event.toolName || "unknown_tool",
+          input: event.args
+        });
+        break;
+      case "tool_execution_end":
+        events.push({
+          kind: "tool_output",
+          name: event.toolName || "unknown_tool"
+        });
+        if (event.isError) {
+          events.push({ kind: "error", message: `Pi tool ${event.toolName || "unknown_tool"} failed` });
+        }
+        break;
+      case "compaction_start":
+        events.push({ kind: "compaction_started" });
+        break;
+      case "compaction_end":
+        events.push({ kind: "compaction_finished" });
+        if (event.errorMessage) events.push({ kind: "error", message: event.errorMessage });
+        break;
+      case "turn_end":
+      case "agent_end":
+        if (!this.turnEnded) {
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+          this.turnEnded = true;
+        }
+        break;
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildPiSystemPrompt(config);
+  }
+};
+
 // src/drivers/index.ts
 var driverFactories = {
   claude: () => new ClaudeDriver(),
@@ -5749,7 +6355,8 @@ var driverFactories = {
   cursor: () => new CursorDriver(),
   gemini: () => new GeminiDriver(),
   kimi: () => new KimiDriver(),
-  opencode: () => new OpenCodeDriver()
+  opencode: () => new OpenCodeDriver(),
+  pi: () => new PiDriver()
 };
 function getDriver(runtimeId) {
   const createDriver = driverFactories[runtimeId];
@@ -5762,7 +6369,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("..");
 }
@@ -5770,7 +6377,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 {
@@ -5819,7 +6426,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);
@@ -5838,7 +6445,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 {
@@ -6278,12 +6885,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;
@@ -6296,10 +6903,10 @@ 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`);
-    writeFileSync7(filePath, JSON.stringify({
+    const dir = path13.join(fallbackDir, ".slock", "runtime-sessions");
+    mkdirSync5(dir, { recursive: true });
+    const filePath = path13.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    writeFileSync8(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
       sessionId,
@@ -6318,7 +6925,7 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   }
 }
 function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), fallbackDir) {
-  const directPath = path12.isAbsolute(sessionId) ? sessionId : null;
+  const directPath = path13.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
       if (statSync(directPath).isFile()) {
@@ -6327,7 +6934,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.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;
@@ -6416,7 +7023,7 @@ function dynamicClaimInstruction(driver) {
 }
 function formatIncomingMessage(message, driver) {
   const threadJoinPrefix = message.thread_join_context ? [
-    `[System: You were added to a new thread via @mention. Read this context before replying.]`,
+    `[Slock thread context: you were added to a new thread via @mention.]`,
     `parent: ${message.thread_join_context.parent_target}`,
     `thread: ${message.thread_join_context.thread_target}`,
     `suggested next step: ${driver?.usesSlockCliForCommunication ? `slock message read --channel "${message.thread_join_context.suggested_read_history_target}"` : `${communicationCommand(driver, "read_history")}(channel="${message.thread_join_context.suggested_read_history_target}")`}`,
@@ -7242,7 +7849,7 @@ function getBusyDeliveryNote(driver) {
   if (driver.busyDeliveryMode === "gated") {
     return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn at runtime-observed safe boundaries. Call check_messages to read the pending messages before context-sensitive side effects.";
   }
-  return "\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.";
+  return "\n\nNote: While you are busy, you may receive [Slock inbox notice: ...] messages. Finish your current step, then call check_messages to check for messages.";
 }
 var NATIVE_STANDING_PROMPT_STARTUP_INPUT = (
   // Claude Code 2.1.114 treats "follow your system prompt" style user turns as
@@ -7280,6 +7887,7 @@ var AgentProcessManager = class _AgentProcessManager {
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
   processExitTraceAttrs = /* @__PURE__ */ new WeakMap();
   agentVisibleBoundaries = /* @__PURE__ */ new Map();
+  agentVisibleMessageIds = /* @__PURE__ */ new Map();
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
     this.slockCliPath = opts.slockCliPath ?? "";
@@ -7325,6 +7933,24 @@ var AgentProcessManager = class _AgentProcessManager {
   getVisibleBoundary(agentId, target) {
     return this.agentVisibleBoundaries.get(agentId)?.get(target);
   }
+  visibleMessageIdMap(agentId) {
+    let map = this.agentVisibleMessageIds.get(agentId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.agentVisibleMessageIds.set(agentId, map);
+    }
+    return map;
+  }
+  getVisibleMessageIdSet(agentId, target) {
+    return this.agentVisibleMessageIds.get(agentId)?.get(target);
+  }
+  isVisibleMessageModelSeen(agentId, target, message) {
+    const seq = Number(message.seq ?? 0);
+    const boundary = this.getVisibleBoundary(agentId, target);
+    if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= Math.floor(seq)) return true;
+    const id = typeof message.message_id === "string" ? message.message_id : typeof message.id === "string" ? message.id : "";
+    return id.length > 0 && this.getVisibleMessageIdSet(agentId, target)?.has(id) === true;
+  }
   scheduleStdinNotification(agentId, ap, delayMs) {
     return ap.notifications.schedule(() => {
       this.sendStdinNotification(agentId);
@@ -7359,13 +7985,14 @@ var AgentProcessManager = class _AgentProcessManager {
     };
     for (const message of input.messages) {
       const seq = Number(message.seq ?? 0);
-      if (!Number.isFinite(seq) || seq <= 0) continue;
       const target = input.target ?? formatVisibleMessageTarget(message);
       if (!target) continue;
       const bucket = ensureBucket(target);
-      bucket.maxSeq = Math.max(bucket.maxSeq, Math.floor(seq));
-      bucket.seqs.add(Math.floor(seq));
-      const id = typeof message.id === "string" ? message.id : typeof message.message_id === "string" ? message.message_id : null;
+      if (Number.isFinite(seq) && seq > 0) {
+        bucket.maxSeq = Math.max(bucket.maxSeq, Math.floor(seq));
+        bucket.seqs.add(Math.floor(seq));
+      }
+      const id = typeof message.message_id === "string" ? message.message_id : typeof message.id === "string" ? message.id : null;
       if (id) bucket.ids.add(id);
     }
     if (input.target && typeof input.boundarySeq === "number" && Number.isFinite(input.boundarySeq) && input.boundarySeq > 0) {
@@ -7374,10 +8001,19 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     if (byTarget.size === 0) return;
     const boundaryMap = this.visibleBoundaryMap(agentId);
+    const visibleIds = this.visibleMessageIdMap(agentId);
     for (const [target, bucket] of byTarget) {
       const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
       const previous = boundaryMap.get(target) ?? 0;
       boundaryMap.set(target, Math.max(previous, highWaterSeq));
+      if (bucket.ids.size > 0) {
+        let targetIds = visibleIds.get(target);
+        if (!targetIds) {
+          targetIds = /* @__PURE__ */ new Set();
+          visibleIds.set(target, targetIds);
+        }
+        for (const id of bucket.ids) targetIds.add(id);
+      }
     }
     const suppress = (messages) => {
       if (!messages || messages.length === 0) return 0;
@@ -7410,6 +8046,7 @@ var AgentProcessManager = class _AgentProcessManager {
     return {
       getBoundary: (target) => this.getVisibleBoundary(agentId, target),
       getPendingMessages: (target) => this.pendingVisibleMessages(agentId, target),
+      isMessageModelSeen: ({ target, message }) => this.isVisibleMessageModelSeen(agentId, target, message),
       getAllPendingMessages: () => this.allPendingVisibleMessages(agentId),
       consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input),
       recordDrainOutcome: (input) => {
@@ -7721,7 +8358,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;
@@ -7735,23 +8372,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);
           }
         }
@@ -8623,7 +9260,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     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})`);
@@ -8684,7 +9321,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path12.join(this.dataDir, agentId);
+    const workspacePath = path13.join(this.dataDir, agentId);
     return {
       agentId,
       launchId,
@@ -8941,7 +9578,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   // 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 {
@@ -8949,8 +9586,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     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;
@@ -8958,14 +9595,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     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");
@@ -9000,13 +9637,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
     const home = os5.homedir();
-    const workspaceDir = path12.join(this.dataDir, agentId);
+    const workspaceDir = path13.join(this.dataDir, agentId);
     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();
@@ -9035,7 +9672,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     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);
@@ -9046,7 +9683,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       } 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);
@@ -9606,7 +10243,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   isThinkingBlockMutationError(message) {
-    return /thinking.*redacted_thinking|redacted_thinking.*thinking/i.test(message) && /cannot be modified/i.test(message);
+    return /thinking.*redacted_thinking|redacted_thinking.*thinking/i.test(message) && /cannot be modified/i.test(message) || /messages\.\d+\.content\.\d+\.text\.start_timestamp:\s*Extra inputs are not permitted/i.test(message);
   }
   markRuntimeProgressStaleIfNeeded(agentId, ap) {
     if (ap.lastActivity !== "working" && ap.lastActivity !== "thinking") return false;
@@ -9935,15 +10572,23 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   recordRuntimeTelemetry(agentId, ap, event) {
+    const telemetryAttrs = {
+      ...event.attrs,
+      ...event.source ? { source: event.source } : {},
+      ...event.usageKind ? { usageKind: event.usageKind } : {},
+      ...event.sessionId ? { sessionId: event.sessionId } : {},
+      ...event.turnId ? { turnId: event.turnId } : {},
+      ...event.runtimeResultId ? { runtimeResultId: event.runtimeResultId } : {}
+    };
     const attrs = {
       agentId,
       launchId: ap.launchId || void 0,
       runtime: ap.config.runtime,
       model: ap.config.model,
       telemetry_name: event.name,
-      ...event.attrs
+      ...telemetryAttrs
     };
-    ap.runtimeTraceSpan?.addEvent(`runtime.telemetry.${event.name}`, event.attrs);
+    ap.runtimeTraceSpan?.addEvent(`runtime.telemetry.${event.name}`, telemetryAttrs);
     this.recordDaemonTrace(`daemon.runtime.telemetry.${event.name}`, attrs);
   }
   sendAgentStatus(agentId, status, launchId) {
@@ -10017,7 +10662,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const notification = `[System notification: You have ${inboxCount} pending inbox message${inboxCount > 1 ? "s" : ""}. Call check_messages to read ${inboxCount > 1 ? "them" : "it"} when you're ready.]`;
+    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 encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     if (encoded) {
@@ -10164,8 +10809,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);
@@ -10470,9 +11115,9 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
 import os6 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";
@@ -10494,7 +11139,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 {
@@ -10524,13 +11169,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 machineDir = path14.join(rootDir, lockId);
+  const lockDir = path14.join(machineDir, "daemon.lock");
   const token = randomUUID3();
-  mkdirSync5(machineDir, { recursive: true });
+  mkdirSync6(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      mkdirSync5(lockDir);
+      mkdirSync6(lockDir);
       const owner = {
         pid: process.pid,
         token,
@@ -10540,7 +11185,7 @@ function acquireDaemonMachineLock(options) {
         apiKeyFingerprint: fingerprint.slice(0, 16)
       };
       try {
-        writeFileSync8(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+        writeFileSync9(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
 `, { mode: 384 });
       } catch (err) {
         rmSync3(lockDir, { recursive: true, force: true });
@@ -10553,7 +11198,15 @@ function acquireDaemonMachineLock(options) {
         release: () => {
           const currentOwner = readOwner(lockDir);
           if (currentOwner?.pid === process.pid && currentOwner.token === token) {
-            rmSync3(lockDir, { recursive: true, force: true });
+            const released = { ...currentOwner, pid: 0 };
+            try {
+              writeFileSync9(ownerPath(lockDir), `${JSON.stringify(released, null, 2)}
+`, {
+                mode: 384
+              });
+            } catch {
+              rmSync3(lockDir, { recursive: true, force: true });
+            }
           }
         }
       };
@@ -10577,8 +11230,8 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
-import path14 from "path";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync10 } 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;
@@ -10615,7 +11268,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));
@@ -10641,15 +11294,15 @@ 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`
       );
-      writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
+      writeFileSync10(this.currentFile, "", { flag: "a", mode: 384 });
       this.currentSize = statSync3(this.currentFile).size;
       this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
@@ -10660,7 +11313,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 });
     }
   }
 };
@@ -10751,11 +11404,11 @@ function isDiagnosticErrorAttr(key) {
 import { createHash as createHash6, randomUUID as randomUUID4 } 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/directUploadCapability.ts
-function joinUrl(base, path17) {
-  return `${base.replace(/\/+$/, "")}${path17}`;
+function joinUrl(base, path18) {
+  return `${base.replace(/\/+$/, "")}${path18}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -10974,7 +11627,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);
@@ -10986,8 +11639,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);
@@ -11061,8 +11714,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 {
@@ -11074,9 +11727,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)}
@@ -11098,7 +11751,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;
@@ -11134,9 +11787,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];
@@ -11153,23 +11806,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path16.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path16.resolve(dirname, "chat-bridge.js");
+  const dirname = path17.dirname(fileURLToPath2(moduleUrl));
+  const jsPath = path17.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path16.resolve(dirname, "chat-bridge.ts");
+    return path17.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path16.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path16.resolve(thisDir, "cli", "index.js");
+  const thisDir = path17.dirname(fileURLToPath2(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;
   }
@@ -11299,6 +11952,11 @@ function summarizeIncomingMessage(msg) {
 var DaemonCore = class {
   options;
   daemonVersion;
+  // When this runner is launched by a managed Computer service, the
+  // service exports SLOCK_COMPUTER_VERSION (the `@slock-ai/computer`
+  // bundle version). Reported in `ready` so the server can surface the
+  // Computer's own version (distinct from the underlying daemonVersion).
+  computerVersion;
   chatBridgePath;
   slockCliPath;
   slockHome;
@@ -11314,6 +11972,7 @@ var DaemonCore = class {
   constructor(options) {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
+    this.computerVersion = (process.env.SLOCK_COMPUTER_VERSION || "").trim() || null;
     this.chatBridgePath = options.chatBridgePath ?? resolveChatBridgePath();
     this.slockCliPath = options.slockCliPath ?? resolveSlockCliPath();
     this.slockHome = resolveSlockHome();
@@ -11348,7 +12007,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() {
@@ -11374,7 +12033,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;
@@ -11773,6 +12432,26 @@ var DaemonCore = class {
       case "ping":
         this.connection.send({ type: "pong" });
         break;
+      case "computer:restart":
+      case "computer:upgrade": {
+        const action = msg.type === "computer:restart" ? "restart" : "upgrade";
+        this.recordDaemonTrace("daemon.computer_control.received", {
+          action,
+          handled: Boolean(this.options.onComputerControl)
+        });
+        if (this.options.onComputerControl) {
+          try {
+            this.options.onComputerControl(action);
+          } catch (err) {
+            logger.error(
+              `[Daemon] computer:${action} control handler failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        } else {
+          logger.info(`[Daemon] Ignoring computer:${action} \u2014 not launched by a Computer service.`);
+        }
+        break;
+      }
     }
   }
   onReminderFire(job) {
@@ -11799,7 +12478,8 @@ var DaemonCore = class {
       runningAgents: runningAgentIds,
       hostname: this.options.hostname ?? os7.hostname(),
       os: this.options.osDescription ?? `${os7.platform()} ${os7.arch()}`,
-      daemonVersion: this.daemonVersion
+      daemonVersion: this.daemonVersion,
+      ...this.computerVersion ? { computerVersion: this.computerVersion } : {}
     });
     this.recordDaemonTrace("daemon.ready.sent", {
       runtimes_count: runtimes.length,
@@ -11860,6 +12540,8 @@ var DaemonCore = class {
 };
 
 export {
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,