sentinelayer-cli 0.40.0 → 0.42.0

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;
@@ -231,6 +233,10 @@ 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 scanExhausted =
+      typeof (result.scanExhausted ?? result.scan_exhausted) === "boolean"
+        ? (result.scanExhausted ?? result.scan_exhausted)
+        : null;
     const progressed = nextCursor && cursorAdvances(nextCursor, cursor);
     if (nextCursor && cursor && !progressed && pageEvents.length === 0) {
       return {
@@ -250,7 +256,7 @@ async function pollSessionEventPages({
     events.push(...pageEvents);
     cursor = nextCursor || cursor;
 
-    if (pageEvents.length < normalizedLimit) {
+    if (pageEvents.length < normalizedLimit && scanExhausted !== false) {
       return {
         ok: true,
         reason: "",
@@ -366,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(

package/src/session/stream.js

@@ -8,6 +8,7 @@ import {
   sessionEventIdentityKeys,
 } from "./event-identity.js";
 import { enrichEventWithMentions } from "./mentions.js";
+import { messageRevision, projectSessionMessageEdits } from "./message-edits.js";
 import { resolveSessionPaths } from "./paths.js";
 import { redactEventPayload } from "./redact.js";
 import { fetchSessionFromApi, listSessionsFromApi, syncSessionEventToApi } from "./sync.js";
@@ -287,6 +288,23 @@ async function releaseLock(lockPath) {
   await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => {});
 }
 
+// Creation and append must coordinate on the SAME lock. In particular, two
+// billing writers may both observe a missing session before either creates it.
+// The callback must not append (append acquires this lock independently).
+export async function withSessionStreamLock(sessionId, operation, {
+  targetPath = process.cwd(),
+  timeoutMs = DEFAULT_LOCK_TIMEOUT_MS,
+} = {}) {
+  const paths = resolveSessionPaths(sessionId, { targetPath });
+  await fsp.mkdir(paths.sessionDir, { recursive: true });
+  await acquireLock(paths.lockPath, { timeoutMs });
+  try {
+    return await operation();
+  } finally {
+    await releaseLock(paths.lockPath);
+  }
+}
+
 async function readEventsFromFile(filePath) {
   try {
     const raw = await fsp.readFile(filePath, "utf-8");
@@ -359,7 +377,8 @@ function eventsShareIdentity(left = {}, right = {}) {
 }
 
 async function appendOrMergeCurrentStreamEvent(paths, canonicalEvent, { mergeExisting = false } = {}) {
-  if (!mergeExisting) {
+  // Keep prior revisions in the raw audit log. Readers project the latest body.
+  if (!mergeExisting || messageRevision(canonicalEvent) > 1) {
     await fsp.appendFile(paths.streamPath, `${JSON.stringify(canonicalEvent)}\n`, "utf-8");
     return;
   }
@@ -427,6 +446,7 @@ export async function appendToStream(
     maxEvents = DEFAULT_MAX_STREAM_EVENTS,
     syncRemote = true,
     awaitRemoteSync = false,
+    lockTimeoutMs = DEFAULT_LOCK_TIMEOUT_MS,
     mergeExisting = false,
   } = {}
 ) {
@@ -457,7 +477,7 @@ export async function appendToStream(
   const nowIso = new Date().toISOString();
   const normalizedMaxEvents = normalizePositiveInteger(maxEvents, DEFAULT_MAX_STREAM_EVENTS);
 
-  await acquireLock(paths.lockPath);
+  await acquireLock(paths.lockPath, { timeoutMs: lockTimeoutMs });
   try {
     await fsp.mkdir(paths.sessionDir, { recursive: true });
     await appendOrMergeCurrentStreamEvent(paths, canonicalEvent, { mergeExisting });
@@ -490,7 +510,7 @@ export async function readStream(
   { tail = 20, since = null, targetPath = process.cwd() } = {}
 ) {
   const paths = resolveSessionPaths(sessionId, { targetPath });
-  const events = await readAllEvents(paths);
+  const events = projectSessionMessageEdits(await readAllEvents(paths));
   const filtered = filterBySince(events, since);
   const normalizedTail = Number(tail);
   if (!Number.isFinite(normalizedTail) || normalizedTail <= 0) {