elepha 0.1.0

package/dist/cli/commands/daemon-control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-control.js","sourceRoot":"","sources":["../../../src/cli/commands/daemon-control.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/doctor.js

@@ -0,0 +1,31 @@
+import { runDoctor } from '../../install/doctor.js';
+import { ConsentStore } from '../../storage/consent-store.js';
+import { openDb } from '../../storage/db.js';
+export function registerDoctor(program) {
+    program
+        .command('doctor')
+        .description('Diagnose capture recovery prerequisites and restart only a down or stuck daemon')
+        .action(() => {
+        let approvedRoots = 0;
+        let databaseError;
+        try {
+            approvedRoots = new ConsentStore(openDb()).countApproved();
+        }
+        catch (error) {
+            databaseError = error;
+        }
+        const result = runDoctor({
+            approvedRoots,
+            inspectDatabase: databaseError
+                ? () => {
+                    throw databaseError;
+                }
+                : undefined,
+        });
+        for (const line of result.lines) {
+            console.log(line);
+        }
+        process.exitCode = result.exitCode;
+    });
+}
+//# sourceMappingURL=doctor.js.map

package/dist/cli/commands/doctor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.js","sourceRoot":"","sources":["../../../src/cli/commands/doctor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,cAAc,CAAC,OAAgB;IAC3C,OAAO;SACF,OAAO,CAAC,QAAQ,CAAC;SACjB,WAAW,CAAC,iFAAiF,CAAC;SAC9F,MAAM,CAAC,GAAG,EAAE;QACT,IAAI,aAAa,GAAG,CAAC,CAAC;QACtB,IAAI,aAAsB,CAAC;QAC3B,IAAI,CAAC;YACD,aAAa,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,aAAa,EAAE,CAAC;QAC/D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,aAAa,GAAG,KAAK,CAAC;QAC1B,CAAC;QACD,MAAM,MAAM,GAAG,SAAS,CAAC;YACrB,aAAa;YACb,eAAe,EAAE,aAAa;gBAC1B,CAAC,CAAC,GAAG,EAAE;oBACD,MAAM,aAAa,CAAC;gBACxB,CAAC;gBACH,CAAC,CAAC,SAAS;SAClB,CAAC,CAAC;QACH,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC;QACD,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;IACvC,CAAC,CAAC,CAAC;AACX,CAAC"}

package/dist/cli/commands/hook.js

@@ -0,0 +1,24 @@
+import { runSessionStartCli } from '../../hooks/session-start.js';
+import { runUserPromptSubmitCli } from '../../hooks/user-prompt-submit.js';
+export function registerHook(program) {
+    const hook = program.command('hook', { hidden: true }).description('Install and execute bounded elepha hooks');
+    hook.command('session-start')
+        .requiredOption('--tool <tool>', 'claude-code or codex')
+        .action(async (opts) => {
+        if (opts.tool !== 'claude-code' && opts.tool !== 'codex') {
+            process.exitCode = 0;
+            return;
+        }
+        await runSessionStartCli(opts.tool);
+    });
+    hook.command('user-prompt-submit')
+        .requiredOption('--tool <tool>', 'claude-code or codex')
+        .action(async (opts) => {
+        if (opts.tool !== 'claude-code' && opts.tool !== 'codex') {
+            process.exitCode = 0;
+            return;
+        }
+        await runUserPromptSubmitCli(opts.tool);
+    });
+}
+//# sourceMappingURL=hook.js.map

package/dist/cli/commands/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../../src/cli/commands/hook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAG3E,MAAM,UAAU,YAAY,CAAC,OAAgB;IACzC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,0CAA0C,CAAC,CAAC;IAC/G,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;SACxB,cAAc,CAAC,eAAe,EAAE,sBAAsB,CAAC;SACvD,MAAM,CAAC,KAAK,EAAE,IAAwB,EAAE,EAAE;QACvC,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACvD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;YACrB,OAAO;QACX,CAAC;QACD,MAAM,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IACP,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC;SAC7B,cAAc,CAAC,eAAe,EAAE,sBAAsB,CAAC;SACvD,MAAM,CAAC,KAAK,EAAE,IAAwB,EAAE,EAAE;QACvC,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACvD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;YACrB,OAAO;QACX,CAAC;QACD,MAAM,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;AACX,CAAC"}

package/dist/cli/commands/import.js

