@lanonasis/recall-forge 1.1.1

package/dist/extraction/markdown-extractor.js

@@ -0,0 +1,228 @@
+// Document-mode extraction for Markdown files
+// Splits by heading sections, emits each as an ExtractionRecord
+import { promises as fs } from "fs";
+import { basename } from "path";
+import { createHash } from "crypto";
+import { shouldCapture } from "../enrichment/capture-filter.js";
+import { detectMemoryType } from "../enrichment/type-detector.js";
+import { extractTags } from "../enrichment/tag-extractor.js";
+import { looksLikePromptInjection } from "../enrichment/prompt-safety.js";
+import { redactSecrets } from "./secret-redactor.js";
+/**
+ * Split a markdown file into heading-delimited sections.
+ * Each section includes the heading text, level (1-6), body content, and starting line number.
+ * Content before the first heading is emitted as a section with heading = filename.
+ */
+function splitMarkdownSections(content, filename) {
+    const lines = content.split("\n");
+    const sections = [];
+    const headingPattern = /^(#{1,6})\s+(.+)$/;
+    let currentHeading = filename.replace(/\.md$/i, "");
+    let currentLevel = 0;
+    let currentLines = [];
+    let currentStart = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const match = headingPattern.exec(lines[i]);
+        if (match) {
+            // Flush previous section
+            const body = currentLines.join("\n").trim();
+            if (body.length > 0) {
+                sections.push({
+                    heading: currentHeading,
+                    level: currentLevel,
+                    body,
+                    lineNumber: currentStart,
+                });
+            }
+            currentHeading = match[2].trim();
+            currentLevel = match[1].length;
+            currentLines = [];
+            currentStart = i + 1;
+        }
+        else {
+            currentLines.push(lines[i]);
+        }
+    }
+    // Flush final section
+    const body = currentLines.join("\n").trim();
+    if (body.length > 0) {
+        sections.push({
+            heading: currentHeading,
+            level: currentLevel,
+            body,
+            lineNumber: currentStart,
+        });
+    }
+    return sections;
+}
+/**
+ * Convert markdown sections into ExtractionRecords.
+ * Each section becomes one record with:
+ *  - text: "{heading}\n\n{body}"  (heading provides context)
+ *  - role: "user" (markdown docs are considered user-authored)
+ *  - sourceFormat: "markdown"
+ */
+function sectionsToRecords(sections) {
+    return sections.map((s) => ({
+        text: s.level > 0 ? `${s.heading}\n\n${s.body}` : s.body,
+        role: "user",
+        sourceFormat: "markdown",
+        lineNumber: s.lineNumber,
+    }));
+}
+function idempotencyKey(filePath, lineNumber, textPrefix) {
+    return createHash("sha256")
+        .update(`${filePath}:${lineNumber}:${textPrefix}`)
+        .digest("hex")
+        .slice(0, 32);
+}
+/**
+ * Detect whether a file is markdown based on extension.
+ * Used by the CLI to route to extractMarkdown() vs extractJsonl().
+ */
+export function isMarkdownFile(filePath) {
+    return /\.(md|markdown|mdx)$/i.test(filePath);
+}
+/**
+ * Extract memories from a Markdown document.
+ *
+ * Pipeline per section:
+ * 1. Split file by headings → MarkdownSection[]
+ * 2. Convert to ExtractionRecord[]
+ * 3. Role filter (default: user only — all sections are "user")
+ * 4. redactSecrets()
+ * 5. shouldCapture() — filter noise
+ * 6. looksLikePromptInjection() — safety check
+ * 7. detectMemoryType() + extractTags() — enrichment
+ * 8. Vector dedup via searchMemories()
+ * 9. createMemory() with idempotency key
+ * 10. Optional local markdown fallback
+ */
+export async function extractMarkdown(options, deps) {
+    const startTime = Date.now();
+    const stats = {
+        linesRead: 0,
+        linesParsed: 0,
+        linesSkipped: 0,
+        recordsExtracted: 0,
+        recordsFiltered: 0,
+        recordsDeduped: 0,
+        recordsStored: 0,
+        secretsRedacted: 0,
+        markdownWritten: 0,
+        errors: 0,
+        durationMs: 0,
+    };
+    const { filePath, channel = "md-extract", dedup = true, dedupThreshold = 0.92, localFallback = false, dryRun = false, limit, strict = false, roles = ["user"], } = options;
+    // Read the entire file
+    let content;
+    try {
+        content = await fs.readFile(filePath, "utf-8");
+    }
+    catch (err) {
+        deps.logger.warn(`Failed to read ${filePath}: ${err instanceof Error ? err.message : "unknown"}`);
+        stats.errors++;
+        stats.durationMs = Date.now() - startTime;
+        return stats;
+    }
+    const lines = content.split("\n");
+    stats.linesRead = lines.length;
+    deps.logger.info(`Format detected: markdown`);
+    // Split into sections
+    const filename = basename(filePath);
+    const sections = splitMarkdownSections(content, filename);
+    const records = sectionsToRecords(sections);
+    stats.linesParsed = stats.linesRead; // all lines are "parsed" in document mode
+    stats.recordsExtracted = records.length;
+    let totalProcessed = 0;
+    for (const record of records) {
+        if (limit && totalProcessed >= limit)
+            break;
+        // Role filter
+        if (roles.length > 0 && !roles.includes(record.role))
+            continue;
+        // Step 1: Redact secrets
+        const redaction = redactSecrets(record.text);
+        stats.secretsRedacted += redaction.secretsFound;
+        const cleanText = redaction.text;
+        // Step 2: Capture filter
+        if (!shouldCapture(cleanText, { strict })) {
+            stats.recordsFiltered++;
+            continue;
+        }
+        // Step 3: Prompt injection check
+        if (looksLikePromptInjection(cleanText)) {
+            stats.recordsFiltered++;
+            continue;
+        }
+        // Step 4: Enrichment
+        const memoryType = detectMemoryType(cleanText, filename);
+        const tags = [
+            ...extractTags(cleanText, filename),
+            "md-extract",
+            filename.replace(/\.md$/i, "").toLowerCase(),
+        ];
+        // Step 5: Vector dedup
+        if (dedup && !dryRun) {
+            try {
+                const existing = await deps.client.searchMemories({
+                    query: cleanText.slice(0, 500),
+                    threshold: dedupThreshold,
+                    limit: 1,
+                });
+                if (existing && existing.length > 0) {
+                    stats.recordsDeduped++;
+                    continue;
+                }
+            }
+            catch (err) {
+                deps.logger.warn(`Dedup check failed: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+        // Step 6: Store
+        if (!dryRun) {
+            const title = cleanText.slice(0, 80).replace(/\s+/g, " ").trim();
+            const params = {
+                title,
+                content: cleanText,
+                type: memoryType,
+                tags,
+                metadata: {
+                    agent_id: deps.config.agentId,
+                    source: "markdown",
+                    channel,
+                    line_number: record.lineNumber,
+                    source_file: filename,
+                    captured_at: new Date().toISOString(),
+                    secrets_redacted: redaction.secretsFound,
+                },
+                idempotency_key: idempotencyKey(filePath, record.lineNumber, cleanText.slice(0, 200)),
+            };
+            try {
+                await deps.client.createMemory(params);
+                stats.recordsStored++;
+            }
+            catch (err) {
+                stats.errors++;
+                deps.logger.warn(`Store failed at line ${record.lineNumber}: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+        else {
+            stats.recordsStored++;
+        }
+        // Step 7: Local markdown fallback
+        if (localFallback && deps.fallback) {
+            try {
+                const title = cleanText.slice(0, 80).replace(/\s+/g, " ").trim();
+                await deps.fallback.writeMemory(title, cleanText);
+                stats.markdownWritten++;
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        totalProcessed++;
+    }
+    stats.durationMs = Date.now() - startTime;
+    return stats;
+}

package/dist/extraction/secret-redactor.d.ts

@@ -0,0 +1,7 @@
+import type { RedactionResult } from "./types.js";
+export declare function redactSecrets(text: string, options?: {
+    redactPII?: boolean;
+}): RedactionResult;
+export declare function containsSecrets(text: string, options?: {
+    redactPII?: boolean;
+}): boolean;

package/dist/extraction/secret-redactor.js

@@ -0,0 +1,112 @@
+// Secret redaction for JSONL extraction
+// Detects and redacts API keys, tokens, credentials, and PII
+const SECRET_PATTERNS = [
+    {
+        name: "lanonasis-api-key",
+        pattern: /\blano_[A-Za-z0-9_-]{20,}\b/g,
+    },
+    {
+        name: "openai-api-key",
+        pattern: /\bsk-[A-Za-z0-9]{20,}\b/g,
+    },
+    {
+        name: "anthropic-api-key",
+        pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+    },
+    {
+        name: "generic-api-key",
+        pattern: /\b(api[_-]?key|apikey)\s*[:=]\s*["']?[A-Za-z0-9_-]{16,}["']?/gi,
+    },
+    {
+        name: "bearer-token",
+        pattern: /\bBearer\s+[A-Za-z0-9._~+\/=-]{20,}\b/gi,
+    },
+    {
+        name: "jwt-token",
+        pattern: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
+    },
+    {
+        name: "aws-access-key",
+        pattern: /\bAKIA[A-Z0-9]{16}\b/g,
+    },
+    {
+        name: "aws-secret-key",
+        pattern: /\baws[_-]?secret[_-]?access[_-]?key\s*[:=]\s*["']?[A-Za-z0-9/+=]{40}["']?/gi,
+    },
+    {
+        name: "database-url",
+        pattern: /\b(postgres|postgresql|mongodb|mysql|redis):\/\/[^"'\s)]+/gi,
+    },
+    {
+        name: "supabase-key",
+        pattern: /\b(eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+|[A-Za-z0-9_-]{40,})\b/g,
+    },
+    {
+        name: "secret-key",
+        pattern: /\b(secret[_-]?key|private[_-]?key)\s*[:=]\s*["']?[A-Za-z0-9_-]{16,}["']?/gi,
+    },
+    {
+        name: "password",
+        pattern: /\b(password|passwd|pwd)\s*[:=]\s*["']?[^\s"']{8,}["']?/gi,
+    },
+];
+const PII_PATTERNS = [
+    {
+        name: "email",
+        pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+    },
+    {
+        name: "phone",
+        pattern: /\+?[\d\s()-]{10,}\b/g,
+    },
+    {
+        name: "credit-card",
+        pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
+    },
+    {
+        name: "ssn",
+        pattern: /\b\d{3}[\s-]?\d{2}[\s-]?\d{4}\b/g,
+    },
+];
+export function redactSecrets(text, options = {}) {
+    let result = text;
+    const secretsFound = [];
+    const { redactPII = true } = options;
+    for (const { name, pattern } of SECRET_PATTERNS) {
+        const matches = result.match(pattern);
+        if (matches && matches.length > 0) {
+            secretsFound.push(name);
+            result = result.replace(pattern, `[REDACTED:${name}]`);
+        }
+    }
+    if (redactPII) {
+        for (const { name, pattern } of PII_PATTERNS) {
+            const matches = result.match(pattern);
+            if (matches && matches.length > 0) {
+                secretsFound.push(name);
+                result = result.replace(pattern, `[REDACTED:${name}]`);
+            }
+        }
+    }
+    return {
+        text: result,
+        secretsFound: secretsFound.length,
+        types: secretsFound,
+    };
+}
+export function containsSecrets(text, options = {}) {
+    const { redactPII = true } = options;
+    for (const { pattern } of SECRET_PATTERNS) {
+        if (pattern.test(text)) {
+            return true;
+        }
+    }
+    if (redactPII) {
+        for (const { pattern } of PII_PATTERNS) {
+            if (pattern.test(text)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/extraction/sqlite-extractor.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractionOptions, ExtractionStats } from "./types.js";
+import type { ExtractionDeps } from "./jsonl-extractor.js";
+/**
+ * Detect whether a file is a SQLite database based on extension.
+ */
+export declare function isSqliteFile(filePath: string): boolean;
+/**
+ * Extract memories from an OpenClaw SQLite memory database.
+ *
+ * Reads the `chunks` table and processes each chunk through the standard pipeline:
+ * redact → filter → enrich → dedup → store
+ *
+ * Also reads `meta` for the embedding model info which is logged and tagged.
+ */
+export declare function extractSqlite(options: ExtractionOptions, deps: ExtractionDeps): Promise<ExtractionStats>;

package/dist/extraction/sqlite-extractor.js

@@ -0,0 +1,245 @@
+// Document-mode extraction for OpenClaw SQLite memory databases
+// Reads chunks table, emits each chunk as an ExtractionRecord
+import { createHash } from "crypto";
+import { basename } from "path";
+import { shouldCapture } from "../enrichment/capture-filter.js";
+import { detectMemoryType } from "../enrichment/type-detector.js";
+import { extractTags } from "../enrichment/tag-extractor.js";
+import { looksLikePromptInjection } from "../enrichment/prompt-safety.js";
+import { redactSecrets } from "./secret-redactor.js";
+/**
+ * Detect whether a file is a SQLite database based on extension.
+ */
+export function isSqliteFile(filePath) {
+    return /\.(sqlite3?|db)$/i.test(filePath);
+}
+function idempotencyKey(dbPath, chunkId) {
+    return createHash("sha256")
+        .update(`sqlite:${dbPath}:${chunkId}`)
+        .digest("hex")
+        .slice(0, 32);
+}
+/**
+ * Open a SQLite database using available runtime bindings.
+ *
+ * Priority:
+ *   1. bun:sqlite  — available when running under Bun (OpenClaw's runtime)
+ *   2. node:sqlite — available in Node.js >= 22.5.0 (experimental)
+ *   3. Throws with a clear message if neither is available
+ *
+ * No child_process or shell commands are used.
+ */
+async function openDatabase(dbPath) {
+    // 1. Try Bun's built-in SQLite (primary path — OpenClaw runs on Bun)
+    try {
+        // @ts-ignore — bun:sqlite is a Bun-specific module, not in @types
+        const { Database } = await import("bun:sqlite");
+        const db = new Database(dbPath, { readonly: true });
+        return {
+            all(sql) {
+                return db.query(sql).all();
+            },
+            get(sql) {
+                return db.query(sql).get();
+            },
+            close() {
+                db.close();
+            },
+        };
+    }
+    catch {
+        // bun:sqlite unavailable — try Node.js built-in (Node >= 22.5.0)
+    }
+    // 2. Try Node's built-in sqlite module (Node 22.5+ experimental)
+    try {
+        // @ts-ignore — node:sqlite is experimental and not in stable @types/node
+        const { DatabaseSync } = await import("node:sqlite");
+        const db = new DatabaseSync(dbPath, { open: true });
+        return {
+            all(sql) {
+                const stmt = db.prepare(sql);
+                return stmt.all();
+            },
+            get(sql) {
+                const stmt = db.prepare(sql);
+                return stmt.get();
+            },
+            close() {
+                db.close();
+            },
+        };
+    }
+    catch {
+        // node:sqlite unavailable
+    }
+    throw new Error(`SQLite extraction requires Bun (bun:sqlite) or Node.js >= 22.5 (node:sqlite). ` +
+        `Neither was available in the current runtime. Run this command under Bun or upgrade Node.`);
+}
+/**
+ * Extract memories from an OpenClaw SQLite memory database.
+ *
+ * Reads the `chunks` table and processes each chunk through the standard pipeline:
+ * redact → filter → enrich → dedup → store
+ *
+ * Also reads `meta` for the embedding model info which is logged and tagged.
+ */
+export async function extractSqlite(options, deps) {
+    const startTime = Date.now();
+    const stats = {
+        linesRead: 0,
+        linesParsed: 0,
+        linesSkipped: 0,
+        recordsExtracted: 0,
+        recordsFiltered: 0,
+        recordsDeduped: 0,
+        recordsStored: 0,
+        secretsRedacted: 0,
+        markdownWritten: 0,
+        errors: 0,
+        durationMs: 0,
+    };
+    const { filePath, channel = "sqlite-extract", dedup = true, dedupThreshold = 0.92, localFallback = false, dryRun = false, limit, strict = false, } = options;
+    const dbName = basename(filePath);
+    let db;
+    try {
+        db = await openDatabase(filePath);
+    }
+    catch (err) {
+        deps.logger.warn(`Failed to open ${filePath}: ${err instanceof Error ? err.message : "unknown"}`);
+        stats.errors++;
+        stats.durationMs = Date.now() - startTime;
+        return stats;
+    }
+    deps.logger.info(`Format detected: sqlite (${dbName})`);
+    // Read embedding model from meta if available
+    let embeddingModel = "unknown";
+    try {
+        const meta = db.get("SELECT value FROM meta WHERE key = 'memory_index_meta_v1'");
+        if (meta && typeof meta.value === "string") {
+            try {
+                const parsed = JSON.parse(meta.value);
+                embeddingModel = parsed.model ?? "unknown";
+                deps.logger.info(`Embedding model: ${embeddingModel} via ${parsed.provider ?? "unknown"}`);
+            }
+            catch { /* non-fatal */ }
+        }
+    }
+    catch { /* meta table might not exist */ }
+    // Read all chunks
+    let chunks;
+    try {
+        chunks = db.all("SELECT id, path, source, start_line, end_line, model, text, updated_at FROM chunks ORDER BY updated_at ASC");
+    }
+    catch (err) {
+        deps.logger.warn(`Failed to read chunks: ${err instanceof Error ? err.message : "unknown"}`);
+        db.close();
+        stats.errors++;
+        stats.durationMs = Date.now() - startTime;
+        return stats;
+    }
+    stats.linesRead = chunks.length;
+    stats.linesParsed = chunks.length;
+    stats.recordsExtracted = chunks.length;
+    let totalProcessed = 0;
+    for (const chunk of chunks) {
+        if (limit && totalProcessed >= limit)
+            break;
+        if (!chunk.text || chunk.text.trim().length === 0) {
+            stats.linesSkipped++;
+            continue;
+        }
+        // Step 1: Redact secrets
+        const redaction = redactSecrets(chunk.text);
+        stats.secretsRedacted += redaction.secretsFound;
+        const cleanText = redaction.text;
+        // Step 2: Capture filter
+        if (!shouldCapture(cleanText, { strict })) {
+            stats.recordsFiltered++;
+            continue;
+        }
+        // Step 3: Prompt injection check
+        if (looksLikePromptInjection(cleanText)) {
+            stats.recordsFiltered++;
+            continue;
+        }
+        // Step 4: Enrichment
+        const sourceFile = chunk.path || dbName;
+        const memoryType = detectMemoryType(cleanText, sourceFile);
+        const tags = [
+            ...extractTags(cleanText, sourceFile),
+            "sqlite-extract",
+            dbName.replace(/\.sqlite3?$/i, ""),
+        ];
+        if (chunk.source)
+            tags.push(chunk.source);
+        // Step 5: Vector dedup
+        if (dedup && !dryRun) {
+            try {
+                const existing = await deps.client.searchMemories({
+                    query: cleanText.slice(0, 500),
+                    threshold: dedupThreshold,
+                    limit: 1,
+                });
+                if (existing && existing.length > 0) {
+                    stats.recordsDeduped++;
+                    continue;
+                }
+            }
+            catch (err) {
+                deps.logger.warn(`Dedup check failed: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+        // Step 6: Store
+        if (!dryRun) {
+            const title = cleanText.slice(0, 80).replace(/\s+/g, " ").trim();
+            const params = {
+                title,
+                content: cleanText,
+                type: memoryType,
+                tags,
+                metadata: {
+                    agent_id: deps.config.agentId,
+                    source: "sqlite",
+                    channel,
+                    source_file: sourceFile,
+                    chunk_id: chunk.id,
+                    start_line: chunk.start_line,
+                    end_line: chunk.end_line,
+                    embedding_model: chunk.model || embeddingModel,
+                    captured_at: chunk.updated_at
+                        ? new Date(chunk.updated_at * 1000).toISOString()
+                        : new Date().toISOString(),
+                    secrets_redacted: redaction.secretsFound,
+                },
+                idempotency_key: idempotencyKey(filePath, chunk.id),
+            };
+            try {
+                await deps.client.createMemory(params);
+                stats.recordsStored++;
+            }
+            catch (err) {
+                stats.errors++;
+                deps.logger.warn(`Store failed for chunk ${chunk.id.slice(0, 8)}: ${err instanceof Error ? err.message : "unknown"}`);
+            }
+        }
+        else {
+            stats.recordsStored++;
+        }
+        // Step 7: Local markdown fallback
+        if (localFallback && deps.fallback) {
+            try {
+                const title = cleanText.slice(0, 80).replace(/\s+/g, " ").trim();
+                await deps.fallback.writeMemory(title, cleanText);
+                stats.markdownWritten++;
+            }
+            catch { /* non-fatal */ }
+        }
+        totalProcessed++;
+        if (totalProcessed % 100 === 0) {
+            deps.logger.info(`Progress: ${totalProcessed}/${chunks.length} chunks processed, ${stats.recordsStored} stored`);
+        }
+    }
+    db.close();
+    stats.durationMs = Date.now() - startTime;
+    return stats;
+}

package/dist/extraction/types.d.ts

@@ -0,0 +1,50 @@
+/** A single meaningful record extracted from one JSONL line */
+export interface ExtractionRecord {
+    text: string;
+    role: "user" | "assistant" | "system" | "unknown";
+    sourceFormat: string;
+    lineNumber: number;
+    timestamp?: string;
+}
+/** Result of the redaction pass */
+export interface RedactionResult {
+    text: string;
+    secretsFound: number;
+    types: string[];
+}
+/** Stats reported after extraction completes */
+export interface ExtractionStats {
+    linesRead: number;
+    linesParsed: number;
+    linesSkipped: number;
+    recordsExtracted: number;
+    recordsFiltered: number;
+    recordsDeduped: number;
+    recordsStored: number;
+    secretsRedacted: number;
+    markdownWritten: number;
+    errors: number;
+    durationMs: number;
+}
+/** Options for the extraction function */
+export interface ExtractionOptions {
+    filePath: string;
+    format?: "claude-code" | "openclaw-cache" | "openclaw-session" | "codex" | "generic" | "markdown" | "sqlite";
+    channel?: string;
+    dedup?: boolean;
+    dedupThreshold?: number;
+    localFallback?: boolean;
+    batchSize?: number;
+    dryRun?: boolean;
+    limit?: number;
+    strict?: boolean;
+    roles?: string[];
+    /** Enable PII detection alongside secret redaction (default: true) */
+    redactPII?: boolean;
+}
+/** A format adapter converts a parsed JSON line into ExtractionRecords */
+export interface FormatAdapter {
+    name: string;
+    detect(sample: Record<string, unknown>): boolean;
+    extract(line: Record<string, unknown>, lineNumber: number): ExtractionRecord[];
+}

package/dist/extraction/types.js

@@ -0,0 +1 @@
+export {};

package/dist/hooks/capture.d.ts

@@ -0,0 +1,23 @@
+import type { LanonasisClient } from "../client.js";
+import type { LanonasisConfig } from "../config.js";
+import type { LocalFallbackWriter } from "./local-fallback.js";
+import type { PrivacyGuard } from "../privacy/privacy-guard.js";
+import type { PrivacyLogWriter } from "../privacy/privacy-log.js";
+export declare function createCaptureHook(client: LanonasisClient, cfg: LanonasisConfig, logger: {
+    info(msg: string): void;
+    warn(msg: string): void;
+}, fallback: LocalFallbackWriter, guard?: PrivacyGuard, privacyLog?: PrivacyLogWriter): (event: {
+    messages: unknown[];
+    success: boolean;
+    error?: string;
+}) => Promise<void>;
+export declare function createCompactionCaptureHook(client: LanonasisClient, cfg: LanonasisConfig, logger: {
+    info(msg: string): void;
+    warn(msg: string): void;
+}, guard?: PrivacyGuard): (event: {
+    messageCount: number;
+    messages?: unknown[];
+    sessionFile?: string;
+    tokenCount?: number;
+    compactingCount?: number;
+}) => Promise<void>;