sentinelayer-cli 0.31.3 → 0.31.5

package/package.json

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

package/src/ai/client.js

@@ -146,6 +146,70 @@ function extractTextFromResponse(provider, payload) {
   return "";
 }
 
+function normalizeUsageNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return 0;
+  }
+  return Math.floor(parsed);
+}
+
+function buildUsagePayload({ provider, model, inputTokens = 0, outputTokens = 0, totalTokens = 0 } = {}) {
+  const input = normalizeUsageNumber(inputTokens);
+  const output = normalizeUsageNumber(outputTokens);
+  const total = normalizeUsageNumber(totalTokens) || input + output;
+  if (total <= 0 && input + output <= 0) {
+    return null;
+  }
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: total,
+    model,
+    provider,
+  };
+}
+
+function extractUsageFromResponse(provider, payload, model) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+
+  if (provider === "openai") {
+    const usage = payload.usage || {};
+    return buildUsagePayload({
+      provider,
+      model,
+      inputTokens: usage.prompt_tokens ?? usage.input_tokens,
+      outputTokens: usage.completion_tokens ?? usage.output_tokens,
+      totalTokens: usage.total_tokens,
+    });
+  }
+
+  if (provider === "anthropic") {
+    const usage = payload.usage || {};
+    return buildUsagePayload({
+      provider,
+      model,
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+    });
+  }
+
+  if (provider === "google") {
+    const usage = payload.usageMetadata || payload.usage_metadata || {};
+    return buildUsagePayload({
+      provider,
+      model,
+      inputTokens: usage.promptTokenCount ?? usage.prompt_token_count,
+      outputTokens: usage.candidatesTokenCount ?? usage.candidates_token_count,
+      totalTokens: usage.totalTokenCount ?? usage.total_token_count,
+    });
+  }
+
+  return null;
+}
+
 function buildProviderRequest({ provider, apiKey, model, prompt, stream }) {
   const normalizedProvider = normalizeProvider(provider);
   const normalizedPrompt = normalizePrompt(prompt);
@@ -527,6 +591,13 @@ export class MultiProviderApiClient {
         } else {
           const payload = await response.json();
           text = extractTextFromResponse(resolvedProvider, payload);
+          const usage = extractUsageFromResponse(resolvedProvider, payload, resolvedModel);
+          return {
+            provider: resolvedProvider,
+            model: resolvedModel,
+            text,
+            usage: usage || undefined,
+          };
         }
 
         return {

package/src/session/daemon.js

@@ -44,6 +44,7 @@ import { stopRuntimeRunsForSession } from "./runtime-bridge.js";
 import { getSession, renewSession } from "./store.js";
 import { appendToStream, readStream, tailStream } from "./stream.js";
 import { handleTaskDirective } from "./tasks.js";
+import { emitLLMInteraction } from "./usage.js";
 
 const DAEMON_TICK_INTERVAL_MS = 30_000;
 const HELP_REQUEST_TIMEOUT_MS = 1_200;
@@ -653,6 +654,28 @@ async function maybeRespondToHelpRequest(
       nowIso,
     }
   );
+  if (normalizeUsageNumber(response.usage.inputTokens) + normalizeUsageNumber(response.usage.outputTokens) > 0) {
+    // The managed proxy already records the durable API billing/v1 row for
+    // this same idempotency key. Keep this copy local for immediate transcript
+    // and recap usage without double-counting Session.total_cost_usd remotely.
+    await emitLLMInteraction(daemonState.sessionId, {
+      agentId: SENTI_IDENTITY.id,
+      agentModel: response.usage.model || daemonState.model,
+      role: SENTI_IDENTITY.role,
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      costUsd: response.usage.costUsd,
+      durationMs: response.usage.latencyMs,
+      action: "proxy_llm",
+      provider: response.usage.provider || "sentinelayer",
+      billingTier: "internal",
+      prompt: normalizeString(requestEvent?.payload?.message) || normalizeString(requestEvent?.payload?.request),
+      response: response.message,
+      interactionId: `senti:${daemonState.sessionId}:help:${requestId}`,
+      targetPath,
+      syncRemote: false,
+    });
+  }
   return responseEvent;
 }
 

package/src/session/recap.js

@@ -4,6 +4,7 @@ import process from "node:process";
 
 import { createAgentEvent } from "../events/schema.js";
 import { dedupeSessionEvents } from "./event-identity.js";
+import { summarizeListeners } from "./listeners.js";
 import { resolveSessionPaths } from "./paths.js";
 import { appendToStream, readStream } from "./stream.js";
 import { getSession } from "./store.js";
