@evo-dev/core 0.0.1-alpha.19 → 0.0.1-alpha.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-dev/core",
-  "version": "0.0.1-alpha.19",
+  "version": "0.0.1-alpha.20",
   "type": "module",
   "repository": {
     "type": "git",

package/src/evolution/evidence/session-memory/retention.ts

@@ -1,18 +1,23 @@
+import { readFile } from "node:fs/promises";
 import { createStableId, normalizeTimestamp, sha256Hex } from "../../../utils/index.ts";
 import { readEvolutionReviewSnapshot } from "../../candidates/index.ts";
 import type { EvolutionReviewSnapshot, SegmentEvolutionTriggerRecord } from "../../schema.ts";
 import { listSegmentEvolutionTriggers } from "../../triggers/index.ts";
+import { resolveSessionMemoryPaths } from "./paths.ts";
 import {
   listSessionEvidenceSegments,
+  listSessionMemoryStates,
   readSessionEvidenceSegment,
+  rewriteSessionRawEvents,
   writeSessionEvidenceSegmentAtomic,
 } from "./storage.ts";
-import type { SessionEvidenceSegmentV1 } from "./types.ts";
+import type { SessionEvidenceSegmentV1, SessionMemoryRawEventV1 } from "./types.ts";
 
 const DEFAULT_RETENTION_LIMIT = 20;
-const MAX_RETENTION_LIMIT = 20;
+const MAX_RETENTION_LIMIT = 10_000;
+const DEFAULT_LEGACY_RETENTION_DAYS = 30;
 
-export type HistoricalSessionEvidenceRetentionProtectionReason =
+export type SessionEvidenceRetentionProtectionReason =
   | "trigger-missing"
   | "trigger-not-terminal"
   | "segment-review-pending"
@@ -20,7 +25,10 @@ export type HistoricalSessionEvidenceRetentionProtectionReason =
   | "retention-invalid"
   | "segment-changed";
 
-export interface PurgeExpiredHistoricalSessionEvidenceResult {
+export type HistoricalSessionEvidenceRetentionProtectionReason =
+  SessionEvidenceRetentionProtectionReason;
+
+export interface PurgeExpiredSessionEvidenceResult {
   scanned: number;
   due: number;
   purged: number;
@@ -28,17 +36,51 @@ export interface PurgeExpiredHistoricalSessionEvidenceResult {
   protected: Array<{
     projectKey: string;
     segmentId: string;
-    reason: HistoricalSessionEvidenceRetentionProtectionReason;
+    reason: SessionEvidenceRetentionProtectionReason;
   }>;
 }
 
-export interface HistoricalSessionEvidenceRetentionInspection {
+export type PurgeExpiredHistoricalSessionEvidenceResult = PurgeExpiredSessionEvidenceResult;
+
+export interface SessionEvidenceRetentionInspection {
   available: number;
   purged: number;
   overdue: number;
   purgeEligible: number;
   protected: number;
-  protectionReasons: Partial<Record<HistoricalSessionEvidenceRetentionProtectionReason, number>>;
+  legacyWithoutRetention: number;
+  legacyOverdue: number;
+  legacyRawBytes: number;
+  legacyOverdueRawBytes: number;
+  expiredCapturedEventPayloads: number;
+  expiredCapturedEventRawBytes: number;
+  protectionReasons: Partial<Record<SessionEvidenceRetentionProtectionReason, number>>;
+}
+
+export type HistoricalSessionEvidenceRetentionInspection = SessionEvidenceRetentionInspection;
+
+export interface LegacySessionEvidenceRetentionMigrationResult {
+  migrated: number;
+  expiredCapturedEventPayloads: number;
+  expiredCapturedEventRawBytes: number;
+  purge: PurgeExpiredSessionEvidenceResult;
+}
+
+interface RetentionContext {
+  reviewSnapshots: Map<string, Promise<EvolutionReviewSnapshot>>;
+  triggerMaps: Map<string, Promise<Map<string, SegmentEvolutionTriggerRecord[]>>>;
+}
+
+export async function inspectSessionEvidenceRetention(input: {
+  homeDir: string;
+  projectKey?: string;
+  now?: string | Date;
+}): Promise<SessionEvidenceRetentionInspection> {
+  const result = await inspectRetention(input, () => true);
+  const expiredEvents = await expireCapturedRawEvents({ ...input, apply: false });
+  result.expiredCapturedEventPayloads = expiredEvents.payloads;
+  result.expiredCapturedEventRawBytes = expiredEvents.rawBytes;
+  return result;
 }
 
 export async function inspectHistoricalSessionEvidenceRetention(input: {
@@ -46,94 +88,112 @@ export async function inspectHistoricalSessionEvidenceRetention(input: {
   projectKey?: string;
   now?: string | Date;
 }): Promise<HistoricalSessionEvidenceRetentionInspection> {
+  return inspectRetention(input, (segment) => segment.origin?.kind === "historical-import");
+}
+
+async function inspectRetention(
+  input: { homeDir: string; projectKey?: string; now?: string | Date },
+  include: (segment: SessionEvidenceSegmentV1) => boolean,
+): Promise<SessionEvidenceRetentionInspection> {
   const now = normalizeTimestamp(input.now);
-  const historical = (
+  const segments = (
     await listSessionEvidenceSegments({
       homeDir: input.homeDir,
       projectKey: input.projectKey,
     })
-  ).filter(
-    (segment) => segment.origin?.kind === "historical-import" && segment.retention !== undefined,
-  );
-  const result: HistoricalSessionEvidenceRetentionInspection = {
-    available: 0,
-    purged: 0,
-    overdue: 0,
-    purgeEligible: 0,
-    protected: 0,
-    protectionReasons: {},
-  };
-  const reviewSnapshots = new Map<string, Promise<EvolutionReviewSnapshot>>();
-  for (const segment of historical) {
-    if (segment.retention?.rawState === "purged") {
+  ).filter(include);
+  const retentionDays = await loadLegacyRetentionDays(input.homeDir, input.projectKey);
+  const result = emptyInspection();
+  const context = createRetentionContext();
+
+  for (const segment of segments) {
+    if (segment.retention === undefined) {
+      const rawBytes = segment.rawExcerpt.stored ? segment.rawExcerpt.byteLength : 0;
+      result.legacyWithoutRetention += 1;
+      result.legacyRawBytes += rawBytes;
+      const expiresAt = legacyExpiresAt(segment, retentionDays);
+      if (Date.parse(expiresAt) <= Date.parse(now)) {
+        result.legacyOverdue += 1;
+        result.legacyOverdueRawBytes += rawBytes;
+        const protection = await findRetentionProtection({
+          homeDir: input.homeDir,
+          segment,
+          context,
+        });
+        if (protection === null) result.purgeEligible += 1;
+        else addProtection(result, protection);
+      }
+      continue;
+    }
+    if (segment.retention.rawState === "purged") {
       result.purged += 1;
       continue;
     }
     result.available += 1;
     if (!hasValidAvailableRetention(segment)) {
       result.overdue += 1;
-      result.protected += 1;
-      result.protectionReasons["retention-invalid"] =
-        (result.protectionReasons["retention-invalid"] ?? 0) + 1;
-      continue;
-    }
-    if (
-      segment.retention === undefined ||
-      Date.parse(segment.retention.expiresAt) > Date.parse(now)
-    ) {
+      addProtection(result, "retention-invalid");
       continue;
     }
+    if (Date.parse(segment.retention.expiresAt) > Date.parse(now)) continue;
     result.overdue += 1;
     const protection = await findRetentionProtection({
       homeDir: input.homeDir,
       segment,
-      reviewSnapshots,
+      context,
     });
-    if (protection === null) {
-      result.purgeEligible += 1;
-      continue;
-    }
-    result.protected += 1;
-    result.protectionReasons[protection] = (result.protectionReasons[protection] ?? 0) + 1;
+    if (protection === null) result.purgeEligible += 1;
+    else addProtection(result, protection);
   }
   return result;
 }
 
+export async function purgeExpiredSessionEvidence(input: {
+  homeDir: string;
+  projectKey?: string;
+  now?: string | Date;
+  limit?: number;
+}): Promise<PurgeExpiredSessionEvidenceResult> {
+  return purgeRetention(input, () => true);
+}
+
 export async function purgeExpiredHistoricalSessionEvidence(input: {
   homeDir: string;
   projectKey?: string;
   now?: string | Date;
   limit?: number;
 }): Promise<PurgeExpiredHistoricalSessionEvidenceResult> {
+  return purgeRetention(input, (segment) => segment.origin?.kind === "historical-import");
+}
+
+async function purgeRetention(
+  input: { homeDir: string; projectKey?: string; now?: string | Date; limit?: number },
+  include: (segment: SessionEvidenceSegmentV1) => boolean,
+): Promise<PurgeExpiredSessionEvidenceResult> {
   const now = normalizeTimestamp(input.now);
   const limit = normalizeLimit(input.limit);
-  const historical = (
+  const segments = (
     await listSessionEvidenceSegments({
       homeDir: input.homeDir,
       projectKey: input.projectKey,
     })
   )
-    .filter(
-      (segment) => segment.origin?.kind === "historical-import" && segment.retention !== undefined,
-    )
+    .filter((segment) => include(segment) && segment.retention !== undefined)
     .sort(
       (left, right) =>
         (left.retention?.expiresAt ?? "").localeCompare(right.retention?.expiresAt ?? "") ||
         left.id.localeCompare(right.id),
     );
-  const result: PurgeExpiredHistoricalSessionEvidenceResult = {
+  const result: PurgeExpiredSessionEvidenceResult = {
     scanned: 0,
     due: 0,
     purged: 0,
-    alreadyPurged: 0,
+    alreadyPurged: segments.filter((segment) => segment.retention?.rawState === "purged").length,
     protected: [],
   };
-  const reviewSnapshots = new Map<string, Promise<EvolutionReviewSnapshot>>();
+  const context = createRetentionContext();
 
-  result.alreadyPurged = historical.filter(
-    (segment) => segment.retention?.rawState === "purged",
-  ).length;
-  for (const segment of historical) {
+  for (const segment of segments) {
     if (result.scanned >= limit) break;
     if (segment.retention === undefined || segment.retention.rawState === "purged") continue;
     result.scanned += 1;
@@ -152,7 +212,7 @@ export async function purgeExpiredHistoricalSessionEvidence(input: {
     const protection = await findRetentionProtection({
       homeDir: input.homeDir,
       segment,
-      reviewSnapshots,
+      context,
     });
     if (protection !== null) {
       result.protected.push({
@@ -169,16 +229,13 @@ export async function purgeExpiredHistoricalSessionEvidence(input: {
       sessionKey: segment.sessionKey,
       segmentId: segment.id,
     });
-    const currentTrigger = await findSegmentTrigger(input.homeDir, current);
     if (
       !hasValidAvailableRetention(current) ||
       current.retention?.rawState !== "available" ||
       current.retention.expiresAt !== segment.retention.expiresAt ||
       !current.rawExcerpt.stored ||
       current.rawExcerpt.sha256 !== segment.rawExcerpt.sha256 ||
-      current.lifecycle.reviewState !== segment.lifecycle.reviewState ||
-      currentTrigger === null ||
-      !isTerminalTrigger(currentTrigger)
+      current.lifecycle.reviewState !== segment.lifecycle.reviewState
     ) {
       result.protected.push({
         projectKey: segment.projectKey,
@@ -187,22 +244,23 @@ export async function purgeExpiredHistoricalSessionEvidence(input: {
       });
       continue;
     }
-    const freshSnapshot = await readEvolutionReviewSnapshot({
+    const freshProtection = await findRetentionProtection({
       homeDir: input.homeDir,
-      projectKey: current.projectKey,
+      segment: current,
+      context: createRetentionContext(),
     });
-    if (hasPendingDerivedReview(freshSnapshot, current)) {
+    if (freshProtection !== null) {
       result.protected.push({
-        projectKey: segment.projectKey,
-        segmentId: segment.id,
-        reason: "derived-review-pending",
+        projectKey: current.projectKey,
+        segmentId: current.id,
+        reason: freshProtection,
       });
       continue;
     }
 
     await writeSessionEvidenceSegmentAtomic({
       homeDir: input.homeDir,
-      segment: createPurgedHistoricalSegment(current, now),
+      segment: createPurgedSegment(current, now),
     });
     result.purged += 1;
   }
@@ -210,11 +268,102 @@ export async function purgeExpiredHistoricalSessionEvidence(input: {
   return result;
 }
 
+export async function migrateLegacySessionEvidenceRetention(input: {
+  homeDir: string;
+  projectKey?: string;
+  now?: string | Date;
+}): Promise<LegacySessionEvidenceRetentionMigrationResult> {
+  const now = normalizeTimestamp(input.now);
+  const retentionDays = await loadLegacyRetentionDays(input.homeDir, input.projectKey);
+  const segments = await listSessionEvidenceSegments({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey,
+  });
+  let migrated = 0;
+  const context = createRetentionContext();
+  for (const segment of segments) {
+    if (segment.retention !== undefined || !segment.rawExcerpt.stored) continue;
+    const policyDays = retentionDays.get(sessionKey(segment)) ?? DEFAULT_LEGACY_RETENTION_DAYS;
+    if (Date.parse(addDays(segment.createdAt, policyDays)) > Date.parse(now)) continue;
+    const protection = await findRetentionProtection({
+      homeDir: input.homeDir,
+      segment,
+      context,
+    });
+    if (protection !== null) continue;
+    const current = await readSessionEvidenceSegment({
+      homeDir: input.homeDir,
+      projectKey: segment.projectKey,
+      sessionKey: segment.sessionKey,
+      segmentId: segment.id,
+    });
+    if (current.retention !== undefined || JSON.stringify(current) !== JSON.stringify(segment)) {
+      continue;
+    }
+    await writeSessionEvidenceSegmentAtomic({
+      homeDir: input.homeDir,
+      segment: {
+        ...current,
+        retention: {
+          policyDays,
+          expiresAt: addDays(current.createdAt, policyDays),
+          rawState: "available",
+          rawPurgedAt: null,
+          originalRawSha256: current.rawExcerpt.sha256,
+        },
+      },
+    });
+    migrated += 1;
+  }
+  const expiredEvents = await expireCapturedRawEvents({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey,
+    now,
+    apply: true,
+  });
+  return {
+    migrated,
+    expiredCapturedEventPayloads: expiredEvents.payloads,
+    expiredCapturedEventRawBytes: expiredEvents.rawBytes,
+    purge: await purgeExpiredSessionEvidence({
+      homeDir: input.homeDir,
+      projectKey: input.projectKey,
+      now,
+      limit: Math.max(DEFAULT_RETENTION_LIMIT, segments.length),
+    }),
+  };
+}
+
+function emptyInspection(): SessionEvidenceRetentionInspection {
+  return {
+    available: 0,
+    purged: 0,
+    overdue: 0,
+    purgeEligible: 0,
+    protected: 0,
+    legacyWithoutRetention: 0,
+    legacyOverdue: 0,
+    legacyRawBytes: 0,
+    legacyOverdueRawBytes: 0,
+    expiredCapturedEventPayloads: 0,
+    expiredCapturedEventRawBytes: 0,
+    protectionReasons: {},
+  };
+}
+
+function addProtection(
+  result: SessionEvidenceRetentionInspection,
+  reason: SessionEvidenceRetentionProtectionReason,
+): void {
+  result.protected += 1;
+  result.protectionReasons[reason] = (result.protectionReasons[reason] ?? 0) + 1;
+}
+
 function normalizeLimit(value: number | undefined): number {
   const limit = value ?? DEFAULT_RETENTION_LIMIT;
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_RETENTION_LIMIT) {
     throw new Error(
-      `Historical Session Evidence retention limit must be between 1 and ${MAX_RETENTION_LIMIT}.`,
+      `Session Evidence retention limit must be between 1 and ${MAX_RETENTION_LIMIT}.`,
     );
   }
   return limit;
@@ -238,25 +387,28 @@ function hasValidAvailableRetention(segment: SessionEvidenceSegmentV1): boolean
 async function findRetentionProtection(input: {
   homeDir: string;
   segment: SessionEvidenceSegmentV1;
-  reviewSnapshots: Map<string, Promise<EvolutionReviewSnapshot>>;
-}): Promise<HistoricalSessionEvidenceRetentionProtectionReason | null> {
+  context: RetentionContext;
+}): Promise<SessionEvidenceRetentionProtectionReason | null> {
   if (
     input.segment.lifecycle.reviewState === "unreviewed" ||
     input.segment.lifecycle.reviewState === "deferred"
   ) {
     return "segment-review-pending";
   }
-  const trigger = await findSegmentTrigger(input.homeDir, input.segment);
-  if (trigger === null) return "trigger-missing";
+  const trigger = await findSegmentTrigger(input.homeDir, input.segment, input.context);
+  if (trigger === null) {
+    if (input.segment.reason === "session-memory-threshold") return null;
+    return "trigger-missing";
+  }
   if (!isTerminalTrigger(trigger)) return "trigger-not-terminal";
 
-  let snapshot = input.reviewSnapshots.get(input.segment.projectKey);
+  let snapshot = input.context.reviewSnapshots.get(input.segment.projectKey);
   if (snapshot === undefined) {
     snapshot = readEvolutionReviewSnapshot({
       homeDir: input.homeDir,
       projectKey: input.segment.projectKey,
     });
-    input.reviewSnapshots.set(input.segment.projectKey, snapshot);
+    input.context.reviewSnapshots.set(input.segment.projectKey, snapshot);
   }
   return hasPendingDerivedReview(await snapshot, input.segment) ? "derived-review-pending" : null;
 }
@@ -264,15 +416,23 @@ async function findRetentionProtection(input: {
 async function findSegmentTrigger(
   homeDir: string,
   segment: SessionEvidenceSegmentV1,
+  context: RetentionContext,
 ): Promise<SegmentEvolutionTriggerRecord | null> {
-  const matches = (
-    await listSegmentEvolutionTriggers({
-      homeDir,
-      projectKey: segment.projectKey,
-    })
-  ).filter(
-    (trigger) => trigger.segmentId === segment.id && trigger.sessionKey === segment.sessionKey,
-  );
+  let triggerMap = context.triggerMaps.get(segment.projectKey);
+  if (triggerMap === undefined) {
+    triggerMap = listSegmentEvolutionTriggers({ homeDir, projectKey: segment.projectKey }).then(
+      (triggers) => {
+        const map = new Map<string, SegmentEvolutionTriggerRecord[]>();
+        for (const trigger of triggers) {
+          const key = `${trigger.sessionKey}\0${trigger.segmentId}`;
+          map.set(key, [...(map.get(key) ?? []), trigger]);
+        }
+        return map;
+      },
+    );
+    context.triggerMaps.set(segment.projectKey, triggerMap);
+  }
+  const matches = (await triggerMap).get(`${segment.sessionKey}\0${segment.id}`) ?? [];
   return matches.length === 1 ? (matches[0] ?? null) : null;
 }
 
@@ -326,13 +486,13 @@ function hasPendingDerivedReview(
   );
 }
 
-function createPurgedHistoricalSegment(
+function createPurgedSegment(
   segment: SessionEvidenceSegmentV1,
   now: string,
 ): SessionEvidenceSegmentV1 {
   const retention = segment.retention;
   if (retention === undefined || retention.rawState !== "available") {
-    throw new Error("Historical Session Evidence raw body is not available for purge.");
+    throw new Error("Session Evidence raw body is not available for purge.");
   }
   return {
     ...segment,
@@ -360,3 +520,124 @@ function createPurgedHistoricalSegment(
     },
   };
 }
+
+function createRetentionContext(): RetentionContext {
+  return {
+    reviewSnapshots: new Map(),
+    triggerMaps: new Map(),
+  };
+}
+
+async function loadLegacyRetentionDays(
+  homeDir: string,
+  projectKey?: string,
+): Promise<Map<string, number>> {
+  const states = await listSessionMemoryStates({ homeDir, projectKey });
+  return new Map(
+    states.map((state) => [`${state.projectKey}\0${state.sessionKey}`, state.policy.retentionDays]),
+  );
+}
+
+function legacyExpiresAt(
+  segment: SessionEvidenceSegmentV1,
+  retentionDays: Map<string, number>,
+): string {
+  return addDays(
+    segment.createdAt,
+    retentionDays.get(sessionKey(segment)) ?? DEFAULT_LEGACY_RETENTION_DAYS,
+  );
+}
+
+function sessionKey(segment: SessionEvidenceSegmentV1): string {
+  return `${segment.projectKey}\0${segment.sessionKey}`;
+}
+
+function addDays(value: string, days: number): string {
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) throw new Error("Invalid Session Evidence retention timestamp.");
+  return new Date(timestamp + days * 24 * 60 * 60 * 1000).toISOString();
+}
+
+async function expireCapturedRawEvents(input: {
+  homeDir: string;
+  projectKey?: string;
+  now?: string | Date;
+  apply: boolean;
+}): Promise<{ payloads: number; rawBytes: number }> {
+  const now = Date.parse(normalizeTimestamp(input.now));
+  const states = await listSessionMemoryStates({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey,
+  });
+  let payloads = 0;
+  let rawBytes = 0;
+  for (const state of states) {
+    const stateUpdatedAt = Date.parse(state.updatedAt);
+    if (Number.isFinite(stateUpdatedAt) && now - stateUpdatedAt < 5 * 60 * 1000) continue;
+    const paths = resolveSessionMemoryPaths({
+      homeDir: input.homeDir,
+      projectKey: state.projectKey,
+      sessionKey: state.sessionKey,
+    });
+    const cursor = await readCursor(paths.cursorPath);
+    const capturedLine = cursor?.lastCapturedLine ?? 0;
+    if (capturedLine <= 0) continue;
+    let text: string;
+    try {
+      text = await readFile(paths.eventsPath, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = text.split("\n").filter((line) => line.trim() !== "");
+    let changed = false;
+    let filePayloads = 0;
+    let fileRawBytes = 0;
+    const nextLines = lines.map((line, index) => {
+      if (index >= capturedLine) return line;
+      let event: SessionMemoryRawEventV1;
+      try {
+        event = JSON.parse(line) as SessionMemoryRawEventV1;
+      } catch {
+        return line;
+      }
+      const expiresAt =
+        Date.parse(event.receivedAt) + state.policy.retentionDays * 24 * 60 * 60 * 1000;
+      if (
+        !Number.isFinite(expiresAt) ||
+        expiresAt > now ||
+        event.rawPayloadExpired === true ||
+        event.rawPayloadJson === "{}"
+      ) {
+        return line;
+      }
+      filePayloads += 1;
+      fileRawBytes += Buffer.byteLength(event.rawPayloadJson, "utf8");
+      if (!input.apply) return line;
+      changed = true;
+      return JSON.stringify({
+        ...event,
+        rawPayloadJson: "{}",
+        rawPayloadTruncated: false,
+        rawPayloadExpired: true,
+      } satisfies SessionMemoryRawEventV1);
+    });
+    if (!input.apply) {
+      payloads += filePayloads;
+      rawBytes += fileRawBytes;
+      continue;
+    }
+    if (changed && (await rewriteSessionRawEvents(paths.eventsPath, nextLines, text))) {
+      payloads += filePayloads;
+      rawBytes += fileRawBytes;
+    }
+  }
+  return { payloads, rawBytes };
+}
+
+async function readCursor(path: string): Promise<{ lastCapturedLine: number | null } | null> {
+  try {
+    return JSON.parse(await readFile(path, "utf8")) as { lastCapturedLine: number | null };
+  } catch {
+    return null;
+  }
+}

package/src/evolution/evidence/session-memory/segment.ts

@@ -100,6 +100,7 @@ export async function createSegment(input: {
     String(toLine),
     input.signals.at(-1)?.eventId ?? input.now,
   ]);
+  const rawSha256 = sha256Hex(truncated.content);
   return {
     schemaVersion: 1,
     kind: "session-evidence-segment",
@@ -112,6 +113,13 @@ export async function createSegment(input: {
     createdAt: input.now,
     reason: input.reason,
     strength: input.strength,
+    retention: {
+      policyDays: input.state.policy.retentionDays,
+      expiresAt: addDays(input.now, input.state.policy.retentionDays),
+      rawState: "available",
+      rawPurgedAt: null,
+      originalRawSha256: rawSha256,
+    },
     source: {
       traceRefId: input.cursor.traceRefId,
       sourcePath: input.paths.eventsPath,
@@ -129,7 +137,7 @@ export async function createSegment(input: {
       content: truncated.content,
       truncated: raw.truncated || truncated.truncated,
       byteLength: Buffer.byteLength(truncated.content, "utf8"),
-      sha256: sha256Hex(truncated.content),
+      sha256: rawSha256,
     },
     normalized: {
       summary: createSegmentSummary(input.reason, input.strength, signalSummaries),
@@ -161,6 +169,12 @@ export async function createSegment(input: {
   };
 }
 
+function addDays(value: string, days: number): string {
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) throw new Error("Invalid Session Evidence retention timestamp.");
+  return new Date(timestamp + days * 24 * 60 * 60 * 1000).toISOString();
+}
+
 export function estimateTokenCount(rawPayloadJson: string, summary: string): number {
   return Math.max(1, Math.ceil((rawPayloadJson.length + summary.length) / 4));
 }