@slock-ai/daemon 0.51.1 → 0.52.1-play.20260520171228

package/dist/{chunk-JDSI7JD5.js → chunk-UM3RDELD.js}

@@ -7,11 +7,11 @@ import {
 } from "./chunk-KNMCE6WB.js";
 
 // src/core.ts
-import path16 from "path";
+import path17 from "path";
 import os8 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../shared/src/tracing/index.ts
 var DEFAULT_TRACE_FLAGS = "00";
@@ -723,6 +723,7 @@ var SERVER_CAPABILITY_MATRIX = {
 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: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
   { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
   { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
@@ -764,10 +765,10 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync4, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync as statSync2, 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 createHash2 } from "crypto";
-import path12 from "path";
+import path13 from "path";
 import os6 from "os";
 
 // src/drivers/claude.ts
@@ -823,6 +824,7 @@ function buildPrompt(config, variant, opts) {
     "- Always communicate through `slock` CLI commands. This is your only output channel.",
     ...opts.extraCriticalRules,
     "- Use only the provided `slock` CLI commands for messaging.",
+    "- Do not combine multiple `slock` CLI commands in one shell command. Run one `slock` command per tool call, read its output, then decide the next command.",
     "- Always claim a task via `slock task claim` before starting work on it. If the claim fails, move on to a different task."
   ] : [
     `- Always communicate through ${sendCmd}. This is your only output channel.`,
@@ -871,13 +873,15 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 17. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
 18. **\`slock profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
 19. **\`slock profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--avatar-url pixel:random:<seed>\`, \`--display-name <name>\`, and \`--description <text>\`. Use \`--avatar-url pixel:random:<seed>\` when you want a new pixel avatar but do not have a local image file. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
-20. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
-21. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
-22. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
-23. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
-24. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
-25. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
-26. **\`slock action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
+20. **\`slock integration list\`** \u2014 List registered third-party services and this agent's active Slock Agent Logins.
+21. **\`slock integration login\`** \u2014 Provision or reuse this agent's login for a registered third-party service.
+22. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+23. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
+24. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
+25. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
+26. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
+27. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
+28. **\`slock action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
 
 The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints JSON to stderr:
 - failure \u2192 stderr \`{"ok":false,"code":"...","message":"..."}\` with non-zero exit
@@ -978,6 +982,11 @@ Each channel has a **name** and optionally a **description** that define its pur
 - **Reply in context** \u2014 always respond in the channel/thread the message came from.
 - **Stay on topic** \u2014 when proactively sharing results or updates, post in the channel most relevant to the work. Don't scatter messages across unrelated channels.
 - If unsure where something belongs, call ${serverInfoCmd} to review channel descriptions.`;
+  const thirdPartyIntegrationsSection = isCli ? `### Third-party integrations
+
+If a registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first run \`slock integration list\` and match the app to a registered service before browsing the app. Use \`slock integration login --service <service>\` to provision or reuse your agent login for that service. When the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`slock profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.` : `### Third-party integrations
+
+If a registered third-party service requires login, use Slock Agent Login through the available registered-service interface instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app, first inspect the registered-service interface and match the app to a registered service before browsing the app. Once the registered-service interface reports the agent login is ready, the agent-side login is ready. If that interface provides an app URL, use it as the service-provided third-party app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow or treat internal request IDs as OAuth callback codes unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use your Slock profile view. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the registered service / Slock Agent Login path.`;
   const readingHistorySection = isCli ? `### Reading history
 
 \`slock message read --channel "#channel-name"\` or \`slock message read --channel dm:@peer-name\` or \`slock message read --channel "#channel:shortid"\`
@@ -1149,6 +1158,8 @@ ${discoverySection}
 
 ${channelAwarenessSection}
 
+${thirdPartyIntegrationsSection}
+
 ${readingHistorySection}
 
 ${historicalReferenceSection}
@@ -1180,6 +1191,17 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
 - When done, summarize the result.
 - Keep updates concise \u2014 one or two sentences. Don't flood the chat.
+- For long answers where users need the conclusion first but details still matter, put the conclusion and next action outside any collapse, then use sanitized HTML details blocks for optional depth:
+
+\`\`\`html
+<details>
+<summary>Evidence, logs, or edge cases</summary>
+
+Detailed notes go here.
+</details>
+\`\`\`
+
+  Do not hide the main recommendation, blocker, or required action inside \`<details>\`; only fold supporting evidence, logs, alternatives, or extended rationale.
 
 ### Conversation etiquette
 
@@ -1275,13 +1297,12 @@ You may develop a specialized role over time through your interactions. Embrace
 
 ## Message Notifications
 
-While you are working, new messages may be delivered directly into your current thread.
+While you are working, the daemon may write a batched inbox-count notification into your current turn.
 
 How to handle these:
-- Treat direct follow-up messages as new user input for the same live session.
-- Adapt if the new message changes priority or direction.
-- You do NOT need to poll just because direct follow-up delivery is available.
-- Use ${checkCmd} only when you need to inspect other pending channels or recover broader context.`;
+- Treat the notification as a signal that new Slock messages are waiting; it does not include the message content.
+- 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.]\``;
       prompt += `
@@ -1349,6 +1370,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";
@@ -1356,6 +1390,7 @@ import { URL as URL2 } from "url";
 var registrations = /* @__PURE__ */ new Map();
 var servers = /* @__PURE__ */ new Map();
 var DECODED_RESPONSE_HEADERS = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding"]);
+var LOCAL_HELD_CONTEXT_LIMIT = 3;
 function allocatePort() {
   return 43e3 + randomBytes(2).readUInt16BE(0) % 1e4;
 }
@@ -1388,8 +1423,10 @@ async function handleProxyRequest(req, res) {
     res.end(JSON.stringify({ error: "invalid local agent proxy token", code: "invalid_agent_proxy_token" }));
     return;
   }
+  const method = req.method ?? "GET";
+  let target;
   try {
-    const target = new URL2(req.url ?? "/", registration.serverUrl);
+    target = new URL2(req.url ?? "/", registration.serverUrl);
     const headers = new Headers();
     for (const [name, value] of Object.entries(req.headers)) {
       if (value === void 0) continue;
@@ -1405,12 +1442,20 @@ async function handleProxyRequest(req, res) {
     headers.set("X-Agent-Id", registration.agentId);
     headers.set("X-Slock-Client", "cli");
     headers.set("X-Slock-Agent-Active-Capabilities", registration.activeCapabilities);
-    const method = req.method ?? "GET";
     let body = method === "GET" || method === "HEAD" ? void 0 : req;
     let sendTarget;
-    if (method === "POST" && target.pathname === "/internal/agent-api/send") {
+    const sideEffectAction = agentApiSideEffectAction(target.pathname);
+    if (method === "GET" && target.pathname === "/internal/agent-api/events") {
+      const localEvents = localAgentApiEventsResponse(registration, target);
+      if (localEvents) {
+        res.writeHead(localEvents.status, { "content-type": "application/json" });
+        res.end(JSON.stringify(localEvents.body));
+        return;
+      }
+    }
+    if (method === "POST" && sideEffectAction) {
       const rawBody = await readRequestBody(req);
-      const prepared = await prepareAgentApiSendForward(registration, headers, rawBody);
+      const prepared = await prepareAgentApiSideEffectForward(registration, headers, rawBody, sideEffectAction);
       if (prepared.localResponse) {
         const responseText = JSON.stringify(prepared.localResponse);
         res.writeHead(200, { "content-type": "application/json" });
@@ -1418,7 +1463,7 @@ async function handleProxyRequest(req, res) {
         return;
       }
       body = prepared.bodyText;
-      sendTarget = prepared.target;
+      if (sideEffectAction === "send") sendTarget = prepared.target;
       headers.set("content-type", "application/json");
       headers.set("content-length", String(Buffer.byteLength(prepared.bodyText)));
     }
@@ -1452,14 +1497,33 @@ async function handleProxyRequest(req, res) {
       res.end();
     }
   } catch (err) {
+    const failure = proxyFailureForError(method, target, err);
+    logger.warn(
+      `[Agent Credential Proxy] request failed (agent=${registration.agentId}, launch=${registration.launchId ?? "none"}, method=${failure.method}, path=${failure.pathname}, query_keys=${failure.queryKeys.join(",") || "none"}): ${failure.errorName}: ${failure.errorMessage}`
+    );
+    registration.inboxCoordinator?.recordProxyFailure?.(failure);
     res.writeHead(502, { "content-type": "application/json" });
     res.end(JSON.stringify({
       error: "failed to proxy local agent request",
       code: "agent_proxy_failed",
-      detail: err instanceof Error ? err.message : String(err)
+      detail: failure.errorMessage
     }));
   }
 }
+function proxyFailureForError(method, target, err) {
+  const queryKeys = target ? [.../* @__PURE__ */ new Set([...target.searchParams.keys()])].sort() : [];
+  return {
+    method,
+    pathname: target?.pathname ?? "unknown",
+    queryKeys,
+    errorName: err instanceof Error ? err.name : typeof err,
+    errorMessage: truncateProxyErrorMessage(err instanceof Error ? err.message : String(err))
+  };
+}
+function truncateProxyErrorMessage(message) {
+  const normalized = message.replace(/\s+/g, " ").trim();
+  return normalized.length > 500 ? `${normalized.slice(0, 497)}...` : normalized;
+}
 async function readRequestBody(req) {
   let body = "";
   req.setEncoding("utf8");
@@ -1471,14 +1535,6 @@ async function readRequestBody(req) {
 function messageSeq(message) {
   return Number(message.seq ?? 0);
 }
-function boundaryBefore(messages) {
-  let minSeq = Number.POSITIVE_INFINITY;
-  for (const message of messages) {
-    const seq = Math.floor(messageSeq(message));
-    if (Number.isFinite(seq) && seq > 0) minSeq = Math.min(minSeq, seq);
-  }
-  return Number.isFinite(minSeq) ? Math.max(0, minSeq - 1) : void 0;
-}
 function maxMessageSeq(messages) {
   let maxSeq = 0;
   for (const message of messages) {
@@ -1487,6 +1543,117 @@ function maxMessageSeq(messages) {
   }
   return maxSeq > 0 ? maxSeq : void 0;
 }
+function sortBySeq(messages) {
+  return [...messages].sort((a, b) => messageSeq(a) - messageSeq(b));
+}
+function latestVisibleMessages(messages, limit) {
+  const sorted = sortBySeq(messages);
+  return sorted.slice(Math.max(0, sorted.length - limit));
+}
+function parseAgentApiEventsQuery(target) {
+  const limit = Math.min(Math.max(Number(target.searchParams.get("limit")) || 50, 1), 200);
+  const sinceRaw = target.searchParams.get("since")?.trim() ?? "";
+  if (!sinceRaw) return { limit, sinceSeq: null, sinceCursorKind: null };
+  if (sinceRaw === "latest") return { limit, sinceSeq: null, sinceCursorKind: "latest" };
+  const parsed = Number(sinceRaw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return {
+      limit,
+      sinceSeq: null,
+      sinceCursorKind: null,
+      error: {
+        error: "since must be a non-negative integer (messageSeq) or 'latest'",
+        code: "since_invalid"
+      }
+    };
+  }
+  return { limit, sinceSeq: Math.floor(parsed), sinceCursorKind: "seq" };
+}
+function localAgentApiEventsResponse(registration, target) {
+  const coordinator = registration.inboxCoordinator;
+  if (!coordinator) return void 0;
+  const pending = coordinator.getAllPendingMessages?.() ?? [];
+  const parsedQuery = parseAgentApiEventsQuery(target);
+  if (parsedQuery.error && pending.length > 0) {
+    return { status: 400, body: parsedQuery.error };
+  }
+  if (pending.length === 0) return void 0;
+  const normalized = sortBySeq(normalizeVisibleMessages(pending));
+  const filtered = parsedQuery.sinceSeq !== null ? normalized.filter((message) => {
+    const seq = messageSeq(message);
+    return Number.isFinite(seq) && seq > parsedQuery.sinceSeq;
+  }) : normalized;
+  const events = filtered.slice(0, parsedQuery.limit);
+  const hasMore = filtered.length > events.length;
+  const newestEvent = events[events.length - 1];
+  const lastSeenMsgId = newestEvent?.message_id ?? newestEvent?.id ?? null;
+  const lastSeenSeq = newestEvent?.seq ?? parsedQuery.sinceSeq;
+  if (events.length > 0) {
+    coordinator.consumeVisibleMessages({ messages: events, source: "agent_api_events" });
+  }
+  coordinator.recordDrainOutcome?.({
+    source: "daemon_pending",
+    sinceCursorKind: parsedQuery.sinceCursorKind,
+    notifiedCount: pending.length,
+    drainedCount: events.length,
+    hasMore
+  });
+  return {
+    status: 200,
+    body: {
+      events,
+      last_seen_msgId: lastSeenMsgId,
+      last_seen_seq: lastSeenSeq,
+      reply_target: null,
+      pending_notice_ids: [],
+      wake_reason: null,
+      has_more: hasMore
+    }
+  };
+}
+function heldAvailableActions(action) {
+  return action === "send" ? ["check_messages", "send_draft", "send_anyway"] : ["check_messages", "retry_action"];
+}
+function localHeldResponse(input) {
+  if (input.messages.length === 0) return void 0;
+  const normalized = sortBySeq(normalizeVisibleMessages(input.messages, input.target));
+  const heldMessages = latestVisibleMessages(normalized, LOCAL_HELD_CONTEXT_LIMIT);
+  const omittedMessageCount = Math.max(0, normalized.length - heldMessages.length);
+  const seenUpToSeq = maxMessageSeq(normalized);
+  if (seenUpToSeq === void 0) return void 0;
+  input.coordinator.consumeVisibleMessages({
+    target: input.target,
+    messages: heldMessages,
+    boundarySeq: seenUpToSeq,
+    source: input.source
+  });
+  const response = {
+    state: "held",
+    outcome: "held",
+    subtype: "freshness",
+    reason: "newer_messages_available",
+    available_actions: heldAvailableActions(input.action),
+    heldMessages,
+    newMessageCount: normalized.length,
+    shownMessageCount: heldMessages.length,
+    omittedMessageCount
+  };
+  response.seenUpToSeq = seenUpToSeq;
+  return response;
+}
+function recordFreshnessDecision(coordinator, decision) {
+  coordinator?.recordFreshnessDecision?.(decision);
+}
+function agentApiSideEffectAction(pathname) {
+  if (pathname === "/internal/agent-api/send") return "send";
+  if (pathname === "/internal/agent-api/tasks/claim") return "task_claim";
+  if (pathname === "/internal/agent-api/tasks/update-status") return "task_update";
+  return void 0;
+}
+function sideEffectTarget(action, body) {
+  const field = action === "send" ? body.target : body.channel;
+  return typeof field === "string" && field.length > 0 ? field : void 0;
+}
 function parseTargetFields(target) {
   if (target.startsWith("dm:@")) {
     const rest = target.slice("dm:@".length);
@@ -1543,42 +1710,98 @@ async function loadRecentTargetMessages(registration, headers, target) {
   const parsed = await res.json().catch(() => null);
   return Array.isArray(parsed?.messages) ? normalizeVisibleMessages(parsed.messages, target) : [];
 }
-async function prepareAgentApiSendForward(registration, headers, rawBody) {
+async function prepareAgentApiSideEffectForward(registration, headers, rawBody, action) {
   let body;
   try {
     body = rawBody ? JSON.parse(rawBody) : {};
   } catch {
     return { bodyText: rawBody };
   }
-  const target = typeof body.target === "string" ? body.target : void 0;
+  const target = sideEffectTarget(action, body);
   const coordinator = registration.inboxCoordinator;
-  if (!target || !coordinator || body.continueAnyway === true) {
+  if (!target || !coordinator) {
+    return { bodyText: JSON.stringify(body), target };
+  }
+  if (action === "send" && body.continueAnyway === true) {
+    recordFreshnessDecision(coordinator, {
+      action,
+      decision: "bypass",
+      target,
+      inboxTrustState: "trusted",
+      reason: "continue_anyway"
+    });
     return { bodyText: JSON.stringify(body), target };
   }
   const pending = coordinator.getPendingMessages(target);
   if (pending.length > 0) {
-    const staleBoundary = boundaryBefore(pending);
-    if (staleBoundary !== void 0) {
-      body.seenUpToSeq = staleBoundary;
+    const localResponse = localHeldResponse({
+      action,
+      target,
+      messages: pending,
+      coordinator,
+      source: "side_effect_preflight_context"
+    });
+    if (localResponse) {
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "local_hold",
+        target,
+        inboxTrustState: "trusted",
+        reason: "exact_target_pending",
+        pendingCount: pending.length,
+        pendingMaxSeq: maxMessageSeq(pending),
+        modelSeenSeq: coordinator.getBoundary(target),
+        heldMessageCount: typeof localResponse.shownMessageCount === "number" ? localResponse.shownMessageCount : void 0,
+        omittedMessageCount: typeof localResponse.omittedMessageCount === "number" ? localResponse.omittedMessageCount : void 0
+      });
     }
-    return { bodyText: JSON.stringify(body), target };
+    return {
+      bodyText: JSON.stringify(body),
+      target,
+      localResponse
+    };
   }
   const existingBoundary = typeof body.seenUpToSeq === "number" && Number.isFinite(body.seenUpToSeq) ? Math.max(0, Math.floor(body.seenUpToSeq)) : void 0;
   const loadedBoundary = coordinator.getBoundary(target);
   const boundary = Math.max(existingBoundary ?? 0, loadedBoundary ?? 0);
   if (boundary > 0) {
-    body.seenUpToSeq = boundary;
+    if (action === "send") body.seenUpToSeq = boundary;
+    recordFreshnessDecision(coordinator, {
+      action,
+      decision: "forward",
+      target,
+      inboxTrustState: "trusted",
+      reason: "model_seen_boundary",
+      pendingCount: 0,
+      modelSeenSeq: boundary
+    });
     return { bodyText: JSON.stringify(body), target };
   }
   const recent = await loadRecentTargetMessages(registration, headers, target);
   if (recent.length > 0) {
     const seenUpToSeq = maxMessageSeq(recent);
-    coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "send_preflight_context" });
+    coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "side_effect_preflight_context" });
+    recordFreshnessDecision(coordinator, {
+      action,
+      decision: "syncing_hold",
+      target,
+      inboxTrustState: "untrusted",
+      reason: "target_first_touch_recent_context",
+      pendingCount: 0,
+      pendingMaxSeq: seenUpToSeq,
+      modelSeenSeq: 0,
+      heldMessageCount: recent.length,
+      omittedMessageCount: 0
+    });
     return {
       bodyText: JSON.stringify(body),
       target,
       localResponse: {
         state: "held",
+        outcome: "held",
+        subtype: "freshness",
+        reason: "newer_messages_available",
+        available_actions: heldAvailableActions(action),
         seenUpToSeq,
         heldMessages: recent,
         newMessageCount: recent.length,
@@ -1587,6 +1810,15 @@ async function prepareAgentApiSendForward(registration, headers, rawBody) {
       }
     };
   }
+  recordFreshnessDecision(coordinator, {
+    action,
+    decision: "forward",
+    target,
+    inboxTrustState: "trusted",
+    reason: "no_exact_target_pending_or_recent_context",
+    pendingCount: 0,
+    modelSeenSeq: 0
+  });
   return { bodyText: JSON.stringify(body), target };
 }
 function shouldBufferJsonResponse(upstream, pathname, registration) {
@@ -1613,8 +1845,28 @@ 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) {
+      coordinator.consumeVisibleMessages({
+        target: sendTarget,
+        messages: normalizeVisibleMessages([{ seq: messageSeq2, id: parsed.messageId }], sendTarget),
+        boundarySeq: messageSeq2,
+        source: "agent_api_send_commit"
+      });
+    }
+    return;
+  }
   if (targetUrl.pathname === "/internal/agent-api/events" && Array.isArray(parsed.events)) {
-    coordinator.consumeVisibleMessages({ messages: normalizeVisibleMessages(parsed.events), source: "agent_api_events" });
+    const messages = normalizeVisibleMessages(parsed.events);
+    coordinator.consumeVisibleMessages({ messages, source: "agent_api_events" });
+    coordinator.recordDrainOutcome?.({
+      source: "server_events",
+      sinceCursorKind: parseAgentApiEventsQuery(targetUrl).sinceCursorKind,
+      notifiedCount: 0,
+      drainedCount: messages.length,
+      hasMore: Boolean(parsed.has_more)
+    });
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/history" && Array.isArray(parsed.messages)) {
@@ -1733,7 +1985,7 @@ ${cmdCredentialLine}"${process.execPath}" "${ctx.slockCliPath}" %*\r
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   delete spawnEnv.SLOCK_AGENT_CREDENTIAL_KEY;
   delete spawnEnv.SLOCK_AGENT_CREDENTIAL_KEY_FILE;
   delete spawnEnv.SLOCK_AGENT_PROXY_URL;
@@ -1780,7 +2032,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   if (platform === "win32") {
     return resolveCommandOnWindows(command, env, execFileSyncFn);
@@ -1805,7 +2057,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -2159,8 +2411,7 @@ var ClaudeDriver = class {
         "- Runtime Profile migration completion is the only exception to CLI-only operation: when a migration notice tells you to acknowledge with `runtime_profile_migration_done`, call the `mcp__chat__runtime_profile_migration_done` tool with the exact `migration_key`; do not use `slock` CLI or reply in chat as the acknowledgment."
       ],
       postStartupNotes: [
-        "**Claude runtime note:** Slock preserves Claude Code same-turn steering through a gated stream-json delivery path. Busy messages are buffered and delivered at Claude-observed safe boundaries; if no earlier safe boundary is available, they are delivered after the current turn ends.",
-        "For long tool runs, you can also use `slock message check` at natural breakpoints to pull pending messages explicitly."
+        "**Claude runtime note:** While you are busy, Slock batches inbox-count notifications instead of injecting message content. Use `slock message check` at natural breakpoints to pull the pending messages before side-effect actions that depend on current context."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -2654,7 +2905,7 @@ var CodexDriver = class {
       toolPrefix: "",
       extraCriticalRules: [],
       postStartupNotes: [
-        "**IMPORTANT**: Your process stays alive across turns. New messages may be delivered directly into the current thread while you are working."
+        "**IMPORTANT**: Your process stays alive across turns. While you are working, Slock may write batched inbox-count notifications into the current turn; call `slock message check` at natural breakpoints to read the pending messages."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -3102,7 +3353,7 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
-    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+    env: scrubDaemonChildEnv({ ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
     timeout: 5e3
   });
@@ -3149,7 +3400,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync6;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -3323,13 +3574,16 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os4 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 {
@@ -3338,6 +3592,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os4.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : 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 ?? os4.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = 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",
@@ -3361,7 +3682,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 = "";
@@ -3415,6 +3754,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -3423,14 +3763,15 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
     if (ctx.config.model && ctx.config.model !== "default") {
       args.push("--model", ctx.config.model);
     }
     const spawnEnv = prepareCliTransport(ctx, { NO_COLOR: "1" }).spawnEnv;
-    const launch = resolveKimiSpawn(args);
-    const proc = spawn6(launch.command, launch.args, {
+    const spawnTarget = resolveKimiSpawn(args);
+    const proc = spawn6(spawnTarget.command, spawnTarget.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -3438,7 +3779,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",
@@ -3554,14 +3895,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path9.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os4.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -3582,7 +3918,7 @@ function detectKimiModels(home = os4.homedir()) {
 
 // src/drivers/opencode.ts
 import { spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
 import os5 from "os";
 import path10 from "path";
 var CHAT_MCP_SERVER_NAME = "chat";
@@ -3820,11 +4156,14 @@ function detectOpenCodeModels(home = os5.homedir(), runCommand = runOpenCodeMode
   if (commandResult.error || commandResult.status !== 0) return null;
   return parseOpenCodeModelsOutput(commandResult.stdout);
 }
-function runOpenCodeModelsCommand(home) {
-  const result = spawnSync2("opencode", ["models"], {
-    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+function runOpenCodeModelsCommand(home, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
+  const result = spawnSyncFn("opencode", ["models"], {
+    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
-    timeout: 5e3
+    timeout: 5e3,
+    shell: platform === "win32"
   });
   return {
     status: result.status,
@@ -3832,6 +4171,102 @@ function runOpenCodeModelsCommand(home) {
     error: result.error
   };
 }
+function isWindowsCommandShim(commandPath) {
+  const ext = path10.win32.extname(commandPath).toLowerCase();
+  return ext === ".cmd" || ext === ".bat";
+}
+function opencodePackageEntryCandidates(packageRoot) {
+  const winPath = path10.win32;
+  return [
+    winPath.join(packageRoot, "bin", "opencode.exe"),
+    winPath.join(packageRoot, "bin", "opencode.js"),
+    winPath.join(packageRoot, "bin", "opencode.mjs"),
+    winPath.join(packageRoot, "dist", "index.js")
+  ];
+}
+function openCodeSpecForEntry(entry, commandArgs) {
+  if (path10.win32.extname(entry).toLowerCase() === ".exe") {
+    return { command: entry, args: commandArgs, shell: false };
+  }
+  return { command: process.execPath, args: [entry, ...commandArgs], shell: false };
+}
+function resolveWindowsOpenCodePackageEntry(commandPath, deps = {}) {
+  const existsSyncFn = deps.existsSyncFn ?? existsSync8;
+  const execFileSyncFn = deps.execFileSyncFn;
+  const env = deps.env ?? process.env;
+  const winPath = path10.win32;
+  const candidates = [];
+  if (execFileSyncFn) {
+    try {
+      const globalRoot = String(execFileSyncFn("npm", ["root", "-g"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env
+      })).trim();
+      if (globalRoot) {
+        candidates.push(...opencodePackageEntryCandidates(winPath.join(globalRoot, "opencode-ai")));
+      }
+    } catch {
+    }
+  }
+  if (commandPath) {
+    const commandDir = winPath.dirname(commandPath);
+    candidates.push(...opencodePackageEntryCandidates(winPath.join(commandDir, "node_modules", "opencode-ai")));
+    candidates.push(...extractWindowsShimTargets(commandPath, deps));
+  }
+  for (const candidate of candidates) {
+    if (existsSyncFn(candidate)) return candidate;
+  }
+  return null;
+}
+function extractWindowsShimTargets(commandPath, deps = {}) {
+  if (!isWindowsCommandShim(commandPath)) return [];
+  const readFileSyncFn = deps.readFileSyncFn ?? readFileSync4;
+  const commandDir = path10.win32.dirname(commandPath);
+  let raw;
+  try {
+    raw = String(readFileSyncFn(commandPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  const dp0Pattern = /%~dp0\\?([^"\r\n]*?opencode\.(?:exe|js|mjs|cjs))/gi;
+  for (const match of raw.matchAll(dp0Pattern)) {
+    const relative = match[1]?.replace(/^\\+/, "");
+    if (relative) candidates.push(path10.win32.normalize(path10.win32.join(commandDir, relative)));
+  }
+  return candidates;
+}
+function resolveOpenCodeSpawn(commandArgs, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
+    return {
+      command: resolveCommandOnPath("opencode", deps) ?? "opencode",
+      args: commandArgs,
+      shell: false
+    };
+  }
+  const command = resolveCommandOnPath("opencode", deps);
+  if (command && path10.win32.extname(command).toLowerCase() === ".exe") {
+    return { command, args: commandArgs, shell: false };
+  }
+  const packageEntry = resolveWindowsOpenCodePackageEntry(command, deps);
+  if (packageEntry) return openCodeSpecForEntry(packageEntry, commandArgs);
+  if (command && !isWindowsCommandShim(command)) {
+    return { command, args: commandArgs, shell: false };
+  }
+  throw new Error(
+    "Cannot resolve OpenCode CLI entry point on Windows without cmd.exe. Install the native OpenCode executable or install opencode-ai globally so Slock can launch node_modules/opencode-ai/bin/opencode.exe directly."
+  );
+}
+function readOpenCodeVersion(deps = {}) {
+  try {
+    const launch = resolveOpenCodeSpawn([], deps);
+    return readCommandVersion(launch.command, launch.args, deps);
+  } catch {
+    return null;
+  }
+}
 function isSystemFirstMessageTask(message) {
   return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX);
 }
@@ -3874,7 +4309,7 @@ var OpenCodeDriver = class {
           model: modelId
         }
       };
-      const version = readCommandVersion("opencode");
+      const version = readOpenCodeVersion();
       const launch = buildOpenCodeLaunchOptions(launchCtx, opts?.home, version);
       return {
         args: launch.args,
@@ -3895,8 +4330,13 @@ var OpenCodeDriver = class {
   sessionId = null;
   sessionAnnounced = false;
   probe() {
-    if (!resolveCommandOnPath("opencode")) return { available: false };
-    const version = readCommandVersion("opencode") || void 0;
+    let version;
+    try {
+      const launch = resolveOpenCodeSpawn([]);
+      version = readCommandVersion(launch.command, launch.args);
+    } catch {
+      return { available: false };
+    }
     const unsupportedMessage = unsupportedOpenCodeVersionMessage(version);
     if (unsupportedMessage) {
       return {
@@ -3904,7 +4344,7 @@ var OpenCodeDriver = class {
         version: `${version} (requires >= ${MIN_SUPPORTED_OPENCODE_VERSION})`
       };
     }
-    return { available: true, version };
+    return { available: true, version: version ?? void 0 };
   }
   async detectModels() {
     return detectOpenCodeModels();
@@ -3912,17 +4352,18 @@ var OpenCodeDriver = class {
   spawn(ctx) {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
-    const version = readCommandVersion("opencode");
+    const version = readOpenCodeVersion();
     const unsupportedMessage = unsupportedOpenCodeVersionMessage(version);
     if (unsupportedMessage) {
       throw new Error(unsupportedMessage);
     }
     const launch = buildOpenCodeLaunchOptions(ctx, os5.homedir(), version);
-    const proc = spawn7("opencode", launch.args, {
+    const spawnSpec = resolveOpenCodeSpawn(launch.args);
+    const proc = spawn7(spawnSpec.command, spawnSpec.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: launch.env,
-      shell: process.platform === "win32"
+      shell: spawnSpec.shell
     });
     proc.stdin?.end();
     return { process: proc };
@@ -3980,6 +4421,297 @@ var OpenCodeDriver = class {
   }
 };
 
+// src/drivers/pi.ts
+import { spawn as spawn8 } from "child_process";
+import { existsSync as existsSync9, 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 (existsSync9(sourceSibling)) return sourceSibling;
+  const bundledEntry = path11.join(moduleDir, "drivers", "piSdkRunner.js");
+  if (existsSync9(bundledEntry)) return bundledEntry;
+  return path11.join(moduleDir, "piSdkRunner.js");
+}
+function buildPiSdkNodeArgs(runnerPath = resolvePiSdkRunnerPath()) {
+  if (runnerPath.endsWith(".ts")) {
+    return [...process.execArgv, runnerPath];
+  }
+  return [runnerPath];
+}
+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 = 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: (modelId, ctx) => {
+      if (!ctx) return modelId && modelId !== "default" ? { args: ["--model", modelId] } : { args: [] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = 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;
+  }
+  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 = buildPiLaunchOptions(ctx);
+    const proc = spawn8(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(),
@@ -3988,7 +4720,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];
@@ -4001,7 +4734,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("..");
 }
@@ -4009,7 +4742,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 {
@@ -4058,7 +4791,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);
@@ -4077,7 +4810,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 {
@@ -4160,6 +4893,7 @@ function classifyRuntimeError(message, httpStatus) {
     return "ProviderApiError";
   }
   if (/\btimeout|timed out\b/i.test(message)) return "TimeoutError";
+  if (/stream closed before response\.completed|error decoding response body/i.test(message)) return "ProviderStreamError";
   if (/\brate.?limit|too many requests\b/i.test(message)) return "RateLimitError";
   if (/\bnot found\b/i.test(message)) return "NotFoundError";
   return "RuntimeError";
@@ -4334,12 +5068,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;
@@ -4352,10 +5086,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,
@@ -4374,7 +5108,7 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   }
 }
 function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir) {
-  const directPath = path12.isAbsolute(sessionId) ? sessionId : null;
+  const directPath = path13.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
       if (statSync2(directPath).isFile()) {
@@ -4383,7 +5117,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), f
     } catch {
     }
   }
-  const resolvedPath = runtime === "claude" ? findSessionJsonl(path12.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path12.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
+  const resolvedPath = runtime === "claude" ? findSessionJsonl(path13.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path13.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
   if (!resolvedPath && fallbackDir) {
     const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
     if (fallback) return fallback;
@@ -5034,12 +5768,21 @@ function classifyTerminalFailure(ap) {
   ].filter((value) => !!value);
   for (const text of candidates) {
     const lower = text.toLowerCase();
-    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found")) {
+    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found") || isProviderStreamFailureText(text)) {
       return text;
     }
   }
   return null;
 }
+function isProviderStreamFailureText(text) {
+  return /stream closed before response\.completed|error decoding response body/i.test(text);
+}
+function isCodexProviderReconnectLog(text) {
+  return /Reconnecting\.\.\.\s*\d+\s*\/\s*\d+/i.test(text);
+}
+function isCodexBenignTransportLog(text) {
+  return /Falling back from WebSockets/i.test(text);
+}
 function hasDirectStdinRecoveryEvidence(ap) {
   const candidates = [
     ap.lastRuntimeError,
@@ -5234,10 +5977,10 @@ function getMessageDeliveryText(driver) {
 function getBusyDeliveryNote(driver) {
   if (!driver.supportsStdinNotification) return "";
   if (driver.busyDeliveryMode === "direct") {
-    return "\n\nNote: While you are busy, new messages may be delivered directly into your active turn. Handle them when appropriate and keep working.";
+    return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn. Call check_messages to read the pending messages before context-sensitive side effects.";
   }
   if (driver.busyDeliveryMode === "gated") {
-    return "\n\nNote: While you are busy, new messages may be delivered at runtime-observed safe boundaries in your active turn. If no safe boundary is available, they will be delivered after the current turn ends.";
+    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.";
 }
@@ -5313,13 +6056,16 @@ var AgentProcessManager = class _AgentProcessManager {
   getVisibleBoundary(agentId, target) {
     return this.agentVisibleBoundaries.get(agentId)?.get(target);
   }
-  pendingVisibleMessages(agentId, target) {
-    const collect = (messages) => (messages ?? []).filter((message) => formatMessageTarget(message) === target && typeof message.seq === "number" && message.seq > 0);
+  allPendingVisibleMessages(agentId) {
+    const collect = (messages) => (messages ?? []).filter((message) => typeof message.seq === "number" && message.seq > 0);
     return [
       ...collect(this.agents.get(agentId)?.inbox),
       ...collect(this.startingInboxes.get(agentId))
     ];
   }
+  pendingVisibleMessages(agentId, target) {
+    return this.allPendingVisibleMessages(agentId).filter((message) => formatMessageTarget(message) === target);
+  }
   /**
    * Single-inbox consume point for messages that have been rendered into the
    * agent-visible input surface. Daemon pending inbox is only a runner cache:
@@ -5390,8 +6136,71 @@ var AgentProcessManager = class _AgentProcessManager {
     return {
       getBoundary: (target) => this.getVisibleBoundary(agentId, target),
       getPendingMessages: (target) => this.pendingVisibleMessages(agentId, target),
-      consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input)
+      getAllPendingMessages: () => this.allPendingVisibleMessages(agentId),
+      consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input),
+      recordDrainOutcome: (input) => {
+        this.recordDaemonTrace("daemon.agent.drain.outcome", {
+          agentId,
+          source: input.source,
+          since_cursor_kind: input.sinceCursorKind ?? void 0,
+          notified_count: input.notifiedCount,
+          drained_count: input.drainedCount,
+          has_more: input.hasMore
+        });
+      },
+      recordProxyFailure: (input) => this.recordAgentProxyFailure(agentId, input),
+      recordFreshnessDecision: (input) => {
+        this.recordDaemonTrace("daemon.agent.inbox.freshness_decision", {
+          agentId,
+          action: input.action,
+          decision: input.decision,
+          target: input.target,
+          inbox_trust_state: input.inboxTrustState,
+          reason: input.reason,
+          pending_count: input.pendingCount,
+          pending_max_seq: input.pendingMaxSeq,
+          model_seen_seq: input.modelSeenSeq,
+          held_message_count: input.heldMessageCount,
+          omitted_message_count: input.omittedMessageCount
+        });
+        this.recordFreshnessDecisionActivity(agentId, input);
+      }
+    };
+  }
+  recordAgentProxyFailure(agentId, input) {
+    this.recordDaemonTrace("daemon.agent.proxy.failure", {
+      agentId,
+      method: input.method,
+      path: input.pathname,
+      query_keys: input.queryKeys,
+      error_name: input.errorName,
+      error_message: input.errorMessage
+    }, "error");
+  }
+  recordFreshnessDecisionActivity(agentId, input) {
+    if (input.decision !== "local_hold" && input.decision !== "syncing_hold") return;
+    const ap = this.agents.get(agentId);
+    const messageCount = input.pendingCount ?? input.heldMessageCount ?? 0;
+    const title = input.action === "send" ? "Send held by freshness check" : input.action === "task_claim" ? "Task claim held by freshness check" : "Task update held by freshness check";
+    const entry = {
+      kind: "slock_action",
+      title,
+      text: [
+        input.target ? `target: ${input.target}` : null,
+        `new messages: ${messageCount} newer message${messageCount === 1 ? "" : "s"}`,
+        `decision: ${input.decision === "syncing_hold" ? "syncing hold" : "local hold"}; review the newer context before retrying`
+      ].filter((line) => Boolean(line)).join("\n")
     };
+    if (ap) ap.activityClientSeq += 1;
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity: ap?.lastActivity || "online",
+      detail: ap?.lastActivityDetail || "",
+      entries: [entry],
+      launchId: ap?.launchId || void 0,
+      clientSeq: ap?.activityClientSeq
+    });
   }
   recordDaemonTrace(name, attrs, status = "ok", parentTraceparent) {
     const span = this.tracer.startSpan(name, {
@@ -5617,26 +6426,26 @@ var AgentProcessManager = class _AgentProcessManager {
     this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path12.join(this.dataDir, agentId);
+      const agentDataDir = path13.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       const runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
-      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);
           }
         }
@@ -5825,8 +6634,24 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       proc.stderr?.on("data", (chunk) => {
         const text = chunk.toString().trim();
         if (!text) return;
-        if (/Reconnecting\.\.\.|Falling back from WebSockets/i.test(text)) return;
         const current = this.agents.get(agentId);
+        if (driver.id === "codex" && isCodexProviderReconnectLog(text)) {
+          if (current) {
+            current.recentStderr = pushRecentStderr(current.recentStderr, text);
+          }
+          this.recordDaemonTrace("daemon.agent.provider_reconnect", {
+            agentId,
+            launchId: current?.launchId || void 0,
+            runtime: config.runtime,
+            model: config.model
+          });
+          this.broadcastActivity(agentId, "working", "Codex reconnecting to provider\u2026", [
+            { kind: "text", text }
+          ]);
+          logger.info(`[Agent ${agentId} stderr]: ${text}`);
+          return;
+        }
+        if (driver.id === "codex" && isCodexBenignTransportLog(text)) return;
         if (current) {
           current.recentStderr = pushRecentStderr(current.recentStderr, text);
         }
@@ -5970,10 +6795,20 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             }
             this.broadcastActivity(agentId, "online", "Process idle");
           } else {
-            this.idleAgentConfigs.delete(agentId);
             const reason = formatCrashReason(finalCode, finalSignal, ap);
-            logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
-            this.sendAgentStatus(agentId, "inactive", ap.launchId);
+            if (terminalFailureDetail && isProviderStreamFailureText(terminalFailureDetail)) {
+              this.idleAgentConfigs.set(agentId, {
+                config: { ...ap.config, sessionId: ap.sessionId },
+                sessionId: ap.sessionId,
+                launchId: ap.launchId
+              });
+              logger.warn(`[Agent ${agentId}] Recoverable provider stream failure (${reason}) \u2014 keeping agent wakeable`);
+              this.sendAgentStatus(agentId, "active", ap.launchId);
+            } else {
+              this.idleAgentConfigs.delete(agentId);
+              logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
+              this.sendAgentStatus(agentId, "inactive", ap.launchId);
+            }
             if (terminalFailureDetail) {
               this.broadcastActivity(
                 agentId,
@@ -6446,6 +7281,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     if (ap.driver.busyDeliveryMode === "gated") {
       ap.pendingNotificationCount++;
+      if (!ap.notificationTimer) {
+        ap.notificationTimer = setTimeout(() => {
+          this.sendStdinNotification(agentId);
+        }, 3e3);
+      }
       this.recordGatedSteeringEvent(agentId, ap, "buffer", {
         reason: "busy_message",
         pendingMessages: ap.inbox.length
@@ -6458,7 +7298,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         session_id_present: true,
         launchId: ap.launchId || void 0,
         inbox_count: ap.inbox.length,
-        pending_notification_count: ap.pendingNotificationCount
+        pending_notification_count: ap.pendingNotificationCount,
+        notification_timer_present: Boolean(ap.notificationTimer)
       }));
       return true;
     }
@@ -6481,7 +7322,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})`);
@@ -6518,7 +7359,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,
@@ -6775,7 +7616,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 {
@@ -6783,8 +7624,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;
@@ -6792,14 +7633,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");
@@ -6834,13 +7675,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 = os6.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();
@@ -6869,7 +7710,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);
@@ -6880,7 +7721,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);
@@ -7283,11 +8124,17 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (reason !== "turn_end") {
       if (ap.gatedSteering.toolBoundaryFlushDisabled) return false;
       if (ap.gatedSteering.compacting || ap.gatedSteering.outstandingToolUses > 0) return false;
+      this.recordGatedSteeringEvent(agentId, ap, "notify", { reason, pendingMessages: ap.inbox.length });
+      return this.sendStdinNotification(agentId);
     }
     const pendingMessages = ap.inbox.length;
     const pendingNotificationCount = ap.pendingNotificationCount;
     const nextMessages = ap.inbox.splice(0, ap.inbox.length);
     ap.pendingNotificationCount = 0;
