sentinelayer-cli 0.31.0 → 0.31.1

package/package.json

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

package/src/session/remote-hydrate.js

@@ -67,11 +67,18 @@ async function readExistingRelayState(sessionId, { targetPath = process.cwd() }
   const knownKeys = new Set();
   const events = await readStream(sessionId, { targetPath, tail: 0 }).catch(() => []);
   const indexByKey = new Map();
+  const duplicateKeys = new Set();
   for (const [index, event] of events.entries()) {
+    for (const key of sessionEventIdentityKeys(event)) {
+      const existingIndex = indexByKey.get(key);
+      if (Number.isInteger(existingIndex) && existingIndex >= 0 && existingIndex !== index) {
+        duplicateKeys.add(key);
+      }
+    }
     addSessionEventIdentityKeys(knownKeys, event);
     indexRelayEventIdentityKeys(indexByKey, events, event, index);
   }
-  return { knownKeys, events, indexByKey };
+  return { knownKeys, events, indexByKey, duplicateKeys };
 }
 
 async function ensureLocalSessionShell(sessionId, { targetPath = process.cwd() } = {}) {
@@ -380,13 +387,19 @@ export async function hydrateSessionFromRemote({
   const successfulRelayKeys = relayState.knownKeys;
   const existingRelayEvents = relayState.events;
   const existingRelayIndexByKey = relayState.indexByKey;
+  const duplicateRelayKeys = relayState.duplicateKeys || new Set();
   const newEvents = [];
+  const eventsNeedingMerge = new Set();
   for (const event of merged) {
     const existingIndex = findRelayEventIdentityIndex(existingRelayIndexByKey, event);
     if (existingIndex >= 0) {
       const existing = existingRelayEvents[existingIndex];
-      if (sessionEventUpgradesExisting(existing, event)) {
+      if (
+        sessionEventUpgradesExisting(existing, event) ||
+        sessionEventHasKnownIdentity(event, duplicateRelayKeys)
+      ) {
         newEvents.push(event);
+        eventsNeedingMerge.add(event);
       }
       continue;
     }
@@ -416,14 +429,20 @@ export async function hydrateSessionFromRemote({
     }
   }
 
-  const appendEvents =
-    remoteStatus && !["active", "pending"].includes(remoteStatus)
-      ? materialNewEvents.map((event) => markPostKillEvent(event))
-      : materialNewEvents;
+  const appendEvents = materialNewEvents.map((event) => ({
+    event: remoteStatus && !["active", "pending"].includes(remoteStatus)
+      ? markPostKillEvent(event)
+      : event,
+    mergeExisting: eventsNeedingMerge.has(event),
+  }));
   const failedRelayKeys = new Set();
-  for (const event of appendEvents) {
+  for (const { event, mergeExisting } of appendEvents) {
     try {
-      const persisted = await _append(sessionId, event, { targetPath, syncRemote: false });
+      const persisted = await _append(sessionId, event, {
+        targetPath,
+        syncRemote: false,
+        mergeExisting,
+      });
       relayed += 1;
       const persistedEvent = persisted && typeof persisted === "object" ? persisted : event;
       existingRelayEvents.push(persistedEvent);

package/src/session/stream.js

@@ -3,6 +3,10 @@ import process from "node:process";
 import { setTimeout as sleep } from "node:timers/promises";
 
 import { createAgentEvent, normalizeAgentEvent } from "../events/schema.js";
+import {
+  dedupeSessionEvents,
+  sessionEventIdentityKeys,
+} from "./event-identity.js";
 import { enrichEventWithMentions } from "./mentions.js";
 import { resolveSessionPaths } from "./paths.js";
 import { redactEventPayload } from "./redact.js";
@@ -348,6 +352,58 @@ async function rotateStreamIfNeeded(paths, maxEvents) {
   await fsp.writeFile(paths.streamPath, retainedPayload, "utf-8");
 }
 
+function eventsShareIdentity(left = {}, right = {}) {
+  const leftKeys = new Set(sessionEventIdentityKeys(left));
+  if (leftKeys.size === 0) return false;
+  return sessionEventIdentityKeys(right).some((key) => leftKeys.has(key));
+}
+
+async function appendOrMergeCurrentStreamEvent(paths, canonicalEvent, { mergeExisting = false } = {}) {
+  if (!mergeExisting) {
+    await fsp.appendFile(paths.streamPath, `${JSON.stringify(canonicalEvent)}\n`, "utf-8");
+    return;
+  }
+
+  const currentEvents = await readEventsFromFile(paths.streamPath);
+  const matchingIndexes = [];
+  for (const [index, event] of currentEvents.entries()) {
+    if (eventsShareIdentity(event, canonicalEvent)) {
+      matchingIndexes.push(index);
+    }
+  }
+
+  if (matchingIndexes.length === 0) {
+    await fsp.appendFile(paths.streamPath, `${JSON.stringify(canonicalEvent)}\n`, "utf-8");
+    return;
+  }
+
+  const replacement = dedupeSessionEvents([
+    ...matchingIndexes.map((index) => currentEvents[index]),
+    canonicalEvent,
+  ])[0] || canonicalEvent;
+  const firstMatch = matchingIndexes[0];
+  const matchingIndexSet = new Set(matchingIndexes);
+  const mergedEvents = [];
+  for (const [index, event] of currentEvents.entries()) {
+    if (index === firstMatch) {
+      mergedEvents.push(replacement);
+      continue;
+    }
+    if (matchingIndexSet.has(index)) {
+      continue;
+    }
+    mergedEvents.push(event);
+  }
+
+  await fsp.writeFile(
+    paths.streamPath,
+    mergedEvents.length > 0
+      ? `${mergedEvents.map((event) => JSON.stringify(event)).join("\n")}\n`
+      : "",
+    "utf-8",
+  );
+}
+
 function filterBySince(events = [], since) {
   const normalizedSince = normalizeString(since);
   if (!normalizedSince) {
@@ -371,6 +427,7 @@ export async function appendToStream(
     maxEvents = DEFAULT_MAX_STREAM_EVENTS,
     syncRemote = true,
     awaitRemoteSync = false,
+    mergeExisting = false,
   } = {}
 ) {
   const paths = resolveSessionPaths(sessionId, { targetPath });
@@ -403,7 +460,7 @@ export async function appendToStream(
   await acquireLock(paths.lockPath);
   try {
     await fsp.mkdir(paths.sessionDir, { recursive: true });
-    await fsp.appendFile(paths.streamPath, `${JSON.stringify(canonicalEvent)}\n`, "utf-8");
+    await appendOrMergeCurrentStreamEvent(paths, canonicalEvent, { mergeExisting });
     await rotateStreamIfNeeded(paths, normalizedMaxEvents);
 
     metadata.lastInteractionAt = nowIso;