@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-5375UYTQ.js

@@ -0,0 +1,914 @@
+import {
+  encodeStoragePathSegment,
+  encodeStoragePathSegmentWithHash,
+  isSafeLegacyPathSegment,
+  resolveSafeStoragePath,
+  storagePathHash
+} from "./chunk-FF4KLI5W.js";
+import {
+  analyzeSessionIntegrity
+} from "./chunk-YRMVARQP.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/transcript.ts
+import { appendFile, mkdir, readdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import path from "path";
+function legacyTranscriptDirFor(channelType, channelId, encodedDir) {
+  if (!isSafeLegacyPathSegment(channelType) || !isSafeLegacyPathSegment(channelId)) {
+    return void 0;
+  }
+  const legacyDir = path.join(channelType, channelId);
+  return legacyDir === encodedDir ? void 0 : legacyDir;
+}
+var TranscriptManager = class _TranscriptManager {
+  transcriptsDir;
+  checkpointPath;
+  stateDir;
+  toolUsageDir;
+  config;
+  sessionFootprintCache = /* @__PURE__ */ new Map();
+  directoryOwnershipCache = /* @__PURE__ */ new Map();
+  /** Default checkpoint TTL in hours */
+  static DEFAULT_CHECKPOINT_TTL_HOURS = 24;
+  /** Approximate characters per token for rough estimation */
+  static CHARS_PER_TOKEN = 4;
+  constructor(config) {
+    this.config = config;
+    this.transcriptsDir = path.join(config.memoryDir, "transcripts");
+    this.stateDir = path.join(config.memoryDir, "state");
+    this.checkpointPath = path.join(this.stateDir, "checkpoint.json");
+    this.toolUsageDir = path.join(this.stateDir, "tool-usage");
+  }
+  /**
+   * Parse a sessionKey to extract channel type and ID.
+   *
+   * SessionKey patterns:
+   *   - agent:<agent-id>:main → type="main", id="default"
+   *   - agent:<agent-id>:discord:channel:<channel-id> → type="discord", id="<channel-id>"
+   *   - agent:<agent-id>:cron:<job-id> → type="cron", id="<job-id>"
+   *   - agent:<agent-id>:slack:channel:<channel-id> → type="slack", id="<channel-id>"
+   *
+   * @returns Object with raw channel identifiers and encoded storage path pieces.
+   */
+  getTranscriptPath(sessionKey) {
+    const parts = sessionKey.split(":");
+    let channelType = "other";
+    let channelId = "default";
+    if (parts.length >= 3) {
+      channelType = parts[2];
+      if (channelType === "main") {
+        channelId = "default";
+      } else if (channelType === "discord" && parts.length >= 5 && parts[3] === "channel") {
+        channelId = parts[4];
+      } else if (channelType === "slack" && parts.length >= 5 && parts[3] === "channel") {
+        channelId = parts[4];
+      } else if (channelType === "cron" && parts.length >= 4) {
+        channelId = parts[3];
+      } else if (parts.length >= 4) {
+        channelId = parts[3];
+      }
+    }
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const dir = path.join(
+      encodeStoragePathSegment(channelType),
+      encodeStoragePathSegment(channelId)
+    );
+    const alternateDir = path.join(
+      encodeStoragePathSegmentWithHash(channelType),
+      `${encodeStoragePathSegmentWithHash(channelId)}--session-${storagePathHash(sessionKey)}`
+    );
+    return {
+      dir,
+      file: `${today}.jsonl`,
+      channelType,
+      channelId,
+      alternateDir,
+      legacyDir: legacyTranscriptDirFor(channelType, channelId, dir)
+    };
+  }
+  /**
+   * Initialize the transcript manager by ensuring directories exist.
+   */
+  async initialize() {
+    await mkdir(this.transcriptsDir, { recursive: true });
+    await mkdir(this.stateDir, { recursive: true });
+    await mkdir(this.toolUsageDir, { recursive: true });
+    log.info("transcript manager initialized");
+  }
+  /**
+   * Best-effort list of sessionKeys that have transcript files on disk.
+   * This is used by cron-style tooling (hourly summaries, conversation indexing)
+   * to iterate across "active" sessions.
+   */
+  async listSessionKeys() {
+    const transcriptDir = this.transcriptsDir;
+    const sessionKeys = /* @__PURE__ */ new Set();
+    try {
+      const typeEntries = await readdir(transcriptDir, { withFileTypes: true });
+      for (const typeEnt of typeEntries) {
+        if (!typeEnt.isDirectory()) continue;
+        const typeDir = path.join(transcriptDir, typeEnt.name);
+        const idEntries = await readdir(typeDir, { withFileTypes: true });
+        for (const idEnt of idEntries) {
+          if (!idEnt.isDirectory()) continue;
+          const chanDir = path.join(typeDir, idEnt.name);
+          const files = (await readdir(chanDir)).filter((f) => f.endsWith(".jsonl")).sort();
+          const last = files[files.length - 1];
+          if (!last) continue;
+          try {
+            const raw = await readFile(path.join(chanDir, last), "utf-8");
+            const firstLine = raw.split("\n").find((l) => l.trim().length > 0);
+            if (!firstLine) continue;
+            const entry = JSON.parse(firstLine);
+            if (typeof entry.sessionKey === "string" && entry.sessionKey.length > 0) {
+              sessionKeys.add(entry.sessionKey);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+      return [];
+    }
+    return Array.from(sessionKeys);
+  }
+  getToolUsagePath(sessionKey) {
+    const p = this.getTranscriptPath(sessionKey);
+    return { dir: p.dir, file: p.file, alternateDir: p.alternateDir, legacyDir: p.legacyDir };
+  }
+  async selectStorageDirForWrite(root, dir, legacyDir, sessionKey, alternateDir) {
+    const channelDir = await resolveSafeStoragePath(root, dir);
+    const encodedStatus = await this.directorySessionStatus(root, dir, sessionKey);
+    if (encodedStatus === "matches" || encodedStatus === "empty") return { dir, channelDir };
+    if (legacyDir) {
+      const legacyChannelDir = await resolveSafeStoragePath(root, legacyDir);
+      if (await this.directorySessionStatus(root, legacyDir, sessionKey) === "matches") {
+        return { dir: legacyDir, channelDir: legacyChannelDir };
+      }
+    }
+    if (encodedStatus === "missing") return { dir, channelDir };
+    if (alternateDir) {
+      const alternateChannelDir = await resolveSafeStoragePath(root, alternateDir);
+      const alternateStatus = await this.directorySessionStatus(root, alternateDir, sessionKey);
+      if (alternateStatus === "missing" || alternateStatus === "empty" || alternateStatus === "matches") {
+        return { dir: alternateDir, channelDir: alternateChannelDir };
+      }
+    }
+    throw new Error(`transcript storage path collision for session: ${sessionKey ?? "(unknown)"}`);
+  }
+  async directorySessionStatus(root, dir, sessionKey) {
+    let channelDir;
+    try {
+      channelDir = await resolveSafeStoragePath(root, dir);
+      if (!(await stat(channelDir)).isDirectory()) return "occupied";
+    } catch (err) {
+      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+      if (code === "ENOENT") return "missing";
+      throw err;
+    }
+    let names;
+    try {
+      names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl"));
+    } catch {
+      return "occupied";
+    }
+    const fileSizes = await this.directoryJsonlFileSizes(root, dir, names);
+    if (!fileSizes) return "occupied";
+    if (!sessionKey) return "matches";
+    const cacheKey = this.directoryOwnershipCacheKey(root, dir, sessionKey);
+    const cached = this.directoryOwnershipCache.get(cacheKey);
+    if (cached && this.sameFileSizes(cached.fileSizes, fileSizes)) {
+      return cached.status;
+    }
+    let hasEntries = false;
+    let hasMatchingEntry = false;
+    for (const name of names) {
+      const filePath = await resolveSafeStoragePath(root, dir, name).catch(() => null);
+      if (filePath === null) return "occupied";
+      try {
+        const raw = await readFile(filePath, "utf-8");
+        for (const line of raw.split("\n")) {
+          if (!line.trim()) continue;
+          hasEntries = true;
+          try {
+            const obj = JSON.parse(line);
+            if (obj.sessionKey === sessionKey) {
+              hasMatchingEntry = true;
+            } else {
+              return "occupied";
+            }
+          } catch {
+            return "occupied";
+          }
+        }
+      } catch {
+        return "occupied";
+      }
+    }
+    const status = hasMatchingEntry ? "matches" : hasEntries ? "occupied" : "empty";
+    if (status === "matches" || status === "empty") {
+      this.directoryOwnershipCache.set(cacheKey, { status, fileSizes });
+    }
+    return status;
+  }
+  directoryOwnershipCacheKey(root, dir, sessionKey) {
+    return `${path.resolve(root)}\0${dir}\0${sessionKey}`;
+  }
+  sameFileSizes(left, right) {
+    if (left.size !== right.size) return false;
+    for (const [name, size] of left) {
+      if (right.get(name) !== size) return false;
+    }
+    return true;
+  }
+  async directoryJsonlFileSizes(root, dir, names) {
+    const fileSizes = /* @__PURE__ */ new Map();
+    for (const name of names) {
+      const filePath = await resolveSafeStoragePath(root, dir, name).catch(() => null);
+      if (filePath === null) return null;
+      const fileInfo = await stat(filePath).catch(() => null);
+      if (!fileInfo?.isFile()) return null;
+      fileSizes.set(name, Math.max(0, fileInfo.size));
+    }
+    return fileSizes;
+  }
+  async rememberDirectoryOwnership(root, dir, sessionKey) {
+    try {
+      const channelDir = await resolveSafeStoragePath(root, dir);
+      const names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl"));
+      const fileSizes = await this.directoryJsonlFileSizes(root, dir, names);
+      if (!fileSizes) return;
+      this.directoryOwnershipCache.set(
+        this.directoryOwnershipCacheKey(root, dir, sessionKey),
+        { status: "matches", fileSizes }
+      );
+    } catch {
+    }
+  }
+  async getSessionStorageFiles(root, dir, legacyDir, alternateDir) {
+    const files = [];
+    const seenDirs = /* @__PURE__ */ new Set();
+    for (const candidateDir of [dir, alternateDir, legacyDir]) {
+      if (!candidateDir || seenDirs.has(candidateDir)) continue;
+      seenDirs.add(candidateDir);
+      let channelDir;
+      try {
+        channelDir = await resolveSafeStoragePath(root, candidateDir);
+      } catch {
+        continue;
+      }
+      let names;
+      try {
+        names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl")).sort();
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        const filePath = await resolveSafeStoragePath(root, candidateDir, name).catch(() => null);
+        if (filePath === null) continue;
+        files.push({
+          cacheKey: path.join(candidateDir, name),
+          name,
+          path: filePath
+        });
+      }
+    }
+    return files.sort((a, b) => a.cacheKey.localeCompare(b.cacheKey));
+  }
+  async appendToolUse(entry) {
+    const { dir, file, alternateDir, legacyDir } = this.getToolUsagePath(entry.sessionKey);
+    const { dir: writeDir, channelDir } = await this.selectStorageDirForWrite(
+      this.toolUsageDir,
+      dir,
+      legacyDir,
+      entry.sessionKey,
+      alternateDir
+    );
+    await mkdir(channelDir, { recursive: true });
+    const filePath = await resolveSafeStoragePath(this.toolUsageDir, writeDir, file);
+    await appendFile(filePath, JSON.stringify(entry) + "\n", "utf-8");
+    await this.rememberDirectoryOwnership(this.toolUsageDir, writeDir, entry.sessionKey);
+  }
+  async readToolUse(sessionKey, startTime, endTime) {
+    const { dir, alternateDir, legacyDir } = this.getToolUsagePath(sessionKey);
+    try {
+      const files = await this.getSessionStorageFiles(this.toolUsageDir, dir, legacyDir, alternateDir);
+      const out = [];
+      for (const file of files) {
+        const raw = await readFile(file.path, "utf-8");
+        for (const line of raw.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const obj = JSON.parse(line);
+            const ts = new Date(String(obj.timestamp ?? "")).getTime();
+            if (!Number.isFinite(ts)) continue;
+            if (ts >= startTime.getTime() && ts < endTime.getTime()) {
+              if (typeof obj.tool === "string" && typeof obj.sessionKey === "string") {
+                if (obj.sessionKey === sessionKey) {
+                  out.push({ timestamp: obj.timestamp, sessionKey: obj.sessionKey, tool: obj.tool });
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      return out;
+    } catch {
+      return [];
+    }
+  }
+  async estimateSessionFootprint(sessionKey) {
+    const { dir, alternateDir, legacyDir } = this.getTranscriptPath(sessionKey);
+    let bytes = 0;
+    try {
+      const files = await this.getSessionStorageFiles(this.transcriptsDir, dir, legacyDir, alternateDir);
+      const cached = this.sessionFootprintCache.get(sessionKey);
+      if (!cached) {
+        const fileBytes = /* @__PURE__ */ new Map();
+        const fileSizes = /* @__PURE__ */ new Map();
+        for (const file of files) {
+          try {
+            const fileInfo = await stat(file.path);
+            const sessionBytes = await this.estimateSessionBytesInFile(
+              file.path,
+              sessionKey
+            );
+            fileBytes.set(file.cacheKey, sessionBytes);
+            fileSizes.set(file.cacheKey, Math.max(0, fileInfo.size));
+            bytes += sessionBytes;
+          } catch {
+          }
+        }
+        this.sessionFootprintCache.set(sessionKey, { totalBytes: bytes, fileBytes, fileSizes });
+      } else {
+        bytes = cached.totalBytes;
+        const seen = new Set(files.map((file) => file.cacheKey));
+        for (const [cachedFile, cachedSessionBytes] of cached.fileBytes.entries()) {
+          if (!seen.has(cachedFile)) {
+            bytes -= cachedSessionBytes;
+            cached.fileBytes.delete(cachedFile);
+            cached.fileSizes.delete(cachedFile);
+          }
+        }
+        for (const file of files) {
+          if (cached.fileBytes.has(file.cacheKey)) continue;
+          try {
+            const fileInfo = await stat(file.path);
+            const sessionBytes = await this.estimateSessionBytesInFile(file.path, sessionKey);
+            cached.fileBytes.set(file.cacheKey, sessionBytes);
+            cached.fileSizes.set(file.cacheKey, Math.max(0, fileInfo.size));
+            bytes += sessionBytes;
+          } catch {
+          }
+        }
+        for (const file of files) {
+          try {
+            const fileInfo = await stat(file.path);
+            const size = Math.max(0, fileInfo.size);
+            const previousSessionBytes = cached.fileBytes.get(file.cacheKey) ?? 0;
+            const previousSize = cached.fileSizes.get(file.cacheKey) ?? -1;
+            if (size !== previousSize) {
+              const sessionBytes = await this.estimateSessionBytesInFile(file.path, sessionKey);
+              cached.fileBytes.set(file.cacheKey, sessionBytes);
+              cached.fileSizes.set(file.cacheKey, size);
+              bytes += sessionBytes - previousSessionBytes;
+            }
+          } catch {
+          }
+        }
+        if (bytes < 0) bytes = 0;
+        cached.totalBytes = bytes;
+      }
+    } catch {
+      this.sessionFootprintCache.delete(sessionKey);
+    }
+    return {
+      bytes,
+      tokens: Math.floor(bytes / _TranscriptManager.CHARS_PER_TOKEN)
+    };
+  }
+  async estimateSessionBytesInFile(filePath, sessionKey) {
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      let total = 0;
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.sessionKey === sessionKey) {
+            total += Buffer.byteLength(`${line}
+`, "utf-8");
+          }
+        } catch {
+        }
+      }
+      return total;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Check if a file is a legacy flat transcript file (YYYY-MM-DD.jsonl format).
+   */
+  isLegacyTranscriptFile(filename) {
+    return /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(filename);
+  }
+  /**
+   * Append a turn to the appropriate transcript file.
+   * Files are stored hierarchically: transcripts/{channelType}/{channelId}.jsonl
+   *
+   * Skips channel types in config.transcriptSkipChannelTypes (e.g., "cron").
+   */
+  async append(entry) {
+    try {
+      const { dir, file, channelType, alternateDir, legacyDir } = this.getTranscriptPath(entry.sessionKey);
+      if (this.config.transcriptSkipChannelTypes.includes(channelType)) {
+        return;
+      }
+      const { dir: writeDir, channelDir } = await this.selectStorageDirForWrite(
+        this.transcriptsDir,
+        dir,
+        legacyDir,
+        entry.sessionKey,
+        alternateDir
+      );
+      const filePath = await resolveSafeStoragePath(this.transcriptsDir, writeDir, file);
+      await mkdir(channelDir, { recursive: true });
+      const line = JSON.stringify(entry) + "\n";
+      await appendFile(filePath, line, "utf-8");
+      await this.rememberDirectoryOwnership(this.transcriptsDir, writeDir, entry.sessionKey);
+      log.debug(`appended transcript entry for ${entry.sessionKey}: ${entry.turnId}`);
+    } catch (err) {
+      log.error("failed to append transcript entry:", err);
+      throw err;
+    }
+  }
+  /**
+   * Get all transcript files from the hierarchical directory structure.
+   * Recursively finds all .jsonl files in transcripts/{channelType}/{channelId}/ subdirectories.
+   */
+  async getAllTranscriptFiles() {
+    const files = [];
+    try {
+      const entries = await readdir(this.transcriptsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const channelTypeDir = path.join(this.transcriptsDir, entry.name);
+          try {
+            const channelTypeEntries = await readdir(channelTypeDir, { withFileTypes: true });
+            for (const channelTypeEntry of channelTypeEntries) {
+              if (channelTypeEntry.isDirectory()) {
+                const channelDir = path.join(channelTypeDir, channelTypeEntry.name);
+                try {
+                  const channelFiles = await readdir(channelDir);
+                  for (const file of channelFiles) {
+                    if (file.endsWith(".jsonl")) {
+                      files.push(path.join(entry.name, channelTypeEntry.name, file));
+                    }
+                  }
+                } catch {
+                }
+              } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl")) {
+                files.push(path.join(entry.name, channelTypeEntry.name));
+              }
+            }
+          } catch {
+          }
+        } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          files.push(entry.name);
+        }
+      }
+    } catch {
+    }
+    return files;
+  }
+  /**
+   * Read transcript entries for a date range.
+   * Returns entries within the time range, optionally filtered by sessionKey.
+   * Reads from all channel subdirectories in the hierarchical structure.
+   */
+  async readRange(startTime, endTime, sessionKey) {
+    const start = new Date(startTime);
+    const end = new Date(endTime);
+    const entries = [];
+    try {
+      const transcriptFiles = await this.getAllTranscriptFiles();
+      for (const relativePath of transcriptFiles) {
+        const filePath = path.join(this.transcriptsDir, relativePath);
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const lines = content.trim().split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const entry = JSON.parse(line);
+              const entryTime = new Date(entry.timestamp);
+              if (entryTime >= start && entryTime <= end) {
+                if (!sessionKey || entry.sessionKey === sessionKey) {
+                  entries.push(entry);
+                }
+              }
+            } catch {
+              log.debug(`skipped malformed transcript line in ${relativePath}`);
+            }
+          }
+        } catch {
+        }
+      }
+      entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+      log.debug(`read ${entries.length} transcript entries from ${transcriptFiles.length} file(s)`);
+      return entries;
+    } catch (err) {
+      log.error("failed to read transcript range:", err);
+      return [];
+    }
+  }
+  /**
+   * Read the last N hours of transcript.
+   *
+   * Fast path: when sessionKey is given, reads only the 1-2 daily files for that
+   * specific channel instead of scanning all 95+ transcript files across all channels.
+   */
+  async readRecent(hours, sessionKey) {
+    const end = /* @__PURE__ */ new Date();
+    const start = new Date(end.getTime() - hours * 60 * 60 * 1e3);
+    if (sessionKey) {
+      return this.readRecentForSession(start, end, sessionKey);
+    }
+    return this.readRange(start.toISOString(), end.toISOString(), void 0);
+  }
+  /**
+   * Optimized read for a specific session: only looks in that session's channel
+   * directory and only reads files whose date falls within the lookback window.
+   */
+  async readRecentForSession(start, end, sessionKey) {
+    const { dir, alternateDir, legacyDir } = this.getTranscriptPath(sessionKey);
+    const dateStrings = /* @__PURE__ */ new Set();
+    const cursor = new Date(start);
+    while (cursor <= end) {
+      dateStrings.add(cursor.toISOString().slice(0, 10));
+      cursor.setDate(cursor.getDate() + 1);
+    }
+    dateStrings.add(end.toISOString().slice(0, 10));
+    const entries = [];
+    const files = await this.getSessionStorageFiles(this.transcriptsDir, dir, legacyDir, alternateDir);
+    for (const file of files) {
+      const dateStr = file.name.slice(0, 10);
+      if (!dateStrings.has(dateStr)) continue;
+      try {
+        const content = await readFile(file.path, "utf-8");
+        for (const line of content.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const entry = JSON.parse(line);
+            const ts = new Date(entry.timestamp);
+            if (ts >= start && ts <= end && entry.sessionKey === sessionKey) {
+              entries.push(entry);
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    log.debug(`readRecentForSession: ${entries.length} entries from ${files.length} file(s) in ${dir}`);
+    return entries;
+  }
+  /**
+   * Cleanup old transcript entries that are older than retentionDays.
+   * For hierarchical structure, reads each file and rewrites without old entries.
+   * Legacy flat files are deleted if their date is older than retentionDays.
+   * Returns the number of files processed (cleaned or deleted).
+   */
+  async cleanup(retentionDays) {
+    if (retentionDays <= 0) {
+      log.warn("cleanup called with invalid retentionDays:", retentionDays);
+      return 0;
+    }
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - retentionDays);
+    cutoff.setHours(0, 0, 0, 0);
+    let processed = 0;
+    try {
+      const entries = await readdir(this.transcriptsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const channelTypeDir = path.join(this.transcriptsDir, entry.name);
+          try {
+            const channelTypeEntries = await readdir(channelTypeDir, { withFileTypes: true });
+            for (const channelTypeEntry of channelTypeEntries) {
+              if (channelTypeEntry.isDirectory()) {
+                const channelDir = path.join(channelTypeDir, channelTypeEntry.name);
+                try {
+                  const channelFiles = await readdir(channelDir);
+                  for (const file of channelFiles) {
+                    if (!file.endsWith(".jsonl")) continue;
+                    const filePath = path.join(channelDir, file);
+                    if (this.isLegacyTranscriptFile(file)) {
+                      const dateStr = file.slice(0, 10);
+                      const fileDate = new Date(dateStr);
+                      if (!isNaN(fileDate.getTime()) && fileDate < cutoff) {
+                        try {
+                          await unlink(filePath);
+                          processed++;
+                          log.debug(`deleted old daily transcript file: ${entry.name}/${channelTypeEntry.name}/${file}`);
+                        } catch (err) {
+                          log.error(`failed to delete transcript file ${filePath}:`, err);
+                        }
+                      }
+                    } else {
+                      const cleaned = await this.cleanupTranscriptFile(filePath, cutoff);
+                      if (cleaned) {
+                        processed++;
+                      }
+                    }
+                  }
+                } catch (err) {
+                  log.debug(`failed to process channel directory ${entry.name}/${channelTypeEntry.name}:`, err);
+                }
+              } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl")) {
+                const filePath = path.join(channelTypeDir, channelTypeEntry.name);
+                const cleaned = await this.cleanupTranscriptFile(filePath, cutoff);
+                if (cleaned) {
+                  processed++;
+                }
+              }
+            }
+          } catch (err) {
+            log.debug(`failed to process channel type directory ${entry.name}:`, err);
+          }
+        } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          if (this.isLegacyTranscriptFile(entry.name)) {
+            const dateStr = entry.name.slice(0, 10);
+            const fileDate = new Date(dateStr);
+            if (!isNaN(fileDate.getTime()) && fileDate < cutoff) {
+              const filePath = path.join(this.transcriptsDir, entry.name);
+              try {
+                await unlink(filePath);
+                processed++;
+                log.debug(`deleted old legacy transcript file: ${entry.name}`);
+              } catch (err) {
+                log.error(`failed to delete legacy transcript file ${entry.name}:`, err);
+              }
+            }
+          }
+        }
+      }
+      if (processed > 0) {
+        log.info(`cleaned up ${processed} transcript file(s) older than ${retentionDays} days`);
+      }
+      return processed;
+    } catch (err) {
+      log.error("failed to cleanup old transcripts:", err);
+      return 0;
+    }
+  }
+  /**
+   * Clean up old entries from a single transcript file.
+   * Reads the file, filters out entries older than cutoff, and rewrites if needed.
+   * Returns true if the file was processed (cleaned or deleted).
+   */
+  async cleanupTranscriptFile(filePath, cutoff) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const validLines = [];
+      let hasOldEntries = false;
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          const entryTime = new Date(entry.timestamp);
+          if (entryTime >= cutoff) {
+            validLines.push(line);
+          } else {
+            hasOldEntries = true;
+          }
+        } catch {
+          validLines.push(line);
+        }
+      }
+      if (validLines.length === 0) {
+        try {
+          await unlink(filePath);
+          log.debug(`deleted empty transcript file: ${filePath}`);
+          return true;
+        } catch (err) {
+          log.error(`failed to delete empty transcript file ${filePath}:`, err);
+          return false;
+        }
+      }
+      if (hasOldEntries) {
+        await writeFile(filePath, validLines.join("\n") + "\n", "utf-8");
+        log.debug(`cleaned old entries from transcript file: ${filePath}`);
+        return true;
+      }
+      return false;
+    } catch (err) {
+      return false;
+    }
+  }
+  /**
+   * Save a checkpoint to preserve conversation context.
+   * Called when compaction is detected.
+   */
+  async saveCheckpoint(checkpoint) {
+    try {
+      await writeFile(this.checkpointPath, JSON.stringify(checkpoint, null, 2), "utf-8");
+      log.info(`saved checkpoint for session ${checkpoint.sessionKey} with ${checkpoint.turns.length} turn(s)`);
+    } catch (err) {
+      log.error("failed to save checkpoint:", err);
+      throw err;
+    }
+  }
+  /**
+   * Load a checkpoint if one exists and is not expired.
+   * Returns null if no checkpoint exists or if it has expired.
+   */
+  async loadCheckpoint(sessionKey) {
+    try {
+      const raw = await readFile(this.checkpointPath, "utf-8");
+      const checkpoint = JSON.parse(raw);
+      if (!checkpoint.sessionKey || !checkpoint.capturedAt || !checkpoint.ttl || !Array.isArray(checkpoint.turns)) {
+        log.warn("checkpoint file has invalid structure");
+        return null;
+      }
+      if (sessionKey && checkpoint.sessionKey !== sessionKey) {
+        log.debug(`checkpoint session mismatch: ${checkpoint.sessionKey} vs ${sessionKey}`);
+        return null;
+      }
+      const ttl = new Date(checkpoint.ttl);
+      if (isNaN(ttl.getTime())) {
+        log.warn("checkpoint has invalid TTL format");
+        return null;
+      }
+      if (ttl < /* @__PURE__ */ new Date()) {
+        log.info(`checkpoint expired at ${checkpoint.ttl}`);
+        return null;
+      }
+      log.info(`loaded checkpoint with ${checkpoint.turns.length} turn(s), expires at ${checkpoint.ttl}`);
+      return checkpoint;
+    } catch (err) {
+      log.debug("no valid checkpoint found");
+      return null;
+    }
+  }
+  /**
+   * Clear (delete) the checkpoint file.
+   * Called after successful injection of checkpoint context.
+   */
+  async clearCheckpoint() {
+    try {
+      await unlink(this.checkpointPath);
+      log.info("cleared checkpoint");
+    } catch (err) {
+      log.debug("no checkpoint to clear");
+    }
+  }
+  /**
+   * Format entries for recall injection.
+   * Returns a formatted string suitable for injecting into agent context.
+   *
+   * Format:
+   * ## Recent Conversation (last X hours)
+   * [10:32] User: message content
+   * [10:33] Assistant: response content
+   *
+   * Content is trimmed to approximately maxTokens.
+   */
+  formatForRecall(entries, maxTokens) {
+    if (entries.length === 0) {
+      return "";
+    }
+    const maxChars = maxTokens * _TranscriptManager.CHARS_PER_TOKEN;
+    const lines = [];
+    const firstEntry = new Date(entries[0].timestamp);
+    const lastEntry = new Date(entries[entries.length - 1].timestamp);
+    const hoursDiff = Math.round((lastEntry.getTime() - firstEntry.getTime()) / (60 * 60 * 1e3));
+    if (hoursDiff < 1) {
+      lines.push("## Recent Conversation (last few minutes)");
+    } else {
+      lines.push(`## Recent Conversation (last ${hoursDiff} hour${hoursDiff === 1 ? "" : "s"})`);
+    }
+    lines.push("");
+    const formattedEntries = [];
+    for (const entry of entries) {
+      const time = new Date(entry.timestamp);
+      const timeStr = time.toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false
+      });
+      const roleLabel = entry.role === "user" ? "User" : "Assistant";
+      formattedEntries.push(`[${timeStr}] ${roleLabel}: ${entry.content}`);
+    }
+    let totalChars = lines.join("\n").length;
+    const selectedEntries = [];
+    for (let i = formattedEntries.length - 1; i >= 0; i--) {
+      const entry = formattedEntries[i];
+      const entryChars = entry.length + 1;
+      if (totalChars + entryChars > maxChars && selectedEntries.length > 0) {
+        break;
+      }
+      selectedEntries.unshift(entry);
+      totalChars += entryChars;
+    }
+    lines.push(...selectedEntries);
+    lines.push("");
+    const result = lines.join("\n");
+    log.debug(`formatted ${selectedEntries.length}/${entries.length} transcript entries for recall (~${result.length} chars)`);
+    return result;
+  }
+  /**
+   * Create a checkpoint from the current buffer state.
+   * Helper method for creating checkpoints before compaction.
+   */
+  createCheckpoint(sessionKey, turns, ttlHours) {
+    const ttl = ttlHours ?? _TranscriptManager.DEFAULT_CHECKPOINT_TTL_HOURS;
+    const expiresAt = /* @__PURE__ */ new Date();
+    expiresAt.setHours(expiresAt.getHours() + ttl);
+    return {
+      sessionKey,
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      turns: [...turns],
+      // Copy turns to avoid mutation
+      ttl: expiresAt.toISOString()
+    };
+  }
+  /**
+   * Get statistics about stored transcripts.
+   * Returns counts from the hierarchical directory structure.
+   */
+  async getStats() {
+    try {
+      const allFiles = await this.getAllTranscriptFiles();
+      if (allFiles.length === 0) {
+        return {
+          totalFiles: 0,
+          totalEntries: 0,
+          oldestFile: null,
+          newestFile: null,
+          channelTypes: {}
+        };
+      }
+      const sortedFiles = allFiles.sort();
+      let totalEntries = 0;
+      const channelTypes = {};
+      for (const relativePath of allFiles) {
+        const filePath = path.join(this.transcriptsDir, relativePath);
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const lines = content.trim().split("\n").filter(Boolean);
+          totalEntries += lines.length;
+          const channelType = relativePath.includes(path.sep) ? relativePath.split(path.sep)[0] : "legacy";
+          channelTypes[channelType] = (channelTypes[channelType] || 0) + 1;
+        } catch {
+        }
+      }
+      return {
+        totalFiles: allFiles.length,
+        totalEntries,
+        oldestFile: sortedFiles[0],
+        newestFile: sortedFiles[sortedFiles.length - 1],
+        channelTypes
+      };
+    } catch (err) {
+      log.error("failed to get transcript stats:", err);
+      return {
+        totalFiles: 0,
+        totalEntries: 0,
+        oldestFile: null,
+        newestFile: null,
+        channelTypes: {}
+      };
+    }
+  }
+  async analyzeIntegrity() {
+    return analyzeSessionIntegrity({ memoryDir: this.config.memoryDir });
+  }
+  async getRecoverySummary(sessionKey) {
+    const report = await this.analyzeIntegrity();
+    const selectedSessions = sessionKey ? report.sessions.filter((session) => session.sessionKey === sessionKey) : report.sessions;
+    const incompleteTurns = selectedSessions.reduce((sum, session) => sum + session.incompleteTurns, 0);
+    const brokenChains = selectedSessions.reduce((sum, session) => sum + session.brokenChains, 0);
+    const filteredIssues = report.issues.filter((issue) => !sessionKey || issue.sessionKey === sessionKey);
+    const issueCount = filteredIssues.length;
+    const severeIssueCount = filteredIssues.filter((issue) => issue.severity !== "info").length;
+    return {
+      generatedAt: report.generatedAt,
+      sessionKey,
+      healthy: sessionKey ? severeIssueCount === 0 && report.checkpoint.healthy : report.healthy,
+      issueCount,
+      incompleteTurns,
+      brokenChains,
+      checkpointHealthy: report.checkpoint.healthy
+    };
+  }
+};
+
+export {
+  TranscriptManager
+};
+//# sourceMappingURL=chunk-5375UYTQ.js.map