sentinelayer-cli 0.41.0 → 0.42.0

package/src/session/codebase-context.js

@@ -0,0 +1,54 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isMainThread, parentPort, Worker, workerData } from "node:worker_threads";
+
+const CACHE_LIMIT_BYTES = 2 * 1024 * 1024;
+const CACHE_TIMEOUT_MS = 750;
+
+// Session creation is not an ingest command. Never recursively walk the cwd:
+// it can be a home directory, a monorepo, or a slow network filesystem.
+// The worker owns only a read; it cannot write metadata after its deadline.
+if (!isMainThread && workerData?.kind === "session-context-cache") {
+  let context = {};
+  try {
+    const cachePath = path.join(workerData.targetPath, ".sentinelayer", "CODEBASE_INGEST.json");
+    const stat = await fs.stat(cachePath);
+    if (stat.isFile() && stat.size <= CACHE_LIMIT_BYTES) {
+      const raw = await fs.readFile(cachePath);
+      if (raw.byteLength <= CACHE_LIMIT_BYTES) {
+        const parsed = JSON.parse(raw.toString("utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) context = parsed;
+      }
+    }
+  } catch {
+    // Missing, malformed, unreadable or oversized optional context is absent.
+  }
+  parentPort.postMessage(context);
+}
+
+export async function readSessionCodebaseContext(targetPath, { timeoutMs = CACHE_TIMEOUT_MS } = {}) {
+  let worker;
+  let timer;
+  try {
+    worker = new Worker(new URL("./codebase-context.js", import.meta.url), {
+      workerData: { kind: "session-context-cache", targetPath },
+      resourceLimits: { maxOldGenerationSizeMb: 32 },
+      stdout: true,
+      stderr: true,
+    });
+    worker.stdout.resume();
+    worker.stderr.resume();
+    return await new Promise((resolve) => {
+      timer = setTimeout(() => resolve({}), timeoutMs);
+      worker.once("message", resolve);
+      worker.once("error", () => resolve({}));
+      worker.once("exit", () => resolve({}));
+    });
+  } catch {
+    return {};
+  } finally {
+    clearTimeout(timer);
+    // Await actual worker termination, not merely a race against its promise.
+    if (worker) await worker.terminate();
+  }
+}

package/src/session/coordination-guidance.js

@@ -7,7 +7,7 @@ export const COORDINATION_ETIQUETTE_ITEMS = Object.freeze([
   "Claim shared files outside chat before editing with `sl session lock <id> <file> --agent <your-agent-id> --intent \"<intent>\"`; install terminal/editor preflights once with `sl session guard-install <id> --agent <your-agent-id>`, inspect with `sl session locks <id>`, renew long work with `sl session renew`, and release with `sl session unlock`. Lease lifecycle never belongs in chat; guarded terminal/editor denials report the file, holder, intent, and expiry directly to the blocked agent.",
   "Run one background/secondary listener for replies with `sl session listen --session <id> --agent <your-name> --transport poll --interval 60 --active-interval 60 --emit ndjson --no-presence`; polling applies bounded jitter, exponential transient backoff, and `Retry-After` as a hard floor. `session listen` refuses duplicate local listeners for the same session/agent by default; use `--force` only to stop and replace an existing local owner and `--allow-duplicate` only when you intentionally need parallel wake hooks. `session listen` is only a delivery cursor, not a grounding command; join or recap before acting. For your primary interactive listener, omit `--no-presence` so it renews an ephemeral TTL outside the transcript. Unsupported or degraded presence remains unknown and never falls back to durable heartbeat events. If background polling is unavailable, fall back to `sl session sync <id> --json` then `sl session read <id> --tail 20 --json` every 5 minutes.",
   "For long-lived rooms, make sure exactly one visible participant owns the Senti daemon: `sl session daemon --session <id> --recap-interval 300 --checkpoint-interval 60`. Routine room health is a derived status projection, not a transcript event; run `sl session recap now <id> --remote --agent <your-name> --json` for local grounding and use an explicit checkpoint only for a durable semantic handoff.",
-  "Use message actions for low-noise coordination before posting a new top-level message: `sl session react <id> ack --target-sequence <n>` only when an explicit ACK is useful, `sl session action <id> working_on --target-sequence <n>` for ownership, and `sl session reply <id> <sequence> \"<message>\"` / `sl session comment <id> <sequence> \"<message>\"` for threaded responses. `sl session read <id> --remote --agent <your-name>` advances one monotonic per-agent read cursor for the displayed window; it never appends per-message view events; reserve `sl session view <id> <sequence>` for repair/backfill of that same cursor. Run `sl session actions` for the full list.",
+  "Use message actions for low-noise coordination before posting a new top-level message: `sl session react <id> ack --target-sequence <n>` only when an explicit ACK is useful, `sl session action <id> working_on --target-sequence <n>` for ownership, and `sl session reply <id> <sequence> \"<message>\"` / `sl session comment <id> <sequence> \"<message>\"` for threaded responses. `sl session read <id> --remote --agent <your-name>` advances one monotonic per-agent delivery cursor for the displayed window; it never appends per-message view events or proves human viewing. Correct your own message with `sl session edit <id> <sequence-or-reply-uuid> \"<replacement>\"`; edits retain audit history and notify recipients. Run `sl session actions` for the full list.",
   "Search before asking peers to restate context: `sl session search <id> \"<topic>\" --limit 10`.",
   "Run `sl review --diff` after each finished file or PR-ready diff and post the result summary back to the session.",
   "Post findings through `sl session say <id> \"finding: [P2] <title> in <file>:<line>\"` with enough context for a peer to act.",

package/src/session/daemon-spawn.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 
 import { resolveSessionPaths } from "./paths.js";
 import {
@@ -116,9 +117,22 @@ export async function getDaemonStatus(sessionId, { targetPath = process.cwd() }
   };
 }
 
+// The daemon is ALWAYS this package's own CLI entry, never "whatever script is running".
+// It used to be process.argv[1]: under a test runner that is the TEST FILE, so the "daemon"
+// re-ran the tests, and every bootstrapped session spawned more detached copies of them.
+// On 2026-09-29 one such run became a detached fork bomb that took the machine down and
+// created thousands of sessions on the API.
+const CLI_ENTRY_PATH = fileURLToPath(new URL("../../bin/sl.js", import.meta.url));
+
 export function resolveCliEntryPath() {
-  const entry = normalizeString(process.argv[1]);
-  return entry ? path.resolve(entry) : "";
+  return CLI_ENTRY_PATH;
+}
+
+// Under the node test runner (it sets NODE_TEST_CONTEXT in every test process), a detached
+// daemon outlives the test that started it. One is spawned only when the test names the
+// entry itself (cliPath), deliberately; never as a side effect of code under test.
+function underTestRunner() {
+  return normalizeString(process.env.NODE_TEST_CONTEXT) !== "";
 }
 
 /**
@@ -156,6 +170,10 @@ export async function spawnDetachedSentiDaemon({
     };
   }
 
+  if (!normalizeString(cliPath) && underTestRunner()) {
+    return { spawned: false, pid: null, reason: "test_runner", logPath: "" };
+  }
+
   const entryPath = normalizeString(cliPath) || resolveCliEntryPath();
   if (!entryPath) {
     return { spawned: false, pid: null, reason: "cli_entry_unresolved", logPath: "" };

package/src/session/daemon.js

@@ -783,7 +783,7 @@ async function runSessionDirectiveWatcher(daemonState) {
       if (!daemonState.running) {
         return;
       }
-      if (normalizeString(event.event) !== "session_message") {
+      if (normalizeString(event.event) !== "session_message" || Number(event.messageRevision || 1) > 1) {
         continue;
       }
       await maybeHandleTaskDirective(daemonState, event);
@@ -1280,6 +1280,12 @@ async function maybeGenerateSessionCheckpoint(
       targetPath: daemonState.targetPath,
       minEvents: daemonState.checkpointMinEvents,
       maxEvents: daemonState.checkpointMaxEvents,
+      // origin is the AUTHORITATIVE field (lane 2): this daemon is a process an agent
+      // started, so its cuts are origin:'agent' — never the managed service, even though
+      // #800's humble default would already resolve to agent. Declaring it explicitly means
+      // the daemon's honesty does not silently ride on that default. createdBy stays the
+      // descriptive "senti" persona; origin:'agent' is what a DoD/audit keys on.
+      origin: "agent",
       createdByAgentId: SENTI_IDENTITY.id,
       nowIso: normalizedNow,
     });

package/src/session/event-identity.js

@@ -25,6 +25,9 @@ export function sessionEventHasDurableCursor(event = {}) {
 }
 
 export function sessionEventUpgradesExisting(existingEvent = {}, candidateEvent = {}) {
+  const existingRevision = Number(existingEvent.messageRevision ?? 1);
+  const candidateRevision = Number(candidateEvent.messageRevision ?? 1);
+  if (candidateRevision !== existingRevision) return candidateRevision > existingRevision;
   const existingSequence = readSessionEventSequence(existingEvent);
   const candidateSequence = readSessionEventSequence(candidateEvent);
   if (candidateSequence > 0 && existingSequence <= 0) {
@@ -85,7 +88,10 @@ function mergeObjectPreferringPrimary(primaryValue, secondaryValue) {
 function mergeDuplicateEvent(existingEvent = {}, candidateEvent = {}) {
   const existingScore = eventDurabilityScore(existingEvent);
   const candidateScore = eventDurabilityScore(candidateEvent);
-  const candidateIsPrimary = candidateScore > existingScore || (
+  const existingRevision = Number(existingEvent.messageRevision ?? 1);
+  const candidateRevision = Number(candidateEvent.messageRevision ?? 1);
+  const differentRevision = existingRevision !== candidateRevision;
+  const candidateIsPrimary = differentRevision ? candidateRevision > existingRevision : candidateScore > existingScore || (
     candidateScore === existingScore &&
     sessionEventUpgradesExisting(existingEvent, candidateEvent)
   ) || (
@@ -99,7 +105,8 @@ function mergeDuplicateEvent(existingEvent = {}, candidateEvent = {}) {
     ...secondaryEvent,
     ...primaryEvent,
     agent: mergeObjectPreferringPrimary(primaryEvent.agent, secondaryEvent.agent),
-    payload: mergeObjectPreferringPrimary(primaryEvent.payload, secondaryEvent.payload),
+    // Revision snapshots replace, rather than merge, the body/routing fields.
+    payload: differentRevision ? primaryEvent.payload : mergeObjectPreferringPrimary(primaryEvent.payload, secondaryEvent.payload),
   };
 }
 

package/src/session/first-message.js

@@ -1,5 +1,6 @@
 import { createAgentEvent } from "../events/schema.js";
 import { appendToStream } from "./stream.js";
+import { syncSessionEventToApi } from "./sync.js";
 
 export const FIRST_MESSAGE_AGENT = Object.freeze({
   id: "senti",
@@ -72,7 +73,7 @@ export function buildFirstSentiMessage({ sessionId } = {}) {
 
 /**
  * Post the first-Senti-message as the opening event of a freshly created
- * session. Best-effort + non-blocking — a failure never fails session
+ * session. Best-effort with bounded remote sync — a failure never fails session
  * creation. Returns { posted, reason }.
  */
 export async function postFirstSentiMessage({ sessionId, targetPath = process.cwd() } = {}) {
@@ -91,8 +92,15 @@ export async function postFirstSentiMessage({ sessionId, targetPath = process.cw
     },
   });
   try {
-    await appendToStream(sid, event, { targetPath, awaitRemoteSync: true });
-    return { posted: true, reason: "posted" };
+    const persisted = await appendToStream(sid, event, {
+      targetPath, syncRemote: false, lockTimeoutMs: 500,
+    });
+    const remoteSync = await syncSessionEventToApi(sid, persisted, {
+      targetPath, timeoutMs: 2_000,
+    }).catch(() => ({ synced: false, reason: "sync_failed" }));
+    // Keep posted's existing local-durability meaning; remote acknowledgement
+    // is explicit and must never be inferred from this compatibility field.
+    return { posted: true, reason: "posted", remoteSynced: Boolean(remoteSync.synced), remoteSync };
   } catch (error) {
     return { posted: false, reason: normalizeString(error?.message) || "append_failed" };
   }

package/src/session/listener.js

@@ -8,6 +8,7 @@ import {
 } from "./sync.js";
 import { cursorAdvances, readSyncCursor, writeSyncCursor } from "./sync-cursor.js";
 import { isSessionListenerLifecycleEvent } from "./control-events.js";
+import { sessionMessageRoutingEvent } from "./message-edits.js";
 
 const BROADCAST_RECIPIENTS = new Set([
   "*",
@@ -68,6 +69,7 @@ function addRecipientValue(values, value) {
 }
 
 export function collectSessionEventRecipients(event = {}) {
+  event = sessionMessageRoutingEvent(event);
   const values = [];
   if (!isPlainObject(event)) return values;
   const payload = isPlainObject(event.payload) ? event.payload : {};
@@ -90,6 +92,7 @@ export function collectSessionEventRecipients(event = {}) {
 
 export function eventMatchesAgent(event = {}, agentId = "") {
   if (!isPlainObject(event)) return false;
+  event = sessionMessageRoutingEvent(event);
   const normalizedAgentId = normalizeComparableId(agentId);
   if (!normalizedAgentId) return false;
 

package/src/session/live-source.js

@@ -21,10 +21,10 @@ import { setTimeout as sleep } from "node:timers/promises";
 import { resolveSessionPaths } from "./paths.js";
 import { readStream } from "./stream.js";
 import {
-  addSessionEventIdentityKeys,
   dedupeSessionEvents,
-  sessionEventHasKnownIdentity,
+  readSessionEventSequence,
   sessionEventIdentityKeys,
+  sessionEventUpgradesExisting,
 } from "./event-identity.js";
 
 const DEFAULT_RECONNECT_BACKOFF_MS = 2_000;
@@ -61,14 +61,21 @@ export async function* watchLocalStream({
 } = {}) {
   if (!sessionId) return;
   const paths = resolveSessionPaths(sessionId, { targetPath });
-  let lastTs = null;
+  let observed = new Map();
+  const observe = (event, previous = observed) => {
+    const keys = sessionEventIdentityKeys(event);
+    const existing = keys.map((key) => previous.get(key)).find(Boolean);
+    const changed = !existing || sessionEventUpgradesExisting(existing, event);
+    for (const key of keys) observed.set(key, changed ? event : existing);
+    return changed;
+  };
 
   // Replay the tail first so any caller getting the iterator catches
   // up with the in-flight context before live events start arriving.
-  const initial = dedupeSessionEvents(await _readEvents(sessionId, { targetPath, tail: initialTail }));
+  const baseline = dedupeSessionEvents(await _readEvents(sessionId, { targetPath, tail: 0 }));
+  for (const event of baseline) observe(event);
+  const initial = Number(initialTail) > 0 ? baseline.slice(-Math.floor(Number(initialTail))) : baseline;
   for (const event of initial) {
-    const candidate = event.ts || event.timestamp;
-    if (candidate) lastTs = candidate;
     yield { source: "fs", event };
   }
 
@@ -114,11 +121,15 @@ export async function* watchLocalStream({
       await pendingPromise;
       if (aborted()) break;
 
-      const events = await _readEvents(sessionId, { targetPath, tail: 0, since: lastTs });
+      // Revisions retain the original timestamp. Identity + monotonic revision,
+      // not wall time, determines whether a local projection is new.
+      const events = dedupeSessionEvents(await _readEvents(sessionId, { targetPath, tail: 0 }));
+      // The NDJSON stream rotates at its configured event cap. Retire identities
+      // no longer in that file instead of accumulating a daemon-lifetime cache.
+      const previous = observed;
+      observed = new Map();
       for (const event of events) {
-        const candidate = event.ts || event.timestamp;
-        if (lastTs && candidate && candidate <= lastTs) continue;
-        if (candidate) lastTs = candidate;
+        if (!observe(event, previous)) continue;
         queue.push({ source: "fs", event });
       }
       while (queue.length > 0) {
@@ -154,11 +165,24 @@ export async function* watchRemoteStream({
     sessionId,
   )}/stream`;
   let backoff = reconnectBackoffMs;
+  // Highest server sequence actually DELIVERED to the consumer. SSE is a live push with no
+  // backlog: reconnecting without it silently drops everything published while we were away,
+  // and a listener that missed messages looks exactly like a quiet room. This is what makes an
+  // agent "go dark".
+  let resumeSequence = 0;
 
   while (!signal?.aborted) {
     let response;
+    // Resume strictly after the last delivered event. The server filter is exclusive
+    // (`sequence_id > from_sequence`), so this replays nothing and skips nothing. The first
+    // connection sends no cursor and starts live, which is the behaviour attaching to a room
+    // should have -- resume only ever applies to a RECONNECT.
+    const url =
+      resumeSequence > 0
+        ? `${endpoint}?fromSequence=${encodeURIComponent(String(resumeSequence))}`
+        : endpoint;
     try {
-      response = await _sseFetch(endpoint, {
+      response = await _sseFetch(url, {
         method: "GET",
         headers: {
           Authorization: `Bearer ${token}`,
@@ -201,6 +225,11 @@ export async function* watchRemoteStream({
             try {
               const event = JSON.parse(payload);
               yield { source: "sse", event };
+              // Advance only AFTER the consumer has taken the event. If the generator is closed
+              // mid-yield we resume one early and the merger dedups the repeat -- a duplicate is
+              // recoverable, a gap is not.
+              const sequence = readSessionEventSequence(event);
+              if (sequence > resumeSequence) resumeSequence = sequence;
             } catch {
               yield { source: "sse", raw: payload };
             }
@@ -255,7 +284,7 @@ export async function* mergeLiveSources({
         : watchRemoteStream({ apiBaseUrl, sessionId, token, signal })
       : null;
 
-  const seen = new Set();
+  const seen = new Map();
   const queue = [];
   let pending = null;
 
@@ -301,14 +330,16 @@ export async function* mergeLiveSources({
     if (item.event) {
       const key = eventKey(item.event);
       if (key) {
-        if (sessionEventHasKnownIdentity(item.event, seen) || seen.has(key)) continue;
-        addSessionEventIdentityKeys(seen, item.event);
-        seen.add(key);
+        const keys = sessionEventIdentityKeys(item.event);
+        const existing = keys.map((identity) => seen.get(identity)).find(Boolean) || seen.get(key);
+        if (existing && !sessionEventUpgradesExisting(existing, item.event)) continue;
+        for (const identity of keys) seen.set(identity, item.event);
+        seen.set(key, item.event);
         if (seen.size > 5000) {
           // bound memory — older keys roll out
           const trimmed = Array.from(seen).slice(-2500);
           seen.clear();
-          for (const k of trimmed) seen.add(k);
+          for (const [identity, event] of trimmed) seen.set(identity, event);
         }
       }
     }

package/src/session/message-edits.js

@@ -0,0 +1,89 @@
+import { createAgentEvent } from "../events/schema.js";
+import { enrichEventWithMentions } from "./mentions.js";
+import { sessionEventIdentityKeys } from "./event-identity.js";
+
+export function messageRevision(value = {}) {
+  const revision = Number(value.messageRevision ?? value.message_revision ?? 1);
+  return Number.isSafeInteger(revision) && revision > 0 ? revision : 1;
+}
+
+export function replyRevisionEvent(sessionId, reply = {}) {
+  if (!reply.id || (reply.actionType ?? reply.action_type) !== "reply") return null;
+  const sequence = reply.targetSequenceId ?? reply.target_sequence_id ?? null;
+  const target = sequence ? `#${sequence}` : reply.targetCursor || "target";
+  const note = String(reply.note ?? "");
+  return createAgentEvent({
+    event: "session_reply",
+    agentId: reply.actorId ?? reply.actor_id ?? "unknown",
+    agentModel: reply.actorKind ?? reply.actor_kind ?? "session-action",
+    sessionId,
+    eventId: `session-action-${reply.id}`,
+    cursor: `action:${reply.id}`,
+    ts: reply.createdAt ?? reply.created_at,
+    messageRevision: messageRevision(reply),
+    editedAt: reply.editedAt,
+    editedBy: reply.editedBy,
+    canEdit: reply.canEdit,
+    revisionEvidence: reply.revisionEvidence,
+    payload: {
+      actionId: reply.id,
+      actionType: "reply",
+      targetSequenceId: sequence,
+      targetCursor: reply.targetCursor || null,
+      targetActionId: reply.targetActionId || null,
+      note,
+      metadata: reply.metadata && typeof reply.metadata === "object" ? reply.metadata : undefined,
+      message: `reply ${target}: ${note}`,
+      source: "session_action",
+    },
+  });
+}
+
+// Edits are immutable notifications with their own sequence/identity. Only the
+// nested snapshot contributes to the CURRENT body; it is never replayed as a
+// new authored message or task directive.
+export function sessionMessageEditSnapshot(event = {}) {
+  if (event.event !== "session_message_edited" || event.payload?.schema !== "session-message-edit:v1") return null;
+  const payload = event.payload;
+  if (payload.targetActionId) {
+    const reply = payload.reply;
+    if (reply?.id !== payload.targetActionId || messageRevision(reply) !== messageRevision(payload)) return null;
+    return replyRevisionEvent(event.sessionId, reply);
+  }
+  const snapshot = payload.event;
+  if (!snapshot?.id || snapshot.id !== payload.targetMessageId || messageRevision(snapshot) !== messageRevision(payload)) return null;
+  return snapshot;
+}
+
+export function projectSessionMessageEdits(events = []) {
+  const snapshots = new Map();
+  for (const event of events) {
+    const snapshot = sessionMessageEditSnapshot(event) || (["session_message", "session_reply"].includes(event.event) ? event : null);
+    if (!snapshot) continue;
+    for (const key of sessionEventIdentityKeys(snapshot)) {
+      if (!snapshots.has(key) || messageRevision(snapshot) > messageRevision(snapshots.get(key))) snapshots.set(key, snapshot);
+    }
+  }
+  return events.map((event) => {
+    if (event.event === "session_message_edited") return event;
+    const snapshot = sessionEventIdentityKeys(event).map((key) => snapshots.get(key)).filter(Boolean)
+      .sort((left, right) => messageRevision(right) - messageRevision(left))[0];
+    return snapshot && messageRevision(snapshot) > messageRevision(event) ? { ...event, ...snapshot } : event;
+  });
+}
+
+// Routing consumes the immutable revision snapshot, but delivery/dedupe always
+// consumes the notification's own identity. Reply edits retain parent routing.
+export function sessionMessageRoutingEvent(event = {}) {
+  const snapshot = sessionMessageEditSnapshot(event);
+  if (!snapshot) return event;
+  const parentPayload = event.payload?.event?.payload || {};
+  const payload = { ...parentPayload, ...snapshot.payload };
+  if (event.payload?.reply) payload.message = String(event.payload.reply.note ?? "");
+  for (const key of ["to", "recipient", "recipients", "targetAgent", "targetAgentId", "broadcast", "mentions"]) {
+    if (event.payload[key] !== undefined) payload[key] = event.payload[key];
+  }
+  const routed = enrichEventWithMentions({ ...snapshot, agent: event.agent || snapshot.agent, payload });
+  if (routed.payload?.mentions?.broadcast?.length) routed.payload.broadcast = true;
+  return routed;
+}

package/src/session/recap.js

@@ -923,7 +923,10 @@ function buildRecapText({
   const lockText = `${activeLocks} file lock${activeLocks === 1 ? "" : "s"} active`;
   const pendingText =
     pendingTasks > 0 ? `You have ${pendingTasks} pending task${pendingTasks === 1 ? "" : "s"}.` : "";
-  const taskText = buildTaskLedgerText(taskLedger);
+  const taskText = buildTaskLedgerText(taskLedger, {
+    liveListenerCount: liveListeners.length,
+    recentActorCount: recentActors.length,
+  });
   const usageText = buildUsageLedgerText(usageSummary);
   const workPlanText = buildWorkPlanText(workPlan);
   const snippetText = snippets.length > 0 ? `Recent: ${snippets.join(" | ")}` : "";
@@ -933,9 +936,20 @@ function buildRecapText({
   ).trim();
 }
 
-function buildTaskLedgerText(taskLedger = emptyTaskLedgerSummary()) {
+function buildTaskLedgerText(
+  taskLedger = emptyTaskLedgerSummary(),
+  { liveListenerCount = 0, recentActorCount = 0 } = {},
+) {
   const total = Number(taskLedger.total || 0);
   if (!total) {
+    const listeners = Math.max(0, Math.floor(Number(liveListenerCount || 0)));
+    const actors = Math.max(0, Math.floor(Number(recentActorCount || 0)));
+    if (listeners > 0) {
+      return `Session tasks: none queued (${listeners} live listener${listeners === 1 ? "" : "s"}; no Senti task assignments recorded)`;
+    }
+    if (actors > 0) {
+      return `Session tasks: none queued (${actors} recent actor${actors === 1 ? "" : "s"}; no Senti task assignments recorded)`;
+    }
     return "Session tasks: none queued";
   }
   const active = Number(taskLedger.active || 0);
@@ -1112,7 +1126,7 @@ const AGENT_JOIN_RULES = [
   "",
   "**Writing back** — You can use **markdown**: bold, italic, lists, fenced code, and `inline code`. The web dashboard renders it. Plain text also works. Keep posts terse and technical — link to the work, don't recap it.",
   "",
-  "**Actions and threading** — Use message actions instead of top-level ACK chatter: `sl session react <id> ack --target-sequence <n>` only when an explicit ACK matters, and `sl session action <id> working_on --target-sequence <n>` for ownership. `sl session read <id> --remote --agent <your-name>` advances one monotonic per-agent read cursor, never one durable view event per message; `sl session view <id> <sequence>` repairs that same cursor. Reply to a specific message with `sl session reply <id> <sequence> \"<message>\"`, `sl session comment <id> <sequence> \"<message>\"`, or `sl session say <id> \"<message>\" --reply-to <sequence>`; only start a new top-level post for a new topic. Run `sl session actions` for the full list.",
+  "**Actions and threading** — Use message actions instead of top-level ACK chatter: `sl session react <id> ack --target-sequence <n>` only when an explicit ACK matters, and `sl session action <id> working_on --target-sequence <n>` for ownership. `sl session read <id> --remote --agent <your-name>` advances one monotonic per-agent delivery cursor, never a durable view event or proof of human viewing. Reply to a specific message with `sl session reply <id> <sequence> \"<message>\"`, `sl session comment <id> <sequence> \"<message>\"`, or `sl session say <id> \"<message>\" --reply-to <sequence>`; correct your own message with `sl session edit <id> <sequence-or-reply-uuid> \"<replacement>\"`. Edits retain audit history and notify recipients; only start a new top-level post for a new topic. Run `sl session actions` for the full list.",
   "",
   "**Search before asking** — Use `sl session search <id> \"<topic>\" --limit 10` to recover old context before asking another agent to re-paste or summarize what is already in the transcript.",
   "",
@@ -1146,7 +1160,10 @@ function buildPeriodicText(recap = {}) {
         ? "no live listeners"
         : "listener status unknown";
   const recentActorText = `${recentActors} recent actor${recentActors === 1 ? "" : "s"}`;
-  const taskText = buildTaskLedgerText(summary.taskLedger);
+  const taskText = buildTaskLedgerText(summary.taskLedger, {
+    liveListenerCount: liveListeners,
+    recentActorCount: recentActors,
+  });
   const workPlanText = buildWorkPlanText(summary.workPlan);
   const usageText = buildUsageLedgerText({
     totals: summary.usageTotals,
@@ -1216,6 +1233,7 @@ export async function buildSessionRecap(
   );
   const liveListenerIds = liveListenerRows.map((row) => row.agentId).filter(Boolean);
 
+  const selectedSourceEvents = events.filter(isMeaningfulRecapSourceEvent);
   const actorEvents = visibleEvents.filter(isMeaningfulRecapSourceEvent);
   const recentActorSet = new Set();
   for (const event of actorEvents) {
@@ -1294,6 +1312,10 @@ export async function buildSessionRecap(
       usageTotals: usageSummary.totals,
       usageTopAgents: usageSummary.topAgents,
       snippets,
+      selectedEventCount: events.length,
+      selectedSourceEventCount: selectedSourceEvents.length,
+      visibleSourceEventCount: actorEvents.length,
+      ignoredOperationalEventCount: Math.max(0, events.length - selectedSourceEvents.length),
       elapsedMinutes,
       windowElapsedMinutes,
       sessionStartedAt: sessionMetadata?.createdAt

package/src/session/remote-hydrate.js

@@ -32,8 +32,10 @@ import {
   sessionEventIdentityKeys,
   sessionEventHasKnownIdentity,
   sessionEventUpgradesExisting,
+  dedupeSessionEvents,
 } from "./event-identity.js";
 import { isSessionControlEvent } from "./control-events.js";
+import { sessionMessageEditSnapshot } from "./message-edits.js";
 
 const EVENTS_CURSOR_SUFFIX = "events";
 const DEFAULT_EVENT_PAGE_LIMIT = 200;
@@ -370,25 +372,11 @@ export async function hydrateSessionFromRemote({
 
   // Dedup across sources — both endpoints can return the same event
   // (e.g. a human relay event). Cursor values are unique per event.
-  const seenCursors = new Set();
-  const seenKeys = new Set();
-  const merged = [];
-  for (const e of humanResult?.events || []) {
-    const c = (e && typeof e === "object" && typeof e.cursor === "string") ? e.cursor : "";
-    if (c && seenCursors.has(c)) continue;
-    if (sessionEventHasKnownIdentity(e, seenKeys)) continue;
-    if (c) seenCursors.add(c);
-    addSessionEventIdentityKeys(seenKeys, e);
-    merged.push(e);
-  }
-  for (const e of eventsResult?.events || []) {
-    const c = (e && typeof e === "object" && typeof e.cursor === "string") ? e.cursor : "";
-    if (c && seenCursors.has(c)) continue;
-    if (sessionEventHasKnownIdentity(e, seenKeys)) continue;
-    if (c) seenCursors.add(c);
-    addSessionEventIdentityKeys(seenKeys, e);
-    merged.push(e);
-  }
+  const sourceEvents = [...(humanResult?.events || []), ...(eventsResult?.events || [])];
+  const merged = dedupeSessionEvents(sourceEvents.flatMap((event) => {
+    const snapshot = sessionMessageEditSnapshot(event);
+    return snapshot ? [snapshot, event] : [event];
+  }));
 
   // If BOTH pollers failed, surface the human-message failure (the
   // legacy contract) so existing callers see no behavior change. If

package/src/session/store.js

@@ -4,10 +4,10 @@ import path from "node:path";
 import process from "node:process";
 
 import { buildArtifactLineageIndex, verifyArtifactChain } from "../daemon/artifact-lineage.js";
-import { collectCodebaseIngest } from "../ingest/engine.js";
+import { readSessionCodebaseContext } from "./codebase-context.js";
 import { computeSessionAnalytics } from "./analytics.js";
 import { resolveSessionPaths, resolveSessionsRoot } from "./paths.js";
-import { appendToStream } from "./stream.js";
+import { appendToStream, withSessionStreamLock } from "./stream.js";
 
 const SESSION_SCHEMA_VERSION = "1.0.0";
 const DEFAULT_TTL_SECONDS = 24 * 60 * 60;
@@ -247,13 +247,7 @@ function normalizeSessionTemplate(raw = null) {
 }
 
 async function collectSessionCodebaseContext(targetPath) {
-  const cachedIngestPath = path.join(targetPath, ".sentinelayer", "CODEBASE_INGEST.json");
-  const cachedIngest = await readJsonFile(cachedIngestPath, { allowMissing: true });
-  if (cachedIngest && typeof cachedIngest === "object") {
-    return normalizeCodebaseContext(cachedIngest);
-  }
-  const ingest = await collectCodebaseIngest({ rootPath: targetPath });
-  return normalizeCodebaseContext(ingest);
+  return normalizeCodebaseContext(await readSessionCodebaseContext(targetPath));
 }
 
 async function buildArchiveSidecars(
@@ -507,11 +501,16 @@ export async function createSession({
     }
   );
 
-  await fsp.mkdir(paths.agentsDir, { recursive: true });
-  await saveMetadata(metadata, paths);
-  await fsp.writeFile(paths.streamPath, "", { encoding: "utf-8", flag: "a" });
-
-  return buildSessionPayload(metadata, paths, nowIso);
+  return withSessionStreamLock(sessionId, async () => {
+    // A concurrent materializer may have won while optional context was read.
+    // Never reset its title/TTL/status or race its first billing append.
+    const existing = await loadMetadata(sessionId, { targetPath: resolvedTargetPath });
+    if (existing) return buildSessionPayload(existing.metadata, paths, nowIso);
+    await fsp.mkdir(paths.agentsDir, { recursive: true });
+    await saveMetadata(metadata, paths);
+    await fsp.writeFile(paths.streamPath, "", { encoding: "utf-8", flag: "a" });
+    return buildSessionPayload(metadata, paths, nowIso);
+  }, { targetPath: resolvedTargetPath });
 }
 
 export async function updateSessionTitle(