@marifold/core 0.60.0

package/dist/sessions/SessionResolver.js

@@ -0,0 +1,1173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionResolver = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const core_1 = require("@priest-ai/core");
+const MarifoldError_1 = require("../errors/MarifoldError");
+const ATTACHMENTS_TABLE = 'marifold_turn_attachments';
+const RESPONSE_METRICS_TABLE = 'marifold_response_metrics';
+const SESSION_DISPLAY_TABLE = 'marifold_session_display';
+const PROFILE_DISPLAY_TABLE = 'marifold_profile_display';
+const DEFAULT_IMAGE_MEDIA_TYPE = 'image/jpeg';
+const COMPACTION_METADATA_KEY = '__compaction';
+const SESSION_TITLE_MAX_CHARS = 200;
+class SessionResolver {
+    sessionsDb;
+    store;
+    constructor(sessionsDb) {
+        this.sessionsDb = sessionsDb;
+    }
+    /** Open a connection with crash-resilience pragmas. `journal_mode = WAL` is a
+     * persistent file property — set by any connection it sticks and is inherited
+     * by every later opener (including priest's session store), making interrupted
+     * writes far less likely to corrupt the file. `synchronous` and `busy_timeout`
+     * are per-connection, so they are reapplied on every open. */
+    open() {
+        const db = new better_sqlite3_1.default(this.sessionsDb, { fileMustExist: true });
+        db.pragma('journal_mode = WAL');
+        db.pragma('synchronous = NORMAL');
+        db.pragma('busy_timeout = 5000');
+        return db;
+    }
+    /** Read-only health check. Safe to run when the DB is corrupt (it is the whole
+     * point — `marifold doctor` must work when the app won't start), and never
+     * throws: failures are returned as `{ ok: false }`. Opens read/write like the
+     * app does, so a pass means the app can actually read the DB. */
+    checkIntegrity() {
+        if (!fs.existsSync(this.sessionsDb))
+            return { ok: true, exists: false };
+        let db;
+        try {
+            db = new better_sqlite3_1.default(this.sessionsDb, { fileMustExist: true });
+        }
+        catch (error) {
+            return { ok: false, exists: true, error: `cannot open: ${String(error)}` };
+        }
+        try {
+            const rows = db.pragma('integrity_check');
+            const results = rows.map(row => row.integrity_check);
+            if (results.length === 1 && results[0] === 'ok') {
+                const sessions = db.prepare('SELECT count(*) AS c FROM sessions').get().c;
+                const turns = db.prepare('SELECT count(*) AS c FROM turns').get().c;
+                return { ok: true, exists: true, sessions, turns };
+            }
+            return { ok: false, exists: true, error: results.slice(0, 3).join('; ') };
+        }
+        catch (error) {
+            return { ok: false, exists: true, error: String(error) };
+        }
+        finally {
+            db.close();
+        }
+    }
+    openStore() {
+        if (!this.store) {
+            fs.mkdirSync(path.dirname(this.sessionsDb), { recursive: true });
+            this.store = new core_1.SQLiteSessionStore(this.sessionsDb);
+            this.store.open();
+        }
+        return this.store;
+    }
+    list(limit = 50, profileName, options = {}) {
+        if (!fs.existsSync(this.sessionsDb))
+            return [];
+        const db = this.open();
+        try {
+            this.ensureSessionDisplayTable(db);
+            const search = options.search?.trim().toLowerCase() ?? '';
+            const filters = [
+                ...(profileName ? ['s.profile_name = ?'] : []),
+                ['COALESCE(d.archived, 0) = ?'],
+                ...(search ? [`(
+          LOWER(COALESCE(d.title, '')) LIKE ?
+          OR LOWER(COALESCE((
+            SELECT content FROM turns
+            WHERE session_id = s.id AND role = 'user'
+            ORDER BY id ASC
+            LIMIT 1
+          ), '')) LIKE ?
+        )`] : []),
+            ].flat();
+            const params = [
+                ...(profileName ? [profileName] : []),
+                options.archived ? 1 : 0,
+                ...(search ? [`%${search}%`, `%${search}%`] : []),
+                limit,
+            ];
+            const orderBy = options.order === 'recent'
+                ? 's.updated_at DESC'
+                : 'COALESCE(d.pinned, 0) DESC, s.updated_at DESC';
+            const rows = db.prepare(`
+        SELECT
+          s.id AS id,
+          s.profile_name AS profileName,
+          s.created_at AS createdAt,
+          s.updated_at AS updatedAt,
+          d.title AS title,
+          d.pinned AS pinned,
+          d.archived AS archived,
+          COUNT(t.id) AS turnCount,
+          (
+            SELECT content FROM turns
+            WHERE session_id = s.id AND role = 'user'
+            ORDER BY id ASC
+            LIMIT 1
+          ) AS preview
+        FROM sessions s
+        LEFT JOIN turns t ON t.session_id = s.id
+        LEFT JOIN ${SESSION_DISPLAY_TABLE} d ON d.session_id = s.id
+        WHERE ${filters.join(' AND ')}
+        GROUP BY s.id
+        ORDER BY ${orderBy}
+        LIMIT ?
+      `).all(...params);
+            return rows.map(row => {
+                const preview = row.preview ? sessionPreview(row.preview) : '';
+                return {
+                    id: row.id,
+                    profileName: row.profileName,
+                    createdAt: row.createdAt,
+                    updatedAt: row.updatedAt,
+                    turnCount: Number(row.turnCount),
+                    ...(preview ? { preview } : {}),
+                    ...(row.title ? { title: row.title } : {}),
+                    ...(row.pinned === 1 ? { pinned: true } : {}),
+                    ...(row.archived === 1 ? { archived: true } : {}),
+                };
+            });
+        }
+        catch (error) {
+            throw new MarifoldError_1.MarifoldError('SESSION_STORE_ERROR', `Could not list sessions from ${this.sessionsDb}: ${String(error)}`, { sessionsDb: this.sessionsDb });
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Contact-list metadata for every profile represented either by a session
+     * or a pinned display row. The latest session determines activity/preview. */
+    profileActivity() {
+        if (!fs.existsSync(this.sessionsDb))
+            return [];
+        const db = this.open();
+        try {
+            this.ensureProfileDisplayTable(db);
+            const rows = db.prepare(`
+        SELECT
+          p.profile_name AS profileName,
+          p.pinned AS pinned,
+          s.updated_at AS updatedAt,
+          (
+            SELECT content
+            FROM turns
+            WHERE session_id = s.id AND role = 'assistant'
+            ORDER BY id DESC
+            LIMIT 1
+          ) AS response
+        FROM ${PROFILE_DISPLAY_TABLE} p
+        LEFT JOIN sessions s ON s.id = (
+          SELECT latest.id
+          FROM sessions latest
+          WHERE latest.profile_name = p.profile_name
+          ORDER BY latest.updated_at DESC, latest.id DESC
+          LIMIT 1
+        )
+        UNION ALL
+        SELECT
+          s.profile_name AS profileName,
+          0 AS pinned,
+          s.updated_at AS updatedAt,
+          (
+            SELECT content
+            FROM turns
+            WHERE session_id = s.id AND role = 'assistant'
+            ORDER BY id DESC
+            LIMIT 1
+          ) AS response
+        FROM sessions s
+        WHERE s.id = (
+          SELECT latest.id
+          FROM sessions latest
+          WHERE latest.profile_name = s.profile_name
+          ORDER BY latest.updated_at DESC, latest.id DESC
+          LIMIT 1
+        )
+        AND NOT EXISTS (
+          SELECT 1
+          FROM ${PROFILE_DISPLAY_TABLE} p
+          WHERE p.profile_name = s.profile_name
+        )
+      `).all();
+            return rows.map(row => {
+                const preview = row.response ? firstLinePreview(row.response) : '';
+                return {
+                    profileName: row.profileName,
+                    ...(row.pinned === 1 ? { pinned: true } : {}),
+                    ...(row.updatedAt ? { updatedAt: row.updatedAt } : {}),
+                    ...(preview ? { preview } : {}),
+                };
+            });
+        }
+        catch (error) {
+            throw this.storeError(`Could not list profile activity from ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    setProfilePinned(profileName, pinned) {
+        if (!fs.existsSync(this.sessionsDb))
+            this.openStore();
+        const db = this.open();
+        try {
+            this.ensureProfileDisplayTable(db);
+            db.prepare(`
+        INSERT INTO ${PROFILE_DISPLAY_TABLE} (profile_name, pinned)
+        VALUES (?, ?)
+        ON CONFLICT(profile_name) DO UPDATE SET pinned = excluded.pinned
+      `).run(profileName, pinned ? 1 : 0);
+        }
+        catch (error) {
+            throw this.storeError(`Could not update profile '${profileName}' display state: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    deleteProfileDisplay(profileName) {
+        if (!fs.existsSync(this.sessionsDb))
+            return;
+        const db = this.open();
+        try {
+            if (this.hasProfileDisplayTable(db)) {
+                db.prepare(`DELETE FROM ${PROFILE_DISPLAY_TABLE} WHERE profile_name = ?`).run(profileName);
+            }
+        }
+        catch (error) {
+            throw this.storeError(`Could not remove profile '${profileName}' display state: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    latest(profileName) {
+        if (!fs.existsSync(this.sessionsDb))
+            return undefined;
+        const db = this.open();
+        let id;
+        try {
+            const row = db.prepare(`
+        SELECT id
+        FROM sessions
+        ${profileName ? 'WHERE profile_name = ?' : ''}
+        ORDER BY updated_at DESC
+        LIMIT 1
+      `).get(...(profileName ? [profileName] : []));
+            id = row?.id;
+        }
+        catch (error) {
+            throw this.storeError(`Could not find the latest session in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+        // Pinning only affects list presentation. Resume-last must continue to use
+        // actual conversation recency.
+        return id ? this.get(id) : undefined;
+    }
+    get(sessionId) {
+        if (!fs.existsSync(this.sessionsDb))
+            return undefined;
+        const db = this.open();
+        try {
+            this.ensureSessionDisplayTable(db);
+            const row = db.prepare(`
+        SELECT
+          s.id AS id,
+          s.profile_name AS profileName,
+          s.created_at AS createdAt,
+          s.updated_at AS updatedAt,
+          d.title AS title,
+          d.pinned AS pinned,
+          d.archived AS archived,
+          COUNT(t.id) AS turnCount,
+          (
+            SELECT content FROM turns
+            WHERE session_id = s.id AND role = 'user'
+            ORDER BY id ASC
+            LIMIT 1
+          ) AS preview
+        FROM sessions s
+        LEFT JOIN turns t ON t.session_id = s.id
+        LEFT JOIN ${SESSION_DISPLAY_TABLE} d ON d.session_id = s.id
+        WHERE s.id = ?
+        GROUP BY s.id
+      `).get(sessionId);
+            if (!row)
+                return undefined;
+            const preview = row.preview ? sessionPreview(row.preview) : '';
+            return {
+                id: row.id,
+                profileName: row.profileName,
+                createdAt: row.createdAt,
+                updatedAt: row.updatedAt,
+                turnCount: Number(row.turnCount),
+                ...(preview ? { preview } : {}),
+                ...(row.title ? { title: row.title } : {}),
+                ...(row.pinned === 1 ? { pinned: true } : {}),
+                ...(row.archived === 1 ? { archived: true } : {}),
+                turns: this.listTurns(db, row.id),
+            };
+        }
+        catch (error) {
+            throw this.storeError(`Could not read session '${sessionId}' from ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Read one persisted image without including its bytes in the session
+     * transcript payload. The service exposes this through an authenticated
+     * binary route so clients can fetch only visible/previewed images. */
+    getAttachment(sessionId, userTurnIndex, attachmentIndex) {
+        if (!Number.isInteger(userTurnIndex) || userTurnIndex < 0
+            || !Number.isInteger(attachmentIndex) || attachmentIndex < 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid('Attachment coordinates must be non-negative integers.');
+        }
+        if (!fs.existsSync(this.sessionsDb))
+            return undefined;
+        const db = this.open();
+        try {
+            if (!this.hasAttachmentsTable(db))
+                return undefined;
+            const row = db.prepare(`
+        SELECT media_type AS mediaType, data, url
+        FROM ${ATTACHMENTS_TABLE}
+        WHERE session_id = ? AND user_turn_index = ? AND attachment_index = ?
+      `).get(sessionId, userTurnIndex, attachmentIndex);
+            if (!row)
+                return undefined;
+            return {
+                mediaType: row.mediaType,
+                ...(row.data !== null ? { data: row.data } : {}),
+                ...(row.url !== null ? { url: row.url } : {}),
+            };
+        }
+        catch (error) {
+            if (error instanceof MarifoldError_1.MarifoldError)
+                throw error;
+            throw this.storeError(`Could not read an attachment for session '${sessionId}' from ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    delete(sessionId) {
+        if (!fs.existsSync(this.sessionsDb))
+            return false;
+        const db = this.open();
+        try {
+            const transaction = db.transaction(() => {
+                this.deleteAttachmentsForSession(db, sessionId);
+                this.deleteResponseMetricsForSession(db, sessionId);
+                this.deleteDisplayForSession(db, sessionId);
+                db.prepare('DELETE FROM turns WHERE session_id = ?').run(sessionId);
+                return db.prepare('DELETE FROM sessions WHERE id = ?').run(sessionId).changes;
+            });
+            return transaction() > 0;
+        }
+        catch (error) {
+            throw this.storeError(`Could not delete session '${sessionId}' from ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Update sidebar-only session fields without touching ids, turns, recency,
+     * or Priest's metadata column. A separate table prevents a model save that
+     * finishes later from overwriting a rename/pin made during the run. */
+    updateDisplay(sessionId, update) {
+        if (!fs.existsSync(this.sessionsDb))
+            return false;
+        if (update.title === undefined && update.pinned === undefined && update.archived === undefined) {
+            throw MarifoldError_1.MarifoldError.configInvalid('At least one of title, pinned, or archived is required.');
+        }
+        const title = update.title === null ? null : update.title?.trim();
+        if (title !== undefined && title !== null && title.length === 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid('Session title cannot be empty.');
+        }
+        if (title !== undefined && title !== null && title.length > SESSION_TITLE_MAX_CHARS) {
+            throw MarifoldError_1.MarifoldError.configInvalid(`Session title cannot exceed ${SESSION_TITLE_MAX_CHARS} characters.`);
+        }
+        const db = this.open();
+        try {
+            if (!db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId))
+                return false;
+            this.ensureSessionDisplayTable(db);
+            const current = db.prepare(`
+        SELECT title, pinned, archived
+        FROM ${SESSION_DISPLAY_TABLE}
+        WHERE session_id = ?
+      `).get(sessionId);
+            const nextTitle = title === undefined ? current?.title ?? null : title;
+            const nextPinned = update.pinned === undefined ? current?.pinned === 1 : update.pinned;
+            const nextArchived = update.archived === undefined ? current?.archived === 1 : update.archived;
+            if (nextTitle === null && !nextPinned && !nextArchived) {
+                db.prepare(`DELETE FROM ${SESSION_DISPLAY_TABLE} WHERE session_id = ?`).run(sessionId);
+            }
+            else {
+                db.prepare(`
+          INSERT INTO ${SESSION_DISPLAY_TABLE} (session_id, title, pinned, archived)
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(session_id) DO UPDATE SET
+            title = excluded.title,
+            pinned = excluded.pinned,
+            archived = excluded.archived
+        `).run(sessionId, nextTitle, nextPinned ? 1 : 0, nextArchived ? 1 : 0);
+            }
+            return true;
+        }
+        catch (error) {
+            if (error instanceof MarifoldError_1.MarifoldError)
+                throw error;
+            throw this.storeError(`Could not update session '${sessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Delete one user turn and the entire conversation branch after it. The
+     * ordinal is zero-based among user turns, so it remains stable even though
+     * Priest rewrites SQLite turn ids whenever a session is saved. */
+    truncateFromUserTurn(sessionId, userTurnIndex) {
+        if (!Number.isInteger(userTurnIndex) || userTurnIndex < 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid('userTurnIndex must be a non-negative integer.');
+        }
+        if (!fs.existsSync(this.sessionsDb))
+            return { found: false, removedTurns: 0 };
+        const db = this.open();
+        try {
+            const session = db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
+            if (!session)
+                return { found: false, removedTurns: 0 };
+            const target = db.prepare(`
+        SELECT id
+        FROM turns
+        WHERE session_id = ? AND role = 'user'
+        ORDER BY id ASC
+        LIMIT 1 OFFSET ?
+      `).get(sessionId, userTurnIndex);
+            const transaction = db.transaction(() => {
+                if (this.hasAttachmentsTable(db)) {
+                    db.prepare(`
+            DELETE FROM ${ATTACHMENTS_TABLE}
+            WHERE session_id = ? AND user_turn_index >= ?
+          `).run(sessionId, userTurnIndex);
+                }
+                if (this.hasResponseMetricsTable(db)) {
+                    db.prepare(`
+            DELETE FROM ${RESPONSE_METRICS_TABLE}
+            WHERE session_id = ? AND user_turn_index >= ?
+          `).run(sessionId, userTurnIndex);
+                }
+                if (!target)
+                    return 0;
+                const removedTurns = db.prepare(`
+          DELETE FROM turns
+          WHERE session_id = ? AND id >= ?
+        `).run(sessionId, target.id).changes;
+                if (removedTurns > 0) {
+                    db.prepare(`
+            UPDATE sessions
+            SET updated_at = strftime('%Y-%m-%dT%H:%M:%f000+00:00', 'now')
+            WHERE id = ?
+          `).run(sessionId);
+                }
+                return removedTurns;
+            });
+            return { found: true, removedTurns: transaction() };
+        }
+        catch (error) {
+            if (error instanceof MarifoldError_1.MarifoldError)
+                throw error;
+            throw this.storeError(`Could not truncate session '${sessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Return only the completed turns before a zero-based user-turn ordinal.
+     * Historical edits use this as model context so later exchanges cannot leak
+     * into the regenerated answer. `undefined` means the session/turn is absent. */
+    turnsBeforeUserTurn(sessionId, userTurnIndex) {
+        if (!Number.isInteger(userTurnIndex) || userTurnIndex < 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid('userTurnIndex must be a non-negative integer.');
+        }
+        const detail = this.get(sessionId);
+        if (!detail)
+            return undefined;
+        const before = [];
+        let currentUserIndex = 0;
+        for (const turn of detail.turns) {
+            if (turn.role === 'user') {
+                if (currentUserIndex === userTurnIndex)
+                    return before;
+                currentUserIndex += 1;
+            }
+            before.push(turn);
+        }
+        return undefined;
+    }
+    /** Replace one persisted user→assistant exchange in place. Later exchanges
+     * keep their ids/order and therefore remain visible and available as future
+     * model context. Attachments are replaced only when `images` is provided. */
+    replaceExchange(sessionId, userTurnIndex, userText, assistantText, images, responseMetrics) {
+        if (!Number.isInteger(userTurnIndex) || userTurnIndex < 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid('userTurnIndex must be a non-negative integer.');
+        }
+        if (!fs.existsSync(this.sessionsDb))
+            return { found: false, replaced: false };
+        const db = this.open();
+        try {
+            const session = db.prepare('SELECT id, metadata FROM sessions WHERE id = ?').get(sessionId);
+            if (!session)
+                return { found: false, replaced: false };
+            const target = db.prepare(`
+        SELECT id
+        FROM turns
+        WHERE session_id = ? AND role = 'user'
+        ORDER BY id ASC
+        LIMIT 1 OFFSET ?
+      `).get(sessionId, userTurnIndex);
+            if (!target)
+                return { found: true, replaced: false };
+            const nextUser = db.prepare(`
+        SELECT id
+        FROM turns
+        WHERE session_id = ? AND role = 'user' AND id > ?
+        ORDER BY id ASC
+        LIMIT 1
+      `).get(sessionId, target.id);
+            const assistant = db.prepare(`
+        SELECT id
+        FROM turns
+        WHERE session_id = ? AND role = 'assistant' AND id > ?
+          ${nextUser ? 'AND id < ?' : ''}
+        ORDER BY id ASC
+        LIMIT 1
+      `).get(...(nextUser
+                ? [sessionId, target.id, nextUser.id]
+                : [sessionId, target.id]));
+            if (!assistant)
+                return { found: true, replaced: false };
+            const transaction = db.transaction(() => {
+                db.prepare('UPDATE turns SET content = ? WHERE id = ?').run(userText, target.id);
+                db.prepare('UPDATE turns SET content = ? WHERE id = ?').run(assistantText, assistant.id);
+                if (images !== undefined)
+                    this.replaceUserTurnAttachments(db, sessionId, userTurnIndex, images);
+                if (responseMetrics) {
+                    this.upsertResponseMetrics(db, sessionId, userTurnIndex, responseMetrics);
+                }
+                else if (this.hasResponseMetricsTable(db)) {
+                    // Replacing response content without replacement metrics must not
+                    // leave the old response's timing/model data attached to new prose.
+                    db.prepare(`
+            DELETE FROM ${RESPONSE_METRICS_TABLE}
+            WHERE session_id = ? AND user_turn_index = ?
+          `).run(sessionId, userTurnIndex);
+                }
+                const metadata = JSON.parse(session.metadata);
+                delete metadata[COMPACTION_METADATA_KEY];
+                db.prepare(`
+          UPDATE sessions
+          SET updated_at = strftime('%Y-%m-%dT%H:%M:%f000+00:00', 'now'),
+              metadata = ?
+          WHERE id = ?
+        `).run(JSON.stringify(metadata), sessionId);
+            });
+            transaction();
+            return { found: true, replaced: true };
+        }
+        catch (error) {
+            if (error instanceof MarifoldError_1.MarifoldError)
+                throw error;
+            throw this.storeError(`Could not replace exchange ${userTurnIndex} in session '${sessionId}': ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    clear(options = {}) {
+        if (!fs.existsSync(this.sessionsDb))
+            return { count: 0, ids: [] };
+        const keepLast = options.keepLast ?? 0;
+        if (!Number.isInteger(keepLast) || keepLast < 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid('keepLast must be a non-negative integer.');
+        }
+        const db = this.open();
+        try {
+            const where = [];
+            const params = [];
+            if (options.profileName) {
+                where.push('profile_name = ?');
+                params.push(options.profileName);
+            }
+            if (options.before) {
+                where.push('updated_at < ?');
+                params.push(options.before);
+            }
+            const whereSql = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
+            const rows = db.prepare(`
+        SELECT id
+        FROM sessions
+        ${whereSql}
+        ORDER BY updated_at DESC
+      `).all(...params);
+            const ids = rows.map(row => row.id).slice(keepLast);
+            if (ids.length === 0)
+                return { count: 0, ids: [] };
+            const transaction = db.transaction((sessionIds) => {
+                const deleteTurns = db.prepare('DELETE FROM turns WHERE session_id = ?');
+                const deleteSession = db.prepare('DELETE FROM sessions WHERE id = ?');
+                for (const id of sessionIds) {
+                    this.deleteAttachmentsForSession(db, id);
+                    this.deleteResponseMetricsForSession(db, id);
+                    this.deleteDisplayForSession(db, id);
+                    deleteTurns.run(id);
+                    deleteSession.run(id);
+                }
+            });
+            transaction(ids);
+            return { count: ids.length, ids };
+        }
+        catch (error) {
+            if (error instanceof MarifoldError_1.MarifoldError)
+                throw error;
+            throw this.storeError(`Could not clear sessions from ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    replaceLastAssistantTurn(sessionId, content) {
+        if (!fs.existsSync(this.sessionsDb))
+            return false;
+        const db = this.open();
+        try {
+            const result = db.prepare(`
+        UPDATE turns
+        SET content = ?
+        WHERE id = (
+          SELECT id
+          FROM turns
+          WHERE session_id = ? AND role = 'assistant'
+          ORDER BY id DESC
+          LIMIT 1
+        )
+      `).run(content, sessionId);
+            return result.changes > 0;
+        }
+        catch (error) {
+            throw this.storeError(`Could not clean session '${sessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    replaceLastUserTurn(sessionId, content) {
+        if (!fs.existsSync(this.sessionsDb))
+            return false;
+        const db = this.open();
+        try {
+            const result = db.prepare(`
+        UPDATE turns
+        SET content = ?
+        WHERE id = (
+          SELECT id
+          FROM turns
+          WHERE session_id = ? AND role = 'user'
+          ORDER BY id DESC
+          LIMIT 1
+        )
+      `).run(content, sessionId);
+            return result.changes > 0;
+        }
+        catch (error) {
+            throw this.storeError(`Could not clean session '${sessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Append one clean user→assistant exchange to a session (creating it if
+     * needed). Agent runs use this to record the objective + final answer as a
+     * single tidy pair, instead of priest's raw per-iteration `Objective:`/tool
+     * framing that made resumed transcripts confusing. */
+    async appendExchange(sessionId, profileName, userText, assistantText, images, responseMetrics) {
+        const store = this.openStore();
+        const session = (await store.get(sessionId)) ?? (await store.create(profileName, sessionId));
+        session.appendTurn('user', userText);
+        session.appendTurn('assistant', assistantText);
+        await store.save(session);
+        this.saveLastUserTurnAttachments(sessionId, images);
+        if (responseMetrics)
+            this.saveLastResponseMetrics(sessionId, responseMetrics);
+    }
+    /** Persist display-only image sources against the newest user turn. Priest
+     * intentionally stores text-only session history, so Marifold owns this
+     * side table and keeps it out of later model context. Local filesystem paths
+     * are deliberately skipped rather than exposed through the service API. */
+    saveLastUserTurnAttachments(sessionId, images) {
+        const persistable = (images ?? []).filter((image) => Boolean(image.data || image.url));
+        if (persistable.length === 0 || !fs.existsSync(this.sessionsDb))
+            return;
+        const db = this.open();
+        try {
+            this.ensureAttachmentsTable(db);
+            const userTurns = db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM turns
+        WHERE session_id = ? AND role = 'user'
+      `).get(sessionId);
+            if (userTurns.count === 0)
+                return;
+            const transaction = db.transaction(() => {
+                // Priest rewrites the turns table on every session save, so SQLite
+                // turn ids are not stable. The zero-based user-turn ordinal is.
+                const userTurnIndex = userTurns.count - 1;
+                db.prepare(`
+          DELETE FROM ${ATTACHMENTS_TABLE}
+          WHERE session_id = ? AND user_turn_index = ?
+        `).run(sessionId, userTurnIndex);
+                const insert = db.prepare(`
+          INSERT INTO ${ATTACHMENTS_TABLE}
+            (session_id, user_turn_index, attachment_index, media_type, data, url)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `);
+                for (const [index, image] of persistable.entries()) {
+                    insert.run(sessionId, userTurnIndex, index, image.mediaType ?? DEFAULT_IMAGE_MEDIA_TYPE, image.data ?? null, image.url ?? null);
+                }
+            });
+            transaction();
+        }
+        catch (error) {
+            throw this.storeError(`Could not save attachments for session '${sessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    /** Persist content-free completion metadata against the newest user turn.
+     * Like attachments, the zero-based user-turn ordinal survives Priest's
+     * whole-session turn-row rewrites. */
+    saveLastResponseMetrics(sessionId, responseMetrics) {
+        if (!fs.existsSync(this.sessionsDb))
+            return;
+        const db = this.open();
+        try {
+            const userTurns = db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM turns
+        WHERE session_id = ? AND role = 'user'
+      `).get(sessionId);
+            if (userTurns.count === 0)
+                return;
+            this.upsertResponseMetrics(db, sessionId, userTurns.count - 1, responseMetrics);
+        }
+        catch (error) {
+            throw this.storeError(`Could not save response metrics for session '${sessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    rename(fromSessionId, toSessionId) {
+        if (!fs.existsSync(this.sessionsDb))
+            return false;
+        if (!toSessionId.trim())
+            throw MarifoldError_1.MarifoldError.configInvalid('New session id cannot be empty.');
+        const db = this.open();
+        try {
+            const exists = db.prepare('SELECT id FROM sessions WHERE id = ?').get(fromSessionId);
+            if (!exists)
+                return false;
+            const conflict = db.prepare('SELECT id FROM sessions WHERE id = ?').get(toSessionId);
+            if (conflict) {
+                throw new MarifoldError_1.MarifoldError('SESSION_STORE_ERROR', `Session '${toSessionId}' already exists.`, { sessionsDb: this.sessionsDb });
+            }
+            const transaction = db.transaction(() => {
+                db.prepare(`
+          INSERT INTO sessions (id, profile_name, created_at, updated_at, metadata)
+          SELECT ?, profile_name, created_at, updated_at, metadata
+          FROM sessions
+          WHERE id = ?
+        `).run(toSessionId, fromSessionId);
+                if (this.hasAttachmentsTable(db)) {
+                    db.prepare(`UPDATE ${ATTACHMENTS_TABLE} SET session_id = ? WHERE session_id = ?`)
+                        .run(toSessionId, fromSessionId);
+                }
+                if (this.hasResponseMetricsTable(db)) {
+                    db.prepare(`UPDATE ${RESPONSE_METRICS_TABLE} SET session_id = ? WHERE session_id = ?`)
+                        .run(toSessionId, fromSessionId);
+                }
+                if (this.hasSessionDisplayTable(db)) {
+                    db.prepare(`UPDATE ${SESSION_DISPLAY_TABLE} SET session_id = ? WHERE session_id = ?`)
+                        .run(toSessionId, fromSessionId);
+                }
+                db.prepare('UPDATE turns SET session_id = ? WHERE session_id = ?').run(toSessionId, fromSessionId);
+                db.prepare('DELETE FROM sessions WHERE id = ?').run(fromSessionId);
+            });
+            transaction();
+            return true;
+        }
+        catch (error) {
+            if (error instanceof MarifoldError_1.MarifoldError)
+                throw error;
+            throw this.storeError(`Could not rename session '${fromSessionId}' in ${this.sessionsDb}: ${String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    close() {
+        this.store?.close();
+        this.store = undefined;
+    }
+    listTurns(db, sessionId) {
+        const rows = db.prepare(`
+      SELECT role, content, timestamp
+      FROM turns
+      WHERE session_id = ?
+      ORDER BY id ASC
+    `).all(sessionId);
+        const attachments = this.listAttachments(db, sessionId);
+        const responseMetrics = this.listResponseMetrics(db, sessionId);
+        let userTurnIndex = -1;
+        return rows.map(row => {
+            if (row.role === 'user')
+                userTurnIndex += 1;
+            const turnAttachments = row.role === 'user' ? attachments.get(userTurnIndex) : undefined;
+            const turnResponseMetrics = row.role === 'assistant' ? responseMetrics.get(userTurnIndex) : undefined;
+            return {
+                role: row.role,
+                content: row.content,
+                timestamp: row.timestamp,
+                ...(turnAttachments ? { attachments: turnAttachments } : {}),
+                ...(turnResponseMetrics ? { responseMetrics: turnResponseMetrics } : {}),
+            };
+        });
+    }
+    ensureAttachmentsTable(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS ${ATTACHMENTS_TABLE} (
+        session_id TEXT NOT NULL,
+        user_turn_index INTEGER NOT NULL,
+        attachment_index INTEGER NOT NULL,
+        media_type TEXT NOT NULL,
+        data TEXT,
+        url TEXT,
+        PRIMARY KEY (session_id, user_turn_index, attachment_index),
+        CHECK ((data IS NOT NULL AND url IS NULL) OR (data IS NULL AND url IS NOT NULL))
+      );
+      CREATE INDEX IF NOT EXISTS idx_marifold_turn_attachments_session
+        ON ${ATTACHMENTS_TABLE} (session_id, user_turn_index);
+    `);
+    }
+    hasAttachmentsTable(db) {
+        return db.prepare(`
+      SELECT 1
+      FROM sqlite_master
+      WHERE type = 'table' AND name = ?
+    `).get(ATTACHMENTS_TABLE) !== undefined;
+    }
+    listAttachments(db, sessionId) {
+        const byTurn = new Map();
+        if (!this.hasAttachmentsTable(db))
+            return byTurn;
+        const rows = db.prepare(`
+      SELECT
+        a.user_turn_index AS userTurnIndex,
+        a.attachment_index AS attachmentIndex,
+        a.media_type AS mediaType,
+        a.data IS NOT NULL AS embedded,
+        a.url AS url
+      FROM ${ATTACHMENTS_TABLE} a
+      WHERE a.session_id = ?
+      ORDER BY a.user_turn_index ASC, a.attachment_index ASC
+    `).all(sessionId);
+        for (const row of rows) {
+            const current = byTurn.get(row.userTurnIndex) ?? [];
+            current.push({
+                kind: 'image',
+                mediaType: row.mediaType,
+                ...(row.embedded === 1 ? {
+                    ref: {
+                        userTurnIndex: row.userTurnIndex,
+                        attachmentIndex: row.attachmentIndex,
+                    },
+                } : {}),
+                ...(row.url !== null ? { url: row.url } : {}),
+            });
+            byTurn.set(row.userTurnIndex, current);
+        }
+        return byTurn;
+    }
+    replaceUserTurnAttachments(db, sessionId, userTurnIndex, images) {
+        const persistable = images.filter((image) => Boolean(image.data || image.url));
+        if (persistable.length > 0)
+            this.ensureAttachmentsTable(db);
+        if (!this.hasAttachmentsTable(db))
+            return;
+        db.prepare(`
+      DELETE FROM ${ATTACHMENTS_TABLE}
+      WHERE session_id = ? AND user_turn_index = ?
+    `).run(sessionId, userTurnIndex);
+        if (persistable.length === 0)
+            return;
+        const insert = db.prepare(`
+      INSERT INTO ${ATTACHMENTS_TABLE}
+        (session_id, user_turn_index, attachment_index, media_type, data, url)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        for (const [index, image] of persistable.entries()) {
+            insert.run(sessionId, userTurnIndex, index, image.mediaType ?? DEFAULT_IMAGE_MEDIA_TYPE, image.data ?? null, image.url ?? null);
+        }
+    }
+    deleteAttachmentsForSession(db, sessionId) {
+        if (!this.hasAttachmentsTable(db))
+            return;
+        db.prepare(`DELETE FROM ${ATTACHMENTS_TABLE} WHERE session_id = ?`).run(sessionId);
+    }
+    ensureResponseMetricsTable(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS ${RESPONSE_METRICS_TABLE} (
+        session_id TEXT NOT NULL,
+        user_turn_index INTEGER NOT NULL CHECK (user_turn_index >= 0),
+        mode TEXT NOT NULL CHECK (mode IN ('agent', 'chat')),
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        think INTEGER NOT NULL CHECK (think IN (0, 1)),
+        started_at TEXT NOT NULL,
+        finished_at TEXT NOT NULL,
+        latency_ms INTEGER NOT NULL CHECK (latency_ms >= 0),
+        input_tokens INTEGER CHECK (input_tokens IS NULL OR input_tokens >= 0),
+        output_tokens INTEGER CHECK (output_tokens IS NULL OR output_tokens >= 0),
+        total_tokens INTEGER CHECK (total_tokens IS NULL OR total_tokens >= 0),
+        cached_input_tokens INTEGER CHECK (cached_input_tokens IS NULL OR cached_input_tokens >= 0),
+        reasoning_tokens INTEGER CHECK (reasoning_tokens IS NULL OR reasoning_tokens >= 0),
+        estimated_cost_usd REAL CHECK (estimated_cost_usd IS NULL OR estimated_cost_usd >= 0),
+        PRIMARY KEY (session_id, user_turn_index)
+      );
+      CREATE INDEX IF NOT EXISTS idx_marifold_response_metrics_finished
+        ON ${RESPONSE_METRICS_TABLE} (finished_at);
+      CREATE INDEX IF NOT EXISTS idx_marifold_response_metrics_provider_model
+        ON ${RESPONSE_METRICS_TABLE} (provider, model, finished_at);
+    `);
+    }
+    hasResponseMetricsTable(db) {
+        return db.prepare(`
+      SELECT 1
+      FROM sqlite_master
+      WHERE type = 'table' AND name = ?
+    `).get(RESPONSE_METRICS_TABLE) !== undefined;
+    }
+    upsertResponseMetrics(db, sessionId, userTurnIndex, metrics) {
+        this.ensureResponseMetricsTable(db);
+        db.prepare(`
+      INSERT INTO ${RESPONSE_METRICS_TABLE} (
+        session_id,
+        user_turn_index,
+        mode,
+        provider,
+        model,
+        think,
+        started_at,
+        finished_at,
+        latency_ms,
+        input_tokens,
+        output_tokens,
+        total_tokens,
+        cached_input_tokens,
+        reasoning_tokens,
+        estimated_cost_usd
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, user_turn_index) DO UPDATE SET
+        mode = excluded.mode,
+        provider = excluded.provider,
+        model = excluded.model,
+        think = excluded.think,
+        started_at = excluded.started_at,
+        finished_at = excluded.finished_at,
+        latency_ms = excluded.latency_ms,
+        input_tokens = excluded.input_tokens,
+        output_tokens = excluded.output_tokens,
+        total_tokens = excluded.total_tokens,
+        cached_input_tokens = excluded.cached_input_tokens,
+        reasoning_tokens = excluded.reasoning_tokens,
+        estimated_cost_usd = excluded.estimated_cost_usd
+    `).run(sessionId, userTurnIndex, metrics.mode, metrics.provider, metrics.model, metrics.think ? 1 : 0, metrics.startedAt, metrics.finishedAt, nonNegativeInteger(metrics.latencyMs) ?? 0, nonNegativeInteger(metrics.usage?.inputTokens), nonNegativeInteger(metrics.usage?.outputTokens), nonNegativeInteger(metrics.usage?.totalTokens), nonNegativeInteger(metrics.usage?.cachedInputTokens), nonNegativeInteger(metrics.usage?.reasoningTokens), nonNegativeNumber(metrics.usage?.estimatedCostUSD));
+    }
+    listResponseMetrics(db, sessionId) {
+        const byTurn = new Map();
+        if (!this.hasResponseMetricsTable(db))
+            return byTurn;
+        const rows = db.prepare(`
+      SELECT
+        user_turn_index AS userTurnIndex,
+        mode,
+        provider,
+        model,
+        think,
+        started_at AS startedAt,
+        finished_at AS finishedAt,
+        latency_ms AS latencyMs,
+        input_tokens AS inputTokens,
+        output_tokens AS outputTokens,
+        total_tokens AS totalTokens,
+        cached_input_tokens AS cachedInputTokens,
+        reasoning_tokens AS reasoningTokens,
+        estimated_cost_usd AS estimatedCostUSD
+      FROM ${RESPONSE_METRICS_TABLE}
+      WHERE session_id = ?
+      ORDER BY user_turn_index ASC
+    `).all(sessionId);
+        for (const row of rows) {
+            const usage = {
+                ...(row.inputTokens !== null ? { inputTokens: row.inputTokens } : {}),
+                ...(row.outputTokens !== null ? { outputTokens: row.outputTokens } : {}),
+                ...(row.totalTokens !== null ? { totalTokens: row.totalTokens } : {}),
+                ...(row.cachedInputTokens !== null ? { cachedInputTokens: row.cachedInputTokens } : {}),
+                ...(row.reasoningTokens !== null ? { reasoningTokens: row.reasoningTokens } : {}),
+                ...(row.estimatedCostUSD !== null ? { estimatedCostUSD: row.estimatedCostUSD } : {}),
+            };
+            byTurn.set(row.userTurnIndex, {
+                mode: row.mode,
+                provider: row.provider,
+                model: row.model,
+                think: row.think === 1,
+                startedAt: row.startedAt,
+                finishedAt: row.finishedAt,
+                latencyMs: row.latencyMs,
+                ...(Object.keys(usage).length > 0 ? { usage } : {}),
+            });
+        }
+        return byTurn;
+    }
+    deleteResponseMetricsForSession(db, sessionId) {
+        if (!this.hasResponseMetricsTable(db))
+            return;
+        db.prepare(`DELETE FROM ${RESPONSE_METRICS_TABLE} WHERE session_id = ?`).run(sessionId);
+    }
+    ensureSessionDisplayTable(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS ${SESSION_DISPLAY_TABLE} (
+        session_id TEXT PRIMARY KEY,
+        title TEXT,
+        pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0, 1)),
+        archived INTEGER NOT NULL DEFAULT 0 CHECK (archived IN (0, 1))
+      )
+    `);
+        const columns = db.prepare(`PRAGMA table_info(${SESSION_DISPLAY_TABLE})`).all();
+        if (!columns.some(column => column.name === 'archived')) {
+            db.exec(`ALTER TABLE ${SESSION_DISPLAY_TABLE} ADD COLUMN archived INTEGER NOT NULL DEFAULT 0 CHECK (archived IN (0, 1))`);
+        }
+    }
+    ensureProfileDisplayTable(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS ${PROFILE_DISPLAY_TABLE} (
+        profile_name TEXT PRIMARY KEY,
+        pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0, 1))
+      )
+    `);
+    }
+    hasProfileDisplayTable(db) {
+        return db.prepare(`
+      SELECT 1
+      FROM sqlite_master
+      WHERE type = 'table' AND name = ?
+    `).get(PROFILE_DISPLAY_TABLE) !== undefined;
+    }
+    hasSessionDisplayTable(db) {
+        return db.prepare(`
+      SELECT 1
+      FROM sqlite_master
+      WHERE type = 'table' AND name = ?
+    `).get(SESSION_DISPLAY_TABLE) !== undefined;
+    }
+    deleteDisplayForSession(db, sessionId) {
+        if (!this.hasSessionDisplayTable(db))
+            return;
+        db.prepare(`DELETE FROM ${SESSION_DISPLAY_TABLE} WHERE session_id = ?`).run(sessionId);
+    }
+    storeError(message) {
+        return new MarifoldError_1.MarifoldError('SESSION_STORE_ERROR', message, { sessionsDb: this.sessionsDb });
+    }
+}
+exports.SessionResolver = SessionResolver;
+const PREVIEW_MAX_CHARS = 80;
+function sessionPreview(content) {
+    const flat = content.replace(/\s+/g, ' ').trim();
+    if (flat.length <= PREVIEW_MAX_CHARS)
+        return flat;
+    return `${flat.slice(0, PREVIEW_MAX_CHARS - 1).trimEnd()}…`;
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? Math.round(value)
+        : null;
+}
+function nonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? value
+        : null;
+}
+function firstLinePreview(content) {
+    const first = content
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(Boolean)
+        ?.replace(/^#{1,6}\s+/, '')
+        .replace(/^[-*+]\s+/, '')
+        .replace(/^\d+[.)]\s+/, '') ?? '';
+    if (first.length <= PREVIEW_MAX_CHARS)
+        return first;
+    return `${first.slice(0, PREVIEW_MAX_CHARS - 1).trimEnd()}…`;
+}
+//# sourceMappingURL=SessionResolver.js.map