@bubblebrain-ai/bubble 0.0.1

package/dist/memory/db.js

@@ -0,0 +1,313 @@
+import { mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+import { getMemoryPaths } from "./paths.js";
+const SCHEMA_VERSION = 1;
+const GLOBAL_CONSOLIDATION_KIND = "memory_consolidate_global";
+const GLOBAL_CONSOLIDATION_KEY = "global";
+const PHASE1_KIND = "memory_phase1_extract";
+const require = createRequire(import.meta.url);
+export class MemoryDatabase {
+    db;
+    constructor(cwd) {
+        const path = getMemoryPaths(cwd).globalDatabase;
+        mkdirSync(dirname(path), { recursive: true });
+        this.db = createDatabase(path);
+        setWalMode(this.db);
+        this.migrate();
+    }
+    close() {
+        this.db.close();
+    }
+    path(cwd) {
+        return getMemoryPaths(cwd).globalDatabase;
+    }
+    upsertStage1Output(output) {
+        this.db.prepare(`
+      INSERT INTO memory_stage1_outputs (
+        session_file, cwd, entry_count, source_updated_at, generated_at,
+        raw_memory, rollout_summary, rollout_slug, usage_count, selected_for_phase2
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0)
+      ON CONFLICT(session_file) DO UPDATE SET
+        cwd = excluded.cwd,
+        entry_count = excluded.entry_count,
+        source_updated_at = excluded.source_updated_at,
+        generated_at = excluded.generated_at,
+        raw_memory = excluded.raw_memory,
+        rollout_summary = excluded.rollout_summary,
+        rollout_slug = excluded.rollout_slug,
+        selected_for_phase2 = CASE
+          WHEN memory_stage1_outputs.selected_for_phase2_source_updated_at = excluded.source_updated_at
+          THEN memory_stage1_outputs.selected_for_phase2
+          ELSE 0
+        END
+    `).run(output.sessionFile, output.cwd, output.entryCount, output.sourceUpdatedAt, output.generatedAt, output.rawMemory, output.rolloutSummary, output.rolloutSlug ?? null);
+    }
+    getStage1Output(sessionFile) {
+        const row = this.db.prepare("SELECT * FROM memory_stage1_outputs WHERE session_file = ?").get(sessionFile);
+        return row ? mapStage1(row) : undefined;
+    }
+    claimPhase1Job(sessionFile, workerId, leaseSeconds) {
+        const now = unixNow();
+        const leaseUntil = now + Math.max(0, leaseSeconds);
+        const tx = this.db.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM memory_jobs WHERE kind = ? AND job_key = ?")
+                .get(PHASE1_KIND, sessionFile);
+            if (!row) {
+                this.db.prepare(`
+          INSERT INTO memory_jobs (kind, job_key, status, worker_id, lease_until, started_at, input_watermark, last_success_watermark)
+          VALUES (?, ?, 'running', ?, ?, ?, 0, 0)
+        `).run(PHASE1_KIND, sessionFile, workerId, leaseUntil, now);
+                return { claimed: true };
+            }
+            const job = mapJob(row);
+            if (job.status === "running" && (job.leaseUntil ?? 0) > now) {
+                return { claimed: false, reason: "already running" };
+            }
+            if ((job.retryAt ?? 0) > now) {
+                return { claimed: false, reason: "retry backoff active" };
+            }
+            this.db.prepare(`
+        UPDATE memory_jobs
+        SET status = 'running', worker_id = ?, lease_until = ?, started_at = ?, finished_at = NULL, last_error = NULL
+        WHERE kind = ? AND job_key = ?
+      `).run(workerId, leaseUntil, now, PHASE1_KIND, sessionFile);
+            return { claimed: true };
+        });
+        return tx();
+    }
+    finishPhase1Job(sessionFile, ok, error) {
+        const now = unixNow();
+        this.db.prepare(`
+      UPDATE memory_jobs
+      SET status = ?,
+          finished_at = ?,
+          lease_until = NULL,
+          retry_at = ?,
+          last_error = ?
+      WHERE kind = ? AND job_key = ?
+    `).run(ok ? "succeeded" : "failed", now, ok ? null : now + 3600, error ?? null, PHASE1_KIND, sessionFile);
+    }
+    listStage1Outputs(limit = 40) {
+        return this.db.prepare(`
+      SELECT * FROM memory_stage1_outputs
+      ORDER BY usage_count DESC, COALESCE(last_usage, generated_at) DESC, source_updated_at DESC
+      LIMIT ?
+    `).all(limit).map((row) => mapStage1(row));
+    }
+    listPreviouslySelectedNotIn(sessionFiles) {
+        if (sessionFiles.length === 0) {
+            return this.db.prepare("SELECT * FROM memory_stage1_outputs WHERE selected_for_phase2 = 1")
+                .all()
+                .map((row) => mapStage1(row));
+        }
+        const placeholders = sessionFiles.map(() => "?").join(", ");
+        return this.db.prepare(`
+      SELECT * FROM memory_stage1_outputs
+      WHERE selected_for_phase2 = 1 AND session_file NOT IN (${placeholders})
+      ORDER BY COALESCE(last_usage, generated_at) DESC
+    `).all(...sessionFiles).map((row) => mapStage1(row));
+    }
+    markSelectedForPhase2(outputs) {
+        const tx = this.db.transaction((items) => {
+            this.db.prepare("UPDATE memory_stage1_outputs SET selected_for_phase2 = 0").run();
+            const stmt = this.db.prepare(`
+        UPDATE memory_stage1_outputs
+        SET selected_for_phase2 = 1,
+            selected_for_phase2_source_updated_at = source_updated_at
+        WHERE session_file = ?
+      `);
+            for (const item of items)
+                stmt.run(item.sessionFile);
+        });
+        tx(outputs);
+    }
+    recordUsage(sessionFiles, now = new Date()) {
+        const unique = [...new Set(sessionFiles)];
+        const stmt = this.db.prepare(`
+      UPDATE memory_stage1_outputs
+      SET usage_count = usage_count + 1,
+          last_usage = ?
+      WHERE session_file = ?
+    `);
+        const tx = this.db.transaction((items) => {
+            let count = 0;
+            for (const item of items) {
+                count += stmt.run(now.toISOString(), item).changes ?? 0;
+            }
+            return count;
+        });
+        return tx(unique);
+    }
+    setThreadMemoryMode(sessionFile, mode) {
+        this.db.prepare(`
+      INSERT INTO memory_thread_modes (session_file, mode, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(session_file) DO UPDATE SET mode = excluded.mode, updated_at = excluded.updated_at
+    `).run(sessionFile, mode, new Date().toISOString());
+    }
+    getThreadMemoryMode(sessionFile) {
+        const row = this.db.prepare("SELECT mode FROM memory_thread_modes WHERE session_file = ?").get(sessionFile);
+        return row?.mode === "disabled" ? "disabled" : "enabled";
+    }
+    claimGlobalPhase2Job(workerId, leaseSeconds) {
+        const now = unixNow();
+        const leaseUntil = now + Math.max(0, leaseSeconds);
+        const tx = this.db.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM memory_jobs WHERE kind = ? AND job_key = ?")
+                .get(GLOBAL_CONSOLIDATION_KIND, GLOBAL_CONSOLIDATION_KEY);
+            if (!row) {
+                this.db.prepare(`
+          INSERT INTO memory_jobs (kind, job_key, status, worker_id, lease_until, started_at, input_watermark, last_success_watermark)
+          VALUES (?, ?, 'running', ?, ?, ?, 0, 0)
+        `).run(GLOBAL_CONSOLIDATION_KIND, GLOBAL_CONSOLIDATION_KEY, workerId, leaseUntil, now);
+                return { claimed: true, job: this.getGlobalPhase2Job() };
+            }
+            const job = mapJob(row);
+            if (job.status === "running" && (job.leaseUntil ?? 0) > now) {
+                return { claimed: false, job, reason: "already running" };
+            }
+            if ((job.retryAt ?? 0) > now) {
+                return { claimed: false, job, reason: "retry backoff active" };
+            }
+            this.db.prepare(`
+        UPDATE memory_jobs
+        SET status = 'running', worker_id = ?, lease_until = ?, started_at = ?, finished_at = NULL, last_error = NULL
+        WHERE kind = ? AND job_key = ?
+      `).run(workerId, leaseUntil, now, GLOBAL_CONSOLIDATION_KIND, GLOBAL_CONSOLIDATION_KEY);
+            return { claimed: true, job: this.getGlobalPhase2Job() };
+        });
+        return tx();
+    }
+    finishGlobalPhase2Job(ok, watermark, error) {
+        const now = unixNow();
+        this.db.prepare(`
+      UPDATE memory_jobs
+      SET status = ?,
+          finished_at = ?,
+          lease_until = NULL,
+          retry_at = ?,
+          last_error = ?,
+          last_success_watermark = CASE WHEN ? THEN ? ELSE last_success_watermark END
+      WHERE kind = ? AND job_key = ?
+    `).run(ok ? "succeeded" : "failed", now, ok ? null : now + 3600, error ?? null, ok ? 1 : 0, watermark, GLOBAL_CONSOLIDATION_KIND, GLOBAL_CONSOLIDATION_KEY);
+    }
+    getGlobalPhase2Job() {
+        const row = this.db.prepare("SELECT * FROM memory_jobs WHERE kind = ? AND job_key = ?")
+            .get(GLOBAL_CONSOLIDATION_KIND, GLOBAL_CONSOLIDATION_KEY);
+        return row ? mapJob(row) : undefined;
+    }
+    resetStageData() {
+        const tx = this.db.transaction(() => {
+            this.db.prepare("DELETE FROM memory_stage1_outputs").run();
+            this.db.prepare("DELETE FROM memory_jobs").run();
+        });
+        tx();
+    }
+    stats() {
+        const stage1Outputs = this.db.prepare("SELECT COUNT(*) AS count FROM memory_stage1_outputs").get().count;
+        const disabledThreads = this.db.prepare("SELECT COUNT(*) AS count FROM memory_thread_modes WHERE mode = 'disabled'").get().count;
+        const jobs = this.db.prepare("SELECT * FROM memory_jobs ORDER BY kind, job_key").all().map((row) => mapJob(row));
+        return { stage1Outputs, disabledThreads, jobs };
+    }
+    migrate() {
+        this.db.prepare("CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)").run();
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS memory_stage1_outputs (
+        session_file TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        entry_count INTEGER NOT NULL,
+        source_updated_at TEXT NOT NULL,
+        generated_at TEXT NOT NULL,
+        raw_memory TEXT NOT NULL,
+        rollout_summary TEXT NOT NULL,
+        rollout_slug TEXT,
+        usage_count INTEGER NOT NULL DEFAULT 0,
+        last_usage TEXT,
+        selected_for_phase2 INTEGER NOT NULL DEFAULT 0,
+        selected_for_phase2_source_updated_at TEXT
+      )
+    `).run();
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS memory_jobs (
+        kind TEXT NOT NULL,
+        job_key TEXT NOT NULL,
+        status TEXT NOT NULL,
+        worker_id TEXT,
+        lease_until INTEGER,
+        retry_at INTEGER,
+        input_watermark INTEGER NOT NULL DEFAULT 0,
+        last_success_watermark INTEGER NOT NULL DEFAULT 0,
+        started_at INTEGER,
+        finished_at INTEGER,
+        last_error TEXT,
+        PRIMARY KEY (kind, job_key)
+      )
+    `).run();
+        this.db.prepare(`
+      CREATE TABLE IF NOT EXISTS memory_thread_modes (
+        session_file TEXT PRIMARY KEY,
+        mode TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `).run();
+        this.db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(SCHEMA_VERSION));
+    }
+}
+function mapStage1(row) {
+    return {
+        sessionFile: String(row.session_file),
+        cwd: String(row.cwd),
+        entryCount: Number(row.entry_count),
+        sourceUpdatedAt: String(row.source_updated_at),
+        generatedAt: String(row.generated_at),
+        rawMemory: String(row.raw_memory),
+        rolloutSummary: String(row.rollout_summary),
+        rolloutSlug: typeof row.rollout_slug === "string" ? row.rollout_slug : undefined,
+        usageCount: Number(row.usage_count ?? 0),
+        lastUsage: typeof row.last_usage === "string" ? row.last_usage : undefined,
+        selectedForPhase2: Number(row.selected_for_phase2 ?? 0) === 1,
+        selectedForPhase2SourceUpdatedAt: typeof row.selected_for_phase2_source_updated_at === "string"
+            ? row.selected_for_phase2_source_updated_at
+            : undefined,
+    };
+}
+function mapJob(row) {
+    return {
+        kind: String(row.kind),
+        jobKey: String(row.job_key),
+        status: isJobStatus(row.status) ? row.status : "pending",
+        workerId: typeof row.worker_id === "string" ? row.worker_id : undefined,
+        leaseUntil: typeof row.lease_until === "number" ? row.lease_until : undefined,
+        retryAt: typeof row.retry_at === "number" ? row.retry_at : undefined,
+        inputWatermark: Number(row.input_watermark ?? 0),
+        lastSuccessWatermark: Number(row.last_success_watermark ?? 0),
+        startedAt: typeof row.started_at === "number" ? row.started_at : undefined,
+        finishedAt: typeof row.finished_at === "number" ? row.finished_at : undefined,
+        lastError: typeof row.last_error === "string" ? row.last_error : undefined,
+    };
+}
+function isJobStatus(value) {
+    return value === "pending" || value === "running" || value === "succeeded" || value === "failed";
+}
+function unixNow() {
+    return Math.floor(Date.now() / 1000);
+}
+function createDatabase(path) {
+    if (isBunRuntime()) {
+        const bunSqlite = require("bun:sqlite");
+        return new bunSqlite.Database(path);
+    }
+    const Database = require("better-sqlite3");
+    return new Database(path);
+}
+function setWalMode(db) {
+    if (typeof db.pragma === "function") {
+        db.pragma("journal_mode = WAL");
+        return;
+    }
+    db.prepare("PRAGMA journal_mode = WAL").get();
+}
+function isBunRuntime() {
+    return typeof globalThis.Bun !== "undefined";
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./paths.js";
+export * from "./store.js";
+export * from "./db.js";
+export * from "./phase1.js";
+export * from "./phase2.js";
+export * from "./start.js";
+export * from "./storage.js";
+export * from "./reset.js";
+export * from "./usage.js";

package/dist/memory/index.js

@@ -0,0 +1,9 @@
+export * from "./paths.js";
+export * from "./store.js";
+export * from "./db.js";
+export * from "./phase1.js";
+export * from "./phase2.js";
+export * from "./start.js";
+export * from "./storage.js";
+export * from "./reset.js";
+export * from "./usage.js";

package/dist/memory/paths.d.ts

@@ -0,0 +1,18 @@
+export { getBubbleHome } from "../bubble-home.js";
+export interface MemoryPaths {
+    globalRoot: string;
+    globalAgents: string;
+    globalSummary: string;
+    globalMemory: string;
+    globalRawMemories: string;
+    globalRolloutSummaries: string;
+    globalSkills: string;
+    globalExtensions: string;
+    globalDatabase: string;
+    projectRoot: string;
+    projectBubbleRoot: string;
+    projectAgents: string;
+    projectLocalAgents: string;
+}
+export declare function getMemoryPaths(cwd: string): MemoryPaths;
+export declare function findProjectRoot(cwd: string): string;

package/dist/memory/paths.js

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { dirname, join, parse, resolve } from "node:path";
+export { getBubbleHome } from "../bubble-home.js";
+import { getBubbleHome } from "../bubble-home.js";
+export function getMemoryPaths(cwd) {
+    const bubbleHome = getBubbleHome();
+    const globalRoot = join(bubbleHome, "memories");
+    const projectRoot = findProjectRoot(cwd);
+    const projectBubbleRoot = join(projectRoot, ".bubble");
+    return {
+        globalRoot,
+        globalAgents: join(bubbleHome, "AGENTS.md"),
+        globalSummary: join(globalRoot, "memory_summary.md"),
+        globalMemory: join(globalRoot, "MEMORY.md"),
+        globalRawMemories: join(globalRoot, "raw_memories.md"),
+        globalRolloutSummaries: join(globalRoot, "rollout_summaries"),
+        globalSkills: join(globalRoot, "skills"),
+        globalExtensions: join(globalRoot, "memories_extensions"),
+        globalDatabase: join(globalRoot, "state.sqlite"),
+        projectRoot,
+        projectBubbleRoot,
+        projectAgents: join(projectRoot, "AGENTS.md"),
+        projectLocalAgents: join(projectBubbleRoot, "AGENTS.md"),
+    };
+}
+export function findProjectRoot(cwd) {
+    let current = resolve(cwd);
+    const root = parse(current).root;
+    while (true) {
+        if (existsSync(join(current, ".git"))) {
+            return current;
+        }
+        if (current === root) {
+            return resolve(cwd);
+        }
+        current = dirname(current);
+    }
+}

package/dist/memory/phase1.d.ts

@@ -0,0 +1,23 @@
+import type { Message, ThinkingLevel } from "../types.js";
+export interface Phase1Options {
+    cwd: string;
+    complete: (messages: Message[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+    }) => Promise<string>;
+    model?: string;
+    minEntries?: number;
+    limit?: number;
+    now?: Date;
+}
+export interface Phase1Result {
+    scanned: number;
+    claimed: number;
+    succeeded: number;
+    empty: number;
+    failed: number;
+    skipped: number;
+    errors: string[];
+}
+export declare function runMemoryPhase1(options: Phase1Options): Promise<Phase1Result>;

package/dist/memory/phase1.js

@@ -0,0 +1,172 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { SessionManager } from "../session.js";
+import { MemoryDatabase } from "./db.js";
+import { getBubbleHome } from "./paths.js";
+import { buildStageOneMessages, parseJsonObject } from "./prompts.js";
+import { redactSecrets } from "./store.js";
+const DEFAULT_MIN_ENTRIES = 4;
+const DEFAULT_LIMIT = 24;
+const MAX_TRANSCRIPT_CHARS = 70_000;
+const MAX_CONTENT_CHARS = 3_000;
+export async function runMemoryPhase1(options) {
+    const result = { scanned: 0, claimed: 0, succeeded: 0, empty: 0, failed: 0, skipped: 0, errors: [] };
+    if (!options.model) {
+        result.skipped++;
+        result.errors.push("no active model");
+        return result;
+    }
+    const db = new MemoryDatabase(options.cwd);
+    try {
+        const sessions = listEligibleSessionFiles(options.limit ?? DEFAULT_LIMIT);
+        result.scanned = sessions.length;
+        for (const sessionFile of sessions) {
+            if (db.getThreadMemoryMode(sessionFile) === "disabled") {
+                result.skipped++;
+                continue;
+            }
+            const session = new SessionManager(sessionFile);
+            const sessionCwd = session.getMetadata().cwd ?? options.cwd;
+            const entries = session.getEntries();
+            const entryCount = entries.length;
+            if (countMeaningfulEntries(entries) < (options.minEntries ?? DEFAULT_MIN_ENTRIES)) {
+                result.skipped++;
+                continue;
+            }
+            const sourceUpdatedAt = statSync(sessionFile).mtime.toISOString();
+            const existing = db.getStage1Output(sessionFile);
+            if (existing && existing.entryCount === entryCount && existing.sourceUpdatedAt === sourceUpdatedAt) {
+                result.skipped++;
+                continue;
+            }
+            const claim = db.claimPhase1Job(sessionFile, randomUUID(), 3600);
+            if (!claim.claimed) {
+                result.skipped++;
+                continue;
+            }
+            result.claimed++;
+            try {
+                const transcript = serializeSessionEntries(entries);
+                const raw = await options.complete(buildStageOneMessages({
+                    cwd: sessionCwd,
+                    sessionFile,
+                    transcript,
+                }), {
+                    model: options.model,
+                    temperature: 0,
+                    thinkingLevel: "off",
+                });
+                const parsed = parseJsonObject(raw);
+                const rawMemory = stringField(parsed.raw_memory);
+                const rolloutSummary = stringField(parsed.rollout_summary);
+                if (!rawMemory && !rolloutSummary) {
+                    result.empty++;
+                    continue;
+                }
+                db.upsertStage1Output({
+                    sessionFile,
+                    cwd: sessionCwd,
+                    entryCount,
+                    sourceUpdatedAt,
+                    generatedAt: (options.now ?? new Date()).toISOString(),
+                    rawMemory: redactSecrets(rawMemory || rolloutSummary).text,
+                    rolloutSummary: redactSecrets(rolloutSummary || rawMemory).text,
+                    rolloutSlug: stringField(parsed.rollout_slug) || undefined,
+                });
+                db.finishPhase1Job(sessionFile, true);
+                result.succeeded++;
+            }
+            catch (error) {
+                db.finishPhase1Job(sessionFile, false, error instanceof Error ? error.message : String(error));
+                result.failed++;
+                result.errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+    return result;
+}
+function listEligibleSessionFiles(limit) {
+    const dir = join(getBubbleHome(), "sessions");
+    if (!existsSync(dir))
+        return [];
+    return collectSessionFiles(dir)
+        .filter((file) => {
+        try {
+            return statSync(file).isFile();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)
+        .slice(0, limit);
+}
+function collectSessionFiles(dir) {
+    const files = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectSessionFiles(path));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+function serializeSessionEntries(entries) {
+    const parts = [];
+    let total = 0;
+    for (const entry of entries) {
+        if (total >= MAX_TRANSCRIPT_CHARS)
+            break;
+        const line = serializeSessionEntry(entry);
+        if (!line)
+            continue;
+        parts.push(line);
+        total += line.length + 1;
+    }
+    return truncate(parts.join("\n"), MAX_TRANSCRIPT_CHARS);
+}
+function serializeSessionEntry(entry) {
+    switch (entry.type) {
+        case "metadata":
+            return `[metadata] ${JSON.stringify(entry.metadata)}`;
+        case "summary":
+            return `[summary] ${truncate(entry.summary, MAX_CONTENT_CHARS)}`;
+        case "marker":
+            return `[marker:${entry.kind}] ${entry.value}`;
+        case "user_message":
+            return `[user] ${truncate(contentToText(entry.message.content), MAX_CONTENT_CHARS)}`;
+        case "assistant_message":
+            return `[assistant] ${truncate(entry.message.content, MAX_CONTENT_CHARS)}`;
+        case "tool_call":
+            return `[tool_call:${entry.toolCall.name}] ${truncate(entry.toolCall.arguments, 1_500)}`;
+        case "tool_result":
+            return `[tool_result${entry.message.isError ? " error=true" : ""}] ${truncate(entry.message.content, 2_000)}`;
+        case "todos_snapshot":
+            return `[todos] ${truncate(JSON.stringify(entry.todos), 2_000)}`;
+    }
+}
+function countMeaningfulEntries(entries) {
+    return entries.filter((entry) => entry.type === "user_message"
+        || entry.type === "assistant_message"
+        || entry.type === "tool_call"
+        || entry.type === "tool_result"
+        || entry.type === "summary").length;
+}
+function contentToText(content) {
+    return typeof content === "string"
+        ? content
+        : content.map((part) => part.type === "text" ? part.text : "[image]").join("\n");
+}
+function truncate(value, maxChars) {
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars - 40).trimEnd()}\n[truncated ${value.length - maxChars + 40} chars]`;
+}
+function stringField(value) {
+    return typeof value === "string" ? value.trim() : "";
+}

package/dist/memory/phase2.d.ts

@@ -0,0 +1,19 @@
+import type { Message, ThinkingLevel } from "../types.js";
+export interface Phase2Options {
+    cwd: string;
+    complete: (messages: Message[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+    }) => Promise<string>;
+    model?: string;
+    limit?: number;
+}
+export interface Phase2Result {
+    status: "succeeded" | "skipped" | "failed";
+    reason?: string;
+    selected: number;
+    memoryPath?: string;
+    summaryPath?: string;
+}
+export declare function runMemoryPhase2(options: Phase2Options): Promise<Phase2Result>;