@@ -28,6 +29,10 @@ const RECAP_SOURCE_IGNORED_EVENTS = new Set([
   "daemon_alert",
   "session_ack",
   "session_checkpoint",
+  "session_listen_error",
+  "session_listener_heartbeat",
+  "session_listener_started",
+  "session_listener_stopped",
   "session_reaction",
   "session_recap",
   "session_usage",
@@ -648,7 +653,9 @@ function buildRecapKey(sessionId, targetPath) {
 }
 
 function buildRecapText({
-  activeAgents = [],
+  recentActors = [],
+  liveListeners = [],
+  listenerCount = 0,
   totalFindings = 0,
   activeLocks = 0,
   pendingTasks = 0,
@@ -657,10 +664,20 @@ function buildRecapText({
   usageSummary = normalizeUsageSummary(),
   snippets = [],
 } = {}) {
-  const agentText =
-    activeAgents.length > 0
-      ? `${activeAgents.length} active (${activeAgents.slice(0, 3).join(", ")})`
-      : "no active peers yet";
+  const listenerText =
+    liveListeners.length > 0
+      ? `${liveListeners.length} live listener${liveListeners.length === 1 ? "" : "s"} (${liveListeners
+          .slice(0, 3)
+          .join(", ")})`
+      : listenerCount > 0
+        ? "no live listeners"
+        : "listener status unknown";
+  const actorText =
+    recentActors.length > 0
+      ? `${recentActors.length} recent actor${recentActors.length === 1 ? "" : "s"} (${recentActors
+          .slice(0, 3)
+          .join(", ")})`
+      : "no recent peer activity";
   const findingText = `${totalFindings} finding${totalFindings === 1 ? "" : "s"} logged`;
   const lockText = `${activeLocks} file lock${activeLocks === 1 ? "" : "s"} active`;
   const pendingText =
@@ -669,7 +686,7 @@ function buildRecapText({
   const usageText = buildUsageLedgerText(usageSummary);
   const workPlanText = buildWorkPlanText(workPlan);
   const snippetText = snippets.length > 0 ? `Recent: ${snippets.join(" | ")}` : "";
-  return `While you were away: ${agentText}. ${findingText}. ${lockText}. ${pendingText} ${taskText}. ${workPlanText} ${usageText} ${snippetText}`.replace(
+  return `While you were away: ${listenerText}; ${actorText}. ${findingText}. ${lockText}. ${pendingText} ${taskText}. ${workPlanText} ${usageText} ${snippetText}`.replace(
     /\s+/g,
     " "
   ).trim();
@@ -840,18 +857,27 @@ function buildAgentJoinBriefingText({ recap = "", forAgent = "" } = {}) {
 function buildPeriodicText(recap = {}) {
   const summary = recap.summary && typeof recap.summary === "object" ? recap.summary : {};
   const elapsedMinutes = Number(summary.elapsedMinutes || 0);
-  const activeAgents = Number(summary.activeAgents || 0);
+  const recentActors = Number(summary.recentActors ?? summary.activeAgents ?? 0);
+  const liveListeners = Number(summary.liveListeners ?? summary.liveListenerCount ?? 0);
+  const listenerCount = Number(summary.listenerCount || 0);
   const totalFindings = Number(summary.totalFindingsCount || 0);
   const activeLocks = Number(summary.activeLocks || 0);
   const lastActor = normalizeString(summary.lastActorId);
   const actorText = lastActor ? `${lastActor} active` : "no active actor";
+  const listenerText =
+    liveListeners > 0
+      ? `${liveListeners} live listener${liveListeners === 1 ? "" : "s"}`
+      : listenerCount > 0
+        ? "no live listeners"
+        : "listener status unknown";
+  const recentActorText = `${recentActors} recent actor${recentActors === 1 ? "" : "s"}`;
   const taskText = buildTaskLedgerText(summary.taskLedger);
   const workPlanText = buildWorkPlanText(summary.workPlan);
   const usageText = buildUsageLedgerText({
     totals: summary.usageTotals,
     topAgents: summary.usageTopAgents,
   });
-  return `Session active for ${elapsedMinutes}m. ${activeAgents} agents. ${totalFindings} findings. ${activeLocks} locks. ${taskText}. ${workPlanText} ${usageText} ${actorText}.`.replace(
+  return `Session active for ${elapsedMinutes}m. ${listenerText}. ${recentActorText}. ${totalFindings} findings. ${activeLocks} locks. ${taskText}. ${workPlanText} ${usageText} ${actorText}.`.replace(
     /\s+/g,
     " ",
   ).trim();
@@ -899,19 +925,28 @@ export async function buildSessionRecap(
     return !normalizedForAgentId || agentId.toLowerCase() !== normalizedForAgentId.toLowerCase();
   });
 
-  const activeAgentSet = new Set();
-  for (const event of visibleEvents) {
+  const listenerRows = summarizeListeners(sortedEvents, {
+    nowMs: toEpoch(normalizedNow, normalizedNow),
+  });
+  const liveListenerRows = listenerRows.filter(
+    (row) => row.status === "active" || row.status === "idle",
+  );
+  const liveListenerIds = liveListenerRows.map((row) => row.agentId).filter(Boolean);
+
+  const actorEvents = visibleEvents.filter(isMeaningfulRecapSourceEvent);
+  const recentActorSet = new Set();
+  for (const event of actorEvents) {
     const agentId = normalizeString(event.agent?.id || event.agentId);
     if (agentId && agentId !== SENTI_AGENT_ID) {
-      activeAgentSet.add(agentId);
+      recentActorSet.add(agentId);
     }
   }
-  const activeAgents = [...activeAgentSet].sort((left, right) => left.localeCompare(right));
+  const recentActors = [...recentActorSet].sort((left, right) => left.localeCompare(right));
 
-  const findingSummary = buildFindingSummary(visibleEvents);
+  const findingSummary = buildFindingSummary(actorEvents);
   const totalFindingsCount =
     findingSummary.P0 + findingSummary.P1 + findingSummary.P2 + findingSummary.P3;
-  const activeLocks = countActiveLocks(visibleEvents);
+  const activeLocks = countActiveLocks(actorEvents);
   const pendingTasks = await readPendingTasks(normalizedSessionId, {
     forAgentId: normalizedForAgentId,
     targetPath: normalizedTargetPath,
@@ -922,17 +957,19 @@ export async function buildSessionRecap(
   const workPlan = await readWorkPlanSummary({
     targetPath: normalizedTargetPath,
   });
-  const snippets = summarizeRecentActivity(visibleEvents, {
+  const snippets = summarizeRecentActivity(actorEvents, {
     forAgentId: normalizedForAgentId,
     limit: 2,
   });
-  const windowElapsedMinutes = buildElapsedMinutes(visibleEvents, normalizedNow);
-  const elapsedMinutes = buildElapsedMinutes(visibleEvents, normalizedNow, {
+  const windowElapsedMinutes = buildElapsedMinutes(actorEvents, normalizedNow);
+  const elapsedMinutes = buildElapsedMinutes(actorEvents, normalizedNow, {
     startedAt: sessionMetadata?.createdAt,
   });
-  const latestEvent = visibleEvents.length > 0 ? visibleEvents[visibleEvents.length - 1] : null;
+  const latestEvent = actorEvents.length > 0 ? actorEvents[actorEvents.length - 1] : null;
   const recapText = buildRecapText({
-    activeAgents,
+    recentActors,
+    liveListeners: liveListenerIds,
+    listenerCount: listenerRows.length,
     totalFindings: totalFindingsCount,
     activeLocks,
     pendingTasks,
@@ -951,8 +988,17 @@ export async function buildSessionRecap(
     text: recapText,
     recap: recapText,
     summary: {
-      activeAgents: activeAgents.length,
-      activeAgentIds: activeAgents,
+      // Back-compat: historical consumers read activeAgents, but this count is
+      // recent transcript actors, not live listener presence.
+      activeAgents: recentActors.length,
+      activeAgentIds: recentActors,
+      recentActors: recentActors.length,
+      recentActorIds: recentActors,
+      liveListeners: liveListenerIds.length,
+      liveListenerIds,
+      liveListenerCount: liveListenerIds.length,
+      listenerCount: listenerRows.length,
+      listenerStatus: listenerRows,
       totalFindings: findingSummary,
       totalFindingsCount,
       activeLocks,

package/src/session/usage.js

@@ -111,6 +111,7 @@ function computedCost({ model, inputTokens, outputTokens }) {
  * @param {string} [params.response]          full response text (clipped)
  * @param {string} [params.interactionId]     opaque id for cross-event correlation
  * @param {string} [params.targetPath]        workspace path (default cwd)
+ * @param {boolean} [params.syncRemote]       sync local usage event to API (default true)
  * @returns {Promise<{ event: string, interactionId: string, totalTokens: number, costUsd: number }>}
  */
 export async function emitLLMInteraction(
@@ -132,6 +133,7 @@ export async function emitLLMInteraction(
     response = "",
     interactionId = "",
     targetPath = process.cwd(),
+    syncRemote = true,
   } = {},
 ) {
   const sid = n(sessionId);
@@ -219,7 +221,7 @@ export async function emitLLMInteraction(
     ts,
   });
 
-  await appendToStream(paths.sessionId, envelope, { targetPath });
+  await appendToStream(paths.sessionId, envelope, { targetPath, syncRemote });
   return {
     event: SESSION_USAGE_EVENT,
     interactionId: id,