mono-pilot 0.2.10 → 0.2.13

package/dist/src/memory/runtime/thread.js

@@ -0,0 +1,116 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { MemoryIndexManager } from "../index-manager.js";
+import { memoryLog } from "../log.js";
+function post(msg) {
+    parentPort?.postMessage(msg);
+}
+// Embed requests are forwarded to main thread via postMessage.
+// Each request gets a unique id; main thread replies with the result.
+let embedNextId = 1;
+const embedPending = new Map();
+const embedViaMainThread = (texts) => {
+    const id = embedNextId++;
+    return new Promise((resolve, reject) => {
+        embedPending.set(id, { resolve, reject });
+        post({ type: "embed", id, texts });
+    });
+};
+let manager = null;
+let dirtyTimer = null;
+try {
+    const init = workerData;
+    let lastDirty = true;
+    manager = new MemoryIndexManager({
+        agentId: init.agentId,
+        workspaceDir: init.workspaceDir,
+        settings: init.settings,
+        embedFn: embedViaMainThread,
+        embedModel: init.embedModel,
+        onAutoSyncEvent: (event) => {
+            post({ type: "autoSyncEvent", event });
+        },
+    });
+    memoryLog.info("worker initialized", { agentId: init.agentId });
+    // Periodically broadcast dirty state so the proxy can cache it.
+    const DIRTY_POLL_MS = 2000;
+    dirtyTimer = setInterval(() => {
+        const dirty = manager?.isDirty?.() ?? false;
+        if (dirty !== lastDirty) {
+            lastDirty = dirty;
+            post({ type: "dirty", value: dirty });
+        }
+    }, DIRTY_POLL_MS);
+    dirtyTimer.unref();
+    parentPort?.on("message", (msg) => {
+        // Embed response from main thread
+        if (msg.type === "embedResult") {
+            const { id, data, error } = msg;
+            const pending = embedPending.get(id);
+            if (pending) {
+                embedPending.delete(id);
+                if (error)
+                    pending.reject(new Error(error));
+                else
+                    pending.resolve(data);
+            }
+            return;
+        }
+        void handleRequest(msg);
+    });
+    post({ type: "ready" });
+}
+catch (err) {
+    // Initialization failed — let the process crash so the proxy's exit handler fires.
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[memory-worker] init failed: ${message}`);
+    memoryLog.error("worker init failed", { error: message });
+    process.exit(1);
+}
+async function handleRequest(req) {
+    if (!manager) {
+        post({ id: req.id, type: "error", message: "Manager not initialized" });
+        return;
+    }
+    try {
+        let result;
+        switch (req.type) {
+            case "search":
+                result = await manager.search(req.query, req.opts);
+                break;
+            case "sync":
+                await manager.sync?.({
+                    ...req.opts,
+                    onWorkDetected: req.notifyWorkDetected
+                        ? () => {
+                            post({ type: "syncWorkDetected", requestId: req.id });
+                        }
+                        : undefined,
+                });
+                result = undefined;
+                break;
+            case "syncDirty":
+                if (manager.syncDirty) {
+                    result = await manager.syncDirty();
+                }
+                else {
+                    await manager.sync?.({ reason: "build-dirty" });
+                    result = [];
+                }
+                break;
+            case "close":
+                if (dirtyTimer)
+                    clearInterval(dirtyTimer);
+                await manager.close?.();
+                result = undefined;
+                break;
+        }
+        post({ id: req.id, type: "result", data: result });
+    }
+    catch (err) {
+        post({
+            id: req.id,
+            type: "error",
+            message: err instanceof Error ? err.message : String(err),
+        });
+    }
+}

package/dist/src/memory/search/fts.js

@@ -0,0 +1,57 @@
+import { CHUNKS_TABLE, FTS_TABLE } from "../store/schema.js";
+import { truncateUtf16Safe } from "./text.js";
+export function buildFtsQuery(raw) {
+    const tokens = raw
+        .match(/[\p{L}\p{N}_]+/gu)
+        ?.map((token) => token.trim())
+        .filter(Boolean) ?? [];
+    if (tokens.length === 0)
+        return null;
+    const quoted = tokens.map((token) => `"${token.replaceAll('"', "")}"`);
+    return quoted.join(" AND ");
+}
+export function bm25RankToScore(rank) {
+    const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
+    return 1 / (1 + normalized);
+}
+export function searchFts(params) {
+    if (params.limit <= 0)
+        return [];
+    const ftsQuery = buildFtsQuery(params.query);
+    if (!ftsQuery)
+        return [];
+    const modelClause = params.model ? ` AND ${FTS_TABLE}.model = ?` : "";
+    const modelParams = params.model ? [params.model] : [];
+    const agentJoin = ` JOIN ${CHUNKS_TABLE} c ON c.id = ${FTS_TABLE}.id`;
+    const agentClause = params.agentId ? " AND c.agent_id = ?" : "";
+    const agentParams = params.agentId ? [params.agentId] : [];
+    const sourceClause = params.source ? " AND c.source = ?" : "";
+    const sourceParams = params.source ? [params.source] : [];
+    const rows = params.db
+        .prepare(`SELECT ${FTS_TABLE}.id as id, ${FTS_TABLE}.path as path,
+				   ${FTS_TABLE}.start_line as start_line,
+				   ${FTS_TABLE}.end_line as end_line,
+				   ${FTS_TABLE}.text as text,
+				   bm25(${FTS_TABLE}) AS rank, c.source as source, c.agent_id as agent_id
+			 FROM ${FTS_TABLE}${agentJoin}
+			 WHERE ${FTS_TABLE} MATCH ?${modelClause}${agentClause}${sourceClause}
+			 ORDER BY rank ASC
+			 LIMIT ?`)
+        .all(ftsQuery, ...modelParams, ...agentParams, ...sourceParams, params.limit);
+    return rows
+        .map((row) => {
+        const textScore = bm25RankToScore(row.rank);
+        return {
+            id: row.id,
+            path: row.path,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            score: textScore,
+            textScore,
+            snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+            source: (row.source === "sessions" ? "sessions" : "memory"),
+            agentId: row.agent_id,
+        };
+    })
+        .filter((row) => row.score >= params.minScore);
+}

