@adhdev/daemon-core 0.8.94 → 0.8.95

package/dist/index.mjs

@@ -7522,6 +7522,125 @@ function listSavedHistorySessions(agentType, options = {}) {
     return { sessions: [], hasMore: false };
   }
 }
+function normalizeCanonicalHermesMessageContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (content == null) return "";
+  try {
+    return JSON.stringify(content).trim();
+  } catch {
+    return String(content).trim();
+  }
+}
+function extractCanonicalHermesMessageTimestamp(message, fallbackTs) {
+  const numericTimestamp = Number(message.receivedAt || message.timestamp || message.ts || 0);
+  if (Number.isFinite(numericTimestamp) && numericTimestamp > 0) return numericTimestamp;
+  const stringTimestamp = typeof message.ts === "string" ? Date.parse(message.ts) : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
+  if (Number.isFinite(stringTimestamp) && stringTimestamp > 0) return stringTimestamp;
+  return fallbackTs;
+}
+function readExistingHermesSessionStartRecord(historySessionId) {
+  try {
+    const dir = path7.join(HISTORY_DIR, "hermes-cli");
+    if (!fs3.existsSync(dir)) return null;
+    const files = listHistoryFiles(dir, historySessionId).sort();
+    for (const file of files) {
+      const lines = fs3.readFileSync(path7.join(dir, file), "utf-8").split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.historySessionId !== historySessionId) continue;
+          if (parsed.kind === "session_start" && parsed.role === "system") {
+            return parsed;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId) {
+  const normalizedSessionId = normalizeSavedHistorySessionId("hermes-cli", historySessionId);
+  if (!normalizedSessionId) return false;
+  try {
+    const sessionFilePath = path7.join(os5.homedir(), ".hermes", "sessions", `session_${normalizedSessionId}.json`);
+    if (!fs3.existsSync(sessionFilePath)) return false;
+    const raw = JSON.parse(fs3.readFileSync(sessionFilePath, "utf-8"));
+    const canonicalMessages = Array.isArray(raw.messages) ? raw.messages : [];
+    const dir = path7.join(HISTORY_DIR, "hermes-cli");
+    fs3.mkdirSync(dir, { recursive: true });
+    const existingSessionStart = readExistingHermesSessionStartRecord(normalizedSessionId);
+    const records = [];
+    if (existingSessionStart) {
+      records.push({
+        ...existingSessionStart,
+        historySessionId: normalizedSessionId
+      });
+    }
+    let fallbackTs = Date.parse(raw.session_start || raw.last_updated || "") || Date.now();
+    for (const message of canonicalMessages) {
+      const role = String(message.role || "").trim();
+      const content = normalizeCanonicalHermesMessageContent(message.content);
+      if (!content) continue;
+      const receivedAt = extractCanonicalHermesMessageTimestamp(message, fallbackTs);
+      fallbackTs = receivedAt + 1;
+      if (role === "user") {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "user",
+          content,
+          kind: "standard",
+          agent: "hermes-cli",
+          historySessionId: normalizedSessionId
+        });
+        continue;
+      }
+      if (role === "assistant") {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "assistant",
+          content,
+          kind: "standard",
+          agent: "hermes-cli",
+          historySessionId: normalizedSessionId
+        });
+        continue;
+      }
+      if (role === "tool") {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "assistant",
+          content,
+          kind: "tool",
+          senderName: "Tool",
+          agent: "hermes-cli",
+          historySessionId: normalizedSessionId
+        });
+      }
+    }
+    if (records.length === 0) return false;
+    const prefix = `${normalizedSessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
+    for (const file of fs3.readdirSync(dir)) {
+      if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
+        fs3.unlinkSync(path7.join(dir, file));
+      }
+    }
+    const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
+    const filePath = path7.join(dir, `${prefix}${targetDate}.jsonl`);
+    fs3.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
+`, "utf-8");
+    invalidatePersistedSavedHistoryIndex("hermes-cli", dir);
+    savedHistorySessionCache.delete("hermes-cli");
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/providers/provider-patch-state.ts
 function isControlValue(value) {
@@ -12432,6 +12551,7 @@ var CliProviderInstance = class {
   historyWriter;
   runtimeMessages = [];
   lastPersistedHistoryMessages = [];
+  lastCanonicalHermesSyncMtimeMs = 0;
   instanceId;
   suppressIdleHistoryReplay = false;
   errorMessage = void 0;
@@ -12464,34 +12584,7 @@ var CliProviderInstance = class {
     await this.enforceFreshSessionLaunchIfNeeded();
     this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
     if (this.providerSessionId) {
-      this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
-      const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
-      this.historyWriter.seedSessionHistory(
-        this.type,
-        restoredHistory.messages,
-        this.providerSessionId,
-        this.instanceId
-      );
-      this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
-        role: message.role,
-        content: message.content,
-        kind: message.kind,
-        senderName: message.senderName,
-        receivedAt: message.receivedAt
-      }));
-      this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
-      if (restoredHistory.messages.length > 0) {
-        this.adapter.seedCommittedMessages(
-          restoredHistory.messages.map((message) => ({
-            role: message.role,
-            content: message.content,
-            timestamp: message.receivedAt,
-            receivedAt: message.receivedAt,
-            kind: message.kind,
-            senderName: message.senderName
-          }))
-        );
-      }
+      this.restorePersistedHistoryFromCurrentSession();
     }
     if (this.providerSessionId && this.launchMode === "resume") {
       const resumedAt = Date.now();
@@ -12600,6 +12693,7 @@ var CliProviderInstance = class {
       parsedMessages = historyMessageCount > 0 ? parsedMessages.slice(-historyMessageCount) : [];
     }
     const mergedMessages = this.mergeConversationMessages(parsedMessages);
+    const canonicalHermesBackedHistory = this.syncCanonicalHermesSavedHistoryIfNeeded();
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     if (parsedMessages.length > 0) {
       const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
@@ -12617,7 +12711,7 @@ var CliProviderInstance = class {
         senderName: typeof message.senderName === "string" ? message.senderName : void 0,
         receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
       }));
