@slock-ai/daemon 0.51.1 → 0.52.1

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

@@ -1275,13 +1275,12 @@ You may develop a specialized role over time through your interactions. Embrace
 
 ## Message Notifications
 
-While you are working, new messages may be delivered directly into your current thread.
+While you are working, the daemon may write a batched inbox-count notification into your current turn.
 
 How to handle these:
-- Treat direct follow-up messages as new user input for the same live session.
-- Adapt if the new message changes priority or direction.
-- You do NOT need to poll just because direct follow-up delivery is available.
-- Use ${checkCmd} only when you need to inspect other pending channels or recover broader context.`;
+- Treat the notification as a signal that new Slock messages are waiting; it does not include the message content.
+- Call ${checkCmd} at the next safe breakpoint to materialize the pending messages before taking side-effect actions that depend on current context.
+- If the new message is higher priority, pivot after reading it. If not, continue your current work.`;
     } else {
       const notifyExample = isCli ? `\`[System notification: You have N new message(s) waiting. Call slock message check to read them when you're ready.]\`` : `\`[System notification: You have N new message(s) waiting. Call ${t("check_messages")} to read them when you're ready.]\``;
       prompt += `
@@ -1356,6 +1355,7 @@ import { URL as URL2 } from "url";
 var registrations = /* @__PURE__ */ new Map();
 var servers = /* @__PURE__ */ new Map();
 var DECODED_RESPONSE_HEADERS = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding"]);
+var LOCAL_HELD_CONTEXT_LIMIT = 3;
 function allocatePort() {
   return 43e3 + randomBytes(2).readUInt16BE(0) % 1e4;
 }
@@ -1388,8 +1388,10 @@ async function handleProxyRequest(req, res) {
     res.end(JSON.stringify({ error: "invalid local agent proxy token", code: "invalid_agent_proxy_token" }));
     return;
   }
+  const method = req.method ?? "GET";
+  let target;
   try {
-    const target = new URL2(req.url ?? "/", registration.serverUrl);
+    target = new URL2(req.url ?? "/", registration.serverUrl);
     const headers = new Headers();
     for (const [name, value] of Object.entries(req.headers)) {
       if (value === void 0) continue;
@@ -1405,12 +1407,20 @@ async function handleProxyRequest(req, res) {
     headers.set("X-Agent-Id", registration.agentId);
     headers.set("X-Slock-Client", "cli");
     headers.set("X-Slock-Agent-Active-Capabilities", registration.activeCapabilities);
-    const method = req.method ?? "GET";
     let body = method === "GET" || method === "HEAD" ? void 0 : req;
     let sendTarget;
-    if (method === "POST" && target.pathname === "/internal/agent-api/send") {
+    const sideEffectAction = agentApiSideEffectAction(target.pathname);
+    if (method === "GET" && target.pathname === "/internal/agent-api/events") {
+      const localEvents = localAgentApiEventsResponse(registration, target);
+      if (localEvents) {
+        res.writeHead(localEvents.status, { "content-type": "application/json" });
+        res.end(JSON.stringify(localEvents.body));
+        return;
+      }
+    }
+    if (method === "POST" && sideEffectAction) {
       const rawBody = await readRequestBody(req);
-      const prepared = await prepareAgentApiSendForward(registration, headers, rawBody);
+      const prepared = await prepareAgentApiSideEffectForward(registration, headers, rawBody, sideEffectAction);
       if (prepared.localResponse) {
         const responseText = JSON.stringify(prepared.localResponse);
         res.writeHead(200, { "content-type": "application/json" });
@@ -1418,7 +1428,7 @@ async function handleProxyRequest(req, res) {
         return;
       }
       body = prepared.bodyText;
-      sendTarget = prepared.target;
+      if (sideEffectAction === "send") sendTarget = prepared.target;
       headers.set("content-type", "application/json");
       headers.set("content-length", String(Buffer.byteLength(prepared.bodyText)));
     }
@@ -1452,14 +1462,33 @@ async function handleProxyRequest(req, res) {
       res.end();
     }
   } catch (err) {
+    const failure = proxyFailureForError(method, target, err);
+    logger.warn(
+      `[Agent Credential Proxy] request failed (agent=${registration.agentId}, launch=${registration.launchId ?? "none"}, method=${failure.method}, path=${failure.pathname}, query_keys=${failure.queryKeys.join(",") || "none"}): ${failure.errorName}: ${failure.errorMessage}`
+    );
+    registration.inboxCoordinator?.recordProxyFailure?.(failure);
     res.writeHead(502, { "content-type": "application/json" });
     res.end(JSON.stringify({
       error: "failed to proxy local agent request",
       code: "agent_proxy_failed",
-      detail: err instanceof Error ? err.message : String(err)
+      detail: failure.errorMessage
     }));
   }
 }
+function proxyFailureForError(method, target, err) {
+  const queryKeys = target ? [.../* @__PURE__ */ new Set([...target.searchParams.keys()])].sort() : [];
+  return {
+    method,
+    pathname: target?.pathname ?? "unknown",
+    queryKeys,
+    errorName: err instanceof Error ? err.name : typeof err,
+    errorMessage: truncateProxyErrorMessage(err instanceof Error ? err.message : String(err))
+  };
+}
+function truncateProxyErrorMessage(message) {
+  const normalized = message.replace(/\s+/g, " ").trim();
+  return normalized.length > 500 ? `${normalized.slice(0, 497)}...` : normalized;
+}
 async function readRequestBody(req) {
   let body = "";
   req.setEncoding("utf8");
@@ -1471,14 +1500,6 @@ async function readRequestBody(req) {
 function messageSeq(message) {
   return Number(message.seq ?? 0);
 }
-function boundaryBefore(messages) {
-  let minSeq = Number.POSITIVE_INFINITY;
-  for (const message of messages) {
-    const seq = Math.floor(messageSeq(message));
-    if (Number.isFinite(seq) && seq > 0) minSeq = Math.min(minSeq, seq);
-  }
-  return Number.isFinite(minSeq) ? Math.max(0, minSeq - 1) : void 0;
-}
 function maxMessageSeq(messages) {
   let maxSeq = 0;
   for (const message of messages) {
@@ -1487,6 +1508,117 @@ function maxMessageSeq(messages) {
   }
   return maxSeq > 0 ? maxSeq : void 0;
 }
+function sortBySeq(messages) {
+  return [...messages].sort((a, b) => messageSeq(a) - messageSeq(b));
+}
+function latestVisibleMessages(messages, limit) {
+  const sorted = sortBySeq(messages);
+  return sorted.slice(Math.max(0, sorted.length - limit));
+}
+function parseAgentApiEventsQuery(target) {
+  const limit = Math.min(Math.max(Number(target.searchParams.get("limit")) || 50, 1), 200);
+  const sinceRaw = target.searchParams.get("since")?.trim() ?? "";
+  if (!sinceRaw) return { limit, sinceSeq: null, sinceCursorKind: null };
+  if (sinceRaw === "latest") return { limit, sinceSeq: null, sinceCursorKind: "latest" };
+  const parsed = Number(sinceRaw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return {
+      limit,
+      sinceSeq: null,
+      sinceCursorKind: null,
+      error: {
+        error: "since must be a non-negative integer (messageSeq) or 'latest'",
+        code: "since_invalid"
+      }
+    };
+  }
+  return { limit, sinceSeq: Math.floor(parsed), sinceCursorKind: "seq" };
+}
+function localAgentApiEventsResponse(registration, target) {
+  const coordinator = registration.inboxCoordinator;
+  if (!coordinator) return void 0;
+  const pending = coordinator.getAllPendingMessages?.() ?? [];
+  const parsedQuery = parseAgentApiEventsQuery(target);
+  if (parsedQuery.error && pending.length > 0) {
+    return { status: 400, body: parsedQuery.error };
+  }
+  if (pending.length === 0) return void 0;
+  const normalized = sortBySeq(normalizeVisibleMessages(pending));
+  const filtered = parsedQuery.sinceSeq !== null ? normalized.filter((message) => {
+    const seq = messageSeq(message);
+    return Number.isFinite(seq) && seq > parsedQuery.sinceSeq;
+  }) : normalized;
+  const events = filtered.slice(0, parsedQuery.limit);
+  const hasMore = filtered.length > events.length;
+  const newestEvent = events[events.length - 1];
+  const lastSeenMsgId = newestEvent?.message_id ?? newestEvent?.id ?? null;
+  const lastSeenSeq = newestEvent?.seq ?? parsedQuery.sinceSeq;
+  if (events.length > 0) {
+    coordinator.consumeVisibleMessages({ messages: events, source: "agent_api_events" });
+  }
+  coordinator.recordDrainOutcome?.({
+    source: "daemon_pending",
+    sinceCursorKind: parsedQuery.sinceCursorKind,
+    notifiedCount: pending.length,
+    drainedCount: events.length,
+    hasMore
+  });
+  return {
+    status: 200,
+    body: {
+      events,
+      last_seen_msgId: lastSeenMsgId,
+      last_seen_seq: lastSeenSeq,
+      reply_target: null,
+      pending_notice_ids: [],
+      wake_reason: null,
+      has_more: hasMore
+    }
+  };
+}
+function heldAvailableActions(action) {
+  return action === "send" ? ["check_messages", "send_draft", "send_anyway"] : ["check_messages", "retry_action"];
+}
+function localHeldResponse(input) {
+  if (input.messages.length === 0) return void 0;
+  const normalized = sortBySeq(normalizeVisibleMessages(input.messages, input.target));
+  const heldMessages = latestVisibleMessages(normalized, LOCAL_HELD_CONTEXT_LIMIT);
+  const omittedMessageCount = Math.max(0, normalized.length - heldMessages.length);
+  const seenUpToSeq = maxMessageSeq(normalized);
+  if (seenUpToSeq === void 0) return void 0;
+  input.coordinator.consumeVisibleMessages({
+    target: input.target,
+    messages: heldMessages,
+    boundarySeq: seenUpToSeq,
+    source: input.source
+  });
+  const response = {
+    state: "held",
+    outcome: "held",
+    subtype: "freshness",
+    reason: "newer_messages_available",
+    available_actions: heldAvailableActions(input.action),
+    heldMessages,
+    newMessageCount: normalized.length,
+    shownMessageCount: heldMessages.length,
+    omittedMessageCount
+  };
+  response.seenUpToSeq = seenUpToSeq;
+  return response;
+}
+function recordFreshnessDecision(coordinator, decision) {
+  coordinator?.recordFreshnessDecision?.(decision);
+}
+function agentApiSideEffectAction(pathname) {
+  if (pathname === "/internal/agent-api/send") return "send";
+  if (pathname === "/internal/agent-api/tasks/claim") return "task_claim";
+  if (pathname === "/internal/agent-api/tasks/update-status") return "task_update";
+  return void 0;
+}
+function sideEffectTarget(action, body) {
+  const field = action === "send" ? body.target : body.channel;
+  return typeof field === "string" && field.length > 0 ? field : void 0;
+}
 function parseTargetFields(target) {
   if (target.startsWith("dm:@")) {
     const rest = target.slice("dm:@".length);
@@ -1543,42 +1675,98 @@ async function loadRecentTargetMessages(registration, headers, target) {
   const parsed = await res.json().catch(() => null);
   return Array.isArray(parsed?.messages) ? normalizeVisibleMessages(parsed.messages, target) : [];
 }
-async function prepareAgentApiSendForward(registration, headers, rawBody) {
+async function prepareAgentApiSideEffectForward(registration, headers, rawBody, action) {
   let body;
   try {
     body = rawBody ? JSON.parse(rawBody) : {};
   } catch {
     return { bodyText: rawBody };
   }
-  const target = typeof body.target === "string" ? body.target : void 0;
+  const target = sideEffectTarget(action, body);
   const coordinator = registration.inboxCoordinator;
-  if (!target || !coordinator || body.continueAnyway === true) {
+  if (!target || !coordinator) {
+    return { bodyText: JSON.stringify(body), target };
+  }
+  if (action === "send" && body.continueAnyway === true) {
+    recordFreshnessDecision(coordinator, {
+      action,
+      decision: "bypass",
+      target,
+      inboxTrustState: "trusted",
+      reason: "continue_anyway"
+    });
     return { bodyText: JSON.stringify(body), target };
   }
   const pending = coordinator.getPendingMessages(target);
   if (pending.length > 0) {
-    const staleBoundary = boundaryBefore(pending);
-    if (staleBoundary !== void 0) {
-      body.seenUpToSeq = staleBoundary;
+    const localResponse = localHeldResponse({
+      action,
+      target,
+      messages: pending,
+      coordinator,
+      source: "side_effect_preflight_context"
+    });
+    if (localResponse) {
+      recordFreshnessDecision(coordinator, {
+        action,
+        decision: "local_hold",
+        target,
+        inboxTrustState: "trusted",
+        reason: "exact_target_pending",
+        pendingCount: pending.length,
+        pendingMaxSeq: maxMessageSeq(pending),
+        modelSeenSeq: coordinator.getBoundary(target),
+        heldMessageCount: typeof localResponse.shownMessageCount === "number" ? localResponse.shownMessageCount : void 0,
+        omittedMessageCount: typeof localResponse.omittedMessageCount === "number" ? localResponse.omittedMessageCount : void 0
+      });
     }
-    return { bodyText: JSON.stringify(body), target };
+    return {
+      bodyText: JSON.stringify(body),
+      target,
+      localResponse
+    };
   }
   const existingBoundary = typeof body.seenUpToSeq === "number" && Number.isFinite(body.seenUpToSeq) ? Math.max(0, Math.floor(body.seenUpToSeq)) : void 0;
   const loadedBoundary = coordinator.getBoundary(target);
   const boundary = Math.max(existingBoundary ?? 0, loadedBoundary ?? 0);
   if (boundary > 0) {
-    body.seenUpToSeq = boundary;
+    if (action === "send") body.seenUpToSeq = boundary;
+    recordFreshnessDecision(coordinator, {
+      action,
+      decision: "forward",
+      target,
+      inboxTrustState: "trusted",
+      reason: "model_seen_boundary",
+      pendingCount: 0,
+      modelSeenSeq: boundary
+    });
     return { bodyText: JSON.stringify(body), target };
   }
   const recent = await loadRecentTargetMessages(registration, headers, target);
   if (recent.length > 0) {
     const seenUpToSeq = maxMessageSeq(recent);
-    coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "send_preflight_context" });
+    coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "side_effect_preflight_context" });
+    recordFreshnessDecision(coordinator, {
+      action,
+      decision: "syncing_hold",
+      target,
+      inboxTrustState: "untrusted",
+      reason: "target_first_touch_recent_context",
+      pendingCount: 0,
+      pendingMaxSeq: seenUpToSeq,
+      modelSeenSeq: 0,
+      heldMessageCount: recent.length,
+      omittedMessageCount: 0
+    });
     return {
       bodyText: JSON.stringify(body),
       target,
       localResponse: {
         state: "held",
+        outcome: "held",
+        subtype: "freshness",
+        reason: "newer_messages_available",
+        available_actions: heldAvailableActions(action),
         seenUpToSeq,
         heldMessages: recent,
         newMessageCount: recent.length,
@@ -1587,6 +1775,15 @@ async function prepareAgentApiSendForward(registration, headers, rawBody) {
       }
     };
   }
+  recordFreshnessDecision(coordinator, {
+    action,
+    decision: "forward",
+    target,
+    inboxTrustState: "trusted",
+    reason: "no_exact_target_pending_or_recent_context",
+    pendingCount: 0,
+    modelSeenSeq: 0
+  });
   return { bodyText: JSON.stringify(body), target };
 }
 function shouldBufferJsonResponse(upstream, pathname, registration) {
@@ -1614,7 +1811,15 @@ function consumeVisibleResponse(registration, targetUrl, sendTarget, responseTex
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/events" && Array.isArray(parsed.events)) {
-    coordinator.consumeVisibleMessages({ messages: normalizeVisibleMessages(parsed.events), source: "agent_api_events" });
+    const messages = normalizeVisibleMessages(parsed.events);
+    coordinator.consumeVisibleMessages({ messages, source: "agent_api_events" });
+    coordinator.recordDrainOutcome?.({
+      source: "server_events",
+      sinceCursorKind: parseAgentApiEventsQuery(targetUrl).sinceCursorKind,
+      notifiedCount: 0,
+      drainedCount: messages.length,
+      hasMore: Boolean(parsed.has_more)
+    });
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/history" && Array.isArray(parsed.messages)) {
@@ -2159,8 +2364,7 @@ var ClaudeDriver = class {
         "- Runtime Profile migration completion is the only exception to CLI-only operation: when a migration notice tells you to acknowledge with `runtime_profile_migration_done`, call the `mcp__chat__runtime_profile_migration_done` tool with the exact `migration_key`; do not use `slock` CLI or reply in chat as the acknowledgment."
       ],
       postStartupNotes: [
-        "**Claude runtime note:** Slock preserves Claude Code same-turn steering through a gated stream-json delivery path. Busy messages are buffered and delivered at Claude-observed safe boundaries; if no earlier safe boundary is available, they are delivered after the current turn ends.",
-        "For long tool runs, you can also use `slock message check` at natural breakpoints to pull pending messages explicitly."
+        "**Claude runtime note:** While you are busy, Slock batches inbox-count notifications instead of injecting message content. Use `slock message check` at natural breakpoints to pull the pending messages before side-effect actions that depend on current context."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -2654,7 +2858,7 @@ var CodexDriver = class {
       toolPrefix: "",
       extraCriticalRules: [],
       postStartupNotes: [
-        "**IMPORTANT**: Your process stays alive across turns. New messages may be delivered directly into the current thread while you are working."
+        "**IMPORTANT**: Your process stays alive across turns. While you are working, Slock may write batched inbox-count notifications into the current turn; call `slock message check` at natural breakpoints to read the pending messages."
       ],
       includeStdinNotificationSection: true,
       messageNotificationStyle: "direct"
@@ -3820,11 +4024,14 @@ function detectOpenCodeModels(home = os5.homedir(), runCommand = runOpenCodeMode
   if (commandResult.error || commandResult.status !== 0) return null;
   return parseOpenCodeModelsOutput(commandResult.stdout);
 }
-function runOpenCodeModelsCommand(home) {
-  const result = spawnSync2("opencode", ["models"], {
+function runOpenCodeModelsCommand(home, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
+  const result = spawnSyncFn("opencode", ["models"], {
     env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
-    timeout: 5e3
+    timeout: 5e3,
+    shell: platform === "win32"
   });
   return {
     status: result.status,
@@ -5234,10 +5441,10 @@ function getMessageDeliveryText(driver) {
 function getBusyDeliveryNote(driver) {
   if (!driver.supportsStdinNotification) return "";
   if (driver.busyDeliveryMode === "direct") {
-    return "\n\nNote: While you are busy, new messages may be delivered directly into your active turn. Handle them when appropriate and keep working.";
+    return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn. Call check_messages to read the pending messages before context-sensitive side effects.";
   }
   if (driver.busyDeliveryMode === "gated") {
-    return "\n\nNote: While you are busy, new messages may be delivered at runtime-observed safe boundaries in your active turn. If no safe boundary is available, they will be delivered after the current turn ends.";
+    return "\n\nNote: While you are busy, the daemon may write batched inbox-count notifications into your active turn at runtime-observed safe boundaries. Call check_messages to read the pending messages before context-sensitive side effects.";
   }
   return "\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.";
 }
@@ -5313,13 +5520,16 @@ var AgentProcessManager = class _AgentProcessManager {
   getVisibleBoundary(agentId, target) {
     return this.agentVisibleBoundaries.get(agentId)?.get(target);
   }
-  pendingVisibleMessages(agentId, target) {
-    const collect = (messages) => (messages ?? []).filter((message) => formatMessageTarget(message) === target && typeof message.seq === "number" && message.seq > 0);
+  allPendingVisibleMessages(agentId) {
+    const collect = (messages) => (messages ?? []).filter((message) => typeof message.seq === "number" && message.seq > 0);
     return [
       ...collect(this.agents.get(agentId)?.inbox),
       ...collect(this.startingInboxes.get(agentId))
     ];
   }
+  pendingVisibleMessages(agentId, target) {
+    return this.allPendingVisibleMessages(agentId).filter((message) => formatMessageTarget(message) === target);
+  }
   /**
    * Single-inbox consume point for messages that have been rendered into the
    * agent-visible input surface. Daemon pending inbox is only a runner cache:
@@ -5390,9 +5600,72 @@ var AgentProcessManager = class _AgentProcessManager {
     return {
       getBoundary: (target) => this.getVisibleBoundary(agentId, target),
       getPendingMessages: (target) => this.pendingVisibleMessages(agentId, target),
-      consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input)
+      getAllPendingMessages: () => this.allPendingVisibleMessages(agentId),
+      consumeVisibleMessages: (input) => this.consumeVisibleMessages(agentId, input),
+      recordDrainOutcome: (input) => {
+        this.recordDaemonTrace("daemon.agent.drain.outcome", {
+          agentId,
+          source: input.source,
+          since_cursor_kind: input.sinceCursorKind ?? void 0,
+          notified_count: input.notifiedCount,
+          drained_count: input.drainedCount,
+          has_more: input.hasMore
+        });
+      },
+      recordProxyFailure: (input) => this.recordAgentProxyFailure(agentId, input),
+      recordFreshnessDecision: (input) => {
+        this.recordDaemonTrace("daemon.agent.inbox.freshness_decision", {
+          agentId,
+          action: input.action,
+          decision: input.decision,
+          target: input.target,
+          inbox_trust_state: input.inboxTrustState,
+          reason: input.reason,
+          pending_count: input.pendingCount,
+          pending_max_seq: input.pendingMaxSeq,
+          model_seen_seq: input.modelSeenSeq,
+          held_message_count: input.heldMessageCount,
+          omitted_message_count: input.omittedMessageCount
+        });
+        this.recordFreshnessDecisionActivity(agentId, input);
+      }
     };
   }
+  recordAgentProxyFailure(agentId, input) {
+    this.recordDaemonTrace("daemon.agent.proxy.failure", {
+      agentId,
+      method: input.method,
+      path: input.pathname,
+      query_keys: input.queryKeys,
+      error_name: input.errorName,
+      error_message: input.errorMessage
+    }, "error");
+  }
+  recordFreshnessDecisionActivity(agentId, input) {
+    if (input.decision !== "local_hold" && input.decision !== "syncing_hold") return;
+    const ap = this.agents.get(agentId);
+    const messageCount = input.pendingCount ?? input.heldMessageCount ?? 0;
+    const title = input.action === "send" ? "Send held by freshness check" : input.action === "task_claim" ? "Task claim held by freshness check" : "Task update held by freshness check";
+    const entry = {
+      kind: "slock_action",
+      title,
+      text: [
+        input.target ? `target: ${input.target}` : null,
+        `new messages: ${messageCount} newer message${messageCount === 1 ? "" : "s"}`,
+        `decision: ${input.decision === "syncing_hold" ? "syncing hold" : "local hold"}; review the newer context before retrying`
+      ].filter((line) => Boolean(line)).join("\n")
+    };
+    if (ap) ap.activityClientSeq += 1;
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity: ap?.lastActivity || "online",
+      detail: ap?.lastActivityDetail || "",
+      entries: [entry],
+      launchId: ap?.launchId || void 0,
+      clientSeq: ap?.activityClientSeq
+    });
+  }
   recordDaemonTrace(name, attrs, status = "ok", parentTraceparent) {
     const span = this.tracer.startSpan(name, {
       parent: parseTraceparent(parentTraceparent),
@@ -6446,6 +6719,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     if (ap.driver.busyDeliveryMode === "gated") {
       ap.pendingNotificationCount++;
+      if (!ap.notificationTimer) {
+        ap.notificationTimer = setTimeout(() => {
+          this.sendStdinNotification(agentId);
+        }, 3e3);
+      }
       this.recordGatedSteeringEvent(agentId, ap, "buffer", {
         reason: "busy_message",
         pendingMessages: ap.inbox.length
@@ -6458,7 +6736,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         session_id_present: true,
         launchId: ap.launchId || void 0,
         inbox_count: ap.inbox.length,
-        pending_notification_count: ap.pendingNotificationCount
+        pending_notification_count: ap.pendingNotificationCount,
+        notification_timer_present: Boolean(ap.notificationTimer)
       }));
       return true;
     }
@@ -7283,11 +7562,17 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (reason !== "turn_end") {
       if (ap.gatedSteering.toolBoundaryFlushDisabled) return false;
       if (ap.gatedSteering.compacting || ap.gatedSteering.outstandingToolUses > 0) return false;
+      this.recordGatedSteeringEvent(agentId, ap, "notify", { reason, pendingMessages: ap.inbox.length });
+      return this.sendStdinNotification(agentId);
     }
     const pendingMessages = ap.inbox.length;
     const pendingNotificationCount = ap.pendingNotificationCount;
     const nextMessages = ap.inbox.splice(0, ap.inbox.length);
     ap.pendingNotificationCount = 0;
+    if (ap.notificationTimer) {
+      clearTimeout(ap.notificationTimer);
+      ap.notificationTimer = null;
+    }
     ap.gatedSteering.lastFlushReason = reason;
     if (reason !== "turn_end") {
       ap.gatedSteering.inFlightBatch = {
@@ -7315,28 +7600,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   }
   flushCompactionBoundaryMessages(agentId, ap) {
     if (!ap.sessionId || !ap.driver.supportsStdinNotification || ap.inbox.length === 0) return false;
-    if (ap.driver.busyDeliveryMode === "gated") {
-      return this.tryFlushGatedSteering(agentId, ap, "compaction_finished");
-    }
-    if (ap.driver.busyDeliveryMode === "direct") {
-      const pendingMessages = ap.inbox.length;
-      const pendingNotificationCount = ap.pendingNotificationCount;
-      const nextMessages = ap.inbox.splice(0, ap.inbox.length);
-      ap.pendingNotificationCount = 0;
-      if (ap.notificationTimer) {
-        clearTimeout(ap.notificationTimer);
-        ap.notificationTimer = null;
-      }
-      this.recordRuntimeTraceEvent(agentId, ap, "runtime.compaction_boundary.flush", {
-        mode: "direct",
-        messageCount: nextMessages.length
-      });
-      if (this.deliverMessagesViaStdin(agentId, ap, nextMessages, "busy")) {
-        return true;
-      }
-      ap.pendingNotificationCount += pendingNotificationCount || pendingMessages;
-      return false;
-    }
     if (ap.pendingNotificationCount > 0) {
       if (ap.notificationTimer) {
         clearTimeout(ap.notificationTimer);
@@ -7555,6 +7818,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
             const nextMessages = ap.inbox.splice(0, ap.inbox.length);
             ap.pendingNotificationCount = 0;
+            if (ap.notificationTimer) {
+              clearTimeout(ap.notificationTimer);
+              ap.notificationTimer = null;
+            }
             if (ap.driver.busyDeliveryMode === "gated") {
               ap.gatedSteering.lastFlushReason = "turn_end";
               this.recordGatedSteeringEvent(agentId, ap, "flush", {
@@ -7698,13 +7965,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   /** Send a batched notification to the agent via stdin about pending messages */
   sendStdinNotification(agentId) {
     const ap = this.agents.get(agentId);
-    if (!ap) return;
+    if (!ap) return false;
     const count = ap.pendingNotificationCount;
     ap.pendingNotificationCount = 0;
-    ap.notificationTimer = null;
-    if (count === 0) return;
-    if (ap.isIdle) return;
-    if (!ap.sessionId) return;
+    if (ap.notificationTimer) {
+      clearTimeout(ap.notificationTimer);
+      ap.notificationTimer = null;
+    }
+    if (count === 0) return false;
+    if (ap.isIdle) return false;
+    if (!ap.sessionId) return false;
     if (ap.gatedSteering.compacting) {
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.compaction_boundary.delivery_suppressed", {
         pendingNotificationCount: count,
@@ -7715,30 +7985,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       logger.info(
         `[Agent ${agentId}] Suppressing stdin delivery until context compaction finishes; pending=${ap.inbox.length}`
       );
-      return;
-    }
-    if (ap.driver.busyDeliveryMode === "gated") {
-      this.recordGatedSteeringEvent(agentId, ap, "suppress", {
-        reason: "timer_notification_not_safe_boundary",
-        pendingNotificationCount: count
-      });
-      ap.pendingNotificationCount += count;
-      logger.info(
-        `[Agent ${agentId}] Suppressing raw busy stdin notification until Claude gated steering boundary; pending=${ap.inbox.length}`
-      );
-      return;
-    }
-    if (ap.driver.busyDeliveryMode === "direct" && ap.inbox.length > 0) {
-      const queuedMessages = ap.inbox.splice(0, ap.inbox.length);
-      console.log(`[Agent ${agentId}] Delivering queued message via stdin while busy`);
-      if (this.deliverMessagesViaStdin(agentId, ap, queuedMessages, "busy")) {
-        return;
-      }
-      ap.pendingNotificationCount += count;
-      return;
+      return false;
     }
-    const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call check_messages to read ${count > 1 ? "them" : "it"} when you're ready.]`;
-    logger.info(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
+    const inboxCount = ap.inbox.length;
+    if (inboxCount === 0) return false;
+    const notification = `[System notification: You have ${inboxCount} pending inbox message${inboxCount > 1 ? "s" : ""}. Call check_messages to read ${inboxCount > 1 ? "them" : "it"} when you're ready.]`;
+    logger.info(`[Agent ${agentId}] Sending stdin notification: ${inboxCount} pending inbox message(s)`);
     const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     if (encoded) {
       ap.process.stdin?.write(encoded + "\n");
@@ -7750,9 +8002,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         outcome: "written",
         mode: "busy",
         pending_notification_count: count,
+        inbox_count: inboxCount,
         session_id_present: true
       });
+      return true;
     } else {
+      ap.pendingNotificationCount += count;
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -7761,8 +8016,10 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         outcome: "encode_failed",
         mode: "busy",
         pending_notification_count: count,
+        inbox_count: inboxCount,
         session_id_present: true
       }, "error");
