chainlesschain 0.166.115 → 0.166.118

package/src/lib/session-history-origins.js

@@ -1,10 +1,14 @@
-import { canonicalDigest } from "@chainlesschain/context-memory-kernel";
+import {
+  canonicalDigest,
+  canonicalJson,
+} from "@chainlesschain/context-memory-kernel";
 import {
   contextItemsToMessages,
   messagesToContextItems,
 } from "./context-memory-kernel/message-adapter.js";
 import {
   decodeVerifiedPersistedMessage,
+  decodeVerifiedRawPersistedMessage,
   encodePersistedMessage,
   getDurableSystemMessageProvenance,
   DURABLE_SYSTEM_MESSAGE_KINDS,
@@ -31,8 +35,28 @@ const historyBearing = (entry) =>
   derivedSystemKinds.has(
     getDurableSystemMessageProvenance(entry.message)?.kind,
   );
+// Compare conversation identity without dropping system messages, their private
+// provenance, or unknown metadata. Raw receipt fields remain available below
+// for authenticating historical ContextItem source digests.
+const conversationMessages = (messages) =>
+  messages.map((message) =>
+    decodeVerifiedPersistedMessage(encodePersistedMessage(message)),
+  );
 const fingerprint = (messages) =>
-  canonicalDigest(messages.map(encodePersistedMessage));
+  canonicalDigest(conversationMessages(messages).map(encodePersistedMessage));
+const sameContextItemContent = (left, right) => {
+  if (typeof left?.content === "string" || typeof right?.content === "string") {
+    return (
+      typeof left?.content === "string" &&
+      typeof right?.content === "string" &&
+      left.content === right.content
+    );
+  }
+  if (left?.contentRef === undefined || right?.contentRef === undefined) {
+    return false;
+  }
+  return canonicalJson(left.contentRef) === canonicalJson(right.contentRef);
+};
 
 /**
  * Origins belong to positions in the current display history, never to equal
@@ -75,12 +99,12 @@ export function createSessionHistoryOrigins() {
     appendPersisted(message, ordinal) {
       if (!context) return;
       append(
-        decodeVerifiedPersistedMessage(message),
+        decodeVerifiedRawPersistedMessage(message),
         displayable(message) ? { first: ordinal, last: ordinal } : null,
       );
     },
     appendMappedPersisted(message, origin) {
-      append(decodeVerifiedPersistedMessage(message), origin);
+      append(decodeVerifiedRawPersistedMessage(message), origin);
     },
     branchPrefix(messages, head, count) {
       if (!context) return null;
@@ -114,7 +138,7 @@ export function createSessionHistoryOrigins() {
       let ordinal = 0;
       replace(
         messages.map((message) => ({
-          message: decodeVerifiedPersistedMessage(message),
+          message: decodeVerifiedRawPersistedMessage(message),
           origin: displayable(message)
             ? { first: ordinal, last: ordinal++ }
             : null,
@@ -126,21 +150,41 @@ export function createSessionHistoryOrigins() {
       let entries = null;
       try {
         if (context) {
-          const originals = messagesToContextItems(
-            context.map((entry) => entry.message),
-            { sessionId: canonical.sessionId },
-          );
-          const byDigest = new Map(
-            originals.map((item) => [item.digest, item]),
-          );
-          const bySequence = new Map(
-            originals.map((item) => [item.sourceRef.eventSequence, item]),
-          );
+          const rawMessages = context.map((entry) => entry.message);
+          // Old compactions hashed raw receipt-bearing bundles; new ones hash
+          // conversation projections. Derive exactly these two representations
+          // from the same bounded verified context, never from output claims.
+          const representations = [rawMessages];
+          if (
+            rawMessages.some(
+              (message) =>
+                message.role === "user" &&
+                (Object.hasOwn(message, "clientMessageId") ||
+                  Object.hasOwn(message, "inputDigest")),
+            )
+          ) {
+            representations.push(conversationMessages(rawMessages));
+          }
+          const sources = representations.map((messages) => {
+            const items = messagesToContextItems(messages, {
+              sessionId: canonical.sessionId,
+              allowExternalization: true,
+            });
+            return {
+              items,
+              byDigest: new Map(items.map((item) => [item.digest, item])),
+              bySequence: new Map(
+                items.map((item) => [item.sourceRef.eventSequence, item]),
+              ),
+            };
+          });
           const itemEntries = (item) =>
             context.slice(
               item.sourceRef.eventSequence,
               item.sourceRef.eventSequence +
-                contextItemsToMessages([item]).length,
+                contextItemsToMessages([item], {
+                  sessionId: canonical.sessionId,
+                }).length,
             );
           entries = [...canonical.outputItems]
             .sort(
@@ -150,13 +194,19 @@ export function createSessionHistoryOrigins() {
                 left.itemId.localeCompare(right.itemId, "en"),
             )
             .flatMap((item) => {
-              const messages = contextItemsToMessages([item]);
-              const source = bySequence.get(item.sourceRef.eventSequence);
-              if (
-                item.sourceRef.store === "cli-jsonl-session" &&
-                source?.sourceRef.digest === item.sourceRef.digest &&
-                source.content === item.content
-              ) {
+              const messages = contextItemsToMessages([item], {
+                sessionId: canonical.sessionId,
+              });
+              const source = sources
+                .map(({ bySequence }) =>
+                  bySequence.get(item.sourceRef.eventSequence),
+                )
+                .find(
+                  (candidate) =>
+                    candidate?.sourceRef.digest === item.sourceRef.digest &&
+                    sameContextItemContent(candidate, item),
+                );
+              if (item.sourceRef.store === "cli-jsonl-session" && source) {
                 return itemEntries(source);
               }
               let origin = null;
@@ -165,18 +215,26 @@ export function createSessionHistoryOrigins() {
                 item.provenance?.parentDigests?.length > 0
               ) {
                 const digests = item.provenance.parentDigests;
-                if (
-                  digests.length <= originals.length &&
-                  new Set(digests).size === digests.length
-                ) {
-                  const parents = digests.map((digest) => byDigest.get(digest));
-                  if (parents.every(Boolean))
-                    origin = span(parents.flatMap(itemEntries));
+                if (new Set(digests).size === digests.length) {
+                  // A summary must name one complete representation. Mixing
+                  // raw and projected aliases cannot manufacture extra parents.
+                  for (const { items, byDigest } of sources) {
+                    if (digests.length > items.length) continue;
+                    const parents = digests.map((digest) =>
+                      byDigest.get(digest),
+                    );
+                    if (parents.every(Boolean)) {
+                      origin = span(parents.flatMap(itemEntries));
+                      break;
+                    }
+                  }
                 }
               }
               return messages.map((message) => ({ message, origin }));
             });
-          const persisted = data.messages.map(decodeVerifiedPersistedMessage);
+          const persisted = data.messages.map(
+            decodeVerifiedRawPersistedMessage,
+          );
           if (
             fingerprint(entries.map((entry) => entry.message)) !==
             fingerprint(persisted)
@@ -189,7 +247,7 @@ export function createSessionHistoryOrigins() {
       replace(
         entries ||
           data.messages.map((message) => ({
-            message: decodeVerifiedPersistedMessage(message),
+            message: decodeVerifiedRawPersistedMessage(message),
             origin: null,
           })),
       );
@@ -213,13 +271,14 @@ export function createSessionHistoryOrigins() {
           start: certificate.start,
           end: certificate.end,
         });
+        const persisted = data.messages.map(decodeVerifiedRawPersistedMessage);
         if (
           fingerprint(projected.map((entry) => entry.message)) !==
-          fingerprint(data.messages.map(decodeVerifiedPersistedMessage))
+          fingerprint(persisted)
         )
           return false;
-        const entries = projected.map(({ message, sourceIndexes }) => ({
-          message,
+        const entries = projected.map(({ sourceIndexes }, index) => ({
+          message: persisted[index],
           origin: span(sourceIndexes.map((index) => context[index])),
         }));
         replace(entries);

package/src/lib/session-message-provenance.js

@@ -214,6 +214,18 @@ function cloneWithoutWireTag(snapshot) {
   return clean;
 }
 
+// Input acceptance belongs to the authenticated event, not the provider's
+// conversation message. Keep encodePersistedMessage unchanged so receipt
+// lookup/deduplication still verifies the original event and digest. Apply this
+// only after the full JSON-safe clone, including for historical checkpoints.
+function conversationMessage(clean) {
+  if (clean?.role === "user") {
+    delete clean.clientMessageId;
+    delete clean.inputDigest;
+  }
+  return clean;
+}
+
 function canonicalTag(kind) {
   if (!DURABLE_KINDS.has(kind)) {
     throw new TypeError(`Unsupported durable system message kind: ${kind}`);
@@ -314,7 +326,7 @@ export function encodePersistedMessage(message) {
  * Decode provenance only after the caller has verified the JSONL hash chain
  * and its independent head/count anchor while holding the session lock.
  */
-export function decodeVerifiedPersistedMessage(message) {
+export function decodeVerifiedRawPersistedMessage(message) {
   if (!message || typeof message !== "object") return message;
   if (!isObjectMessage(message)) return null;
   const snapshot = plainDataSnapshot(message);
@@ -332,6 +344,12 @@ export function decodeVerifiedPersistedMessage(message) {
   return clean;
 }
 
+/** Verified message replay has a conversation projection distinct from the
+ * exact historical payload used to authenticate migration and lineage. */
+export function decodeVerifiedPersistedMessage(message) {
+  return conversationMessage(decodeVerifiedRawPersistedMessage(message));
+}
+
 /** Strip an untrusted wire field without granting runtime replay authority. */
 export function sanitizePersistedMessage(message) {
   if (!message || typeof message !== "object") return message;
@@ -340,6 +358,12 @@ export function sanitizePersistedMessage(message) {
   return snapshot ? cloneWithoutWireTag(snapshot) : null;
 }
 
+/** Conversation replay excludes receipt metadata; generic data sanitation and
+ * historical migration digests retain their original representation. */
+export function sanitizeConversationMessage(message) {
+  return conversationMessage(sanitizePersistedMessage(message));
+}
+
 /** Deep-sanitize an untrusted persisted message array without granting replay. */
 export function sanitizePersistedMessages(messages, options = {}) {
   const strict = options?.strict === true;
@@ -442,7 +466,7 @@ export function projectCanonicalResumeMessages(messages, options = {}) {
     }
     if (isRuntimeOnlySessionMessage(raw)) continue;
     if (role !== "system") {
-      projected.push(clean);
+      projected.push(conversationMessage(clean));
     } else if (runtimeTag) {
       projected.push(attachRuntimeTag(clean, canonicalTag(runtimeTag.kind)));
     }

package/src/lib/session-runtime-retention.js

@@ -1,6 +1,10 @@
 /** Bounded live-state retention for long-running agent conversations. */
 
 import { createHash } from "node:crypto";
+import {
+  isRuntimeOnlySessionMessage,
+  markRuntimeOnlySessionMessage,
+} from "./session-message-provenance.js";
 
 export const SESSION_RUNTIME_RETENTION_LIMITS = Object.freeze({
   recentResults: 32,
@@ -136,7 +140,12 @@ export function releaseOldLiveSessionResults(messages, configured = {}) {
       originalChars: content.length,
       retainedChars: projection.content.length,
     });
-    return { ...message, content: projection.content };
+    const retained = { ...message, content: projection.content };
+    // This is a trusted host clone. Preserve only authority already attached
+    // to its source; matching background-result text grants no authority.
+    return isRuntimeOnlySessionMessage(message)
+      ? markRuntimeOnlySessionMessage(retained)
+      : retained;
   });
   return {
     messages: output,

package/src/lib/session-transcript-history.js

@@ -77,7 +77,11 @@ function isContextCompaction(data) {
         }));
     return (
       canonicalDigest(
-        content(contextItemsToMessages(canonical.outputItems)),
+        content(
+          contextItemsToMessages(canonical.outputItems, {
+            sessionId: canonical.sessionId,
+          }),
+        ),
       ) === canonicalDigest(content(data.messages))
     );
   } catch {

package/src/lib/session-transcript-migration.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 
 import {
   appendEvent,
+  appendAuthorityEventWithVerifiedProjection,
   findLatestEvent,
   listSessionAuthoritySummaries,
   readVerifiedMessages,
@@ -12,7 +13,10 @@ import {
   getSession as getDatabaseSession,
   listSessions as listDatabaseSessions,
 } from "./session-manager.js";
-import { sanitizePersistedMessages } from "./session-message-provenance.js";
+import {
+  sanitizeConversationMessage,
+  sanitizePersistedMessages,
+} from "./session-message-provenance.js";
 
 export const SESSION_STORE_MIGRATION_EVENT = "session_store_migrated";
 export const SESSION_STORE_MIGRATION_SCHEMA =
@@ -71,6 +75,7 @@ export function ensureCanonicalSessionTranscript(
 ) {
   const deps = {
     appendEvent,
+    appendAuthorityEventWithVerifiedProjection,
     findLatestEvent,
     readVerifiedMessages,
     sessionHasPersistedEvidence,
@@ -113,14 +118,67 @@ export function ensureCanonicalSessionTranscript(
     });
   }
 
+  const migration = {
+    schema: SESSION_STORE_MIGRATION_SCHEMA,
+    source,
+    messagesDigest: digest,
+    messageCount: importedMessages.length,
+  };
+  const conflict = () =>
+    migrationError(
+      "CC_SESSION_MIGRATION_CONFLICT",
+      `canonical transcript already contains different messages: ${id}`,
+      { sessionId: id },
+    );
   const currentMessages = deps.readVerifiedMessages(id);
+  let recoveredImport = false;
   if (currentMessages.length > 0) {
-    if (messagesDigest(currentMessages) !== digest) {
-      throw migrationError(
-        "CC_SESSION_MIGRATION_CONFLICT",
-        `canonical transcript already contains different messages: ${id}`,
-        { sessionId: id },
+    const snapshot = deps.findLatestEvent(id, "compact");
+    if (snapshot?.data?.reason === "physical-store-import") {
+      // Conversation replay omits input receipt metadata. Recover an interrupted
+      // import only from the exact raw snapshot, never normalized equality alone.
+      // Recheck both evidence and live replay under the marker's writer lock.
+      deps.appendAuthorityEventWithVerifiedProjection(
+        id,
+        SESSION_STORE_MIGRATION_EVENT,
+        migration,
+        {
+          createProjection: () => {
+            let latest = null;
+            let completed = false;
+            return {
+              accept(event) {
+                if (event.type === "compact") latest = event.data;
+                if (event.type === SESSION_STORE_MIGRATION_EVENT)
+                  completed = true;
+              },
+              finish: () => ({ latest, completed }),
+            };
+          },
+          validateProjection({ latest, completed }, authority) {
+            if (
+              completed ||
+              latest?.reason !== "physical-store-import" ||
+              !Array.isArray(latest.messages) ||
+              messagesDigest(latest.messages) !== digest ||
+              // Old snapshots did not record a source label. Their exact raw
+              // source bytes remain the only available import identity proof.
+              (Object.hasOwn(latest, "migration") &&
+                (latest.migration?.schema !== migration.schema ||
+                  latest.migration.source !== source ||
+                  latest.migration.messagesDigest !== digest)) ||
+              messagesDigest(authority.readMessages()) !==
+                messagesDigest(
+                  importedMessages.map(sanitizeConversationMessage),
+                )
+            )
+              throw conflict();
+          },
+        },
       );
+      recoveredImport = true;
+    } else if (messagesDigest(currentMessages) !== digest) {
+      throw conflict();
     }
   } else if (importedMessages.length > 0) {
     deps.appendEvent(id, "compact", {
@@ -128,15 +186,12 @@ export function ensureCanonicalSessionTranscript(
       originalMessages: importedMessages.length,
       compressedMessages: importedMessages.length,
       reason: "physical-store-import",
+      migration,
     });
   }
 
-  deps.appendEvent(id, SESSION_STORE_MIGRATION_EVENT, {
-    schema: SESSION_STORE_MIGRATION_SCHEMA,
-    source,
-    messagesDigest: digest,
-    messageCount: importedMessages.length,
-  });
+  if (!recoveredImport)
+    deps.appendEvent(id, SESSION_STORE_MIGRATION_EVENT, migration);
   return Object.freeze({
     sessionId: id,
     migrated: true,