-      if (!shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
+      if (!canonicalHermesBackedHistory && !shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
         const incrementalMessages = buildIncrementalHistoryAppendMessages(this.lastPersistedHistoryMessages, normalizedMessagesToSave);
         this.historyWriter.appendNewMessages(
           this.type,
@@ -12627,7 +12721,9 @@ var CliProviderInstance = class {
           this.providerSessionId
         );
       }
-      this.lastPersistedHistoryMessages = normalizedMessagesToSave;
+      if (!canonicalHermesBackedHistory) {
+        this.lastPersistedHistoryMessages = normalizedMessagesToSave;
+      }
     }
     this.applyProviderResponse(parsedStatus, { phase: "immediate" });
     const surface = resolveProviderStateSurface({
@@ -13084,6 +13180,7 @@ ${effect.notification.body || ""}`.trim();
     this.providerSessionId = nextSessionId;
     this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
     this.historyWriter.writeSessionStart(this.type, nextSessionId, this.workingDir, this.instanceId);
+    this.restorePersistedHistoryFromCurrentSession();
     this.adapter.updateRuntimeMeta({ providerSessionId: nextSessionId });
     this.onProviderSessionResolved?.({
       instanceId: this.instanceId,
@@ -13095,6 +13192,61 @@ ${effect.notification.body || ""}`.trim();
     });
     LOG.info("CLI", `[${this.type}] discovered provider session id: ${nextSessionId}`);
   }
+  syncCanonicalHermesSavedHistoryIfNeeded() {
+    if (this.type !== "hermes-cli" || !this.providerSessionId) return false;
+    try {
+      const canonicalPath = path11.join(os11.homedir(), ".hermes", "sessions", `session_${this.providerSessionId}.json`);
+      if (!fs5.existsSync(canonicalPath)) return false;
+      const stat = fs5.statSync(canonicalPath);
+      if (stat.mtimeMs <= this.lastCanonicalHermesSyncMtimeMs) return true;
+      const rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
+      if (!rebuilt) return false;
+      this.lastCanonicalHermesSyncMtimeMs = stat.mtimeMs;
+      const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
+      this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+        role: message.role,
+        content: message.content,
+        kind: message.kind,
+        senderName: message.senderName,
+        receivedAt: message.receivedAt
+      }));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  restorePersistedHistoryFromCurrentSession() {
+    if (!this.providerSessionId) return;
+    this.syncCanonicalHermesSavedHistoryIfNeeded();
+    this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
+    const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
+    this.historyWriter.seedSessionHistory(
+      this.type,
+      restoredHistory.messages,
+      this.providerSessionId,
+      this.instanceId
+    );
+    this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+      role: message.role,
+      content: message.content,
+      kind: message.kind,
+      senderName: message.senderName,
+      receivedAt: message.receivedAt
+    }));
+    this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
+    if (restoredHistory.messages.length > 0) {
+      this.adapter.seedCommittedMessages(
+        restoredHistory.messages.map((message) => ({
+          role: message.role,
+          content: message.content,
+          timestamp: message.receivedAt,
+          receivedAt: message.receivedAt,
+          kind: message.kind,
+          senderName: message.senderName
+        }))
+      );
+    }
+  }
   getProbeDirectories() {
     const dirs = /* @__PURE__ */ new Set();
     const addDir = (value) => {