+      return false;
     }
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
@@ -7998,10 +8255,12 @@ var DaemonConnection = class {
         messageKind = msg.type;
         this.markInbound(messageKind);
         this.resetWatchdog();
-        this.trace("daemon.connection.inbound_received", {
-          message_type: messageKind,
-          last_inbound_age_ms_bucket: "0"
-        });
+        if (messageKind !== "ping") {
+          this.trace("daemon.connection.inbound_received", {
+            message_type: messageKind,
+            last_inbound_age_ms_bucket: "0"
+          });
+        }
         this.options.onMessage(msg);
       } catch (err) {
         this.markInbound("invalid_json");

package/dist/cli/index.js

@@ -14832,69 +14832,6 @@ function registerThreadUnfollowCommand(parent) {
   });
 }
 
-// src/commands/message/_continueDraftState.ts
-import fs2 from "fs";
-import os from "os";
-import path from "path";
-var DEFAULT_LOCAL_DRAFT_TTL_MS = 10 * 60 * 1e3;
-function stateFilePath(agentId) {
-  return path.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
-}
-function readState(agentId) {
-  const filePath = stateFilePath(agentId);
-  try {
-    const raw = fs2.readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    return typeof parsed === "object" && parsed ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function writeState(agentId, state) {
-  const filePath = stateFilePath(agentId);
-  fs2.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs2.writeFileSync(filePath, JSON.stringify(state), "utf8");
-}
-function getSavedDraft(agentId, target) {
-  const state = readState(agentId);
-  const draft = state.targets?.[target];
-  if (!draft || typeof draft === "string") return null;
-  if (typeof draft.content !== "string") return null;
-  const attachmentIds = Array.isArray(draft.attachmentIds) ? draft.attachmentIds.filter((item) => typeof item === "string") : [];
-  const savedAt = Number.isFinite(draft.savedAt) ? draft.savedAt : Date.now();
-  const reholdCount = Number.isFinite(draft.reholdCount) ? draft.reholdCount : 0;
-  const seenUpToSeq = Number.isFinite(draft.seenUpToSeq) ? draft.seenUpToSeq : void 0;
-  if (Date.now() - savedAt > DEFAULT_LOCAL_DRAFT_TTL_MS) {
-    clearSavedDraft(agentId, target);
-    return null;
-  }
-  return {
-    content: draft.content,
-    attachmentIds,
-    savedAt,
-    reholdCount,
-    seenUpToSeq
-  };
-}
-function setSavedDraft(agentId, target, draft) {
-  const state = readState(agentId);
-  const targets = state.targets ?? {};
-  targets[target] = {
-    content: draft.content,
-    attachmentIds: draft.attachmentIds,
-    savedAt: draft.savedAt,
-    reholdCount: draft.reholdCount,
-    ...draft.seenUpToSeq !== void 0 ? { seenUpToSeq: draft.seenUpToSeq } : {}
-  };
-  writeState(agentId, { targets });
-}
-function clearSavedDraft(agentId, target) {
-  const state = readState(agentId);
-  if (!state.targets || !(target in state.targets)) return;
-  delete state.targets[target];
-  writeState(agentId, state);
-}
-
 // src/commands/message/_format.ts
 function toLocalTime(iso) {
   const d = new Date(iso);
@@ -14938,7 +14875,13 @@ function formatMessages(messages) {
   if (messages.length === 0) return "No new messages.";
   return messages.map(formatMessageLine).join("\n");
 }
-function formatHistoryMessageLine(m) {
+function buildReplyTarget(channel, messageId) {
+  if (!messageId) return null;
+  const isThreadTarget = /^#[^:]+:[0-9a-f]{8}$/i.test(channel) || /^dm:@[^:]+:[0-9a-f]{8}$/i.test(channel);
+  if (isThreadTarget) return null;
+  return `${channel}:${messageId.slice(0, 8)}`;
+}
+function formatHistoryMessageLine(channel, m) {
   const senderName = m.senderName ?? m.sender_name ?? "unknown";
   const senderDescription = m.senderDescription ?? m.sender_description ?? null;
   const messageId = m.id ?? m.message_id ?? "-";
@@ -14952,6 +14895,10 @@ function formatHistoryMessageLine(m) {
   if (senderType) headerParts.push(`type=${senderType}`);
   if (m.threadId) headerParts.push(`threadId=${m.threadId}`);
   if ((m.replyCount ?? 0) > 0) headerParts.push(`replyCount=${m.replyCount}`);
+  if (m.threadId || (m.replyCount ?? 0) > 0) {
+    const replyTarget = buildReplyTarget(channel, messageId);
+    if (replyTarget) headerParts.push(`replyTarget=${replyTarget}`);
+  }
   const attachSuffix = formatAttachmentSuffix(m.attachments);
   const taskSuffix = m.taskStatus ? ` [task #${m.taskNumber} status=${m.taskStatus}${m.taskAssigneeId ? ` assignee=${m.taskAssigneeType}:${m.taskAssigneeId}` : ""}]` : "";
   const handle = senderDescription ? `@${senderName} \u2014 ${senderDescription}` : `@${senderName}`;
@@ -14959,7 +14906,7 @@ function formatHistoryMessageLine(m) {
 }
 function formatHistory(channel, data, opts) {
   if (!data.messages || data.messages.length === 0) return "No messages in this channel.";
-  const formatted = data.messages.map((m) => formatHistoryMessageLine({
+  const formatted = data.messages.map((m) => formatHistoryMessageLine(channel, {
     ...m,
     senderName: m.senderName ?? m.sender_name ?? "unknown",
     senderDescription: m.senderDescription ?? m.sender_description ?? null
@@ -15030,6 +14977,91 @@ thread: ${result.parentChannelName} -> ${target}` : "";
 ${formatted}`;
 }
 
+// src/commands/freshnessHold.ts
+function isFreshnessHeldResponse(data) {
+  return Boolean(data && typeof data === "object" && data.state === "held");
+}
+function formatFreshnessHoldOutput(target, data, opts) {
+  const newMessageCount = data.newMessageCount ?? 0;
+  const shownMessageCount = data.shownMessageCount ?? data.heldMessages?.length ?? 0;
+  const omittedMessageCount = data.omittedMessageCount ?? Math.max(0, newMessageCount - shownMessageCount);
+  const heldHistory = data.heldMessages && data.heldMessages.length > 0 ? `
+
+${formatHistory(target, { messages: data.heldMessages })}` : "";
+  const mentionNote = (data.mentionAnnotation?.formalMentionCount ?? 0) > 0 ? `
+
+Note: ${data.mentionAnnotation.formalMentionCount} of these messages formally @mention you.` : "";
+  const omittedNote = omittedMessageCount > 0 ? ` ${omittedMessageCount} earlier same-target message${omittedMessageCount === 1 ? "" : "s"} omitted from this notice and no longer block this action; use slock message read explicitly if you need earlier context.` : "";
+  const continueAnyway = data.continueAnywaySuggested && opts.continueAnywayInstruction ? opts.continueAnywayInstruction : "";
+  return `Freshness hold: showing latest ${shownMessageCount} of ${newMessageCount} newer message${newMessageCount === 1 ? "" : "s"}.${omittedNote}
+${opts.heldAction} Review the bounded context shown here, then choose one path.${mentionNote}${heldHistory}
+
+` + (opts.draftInstructions ?? "") + continueAnyway;
+}
+
+// src/commands/message/_continueDraftState.ts
+import fs2 from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_LOCAL_DRAFT_TTL_MS = 10 * 60 * 1e3;
+function stateFilePath(agentId) {
+  return path.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
+}
+function readState(agentId) {
+  const filePath = stateFilePath(agentId);
+  try {
+    const raw = fs2.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeState(agentId, state) {
+  const filePath = stateFilePath(agentId);
+  fs2.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, JSON.stringify(state), "utf8");
+}
+function getSavedDraft(agentId, target) {
+  const state = readState(agentId);
+  const draft = state.targets?.[target];
+  if (!draft || typeof draft === "string") return null;
+  if (typeof draft.content !== "string") return null;
+  const attachmentIds = Array.isArray(draft.attachmentIds) ? draft.attachmentIds.filter((item) => typeof item === "string") : [];
+  const savedAt = Number.isFinite(draft.savedAt) ? draft.savedAt : Date.now();
+  const reholdCount = Number.isFinite(draft.reholdCount) ? draft.reholdCount : 0;
+  const seenUpToSeq = Number.isFinite(draft.seenUpToSeq) ? draft.seenUpToSeq : void 0;
+  if (Date.now() - savedAt > DEFAULT_LOCAL_DRAFT_TTL_MS) {
+    clearSavedDraft(agentId, target);
+    return null;
+  }
+  return {
+    content: draft.content,
+    attachmentIds,
+    savedAt,
+    reholdCount,
+    seenUpToSeq
+  };
+}
+function setSavedDraft(agentId, target, draft) {
+  const state = readState(agentId);
+  const targets = state.targets ?? {};
+  targets[target] = {
+    content: draft.content,
+    attachmentIds: draft.attachmentIds,
+    savedAt: draft.savedAt,
+    reholdCount: draft.reholdCount,
+    ...draft.seenUpToSeq !== void 0 ? { seenUpToSeq: draft.seenUpToSeq } : {}
+  };
+  writeState(agentId, { targets });
+}
+function clearSavedDraft(agentId, target) {
+  const state = readState(agentId);
+  if (!state.targets || !(target in state.targets)) return;
+  delete state.targets[target];
+  writeState(agentId, state);
+}
+
 // src/commands/message/send.ts
 var SendContentError = class extends Error {
   constructor(code, message) {
@@ -15124,28 +15156,19 @@ function rejectSendDraftStdin(content, target) {
   );
 }
 function formatHeldSendOutput(target, data) {
-  const newMessageCount = data.newMessageCount ?? 0;
-  const shownMessageCount = data.shownMessageCount ?? data.heldMessages?.length ?? 0;
-  const omittedMessageCount = data.omittedMessageCount ?? Math.max(0, newMessageCount - shownMessageCount);
-  const heldHistory = data.heldMessages && data.heldMessages.length > 0 ? `
-
-${formatHistory(target, { messages: data.heldMessages })}` : "";
-  const mentionNote = (data.mentionAnnotation?.formalMentionCount ?? 0) > 0 ? `
-
-Note: ${data.mentionAnnotation.formalMentionCount} of these messages formally @mention you.` : "";
-  const omittedNote = omittedMessageCount > 0 ? ` ${omittedMessageCount} additional newer message${omittedMessageCount === 1 ? "" : "s"} omitted from this notice; use slock message read explicitly if you need more context.` : "";
-  return `Freshness hold: showing latest ${shownMessageCount} of ${newMessageCount} newer message${newMessageCount === 1 ? "" : "s"}.${omittedNote}
-Your message has been saved as a draft. Review the bounded context shown here, then choose one path.${mentionNote}${heldHistory}
-
-To update the draft, send revised content normally:
+  return formatFreshnessHoldOutput(target, data, {
+    heldAction: "Your message has been saved as a draft.",
+    draftInstructions: `To update the draft, send revised content normally:
   slock message send --target "${target}" <<'EOF'
   revised message
   EOF
 To send the current draft unchanged:
   slock message send --send-draft --target "${target}"
-` + (data.continueAnywaySuggested ? `If repeated updates keep blocking the same draft and this is still the right reply, you may use:
+`,
+    continueAnywayInstruction: `If repeated updates keep blocking the same draft and this is still the right reply, you may use:
   slock message send --send-draft --anyway --target "${target}"
-` : "");
+`
+  });
 }
 function registerSendCommand(parent) {
   parent.command("send").description("Send a message to a channel, DM, or thread").argument("[content...]", "Unsupported positional message content. Pipe content to stdin instead.").requiredOption("--target <target>", "Target: '#channel', 'dm:@peer', '#channel:threadId', 'dm:@peer:threadId'").option("--send-draft", "Send the current saved draft after reviewing newer messages").option("--anyway", "Escape hatch: send a saved draft even if freshness re-check is still stale").option("--content <content>", "Unsupported. Pipe message content to stdin instead.").option(
@@ -15799,6 +15822,13 @@ function registerTaskClaimCommand(parent) {
       const code = res.status >= 500 ? "SERVER_5XX" : "CLAIM_FAILED";
       fail(code, res.error ?? `HTTP ${res.status}`);
     }
+    if (isFreshnessHeldResponse(res.data)) {
+      process.stdout.write(formatFreshnessHoldOutput(opts.channel, res.data, {
+        heldAction: "Your task claim was not applied.",
+        draftInstructions: "After reviewing the newer context, rerun the task claim command if it is still correct.\n"
+      }));
+      return;
+    }
     process.stdout.write(formatClaimResults(opts.channel, res.data) + "\n");
   });
 }
@@ -15865,6 +15895,13 @@ function registerTaskUpdateCommand(parent) {
       const code = res.status >= 500 ? "SERVER_5XX" : "UPDATE_FAILED";
       fail(code, res.error ?? `HTTP ${res.status}`);
     }
+    if (isFreshnessHeldResponse(res.data)) {
+      process.stdout.write(formatFreshnessHoldOutput(opts.channel, res.data, {
+        heldAction: "Your task status update was not applied.",
+        draftInstructions: "After reviewing the newer context, rerun the task update command if it is still correct.\n"
+      }));
+      return;
+    }
     process.stdout.write(formatTaskStatusUpdated(n, opts.status) + "\n");
   });
 }

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-JDSI7JD5.js";
+} from "./chunk-WGO5H7XX.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-KNMCE6WB.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-JDSI7JD5.js";
+} from "./chunk-WGO5H7XX.js";
 import "./chunk-KNMCE6WB.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.51.1",
+  "version": "0.52.1",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"