sentinelayer-cli 0.30.8 → 0.30.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.30.8",
+  "version": "0.30.10",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {

package/src/commands/session.js

@@ -138,6 +138,49 @@ function normalizeString(value) {
   return String(value || "").trim();
 }
 
+function messagePartsHaveContent(messageParts) {
+  const parts = Array.isArray(messageParts) ? messageParts : [messageParts];
+  return parts.some((part) => normalizeString(part));
+}
+
+function joinMessageParts(messageParts) {
+  if (Array.isArray(messageParts)) {
+    return messageParts.length === 1 ? String(messageParts[0] || "") : messageParts.join(" ");
+  }
+  return String(messageParts || "");
+}
+
+async function readUtf8FromStdin(stdin = process.stdin) {
+  if (stdin.isTTY) {
+    throw new Error("--stdin requires piped input.");
+  }
+  stdin.setEncoding("utf8");
+  let text = "";
+  for await (const chunk of stdin) {
+    text += String(chunk);
+  }
+  return text;
+}
+
+async function resolveSessionSayMessageInput(messageParts, options = {}) {
+  const hasPositionalMessage = messagePartsHaveContent(messageParts);
+  const hasMessageFile = Boolean(normalizeString(options.messageFile));
+  const hasStdin = Boolean(options.stdin);
+  const sources = [hasPositionalMessage, hasMessageFile, hasStdin].filter(Boolean).length;
+  if (sources > 1) {
+    throw new Error("Use only one message source: positional message, --message-file, or --stdin.");
+  }
+  if (hasMessageFile) {
+    return normalizeString(
+      await fsp.readFile(path.resolve(process.cwd(), String(options.messageFile)), "utf-8"),
+    );
+  }
+  if (hasStdin) {
+    return normalizeString(await readUtf8FromStdin());
+  }
+  return normalizeString(joinMessageParts(messageParts));
+}
+
 function optionWasSetByCli(command, optionName) {
   if (!command || typeof command.getOptionValueSource !== "function") {
     return false;
@@ -3343,7 +3386,7 @@ export function registerSessionCommand(program) {
     });
 
   session
-    .command("say <sessionId> <message>")
+    .command("say <sessionId> [message...]")
     .description("Send a message to the session")
     .option(
       "--agent <id>",
@@ -3367,16 +3410,18 @@ export function registerSessionCommand(program) {
     .option("--to <agent>", "Direct the message to a specific agent id")
     .option("--reply-to <sequence>", "Mark this message as a reply to a target sequence id")
     .option("--reply-cursor <cursor>", "Mark this message as a reply to a target event cursor")
+    .option("--message-file <path>", "Read the message body from a UTF-8 file")
+    .option("--stdin", "Read the message body from stdin")
     .option("--force-cli-user", "Allow fallback sends as cli-user when no agent identity can be resolved")
     .option("--local-only", "Append only to the local session cache without remote send confirmation")
     .option("--path <path>", "Workspace path for the session", ".")
     .option("--json", "Emit machine-readable output")
-    .action(async (sessionId, message, options, command) => {
+    .action(async (sessionId, messageParts, options, command) => {
       const normalizedSessionId = normalizeString(sessionId);
       if (!normalizedSessionId) {
         throw new Error("session id is required.");
       }
-      const normalizedMessage = normalizeString(message);
+      const normalizedMessage = await resolveSessionSayMessageInput(messageParts, options);
       if (!normalizedMessage) {
         throw new Error("message is required.");
       }
@@ -4324,8 +4369,9 @@ export function registerSessionCommand(program) {
       const durablePresenceEnabled = options.presence !== false;
       const publishPresence = durablePresenceEnabled && canPublishListenerPresence(agentId);
       const presenceIntervalMs = Math.max(1, presenceIntervalSeconds) * 1000;
-      const presenceKeepaliveMs =
-        Math.max(presenceIntervalSeconds, presenceKeepaliveSeconds, 1) * 1000;
+      const effectivePresenceKeepaliveSeconds =
+        Math.max(presenceIntervalSeconds, presenceKeepaliveSeconds, intervalSeconds, 1);
+      const presenceKeepaliveMs = effectivePresenceKeepaliveSeconds * 1000;
       let lastPresenceHeartbeatMs = 0;
       let lastPresenceHeartbeatFingerprint = "";
 
@@ -4512,7 +4558,7 @@ export function registerSessionCommand(program) {
             const publishLifecycle = {
               ...lifecycle,
               presenceIntervalSeconds,
-              presenceKeepaliveSeconds: Math.max(presenceIntervalSeconds, presenceKeepaliveSeconds),
+              presenceKeepaliveSeconds: effectivePresenceKeepaliveSeconds,
             };
             if (lifecycleType === "heartbeat") {
               const nowMs = Date.now();

package/src/session/listeners.js

@@ -9,6 +9,7 @@ const LISTENER_EVENT_TYPES = new Set([
 // A heartbeat older than this (and not explicitly stopped) means the
 // listener likely died without a clean stop — show it as stale, not live.
 const DEFAULT_STALE_AFTER_MS = 180_000;
+const MAX_STALE_GRACE_MS = 60_000;
 
 function normalizeString(value) {
   return String(value || "").trim();
@@ -29,6 +30,38 @@ function positiveInt(value) {
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
 }
 
+function listenerStaleAfterMs({
+  staleAfterMs,
+  presenceKeepaliveSeconds,
+  presenceIntervalSeconds,
+  cadenceSeconds,
+  idleIntervalSeconds,
+  activeIntervalSeconds,
+} = {}) {
+  const fallbackMs = Math.max(1, Number(staleAfterMs) || DEFAULT_STALE_AFTER_MS);
+  const keepaliveMs = presenceKeepaliveSeconds ? presenceKeepaliveSeconds * 1000 : null;
+  const expectedIntervalSeconds =
+    cadenceSeconds ||
+    presenceIntervalSeconds ||
+    idleIntervalSeconds ||
+    activeIntervalSeconds ||
+    null;
+  const expectedIntervalMs = expectedIntervalSeconds ? expectedIntervalSeconds * 1000 : 0;
+
+  if (keepaliveMs) {
+    // The listener can only publish on a poll tick. Allow one bounded poll
+    // interval after the advertised keepalive, not the old 2.5x keepalive
+    // window that made dead listeners look live for several extra minutes.
+    return keepaliveMs + Math.min(expectedIntervalMs || 0, MAX_STALE_GRACE_MS);
+  }
+
+  if (expectedIntervalMs) {
+    return Math.max(fallbackMs, Math.round(expectedIntervalMs * 2.5));
+  }
+
+  return fallbackMs;
+}
+
 /**
  * Reduce a stream of session_listener_* events into one row per agent: who is
  * listening, at what cadence, and whether they're currently active or idle.
@@ -66,17 +99,14 @@ export function summarizeListeners(events = [], { nowMs = Date.now(), staleAfter
     const cadenceSeconds = active
       ? activeIntervalSeconds || nextPollSeconds
       : idleIntervalSeconds || nextPollSeconds;
-    const expectedPresenceSeconds =
-      presenceKeepaliveSeconds ||
-      presenceIntervalSeconds ||
-      cadenceSeconds ||
-      idleIntervalSeconds ||
-      activeIntervalSeconds ||
-      null;
-    const staleAfterForRowMs = Math.max(
+    const staleAfterForRowMs = listenerStaleAfterMs({
       staleAfterMs,
-      expectedPresenceSeconds ? expectedPresenceSeconds * 2_500 : 0,
-    );
+      presenceKeepaliveSeconds,
+      presenceIntervalSeconds,
+      cadenceSeconds,
+      idleIntervalSeconds,
+      activeIntervalSeconds,
+    });
     let status;
     if (stopped) status = "stopped";
     else if (ageMs !== null && ageMs > staleAfterForRowMs) status = "stale";
@@ -94,6 +124,7 @@ export function summarizeListeners(events = [], { nowMs = Date.now(), staleAfter
       presenceIntervalSeconds,
       presenceKeepaliveSeconds,
       nextPollSeconds,
+      staleAfterSeconds: Math.round(staleAfterForRowMs / 1000),
       lastSeenAt: epoch ? new Date(epoch).toISOString() : null,
       lastSeenAgoSeconds: ageMs !== null ? Math.round(ageMs / 1000) : null,
       lastHumanActivityAt: normalizeString(payload.lastHumanActivityAt) || null,