@geminixiang/mikan 1.0.0-beta.7 → 1.0.0-beta.70

package/dist/sessions/{agent-memory-file-manager.js → chat-history-sync.js}

@@ -1,32 +1,33 @@
-import { join } from "path";
-import { isRecord, parseJsonValue, readTextFileIfExists } from "../utils/file-guards.js";
-import { formatLocalTimestamp } from "../utils/date.js";
-import { atomicWritePrivateFile } from "../utils/fs-atomic.js";
+import { officeSessionsDir } from "../office/index.js";
+import { SessionStore } from "./session-store.js";
+import { join } from "node:path";
 import * as log from "../log.js";
-import { isPlatformHistorySession } from "./metadata.js";
-import { createManagedSessionFile, createManagedSessionFileAtPath, extractSessionSuffix, getChannelSessionDir, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, tryResolveCurrentSession, tryResolveThreadSession, } from "./store.js";
+import { isRecord, parseJsonValue, readTextFileIfExists } from "../file-guards.js";
+import { isCommandText } from "../adapters/commands/manifest.js";
+import { formatHistoryLine, stripHistoryLinePrefix } from "./history-line.js";
+import { isPlatformHistorySession } from "./store.js";
+import { isThreadSessionKey } from "./session-key.js";
+import { archiveManagedSessionFile, createManagedSessionFile, createManagedSessionFileAtPath, extractSessionSuffix, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, resolveParentSessionForThread, tryResolveCurrentSession, tryResolveThreadSession, } from "./store.js";
 const DEFAULT_RECENT_DAYS = 14;
 const DEFAULT_MAX_TOP_LEVEL_MESSAGES = 200;
 const CHAT_SYNC_CUSTOM_TYPE = "mikan.chat_sync";
-const BIWEEKLY_ROTATION_ANCHOR = new Date(2026, 0, 4); // Sunday
-const BIWEEKLY_MS = 14 * 24 * 60 * 60 * 1000;
 export function hasMaterializedChatSession(options) {
-    if (!options.sessionKey.includes(":")) {
+    if (!isThreadSessionKey(options.sessionKey)) {
         return resolveChannelSessionFile(options.conversationDir) !== null;
     }
     return (tryResolveThreadSession(getThreadSessionFile(options.conversationDir, options.sessionKey)) !==
         null);
 }
 export function registerThreadSession(options) {
-    if (!options.sessionKey.includes(":"))
+    if (!isThreadSessionKey(options.sessionKey))
         return null;
     const threadFile = getThreadSessionFile(options.conversationDir, options.sessionKey);
     return (tryResolveThreadSession(threadFile) ??
-        createManagedSessionFileAtPath(threadFile, options.cwd ?? options.conversationDir));
+        createManagedSessionFileAtPath(threadFile, options.cwd ?? options.conversationDir, resolveParentSessionForThread(options.conversationDir, extractSessionSuffix(options.sessionKey)) ?? undefined));
 }
 export async function waitForThreadSessionBootstrap(options) {
     const { parentSessionKey, sessionKey, hasThreadSession, isParentRunning, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), pollMs = 100, } = options;
-    if (!sessionKey.includes(":"))
+    if (!isThreadSessionKey(sessionKey))
         return false;
     if (sessionKey === parentSessionKey)
         return false;
@@ -39,7 +40,13 @@ export async function waitForThreadSessionBootstrap(options) {
     }
     return waited;
 }
