sentinelayer-cli 0.11.3 → 0.11.4

package/package.json

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

package/src/commands/session.js

@@ -69,6 +69,7 @@ import { hydrateSessionFromRemote } from "../session/remote-hydrate.js";
 import { mergeLiveSources } from "../session/live-source.js";
 import { listenSessionEvents } from "../session/listener.js";
 import { buildSessionRecap } from "../session/recap.js";
+import { computeTranscriptStats } from "../session/transcript.js";
 import { deriveSessionTitle } from "../session/senti-naming.js";
 import { pushSessionTitleToApi } from "../session/title-sync.js";
 import {
@@ -96,6 +97,68 @@ function normalizeString(value) {
   return String(value || "").trim();
 }
 
+function compareIsoDesc(left = "", right = "") {
+  return normalizeString(right).localeCompare(normalizeString(left));
+}
+
+function buildSessionParticipants({ statsAgents = [], registeredAgents = [] } = {}) {
+  const byAgentId = new Map();
+  for (const agent of Array.isArray(statsAgents) ? statsAgents : []) {
+    const agentId = normalizeString(agent?.agentId || agent?.id);
+    if (!agentId) continue;
+    byAgentId.set(agentId, {
+      ...agent,
+      agentId,
+      registered: false,
+      source: "events",
+    });
+  }
+
+  for (const agent of Array.isArray(registeredAgents) ? registeredAgents : []) {
+    const agentId = normalizeString(agent?.agentId || agent?.id);
+    if (!agentId) continue;
+    const existing = byAgentId.get(agentId);
+    if (existing) {
+      byAgentId.set(agentId, {
+        ...existing,
+        model: existing.model || normalizeString(agent.model),
+        role: normalizeString(agent.role) || existing.role,
+        status: normalizeString(agent.status) || existing.status,
+        registered: true,
+        source: "events+registry",
+        joinedAt: normalizeString(agent.joinedAt) || existing.joinedAt,
+        lastActivityAt: normalizeString(agent.lastActivityAt) || existing.lastActivityAt,
+        active: agent.active,
+      });
+      continue;
+    }
+    byAgentId.set(agentId, {
+      agentId,
+      displayName: normalizeString(agent.displayName) || agentId,
+      model: normalizeString(agent.model),
+      role: normalizeString(agent.role),
+      status: normalizeString(agent.status),
+      firstSeen: normalizeString(agent.joinedAt) || null,
+      lastSeen: normalizeString(agent.lastActivityAt) || normalizeString(agent.joinedAt) || null,
+      joinedAt: normalizeString(agent.joinedAt) || null,
+      lastActivityAt: normalizeString(agent.lastActivityAt) || null,
+      active: agent.active,
+      eventCount: 0,
+      activeSeconds: 0,
+      tokens: 0,
+      costUsd: 0,
+      registered: true,
+      source: "registry",
+    });
+  }
+
+  return [...byAgentId.values()].sort((left, right) => {
+    const eventDelta = Number(right.eventCount || 0) - Number(left.eventCount || 0);
+    if (eventDelta !== 0) return eventDelta;
+    return compareIsoDesc(left.lastSeen || left.lastActivityAt, right.lastSeen || right.lastActivityAt);
+  });
+}
+
 function parsePositiveInteger(rawValue, field, fallbackValue) {
   if (rawValue === undefined || rawValue === null || String(rawValue).trim() === "") {
     return fallbackValue;
@@ -1291,6 +1354,8 @@ export function registerSessionCommand(program) {
         agentId: resolvedAgentId,
         model,
         role,
+        trackProcessExit: false,
+        awaitRemoteSync: Boolean(explicitAgent),
       });
       const agentJoinRelayed =
         Boolean(explicitAgent) &&
@@ -2269,12 +2334,23 @@ export function registerSessionCommand(program) {
           limit: 5_000,
         }),
       ]);
