@slock-ai/daemon 0.55.6 → 0.56.0

package/dist/{chunk-HAZSZDOZ.js → chunk-4H5XFLYA.js}

@@ -360,6 +360,40 @@ var NoopActiveSpan = class {
   }
 };
 var noopTracer = new NoopTracer();
+function createScopedTracer(tracer, scopeAttrs) {
+  if (!Object.keys(scopeAttrs).length) return tracer;
+  return new ScopedTracer(tracer, scopeAttrs);
+}
+var ScopedTracer = class {
+  constructor(tracer, scopeAttrs) {
+    this.tracer = tracer;
+    this.scopeAttrs = scopeAttrs;
+  }
+  startSpan(name, options) {
+    const span = this.tracer.startSpan(name, {
+      ...options,
+      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+    });
+    return new ScopedActiveSpan(span, this.scopeAttrs);
+  }
+};
+var ScopedActiveSpan = class {
+  constructor(span, scopeAttrs) {
+    this.span = span;
+    this.scopeAttrs = scopeAttrs;
+    this.context = span.context;
+  }
+  context;
+  addEvent(name, attrs) {
+    this.span.addEvent(name, mergeAttrs(attrs, this.scopeAttrs));
+  }
+  end(status, options) {
+    this.span.end(status, options ? {
+      ...options,
+      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+    } : void 0);
+  }
+};
 var BasicTracer = class {
   sink;
   clock;
@@ -904,6 +938,28 @@ var actionCardActionSchema = z.discriminatedUnion("type", [
   channelAddMemberOperationSchema
 ]);
 
+// ../shared/src/agentInbox.ts
+function formatAgentInboxDelta(rows, options = {}) {
+  const totalPendingMessages = options.totalPendingMessages;
+  const header = typeof totalPendingMessages === "number" ? `Inbox update: ${totalPendingMessages} unread message${totalPendingMessages === 1 ? "" : "s"} total; ${rows.length === 0 ? "no" : rows.length} changed target${rows.length === 1 ? "" : "s"}` : `Inbox update: ${rows.length} changed target${rows.length === 1 ? "" : "s"}`;
+  if (rows.length === 0) return typeof totalPendingMessages === "number" ? header : "Inbox update: no pending targets";
+  return [
+    header,
+    ...rows.map((row) => `${row.target}  ${formatAgentInboxRowDetails(row)}`)
+  ].join("\n");
+}
+function formatAgentInboxRowDetails(row) {
+  const parts = [`pending: ${row.pendingCount} message${row.pendingCount === 1 ? "" : "s"}`];
+  if (row.firstPendingMsgId) parts.push(`first msg=${shortMessageId(row.firstPendingMsgId)}`);
+  if (row.latestSenderName) parts.push(`latest @${row.latestSenderName}`);
+  if (row.latestMsgId) parts.push(`latest msg=${shortMessageId(row.latestMsgId)}`);
+  parts.push(...row.flags);
+  return parts.join(" \xB7 ");
+}
+function shortMessageId(value) {
+  return value.slice(0, 8);
+}
+
 // ../shared/src/translationLanguages.ts
 var SUPPORTED_TRANSLATION_LANGUAGE_CODES = [
   "en",
@@ -996,7 +1052,7 @@ var RUNTIMES = [
   { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
   { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
   { id: "opencode", displayName: "OpenCode", binary: "opencode", supported: true },
-  { id: "pi", displayName: "Pi CLI", binary: "pi", supported: true }
+  { id: "pi", displayName: "Pi", binary: "pi", supported: true }
 ];
 var RUNTIME_MODELS = {
   claude: [
@@ -1049,9 +1105,7 @@ var RUNTIME_MODELS = {
     { id: "fusecode/opus[1m]", label: "Opus 1M via FuseCode", verified: "suggestion_only" }
   ],
   pi: [
-    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
-    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro (Pi)", verified: "suggestion_only" },
-    { id: "deepseek/deepseek-v4-flash", label: "DeepSeek V4 Flash (Pi)", verified: "suggestion_only" }
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" }
   ],
   // Kimi CLI resolves model keys from each user's local config, so the safest
   // built-in option is to defer to whatever default model the CLI already uses.
@@ -1208,7 +1262,7 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync5, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
 import path13 from "path";
@@ -1253,6 +1307,7 @@ function buildPrompt(config, variant, opts) {
   const sendCmd = isCli ? "`slock message send`" : `\`${t("send_message")}\``;
   const readCmd = isCli ? "`slock message read`" : `\`${t("read_history")}\``;
   const checkCmd = isCli ? "`slock message check`" : `\`${t("check_messages")}\``;
+  const inboxCheckCmd = isCli ? "`slock inbox check`" : checkCmd;
   const taskClaimCmd = isCli ? "`slock task claim`" : `\`${t("claim_tasks")}\``;
   const taskCreateCmd = isCli ? "`slock task create`" : `\`${t("create_tasks")}\``;
   const taskUpdateCmd = isCli ? "`slock task update`" : `\`${t("update_task_status")}\``;
@@ -1733,14 +1788,14 @@ You may develop a specialized role over time through your interactions. Embrace
 
 ## Message Notifications
 
-While you are working, the daemon may write a batched inbox-count notification into your current turn.
+While you are working, the daemon may write a batched, content-free inbox update into your current turn.
 
 How to handle these:
-- 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.`;
+- Treat the notification as a non-urgent signal that new Slock messages are waiting; it does not include the message content and does not require an immediate interruption.
+- Keep working until a natural breakpoint. If you then choose to inspect pending targets, call ${inboxCheckCmd}; use ${checkCmd} / ${readCmd} when you choose to inspect message content.
+- If a message you explicitly read is higher priority, pivot to it. If not, continue your current work.`;
     } else {
-      const notifyExample = isCli ? `\`[Slock inbox notice: You have N pending inbox message(s). Call slock message check to read them when you're ready.]\`` : `\`[Slock inbox notice: You have N pending inbox message(s). Call ${t("check_messages")} to read them when you're ready.]\``;
+      const notifyExample = isCli ? `\`[Slock inbox notice:\\nInbox update: N unread messages total; M changed targets\\n#channel  pending: K messages ...]\`` : `\`[Slock inbox notice:\\nInbox update: N unread messages total; M changed targets\\n#channel  pending: K messages ...]\``;
       prompt += `
 
 ## Message Notifications
@@ -1750,9 +1805,9 @@ While you are busy (executing tools, thinking, etc.), new messages may arrive. W
 ${notifyExample}
 
 How to handle these:
-- Call ${checkCmd} to check for new messages. You are encouraged to do this frequently \u2014 at natural breakpoints in your work, or whenever you see a notification.
-- If the new message is higher priority, you may pivot to it. If not, continue your current work.
-- ${checkCmd} returns instantly with any pending messages (or "no new messages"). It is always safe to call.`;
+- The notice is target-scoped and content-free. Its header may show total unread/pending count, while detail rows list the targets changed by this update; it never includes message bodies.
+- Do not interrupt the current step just because a notice arrived. At a natural breakpoint, call ${inboxCheckCmd} if you choose to inspect pending targets, or use ${checkCmd} / ${readCmd} when you choose to inspect message content.
+- If a message you explicitly read is higher priority, you may pivot to it. If not, continue your current work.`;
     }
   }
   if (config.description) {
@@ -2061,6 +2116,80 @@ function reduceApmGatedFlushReadiness(state, input) {
   };
 }
 
+// src/agentInboxProjection.ts
+function projectAgentInboxSnapshot(messages) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const target = formatInboxMessageTarget(message);
+    if (!target) continue;
+    const bucket = buckets.get(target) ?? [];
+    bucket.push(message);
+    buckets.set(target, bucket);
+  }
+  return [...buckets.entries()].map(([target, bucket]) => projectBucket(target, bucket)).sort((a, b) => (b.latestSeq ?? 0) - (a.latestSeq ?? 0) || a.target.localeCompare(b.target));
+}
+function projectBucket(target, messages) {
+  const sorted = [...messages].sort(compareInboxMessages);
+  const first = sorted[0];
+  const latest = sorted[sorted.length - 1];
+  const flags = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.channel_type === "thread") flags.add("thread");
+    if (message.channel_type === "dm") flags.add("dm");
+    if (message.task_number || message.task_status) flags.add("task");
+    if (message.mention === true || message.mentioned === true) flags.add("mention");
+  }
+  return stripUndefined({
+    target,
+    channelId: latest.channel_id ?? latest.parent_channel_id,
+    channelType: latest.channel_type,
+    pendingCount: messages.length,
+    firstPendingMsgId: messageId(first),
+    firstPendingSeq: messageSeq(first),
+    latestMsgId: messageId(latest),
+    latestSeq: messageSeq(latest),
+    latestSenderName: latest.sender_name ?? latest.senderName,
+    latestSenderType: normalizeSenderType(latest.sender_type ?? latest.senderType),
+    flags: [...flags].sort()
+  });
+}
+function compareInboxMessages(a, b) {
+  return (messageSeq(a) ?? 0) - (messageSeq(b) ?? 0) || (messageId(a) ?? "").localeCompare(messageId(b) ?? "");
+}
+function formatInboxMessageTarget(message) {
+  if (message.channel_type === "thread" && message.parent_channel_name && message.channel_name) {
+    const shortId = shortMessageId2(String(message.channel_name).startsWith("thread-") ? String(message.channel_name).slice("thread-".length) : String(message.channel_name));
+    if (message.parent_channel_type === "dm") return `dm:@${message.parent_channel_name}:${shortId}`;
+    return `#${message.parent_channel_name}:${shortId}`;
+  }
+  if (message.channel_type === "dm" && message.channel_name) return `dm:@${message.channel_name}`;
+  if (message.channel_name) return `#${message.channel_name}`;
+  return null;
+}
+function messageId(message) {
+  if (!message) return void 0;
+  return nonEmptyString(message.message_id) ?? nonEmptyString(message.id);
+}
+function messageSeq(message) {
+  if (!message || typeof message.seq !== "number" || !Number.isFinite(message.seq) || message.seq <= 0) return void 0;
+  return Math.floor(message.seq);
+}
+function shortMessageId2(value) {
+  return value.slice(0, 8);
+}
+function normalizeSenderType(value) {
+  return value === "human" || value === "agent" || value === "system" ? value : void 0;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function stripUndefined(value) {
+  for (const key of Object.keys(value)) {
+    if (value[key] === void 0) delete value[key];
+  }
+  return value;
+}
+
 // src/agentCredentialProxy.ts
 var registrations = /* @__PURE__ */ new Map();
 var proxyServerState = null;
@@ -2204,6 +2333,14 @@ async function handleProxyRequest(req, res) {
     }
     let sendTarget;
     const sideEffectAction = agentApiSideEffectAction(target.pathname);
+    if (method === "GET" && target.pathname === "/internal/agent-api/inbox") {
+      const localInbox = localAgentApiInboxResponse(registration);
+      if (localInbox) {
+        res.writeHead(localInbox.status, { "content-type": "application/json" });
+        res.end(JSON.stringify(localInbox.body));
+        return;
+      }
+    }
     if (method === "GET" && target.pathname === "/internal/agent-api/events") {
       const localEvents = localAgentApiEventsResponse(registration, target);
       if (localEvents) {
@@ -2347,6 +2484,7 @@ function transportNormalizedErrorForError(target, err, launchId) {
 function routeFamilyForPath(pathname) {
   if (pathname === "/internal/agent-api/send") return "agent-api/send";
   if (pathname === "/internal/agent-api/events") return "agent-api/events";
+  if (pathname === "/internal/agent-api/inbox") return "agent-api/inbox";
   if (pathname === "/internal/agent-api/receive-ack") return "agent-api/events";
   if (pathname === "/internal/agent-api/tasks/claim") return "tasks/claim";
   if (pathname === "/internal/agent-api/tasks/update-status") return "tasks/update";
@@ -2403,13 +2541,13 @@ async function readRequestBody(req) {
   }
   return Buffer.concat(chunks);
 }
-function messageSeq(message) {
+function messageSeq2(message) {
   return Number(message.seq ?? 0);
 }
 function maxMessageSeq(messages) {
   let maxSeq = 0;
   for (const message of messages) {
-    const seq = Math.floor(messageSeq(message));
+    const seq = Math.floor(messageSeq2(message));
     if (Number.isFinite(seq) && seq > 0) maxSeq = Math.max(maxSeq, seq);
   }
   return maxSeq > 0 ? maxSeq : void 0;
@@ -2423,7 +2561,7 @@ function isSelfAuthoredMessage(registration, message) {
   return messageSenderId(message) === registration.agentId;
 }
 function isMessageModelSeen(coordinator, target, message) {
-  const seq = Math.floor(messageSeq(message));
+  const seq = Math.floor(messageSeq2(message));
   const boundary = coordinator.getBoundary(target);
   if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= seq) return true;
   return coordinator.isMessageModelSeen?.({ target, message }) === true;
@@ -2433,12 +2571,31 @@ function resolveFreshnessBoundary(messages) {
   return typeof seenUpToSeq === "number" ? { ok: true, seenUpToSeq } : { ok: false, reason: "missing_seq_boundary" };
 }
 function sortBySeq(messages) {
-  return [...messages].sort((a, b) => messageSeq(a) - messageSeq(b));
+  return [...messages].sort((a, b) => messageSeq2(a) - messageSeq2(b));
 }
 function latestVisibleMessages(messages, limit) {
   const sorted = sortBySeq(messages);
   return sorted.slice(Math.max(0, sorted.length - limit));
 }
+function localAgentApiInboxResponse(registration) {
+  const coordinator = registration.inboxCoordinator;
+  if (!coordinator) return void 0;
+  const pending = coordinator.getAllPendingMessages?.() ?? [];
+  const rows = projectAgentInboxSnapshot(pending);
+  coordinator.recordInboxSnapshot?.({
+    source: "agent_api_inbox_check",
+    rows,
+    pendingMessageCount: pending.length
+  });
+  return {
+    status: 200,
+    body: {
+      rows,
+      pending_targets: rows.length,
+      pending_messages: pending.length
+    }
+  };
+}
 function parseAgentApiEventsQuery(target) {
   const limit = Math.min(Math.max(Number(target.searchParams.get("limit")) || 50, 1), 200);
   const sinceRaw = target.searchParams.get("since")?.trim() ?? "";
@@ -2469,7 +2626,7 @@ function localAgentApiEventsResponse(registration, target) {
   if (pending.length === 0) return void 0;
   const normalized = sortBySeq(normalizeVisibleMessages(pending));
   const filtered = parsedQuery.sinceSeq !== null ? normalized.filter((message) => {
-    const seq = messageSeq(message);
+    const seq = messageSeq2(message);
     return Number.isFinite(seq) && seq > parsedQuery.sinceSeq;
   }) : normalized;
   const events = filtered.slice(0, parsedQuery.limit);
@@ -2794,12 +2951,12 @@ function consumeVisibleResponse(registration, targetUrl, sendTarget, responseTex
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/send" && parsed.state === "sent") {
-    const messageSeq2 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
-    if (sendTarget && messageSeq2 && messageSeq2 > 0) {
+    const messageSeq3 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
+    if (sendTarget && messageSeq3 && messageSeq3 > 0) {
       coordinator.consumeVisibleMessages({
         target: sendTarget,
-        messages: normalizeVisibleMessages([{ seq: messageSeq2, id: parsed.messageId }], sendTarget),
-        boundarySeq: messageSeq2,
+        messages: normalizeVisibleMessages([{ seq: messageSeq3, id: parsed.messageId }], sendTarget),
+        boundarySeq: messageSeq3,
         source: "agent_api_send_commit"
       });
     }
@@ -3873,7 +4030,7 @@ function rawResponseItemProgressEvent(message) {
     payloadBytes
   };
 }
-function nonEmptyString(value) {
+function nonEmptyString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 var CodexEventNormalizer = class {
@@ -3928,8 +4085,8 @@ var CodexEventNormalizer = class {
     }
     const telemetry = parseCodexTelemetryEvent(message);
     if (telemetry) {
-      const telemetrySessionId = nonEmptyString(message.params?.threadId) ?? nonEmptyString(message.params?.thread?.id) ?? nonEmptyString(message.params?.sessionId);
-      const telemetryTurnId = nonEmptyString(message.params?.turnId) ?? nonEmptyString(message.params?.turn?.id);
+      const telemetrySessionId = nonEmptyString2(message.params?.threadId) ?? nonEmptyString2(message.params?.thread?.id) ?? nonEmptyString2(message.params?.sessionId);
+      const telemetryTurnId = nonEmptyString2(message.params?.turnId) ?? nonEmptyString2(message.params?.turn?.id);
       if (telemetrySessionId) {
         this.currentThreadId = telemetrySessionId;
       }
@@ -5986,12 +6143,23 @@ var OpenCodeDriver = class {
 
 // src/drivers/pi.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { spawn as spawn9, spawnSync as spawnSync3 } from "child_process";
-import { mkdirSync as mkdirSync4 } from "fs";
+import { EventEmitter } from "events";
+import { mkdirSync as mkdirSync4, readdirSync } from "fs";
+import { PassThrough, Writable } from "stream";
 import path11 from "path";
+import {
+  AuthStorage,
+  createBashTool,
+  createAgentSession,
+  DefaultResourceLoader,
+  getAgentDir,
+  ModelRegistry,
+  SessionManager,
+  SettingsManager,
+  VERSION as PI_SDK_VERSION
+} from "@earendil-works/pi-coding-agent";
 var PI_SESSION_DIR = ".pi-sessions";
 var PI_PROVIDER_LABELS = {
-  deepseek: "DeepSeek",
   google: "Google",
   openai: "OpenAI",
   openrouter: "OpenRouter"
@@ -5999,69 +6167,51 @@ var PI_PROVIDER_LABELS = {
 function buildPiSessionDir(workingDirectory) {
   return path11.join(workingDirectory, PI_SESSION_DIR);
 }
-function buildPiRpcArgs(ctx, sessionId) {
-  const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
-  const args = [
-    "--mode",
-    "rpc",
-    "--session-dir",
-    buildPiSessionDir(ctx.workingDirectory),
-    "--system-prompt",
-    ctx.standingPrompt
-  ];
-  if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
-    args.push("--model", launchRuntimeFields.model);
-  }
-  if (launchRuntimeFields.reasoningEffort) {
-    args.push("--thinking", launchRuntimeFields.reasoningEffort);
+async function buildPiSpawnEnv(ctx) {
+  return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
+}
+function resolvePiModelFromRegistry(modelId, modelRegistry) {
+  if (!modelId || modelId === "default") return void 0;
+  const [provider, ...modelParts] = modelId.split("/");
+  if (provider && modelParts.length > 0) {
+    return modelRegistry.find(provider, modelParts.join("/"));
   }
-  if (sessionId) {
-    args.push("--session-id", sessionId);
+  return modelRegistry.getAll().find((model) => model.id === modelId);
+}
+function findPiSessionFile(sessionDir, sessionId) {
+  let entries;
+  try {
+    entries = readdirSync(sessionDir);
+  } catch {
+    return null;
   }
-  return args;
+  const suffix = `_${sessionId}.jsonl`;
+  const match = entries.find((entry) => entry.endsWith(suffix));
+  return match ? path11.join(sessionDir, match) : null;
 }
-async function buildPiSpawnEnv(ctx) {
-  return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
+function piSdkEventToJsonLine(event) {
+  if (event.type === "agent_end") {
+    return JSON.stringify({ type: "agent_end" });
+  }
+  return JSON.stringify(event);
 }
-function parsePiModelsOutput(output) {
-  const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
+function detectPiModelsFromRegistry(modelRegistry) {
   const models = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const rawLine of stripAnsi(output).split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || /^provider\s+model\s+/i.test(line) || /^[-\s]+$/.test(line)) continue;
-    const columns = line.split(/\s+/);
-    const provider = columns[0];
-    const model = columns[1];
-    if (!provider || !model || provider.startsWith("-") || model.startsWith("-")) continue;
-    if (/^(yes|no)$/i.test(model)) continue;
-    const id = `${provider}/${model}`;
+  for (const model of modelRegistry.getAvailable()) {
+    const id = `${model.provider}/${model.id}`;
     if (seen.has(id)) continue;
     seen.add(id);
     models.push({
       id,
-      label: `${humanizePiSegment(model)} \xB7 ${PI_PROVIDER_LABELS[provider] || humanizePiSegment(provider)}`,
+      label: `${model.name || humanizePiSegment(model.id)} \xB7 ${PI_PROVIDER_LABELS[model.provider] || humanizePiSegment(model.provider)}`,
       verified: "launchable"
     });
   }
   return models.length > 0 ? { models } : null;
 }
-function detectPiModels(runCommand = runPiModelsCommand) {
-  const result = runCommand();
-  if (result.error || result.status !== 0) return null;
-  return parsePiModelsOutput(result.stdout);
-}
-function runPiModelsCommand() {
-  const result = spawnSync3("pi", ["--list-models"], {
-    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
-    encoding: "utf8",
-    timeout: 5e3
-  });
-  return {
-    status: result.status,
-    stdout: String(result.stdout || ""),
-    error: result.error
-  };
+function detectPiModels(modelRegistry = ModelRegistry.create(AuthStorage.create())) {
+  return detectPiModelsFromRegistry(modelRegistry);
 }
 function humanizePiSegment(value) {
   return value.split(/[-_/]/).filter(Boolean).map(formatPiLabelToken).join(" ");
@@ -6071,7 +6221,6 @@ function formatPiLabelToken(token) {
   const specialCases = {
     ai: "AI",
     api: "API",
-    deepseek: "DeepSeek",
     flash: "Flash",
     gpt: "GPT",
     pro: "Pro",
@@ -6095,6 +6244,116 @@ function piErrorMessage(error) {
   }
   return "Unknown Pi error";
 }
+var PiSdkProcess = class extends EventEmitter {
+  constructor(session) {
+    super();
+    this.session = session;
+    this.stdin = new Writable({
+      write: (chunk, _encoding, callback) => {
+        this.handleInput(String(chunk)).then(
+          () => callback(),
+          (error) => {
+            this.writeError(error);
+            callback();
+          }
+        );
+      }
+    });
+    this.session.subscribe((event) => {
+      this.writeStdout(piSdkEventToJsonLine(event));
+    });
+  }
+  stdout = new PassThrough();
+  stderr = new PassThrough();
+  stdin;
+  pid = void 0;
+  exitCode = null;
+  signalCode = null;
+  killed = false;
+  buffer = "";
+  closed = false;
+  kill(signal = "SIGTERM") {
+    if (this.closed) return false;
+    this.killed = true;
+    this.signalCode = typeof signal === "string" ? signal : null;
+    void this.shutdown(null, this.signalCode);
+    return true;
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  async handleInput(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim() || this.closed) continue;
+      await this.handleCommand(line);
+    }
+  }
+  async handleCommand(raw) {
+    let command;
+    try {
+      command = JSON.parse(raw);
+    } catch (error) {
+      this.writeError(error);
+      return;
+    }
+    const id = typeof command.id === "string" ? command.id : void 0;
+    try {
+      if (command.type === "prompt") {
+        await this.session.prompt(String(command.message ?? ""));
+        this.writeStdout(JSON.stringify({ id, type: "response", command: "prompt", success: true }));
+      } else if (command.type === "steer") {
+        await this.session.steer(String(command.message ?? ""));
+        this.writeStdout(JSON.stringify({ id, type: "response", command: "steer", success: true }));
+      } else {
+        throw new Error(`Unsupported Pi SDK command: ${command.type || "unknown"}`);
+      }
+    } catch (error) {
+      this.writeStdout(JSON.stringify({
+        id,
+        type: "response",
+        command: command.type || "unknown",
+        success: false,
+        error: piErrorMessage(error)
+      }));
+    }
+  }
+  writeStdout(line) {
+    if (this.closed) return;
+    this.stdout.write(line + "\n");
+  }
+  writeError(error) {
+    if (this.closed) return;
+    this.stderr.write(piErrorMessage(error) + "\n");
+  }
+  async shutdown(code, signal) {
+    if (this.closed) return;
+    this.closed = true;
+    this.exitCode = code;
+    this.signalCode = signal;
+    try {
+      if (this.session.isStreaming) {
+        await this.session.abort();
+      }
+    } catch (error) {
+      this.stderr.write(piErrorMessage(error) + "\n");
+    }
+    try {
+      this.session.dispose();
+    } catch {
+    }
+    this.stdin.destroy();
+    this.stdout.end();
+    this.stderr.end();
+    this.emit("exit", code, signal);
+    this.emit("close", code, signal);
+  }
+};
 var PiDriver = class {
   id = "pi";
   supportsNativeStandingPrompt = true;
@@ -6112,7 +6371,7 @@ var PiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -6124,11 +6383,9 @@ var PiDriver = class {
   requestId = 0;
   process = null;
   probe() {
-    const command = resolveCommandOnPath("pi");
-    if (!command) return { available: false };
     return {
       available: true,
-      version: readCommandVersion(command) ?? void 0
+      version: PI_SDK_VERSION
     };
   }
   async detectModels() {
@@ -6139,15 +6396,57 @@ var PiDriver = class {
     this.sessionAnnounced = false;
     this.sawTextDelta = false;
     this.requestId = 0;
-    mkdirSync4(buildPiSessionDir(ctx.workingDirectory), { recursive: true });
-    const proc = spawn9(resolveCommandOnPath("pi") ?? "pi", buildPiRpcArgs(ctx, this.sessionId), {
+    const sessionDir = buildPiSessionDir(ctx.workingDirectory);
+    mkdirSync4(sessionDir, { recursive: true });
+    const spawnEnv = await buildPiSpawnEnv(ctx);
+    const agentDir = spawnEnv.PI_CODING_AGENT_DIR || getAgentDir();
+    const authStorage = AuthStorage.create(path11.join(agentDir, "auth.json"));
+    const modelRegistry = ModelRegistry.create(authStorage, path11.join(agentDir, "models.json"));
+    const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
+    const model = resolvePiModelFromRegistry(launchRuntimeFields.model, modelRegistry);
+    if (launchRuntimeFields.model && launchRuntimeFields.model !== "default" && !model) {
+      throw new Error(`Pi model not found: ${launchRuntimeFields.model}`);
+    }
+    const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false } });
+    const resourceLoader = new DefaultResourceLoader({
       cwd: ctx.workingDirectory,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: await buildPiSpawnEnv(ctx),
-      shell: process.platform === "win32"
+      agentDir,
+      settingsManager,
+      systemPromptOverride: () => ctx.standingPrompt
     });
+    await resourceLoader.reload();
+    const existingSessionFile = ctx.config.sessionId ? findPiSessionFile(sessionDir, ctx.config.sessionId) : null;
+    const sessionManager = existingSessionFile ? SessionManager.open(existingSessionFile, sessionDir, ctx.workingDirectory) : SessionManager.create(ctx.workingDirectory, sessionDir, { id: this.sessionId });
+    const { session } = await createAgentSession({
+      cwd: ctx.workingDirectory,
+      agentDir,
+      model,
+      thinkingLevel: launchRuntimeFields.reasoningEffort,
+      authStorage,
+      modelRegistry,
+      resourceLoader,
+      customTools: [
+        createBashTool(ctx.workingDirectory, {
+          spawnHook: (spawnContext) => ({
+            ...spawnContext,
+            env: {
+              ...spawnContext.env,
+              ...spawnEnv
+            }
+          })
+        })
+      ],
+      sessionManager,
+      settingsManager
+    });
+    this.sessionId = session.sessionId;
+    const proc = new PiSdkProcess(session);
     this.process = proc;
-    this.sendRpcCommand("prompt", { message: ctx.prompt });
+    setImmediate(() => {
+      if (this.process === proc && !proc.killed) {
+        this.sendRpcCommand("prompt", { message: ctx.prompt });
+      }
+    });
     return { process: proc };
   }
   parseLine(line) {
@@ -6236,7 +6535,7 @@ var PiDriver = class {
       toolPrefix: "",
       extraCriticalRules: [],
       postStartupNotes: [
-        "**Pi runtime note:** Slock keeps Pi running in RPC mode. While you are working, Slock may send inbox-count notifications into the current turn; call `slock message check` at natural breakpoints."
+        "**Pi runtime note:** Slock keeps Pi running as a persistent SDK session. While you are working, Slock may send inbox-count notifications into the current turn; call `slock message check` at natural breakpoints."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -6390,7 +6689,9 @@ import { createHash as createHash2 } from "crypto";
 var MAX_RUNTIME_ERROR_MESSAGE_EXCERPT_CHARS = 4096;
 var RUNTIME_AUTH_ACTION_REQUIRED_PATTERNS = [
   /access token could not be refreshed/i,
+  /\btoken_(?:revoked|invalidated)\b/i,
   /refresh token was already used/i,
+  /access token.*invalidated/i,
   /authentication token has been invalidated/i,
   /logged out or signed in to another account/i,
   /not logged in/i,
@@ -6472,6 +6773,9 @@ function classifyRuntimeError(message, httpStatus) {
     return "ProviderApiError";
   }
   if (isRuntimeAuthActionRequiredText(message)) return "AuthError";
+  if (/\bmodel\b.*\bnot supported\b/i.test(message) || /\bunsupported\b.*\bmodel\b/i.test(message) || /\bmodel\b.*\bnot available\b/i.test(message)) {
+    return "ModelConfigError";
+  }
   if (/\b(?:ETIMEDOUT|timeout|timed out)\b/i.test(message)) return "TimeoutError";
   if (/\b(?:ECONNRESET|EPIPE|ECONNREFUSED|ENOTFOUND|EAI_AGAIN)\b/i.test(message) || /\bUnable to connect to API\b/i.test(message)) {
     return "ProviderConnectionError";
@@ -6504,6 +6808,8 @@ function classifyRuntimeErrorReason(runtimeErrorClass) {
       return "auth_failed";
     case "NotFoundError":
       return "not_found";
+    case "ModelConfigError":
+      return "model_config_error";
     case "ProviderServerError":
       return "provider_server_error";
     case "ProviderApiError":
@@ -6531,7 +6837,7 @@ function runtimeDisplayName(runtimeId) {
     case "opencode":
       return "OpenCode";
     case "pi":
-      return "Pi CLI";
+      return "Pi";
     default:
       return runtimeId || "This runtime";
   }
@@ -6777,8 +7083,8 @@ function formatVisibleMessageTarget(message) {
   }
   return null;
 }
-function getMessageShortId(messageId) {
-  return messageId.startsWith("thread-") ? messageId.slice(7) : messageId.slice(0, 8);
+function getMessageShortId(messageId2) {
+  return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
 }
 var RESPONSE_TARGET_HINT = "Reply in the channel or create/reply in a thread as appropriate; use each message's `target` and `msg` fields to choose the exact target.";
 function findSessionJsonl(root, predicate) {
@@ -6789,7 +7095,7 @@ function findSessionJsonl(root, predicate) {
     if (depth < 0 || visited >= maxEntries) return null;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
     } catch {
       return null;
     }
@@ -7505,7 +7811,7 @@ function classifyTerminalFailure(ap) {
   for (const text of candidates) {
     const diagnostics = buildRuntimeErrorDiagnosticEnvelope(text);
     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") || diagnostics.spanAttrs.runtime_error_action_required === true || isProviderStreamFailureText(text) || isRuntimeStartTimeoutText(text)) {
+    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") || lower.includes("model is not supported") || lower.includes("unsupported model") || /\bmodel\b.*\bnot supported\b/i.test(text) || diagnostics.spanAttrs.runtime_error_action_required === true || isProviderStreamFailureText(text) || isRuntimeStartTimeoutText(text)) {
       const actionRequired = diagnostics.spanAttrs.runtime_error_action_required === true;
       return {
         detail: actionRequired ? formatRuntimeLoginRequiredMessage(ap.driver.id) : text,
@@ -7515,6 +7821,16 @@ function classifyTerminalFailure(ap) {
   }
   return null;
 }
+function classifyStickyTerminalFailure(ap) {
+  const terminalFailure = classifyTerminalFailure(ap);
+  if (!terminalFailure) return null;
+  if (terminalFailure.actionRequired) return terminalFailure;
+  if (/\bmodel\b.*\bnot supported\b/i.test(terminalFailure.detail)) return terminalFailure;
+  if (/\bunsupported\b.*\bmodel\b/i.test(terminalFailure.detail)) return terminalFailure;
+  if (isProviderStreamFailureText(terminalFailure.detail)) return null;
+  if (isRuntimeStartTimeoutText(terminalFailure.detail)) return null;
+  return null;
+}
 function isProviderStreamFailureText(text) {
   return /stream closed before response\.completed|error decoding response body/i.test(text);
 }
@@ -7759,7 +8075,11 @@ var RUNTIME_TELEMETRY_RESERVED_ATTR_KEYS = /* @__PURE__ */ new Set([
   "usageKind",
   "sessionId",
   "turnId",
-  "runtimeResultId"
+  "runtimeResultId",
+  "daemonVersion",
+  "daemon_version",
+  "computerVersion",
+  "computer_version"
 ]);
 function sanitizeRuntimeTelemetryPayloadAttrs(attrs) {
   const sanitized = {};
@@ -7770,17 +8090,17 @@ function sanitizeRuntimeTelemetryPayloadAttrs(attrs) {
   return sanitized;
 }
 function getMessageDeliveryText(driver) {
-  return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
+  return driver.supportsStdinNotification ? "New inbox updates may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you with an inbox update when new messages arrive.";
 }
 function getBusyDeliveryNote(driver) {
   if (!driver.supportsStdinNotification) return "";
   if (driver.busyDeliveryMode === "direct") {
-    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.";
+    return "\n\nNote: While you are busy, the daemon may write batched content-free inbox updates into your active turn. Finish your current step, then check the inbox or read messages at a natural breakpoint.";
   }
   if (driver.busyDeliveryMode === "gated") {
-    return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn at runtime-observed safe boundaries. Call check_messages to read the pending messages before context-sensitive side effects.";
+    return "\n\nNote: While you are busy, the daemon may write batched content-free inbox updates into your active turn at runtime-observed safe boundaries. Finish your current step, then check the inbox or read messages at a natural breakpoint.";
   }
-  return "\n\nNote: While you are busy, you may receive [Slock inbox notice: ...] messages. Finish your current step, then call check_messages to check for messages.";
+  return "\n\nNote: While you are busy, you may receive [Slock inbox notice: ...] messages. Finish your current step, then check the inbox or read messages at a natural breakpoint.";
 }
 var NATIVE_STANDING_PROMPT_STARTUP_INPUT = (
   // Claude Code 2.1.114 treats "follow your system prompt" style user turns as
@@ -7979,6 +8299,13 @@ var AgentProcessManager = class _AgentProcessManager {
       getPendingMessages: (target) => this.pendingVisibleMessages(agentId, target),
       isMessageModelSeen: ({ target, message }) => this.isVisibleMessageModelSeen(agentId, target, message),
       getAllPendingMessages: () => this.allPendingVisibleMessages(agentId),
+      recordInboxSnapshot: (input) => {
+        this.recordDaemonTrace("daemon.agent.inbox_projection.snapshot", {
+          agentId,
+          source: input.source,
+          ...this.inboxProjectionTraceAttrs(input.rows, input.pendingMessageCount)
+        });
+      },
       consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input),
       recordDrainOutcome: (input) => {
         this.recordDaemonTrace("daemon.agent.drain.outcome", {
@@ -8328,6 +8655,8 @@ var AgentProcessManager = class _AgentProcessManager {
       const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
       let prompt;
       let promptSource;
+      let wakeMessageDeliveredAsInboxUpdate = false;
+      const startingInboxMessages = this.startingInboxes.get(agentId) || [];
       if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
         promptSource = "runtime_profile_control";
@@ -8337,13 +8666,15 @@ var AgentProcessManager = class _AgentProcessManager {
         promptSource = "resume_prompt";
       } else if (wakeMessage) {
         const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
-        const channelLabel = formatChannelLabel(wakeMessage);
-        prompt = runtimeProfileControlPrompt ?? `New message received:
-
-${formatIncomingMessage(wakeMessage, driver)}`;
-        promptSource = runtimeProfileControlPrompt ? "runtime_profile_control_message" : "wake_message";
+        if (runtimeProfileControlPrompt) {
+          prompt = runtimeProfileControlPrompt;
+        } else {
+          wakeMessageDeliveredAsInboxUpdate = true;
+          prompt = this.formatInboxUpdateRuntimeInput([wakeMessage, ...startingInboxMessages], driver);
+        }
+        promptSource = runtimeProfileControlPrompt ? "runtime_profile_control_message" : "wake_inbox_update";
         if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
-          const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
+          const otherUnread = Object.entries(unreadSummary);
           if (otherUnread.length > 0) {
             prompt += `
 
@@ -8354,18 +8685,9 @@ You also have unread messages in other channels:`;
             }
             prompt += `
 
-Use ${communicationCommand(driver, "read_history")} to catch up, or respond to the message above first.`;
+Use the inbox/read commands at a natural breakpoint if you choose to inspect those targets.`;
           }
         }
-        if (!runtimeProfileControlPrompt) {
-          prompt += `
-
-Respond as appropriate \u2014 ${dynamicReplyInstruction(driver)}, or take action as needed. Complete ALL your work before stopping.
-${RESPONSE_TARGET_HINT}
-
-IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. ${getMessageDeliveryText(driver)}`;
-          prompt += getBusyDeliveryNote(driver);
-        }
       } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
         prompt = `You have unread messages from while you were offline:`;
         for (const [ch, count] of Object.entries(unreadSummary)) {
@@ -8440,7 +8762,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       const agentProcess = {
         process: proc,
         driver,
-        inbox: this.startingInboxes.get(agentId) || [],
+        inbox: wakeMessageDeliveredAsInboxUpdate && wakeMessage ? [wakeMessage, ...startingInboxMessages] : startingInboxMessages,
         config: runtimeConfig,
         sessionId: runtimeConfig.sessionId || null,
         launchId: launchId || null,
@@ -8483,7 +8805,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       if (runtimeConfig.runtimeProfileControl) {
         this.ackInjectedRuntimeProfileControl(agentId, runtimeConfig.runtimeProfileControl, agentProcess.launchId);
       }
-      if (wakeMessage) {
+      if (wakeMessageDeliveredAsInboxUpdate) {
+        this.recordInboxUpdateProjection(agentId, agentProcess, agentProcess.inbox, "spawn_wake_inbox_update", "wake", prompt);
+      } else if (wakeMessage) {
         this.consumeVisibleMessages(agentId, { messages: [wakeMessage], source: "spawn_wake_message" });
         this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
       }
@@ -8584,8 +8908,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           const finalSignal = ap.exitSignal ?? signal;
           const startupTimeoutTermination = ap.expectedTerminationReason === "startup_timeout";
           const expectedTermination = Boolean(ap.expectedTerminationReason);
-          const processEndedCleanly = finalCode === 0 || expectedTermination && !ap.lastRuntimeError;
-          const terminalFailureDetail = processEndedCleanly ? null : classifyTerminalFailure(ap);
+          const stickyTerminalFailureDetail = classifyStickyTerminalFailure(ap);
+          const processEndedCleanly = !stickyTerminalFailureDetail && (finalCode === 0 || expectedTermination && !ap.lastRuntimeError);
+          const terminalFailureDetail = processEndedCleanly ? null : stickyTerminalFailureDetail ?? classifyTerminalFailure(ap);
           const resumeRecoveryReason = resumeSessionRecoveryReason(ap);
           const shouldColdStartResumeSession = resumeRecoveryReason !== null;
           const summary = summarizeCrash(finalCode, finalSignal);
@@ -9068,13 +9393,36 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }));
       return true;
     }
+    const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
+    if (stickyTerminalFailure) {
+      ap.inbox.push(message);
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "queued_terminal_runtime_error",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: Boolean(ap.sessionId),
+        launchId: ap.launchId || void 0,
+        is_idle: ap.isIdle,
+        inbox_count: ap.inbox.length
+      }));
+      this.sendAgentStatus(agentId, "inactive", ap.launchId);
+      this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+      return true;
+    }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
-      const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-      nextMessages.push(message);
+      ap.inbox.push(message);
+      const nextMessages = [...ap.inbox];
       this.commitApmIdleState(agentId, ap, false);
-      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", nextMessages);
+      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", [message]);
       this.broadcastActivity(agentId, "working", "Message received");
-      const stdinAccepted = this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
+      const stdinAccepted = this.deliverInboxUpdateViaStdin(
+        agentId,
+        ap,
+        [message],
+        "idle",
+        "stdin_idle_delivery"
+      );
       this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
         outcome: "stdin_idle_delivery",
         accepted: true,
@@ -9905,6 +10253,29 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ...messageProducerFactTraceAttrs(messages)
     };
   }
+  inboxProjectionTraceAttrs(rows, pendingMessageCount) {
+    let maxPendingCount = 0;
+    let mentionTargetCount = 0;
+    let threadTargetCount = 0;
+    let dmTargetCount = 0;
+    let taskTargetCount = 0;
+    for (const row of rows) {
+      maxPendingCount = Math.max(maxPendingCount, row.pendingCount);
+      if (row.flags.includes("mention")) mentionTargetCount += 1;
+      if (row.flags.includes("thread")) threadTargetCount += 1;
+      if (row.flags.includes("dm")) dmTargetCount += 1;
+      if (row.flags.includes("task")) taskTargetCount += 1;
+    }
+    return {
+      inbox_target_count: rows.length,
+      pending_message_count: pendingMessageCount,
+      max_pending_per_target: maxPendingCount,
+      mention_target_count: mentionTargetCount,
+      thread_target_count: threadTargetCount,
+      dm_target_count: dmTargetCount,
+      task_target_count: taskTargetCount
+    };
+  }
   runtimeProfileTurnControlTraceAttrs(control) {
     if (!control) return {};
     const pendingAgeMs = Math.max(0, Date.now() - control.injectedAtMs);
@@ -10066,7 +10437,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return written;
         }
       case "deliver_stdin": {
-        const messages = ap.inbox.splice(0, ap.inbox.length);
+        const messages = [...ap.inbox];
         ap.notifications.clear();
         if (messages.length === 0) {
           this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
@@ -10084,7 +10455,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           });
         }
         this.broadcastActivity(agentId, "working", "Message received");
-        const accepted = this.deliverMessagesViaStdin(agentId, ap, messages, effect.stdinMode);
+        const runtimeProfileMessages = messages.filter((message) => runtimeProfileNotificationFromMessage(message));
+        const ordinaryMessages = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+        let accepted = true;
+        if (runtimeProfileMessages.length > 0) {
+          ap.inbox.splice(0, ap.inbox.length, ...ordinaryMessages);
+          accepted = this.deliverMessagesViaStdin(agentId, ap, runtimeProfileMessages, effect.stdinMode);
+        }
+        if (ordinaryMessages.length > 0) {
+          accepted = this.deliverInboxUpdateViaStdin(
+            agentId,
+            ap,
+            ordinaryMessages,
+            effect.stdinMode,
+            `stdin_${effect.stdinMode}_delivery`
+          ) && accepted;
+        }
         this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
           outcome: accepted ? "written" : "not_written",
           delivered_messages_count: messages.length
@@ -10396,30 +10782,41 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.flushPendingTrajectory(agentId);
         if (ap) {
           if (event.sessionId) ap.sessionId = event.sessionId;
+          const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
           const reduction = reduceApmGatedTurnEnd(ap.gatedSteering, {
-            inboxLength: ap.inbox.length,
+            inboxLength: stickyTerminalFailure ? 0 : ap.inbox.length,
             supportsStdinNotification: ap.driver.supportsStdinNotification,
             hasSession: Boolean(ap.sessionId),
             terminateProcessOnTurnEnd: ap.driver.terminateProcessOnTurnEnd === true
           });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "turn_end" });
           const deliverStdinEffect = reduction.effects.find((effect) => effect.kind === "deliver_stdin");
+          if (stickyTerminalFailure) {
+            this.sendAgentStatus(agentId, "inactive", ap.launchId);
+          }
           if (deliverStdinEffect) {
             if (!this.executeApmGatedSteeringEffect(agentId, ap, deliverStdinEffect)) {
               this.commitApmIdleState(agentId, ap, true);
-              this.broadcastActivity(agentId, "online", "Idle");
+              if (stickyTerminalFailure) {
+                this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+              } else {
+                this.broadcastActivity(agentId, "online", "Idle");
+              }
             }
           } else {
-            if (ap.lastRuntimeError) {
+            if (stickyTerminalFailure) {
+              this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+            } else if (ap.lastRuntimeError) {
               this.broadcastActivity(agentId, "error", ap.lastRuntimeError);
             } else {
               this.broadcastActivity(agentId, "online", "Idle");
             }
           }
-          this.endRuntimeTrace(ap, "ok", {
-            outcome: "turn-completed",
+          this.endRuntimeTrace(ap, stickyTerminalFailure ? "error" : "ok", {
+            outcome: stickyTerminalFailure ? "runtime-error-with-turn-end" : "turn-completed",
+            ...stickyTerminalFailure ? { terminalRuntimeError: true } : {},
             ...runtimeTraceCounterAttrs(ap),
-            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "turn_end")
+            ...this.finalizeRuntimeProfileTurnControl(agentId, ap, stickyTerminalFailure ? "runtime_error" : "turn_end")
           });
           if (ap.driver.terminateProcessOnTurnEnd) {
             logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
@@ -10477,6 +10874,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
           if (ap.driver.supportsStdinNotification && terminalFailure) {
+            const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
             if (terminalFailure.actionRequired) {
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} auth requires user action; terminating runtime process`);
               try {
@@ -10489,6 +10887,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
                 const reason = err instanceof Error ? err.message : String(err);
                 logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after auth error: ${reason}`);
               }
+            } else if (stickyTerminalFailure) {
+              ap.notifications.clear();
+              this.sendAgentStatus(agentId, "inactive", ap.launchId);
+              logger.warn(`[Agent ${agentId}] ${ap.driver.id} terminal runtime error requires explicit recovery`);
             } else {
               ap.notifications.clear();
               logger.info(`[Agent ${agentId}] Marked ${ap.driver.id} wakeable after terminal runtime error`);
@@ -10595,11 +10997,30 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const notification = `[Slock inbox notice: You have ${inboxCount} pending inbox message${inboxCount > 1 ? "s" : ""}. Call check_messages to read ${inboxCount > 1 ? "them" : "it"} when you're ready.]`;
-    logger.info(`[Agent ${agentId}] Sending stdin notification: ${inboxCount} pending inbox message(s)`);
+    const changedMessages = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    const inboxRows = projectAgentInboxSnapshot(changedMessages);
+    const notification = `[Slock inbox notice:
+${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
+    const notificationByteCount = Buffer.byteLength(notification, "utf8");
+    const projectionAttrs = this.inboxProjectionTraceAttrs(inboxRows, inboxCount);
+    this.recordDaemonTrace("daemon.agent.inbox_projection.delta", {
+      agentId,
+      source: "busy_stdin_notification",
+      ...projectionAttrs
+    });
+    logger.info(`[Agent ${agentId}] Sending stdin inbox update: ${inboxRows.length} changed target(s), ${inboxCount} pending message(s)`);
     const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     if (encoded) {
       ap.process.stdin?.write(encoded + "\n");
+      this.recordDaemonTrace("daemon.agent.inbox_update.pushed", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        mode: "busy",
+        notification_byte_count: notificationByteCount,
+        ...projectionAttrs
+      });
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -10609,6 +11030,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         mode: "busy",
         pending_notification_count: count,
         inbox_count: inboxCount,
+        inbox_target_count: inboxRows.length,
         session_id_present: true
       });
       return true;
@@ -10626,11 +11048,110 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         retry_scheduled: retryScheduled,
         notification_timer_present: ap.notifications.hasTimer,
         inbox_count: inboxCount,
+        inbox_target_count: inboxRows.length,
         session_id_present: true
       }, "error");
       return false;
     }
   }
+  formatInboxUpdateRuntimeInput(messages, driver, totalPendingMessages = messages.length) {
+    const rows = projectAgentInboxSnapshot(messages);
+    return [
+      "[Slock inbox notice:",
+      formatAgentInboxDelta(rows, { totalPendingMessages }),
+      "]"
+    ].join("\n");
+  }
+  recordInboxUpdateProjection(agentId, ap, messages, source, mode, renderedInput, totalPendingMessages = messages.length) {
+    const rows = projectAgentInboxSnapshot(messages);
+    const projectionAttrs = this.inboxProjectionTraceAttrs(rows, totalPendingMessages);
+    this.recordDaemonTrace("daemon.agent.inbox_projection.delta", {
+      agentId,
+      source,
+      ...projectionAttrs
+    });
+    this.recordDaemonTrace("daemon.agent.inbox_update.pushed", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      mode,
+      notification_byte_count: Buffer.byteLength(renderedInput, "utf8"),
+      cursors_advanced: "none",
+      ...projectionAttrs
+    });
+    return projectionAttrs;
+  }
+  deliverInboxUpdateViaStdin(agentId, ap, messages, mode, source) {
+    if (messages.length === 0) return true;
+    const prompt = this.formatInboxUpdateRuntimeInput(messages, ap.driver, ap.inbox.length);
+    const projectionAttrs = this.recordInboxUpdateProjection(agentId, ap, messages, source, mode, prompt, ap.inbox.length);
+    const inputTraceAttrs = buildRuntimeInputTraceAttrs({
+      source,
+      prompt,
+      messages,
+      sessionIdPresent: Boolean(ap.sessionId),
+      nativeStandingPrompt: Boolean(ap.driver.supportsNativeStandingPrompt)
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.input.prepared", inputTraceAttrs);
+    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
+    if (!encoded) {
+      if (mode === "idle") {
+        this.commitApmIdleState(agentId, ap, true);
+      }
+      logger.warn(
+        `[Agent ${agentId}] Failed to encode ${mode} inbox update; ${messages.length === 1 ? "message remains" : "messages remain"} pending`
+      );
+      this.recordDaemonTrace("daemon.agent.stdin_delivery", {
+        agentId,
+        launchId: ap.launchId || void 0,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        mode,
+        messages_count: messages.length,
+        session_id_present: Boolean(ap.sessionId),
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.notifications.pendingCount,
+        busy_delivery_mode: ap.driver.busyDeliveryMode,
+        supports_stdin_notification: ap.driver.supportsStdinNotification,
+        ...this.messagesTraceAttrs(messages),
+        ...inputTraceAttrs,
+        ...projectionAttrs,
+        outcome: "encode_failed",
+        requeued_messages_count: 0,
+        cursors_advanced: "none"
+      }, "error");
+      return false;
+    }
+    const senders = [...new Set(messages.map((message) => `@${message.sender_name}`))].join(", ");
+    logger.info(
+      `[Agent ${agentId}] Delivering ${mode} inbox update for ${messages.length === 1 ? "message" : `${messages.length} messages`} from ${senders}`
+    );
+    if (this.containsOrdinaryInboxMessage(messages)) {
+      ap.lastRuntimeError = null;
+    }
+    ap.process.stdin?.write(encoded + "\n");
+    this.recordDaemonTrace("daemon.agent.stdin_delivery", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      mode,
+      messages_count: messages.length,
+      session_id_present: Boolean(ap.sessionId),
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.notifications.pendingCount,
+      busy_delivery_mode: ap.driver.busyDeliveryMode,
+      supports_stdin_notification: ap.driver.supportsStdinNotification,
+      ...this.messagesTraceAttrs(messages),
+      ...inputTraceAttrs,
+      ...projectionAttrs,
+      outcome: "written",
+      stdin_write_attempted: true,
+      cursors_advanced: "none"
+    });
+    return true;
+  }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
   deliverMessagesViaStdin(agentId, ap, messages, mode) {
     if (messages.length === 0) return true;
@@ -11163,7 +11684,7 @@ function acquireDaemonMachineLock(options) {
 }
 
 // src/localTraceSink.ts
-import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync7, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync9 } from "fs";
 import path15 from "path";
 var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 var DEFAULT_MAX_FILE_AGE_MS = 5 * 60 * 1e3;
@@ -11242,7 +11763,7 @@ var LocalRotatingTraceSink = class {
     }
   }
   pruneOldFiles() {
-    const files = readdirSync2(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
+    const files = readdirSync3(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
     const excess = files.length - this.maxFiles;
     if (excess <= 0) return;
     for (const file of files.slice(0, excess)) {
@@ -11911,7 +12432,7 @@ var DaemonCore = class {
     this.slockHome = resolveSlockHome();
     process.env[SLOCK_HOME_ENV] = this.slockHome;
     this.injectedTracer = Boolean(options.tracer);
-    this.tracer = options.tracer ?? noopTracer;
+    this.tracer = this.withDaemonTraceScope(options.tracer ?? noopTracer);
     this.runtimeDetector = options.runtimeDetector ?? (() => detectRuntimes(this.tracer));
     this.reminderCache = new ReminderCache({
       clock: options.reminderClock,
@@ -11962,9 +12483,9 @@ var DaemonCore = class {
       maxFileAgeJitterMs: jitter.maxFileAgeJitterMs,
       maxFiles: this.options.localTraceMaxFiles ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILES", 8)
     });
-    this.tracer = new BasicTracer({
+    this.tracer = this.withDaemonTraceScope(new BasicTracer({
       sink: this.localTraceSink
-    });
+    }));
     this.agentManager.setTracer(this.tracer);
     this.agentManager.setCliTransportTraceDir(path17.join(machineDir, "traces"));
   }
@@ -12058,6 +12579,23 @@ var DaemonCore = class {
     });
     span.end(status);
   }
+  withDaemonTraceScope(tracer) {
+    return createScopedTracer(tracer, this.daemonTraceScopeAttrs());
+  }
+  daemonTraceScopeAttrs() {
+    return {
+      daemonVersion: this.daemonVersion,
+      daemon_version: this.daemonVersion,
+      daemon_version_present: Boolean(this.daemonVersion),
+      ...this.computerVersion ? {
+        computerVersion: this.computerVersion,
+        computer_version: this.computerVersion,
+        computer_version_present: true
+      } : {
+        computer_version_present: false
+      }
+    };
+  }
   async requestRunnerCredentialOnce(agentId, config) {
     const url = new URL(`/internal/computer/runners/${encodeURIComponent(agentId)}/credentials`, this.options.serverUrl);
     const res = await daemonFetch(url, {
@@ -12418,8 +12956,7 @@ var DaemonCore = class {
       runtimes_count: runtimes.length,
       running_agents_count: runningAgentIds.length,
       idle_agents_count: idleAgentSessions.length,
-      runtime_profile_reports_count: runtimeProfileReports.length,
-      daemon_version_present: Boolean(this.daemonVersion)
+      runtime_profile_reports_count: runtimeProfileReports.length
     });
     for (const agentId of runningAgentIds) {
       const sessionId = this.agentManager.getAgentSessionId(agentId);