@@ -0,0 +1,611 @@
+import path from 'node:path';
+import Database from 'better-sqlite3';
+import { canonicalizeExisting, isWithinProviderStore, normalizeForCompare } from '../../config/paths.js';
+import { readSessionMetadata } from '../../discovery/session-projects.js';
+import { daemonHealth as currentDaemonHealth } from '../../install/health-checks.js';
+import { stripShellSyntax } from '../../security/sanitize.js';
+import { writeBackup } from '../../storage/backup.js';
+import { validateCandidateSemantics } from '../../storage/candidate-validator.js';
+import { defaultDbPath } from '../../storage/db.js';
+import { firstPromptSearch } from '../../storage/first-prompt-search.js';
+import { MemoryStore } from '../../storage/memory-store.js';
+import { ProjectResolver } from '../../storage/project-resolver.js';
+import { sanitizeRollupDecisionsField, sanitizeRollupDisplayField, sanitizeRollupPendingItemsField, } from '../../storage/sanitize-backfill.js';
+import { hydrateTurnDecisions, sanitizeTurnDecision } from '../../storage/turn-store.js';
+import { errorMessage } from '../../util/error.js';
+import { runImportWizard } from '../import-wizard.js';
+import { confirmYesNo } from '../shared.js';
+export const IMPORTED_TABLES = ['projects', 'sessions', 'memories', 'session_rollups'];
+class ImportApplyError extends Error {
+    snapshotPath;
+    constructor(snapshotPath, cause) {
+        super(`Import failed after saving the pre-import snapshot to ${snapshotPath}: ${errorMessage(cause)}`);
+        this.snapshotPath = snapshotPath;
+    }
+}
+const REQUIRED_COLUMNS = {
+    projects: ['id', 'path', 'display_name', 'git_root', 'git_remote', 'git_root_commit', 'first_seen_at', 'last_seen_at'],
+    sessions: [
+        'id',
+        'tool',
+        'native_id',
+        'segment_index',
+        'project_id',
+        'source_path',
+        'cursor',
+        'started_at',
+        'last_ingested_at',
+        'surface',
+        'git_branch',
+        'kind',
+        'last_turn_at',
+        'trailing_branch',
+        'trailing_files',
+        'rendered_chars',
+        'rendered_turns',
+        'title',
+        'custom_title',
+        'git_commit_count',
+    ],
+    memories: [
+        'id',
+        'project_id',
+        'session_id',
+        'turn_index',
+        'tool',
+        'turn_started_at',
+        'decisions',
+        'files_touched',
+        'pending_items',
+        'superseded_at',
+        'created_at',
+        'summarizer_status',
+        'reingested_at',
+        'has_external_content',
+    ],
+    session_rollups: [
+        'session_id',
+        'project_id',
+        'tool',
+        'title',
+        'summary',
+        'decisions',
+        'pending_items',
+        'files_touched',
+        'turn_count',
+        'started_at',
+        'ended_at',
+        'kind',
+        'parent_session_id',
+        'summarizer_status',
+        'rollup_state',
+        'rolled_up_through_turn_index',
+        'computed_at',
+        'rollup_version',
+    ],
+};
+const SESSION_WRITE_COLUMNS = [...REQUIRED_COLUMNS.sessions.filter((column) => column !== 'id'), 'first_prompt_search'];
+const MEMORY_WRITE_COLUMNS = REQUIRED_COLUMNS.memories.filter((column) => column !== 'id');
+const ROLLUP_WRITE_COLUMNS = REQUIRED_COLUMNS.session_rollups;
+function tableNames(db) {
+    return new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name));
+}
+function tableColumns(db, table) {
+    return new Set(db.pragma(`table_info(${table})`).map((column) => column.name));
+}
+function validateCandidate(db) {
+    const tables = tableNames(db);
+    const missingTables = IMPORTED_TABLES.filter((table) => !tables.has(table));
+    if (missingTables.length > 0) {
+        throw new Error(`Backup is incomplete (missing required table(s): ${missingTables.join(', ')}).`);
+    }
+    for (const table of IMPORTED_TABLES) {
+        const columns = tableColumns(db, table);
+        const missingColumns = REQUIRED_COLUMNS[table].filter((column) => !columns.has(column));
+        if (missingColumns.length > 0) {
+            throw new Error(`Backup is incompatible (${table} is missing required column(s): ${missingColumns.join(', ')}).`);
+        }
+    }
+    const semanticViolations = validateCandidateSemantics(db, ['sessions', 'memories', 'session_rollups']);
+    if (semanticViolations.length > 0) {
+        throw new Error(`Backup is semantically invalid: ${semanticViolations.join('; ')}`);
+    }
+    const integrity = db.pragma('integrity_check');
+    if (integrity.length !== 1 || integrity[0]?.integrity_check !== 'ok') {
+        throw new Error(`Backup failed integrity_check: ${integrity.map((row) => row.integrity_check).join('; ')}`);
+    }
+    const foreignKeys = db.pragma('foreign_key_check');
+    if (foreignKeys.length > 0) {
+        throw new Error(`Backup failed foreign_key_check with ${foreignKeys.length} violation(s).`);
+    }
+}
+function openCandidate(candidatePath) {
+    let candidate;
+    try {
+        candidate = new Database(candidatePath, { readonly: true, fileMustExist: true });
+        candidate.pragma('query_only = ON');
+        candidate.exec('BEGIN');
+        validateCandidate(candidate);
+        return candidate;
+    }
+    catch (error) {
+        candidate?.close();
+        if (error instanceof Error && (error.message.startsWith('Backup is ') || error.message.startsWith('Backup failed '))) {
+            throw error;
+        }
+        throw new Error(`Not a valid SQLite backup at ${candidatePath}: ${errorMessage(error)}`);
+    }
+}
+function identityCandidates(project) {
+    const candidates = [];
+    if (project.git_remote) {
+        candidates.push({ key: `remote:${project.git_remote}`, rank: 0 });
+    }
+    if (project.git_root_commit) {
+        candidates.push({ key: `commit:${project.git_root_commit}`, rank: 1 });
+    }
+    if (project.git_root) {
+        candidates.push({ key: `path:${normalizeForCompare(project.git_root)}`, rank: 2 });
+    }
+    candidates.push({ key: `path:${normalizeForCompare(project.path)}`, rank: 3 });
+    return candidates.filter((candidate, index) => candidates.findIndex((other) => other.key === candidate.key) === index);
+}
+function identityKeys(project) {
+    return identityCandidates(project).map((candidate) => candidate.key);
+}
+function isImportSourceWithinProviderStore(tool, sourcePath) {
+    if (typeof sourcePath !== 'string') {
+        return false;
+    }
+    return isWithinProviderStore(tool, sourcePath);
+}
+function groupBackupProjects(projects) {
+    const parent = new Map(projects.map((project) => [project.id, project.id]));
+    const ownerByIdentity = new Map();
+    const find = (id) => {
+        const owner = parent.get(id);
+        if (owner === undefined || owner === id) {
+            return id;
+        }
+        const root = find(owner);
+        parent.set(id, root);
+        return root;
+    };
+    const union = (left, right) => {
+        const leftRoot = find(left);
+        const rightRoot = find(right);
+        if (leftRoot !== rightRoot) {
+            parent.set(rightRoot, leftRoot);
+        }
+    };
+    for (const project of projects) {
+        for (const key of identityKeys(project)) {
+            const owner = ownerByIdentity.get(key);
+            if (owner === undefined) {
+                ownerByIdentity.set(key, project.id);
+            }
+            else {
+                union(project.id, owner);
+            }
+        }
+    }
+    const groups = new Map();
+    for (const project of projects) {
+        const root = find(project.id);
+        const group = groups.get(root);
+        if (group) {
+            group.push(project);
+        }
+        else {
+            groups.set(root, [project]);
+        }
+    }
+    return [...groups.values()];
+}
+function canonicalLocalIds(db) {
+    // Imported paths are untrusted database content, so Git resolution is disabled:
+    // identity comes only from stored fields and no backup-derived path can reach a subprocess.
+    const sets = new ProjectResolver(db, { resolveGitRoot: () => null }).list();
+    const canonicalById = new Map();
+    for (const set of sets) {
+        const canonical = set.projectIds[0];
+        if (canonical === undefined) {
+            continue;
+        }
+        for (const projectId of set.projectIds) {
+            canonicalById.set(projectId, canonical);
+        }
+    }
+    return canonicalById;
+}
+function planProjects(active, candidate) {
+    const localProjects = active.prepare('SELECT * FROM projects ORDER BY id').all();
+    const backupProjects = candidate.prepare('SELECT * FROM projects ORDER BY id').all();
+    const canonicalById = canonicalLocalIds(active);
+    const localByIdentity = new Map();
+    for (const project of localProjects) {
+        const canonical = canonicalById.get(project.id) ?? project.id;
+        for (const key of identityKeys(project)) {
+            if (!localByIdentity.has(key)) {
+                localByIdentity.set(key, canonical);
+            }
+        }
+    }
+    return groupBackupProjects(backupProjects).map((group) => {
+        const existingLocalId = group
+            .flatMap(identityCandidates)
+            .sort((a, b) => a.rank - b.rank)
+            .map((candidate) => localByIdentity.get(candidate.key))
+            .find((localId) => localId !== undefined);
+        const representative = [...group].sort((a, b) => Number(Boolean(b.git_remote)) - Number(Boolean(a.git_remote)) ||
+            Number(Boolean(b.git_root_commit)) - Number(Boolean(a.git_root_commit)) ||
+            Number(Boolean(b.git_root)) - Number(Boolean(a.git_root)) ||
+            a.id - b.id)[0];
+        if (!representative) {
+            throw new Error('Backup project group is empty.');
+        }
+        return {
+            backupProjectIds: group.map((project) => project.id),
+            representative,
+            ...(existingLocalId === undefined ? {} : { existingLocalId }),
+        };
+    });
+}
+async function buildPlan(active, candidate) {
+    const projects = planProjects(active, candidate);
+    const activeStore = new MemoryStore(active);
+    const existing = active.prepare('SELECT id FROM sessions WHERE tool = ? AND native_id = ? AND segment_index = ?');
+    const purged = active.prepare('SELECT 1 FROM purged_transcripts WHERE tool = ? AND native_id = ?');
+    const sessions = [];
+    for (const row of candidate.prepare('SELECT * FROM sessions ORDER BY id').all()) {
+        if (!isImportSourceWithinProviderStore(row.tool, row.source_path)) {
+            sessions.push({ row, disposition: 'outside_store' });
+            continue;
+        }
+        if (purged.get(row.tool, row.native_id)) {
+            sessions.push({ row, disposition: 'purged' });
+            continue;
+        }
+        if (activeStore.isTranscriptIncognito(row.tool, row.native_id)) {
+            sessions.push({ row, disposition: 'incognito' });
+            continue;
+        }
+        const sourcePath = typeof row.source_path === 'string' ? row.source_path : undefined;
+        const metadata = sourcePath === undefined ? undefined : await readSessionMetadata(sourcePath).catch(() => undefined);
+        const canonicalCwd = metadata === undefined ? undefined : canonicalizeExisting(metadata.cwd);
+        if (canonicalCwd === undefined || activeStore.consent.consentState(canonicalCwd) !== 'approved') {
+            sessions.push({ row, disposition: 'unconsented' });
+            continue;
+        }
+        const local = existing.get(row.tool, row.native_id, row.segment_index);
+        sessions.push(local ? { row, disposition: 'existing', localSessionId: local.id, canonicalCwd } : { row, disposition: 'new', canonicalCwd });
+    }
+    return {
+        projects,
+        sessions,
+        counts: {
+            new: sessions.filter((session) => session.disposition === 'new').length,
+            existing: sessions.filter((session) => session.disposition === 'existing').length,
+            purged: sessions.filter((session) => session.disposition === 'purged').length,
+            incognito: sessions.filter((session) => session.disposition === 'incognito').length,
+            unconsented: sessions.filter((session) => session.disposition === 'unconsented').length,
+            outsideStore: sessions.filter((session) => session.disposition === 'outside_store').length,
+        },
+    };
+}
+async function readPlan(dbPath, candidate) {
+    const active = new Database(dbPath, { readonly: true, fileMustExist: true });
+    try {
+        active.pragma('query_only = ON');
+        return await buildPlan(active, candidate);
+    }
+    finally {
+        active.close();
+    }
+}
+function printPreview(candidatePath, overwrite, plan) {
+    console.log(`Import preview: ${candidatePath}`);
+    if (overwrite) {
+        console.log(`${plan.counts.new} new, ${plan.counts.existing} overwritten, ${plan.counts.purged} skipped (purged), ${plan.counts.incognito} skipped (incognito), ${plan.counts.unconsented} skipped (unconsented)`);
+    }
+    else {
+        console.log(`${plan.counts.new} new, ${plan.counts.existing} skipped (already present), ${plan.counts.purged} skipped (purged), ${plan.counts.incognito} skipped (incognito), ${plan.counts.unconsented} skipped (unconsented)`);
+    }
+    if (plan.counts.outsideStore > 0) {
+        console.error(`${plan.counts.outsideStore} skipped (transcript outside provider store)`);
+    }
+}
+function insertRow(db, table, columns, row, overrides) {
+    const values = columns.map((column) => (Object.hasOwn(overrides, column) ? overrides[column] : row[column]));
+    const result = db.prepare(`INSERT INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`).run(...values);
+    return Number(result.lastInsertRowid);
+}
+function sanitizedImportedTitle(value) {
+    return typeof value === 'string' ? stripShellSyntax(value) : value;
+}
+function sanitizedImportedFirstPromptSearch(value) {
+    return typeof value === 'string' ? firstPromptSearch(value) : null;
+}
+function sanitizedImportedDecisions(value) {
+    return typeof value === 'string' ? JSON.stringify(hydrateTurnDecisions(value).map(sanitizeTurnDecision)) : value;
+}
+function sanitizedImportedPendingItems(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return JSON.stringify(Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string').map(stripShellSyntax) : []);
+    }
+    catch {
+        return '[]';
+    }
+}
+function sanitizedImportedRollupText(value) {
+    return typeof value === 'string' ? sanitizeRollupDisplayField(value) : value;
+}
+function sanitizedImportedRollupDecisions(value) {
+    return typeof value === 'string' ? sanitizeRollupDecisionsField(value) : value;
+}
+function sanitizedImportedRollupPendingItems(value) {
+    return typeof value === 'string' ? sanitizeRollupPendingItemsField(value) : value;
+}
+function updateSession(db, row, localSessionId, projectId) {
+    const values = SESSION_WRITE_COLUMNS.map((column) => {
+        if (column === 'project_id') {
+            return projectId;
+        }
+        if (column === 'first_prompt_search') {
+            return sanitizedImportedFirstPromptSearch(row[column]);
+        }
+        return column === 'title' || column === 'custom_title' ? sanitizedImportedTitle(row[column]) : row[column];
+    });
+    db.prepare(`UPDATE sessions SET ${SESSION_WRITE_COLUMNS.map((column) => `${column} = ?`).join(', ')} WHERE id = ?`).run(...values, localSessionId);
+}
+function applyProjects(db, plan, overwrite) {
+    const sessionStore = new MemoryStore(db);
+    const localByCanonicalCwd = new Map();
+    const sessionProjectIds = new Map();
+    for (const session of plan.sessions) {
+        if (session.disposition !== 'new' && !(overwrite && session.disposition === 'existing')) {
+            continue;
+        }
+        const canonicalCwd = session.canonicalCwd;
+        if (canonicalCwd === undefined) {
+            throw new Error(`Importable backup session ${session.row.id} has no canonical cwd.`);
+        }
+        const projectId = localByCanonicalCwd.get(canonicalCwd) ?? sessionStore.upsertProject(canonicalCwd).id;
+        localByCanonicalCwd.set(canonicalCwd, projectId);
+        sessionProjectIds.set(session.row.id, projectId);
+    }
+    return sessionProjectIds;
+}
+function requiredMapping(map, backupId, label) {
+    const localId = map.get(backupId);
+    if (localId === undefined) {
+        throw new Error(`Backup ${label} ${backupId} has no local identity mapping.`);
+    }
+    return localId;
+}
+function assertPlanStillAuthorized(db, plan) {
+    const activeStore = new MemoryStore(db);
+    const purged = db.prepare('SELECT 1 FROM purged_transcripts WHERE tool = ? AND native_id = ?');
+    const changed = [];
+    for (const session of plan.sessions) {
+        if (session.disposition !== 'new' && session.disposition !== 'existing') {
+            continue;
+        }
+        const reasons = [];
+        if (session.canonicalCwd === undefined) {
+            reasons.push('canonical cwd missing');
+        }
+        else {
+            const consent = activeStore.consent.consentState(session.canonicalCwd);
+            if (consent !== 'approved') {
+                reasons.push(`consent ${consent}`);
+            }
+        }
+        if (purged.get(session.row.tool, session.row.native_id)) {
+            reasons.push('purged');
+        }
+        if (activeStore.isTranscriptIncognito(session.row.tool, session.row.native_id)) {
+            reasons.push('incognito');
+        }
+        if (reasons.length > 0) {
+            changed.push(`${session.row.tool}:${session.row.native_id}#${session.row.segment_index} (${reasons.join(', ')})`);
+        }
+    }
+    if (changed.length > 0) {
+        throw new Error(`Import authorization changed after the preview for: ${changed.join('; ')}. Nothing was imported. Re-run elepha import for a fresh preview.`);
+    }
+}
+function applyMerge(db, candidate, plan, overwrite) {
+    const sessionProjectIds = applyProjects(db, plan, overwrite);
+    const sessionIds = new Map();
+    const importedSessionIds = new Set();
+    for (const session of plan.sessions) {
+        if (session.disposition === 'purged' ||
+            session.disposition === 'incognito' ||
+            session.disposition === 'unconsented' ||
+            session.disposition === 'outside_store') {
+            continue;
+        }
+        if (session.disposition === 'existing') {
+            const localSessionId = session.localSessionId;
+            if (localSessionId === undefined) {
+                throw new Error(`Existing backup session ${session.row.id} has no local mapping.`);
+            }
+            sessionIds.set(session.row.id, localSessionId);
+            if (!overwrite) {
+                continue;
+            }
+            const projectId = requiredMapping(sessionProjectIds, session.row.id, 'session project');
+            db.prepare('DELETE FROM memories WHERE session_id = ?').run(localSessionId);
+            db.prepare('DELETE FROM session_rollups WHERE session_id = ?').run(localSessionId);
+            updateSession(db, session.row, localSessionId, projectId);
+            importedSessionIds.add(session.row.id);
+            continue;
+        }
+        const projectId = requiredMapping(sessionProjectIds, session.row.id, 'session project');
+        const localSessionId = insertRow(db, 'sessions', SESSION_WRITE_COLUMNS, session.row, {
+            project_id: projectId,
+            title: sanitizedImportedTitle(session.row.title),
+            custom_title: sanitizedImportedTitle(session.row.custom_title),
+            first_prompt_search: sanitizedImportedFirstPromptSearch(session.row.first_prompt_search),
+        });
+        sessionIds.set(session.row.id, localSessionId);
+        importedSessionIds.add(session.row.id);
+    }
+    const memories = candidate.prepare('SELECT * FROM memories WHERE session_id = ? ORDER BY id');
+    const rollup = candidate.prepare('SELECT * FROM session_rollups WHERE session_id = ?');
+    for (const backupSessionId of importedSessionIds) {
+        const localSessionId = requiredMapping(sessionIds, backupSessionId, 'session');
+        const projectId = requiredMapping(sessionProjectIds, backupSessionId, 'session project');
+        for (const memory of memories.iterate(backupSessionId)) {
+            insertRow(db, 'memories', MEMORY_WRITE_COLUMNS, memory, {
+                project_id: projectId,
+                session_id: localSessionId,
+                decisions: sanitizedImportedDecisions(memory.decisions),
+                pending_items: sanitizedImportedPendingItems(memory.pending_items),
+            });
+        }
+        const backupRollup = rollup.get(backupSessionId);
+        if (backupRollup) {
+            // A vetoed parent has no local mapping by design. Detaching the child
+            // preserves its portable rollup without resurrecting the tombstoned session.
+            const parentSessionId = backupRollup.parent_session_id === null ? null : (sessionIds.get(backupRollup.parent_session_id) ?? null);
+            insertRow(db, 'session_rollups', ROLLUP_WRITE_COLUMNS, backupRollup, {
+                project_id: projectId,
+                session_id: localSessionId,
+                parent_session_id: parentSessionId,
+                title: sanitizedImportedRollupText(backupRollup.title),
+                summary: sanitizedImportedRollupText(backupRollup.summary),
+                decisions: sanitizedImportedRollupDecisions(backupRollup.decisions),
+                pending_items: sanitizedImportedRollupPendingItems(backupRollup.pending_items),
+            });
+        }
+    }
+}
+function applyImport(dbPath, candidate, plan, overwrite, snapshotWriter, beforeVerify) {
+    const active = new Database(dbPath, { fileMustExist: true });
+    let snapshotPath;
+    try {
+        active.pragma('journal_mode = WAL');
+        active.pragma('foreign_keys = ON');
+        active.pragma('wal_checkpoint(TRUNCATE)');
+        snapshotPath = snapshotWriter(active, dbPath);
+        const merge = active.transaction(() => {
+            assertPlanStillAuthorized(active, plan);
+            applyMerge(active, candidate, plan, overwrite);
+            beforeVerify?.(active);
+            const foreignKeys = active.pragma('foreign_key_check');
+            if (foreignKeys.length > 0) {
+                throw new Error(`foreign_key_check found ${foreignKeys.length} violation(s)`);
+            }
+        });
+        merge.immediate();
+        return snapshotPath;
+    }
+    catch (error) {
+        if (snapshotPath !== undefined) {
+            throw new ImportApplyError(snapshotPath, error);
+        }
+        throw error;
+    }
+    finally {
+        active.close();
+    }
+}
+/** A multi-table identity-remapped merge needs one transaction spanning project resolution, FK remapping, and verification, so it cannot use the generic destructive-operation runner. */
+export async function runImportOperation(candidatePath, overwrite, runtime = {}) {
+    const dbPath = runtime.dbPath ?? defaultDbPath();
+    const candidate = openCandidate(candidatePath);
+    try {
+        const health = (runtime.daemonHealth ?? currentDaemonHealth)();
+        if (health.healthy) {
+            throw new Error(`Refusing import while the daemon is running (${health.state}). Run elepha pause first.`);
+        }
+        if (health.state.startsWith('STUCK')) {
+            console.error(`Daemon appears stuck (${health.state}); proceeding — it is not writing.`);
+        }
+        const plan = await readPlan(dbPath, candidate);
+        printPreview(candidatePath, overwrite, plan);
+        if (runtime.confirm && !(await runtime.confirm(plan))) {
+            return {
+                cancelled: true,
+                added: 0,
+                overwritten: 0,
+                skipped: plan.counts.existing + plan.counts.purged + plan.counts.incognito + plan.counts.unconsented + plan.counts.outsideStore,
+            };
+        }
+        const snapshotPath = applyImport(dbPath, candidate, plan, overwrite, runtime.writeBackup ?? writeBackup, runtime.beforeVerify);
+        const overwritten = overwrite ? plan.counts.existing : 0;
+        const skipped = plan.counts.outsideStore +
+            plan.counts.purged +
+            plan.counts.incognito +
+            plan.counts.unconsented +
+            (overwrite ? 0 : plan.counts.existing);
+        console.log(`Imported: ${plan.counts.new} added, ${overwritten} overwritten, ${skipped} skipped. ${plan.counts.unconsented} skipped (unconsented). Snapshot: ${snapshotPath}`);
+        return { cancelled: false, snapshotPath, added: plan.counts.new, overwritten, skipped };
+    }
+    finally {
+        candidate.close();
+    }
+}
+async function confirmImport(overwrite) {
+    const prompt = overwrite
+        ? 'Import this backup and overwrite matching sessions? A snapshot is saved first. [y/N] '
+        : 'Import only new sessions from this backup? A snapshot is saved first. [y/N] ';
+    return confirmYesNo(prompt);
+}
+export function reportImportError(error) {
+    console.error(errorMessage(error));
+    process.exitCode = 1;
+}
+export function registerImport(program) {
+    program
+        .command('import [file]')
+        .description('Merge an elepha backup into the local database')
+        .option('--overwrite', "overwrite matching sessions with the backup's version")
+        .option('--skip-confirmation', 'import without an interactive confirmation')
+        .action(async (file, opts) => {
+        const importBackup = (candidate, overwrite, confirm) => runImportOperation(candidate, overwrite, {
+            dbPath: defaultDbPath(),
+            ...(confirm === undefined ? {} : { confirm }),
+        });
+        if (file === undefined) {
+            if (!process.stdin.isTTY) {
+                console.error('Specify a backup file when not running interactively.');
+                process.exitCode = 1;
+                return;
+            }
+            try {
+                process.exitCode = await runImportWizard({
+                    skipConfirmation: opts.skipConfirmation,
+                    importBackup,
+                });
+            }
+            catch (error) {
+                reportImportError(error);
+            }
+            return;
+        }
+        const confirm = opts.skipConfirmation
+            ? undefined
+            : process.stdin.isTTY
+                ? () => confirmImport(opts.overwrite)
+                : async () => {
+                    throw new Error('Refusing to import without a TTY confirmation. Re-run interactively or use --skip-confirmation.');
+                };
+        try {
+            const result = await importBackup(path.resolve(file), opts.overwrite, confirm);
+            if (result.cancelled) {
+                console.log('Cancelled — no changes were made.');
+            }
+        }
+        catch (error) {
+            reportImportError(error);
+        }
+    });
+}
+//# sourceMappingURL=import.js.map