+    if (ap.notificationTimer) {
+      clearTimeout(ap.notificationTimer);
+      ap.notificationTimer = null;
+    }
     ap.gatedSteering.lastFlushReason = reason;
     if (reason !== "turn_end") {
       ap.gatedSteering.inFlightBatch = {
@@ -7315,28 +8162,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   flushCompactionBoundaryMessages(agentId, ap) {
     if (!ap.sessionId || !ap.driver.supportsStdinNotification || ap.inbox.length === 0) return false;
-    if (ap.driver.busyDeliveryMode === "gated") {
-      return this.tryFlushGatedSteering(agentId, ap, "compaction_finished");
-    }
-    if (ap.driver.busyDeliveryMode === "direct") {
-      const pendingMessages = ap.inbox.length;
-      const pendingNotificationCount = ap.pendingNotificationCount;
-      const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-      ap.pendingNotificationCount = 0;
-      if (ap.notificationTimer) {
-        clearTimeout(ap.notificationTimer);
-        ap.notificationTimer = null;
-      }
-      this.recordRuntimeTraceEvent(agentId, ap, "runtime.compaction_boundary.flush", {
-        mode: "direct",
-        messageCount: nextMessages.length
-      });
-      if (this.deliverMessagesViaStdin(agentId, ap, nextMessages, "busy")) {
-        return true;
-      }
-      ap.pendingNotificationCount += pendingNotificationCount || pendingMessages;
-      return false;
-    }
     if (ap.pendingNotificationCount > 0) {
       if (ap.notificationTimer) {
         clearTimeout(ap.notificationTimer);
@@ -7555,6 +8380,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
             const nextMessages = ap.inbox.splice(0, ap.inbox.length);
             ap.pendingNotificationCount = 0;
+            if (ap.notificationTimer) {
+              clearTimeout(ap.notificationTimer);
+              ap.notificationTimer = null;
+            }
             if (ap.driver.busyDeliveryMode === "gated") {
               ap.gatedSteering.lastFlushReason = "turn_end";
               this.recordGatedSteeringEvent(agentId, ap, "flush", {
@@ -7698,13 +8527,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   /** Send a batched notification to the agent via stdin about pending messages */
   sendStdinNotification(agentId) {
     const ap = this.agents.get(agentId);
-    if (!ap) return;
+    if (!ap) return false;
     const count = ap.pendingNotificationCount;
     ap.pendingNotificationCount = 0;
-    ap.notificationTimer = null;
-    if (count === 0) return;
-    if (ap.isIdle) return;
-    if (!ap.sessionId) return;
+    if (ap.notificationTimer) {
+      clearTimeout(ap.notificationTimer);
+      ap.notificationTimer = null;
+    }
+    if (count === 0) return false;
+    if (ap.isIdle) return false;
+    if (!ap.sessionId) return false;
     if (ap.gatedSteering.compacting) {
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.compaction_boundary.delivery_suppressed", {
         pendingNotificationCount: count,
@@ -7715,30 +8547,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       logger.info(
         `[Agent ${agentId}] Suppressing stdin delivery until context compaction finishes; pending=${ap.inbox.length}`
       );
-      return;
-    }
-    if (ap.driver.busyDeliveryMode === "gated") {
-      this.recordGatedSteeringEvent(agentId, ap, "suppress", {
-        reason: "timer_notification_not_safe_boundary",
-        pendingNotificationCount: count
-      });
-      ap.pendingNotificationCount += count;
-      logger.info(
-        `[Agent ${agentId}] Suppressing raw busy stdin notification until Claude gated steering boundary; pending=${ap.inbox.length}`
-      );
-      return;
-    }
-    if (ap.driver.busyDeliveryMode === "direct" && ap.inbox.length > 0) {
-      const queuedMessages = ap.inbox.splice(0, ap.inbox.length);
-      console.log(`[Agent ${agentId}] Delivering queued message via stdin while busy`);
-      if (this.deliverMessagesViaStdin(agentId, ap, queuedMessages, "busy")) {
-        return;
-      }
-      ap.pendingNotificationCount += count;
-      return;
+      return false;
     }
-    const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call check_messages to read ${count > 1 ? "them" : "it"} when you're ready.]`;
-    logger.info(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
+    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.]`;
+    logger.info(`[Agent ${agentId}] Sending stdin notification: ${inboxCount} pending inbox message(s)`);
     const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     if (encoded) {
       ap.process.stdin?.write(encoded + "\n");
@@ -7750,9 +8564,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         outcome: "written",
         mode: "busy",
         pending_notification_count: count,
+        inbox_count: inboxCount,
         session_id_present: true
       });
+      return true;
     } else {
+      ap.pendingNotificationCount += count;
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -7761,8 +8578,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         outcome: "encode_failed",
         mode: "busy",
         pending_notification_count: count,
+        inbox_count: inboxCount,
         session_id_present: true
       }, "error");
+      return false;
     }
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
@@ -7868,8 +8687,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);
@@ -7998,10 +8817,12 @@ var DaemonConnection = class {
         messageKind = msg.type;
         this.markInbound(messageKind);
         this.resetWatchdog();
-        this.trace("daemon.connection.inbound_received", {
-          message_type: messageKind,
-          last_inbound_age_ms_bucket: "0"
-        });
+        if (messageKind !== "ping") {
+          this.trace("daemon.connection.inbound_received", {
+            message_type: messageKind,
+            last_inbound_age_ms_bucket: "0"
+          });
+        }
         this.options.onMessage(msg);
       } catch (err) {
         this.markInbound("invalid_json");
@@ -8172,9 +8993,9 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
 import os7 from "os";
-import path13 from "path";
+import path14 from "path";
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -8196,7 +9017,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 {
@@ -8226,13 +9047,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 = randomUUID2();
-  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,
@@ -8242,7 +9063,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 });
@@ -8279,8 +9100,8 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
-import path14 from "path";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync4, 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;
@@ -8316,7 +9137,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));
@@ -8342,15 +9163,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 = statSync4(this.currentFile).size;
       this.currentFileOpenedAtMs = nowMs;
       this.pruneOldFiles();
@@ -8361,7 +9182,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 });
     }
   }
 };
@@ -8448,11 +9269,11 @@ function isDiagnosticErrorAttr(key) {
 import { createHash as createHash5, randomUUID as randomUUID3 } 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 {
@@ -8671,7 +9492,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);
@@ -8683,8 +9504,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);
@@ -8758,8 +9579,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 {
@@ -8771,9 +9592,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)}
@@ -8795,7 +9616,7 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels"];
 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;
@@ -8831,9 +9652,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];
@@ -8850,23 +9671,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;
   }
@@ -9045,7 +9866,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() {
@@ -9547,6 +10368,8 @@ var DaemonCore = class {
 };
 
 export {
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,