@pentoshi/clai 4.11.5 → 4.11.8

package/dist/store/history.js

@@ -1,7 +1,5 @@
 import { readFileSync } from "node:fs";
-import { appendFile, copyFile, mkdir, readdir, open, readFile, rename, rm, stat, utimes, writeFile, } from "node:fs/promises";
-import { join } from "node:path";
-import { isInternalChatMessage, } from "../types.js";
+import { isInternalChatMessage } from "../types.js";
 import { imageBudgetFor, } from "../attachments/image-content.js";
 import { prepareImageForModel } from "../attachments/image-prepare.js";
 import { redactSecrets } from "../llm/provider.js";
@@ -9,52 +7,18 @@ import { canonicalizeChatMessageReasoningArtifacts } from "../llm/reasoning-arti
 import { redactSecretsCached } from "./redaction-cache.js";
 import { getConfig } from "./config.js";
 import { safeCwd } from "../os/cwd.js";
-import { fixOwner, fixOwnerSync, handlePermissionError, safeExists } from "../os/permissions.js";
-import { getHistoryDir } from "./paths.js";
-import { getActiveSessionWorkspace, isUnderSessionWorkspaceParent, sessionWorkspaceRoot, } from "./session-workspace.js";
-import { appendIndexedHistoryRecord, findHistoryRecordStreaming, historySummary, readIndexedHistoryRecord, readValidatedHistoryIndex, rebuildHistoryIndex, rebuildHistoryIndexWithStatus, writeIndexedJsonl, } from "./history-index.js";
-/** Live paths so CLAI_DATA_DIR / CLAI_HISTORY_DIR always apply (and tests work). */
-function historyDirPath() {
-    return getHistoryDir();
-}
-function dbFilePath() {
-    return join(historyDirPath(), "history.db");
-}
-function jsonlFilePath() {
-    return join(historyDirPath(), "history.jsonl");
-}
-function jsonlIndexFilePath() {
-    return join(historyDirPath(), "history.index.json");
-}
-function jsonlLockFilePath() {
-    return join(historyDirPath(), "history.jsonl.lock");
-}
-function jsonlLockReaperPath() {
-    return join(historyDirPath(), "history.jsonl.lock.reaper");
-}
-/** Sessions pruned by retention land here — never hard-deleted on autosave. */
-function archiveFilePath() {
-    return join(historyDirPath(), "history-archive.jsonl");
-}
-/** Rolling pre-write snapshots of the active history file. */
-function backupDirPath() {
-    return join(historyDirPath(), "history-backups");
-}
-/** Max rolling backups kept under history-backups/. */
-const MAX_HISTORY_BACKUPS = 12;
-const sqliteModuleName = "better-sqlite3";
-function sessionModelFields(selection, fallback) {
-    const provider = selection?.provider ?? fallback?.provider;
-    const model = selection?.model ?? fallback?.model;
-    return {
-        ...(provider ? { provider } : {}),
-        ...(model ? { model } : {}),
-    };
-}
-/** Snapshot the active session workspace for history persistence. */
+import { getActiveSessionWorkspace } from "./session-workspace.js";
+import { backupDirPath, compareHistoryFreshness, dedupeHistoryById, historyRevision, invalidateSessionListCache, jsonlFilePath, sortHistoryByUpdatedDesc } from "./history/recovery.js";
+import { archiveFilePath, enforceSqliteRetention, loadDatabase, sessionModelFields, upsertSqlite } from "./history/sqlite-backend.js";
+import { upsertJsonl } from "./history/jsonl-backend.js";
+import { getSession } from "./history/session-queries.js";
+export { clearAllHistory, deleteSession, purgeSession } from "./history/lifecycle.js";
+export { listSessionSummaries, listSessions } from "./history/session-queries.js";
+export { getSession };
+export { partitionByRetention } from "./history/jsonl-backend.js";
+export { recoverOrphanedHistory } from "./history/recovery.js";
+export { compareHistoryFreshness, dedupeHistoryById, sortHistoryByUpdatedDesc };
 function workspaceFieldsFromActive(existing) {
-    // Prefer the already-persisted folder so rebinding mid-session never
-    // renames a live workspace out from under open artifact paths.
     if (existing?.workspaceFolder) {
         return {
             workspaceFolder: existing.workspaceFolder,
@@ -70,93 +34,9 @@ function workspaceFieldsFromActive(existing) {
     }
     return {};
 }
-let cachedDb;
-let sqliteUnavailable = false;
-let cachedSessionList;
-let sessionListGeneration = 0;
-/** Keep repeated /history opens fast while bounding cross-process staleness. */
-const SESSION_LIST_CACHE_TTL_MS = 1_000;
-function invalidateSessionListCache() {
-    sessionListGeneration += 1;
-    cachedSessionList = undefined;
-}
-async function loadDatabase() {
-    if (cachedDb)
-        return cachedDb;
-    if (sqliteUnavailable)
-        return undefined;
-    try {
-        await mkdir(historyDirPath(), { recursive: true });
-        await fixOwner(historyDirPath());
-        const imported = (await import(sqliteModuleName));
-        const Ctor = imported.default ?? imported;
-        cachedDb = new Ctor(dbFilePath());
-        fixOwnerSync(dbFilePath());
-        cachedDb.exec(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        name TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        writer_generation TEXT,
-        revision INTEGER NOT NULL DEFAULT 0,
-        cwd TEXT NOT NULL,
-        message_count INTEGER NOT NULL DEFAULT 0,
-        item_count INTEGER NOT NULL DEFAULT 0,
-        has_images INTEGER NOT NULL DEFAULT 0,
-        messages_json TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS tool_calls (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        name TEXT NOT NULL,
-        args_json TEXT NOT NULL,
-        ok INTEGER NOT NULL,
-        exit_code INTEGER,
-        output TEXT NOT NULL,
-        FOREIGN KEY(session_id) REFERENCES sessions(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_sessions_updated_at ON sessions(updated_at);
-      CREATE INDEX IF NOT EXISTS idx_tool_calls_session_id ON tool_calls(session_id);
-    `);
-        const sessionColumns = cachedDb
-            .prepare("PRAGMA table_info(sessions)")
-            .all();
-        if (!sessionColumns.some((column) => column.name === "writer_generation")) {
-            cachedDb.exec("ALTER TABLE sessions ADD COLUMN writer_generation TEXT;");
-        }
-        if (!sessionColumns.some((column) => column.name === "revision")) {
-            cachedDb.exec("ALTER TABLE sessions ADD COLUMN revision INTEGER NOT NULL DEFAULT 0;");
-        }
-        if (!sessionColumns.some((column) => column.name === "message_count")) {
-            cachedDb.exec("ALTER TABLE sessions ADD COLUMN message_count INTEGER NOT NULL DEFAULT 0;");
-        }
-        if (!sessionColumns.some((column) => column.name === "item_count")) {
-            cachedDb.exec("ALTER TABLE sessions ADD COLUMN item_count INTEGER NOT NULL DEFAULT 0;");
-        }
-        if (!sessionColumns.some((column) => column.name === "has_images")) {
-            cachedDb.exec("ALTER TABLE sessions ADD COLUMN has_images INTEGER NOT NULL DEFAULT 0;");
-        }
-        return cachedDb;
-    }
-    catch (err) {
-        if (err && err.code === "EACCES") {
-            handlePermissionError(err);
-        }
-        sqliteUnavailable = true;
-        return undefined;
-    }
-}
 function newId() {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function hydrateHistoryRecord(record) {
-    return {
-        ...record,
-        messages: record.messages.map(canonicalizeChatMessageReasoningArtifacts),
-    };
-}
 function scrubMessages(messages) {
     return messages.map((message) => {
         const { images, ...rest } = message;
@@ -226,7 +106,6 @@ function isSettledItem(item) {
 function scrubTranscript(items) {
     if (!items)
         return undefined;
-    // Drop UI chrome notices — they must never bloat saved history item counts.
     const durable = items.filter((item) => item.kind !== "notice");
     return durable.map((item) => {
         const reusable = isSettledItem(item);
@@ -271,503 +150,11 @@ function scrubTranscriptItem(item) {
                 done: true,
             };
         default: {
-            // notice already filtered; keep exhaustiveness for future kinds
             return item;
         }
     }
 }
-const JSONL_LOCK_STALE_MS = 60_000;
-const JSONL_LOCK_RETRIES = 200;
-/** Serialize stale-lock reclamation and recheck the owner while holding it. */
-async function reapStaleJsonlLock() {
-    let reaper;
-    const reaperToken = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    try {
-        reaper = await open(jsonlLockReaperPath(), "wx", 0o600);
-        try {
-            await reaper.writeFile(reaperToken);
-        }
-        catch (error) {
-            await reaper.close().catch(() => undefined);
-            await rm(jsonlLockReaperPath(), { force: true }).catch(() => undefined);
-            throw error;
-        }
-    }
-    catch (error) {
-        if (error?.code !== "EEXIST")
-            throw error;
-        const existingToken = await readFile(jsonlLockReaperPath(), "utf8").catch(() => undefined);
-        const reaperStat = await stat(jsonlLockReaperPath()).catch(() => undefined);
-        if (!reaperStat ||
-            Date.now() - reaperStat.mtimeMs <= JSONL_LOCK_STALE_MS) {
-            return;
-        }
-        const confirmed = await readFile(jsonlLockReaperPath(), "utf8").catch(() => undefined);
-        if (confirmed !== undefined && confirmed === existingToken) {
-            await rm(jsonlLockReaperPath(), { force: true }).catch(() => undefined);
-        }
-        return;
-    }
-    try {
-        const token = await readFile(jsonlLockFilePath(), "utf8").catch(() => undefined);
-        const lockStat = await stat(jsonlLockFilePath()).catch(() => undefined);
-        if (!lockStat || Date.now() - lockStat.mtimeMs <= JSONL_LOCK_STALE_MS) {
-            return;
-        }
-        // The live owner refreshes mtime periodically. A stale marker—including
-        // an empty marker left between open/write—is therefore safe to reclaim.
-        const confirmed = await readFile(jsonlLockFilePath(), "utf8").catch(() => undefined);
-        if (confirmed !== undefined && confirmed === token) {
-            await rm(jsonlLockFilePath(), { force: true });
-        }
-    }
-    finally {
-        await reaper.close().catch(() => undefined);
-        const currentReaper = await readFile(jsonlLockReaperPath(), "utf8").catch(() => undefined);
-        if (currentReaper === reaperToken) {
-            await rm(jsonlLockReaperPath(), { force: true }).catch(() => undefined);
-        }
-    }
-}
-/**
- * Cross-process lock around JSONL read/modify/rename. Atomic rename protects
- * readers, but without this lock two clai processes can both read the same
- * base file and then each replace it, dropping whichever session they did not
- * observe. The lock is transient and stale crash leftovers self-heal.
- */
-async function acquireJsonlWriteLock() {
-    await mkdir(historyDirPath(), { recursive: true });
-    for (let attempt = 0; attempt < JSONL_LOCK_RETRIES; attempt += 1) {
-        try {
-            const token = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-            const handle = await open(jsonlLockFilePath(), "wx", 0o600);
-            try {
-                await handle.writeFile(token);
-            }
-            catch (error) {
-                await handle.close().catch(() => undefined);
-                await rm(jsonlLockFilePath(), { force: true }).catch(() => undefined);
-                throw error;
-            }
-            const heartbeat = setInterval(() => {
-                const now = new Date();
-                void utimes(jsonlLockFilePath(), now, now).catch(() => undefined);
-            }, JSONL_LOCK_STALE_MS / 3);
-            heartbeat.unref();
-            return async () => {
-                clearInterval(heartbeat);
-                await handle.close().catch(() => undefined);
-                const currentToken = await readFile(jsonlLockFilePath(), "utf8").catch(() => undefined);
-                if (currentToken === token) {
-                    await rm(jsonlLockFilePath(), { force: true }).catch(() => undefined);
-                }
-            };
-        }
-        catch (error) {
-            if (error?.code !== "EEXIST")
-                throw error;
-            await reapStaleJsonlLock();
-            await new Promise((resolve) => setTimeout(resolve, 25));
-        }
-    }
-    throw new Error("timed out waiting for history write lock");
-}
-/**
- * Serializes every JSONL mutation through a single promise chain so concurrent
- * autosaves never interleave a read with another writer's truncating write.
- * Without this, a reader could observe a half-written (or momentarily empty)
- * file and then persist back only its own record, wiping every other session.
- */
-let jsonlWriteChain = Promise.resolve();
-/** Shared one-time orphan/archive recovery; writes await it, UI listings may not. */
-let recoveryPromise;
-/** Queue a locked JSONL section; the chain survives individual failures. */
-function queueJsonlWrite(operation, fallback) {
-    invalidateSessionListCache();
-    const run = jsonlWriteChain.then(async () => {
-        try {
-            await ensureHistoryRecovered();
-            const releaseLock = await acquireJsonlWriteLock();
-            try {
-                return await operation();
-            }
-            finally {
-                await releaseLock();
-                // A list may have been loaded after the pre-write invalidation but
-                // before the atomic rename completed. Never leave that snapshot cached.
-                invalidateSessionListCache();
-            }
-        }
-        catch (err) {
-            handlePermissionError(err);
-            return fallback();
-        }
-    });
-    jsonlWriteChain = run.then(() => undefined, () => undefined);
-    return run;
-}
-function mutateJsonl(update) {
-    return queueJsonlWrite(async () => {
-        const current = await readJsonlRecordsFrom(jsonlFilePath());
-        await writeJsonlAtomic(update(current), current.length);
-    }, () => undefined);
-}
-function updatedAtMs(record) {
-    const t = Date.parse(record.updatedAt || record.createdAt || "");
-    return Number.isFinite(t) ? t : 0;
-}
-function historyRevision(record) {
-    const revision = record?.revision;
-    return typeof revision === "number" &&
-        Number.isSafeInteger(revision) &&
-        revision > 0
-        ? revision
-        : 0;
-}
-function historyWriterGeneration(record) {
-    const generation = record?.writerGeneration;
-    return typeof generation === "string" && generation.length > 0
-        ? generation
-        : undefined;
-}
-/**
- * Compare snapshots by writer generation, then capture revision. Legacy rows
- * without a generation retain revision/timestamp fallback for compatibility.
- */
-export function compareHistoryFreshness(left, right) {
-    const leftGeneration = historyWriterGeneration(left);
-    const rightGeneration = historyWriterGeneration(right);
-    if (leftGeneration || rightGeneration) {
-        if (!leftGeneration)
-            return -1;
-        if (!rightGeneration)
-            return 1;
-        const generationDelta = leftGeneration.localeCompare(rightGeneration);
-        if (generationDelta !== 0)
-            return generationDelta;
-    }
-    const revisionDelta = historyRevision(left) - historyRevision(right);
-    if (revisionDelta !== 0)
-        return revisionDelta;
-    if (historyRevision(left) > 0)
-        return 0;
-    return updatedAtMs(left) - updatedAtMs(right);
-}
-/** Keep the newest captured version of each session id. */
-export function dedupeHistoryById(records) {
-    const byId = new Map();
-    for (const record of records) {
-        if (!record?.id)
-            continue;
-        const prev = byId.get(record.id);
-        // Preserve the first source on an exact tie. JSONL is passed first during
-        // cross-backend merge and is the durable canonical copy.
-        if (!prev || compareHistoryFreshness(record, prev) > 0) {
-            byId.set(record.id, record);
-        }
-    }
-    return [...byId.values()];
-}
-export function sortHistoryByUpdatedDesc(records) {
-    return [...records].sort((a, b) => updatedAtMs(b) - updatedAtMs(a));
-}
-/**
- * Apply retention by *recency* (not file order). Pruned sessions are returned
- * separately so callers can archive them — never silently destroy history.
- * limit <= 0 means unlimited (keep everything).
- */
-export function partitionByRetention(records, limit) {
-    const unique = sortHistoryByUpdatedDesc(dedupeHistoryById(records));
-    if (!limit || limit <= 0 || unique.length <= limit) {
-        return { kept: unique, pruned: [] };
-    }
-    return {
-        kept: unique.slice(0, limit),
-        pruned: unique.slice(limit),
-    };
-}
-/** Read and parse all valid JSONL records from any path. */
-async function readJsonlRecordsFrom(path) {
-    if (!(await safeExists(path)))
-        return [];
-    try {
-        const raw = await readFile(path, "utf8");
-        return raw
-            .split("\n")
-            .filter(Boolean)
-            .map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((record) => record !== null)
-            .map(hydrateHistoryRecord);
-    }
-    catch (err) {
-        if (err && err.code === "EACCES")
-            handlePermissionError(err);
-        return [];
-    }
-}
-/** Session count without parsing the whole file when the index is valid. */
-async function countJsonlSessions() {
-    const entries = await readValidatedHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-    if (entries)
-        return entries.length;
-    return (await readJsonlRecordsFrom(jsonlFilePath())).length;
-}
-async function appendRecordsToFile(path, records) {
-    if (records.length === 0)
-        return;
-    await mkdir(historyDirPath(), { recursive: true });
-    await fixOwner(historyDirPath());
-    const chunk = `${records.map((r) => JSON.stringify(r)).join("\n")}\n`;
-    // Append is best-effort durable; archive growth is unbounded by design so
-    // retention never permanently loses a conversation.
-    await appendFile(path, chunk, { mode: 0o600 });
-    await fixOwner(path).catch(() => undefined);
-}
-async function backupActiveHistory() {
-    if (!(await safeExists(jsonlFilePath())))
-        return;
-    try {
-        await mkdir(backupDirPath(), { recursive: true });
-        await fixOwner(backupDirPath());
-        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const dest = join(backupDirPath(), `history-${stamp}.jsonl`);
-        await copyFile(jsonlFilePath(), dest);
-        await fixOwner(dest).catch(() => undefined);
-        // Keep only the newest N backups.
-        const names = (await readdir(backupDirPath()))
-            .filter((n) => n.startsWith("history-") && n.endsWith(".jsonl"))
-            .sort()
-            .reverse();
-        for (const old of names.slice(MAX_HISTORY_BACKUPS)) {
-            await rm(join(backupDirPath(), old), { force: true }).catch(() => undefined);
-        }
-    }
-    catch {
-        // Backup is best-effort; never block the autosave path.
-    }
-}
-// Restore backups only for a missing/corrupt active file, then merge orphan write temps.
-export async function recoverOrphanedHistory() {
-    const sources = [];
-    const tempSources = [];
-    const releaseLock = await acquireJsonlWriteLock();
-    try {
-        const activePath = jsonlFilePath();
-        const activeExists = await safeExists(activePath);
-        const tempNames = await readdir(historyDirPath())
-            .then((names) => names.filter((name) => name.startsWith("history.jsonl.") && name.endsWith(".tmp")))
-            .catch(() => []);
-        if (activeExists && tempNames.length === 0) {
-            const indexed = await readValidatedHistoryIndex(activePath, jsonlIndexFilePath());
-            if (indexed)
-                return { recovered: 0, sources };
-            const rebuilt = await rebuildHistoryIndexWithStatus(activePath, jsonlIndexFilePath());
-            if (!rebuilt.malformed)
-                return { recovered: 0, sources };
-        }
-        let activeCorrupt = false;
-        let active = [];
-        if (activeExists) {
-            try {
-                const raw = await readFile(activePath, "utf8");
-                const lines = raw.split("\n").filter((line) => line.trim().length > 0);
-                for (const line of lines) {
-                    try {
-                        active.push(hydrateHistoryRecord(JSON.parse(line)));
-                    }
-                    catch {
-                        activeCorrupt = true;
-                    }
-                }
-            }
-            catch (error) {
-                if (error?.code === "EACCES")
-                    handlePermissionError(error);
-                activeCorrupt = true;
-            }
-        }
-        const backupRecords = [];
-        if (!activeExists || activeCorrupt) {
-            try {
-                const backups = (await readdir(backupDirPath()))
-                    .filter((name) => name.startsWith("history-") && name.endsWith(".jsonl"))
-                    .sort()
-                    .reverse();
-                for (const name of backups) {
-                    const rows = await readJsonlRecordsFrom(join(backupDirPath(), name));
-                    if (rows.length === 0)
-                        continue;
-                    backupRecords.push(...rows);
-                    sources.push(`history-backups/${name}`);
-                    break;
-                }
-            }
-            catch {
-                // No usable backup directory.
-            }
-        }
-        const extras = [];
-        try {
-            const names = await readdir(historyDirPath());
-            for (const name of names) {
-                if (!name.startsWith("history.jsonl.") || !name.endsWith(".tmp")) {
-                    continue;
-                }
-                const path = join(historyDirPath(), name);
-                const rows = await readJsonlRecordsFrom(path);
-                if (rows.length === 0) {
-                    await rm(path, { force: true }).catch(() => undefined);
-                    continue;
-                }
-                extras.push(...rows);
-                sources.push(name);
-                tempSources.push(name);
-            }
-        }
-        catch {
-            // History directory may not exist yet.
-        }
-        const activeById = new Map(active.map((record) => [record.id, record]));
-        const merged = dedupeHistoryById([...active, ...backupRecords, ...extras]);
-        const recoveredCount = merged.filter((record) => {
-            const previous = activeById.get(record.id);
-            return !previous || compareHistoryFreshness(record, previous) > 0;
-        }).length;
-        const needsRewrite = activeCorrupt ||
-            (!activeExists && backupRecords.length > 0) ||
-            recoveredCount > 0;
-        if (!needsRewrite)
-            return { recovered: 0, sources };
-        await mkdir(historyDirPath(), { recursive: true });
-        await fixOwner(historyDirPath());
-        if (activeExists && !activeCorrupt)
-            await backupActiveHistory();
-        const sorted = sortHistoryByUpdatedDesc(merged);
-        sorted.reverse();
-        await writeIndexedJsonl(activePath, jsonlIndexFilePath(), sorted);
-        await Promise.all([
-            fixOwner(activePath),
-            fixOwner(jsonlIndexFilePath()),
-        ]);
-        for (const name of tempSources) {
-            await rm(join(historyDirPath(), name), { force: true }).catch(() => undefined);
-        }
-        return { recovered: recoveredCount, sources };
-    }
-    finally {
-        await releaseLock();
-    }
-}
-function startHistoryRecovery() {
-    if (!recoveryPromise) {
-        recoveryPromise = recoverOrphanedHistory()
-            .then(() => undefined, () => undefined)
-            .finally(() => {
-            // A background recovery may have merged archive/temp records after a
-            // picker list was published; force the next /history to refresh.
-            invalidateSessionListCache();
-        });
-    }
-    return recoveryPromise;
-}
-async function ensureHistoryRecovered() {
-    await startHistoryRecovery();
-}
-/**
- * Apply retention (archive pruned sessions) and write the active file
- * atomically. Never hard-deletes pruned chats — they go to history-archive.jsonl.
- */
-async function writeJsonlAtomic(records, knownExistingCount) {
-    invalidateSessionListCache();
-    await mkdir(historyDirPath(), { recursive: true });
-    await fixOwner(historyDirPath());
-    const limit = getConfig().historyRetentionLimit;
-    const { kept, pruned } = partitionByRetention(records, limit);
-    if (pruned.length > 0) {
-        // Durable archive before the active file shrinks.
-        await appendRecordsToFile(archiveFilePath(), pruned);
-    }
-    // If we would shrink (or replace) the on-disk set, snapshot first.
-    if (await safeExists(jsonlFilePath())) {
-        const existingCount = knownExistingCount ?? (await countJsonlSessions());
-        if (kept.length < existingCount || pruned.length > 0) {
-            await backupActiveHistory();
-        }
-    }
-    // Refuse to write an empty file over a non-empty one unless the caller
-    // intentionally has zero records (e.g. clear after archiving).
-    if (kept.length === 0 && (await safeExists(jsonlFilePath()))) {
-        const existing = await readJsonlRecordsFrom(jsonlFilePath());
-        if (existing.length > 0 && records.length > 0) {
-            // Something went wrong in partitioning — keep the safer set.
-            const safe = sortHistoryByUpdatedDesc(dedupeHistoryById(existing));
-            safe.reverse();
-            await writeIndexedJsonl(jsonlFilePath(), jsonlIndexFilePath(), safe);
-            await Promise.all([
-                fixOwner(jsonlFilePath()),
-                fixOwner(jsonlIndexFilePath()),
-            ]);
-            return;
-        }
-    }
-    // File order: oldest → newest (matches classic append style).
-    const ordered = sortHistoryByUpdatedDesc(kept);
-    ordered.reverse();
-    await writeIndexedJsonl(jsonlFilePath(), jsonlIndexFilePath(), ordered);
-    await Promise.all([
-        fixOwner(jsonlFilePath()),
-        fixOwner(jsonlIndexFilePath()),
-    ]);
-}
-function serializeSessionPayload(record) {
-    return JSON.stringify({
-        messages: record.messages,
-        transcript: record.transcript,
-        ...(record.contextUsage ? { contextUsage: record.contextUsage } : {}),
-        ...(record.previousTurn ? { previousTurn: record.previousTurn } : {}),
-        ...sessionModelFields(record),
-        ...(record.workspaceFolder
-            ? {
-                workspaceFolder: record.workspaceFolder,
-                workspaceCode: record.workspaceCode,
-            }
-            : {}),
-    });
-}
-/** SQLite mirror write with atomic generation/revision rejection. */
-function upsertSqlite(db, record) {
-    const summary = historySummary(record);
-    db.prepare(`INSERT INTO sessions
-       (id, name, created_at, updated_at, writer_generation, revision, cwd,
-        message_count, item_count, has_images, messages_json)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(id) DO UPDATE SET
-       name = excluded.name,
-       created_at = excluded.created_at,
-       updated_at = excluded.updated_at,
-       writer_generation = excluded.writer_generation,
-       revision = excluded.revision,
-       cwd = excluded.cwd,
-       message_count = excluded.message_count,
-       item_count = excluded.item_count,
-       has_images = excluded.has_images,
-       messages_json = excluded.messages_json
-     WHERE (sessions.writer_generation IS NULL AND excluded.writer_generation IS NOT NULL)
-        OR excluded.writer_generation > sessions.writer_generation
-        OR (excluded.writer_generation = sessions.writer_generation
-            AND excluded.revision >= sessions.revision)
-        OR (sessions.writer_generation IS NULL AND excluded.writer_generation IS NULL
-            AND excluded.revision >= sessions.revision)`).run(record.id, record.name ?? null, record.createdAt, record.updatedAt, historyWriterGeneration(record) ?? null, historyRevision(record), record.cwd, summary.messageCount, summary.itemCount, summary.hasImages ? 1 : 0, serializeSessionPayload(record));
-}
 export async function saveSession(messages, name, transcript, contextUsage, revision, writerGeneration, previousTurn, sessionModel) {
-    // Auto-derive a readable name from the first real user message if none provided
     if (!name) {
         const firstUser = messages.find((m) => m.role === "user" && !isInternalChatMessage(m));
         if (firstUser) {
@@ -794,8 +181,6 @@ export async function saveSession(messages, name, transcript, contextUsage, revi
         ...sessionModelFields(sessionModel),
         ...workspace,
     };
-    // Private mode: never persist chat content. Caller still gets a record
-    // back (so /save echoes a usable id) but nothing hits disk.
     if (getConfig().privateMode)
         return record;
     invalidateSessionListCache();
@@ -864,90 +249,6 @@ export async function upsertSession(id, messages, name, transcript, contextUsage
     }
     return canonical;
 }
-async function enforceSqliteRetention(db) {
-    const limit = getConfig().historyRetentionLimit;
-    if (!limit || limit <= 0)
-        return;
-    // Archive rows about to be deleted, then delete — never hard-drop without
-    // a JSONL archive copy.
-    try {
-        const doomed = db
-            .prepare(`SELECT id, name, created_at, updated_at, writer_generation, revision, cwd, messages_json FROM sessions
-         WHERE id NOT IN (SELECT id FROM sessions ORDER BY updated_at DESC LIMIT ?)`)
-            .all(Math.floor(limit));
-        const records = doomed.map(rowToSession);
-        if (records.length > 0)
-            await appendRecordsToFile(archiveFilePath(), records);
-    }
-    catch {
-        /* archive best-effort */
-    }
-    db.exec(`DELETE FROM sessions WHERE id NOT IN (SELECT id FROM sessions ORDER BY updated_at DESC LIMIT ${Math.floor(limit)});`);
-}
-/** Below this size a full rewrite is cheap enough to skip compaction. */
-const HISTORY_COMPACT_MIN_BYTES = 1_000_000;
-/** Compact once dead (superseded) lines dominate the active file. */
-const HISTORY_COMPACT_LIVE_RATIO = 0.6;
-function summaryFreshness(summary) {
-    return {
-        id: summary.id,
-        writerGeneration: summary.writerGeneration,
-        revision: summary.revision,
-        createdAt: summary.createdAt,
-        updatedAt: summary.updatedAt,
-        cwd: summary.cwd,
-        messages: [],
-    };
-}
-function shouldCompactHistory(result) {
-    const limit = getConfig().historyRetentionLimit;
-    if (limit > 0 && result.entries.length > limit)
-        return true;
-    if (result.fileSize < HISTORY_COMPACT_MIN_BYTES)
-        return false;
-    return result.liveBytes / result.fileSize < HISTORY_COMPACT_LIVE_RATIO;
-}
-async function compactJsonlUnderLock() {
-    const records = await readJsonlRecordsFrom(jsonlFilePath());
-    await writeJsonlAtomic(records, records.length);
-}
-async function upsertJsonlUnderLock(record) {
-    await mkdir(historyDirPath(), { recursive: true });
-    await fixOwner(historyDirPath());
-    const entries = await readValidatedHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-    if (!entries) {
-        const current = await readJsonlRecordsFrom(jsonlFilePath());
-        const index = current.findIndex((item) => item.id === record.id);
-        const existing = index >= 0 ? current[index] : undefined;
-        if (existing && compareHistoryFreshness(record, existing) <= 0) {
-            return existing;
-        }
-        if (index >= 0)
-            current[index] = record;
-        else
-            current.push(record);
-        await writeJsonlAtomic(current, current.length);
-        return record;
-    }
-    const existingEntry = entries.find((entry) => entry.id === record.id);
-    if (existingEntry &&
-        compareHistoryFreshness(record, summaryFreshness(existingEntry.summary)) <= 0) {
-        const stored = await readIndexedHistoryRecord(jsonlFilePath(), existingEntry);
-        if (stored)
-            return hydrateHistoryRecord(stored);
-    }
-    const result = await appendIndexedHistoryRecord(jsonlFilePath(), jsonlIndexFilePath(), entries, record);
-    await Promise.all([
-        fixOwner(jsonlFilePath()).catch(() => undefined),
-        fixOwner(jsonlIndexFilePath()).catch(() => undefined),
-    ]);
-    if (shouldCompactHistory(result))
-        await compactJsonlUnderLock();
-    return record;
-}
-async function upsertJsonl(record) {
-    return queueJsonlWrite(() => upsertJsonlUnderLock(record), () => record);
-}
 export async function saveToolCall(sessionId, call, result) {
     const record = {
         id: newId(),
@@ -966,512 +267,9 @@ export async function saveToolCall(sessionId, call, result) {
     }
     return record;
 }
-function rowToSession(row) {
-    const data = row;
-    const parsed = JSON.parse(data.messages_json);
-    let payload = {};
-    let messages;
-    if (Array.isArray(parsed)) {
-        messages = parsed;
-    }
-    else {
-        payload = parsed;
-        messages = parsed.messages ?? [];
-    }
-    return hydrateHistoryRecord({
-        id: data.id,
-        writerGeneration: data.writer_generation ?? undefined,
-        revision: typeof data.revision === "number" && data.revision > 0
-            ? data.revision
-            : undefined,
-        name: data.name ?? undefined,
-        createdAt: data.created_at,
-        updatedAt: data.updated_at,
-        cwd: data.cwd,
-        messages,
-        transcript: payload.transcript,
-        contextUsage: payload.contextUsage,
-        previousTurn: payload.previousTurn,
-        provider: payload.provider,
-        model: payload.model,
-        workspaceFolder: payload.workspaceFolder,
-        workspaceCode: payload.workspaceCode,
-    });
-}
-function rowToSummary(row) {
-    const data = row;
-    return {
-        id: data.id,
-        ...(data.writer_generation
-            ? { writerGeneration: data.writer_generation }
-            : {}),
-        ...(typeof data.revision === "number" && data.revision > 0
-            ? { revision: data.revision }
-            : {}),
-        ...(data.name ? { name: data.name } : {}),
-        createdAt: data.created_at,
-        updatedAt: data.updated_at,
-        cwd: data.cwd,
-        messageCount: Math.max(0, data.message_count ?? 0),
-        itemCount: Math.max(0, data.item_count ?? data.message_count ?? 0),
-        hasImages: data.has_images === 1,
-    };
-}
-function sortSummaries(summaries) {
-    return [...summaries].sort((left, right) => Date.parse(right.updatedAt || right.createdAt) -
-        Date.parse(left.updatedAt || left.createdAt));
-}
-export async function listSessionSummaries(limit = 20, options = {}) {
-    if (options.recovery === "blocking")
-        await ensureHistoryRecovered();
-    else
-        void startHistoryRecovery();
-    const cacheKey = historyDirPath();
-    const requestedLimit = limit > 0 ? Math.floor(limit) : 0;
-    const now = Date.now();
-    if (cachedSessionList?.historyDir === cacheKey &&
-        now - cachedSessionList.cachedAt <= SESSION_LIST_CACHE_TTL_MS &&
-        (cachedSessionList.coversAll ||
-            (requestedLimit > 0 &&
-                requestedLimit <= cachedSessionList.summaries.length))) {
-        const cached = cachedSessionList.summaries;
-        return requestedLimit > 0 ? cached.slice(0, requestedLimit) : [...cached];
-    }
-    const loadGeneration = sessionListGeneration;
-    let summaries;
-    let coversAll = false;
-    const entries = await readValidatedHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-    if (entries) {
-        summaries = sortSummaries(entries.map((entry) => entry.summary));
-        coversAll = true;
-    }
-    if (!summaries) {
-        const db = await loadDatabase();
-        if (db) {
-            try {
-                const sql = "SELECT id, name, created_at, updated_at, writer_generation, revision, cwd, " +
-                    "message_count, item_count, has_images FROM sessions " +
-                    "ORDER BY updated_at DESC" +
-                    (requestedLimit > 0 ? " LIMIT ?" : "");
-                const rows = requestedLimit > 0
-                    ? db.prepare(sql).all(requestedLimit)
-                    : db.prepare(sql).all();
-                summaries = rows.map(rowToSummary);
-                coversAll = requestedLimit === 0 || rows.length < requestedLimit;
-            }
-            catch {
-                summaries = undefined;
-            }
-        }
-    }
-    if (!summaries || summaries.length === 0) {
-        const rebuilt = await rebuildHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-        summaries = sortSummaries(rebuilt.map((entry) => entry.summary));
-        coversAll = true;
-    }
-    else {
-        void rebuildHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-    }
-    if (sessionListGeneration === loadGeneration) {
-        cachedSessionList = {
-            historyDir: cacheKey,
-            summaries,
-            cachedAt: Date.now(),
-            coversAll,
-        };
-    }
-    return requestedLimit > 0 ? summaries.slice(0, requestedLimit) : [...summaries];
-}
-async function listJsonlSessions(limit) {
-    try {
-        const records = sortHistoryByUpdatedDesc(dedupeHistoryById(await readJsonlRecordsFrom(jsonlFilePath())));
-        if (!limit || limit <= 0)
-            return records;
-        return records.slice(0, limit);
-    }
-    catch (err) {
-        if (err && err.code === "EACCES") {
-            handlePermissionError(err);
-        }
-        return [];
-    }
-}
-function mergeSessionLists(...lists) {
-    return sortHistoryByUpdatedDesc(dedupeHistoryById(lists.flat()));
-}
-export async function listSessions(limit = 20, options = {}) {
-    if (options.recovery === "background")
-        void startHistoryRecovery();
-    else
-        await ensureHistoryRecovered();
-    const [fromJsonl, db] = await Promise.all([
-        listJsonlSessions(0),
-        loadDatabase(),
-    ]);
-    let fromDb = [];
-    if (db) {
-        try {
-            const rows = db
-                .prepare("SELECT id, name, created_at, updated_at, writer_generation, revision, cwd, messages_json FROM sessions ORDER BY updated_at DESC")
-                .all();
-            fromDb = rows.map(rowToSession);
-        }
-        catch {
-            fromDb = [];
-        }
-    }
-    const merged = mergeSessionLists(fromJsonl, fromDb);
-    return !limit || limit <= 0 ? merged : merged.slice(0, limit);
-}
-export async function getSession(sessionId) {
-    void startHistoryRecovery();
-    const entries = await readValidatedHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-    const entry = entries?.find((candidate) => candidate.id === sessionId);
-    if (entry) {
-        const indexed = await readIndexedHistoryRecord(jsonlFilePath(), entry);
-        if (indexed)
-            return hydrateHistoryRecord(indexed);
-    }
-    const db = await loadDatabase();
-    if (db) {
-        try {
-            const row = db
-                .prepare("SELECT id, name, created_at, updated_at, writer_generation, revision, cwd, messages_json FROM sessions WHERE id = ?")
-                .get(sessionId);
-            if (row)
-                return rowToSession(row);
-        }
-        catch {
-            // Fall through to streaming JSONL lookup.
-        }
-    }
-    const active = await findHistoryRecordStreaming(jsonlFilePath(), sessionId);
-    if (active) {
-        void rebuildHistoryIndex(jsonlFilePath(), jsonlIndexFilePath());
-        return hydrateHistoryRecord(active);
-    }
-    const archived = await findHistoryRecordStreaming(archiveFilePath(), sessionId);
-    return archived ? hydrateHistoryRecord(archived) : undefined;
-}
 export function getHistoryPath() {
-    // Prefer JSONL as the durable path users can inspect/backup; SQLite is
-    // optional acceleration when better-sqlite3 is installed.
     return jsonlFilePath();
 }
-export async function clearAllHistory() {
-    await ensureHistoryRecovered();
-    const details = [];
-    try {
-        invalidateSessionListCache();
-        const db = await loadDatabase();
-        if (db) {
-            db.exec("DELETE FROM sessions; DELETE FROM tool_calls; PRAGMA wal_checkpoint(TRUNCATE); VACUUM;");
-            details.push("sqlite cleared");
-        }
-    }
-    catch (error) {
-        details.push(`sqlite error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const releaseLock = await acquireJsonlWriteLock();
-    try {
-        const names = await readdir(historyDirPath()).catch(() => []);
-        const removable = names.filter((name) => name === "history.jsonl" ||
-            name === "history.index.json" ||
-            name === "history-archive.jsonl" ||
-            name === "history-backups" ||
-            name.startsWith("history-cleared-") ||
-            (name.startsWith("history.jsonl.") && name.endsWith(".tmp")));
-        await Promise.all(removable.map((name) => rm(join(historyDirPath(), name), { recursive: true, force: true })));
-        details.push("history, index, archives, and backups deleted");
-    }
-    catch (error) {
-        details.push(`history file error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    finally {
-        await releaseLock();
-    }
-    try {
-        const { clearAllPlans } = await import("./plan.js");
-        await clearAllPlans();
-        details.push("plans cleared");
-    }
-    catch {
-        details.push("plan store unavailable");
-    }
-    invalidateSessionListCache();
-    return { cleared: true, detail: details.join("; ") };
-}
-const HISTORY_FILTER_CHUNK_BYTES = 64 * 1024;
-async function* readHistoryJsonlLines(path) {
-    const handle = await open(path, "r");
-    const chunk = Buffer.allocUnsafe(HISTORY_FILTER_CHUNK_BYTES);
-    // Accumulate un-terminated fragments as a list of buffers rather than
-    // repeatedly concatenating into a growing `carry`. A single JSONL record
-    // (a large transcript/messages blob) can span many chunks; concatenating
-    // on every chunk read copied the whole accumulated line again each time,
-    // making the reader O(line length squared) for one oversized record. Only
-    // materializing the line once — when its terminating newline is finally
-    // seen — keeps this linear in total bytes read.
-    let carryChunks = [];
-    let carryLen = 0;
-    try {
-        while (true) {
-            const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
-            if (bytesRead === 0)
-                break;
-            let start = 0;
-            while (true) {
-                const newline = chunk.indexOf(0x0a, start);
-                if (newline < 0 || newline >= bytesRead)
-                    break;
-                const segment = chunk.subarray(start, newline + 1);
-                if (carryLen > 0) {
-                    yield Buffer.concat([...carryChunks, segment], carryLen + segment.length);
-                    carryChunks = [];
-                    carryLen = 0;
-                }
-                else {
-                    yield Buffer.from(segment);
-                }
-                start = newline + 1;
-            }
-            if (start < bytesRead) {
-                carryChunks.push(Buffer.from(chunk.subarray(start, bytesRead)));
-                carryLen += bytesRead - start;
-            }
-        }
-        if (carryLen > 0)
-            yield Buffer.concat(carryChunks, carryLen);
-    }
-    finally {
-        await handle.close();
-    }
-}
-function parseHistoryJsonlLine(line) {
-    try {
-        const value = JSON.parse(line.toString("utf8"));
-        if (value === null)
-            return { valid: false };
-        return {
-            valid: true,
-            ...(value && typeof value === "object" && !Array.isArray(value)
-                ? {
-                    id: typeof value.id === "string"
-                        ? value.id
-                        : undefined,
-                }
-                : {}),
-        };
-    }
-    catch {
-        return { valid: false };
-    }
-}
-async function historyFileContainsSession(path, sessionId) {
-    if (!(await safeExists(path)))
-        return false;
-    for await (const line of readHistoryJsonlLines(path)) {
-        if (parseHistoryJsonlLine(line).id === sessionId)
-            return true;
-    }
-    return false;
-}
-async function writeAllHistoryBytes(handle, bytes, position) {
-    let written = 0;
-    while (written < bytes.length) {
-        const result = await handle.write(bytes, written, bytes.length - written, position + written);
-        if (result.bytesWritten <= 0) {
-            throw new Error("failed to write history data");
-        }
-        written += result.bytesWritten;
-    }
-    return position + written;
-}
-async function removeSessionFromHistoryFile(path, sessionId, options = {}) {
-    if (!options.knownToExist &&
-        !(await historyFileContainsSession(path, sessionId))) {
-        return false;
-    }
-    const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
-    let output;
-    let committed = false;
-    let retained = false;
-    try {
-        output = await open(temporary, "wx", 0o600);
-        let outputPosition = 0;
-        for await (const line of readHistoryJsonlLines(path)) {
-            const parsed = parseHistoryJsonlLine(line);
-            if (!parsed.valid || parsed.id === sessionId)
-                continue;
-            outputPosition = await writeAllHistoryBytes(output, line, outputPosition);
-            retained = true;
-        }
-        await output.close();
-        output = undefined;
-        if (!retained) {
-            await rm(temporary, { force: true });
-            await rm(path, { force: true });
-            committed = true;
-            return true;
-        }
-        await rename(temporary, path);
-        committed = true;
-        await fixOwner(path);
-        return true;
-    }
-    finally {
-        await output?.close().catch(() => undefined);
-        if (!committed)
-            await rm(temporary, { force: true }).catch(() => undefined);
-    }
-}
-async function removeSessionFromActiveHistory(sessionId) {
-    const path = jsonlFilePath();
-    let entries = await readValidatedHistoryIndex(path, jsonlIndexFilePath());
-    if (!entries) {
-        entries = await rebuildHistoryIndex(path, jsonlIndexFilePath());
-    }
-    if (!entries.some((entry) => entry.id === sessionId))
-        return false;
-    // The index already proved the id is present, so skip the redundant
-    // whole-file existence pre-scan and go straight to the rewrite pass.
-    const removed = await removeSessionFromHistoryFile(path, sessionId, {
-        knownToExist: true,
-    });
-    if (!removed)
-        return false;
-    if (!(await safeExists(path))) {
-        await writeFile(path, "", { mode: 0o600 });
-    }
-    await rebuildHistoryIndex(path, jsonlIndexFilePath());
-    await Promise.all([
-        fixOwner(path),
-        fixOwner(jsonlIndexFilePath()),
-    ]);
-    return true;
-}
-export async function deleteSession(sessionId) {
-    const id = sessionId.trim();
-    if (!id)
-        return { deleted: false, detail: "missing session id" };
-    let deletedFromJsonl = false;
-    let deletedFromArchive = false;
-    let deletedFromBackup = false;
-    let deletedFromSqlite = false;
-    let historyWriteFailed = false;
-    await queueJsonlWrite(async () => {
-        deletedFromJsonl = await removeSessionFromActiveHistory(id);
-        deletedFromArchive = await removeSessionFromHistoryFile(archiveFilePath(), id);
-        const backupNames = (await readdir(backupDirPath()).catch(() => []))
-            .filter((name) => name.startsWith("history-") && name.endsWith(".jsonl"));
-        for (const name of backupNames) {
-            deletedFromBackup =
-                (await removeSessionFromHistoryFile(join(backupDirPath(), name), id)) ||
-                    deletedFromBackup;
-        }
-    }, () => {
-        historyWriteFailed = true;
-    });
-    if (historyWriteFailed) {
-        return { deleted: false, detail: "could not remove the session from history files" };
-    }
-    try {
-        const db = await loadDatabase();
-        if (db) {
-            db.prepare("DELETE FROM tool_calls WHERE session_id = ?").run(id);
-            const result = db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-            const changes = result.changes ?? 0;
-            if (changes > 0)
-                deletedFromSqlite = true;
-            try {
-                db.exec("PRAGMA wal_checkpoint(TRUNCATE);");
-            }
-            catch { }
-            invalidateSessionListCache();
-        }
-    }
-    catch (error) {
-        return {
-            deleted: false,
-            detail: `could not remove the session from the history database: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    invalidateSessionListCache();
-    if (!deletedFromJsonl && !deletedFromArchive && !deletedFromBackup && !deletedFromSqlite) {
-        const existing = await getSession(id);
-        if (existing)
-            return { deleted: false, detail: "failed to delete" };
-        return { deleted: false, detail: "session not found" };
-    }
-    return { deleted: true, detail: `deleted ${id}` };
-}
-async function releasePurgedSessionModel(sessionId) {
-    try {
-        const { releaseSessionModel } = await import("./session-model.js");
-        await releaseSessionModel(sessionId);
-    }
-    catch {
-        void 0;
-    }
-}
-export async function purgeSession(sessionId) {
-    const id = sessionId.trim();
-    if (!id) {
-        return {
-            deleted: false,
-            detail: "missing session id",
-            removedWorkspace: false,
-            removedPlan: false,
-        };
-    }
-    const record = await getSession(id);
-    const workspaceFolder = record?.workspaceFolder?.trim();
-    const result = await deleteSession(id);
-    if (!result.deleted) {
-        return { ...result, removedWorkspace: false, removedPlan: false };
-    }
-    let removedPlan = false;
-    try {
-        const { deletePlan } = await import("./plan.js");
-        await deletePlan(id);
-        removedPlan = true;
-    }
-    catch {
-        removedPlan = false;
-    }
-    try {
-        const { releaseSessionScope } = await import("./scope.js");
-        await releaseSessionScope(id);
-    }
-    catch {
-        void 0;
-    }
-    await releasePurgedSessionModel(id);
-    let removedWorkspace = false;
-    if (workspaceFolder) {
-        try {
-            const root = sessionWorkspaceRoot(workspaceFolder);
-            if (isUnderSessionWorkspaceParent(root)) {
-                await rm(root, { recursive: true, force: true });
-                removedWorkspace = true;
-            }
-        }
-        catch {
-            removedWorkspace = false;
-        }
-    }
-    const extras = [];
-    if (removedWorkspace)
-        extras.push("artifacts");
-    if (removedPlan)
-        extras.push("plan");
-    return {
-        deleted: true,
-        detail: extras.length > 0 ? `${result.detail} + ${extras.join(" + ")}` : result.detail,
-        removedWorkspace,
-        removedPlan,
-    };
-}
 export function getJsonlHistoryPath() {
     return jsonlFilePath();
 }