package/dist/src/memory/search/hybrid.js

@@ -0,0 +1,50 @@
+export function mergeHybridResults(params) {
+    const byId = new Map();
+    for (const entry of params.vector) {
+        byId.set(entry.id, {
+            path: entry.path,
+            startLine: entry.startLine,
+            endLine: entry.endLine,
+            snippet: entry.snippet,
+            vectorScore: entry.vectorScore,
+            textScore: 0,
+            source: entry.source,
+            agentId: entry.agentId,
+        });
+    }
+    for (const entry of params.keyword) {
+        const existing = byId.get(entry.id);
+        if (existing) {
+            existing.textScore = Math.max(existing.textScore, entry.textScore);
+            if (!existing.snippet && entry.snippet) {
+                existing.snippet = entry.snippet;
+            }
+            if (!existing.agentId && entry.agentId) {
+                existing.agentId = entry.agentId;
+            }
+        }
+        else {
+            byId.set(entry.id, {
+                path: entry.path,
+                startLine: entry.startLine,
+                endLine: entry.endLine,
+                snippet: entry.snippet,
+                vectorScore: 0,
+                textScore: entry.textScore,
+                source: entry.source,
+                agentId: entry.agentId,
+            });
+        }
+    }
+    const vectorWeight = params.vectorWeight;
+    const textWeight = params.textWeight;
+    return Array.from(byId.values()).map((entry) => ({
+        path: entry.path,
+        startLine: entry.startLine,
+        endLine: entry.endLine,
+        snippet: entry.snippet,
+        source: entry.source,
+        score: entry.vectorScore * vectorWeight + entry.textScore * textWeight,
+        agentId: entry.agentId,
+    }));
+}

package/dist/src/memory/search/text.js