-export class AgentMemoryFileManager {
+/**
+ * Syncs the platform chat transcript (log.jsonl) into managed session files:
+ * resolves which session file a message belongs to (top-level vs thread,
+ * with biweekly rotation), bootstraps new sessions from recent history, and
+ * incrementally appends log messages the session does not yet represent.
+ */
+export class ChatHistorySync {
     constructor(options = {}) {
         this.recentDays = options.recentDays ?? DEFAULT_RECENT_DAYS;
         this.maxTopLevelMessages = options.maxTopLevelMessages ?? DEFAULT_MAX_TOP_LEVEL_MESSAGES;
@@ -47,14 +54,13 @@ export class AgentMemoryFileManager {
     }
     async resolveSessionScope(options) {
         const cwd = options.cwd ?? options.conversationDir;
-        const sessionDir = getChannelSessionDir(options.conversationDir);
-        if (!options.sessionKey.includes(":")) {
-            const contextFile = this.resolveTopLevelSessionFile({
+        const sessionDir = officeSessionsDir(options.conversationDir);
+        if (!isThreadSessionKey(options.sessionKey)) {
+            const contextFile = await this.resolveTopLevelSessionFile({
                 conversationDir: options.conversationDir,
                 sessionDir,
                 cwd,
                 currentMessageId: options.currentMessageId,
-                rotateTopLevelSession: options.rotateTopLevelSession === true,
             });
             return { sessionDir, contextFile, threadRootMessage: null };
         }
@@ -66,32 +72,49 @@ export class AgentMemoryFileManager {
             currentMessageId: options.currentMessageId,
         });
     }
-    syncSessionManager(options) {
+    async syncSessionManager(options) {
         const records = readConversationLog(options.conversationDir);
-        syncSessionManagerFromLog(options.sessionManager, selectExistingSessionSyncMessages(records, {
-            sessionKey: options.sessionKey.includes(":") ? options.sessionKey : null,
+        return syncSessionManagerFromLog(options.sessionManager, selectExistingSessionSyncMessages(records, {
+            sessionKey: isThreadSessionKey(options.sessionKey) ? options.sessionKey : null,
             excludeMessageId: options.currentMessageId,
-        }), this.historyWindow());
+        }), {
+            recentDays: this.recentDays,
+            maxMessages: this.maxTopLevelMessages,
+            now: this.now(),
+        });
     }
-    resetSession(options) {
+    async resetSession(options) {
         const cwd = options.cwd ?? options.conversationDir;
-        if (options.sessionKey.includes(":")) {
-            return createManagedSessionFileAtPath(getThreadSessionFile(options.conversationDir, options.sessionKey), cwd);
+        const sessionFile = isThreadSessionKey(options.sessionKey)
+            ? resetThreadSessionFile(options.conversationDir, options.sessionKey, cwd)
+            : createManagedSessionFile(officeSessionsDir(options.conversationDir), cwd);
+        const records = readConversationLog(options.conversationDir);
+        const lastMessageId = latestSyncMessageId(records, {
+            sessionKey: isThreadSessionKey(options.sessionKey) ? options.sessionKey : null,
+        });
+        const sessionManager = await openManagedSession(sessionFile, cwd);
+        try {
+            await sessionManager.appendCustomEntry(CHAT_SYNC_CUSTOM_TYPE, {
+                source: "log.jsonl",
+                messageCount: 0,
+                resetAt: this.now().toISOString(),
+                ...(lastMessageId ? { lastMessageId } : {}),
+            });
         }
-        return createManagedSessionFile(getChannelSessionDir(options.conversationDir), cwd);
+        finally {
+            await sessionManager.close();
+        }
+        return sessionFile;
     }
-    resolveTopLevelSessionFile(options) {
-        const records = readConversationLog(options.conversationDir);
+    async resolveTopLevelSessionFile(options) {
+        // Materialization only: an existing session is returned as-is. The
+        // runtime performs the one incremental log sync per event through the
+        // runner, after the writer is created — syncing here too made every
+        // cache-miss event run the pipeline twice.
         const existing = tryResolveCurrentSession(options.sessionDir);
-        if (existing && !isPlatformHistorySession(existing)) {
-            if (!options.rotateTopLevelSession || !shouldRotateTopLevelSession(existing, this.now())) {
-                syncSessionFromLog(existing, options.cwd, selectExistingSessionSyncMessages(records, {
-                    sessionKey: null,
-                    excludeMessageId: options.currentMessageId,
-                }), this.historyWindow());
-                return existing;
-            }
-        }
+        if (existing && !isPlatformHistorySession(existing))
+            return existing;
+        const records = readConversationLog(options.conversationDir);
         const sessionFile = createManagedSessionFile(options.sessionDir, options.cwd);
         const bootstrapRecords = selectRecentTopLevelMessages(records, {
             recentDays: this.recentDays,
@@ -99,119 +122,81 @@ export class AgentMemoryFileManager {
             now: this.now(),
             excludeMessageId: options.currentMessageId,
         });
-        bootstrapSessionFromLog(sessionFile, options.cwd, bootstrapRecords, latestSyncMessageId(records, {
+        await bootstrapSessionFromLog(sessionFile, options.cwd, bootstrapRecords, latestSyncMessageId(records, {
             sessionKey: null,
             excludeMessageId: options.currentMessageId,
         }));
         return sessionFile;
     }
-    historyWindow() {
-        return { recentDays: this.recentDays, maxMessages: this.maxTopLevelMessages, now: this.now() };
-    }
-    resolveThreadSessionScope(options) {
+    async resolveThreadSessionScope(options) {
         const threadFile = getThreadSessionFile(options.conversationDir, options.sessionKey);
         const threadId = extractSessionSuffix(options.sessionKey);
         const records = readConversationLog(options.conversationDir);
         const threadRootMessage = buildThreadRootSeed(findLogRecordById(records, threadId)?.message);
         const existing = tryResolveThreadSession(threadFile);
         if (existing) {
-            syncSessionFromLog(existing, options.cwd, selectExistingSessionSyncMessages(records, {
-                sessionKey: options.sessionKey,
-                excludeMessageId: options.currentMessageId,
-            }), this.historyWindow());
+            // Materialization only; the runtime owns the per-event incremental sync.
             return { sessionDir: options.sessionDir, contextFile: existing, threadRootMessage };
         }
-        createManagedSessionFileAtPath(threadFile, options.cwd);
+        createManagedSessionFileAtPath(threadFile, options.cwd, resolveParentSessionForThread(options.conversationDir, threadId) ?? undefined);
         const bootstrapRecords = selectThreadBootstrapMessages(records, threadId, {
             recentDays: this.recentDays,
             maxTopLevelMessages: this.maxTopLevelMessages,
             now: this.now(),
             excludeMessageId: options.currentMessageId,
         });
-        bootstrapSessionFromLog(threadFile, options.cwd, bootstrapRecords, latestSyncMessageId(records, {
+        await bootstrapSessionFromLog(threadFile, options.cwd, bootstrapRecords, latestSyncMessageId(records, {
             sessionKey: options.sessionKey,
             excludeMessageId: options.currentMessageId,
         }));
         return { sessionDir: options.sessionDir, contextFile: threadFile, threadRootMessage };
     }
 }
-function shouldRotateTopLevelSession(sessionFile, now) {
-    const timestamp = readSessionTimestamp(sessionFile);
-    return timestamp !== null && biweeklyBucket(timestamp) !== biweeklyBucket(now);
-}
-function readSessionTimestamp(sessionFile) {
-    const raw = readTextFileIfExists(sessionFile);
-    if (raw === undefined)
-        return null;
-    const firstLine = raw.split("\n").find((line) => line.trim());
-    if (!firstLine)
-        return null;
+/** The recorded parent of an existing thread session, kept across a reset. */
+function existingThreadParent(threadFile) {
+    let header;
     try {
-        const header = parseJsonValue(firstLine, (value) => isRecord(value), (detail) => (detail === "unexpected JSON shape" ? "expected a JSON object" : detail));
-        if (typeof header.timestamp !== "string")
-            return null;
-        const date = new Date(header.timestamp);
-        return Number.isFinite(date.getTime()) ? date : null;
+        header = SessionStore.readHeader(threadFile);
     }
     catch {
-        return null;
+        return undefined; // File missing or corrupted — the session is recreated.
     }
-}
-function biweeklyBucket(date) {
-    const weekStart = sundayStart(date).getTime();
-    const anchor = sundayStart(BIWEEKLY_ROTATION_ANCHOR).getTime();
-    return Math.floor((weekStart - anchor) / BIWEEKLY_MS);
-}
-function sundayStart(date) {
-    return new Date(date.getFullYear(), date.getMonth(), date.getDate() - date.getDay());
-}
-function readConversationLog(conversationDir) {
-    const logFile = join(conversationDir, "log.jsonl");
-    const raw = readTextFileIfExists(logFile);
-    if (raw === undefined)
-        return [];
-    const lines = raw.trim().split("\n").filter(Boolean);
-    const records = [];
-    for (let i = 0; i < lines.length; i++) {
-        try {
-            const message = parseJsonValue(lines[i], (value) => isRecord(value), (detail) => (detail === "unexpected JSON shape" ? "expected a JSON object" : detail));
-            records.push({ message, index: i });
-        }
-        catch (err) {
-            log.logWarning(`Skipping malformed log entry at ${logFile}:${i + 1}`, err instanceof Error ? err.message : String(err));
-        }
+    const path = header?.parentSession;
+    if (!header || !path)
+        return undefined;
+    // Prefer the stored UUID; legacy sessions without it need the parent file.
+    const id = header.parentSessionId ?? readParentSessionId(path);
+    return id ? { path, id } : undefined;
+}
+function readParentSessionId(parentPath) {
+    try {
+        return SessionStore.readHeader(parentPath)?.id;
     }
-    return coalesceMessagingBotLogChunks(records);
-}
-function coalesceMessagingBotLogChunks(records) {
-    const coalesced = [];
-    for (const record of records) {
-        const previous = coalesced.at(-1);
-        if (previous && canCoalesceMessagingBotLogChunk(previous.message, record.message)) {
-            previous.message.text = `${previous.message.text ?? ""}${record.message.text ?? ""}`;
-            continue;
-        }
-        coalesced.push({ ...record, message: { ...record.message } });
+    catch {
+        return undefined;
     }
-    return coalesced;
 }
-function canCoalesceMessagingBotLogChunk(previous, current) {
-    return (previous.isMessagingBot === true &&
-        current.isMessagingBot === true &&
-        !!previous.ts &&
-        previous.ts === current.ts &&
-        previous.threadTs === current.threadTs &&
-        previous.user === current.user);
+/**
+ * Archive a thread session and create its replacement, preserving lineage:
+ * the original parent is kept rather than re-bound to the current session.
+ */
+function resetThreadSessionFile(conversationDir, sessionKey, cwd) {
+    const threadFile = getThreadSessionFile(conversationDir, sessionKey);
+    const parent = existingThreadParent(threadFile) ??
+        resolveParentSessionForThread(conversationDir, extractSessionSuffix(sessionKey)) ??
+        undefined;
+    archiveManagedSessionFile(threadFile);
+    return createManagedSessionFileAtPath(threadFile, cwd, parent);
 }
 function findLogRecordById(records, messageId) {
     for (let i = records.length - 1; i >= 0; i--) {
-        if (records[i].message.ts === messageId)
+        if (records[i]?.message.ts === messageId)
             return records[i];
     }
     return undefined;
 }
 function selectRecentTopLevelMessages(records, options) {
-    return selectRecentMessages(records.filter((record) => isTopLevelHistoryMessage(record.message, options.excludeMessageId)), options);
+    return selectRecentMessages(recordsBeforeCurrentMessage(records, options.excludeMessageId).filter((record) => isTopLevelHistoryMessage(record.message, options.excludeMessageId)), options);
 }
 function selectRecentMessages(records, options) {
     const sinceMs = options.now.getTime() - options.recentDays * 24 * 60 * 60 * 1000;
@@ -220,17 +205,18 @@ function selectRecentMessages(records, options) {
         .slice(-options.maxMessages);
 }
 function selectThreadBootstrapMessages(records, threadId, options) {
-    const rootRecord = findLogRecordById(records, threadId);
+    const scopedRecords = recordsBeforeCurrentMessage(records, options.excludeMessageId);
+    const rootRecord = findLogRecordById(scopedRecords, threadId);
     const topLevelSource = rootRecord
-        ? records.filter((record) => record.index <= rootRecord.index)
-        : records;
+        ? scopedRecords.filter((record) => record.index <= rootRecord.index)
+        : scopedRecords;
     const topLevelRecords = selectRecentTopLevelMessages(topLevelSource, {
         recentDays: options.recentDays,
         maxMessages: options.maxTopLevelMessages,
         now: options.now,
         excludeMessageId: options.excludeMessageId,
     });
-    const threadRecords = records.filter((record) => isRenderableConversationMessage(record.message, options.excludeMessageId) &&
+    const threadRecords = scopedRecords.filter((record) => isRenderableConversationMessage(record.message, options.excludeMessageId) &&
         (record.message.ts === threadId || record.message.threadTs === threadId));
     return dedupeAndSortRecords([...topLevelRecords, ...threadRecords]);
 }
@@ -247,7 +233,7 @@ function isRecentHistoryMessage(message, sinceMs) {
 }
 function selectExistingSessionSyncMessages(records, options) {
     const threadId = options.sessionKey ? extractSessionSuffix(options.sessionKey) : null;
-    return dedupeAndSortRecords(records.filter((record) => {
+    return dedupeAndSortRecords(recordsBeforeCurrentMessage(records, options.excludeMessageId).filter((record) => {
         if (!isRenderableConversationMessage(record.message, options.excludeMessageId))
             return false;
         if (!threadId)
@@ -255,21 +241,29 @@ function selectExistingSessionSyncMessages(records, options) {
         return record.message.ts === threadId || record.message.threadTs === threadId;
     }));
 }
+/**
+ * Slack logs messages before enqueueing them, so a later queued turn may
+ * already be present while the current turn is being prepared. Chat history
+ * must stop at the current record rather than merely removing that one id.
+ */
+function recordsBeforeCurrentMessage(records, currentMessageId) {
+    if (!currentMessageId)
+        return records;
+    const currentRecord = findLogRecordById(records, currentMessageId);
+    if (!currentRecord)
+        return records;
+    return records.filter((record) => record.index < currentRecord.index);
+}
 function latestSyncMessageId(records, options) {
     return selectExistingSessionSyncMessages(records, options).at(-1)?.message.ts;
 }
 function isRenderableConversationMessage(message, excludeMessageId) {
     if (excludeMessageId && message.ts === excludeMessageId)
         return false;
-    if (isChatCommandMessage(message))
+    if (!message.isMessagingBot && isCommandText(message.text ?? ""))
         return false;
     return !!message.text?.trim();
 }
-function isChatCommandMessage(message) {
-    const text = message.text?.trim() ?? "";
-    return (!message.isMessagingBot &&
-        /^\/(?:pi-[\w-]+|login|session|new|stop|model|sandbox|admin|auto-reply)(?:@\w+)?(?:\s|$)/i.test(text));
-}
 function dedupeAndSortRecords(records) {
     const byKey = new Map();
     for (const record of records) {
@@ -296,74 +290,98 @@ function sortTime(record) {
     }
     return record.index;
 }
-function bootstrapSessionFromLog(sessionFile, cwd, records, lastMessageId = records.at(-1)?.message.ts) {
+async function bootstrapSessionFromLog(sessionFile, cwd, records, lastMessageId = records.at(-1)?.message.ts) {
     if (records.length === 0 && !lastMessageId)
         return;
-    const sessionManager = openManagedSession(sessionFile, cwd);
-    appendLogRecordsToSession(sessionManager, records);
-    sessionManager.appendCustomEntry(CHAT_SYNC_CUSTOM_TYPE, {
-        source: "log.jsonl",
-        messageCount: records.length,
-        lastMessageId,
-    });
-    forceRewriteSession(sessionManager, sessionFile);
-}
-function syncSessionFromLog(sessionFile, cwd, records, historyWindow) {
-    if (records.length === 0)
-        return;
-    syncSessionManagerFromLog(openManagedSession(sessionFile, cwd), records, historyWindow);
+    const sessionManager = await openManagedSession(sessionFile, cwd);
+    try {
+        await appendLogRecordsToSession(sessionManager, records);
+        await sessionManager.appendCustomEntry(CHAT_SYNC_CUSTOM_TYPE, {
+            source: "log.jsonl",
+            messageCount: records.length,
+            lastMessageId,
+        });
+    }
+    finally {
+        await sessionManager.close();
+    }
 }
-function syncSessionManagerFromLog(sessionManager, records, historyWindow) {
+async function syncSessionManagerFromLog(sessionManager, records, historyWindow) {
     if (records.length === 0)
-        return;
-    const existingEntries = sessionManager.getEntries();
+        return { appended: 0 };
+    const existingEntries = await sessionManager.getEntries();
+    const resetAt = getLatestChatSyncResetAt(existingEntries);
+    const controlledIds = new Set(existingEntries.flatMap((entry) => {
+        if (entry.type !== "custom" ||
+            entry.customType !== "mikan.control_input" ||
+            !isRecord(entry.data))
+            return [];
+        return typeof entry.data.messageId === "string" ? [entry.data.messageId] : [];
+    }));
+    const eligibleRecords = records.filter((record) => !controlledIds.has(record.message.ts ?? "") && (!resetAt || isAfterReset(record, resetAt)));
     const lastSyncedMessageId = getLatestChatSyncMessageId(existingEntries);
     const lastSyncedIndex = lastSyncedMessageId
-        ? records.findIndex((record) => record.message.ts === lastSyncedMessageId)
+        ? eligibleRecords.findIndex((record) => record.message.ts === lastSyncedMessageId)
         : -1;
-    if (lastSyncedMessageId && lastSyncedIndex === -1)
-        return;
-    const syncCandidates = selectRecentMessages(records.slice(lastSyncedIndex + 1), historyWindow);
+    // A truncated or rebuilt log may no longer contain the watermark. Replay the
+    // current bounded history; represented-message matching below prevents duplicates.
+    const syncCandidates = selectRecentMessages(eligibleRecords.slice(lastSyncedIndex + 1), historyWindow);
     if (syncCandidates.length === 0)
-        return;
+        return { appended: 0 };
     const represented = buildRepresentedMessageCounts(existingEntries);
     const newRecords = syncCandidates.filter((record) => !consumeRepresentedLogMessage(record, represented));
     if (newRecords.length === 0)
-        return;
-    appendLogRecordsToSession(sessionManager, newRecords);
-    sessionManager.appendCustomEntry(CHAT_SYNC_CUSTOM_TYPE, {
+        return { appended: 0 };
+    const lastMessageId = syncCandidates.at(-1)?.message.ts;
+    await appendLogRecordsToSession(sessionManager, newRecords);
+    await sessionManager.appendCustomEntry(CHAT_SYNC_CUSTOM_TYPE, {
         source: "log.jsonl",
         messageCount: newRecords.length,
-        lastMessageId: syncCandidates.at(-1)?.message.ts,
+        lastMessageId,
     });
+    return {
+        appended: newRecords.length,
+        ...(lastMessageId !== undefined ? { lastMessageId } : {}),
+    };
 }
-function appendLogRecordsToSession(sessionManager, records) {
+async function appendLogRecordsToSession(sessionManager, records) {
     for (const record of records) {
         const message = buildHistorySessionMessage(record.message);
         if (message)
-            sessionManager.appendMessage(message);
+            await sessionManager.appendMessage(message);
     }
 }
-function forceRewriteSession(sessionManager, sessionFile) {
-    const header = sessionManager.getHeader();
-    if (!header)
-        return;
-    const content = [header, ...sessionManager.getEntries()]
-        .map((entry) => JSON.stringify(entry))
-        .join("\n");
-    atomicWritePrivateFile(sessionFile, `${content}\n`);
-}
-function getLatestChatSyncMessageId(entries) {
-    for (let i = entries.length - 1; i >= 0; i--) {
-        const entry = entries[i];
-        if (entry.type !== "custom" || entry.customType !== CHAT_SYNC_CUSTOM_TYPE)
-            continue;
-        if (!isRecord(entry.data))
-            return undefined;
-        return typeof entry.data.lastMessageId === "string" ? entry.data.lastMessageId : undefined;
+function isChatSyncMarker(entry) {
+    return entry.type === "custom" && entry.customType === CHAT_SYNC_CUSTOM_TYPE;
+}
+/** The reset timestamp a chat-sync marker records, when it carries a usable one. */
+function markerResetAt(entry) {
+    if (!isChatSyncMarker(entry))
+        return undefined;
+    if (!isRecord(entry.data) || typeof entry.data.resetAt !== "string")
+        return undefined;
+    const resetAt = new Date(entry.data.resetAt).getTime();
+    return Number.isFinite(resetAt) ? resetAt : undefined;
+}
+function getLatestChatSyncResetAt(entries) {
+    for (const entry of entries.toReversed()) {
+        const resetAt = markerResetAt(entry);
+        if (resetAt !== undefined)
+            return resetAt;
     }
     return undefined;
 }
+function isAfterReset(record, resetAt) {
+    if (!record.message.date)
+        return false;
+    const messageTime = new Date(record.message.date).getTime();
+    return Number.isFinite(messageTime) && messageTime >= resetAt;
+}
+function getLatestChatSyncMessageId(entries) {
+    const marker = entries.toReversed().find(isChatSyncMarker);
+    const lastMessageId = isRecord(marker?.data) ? marker.data.lastMessageId : undefined;
+    return typeof lastMessageId === "string" ? lastMessageId : undefined;
+}
 function buildRepresentedMessageCounts(entries) {
     const counts = new Map();
     for (const entry of entries) {
@@ -413,11 +431,7 @@ function getSessionMessageText(entry) {
         .map((part) => (part.type === "text" && "text" in part ? part.text : ""))
         .join("\n");
 }
-function normalizeComparableText(text) {
-    return text
-        .replace(/^\[[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}[+-][0-9]{2}:[0-9]{2}\]\s+\[[^\]]+\](?:\s+\[in-thread:[^\]]+\])?:\s*/, "")
-        .trim();
-}
+const normalizeComparableText = stripHistoryLinePrefix;
 function buildHistorySessionMessage(message) {
     const text = message.text?.trim();
     if (!text)
@@ -466,10 +480,11 @@ function parseMessageTimestamp(message) {
     return undefined;
 }
 function formatHistoryMessage(message) {
-    const text = message.text?.trim() ?? "";
-    const userLabel = message.userName || message.user || "unknown";
-    const timestamp = message.date ? formatLocalTimestamp(new Date(message.date)) : null;
-    return timestamp ? `[${timestamp}] [${userLabel}]: ${text}` : `[${userLabel}]: ${text}`;
+    return formatHistoryLine({
+        date: message.date ? new Date(message.date) : undefined,
+        userName: message.userName || message.user,
+        text: message.text?.trim() ?? "",
+    });
 }
 function zeroUsage() {
     return {
@@ -481,4 +496,53 @@ function zeroUsage() {
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
     };
 }
-//# sourceMappingURL=agent-memory-file-manager.js.map
+// ── Conversation platform log (log.jsonl) ─────────────────────────────────────
+/**
+ * Read a conversation's platform chat log (log.jsonl): skip malformed lines,
+ * and coalesce consecutive messaging-bot chunks that share a ts — streamed
+ * responses are logged in pieces but represent one message.
+ */
+function readConversationLog(conversationDir) {
+    const logFile = join(conversationDir, "log.jsonl");
+    const raw = readTextFileIfExists(logFile);
+    if (raw === undefined)
+        return [];
+    const records = [];
+    for (const [index, line] of raw.trim().split("\n").filter(Boolean).entries()) {
+        const message = parseLogLine(line, logFile, index + 1);
+        if (message)
+            records.push({ message, index });
+    }
+    return coalesceMessagingBotLogChunks(records);
+}
+/** One log line, or `undefined` after warning about a malformed one. */
+function parseLogLine(line, logFile, lineNumber) {
+    try {
+        return parseJsonValue(line, (value) => isRecord(value), (detail) => (detail === "unexpected JSON shape" ? "expected a JSON object" : detail));
+    }
+    catch (err) {
+        log.logWarning(`Skipping malformed log entry at ${logFile}:${lineNumber}`, err instanceof Error ? err.message : String(err));
+        return undefined;
+    }
+}
+function coalesceMessagingBotLogChunks(records) {
+    const coalesced = [];
+    for (const record of records) {
+        const previous = coalesced.at(-1);
+        if (previous && canCoalesceMessagingBotLogChunk(previous.message, record.message)) {
+            previous.message.text = `${previous.message.text ?? ""}${record.message.text ?? ""}`;
+            continue;
+        }
+        coalesced.push({ ...record, message: { ...record.message } });
+    }
+    return coalesced;
+}
+function canCoalesceMessagingBotLogChunk(previous, current) {
+    return (previous.isMessagingBot === true &&
+        current.isMessagingBot === true &&
+        !!previous.ts &&
+        previous.ts === current.ts &&
+        previous.threadTs === current.threadTs &&
+        previous.user === current.user);
+}
+//# sourceMappingURL=chat-history-sync.js.map