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

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

@@ -939,10 +939,12 @@ var actionCardActionSchema = z.discriminatedUnion("type", [
 ]);
 
 // ../shared/src/agentInbox.ts
-function formatAgentInboxDelta(rows) {
-  if (rows.length === 0) return "Inbox update: no pending targets";
+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 [
-    `Inbox update: ${rows.length} changed target${rows.length === 1 ? "" : "s"}`,
+    header,
     ...rows.map((row) => `${row.target}  ${formatAgentInboxRowDetails(row)}`)
   ].join("\n");
 }
@@ -1305,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")}\``;
@@ -1785,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
@@ -1802,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) {
@@ -1858,19 +1861,6 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
-// src/authEnv.ts
-var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
-var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
-function scrubDaemonAuthEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  return env;
-}
-function scrubDaemonChildEnv(env) {
-  delete env[DAEMON_API_KEY_ENV];
-  delete env[SLOCK_AGENT_TOKEN_ENV];
-  return env;
-}
-
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -3026,9 +3016,7 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 var cachedOpencliBinPath;
 function resolveOpencliBinPath() {
@@ -3243,7 +3231,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(opencliBinPath)} "
     ...agentCredentialProxy ? {} : { SLOCK_AGENT_TOKEN_FILE: tokenFile },
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -3672,7 +3660,7 @@ function resolveCommandOnWindows(command, env, execFileSyncFn, existsSyncFn) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync2;
   if (platform === "win32") {
@@ -3698,7 +3686,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -5161,11 +5149,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -5221,7 +5209,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -5393,16 +5381,13 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
 import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
-var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
-var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
-var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -5411,73 +5396,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os3.homedir(), env = process.env) {
-  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  if (inlineConfig && inlineConfig.trim()) {
-    return {
-      raw: inlineConfig,
-      explicitPath: null,
-      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
-    };
-  }
-  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
-  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
-  try {
-    return {
-      raw: readFileSync3(configPath, "utf8"),
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  } catch {
-    return {
-      raw: null,
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  }
-}
-function buildKimiSpawnEnv(env = process.env) {
-  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
-  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
-  return scrubDaemonChildEnv(spawnEnv);
-}
-function buildKimiEffectiveEnv(ctx, overrideEnv) {
-  return {
-    ...process.env,
-    ...ctx.config.envVars || {},
-    ...overrideEnv || {}
-  };
-}
-function buildKimiLaunchOptions(ctx, opts = {}) {
-  const env = buildKimiEffectiveEnv(ctx, opts.env);
-  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
-  const args = [];
-  let configFilePath = null;
-  let configContent = null;
-  if (source.explicitPath) {
-    configFilePath = source.explicitPath;
-  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
-    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
-    configContent = source.raw;
-    if (opts.writeGeneratedConfig !== false) {
-      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
-      chmodSync(configFilePath, 384);
-    }
-  }
-  if (configFilePath) {
-    args.push("--config-file", configFilePath);
-  }
-  if (ctx.config.model && ctx.config.model !== "default") {
-    args.push("--model", ctx.config.model);
-  }
-  return {
-    args,
-    env: buildKimiSpawnEnv(env),
-    configFilePath,
-    configContent
-  };
-}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -5501,25 +5419,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId, ctx, opts) => {
-      if (!ctx) return { args: ["--model", modelId] };
-      const launchCtx = {
-        ...ctx,
-        config: {
-          ...ctx.config,
-          model: modelId
-        }
-      };
-      const launch = buildKimiLaunchOptions(launchCtx, {
-        home: opts?.home,
-        writeGeneratedConfig: false
-      });
-      return {
-        args: launch.args,
-        env: launch.env,
-        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -5573,7 +5473,6 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
-    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -5582,16 +5481,15 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId,
-      ...launch.args
+      this.sessionId
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(ctx.config);
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -5599,7 +5497,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -5713,9 +5611,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os3.homedir()) {
+  const configPath = path9.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -5979,7 +5882,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -6786,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,
@@ -6868,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";
@@ -6900,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":
@@ -7901,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,
@@ -7911,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);
 }
@@ -8170,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
@@ -8735,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";
@@ -8744,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 += `
 
@@ -8761,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)) {
@@ -8847,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,
@@ -8890,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);
       }
@@ -8991,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);
@@ -9475,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,
@@ -10496,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, {
@@ -10514,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
@@ -10826,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`);
@@ -10907,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 {
@@ -10919,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`);
@@ -11025,9 +10997,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const inboxRows = projectAgentInboxSnapshot(ap.inbox);
+    const changedMessages = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    const inboxRows = projectAgentInboxSnapshot(changedMessages);
     const notification = `[Slock inbox notice:
-${formatAgentInboxDelta(inboxRows)}]`;
+${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
     const notificationByteCount = Buffer.byteLength(notification, "utf8");
     const projectionAttrs = this.inboxProjectionTraceAttrs(inboxRows, inboxCount);
     this.recordDaemonTrace("daemon.agent.inbox_projection.delta", {
@@ -11081,6 +11054,104 @@ ${formatAgentInboxDelta(inboxRows)}]`;
       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;
@@ -12134,7 +12205,7 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
-var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -12170,9 +12241,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -12939,8 +13010,6 @@ var DaemonCore = class {
 };
 
 export {
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,

package/dist/core.js

@@ -1,5 +1,4 @@
 import {
-  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -9,14 +8,12 @@ import {
   resolveChatBridgePath,
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
-  scanWorkspaceDirectories,
-  scrubDaemonAuthEnv
-} from "./chunk-OV4XD66N.js";
+  scanWorkspaceDirectories
+} from "./chunk-4H5XFLYA.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-M2KQBJR3.js";
 export {
-  DAEMON_API_KEY_ENV,
   DAEMON_CLI_USAGE,
   DaemonCore,
   deleteWorkspaceDirectory,
@@ -27,6 +24,5 @@ export {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
-  scrubDaemonAuthEnv,
   subscribeDaemonLogs
 };

package/dist/index.js

@@ -2,14 +2,12 @@
 import {
   DAEMON_CLI_USAGE,
   DaemonCore,
-  parseDaemonCliArgs,
-  scrubDaemonAuthEnv
-} from "./chunk-OV4XD66N.js";
+  parseDaemonCliArgs
+} from "./chunk-4H5XFLYA.js";
 import "./chunk-M2KQBJR3.js";
 
 // src/index.ts
-var parsedArgs = parseDaemonCliArgs(process.argv.slice(2), process.env);
-scrubDaemonAuthEnv(process.env);
+var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));
 if (!parsedArgs) {
   console.error(DAEMON_CLI_USAGE);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.55.7-play.20260602150229",
+  "version": "0.56.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"

package/dist/drivers/piSdkRunner.js

@@ -1,96 +0,0 @@
-// src/drivers/piSdkRunner.ts
-import { readFile } from "fs/promises";
-import path from "path";
-import {
-  AuthStorage,
-  createAgentSessionFromServices,
-  createAgentSessionServices,
-  SessionManager
-} from "@earendil-works/pi-coding-agent";
-function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value)}
-`);
-}
-function parseArgs(argv) {
-  const index = argv.indexOf("--config");
-  const configPath = index >= 0 ? argv[index + 1] : void 0;
-  if (!configPath) throw new Error("Missing --config <path>");
-  return { configPath };
-}
-function resolveConfiguredModel(modelId, modelRegistry) {
-  if (!modelId) return void 0;
-  const [provider, ...rest] = modelId.split("/");
-  const providerScopedId = rest.join("/");
-  if (provider && providerScopedId) {
-    const exact = modelRegistry.find(provider, providerScopedId);
-    if (exact) return exact;
-  }
-  return modelRegistry.getAll().find(
-    (model) => model.id === modelId || `${model.provider}/${model.id}` === modelId || (providerScopedId ? model.id === providerScopedId : false)
-  );
-}
-async function createSessionManager(config) {
-  if (!config.sessionId) return SessionManager.create(config.cwd, config.sessionDir);
-  const localSessions = await SessionManager.list(config.cwd, config.sessionDir);
-  const match = localSessions.find((session) => session.id.startsWith(config.sessionId));
-  if (match) return SessionManager.open(match.path, config.sessionDir);
-  return SessionManager.create(config.cwd, config.sessionDir);
-}
-async function run() {
-  const { configPath } = parseArgs(process.argv.slice(2));
-  const config = JSON.parse(await readFile(configPath, "utf8"));
-  const authStorage = AuthStorage.create(path.join(config.agentDir, "auth.json"));
-  const services = await createAgentSessionServices({
-    cwd: config.cwd,
-    agentDir: config.agentDir,
-    authStorage,
-    resourceLoaderOptions: {
-      appendSystemPrompt: [config.standingPrompt],
-      noContextFiles: true,
-      noExtensions: true,
-      noPromptTemplates: true,
-      noSkills: true,
-      noThemes: true
-    }
-  });
-  for (const diagnostic of services.diagnostics) {
-    const line = `[Pi SDK] ${diagnostic.type}: ${diagnostic.message}`;
-    if (diagnostic.type === "error") throw new Error(line);
-    process.stderr.write(`${line}
-`);
-  }
-  const sessionManager = await createSessionManager(config);
-  const model = resolveConfiguredModel(config.model, services.modelRegistry);
-  if (config.model && !model) {
-    throw new Error(`Configured Pi model '${config.model}' was not found in Pi model registry.`);
-  }
-  const { session } = await createAgentSessionFromServices({
-    services,
-    sessionManager,
-    model
-  });
-  const header = session.sessionManager.getHeader();
-  if (header) writeJson(header);
-  const unsubscribe = session.subscribe((event) => writeJson(event));
-  try {
-    await session.prompt(config.prompt);
-  } finally {
-    unsubscribe();
-    session.dispose();
-    await services.settingsManager.flush();
-  }
-}
-run().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  writeJson({
-    type: "message_end",
-    message: {
-      role: "assistant",
-      content: [],
-      stopReason: "error",
-      errorMessage: message
-    }
-  });
-  writeJson({ type: "turn_end" });
-  process.exitCode = 1;
-});