+      const stats = computeTranscriptStats({
+        sessionMeta: sessionPayload,
+        events,
+      });
+      const participants = buildSessionParticipants({
+        statsAgents: stats.agents,
+        registeredAgents: agents,
+      });
 
       let output;
       if (format === "ndjson") {
         const lines = [];
         lines.push(JSON.stringify({ kind: "session", value: sessionPayload }));
         for (const agent of agents) lines.push(JSON.stringify({ kind: "agent", value: agent }));
+        for (const participant of participants) {
+          lines.push(JSON.stringify({ kind: "participant", value: participant }));
+        }
         for (const event of events) lines.push(JSON.stringify({ kind: "event", value: event }));
         for (const task of tasks.tasks || []) lines.push(JSON.stringify({ kind: "task", value: task }));
         output = `${lines.join("\n")}\n`;
@@ -2285,13 +2361,18 @@ export function registerSessionCommand(program) {
             exportedAt: new Date().toISOString(),
             session: sessionPayload,
             agents,
+            participants,
             events,
             tasks: tasks.tasks || [],
             counts: {
-              agents: agents.length,
+              agents: participants.length,
+              participants: participants.length,
+              derivedAgents: stats.agents.length,
+              registeredAgents: agents.length,
               events: events.length,
               tasks: (tasks.tasks || []).length,
             },
+            totals: stats.totals,
           },
           null,
           2,
@@ -2305,7 +2386,7 @@ export function registerSessionCommand(program) {
         await fsp.writeFile(outPath, output, "utf-8");
         console.log(
           pc.gray(
-            `Exported ${events.length} events / ${agents.length} agents / ${
+            `Exported ${events.length} events / ${participants.length} participants (${agents.length} registered agents) / ${
               (tasks.tasks || []).length
             } tasks → ${outPath}`,
           ),
@@ -2399,6 +2480,10 @@ export function registerSessionCommand(program) {
           includeSystemEvents: options.systemEvents !== false,
         },
       });
+      const participants = buildSessionParticipants({
+        statsAgents: stats.agents,
+        registeredAgents: agents,
+      });
 
       const outArg = normalizeString(options.out);
       const outPath = outArg
@@ -2413,7 +2498,11 @@ export function registerSessionCommand(program) {
         outPath,
         bytes: Buffer.byteLength(markdown, "utf-8"),
         eventCount: events.length,
-        agentCount: agents.length,
+        agentCount: participants.length,
+        participantCount: participants.length,
+        derivedAgentCount: stats.agents.length,
+        registeredAgentCount: agents.length,
+        participants,
         sessionLiveSeconds: stats.sessionLiveSeconds,
         sentiActions: stats.sentiActions,
         totals: stats.totals,
@@ -2426,7 +2515,7 @@ export function registerSessionCommand(program) {
       console.log(pc.bold(`Downloaded session ${normalizedSessionId} → ${outPath}`));
       console.log(
         pc.gray(
-          `${events.length} events · ${agents.length} agents · live ${stats.sessionLiveSeconds}s · senti=${stats.sentiActions} · tokens=${stats.totals.tokenTotal} · cost=$${stats.totals.costTotalUsd.toFixed(4)}`,
+          `${events.length} events · ${participants.length} participants (${agents.length} registered agents) · live ${stats.sessionLiveSeconds}s · senti=${stats.sentiActions} · tokens=${stats.totals.tokenTotal} · cost=$${stats.totals.costTotalUsd.toFixed(4)}`,
         ),
       );
     });

package/src/session/agent-registry.js

@@ -156,14 +156,19 @@ async function writeAgentSnapshot(snapshotPath, snapshot) {
   await fsp.rename(tmpPath, snapshotPath);
 }
 
-async function emitAgentEvent(sessionId, event, payload, { targetPath = process.cwd() } = {}) {
+async function emitAgentEvent(
+  sessionId,
+  event,
+  payload,
+  { targetPath = process.cwd(), awaitRemoteSync = false } = {}
+) {
   const envelope = createAgentEvent({
     event,
     agentId: payload.agentId,
     sessionId,
     payload,
   });
-  await appendToStream(sessionId, envelope, { targetPath });
+  await appendToStream(sessionId, envelope, { targetPath, awaitRemoteSync });
 }
 
 function buildAgentSnapshotPath(paths, agentId) {
@@ -238,7 +243,14 @@ function _ensureExitHooksInstalled() {
 
 export async function registerAgent(
   sessionId,
-  { agentId = "", model = "", role = "observer", targetPath = process.cwd() } = {}
+  {
+    agentId = "",
+    model = "",
+    role = "observer",
+    targetPath = process.cwd(),
+    trackProcessExit = true,
+    awaitRemoteSync = false,
+  } = {}
 ) {
   const paths = resolveSessionPaths(sessionId, { targetPath });
   const nowIso = new Date().toISOString();
@@ -289,8 +301,10 @@ export async function registerAgent(
     model: snapshot.model,
     role: snapshot.role,
     status: snapshot.status,
-  }, { targetPath });
-  _trackLocalAgent(paths.sessionId, snapshot.agentId, targetPath);
+  }, { targetPath, awaitRemoteSync });
+  if (trackProcessExit) {
+    _trackLocalAgent(paths.sessionId, snapshot.agentId, targetPath);
+  }
 
   if (renamedFrom) {
     const welcome = buildSentiWelcome({
@@ -310,6 +324,7 @@ export async function registerAgent(
     await emitContextBriefing(paths.sessionId, {
       forAgentId: snapshot.agentId,
       targetPath,
+      awaitRemoteSync,
     }).catch(() => {});
   }
 

package/src/session/recap.js

@@ -559,6 +559,7 @@ export async function emitContextBriefing(
     targetPath = process.cwd(),
     nowIso = new Date().toISOString(),
     includeJoinRules = true,
+    awaitRemoteSync = false,
   } = {}
 ) {
   const recap = await buildSessionRecap(sessionId, {
@@ -588,6 +589,7 @@ export async function emitContextBriefing(
   });
   const persisted = await appendToStream(sessionId, event, {
     targetPath,
+    awaitRemoteSync,
   });
   return {
     recap,

package/src/session/remote-hydrate.js

@@ -166,14 +166,25 @@ async function pollSessionEventPages({
       };
     }
 
+    const pageEvents = Array.isArray(result.events) ? result.events : [];
     const nextCursor =
       typeof result.cursor === "string" && result.cursor.trim() ? result.cursor.trim() : cursor;
     const progressed = nextCursor && cursorAdvances(nextCursor, cursor);
+    if (nextCursor && cursor && !progressed && pageEvents.length === 0) {
+      return {
+        ok: true,
+        reason: "",
+        events,
+        cursor,
+        pageCount,
+        complete: true,
+        truncated: false,
+      };
+    }
     if (nextCursor && cursor && !progressed) {
       reason = "cursor_not_advanced";
       break;
     }
-    const pageEvents = Array.isArray(result.events) ? result.events : [];
     events.push(...pageEvents);
     cursor = nextCursor || cursor;
 

package/src/session/stream.js

@@ -337,7 +337,12 @@ function filterBySince(events = [], since) {
 export async function appendToStream(
   sessionId,
   event,
-  { targetPath = process.cwd(), maxEvents = DEFAULT_MAX_STREAM_EVENTS, syncRemote = true } = {}
+  {
+    targetPath = process.cwd(),
+    maxEvents = DEFAULT_MAX_STREAM_EVENTS,
+    syncRemote = true,
+    awaitRemoteSync = false,
+  } = {}
 ) {
   const paths = resolveSessionPaths(sessionId, { targetPath });
   let metadata = await readSessionMetadata(paths);
@@ -381,9 +386,14 @@ export async function appendToStream(
 
   if (syncRemote) {
     // Best-effort dashboard sync. Never block local stream durability on API state.
-    void syncSessionEventToApi(paths.sessionId, canonicalEvent, {
+    const syncPromise = syncSessionEventToApi(paths.sessionId, canonicalEvent, {
       targetPath,
     }).catch(() => {});
+    if (awaitRemoteSync) {
+      await syncPromise;
+    } else {
+      void syncPromise;
+    }
   }
 
   return canonicalEvent;

package/src/session/transcript.js

@@ -359,26 +359,32 @@ export function buildTranscriptMarkdown({
       `| ${avatarMd(identity)} | **${agent.displayName}** \`${agent.agentId}\` | ${agent.family} | ${formatDuration(agent.activeSeconds)} | ${agent.eventCount} | ${agent.tokens.toLocaleString("en-US")} | $${agent.costUsd.toFixed(4)} |`,
     );
   }
-  if (stats.agents.length === 0) {
-    lines.push("| 👤 | (no agents joined) | — | 0s | 0 | 0 | $0.00 |");
-  }
   // Surface registered-but-silent agents at the bottom of the table so
   // the participants list is comprehensive even if they never emitted
   // a stream event.
   const seenIds = new Set(stats.agents.map((a) => a.agentId));
+  const silentRegisteredAgents = [];
   for (const registered of agents || []) {
     const id = normalize(registered?.agentId);
     if (!id || seenIds.has(id)) continue;
+    seenIds.add(id);
     const profile = speakerProfiles.get(id) || null;
     const identity = resolveSpeakerIdentity({
       agentId: id,
       agentModel: registered.model || "",
       profile,
     });
+    silentRegisteredAgents.push({ id, identity });
+  }
+  if (stats.agents.length === 0 && silentRegisteredAgents.length === 0) {
+    lines.push("| 👤 | (no agents joined) | — | 0s | 0 | 0 | $0.00 |");
+  }
+  for (const registered of silentRegisteredAgents) {
     lines.push(
-      `| ${avatarMd(identity)} | **${identity.displayName}** \`${id}\` | ${identity.family} | 0s · idle | 0 | 0 | $0.0000 |`,
+      `| ${avatarMd(registered.identity)} | **${registered.identity.displayName}** \`${registered.id}\` | ${registered.identity.family} | 0s · idle | 0 | 0 | $0.0000 |`,
     );
   }
+  stats.participantCount = stats.agents.length + silentRegisteredAgents.length;
   lines.push("");
 
   // Conversation