@@ -0,0 +1,30 @@
+function isHighSurrogate(codeUnit) {
+    return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+function isLowSurrogate(codeUnit) {
+    return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+function sliceUtf16Safe(input, from, to) {
+    const len = input.length;
+    let start = Math.max(0, Math.min(len, Math.floor(from)));
+    let end = Math.max(0, Math.min(len, Math.floor(to)));
+    if (start > 0 && start < len) {
+        const codeUnit = input.charCodeAt(start);
+        if (isLowSurrogate(codeUnit) && isHighSurrogate(input.charCodeAt(start - 1))) {
+            start += 1;
+        }
+    }
+    if (end > 0 && end < len) {
+        const codeUnit = input.charCodeAt(end - 1);
+        if (isHighSurrogate(codeUnit) && isLowSurrogate(input.charCodeAt(end))) {
+            end -= 1;
+        }
+    }
+    return input.slice(start, end);
+}
+export function truncateUtf16Safe(input, maxLen) {
+    const limit = Math.max(0, Math.floor(maxLen));
+    if (input.length <= limit)
+        return input;
+    return sliceUtf16Safe(input, 0, limit);
+}

package/dist/src/memory/search/vector.js

@@ -0,0 +1,43 @@
+import { CHUNKS_TABLE, VECTOR_TABLE } from "../store/schema.js";
+import { truncateUtf16Safe } from "./text.js";
+const vectorToBlob = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
+export async function searchVector(params) {
+    if (params.queryVec.length === 0 || params.limit <= 0) {
+        return [];
+    }
+    const conditions = [];
+    const paramsList = [];
+    if (params.model) {
+        conditions.push("c.model = ?");
+        paramsList.push(params.model);
+    }
+    if (params.agentId) {
+        conditions.push("c.agent_id = ?");
+        paramsList.push(params.agentId);
+    }
+    if (params.source) {
+        conditions.push("c.source = ?");
+        paramsList.push(params.source);
+    }
+    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+    const rows = params.db
+        .prepare(`SELECT c.id, c.path, c.start_line, c.end_line, c.text,
+				   c.source as source,
+				   c.agent_id as agent_id,
+				   vec_distance_cosine(v.embedding, ?) AS dist
+			 FROM ${VECTOR_TABLE} v
+			 JOIN ${CHUNKS_TABLE} c ON c.id = v.id${whereClause}
+			 ORDER BY dist ASC
+			 LIMIT ?`)
+        .all(vectorToBlob(params.queryVec), ...paramsList, params.limit);
+    return rows.map((row) => ({
+        id: row.id,
+        path: row.path,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        vectorScore: 1 - row.dist,
+        snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+        source: row.source === "sessions" ? "sessions" : "memory",
+        agentId: row.agent_id,
+    }));
+}

package/dist/src/memory/session/content-hash.js

@@ -0,0 +1,7 @@
+import { createHash } from "node:crypto";
+const HASH_LENGTH = 12;
+export function buildContentHashSlug(content) {
+    const normalized = content.trim().replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const hash = createHash("sha256").update(normalized).digest("hex");
+    return hash.slice(0, HASH_LENGTH);
+}

package/dist/src/memory/session/entry.js

@@ -0,0 +1,33 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+function shortenHomePath(pathValue) {
+    const home = homedir();
+    return pathValue.startsWith(home) ? `~${pathValue.slice(home.length)}` : pathValue;
+}
+function formatExcerpt(messages) {
+    return messages.map((message) => `${message.role}: ${message.text}`).join("\n");
+}
+export function buildSessionMemoryEntry(input) {
+    const iso = input.timestamp.toISOString();
+    const [datePart, timePart] = iso.split("T");
+    const time = (timePart ?? "").split(".")[0] ?? "";
+    const lines = [
+        `# Session: ${datePart ?? ""} ${time} UTC`,
+        "",
+        `- **Reason**: ${input.reason}`,
+        `- **Session ID**: ${input.sessionId ?? "unknown"}`,
+    ];
+    if (input.sessionFile) {
+        lines.push(`- **Session File**: ${shortenHomePath(input.sessionFile)}`);
+    }
+    lines.push("");
+    if (input.messages.length > 0) {
+        lines.push("## Conversation Excerpt", "", formatExcerpt(input.messages), "");
+    }
+    return lines.join("\n");
+}
+export async function writeSessionMemoryFile(filePath, content) {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+}

package/dist/src/memory/session/flush-policy.js

@@ -0,0 +1,34 @@
+import { loadSessionTranscriptState } from "./transcript/state.js";
+import { readSessionTranscriptDelta } from "./transcript/reader.js";
+import { getSessionTranscriptStatePath, normalizeSessionId } from "./transcript/paths.js";
+function normalizeThreshold(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.trunc(value));
+}
+function hasDeltaThresholds(policy) {
+    return normalizeThreshold(policy.deltaBytes) > 0 || normalizeThreshold(policy.deltaMessages) > 0;
+}
+export async function evaluateSessionFlushDelta(params) {
+    const byteThreshold = normalizeThreshold(params.policy.deltaBytes);
+    const messageThreshold = normalizeThreshold(params.policy.deltaMessages);
+    const initialSessionId = normalizeSessionId(undefined, params.sessionFile);
+    const initialStatePath = getSessionTranscriptStatePath(params.agentId, initialSessionId);
+    const initialState = await loadSessionTranscriptState(initialStatePath);
+    const delta = await readSessionTranscriptDelta(params.sessionFile, initialState.lastLine);
+    const finalSessionId = normalizeSessionId(delta.sessionId, params.sessionFile);
+    const statePath = getSessionTranscriptStatePath(params.agentId, finalSessionId);
+    const state = finalSessionId === initialSessionId ? initialState : await loadSessionTranscriptState(statePath);
+    const finalDelta = finalSessionId === initialSessionId
+        ? delta
+        : await readSessionTranscriptDelta(params.sessionFile, state.lastLine);
+    const bytesReached = byteThreshold > 0 && finalDelta.deltaBytes >= byteThreshold;
+    const messagesReached = messageThreshold > 0 && finalDelta.messages.length >= messageThreshold;
+    return {
+        sessionId: finalSessionId,
+        lastLine: finalDelta.lastLine,
+        deltaBytes: finalDelta.deltaBytes,
+        deltaMessages: finalDelta.messages.length,
+        shouldFlush: hasDeltaThresholds(params.policy) && (bytesReached || messagesReached),
+    };
+}

package/dist/src/memory/session/hook.js

@@ -0,0 +1,191 @@
+import { join } from "node:path";
+import { deriveAgentId } from "../../agents-paths.js";
+import { loadResolvedMemorySearchConfig } from "../config/loader.js";
+import { memoryLog } from "../log.js";
+import { evaluateSessionFlushDelta } from "./flush-policy.js";
+import { buildContentHashSlug } from "./content-hash.js";
+import { buildSessionMemoryEntry, writeSessionMemoryFile } from "./entry.js";
+import { formatSessionTimestampParts, buildMemoryFilename, getAgentMemoryDir } from "./paths.js";
+import { readSessionExcerpt } from "./session-reader.js";
+import { flushSessionTranscript } from "./transcript/flush.js";
+import { publishSystemEvent } from "../../extensions/system-events.js";
+const SESSION_EXCERPT_MAX_MESSAGES = 50;
+async function flushSessionArtifacts(params) {
+    const agentId = deriveAgentId(params.ctx.cwd);
+    memoryLog.info("flush trigger", {
+        agentId,
+        trigger: params.trigger,
+        reason: params.reason,
+        sessionFile: params.sessionFile,
+    });
+    const memoryResult = await flushSessionMemory({
+        agentId,
+        reason: params.reason,
+        sessionFile: params.sessionFile,
+    });
+    const transcriptResult = await flushSessionTranscript({
+        agentId,
+        reason: params.reason,
+        sessionFile: params.sessionFile,
+    });
+    memoryLog.info("flush artifacts written", {
+        agentId,
+        trigger: params.trigger,
+        reason: params.reason,
+        sessionMemoryWritten: memoryResult.written,
+        sessionMemoryPath: memoryResult.filePath,
+        sessionTranscriptWritten: transcriptResult.written,
+        sessionTranscriptPath: transcriptResult.filePath,
+        sessionTranscriptLastLine: transcriptResult.lastLine,
+    });
+    if (memoryResult.written) {
+        publishSystemEvent({
+            source: "memory",
+            level: "info",
+            message: `Session memory flush persisted (${params.trigger}).`,
+            dedupeKey: `memory|session_memory_flush|${params.trigger}`,
+            toast: false,
+            ctx: params.ctx,
+        });
+    }
+    if (transcriptResult.written) {
+        publishSystemEvent({
+            source: "memory",
+            level: "info",
+            message: `Session transcript flush persisted (${params.trigger}).`,
+            dedupeKey: `memory|session_transcript_flush|${params.trigger}`,
+            toast: false,
+            ctx: params.ctx,
+        });
+    }
+}
+function notifySessionFlushFailure(ctx, trigger, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    publishSystemEvent({
+        source: "memory",
+        level: "warning",
+        message: `Session flush failed (${trigger}): ${message}`,
+        dedupeKey: `memory|session_flush_failed|${trigger}`,
+        toast: false,
+        ctx,
+    });
+}
+async function flushSessionMemory(params) {
+    const excerpt = await readSessionExcerpt(params.sessionFile, SESSION_EXCERPT_MAX_MESSAGES);
+    if (excerpt.messages.length === 0) {
+        return { written: false };
+    }
+    const timestamp = new Date();
+    const { date, timeSlug } = formatSessionTimestampParts(timestamp);
+    const hashInput = [excerpt.sessionId ?? "", ...excerpt.messages.map((msg) => `${msg.role}:${msg.text}`)].join("\n");
+    const hashSlug = buildContentHashSlug(hashInput);
+    const filePath = join(getAgentMemoryDir(params.agentId), buildMemoryFilename(date, `${timeSlug}-${hashSlug}`));
+    const content = buildSessionMemoryEntry({
+        timestamp,
+        reason: params.reason,
+        sessionId: excerpt.sessionId,
+        sessionFile: params.sessionFile,
+        messages: excerpt.messages,
+    });
+    await writeSessionMemoryFile(filePath, content);
+    return { written: true, filePath };
+}
+async function handleSessionSwitch(event, ctx) {
+    if (!event.previousSessionFile)
+        return;
+    const settings = await loadResolvedMemorySearchConfig();
+    if (!settings.enabled || !settings.flush.onSessionSwitch)
+        return;
+    await flushSessionArtifacts({
+        reason: event.reason,
+        sessionFile: event.previousSessionFile,
+        ctx,
+        trigger: "session-switch",
+    });
+}
+async function handleSessionBeforeCompact(_event, ctx) {
+    const settings = await loadResolvedMemorySearchConfig();
+    if (!settings.enabled || !settings.flush.onSessionCompact)
+        return;
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (!sessionFile)
+        return;
+    await flushSessionArtifacts({
+        reason: "compaction",
+        sessionFile,
+        ctx,
+        trigger: "session-compact",
+    });
+}
+async function handleTurnEnd(_event, ctx) {
+    const settings = await loadResolvedMemorySearchConfig();
+    if (!settings.enabled)
+        return;
+    const byteThreshold = settings.flush.deltaBytes;
+    const messageThreshold = settings.flush.deltaMessages;
+    if (byteThreshold <= 0 && messageThreshold <= 0)
+        return;
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (!sessionFile)
+        return;
+    const agentId = deriveAgentId(ctx.cwd);
+    const delta = await evaluateSessionFlushDelta({
+        agentId,
+        sessionFile,
+        policy: {
+            deltaBytes: byteThreshold,
+            deltaMessages: messageThreshold,
+        },
+    });
+    memoryLog.info("flush delta evaluated", {
+        agentId,
+        sessionFile,
+        deltaBytes: delta.deltaBytes,
+        deltaMessages: delta.deltaMessages,
+        thresholdBytes: byteThreshold,
+        thresholdMessages: messageThreshold,
+        shouldFlush: delta.shouldFlush,
+    });
+    if (!delta.shouldFlush)
+        return;
+    await flushSessionArtifacts({
+        reason: "resume",
+        sessionFile,
+        ctx,
+        trigger: "delta-threshold",
+    });
+}
+export function registerSessionMemoryHook(pi) {
+    pi.on("session_switch", async (event, ctx) => {
+        try {
+            await handleSessionSwitch(event, ctx);
+        }
+        catch (error) {
+            console.warn(`[memory] session switch flush failed: ${String(error)}`);
+            memoryLog.warn("session switch flush failed", { error: String(error) });
+            notifySessionFlushFailure(ctx, "session-switch", error);
+            // Best effort: session memory is non-critical.
+        }
+    });
+    pi.on("session_before_compact", async (event, ctx) => {
+        try {
+            await handleSessionBeforeCompact(event, ctx);
+        }
+        catch (error) {
+            console.warn(`[memory] session_before_compact flush failed: ${String(error)}`);
+            memoryLog.warn("session_before_compact flush failed", { error: String(error) });
+            notifySessionFlushFailure(ctx, "session-compact", error);
+            // Best effort: session memory is non-critical.
+        }
+    });
+    pi.on("turn_end", async (event, ctx) => {
+        try {
+            await handleTurnEnd(event, ctx);
+        }
+        catch (error) {
+            console.warn(`[memory] turn_end delta flush failed: ${String(error)}`);
+            memoryLog.warn("turn_end delta flush failed", { error: String(error) });
+            notifySessionFlushFailure(ctx, "delta-threshold", error);
+        }
+    });
+}

package/dist/src/memory/session/paths.js

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { getAgentDir } from "../../agents-paths.js";
+export function getAgentMemoryDir(agentId) {
+    return join(getAgentDir(agentId), "memory");
+}
+export function formatSessionTimestampParts(timestamp) {
+    const iso = timestamp.toISOString();
+    const [datePart, timePart] = iso.split("T");
+    const time = (timePart ?? "").split(".")[0] ?? "";
+    const timeSlug = time.replace(/:/g, "").slice(0, 4);
+    return { date: datePart ?? "", time, timeSlug };
+}
+export function buildMemoryFilename(date, slug) {
+    return `${date}-${slug}.md`;
+}

package/dist/src/memory/session/session-reader.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+function parseJsonLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractTextContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    const texts = content
+        .map((item) => {
+        if (!item || typeof item !== "object")
+            return undefined;
+        const entry = item;
+        return entry.type === "text" && typeof entry.text === "string" ? entry.text : undefined;
+    })
+        .filter((text) => typeof text === "string" && text.trim().length > 0);
+    if (texts.length === 0)
+        return undefined;
+    return texts.join("\n");
+}
+function shouldSkipUserText(text) {
+    return text.trim().startsWith("/");
+}
+const USER_QUERY_OPEN = "<user_query>";
+const USER_QUERY_CLOSE = "</user_query>";
+function extractUserQuery(text) {
+    const start = text.indexOf(USER_QUERY_OPEN);
+    const end = text.lastIndexOf(USER_QUERY_CLOSE);
+    if (start === -1 || end === -1 || end <= start)
+        return undefined;
+    const extracted = text.slice(start + USER_QUERY_OPEN.length, end).trim();
+    return extracted.length > 0 ? extracted : undefined;
+}
+export async function readSessionExcerpt(sessionFile, maxMessages) {
+    const result = { messages: [] };
+    if (maxMessages <= 0)
+        return result;
+    let raw;
+    try {
+        raw = await readFile(sessionFile, "utf-8");
+    }
+    catch {
+        return result;
+    }
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    for (const line of lines) {
+        const entry = parseJsonLine(line);
+        if (!entry)
+            continue;
+        if (entry.type === "session" && typeof entry.id === "string" && !result.sessionId) {
+            result.sessionId = entry.id;
+            continue;
+        }
+        if (entry.type !== "message" || !entry.message)
+            continue;
+        const role = entry.message.role;
+        if (role !== "user" && role !== "assistant")
+            continue;
+        const text = extractTextContent(entry.message.content ?? "");
+        if (!text)
+            continue;
+        let normalized = text.trim();
+        if (!normalized)
+            continue;
+        if (role === "user") {
+            const extracted = extractUserQuery(normalized);
+            if (!extracted)
+                continue;
+            if (shouldSkipUserText(extracted))
+                continue;
+            normalized = extracted;
+        }
+        result.messages.push({ role, text: normalized });
+        if (result.messages.length > maxMessages) {
+            result.messages.shift();
+        }
+    }
+    return result;
+}

package/dist/src/memory/session/transcript/content-hash.js

@@ -0,0 +1,7 @@
+import { createHash } from "node:crypto";
+const HASH_LENGTH = 12;
+export function buildTranscriptContentHashSlug(content) {
+    const normalized = content.trim().replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const hash = createHash("sha256").update(normalized).digest("hex");
+    return hash.slice(0, HASH_LENGTH);
+}