@danceiny/gotry 0.0.1-rc.8 → 0.0.1-rc.9

package/dist/src/state-ledger.js

@@ -0,0 +1,848 @@
+import Database from 'better-sqlite3';
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, isAbsolute, join } from 'node:path';
+import { mergeProfile } from './memory-capture.js';
+import { appendEvent as gateUtilityEvent, projectUtility } from './memory-utility.js';
+import { appendTrip as gateTrip } from './travel-timeline.js';
+import { upsertCompanion } from './companions.js';
+const SCHEMA_VERSION = '1';
+export function makeWishId(name) {
+    return 'w-' + createHash('sha256').update(String(name).trim()).digest('hex').slice(0, 10);
+}
+function sha(s) {
+    return createHash('sha256').update(s).digest('hex');
+}
+function stateDirOf(stateRoot) {
+    const root = isAbsolute(stateRoot) ? stateRoot : join(process.cwd(), stateRoot);
+    return join(root, 'gotry-state');
+}
+export function ledgerDbPath(stateRoot) {
+    return join(stateDirOf(stateRoot), 'gotry-state.db');
+}
+export function ledgerExists(stateRoot) {
+    return existsSync(ledgerDbPath(stateRoot));
+}
+const LEGACY_FILES = [
+    'motivation-profile.json',
+    'wish-pool.json',
+    'memory-utility.jsonl',
+    'trips.jsonl',
+    'companions.json'
+];
+function legacyFilesPresent(stateRoot) {
+    const dir = stateDirOf(stateRoot);
+    return LEGACY_FILES.some((f)=>existsSync(join(dir, f)));
+}
+function isUniqueViolation(e) {
+    return e instanceof Error && e.code === 'SQLITE_CONSTRAINT_UNIQUE';
+}
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS events (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL,
+  actor TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  subject_id TEXT NOT NULL DEFAULT '',
+  payload TEXT NOT NULL,
+  idem_key TEXT,
+  run_id TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS events_idem ON events(idem_key) WHERE idem_key IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS projection_docs (
+  subject TEXT PRIMARY KEY,
+  doc TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS projection_items (
+  subject TEXT NOT NULL,
+  item_id TEXT NOT NULL,
+  doc TEXT NOT NULL,
+  ord INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (subject, item_id)
+);
+
+CREATE TABLE IF NOT EXISTS workflow_runs (
+  id TEXT PRIMARY KEY,
+  goal TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending','settled','failed')),
+  ticket_json TEXT NOT NULL,
+  state_json TEXT NOT NULL,
+  deliverable TEXT,
+  created TEXT NOT NULL,
+  updated TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS workflow_steps (
+  run_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('intent','done','failed')),
+  result TEXT,
+  intent_ts TEXT NOT NULL,
+  done_ts TEXT,
+  PRIMARY KEY (run_id, name)
+);
+
+CREATE TABLE IF NOT EXISTS pending_writes (
+  idem_key TEXT PRIMARY KEY,
+  seam TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending','confirmed','compensated')),
+  receipt TEXT,
+  created TEXT NOT NULL,
+  updated TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS kv (k TEXT PRIMARY KEY, v TEXT NOT NULL);
+`;
+export class StateLedger {
+    db;
+    stateRoot;
+    dbPath;
+    constructor(db, stateRoot){
+        this.db = db;
+        this.stateRoot = stateRoot;
+        this.dbPath = ledgerDbPath(stateRoot);
+    }
+    insertEvent(ev) {
+        const stmt = this.db.prepare(`INSERT INTO events (ts, actor, kind, subject_id, payload, idem_key, run_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        try {
+            const info = stmt.run(ev.ts ?? new Date().toISOString(), ev.actor, ev.kind, ev.subjectId ?? '', JSON.stringify(ev.payload), ev.idemKey ?? null, ev.runId ?? null);
+            return Number(info.lastInsertRowid);
+        } catch (e) {
+            if (isUniqueViolation(e)) return null;
+            throw e;
+        }
+    }
+    readEvents(kind, limit = 100) {
+        const where = kind ? 'WHERE kind = ?' : '';
+        const rows = this.db.prepare(`SELECT seq, ts, actor, kind, subject_id, payload, idem_key, run_id
+       FROM events ${where} ORDER BY seq DESC LIMIT ?`).all(...kind ? [
+            kind,
+            limit
+        ] : [
+            limit
+        ]);
+        return rows;
+    }
+    countEvents() {
+        return this.db.prepare('SELECT COUNT(*) AS n FROM events').get().n;
+    }
+    readMotivation() {
+        const row = this.db.prepare(`SELECT doc FROM projection_docs WHERE subject = 'motivation'`).get();
+        return row ? JSON.parse(row.doc) : null;
+    }
+    readWishPool() {
+        const rows = this.db.prepare(`SELECT doc FROM projection_items WHERE subject = 'wish_pool' ORDER BY ord, rowid`).all();
+        return rows.map((r)=>JSON.parse(r.doc));
+    }
+    readCompanions() {
+        const rows = this.db.prepare(`SELECT doc FROM projection_items WHERE subject = 'companions' ORDER BY ord, rowid`).all();
+        return rows.map((r)=>JSON.parse(r.doc));
+    }
+    readUtilityEvents() {
+        const rows = this.db.prepare(`SELECT payload FROM events WHERE kind = 'memory_utility.event' ORDER BY seq`).all();
+        return rows.map((r)=>JSON.parse(r.payload).event);
+    }
+    readTrips() {
+        const rows = this.db.prepare(`SELECT payload FROM events WHERE kind = 'trip.logged' ORDER BY seq`).all();
+        return rows.map((r)=>JSON.parse(r.payload).trip);
+    }
+    projectUtilityNow() {
+        return projectUtility(this.readUtilityEvents());
+    }
+    appendMotivationPatch(patch, actor = 'tool:gotry_motivation_save') {
+        const ts = new Date().toISOString();
+        const run = this.db.transaction(()=>{
+            const current = this.readMotivation();
+            const merged = mergeProfile(current, patch);
+            if (!merged) {
+                const unchanged = {
+                    ...current ?? {
+                        weights: {},
+                        evidence: [],
+                        hard: {}
+                    },
+                    updated_at: current?.updated_at ?? ts
+                };
+                return {
+                    saved: false,
+                    profile: unchanged
+                };
+            }
+            const doc = {
+                ...merged,
+                updated_at: ts
+            };
+            this.insertEvent({
+                actor,
+                kind: 'motivation.patch',
+                subjectId: 'motivation',
+                payload: {
+                    patch
+                },
+                ts
+            });
+            this.db.prepare(`INSERT INTO projection_docs (subject, doc) VALUES ('motivation', ?)
+         ON CONFLICT(subject) DO UPDATE SET doc = excluded.doc`).run(JSON.stringify(doc));
+            return {
+                saved: true,
+                profile: doc
+            };
+        });
+        return run();
+    }
+    appendWish(entry, actor = 'tool:gotry_wish_pool_add') {
+        const name = String(entry.name ?? '').trim();
+        const conditions = entry.conditions;
+        if (!name || !conditions || typeof conditions !== 'object' || Object.keys(conditions).length === 0) {
+            throw new Error('wish pool entry requires name and conditions (fulfilment conditions are the whole point)');
+        }
+        const ts = new Date().toISOString();
+        const run = this.db.transaction(()=>{
+            const pool = this.readWishPool();
+            const existing = pool.find((w)=>String(w.name ?? '') === name);
+            if (existing) {
+                const id = typeof existing.wish_id === 'string' && existing.wish_id ? existing.wish_id : makeWishId(name);
+                const next = {
+                    ...existing,
+                    wish_id: id,
+                    reason: entry.reason !== undefined ? entry.reason : existing.reason,
+                    conditions,
+                    ...entry.muted !== undefined ? {
+                        muted: Boolean(entry.muted)
+                    } : {}
+                };
+                this.insertEvent({
+                    actor,
+                    kind: 'wish.updated',
+                    subjectId: id,
+                    payload: {
+                        wish_id: id,
+                        patch: {
+                            reason: next.reason,
+                            conditions,
+                            ...entry.muted !== undefined ? {
+                                muted: Boolean(entry.muted)
+                            } : {}
+                        }
+                    },
+                    ts
+                });
+                this.upsertItem('wish_pool', id, next);
+                return {
+                    added: false,
+                    wish_id: id,
+                    total: pool.length
+                };
+            }
+            const id = makeWishId(name);
+            const doc = {
+                wish_id: id,
+                name,
+                reason: entry.reason ?? '',
+                conditions,
+                ...entry.muted !== undefined ? {
+                    muted: Boolean(entry.muted)
+                } : {},
+                added_at: ts
+            };
+            const seq = this.insertEvent({
+                actor,
+                kind: 'wish.added',
+                subjectId: id,
+                payload: {
+                    wish: doc
+                },
+                ts
+            });
+            this.insertItem('wish_pool', id, doc, seq ?? 0);
+            return {
+                added: true,
+                wish_id: id,
+                total: pool.length + 1
+            };
+        });
+        return run();
+    }
+    appendUtilityEvent(ev, actor = 'tool:gotry_wish_pool_list') {
+        const full = gateUtilityEvent([], ev).events[0];
+        if (!full) return {
+            appended: false,
+            events: this.readUtilityEvents()
+        };
+        const run = this.db.transaction(()=>{
+            return this.insertEvent({
+                actor,
+                kind: 'memory_utility.event',
+                subjectId: full.wish_id,
+                payload: {
+                    event: full
+                },
+                idemKey: `mu:${full.event_id}`
+            }) !== null;
+        });
+        return {
+            appended: run(),
+            events: this.readUtilityEvents()
+        };
+    }
+    appendTripEvent(ev, actor = 'tool:gotry_trip_log') {
+        const run = this.db.transaction(()=>{
+            const existing = this.readTrips();
+            const gate = gateTrip(existing, ev);
+            if (!gate.appended) return {
+                appended: false,
+                tripId: gate.tripId,
+                reason: gate.reason,
+                total: existing.length
+            };
+            const full = gate.events[gate.events.length - 1];
+            this.insertEvent({
+                actor,
+                kind: 'trip.logged',
+                subjectId: full.trip_id,
+                payload: {
+                    trip: full
+                },
+                idemKey: `trip:${full.trip_id}`
+            });
+            return {
+                appended: true,
+                tripId: full.trip_id,
+                total: gate.events.length
+            };
+        });
+        return run();
+    }
+    appendCompanion(patch, actor = 'tool:gotry_companion_save') {
+        const run = this.db.transaction(()=>{
+            const profiles = this.readCompanions();
+            const res = upsertCompanion(profiles, patch);
+            if (!res.appended) return {
+                appended: false,
+                companionId: res.companionId,
+                reason: res.reason,
+                total: profiles.length
+            };
+            this.insertEvent({
+                actor,
+                kind: 'companion.saved',
+                subjectId: res.companionId,
+                payload: {
+                    patch
+                }
+            });
+            this.replaceItems('companions', res.profiles.map((p)=>[
+                    p.companion_id,
+                    p
+                ]));
+            return {
+                appended: true,
+                companionId: res.companionId,
+                total: res.profiles.length
+            };
+        });
+        return run();
+    }
+    confirmOutcome(input, actor = 'tool:gotry_wish_pool_list') {
+        const run = this.db.transaction(()=>{
+            const now = new Date().toISOString();
+            const full = gateUtilityEvent([], {
+                wish_id: input.wishId,
+                kind: 'verified_outcome',
+                ts: now,
+                ctx: 'gotry_wish_pool_list.confirm',
+                detail: input.detail,
+                attribution: input.attribution
+            }).events[0];
+            const recorded = full ? this.insertEvent({
+                actor,
+                kind: 'memory_utility.event',
+                subjectId: full.wish_id,
+                payload: {
+                    event: full
+                },
+                idemKey: `mu:${full.event_id}`
+            }) !== null : false;
+            let trip;
+            if (input.trip) {
+                const existing = this.readTrips();
+                const gate = gateTrip(existing, input.trip);
+                if (gate.appended) {
+                    const fullTrip = gate.events[gate.events.length - 1];
+                    this.insertEvent({
+                        actor,
+                        kind: 'trip.logged',
+                        subjectId: fullTrip.trip_id,
+                        payload: {
+                            trip: fullTrip
+                        },
+                        idemKey: `trip:${fullTrip.trip_id}`
+                    });
+                }
+                trip = {
+                    appended: gate.appended,
+                    tripId: gate.tripId,
+                    reason: gate.reason
+                };
+            }
+            return {
+                recorded,
+                trip
+            };
+        });
+        return run();
+    }
+    upsertItem(subject, itemId, doc) {
+        const ord = this.db.prepare(`SELECT ord FROM projection_items WHERE subject = ? AND item_id = ?`).get(subject, itemId)?.ord ?? this.nextOrd(subject);
+        this.db.prepare(`INSERT INTO projection_items (subject, item_id, doc, ord) VALUES (?, ?, ?, ?)
+       ON CONFLICT(subject, item_id) DO UPDATE SET doc = excluded.doc`).run(subject, itemId, JSON.stringify(doc), ord);
+    }
+    insertItem(subject, itemId, doc, ord) {
+        this.db.prepare(`INSERT INTO projection_items (subject, item_id, doc, ord) VALUES (?, ?, ?, ?)
+       ON CONFLICT(subject, item_id) DO UPDATE SET doc = excluded.doc`).run(subject, itemId, JSON.stringify(doc), ord);
+    }
+    replaceItems(subject, items) {
+        this.db.prepare('DELETE FROM projection_items WHERE subject = ?').run(subject);
+        const ins = this.db.prepare('INSERT INTO projection_items (subject, item_id, doc, ord) VALUES (?, ?, ?, ?)');
+        items.forEach(([id, doc], i)=>ins.run(subject, id, JSON.stringify(doc), i));
+    }
+    nextOrd(subject) {
+        return (this.db.prepare('SELECT COALESCE(MAX(ord), -1) AS m FROM projection_items WHERE subject = ?').get(subject).m ?? -1) + 1;
+    }
+    rebuildProjections(toSeq) {
+        const run = this.db.transaction(()=>{
+            this.db.prepare('DELETE FROM projection_docs').run();
+            this.db.prepare('DELETE FROM projection_items').run();
+            const rows = (toSeq === undefined ? this.db.prepare('SELECT seq, ts, kind, subject_id, payload FROM events ORDER BY seq') : this.db.prepare('SELECT seq, ts, kind, subject_id, payload FROM events WHERE seq <= ? ORDER BY seq')).all(...toSeq === undefined ? [] : [
+                toSeq
+            ]);
+            for (const row of rows)this.foldEvent(row);
+            const wishes = this.db.prepare(`SELECT COUNT(*) AS n FROM projection_items WHERE subject = 'wish_pool'`).get().n;
+            const companions = this.db.prepare(`SELECT COUNT(*) AS n FROM projection_items WHERE subject = 'companions'`).get().n;
+            return {
+                events: rows.length,
+                wishes,
+                companions
+            };
+        });
+        return run();
+    }
+    foldEvent(row) {
+        const p = JSON.parse(row.payload);
+        switch(row.kind){
+            case 'motivation.imported':
+                {
+                    const doc = p['profile'];
+                    this.db.prepare(`INSERT INTO projection_docs (subject, doc) VALUES ('motivation', ?)
+           ON CONFLICT(subject) DO UPDATE SET doc = excluded.doc`).run(JSON.stringify(doc));
+                    break;
+                }
+            case 'motivation.patch':
+                {
+                    const current = this.readMotivation();
+                    const merged = mergeProfile(current, p['patch']);
+                    if (merged) {
+                        const doc = {
+                            ...merged,
+                            updated_at: row.ts
+                        };
+                        this.db.prepare(`INSERT INTO projection_docs (subject, doc) VALUES ('motivation', ?)
+             ON CONFLICT(subject) DO UPDATE SET doc = excluded.doc`).run(JSON.stringify(doc));
+                    }
+                    break;
+                }
+            case 'wish.imported':
+            case 'wish.added':
+                {
+                    const wish = p['wish'] ?? p['profile'];
+                    this.insertItem('wish_pool', String(wish.wish_id ?? row.subject_id), wish, row.seq);
+                    break;
+                }
+            case 'wish.updated':
+                {
+                    const id = String(p['wish_id']);
+                    const patch = p['patch'] ?? {};
+                    const rows = this.db.prepare(`SELECT doc FROM projection_items WHERE subject = 'wish_pool' AND item_id = ?`).get(id);
+                    if (rows) {
+                        const doc = {
+                            ...JSON.parse(rows.doc),
+                            ...patch
+                        };
+                        this.upsertItem('wish_pool', id, doc);
+                    }
+                    break;
+                }
+            case 'companion.imported':
+                {
+                    const profile = p['profile'];
+                    this.insertItem('companions', profile.companion_id, profile, row.seq);
+                    break;
+                }
+            case 'companion.saved':
+                {
+                    const patch = p['patch'];
+                    const res = upsertCompanion(this.readCompanions(), patch);
+                    this.replaceItems('companions', res.profiles.map((c)=>[
+                            c.companion_id,
+                            c
+                        ]));
+                    break;
+                }
+            default:
+                break;
+        }
+    }
+    createWorkflowRun(input, actor = 'system:async-request') {
+        const ts = new Date().toISOString();
+        const run = this.db.transaction(()=>{
+            this.db.prepare(`INSERT INTO workflow_runs (id, goal, status, ticket_json, state_json, deliverable, created, updated)
+         VALUES (?, ?, 'pending', ?, ?, NULL, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET updated = excluded.updated`).run(input.id, input.goal, JSON.stringify(input.ticket), JSON.stringify(input.state), ts, ts);
+            this.insertEvent({
+                actor,
+                kind: 'async.run_created',
+                subjectId: input.id,
+                payload: {
+                    ticket: input.ticket
+                },
+                runId: input.id,
+                ts
+            });
+        });
+        run();
+    }
+    getWorkflowRun(id) {
+        return this.db.prepare('SELECT * FROM workflow_runs WHERE id = ?').get(id);
+    }
+    pendingWorkflowRuns() {
+        return this.db.prepare(`SELECT id, goal FROM workflow_runs WHERE status = 'pending' ORDER BY created`).all();
+    }
+    getWorkflowStep(runId, name) {
+        return this.db.prepare('SELECT status, result FROM workflow_steps WHERE run_id = ? AND name = ?').get(runId, name);
+    }
+    markStepIntent(runId, name) {
+        this.db.prepare(`INSERT INTO workflow_steps (run_id, name, status, intent_ts) VALUES (?, ?, 'intent', ?)
+       ON CONFLICT(run_id, name) DO NOTHING`).run(runId, name, new Date().toISOString());
+    }
+    markStepDone(runId, name, result) {
+        this.db.prepare(`UPDATE workflow_steps SET status = 'done', result = ?, done_ts = ? WHERE run_id = ? AND name = ?`).run(JSON.stringify(result), new Date().toISOString(), runId, name);
+    }
+    settleWorkflowRun(id, deliverable, actor = 'system:async-collect') {
+        const run = this.db.transaction(()=>{
+            this.db.prepare(`UPDATE workflow_runs SET status = 'settled', deliverable = ?, updated = ? WHERE id = ?`).run(deliverable, new Date().toISOString(), id);
+            this.insertEvent({
+                actor,
+                kind: 'async.settled',
+                subjectId: id,
+                payload: {
+                    bytes: deliverable.length
+                },
+                runId: id
+            });
+        });
+        run();
+    }
+    requestPendingWrite(input, actor = 'system:writegate') {
+        const ts = new Date().toISOString();
+        const run = this.db.transaction(()=>{
+            const info = this.db.prepare(`INSERT INTO pending_writes (idem_key, seam, payload, status, created, updated)
+         VALUES (?, ?, ?, 'pending', ?, ?) ON CONFLICT(idem_key) DO NOTHING`).run(input.idemKey, input.seam, JSON.stringify(input.payload ?? {}), ts, ts);
+            if (info.changes === 0) {
+                const row = this.db.prepare('SELECT status FROM pending_writes WHERE idem_key = ?').get(input.idemKey);
+                return {
+                    created: false,
+                    status: row.status
+                };
+            }
+            this.insertEvent({
+                actor,
+                kind: 'write.pending',
+                subjectId: input.idemKey,
+                payload: {
+                    seam: input.seam,
+                    payload: input.payload
+                },
+                idemKey: `pw:${sha(input.idemKey)}:pending`
+            });
+            return {
+                created: true,
+                status: 'pending'
+            };
+        });
+        return run();
+    }
+    confirmPendingWrite(idemKey, receipt, actor = 'system:writegate') {
+        const run = this.db.transaction(()=>{
+            const info = this.db.prepare(`UPDATE pending_writes SET status = 'confirmed', receipt = ?, updated = ? WHERE idem_key = ? AND status = 'pending'`).run(receipt, new Date().toISOString(), idemKey);
+            if (info.changes === 0) {
+                const row = this.db.prepare('SELECT status FROM pending_writes WHERE idem_key = ?').get(idemKey);
+                return {
+                    ok: false,
+                    status: row?.status ?? 'missing'
+                };
+            }
+            this.insertEvent({
+                actor,
+                kind: 'write.confirmed',
+                subjectId: idemKey,
+                payload: {
+                    receipt
+                }
+            });
+            return {
+                ok: true,
+                status: 'confirmed'
+            };
+        });
+        return run();
+    }
+    compensatePendingWrite(idemKey, note, actor = 'system:writegate') {
+        const run = this.db.transaction(()=>{
+            const info = this.db.prepare(`UPDATE pending_writes SET status = 'compensated', receipt = COALESCE(receipt, ?), updated = ? WHERE idem_key = ? AND status != 'compensated'`).run(note, new Date().toISOString(), idemKey);
+            if (info.changes === 0) {
+                const row = this.db.prepare('SELECT status FROM pending_writes WHERE idem_key = ?').get(idemKey);
+                return {
+                    ok: false,
+                    status: row?.status ?? 'missing'
+                };
+            }
+            this.insertEvent({
+                actor,
+                kind: 'write.compensated',
+                subjectId: idemKey,
+                payload: {
+                    note
+                }
+            });
+            return {
+                ok: true,
+                status: 'compensated'
+            };
+        });
+        return run();
+    }
+    listPendingWrites() {
+        return this.db.prepare('SELECT idem_key, seam, status, receipt, created FROM pending_writes ORDER BY created').all();
+    }
+    forkWhatIf(destPath) {
+        this.db.prepare('VACUUM INTO ?').run(destPath);
+        return destPath;
+    }
+    forgetSubject(subjects, actor = 'system:state-cli') {
+        const run = this.db.transaction(()=>{
+            let deleted = 0;
+            for (const s of subjects){
+                const placeholders = s.kinds.map(()=>'?').join(',');
+                const info = this.db.prepare(`DELETE FROM events WHERE subject_id = ? AND kind IN (${placeholders})`).run(s.subjectId, ...s.kinds);
+                deleted += info.changes;
+            }
+            this.insertEvent({
+                actor,
+                kind: 'forget.executed',
+                payload: {
+                    subjects
+                }
+            });
+            this.rebuildProjections();
+            return {
+                deleted
+            };
+        });
+        return run();
+    }
+    close() {
+        this.db.close();
+    }
+}
+const openLedgers = new Map();
+function openDb(stateRoot) {
+    const path = ledgerDbPath(stateRoot);
+    const cached = openLedgers.get(path);
+    if (cached) return cached;
+    mkdirSync(join(path, '..'), {
+        recursive: true
+    });
+    mkdirSync(dirname(path), {
+        recursive: true
+    });
+    const db = new Database(path);
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.pragma('busy_timeout = 5000');
+    db.exec(SCHEMA);
+    db.prepare('INSERT INTO kv (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v').run('schema_version', SCHEMA_VERSION);
+    const ledger = new StateLedger(db, stateRoot);
+    openLedgers.set(path, ledger);
+    return ledger;
+}
+export function openLedgerIfExists(stateRoot) {
+    if (!ledgerExists(stateRoot)) return null;
+    return openDb(stateRoot);
+}
+export function ensureLedger(stateRoot) {
+    if (ledgerExists(stateRoot)) return openDb(stateRoot);
+    const dir = stateDirOf(stateRoot);
+    const hasLegacy = legacyFilesPresent(stateRoot);
+    let backupDir = null;
+    if (hasLegacy) {
+        backupDir = join(dir, 'pre-ledger-backup');
+        mkdirSync(backupDir, {
+            recursive: true
+        });
+        for (const f of LEGACY_FILES){
+            if (existsSync(join(dir, f))) copyFileSync(join(dir, f), join(backupDir, f));
+        }
+    }
+    const ledger = openDb(stateRoot);
+    if (hasLegacy) importLegacyInto(ledger, dir);
+    return ledger;
+}
+function importLegacyInto(ledger, dir) {
+    const imported = {
+        motivation: false,
+        wishes: 0,
+        utilityEvents: 0,
+        trips: 0,
+        companions: 0
+    };
+    const run = ledger.db.transaction(()=>{
+        const flag = ledger.db.prepare(`SELECT v FROM kv WHERE k = 'legacy_imported_v1'`).get();
+        if (flag) return;
+        const readJsonSafe = (p)=>{
+            try {
+                return JSON.parse(readFileSync(p, 'utf-8'));
+            } catch  {
+                return null;
+            }
+        };
+        const profile = readJsonSafe(join(dir, 'motivation-profile.json'));
+        if (profile) {
+            if (ledger.insertEvent({
+                actor: 'system:migrate',
+                kind: 'motivation.imported',
+                subjectId: 'motivation',
+                payload: {
+                    profile
+                },
+                idemKey: 'import:motivation'
+            }) !== null) imported.motivation = true;
+        }
+        const pool = readJsonSafe(join(dir, 'wish-pool.json'));
+        if (Array.isArray(pool)) {
+            for (const w of pool){
+                const id = String(w['wish_id'] ?? makeWishId(String(w['name'] ?? '')));
+                const wish = {
+                    ...w,
+                    wish_id: id
+                };
+                if (ledger.insertEvent({
+                    actor: 'system:migrate',
+                    kind: 'wish.imported',
+                    subjectId: id,
+                    payload: {
+                        wish
+                    },
+                    idemKey: `import:wish:${id}`
+                }) !== null) imported.wishes++;
+            }
+        }
+        try {
+            const lines = readFileSync(join(dir, 'memory-utility.jsonl'), 'utf-8').split('\n').filter(Boolean);
+            for (const line of lines){
+                try {
+                    const ev = JSON.parse(line);
+                    if (ledger.insertEvent({
+                        actor: 'system:migrate',
+                        kind: 'memory_utility.event',
+                        subjectId: ev.wish_id,
+                        payload: {
+                            event: ev
+                        },
+                        idemKey: `mu:${ev.event_id}`
+                    }) !== null) imported.utilityEvents++;
+                } catch  {}
+            }
+        } catch  {}
+        try {
+            const lines = readFileSync(join(dir, 'trips.jsonl'), 'utf-8').split('\n').filter(Boolean);
+            for (const line of lines){
+                try {
+                    const trip = JSON.parse(line);
+                    if (ledger.insertEvent({
+                        actor: 'system:migrate',
+                        kind: 'trip.logged',
+                        subjectId: trip.trip_id,
+                        payload: {
+                            trip
+                        },
+                        idemKey: `trip:${trip.trip_id}`
+                    }) !== null) imported.trips++;
+                } catch  {}
+            }
+        } catch  {}
+        const companions = readJsonSafe(join(dir, 'companions.json'));
+        if (Array.isArray(companions)) {
+            for (const c of companions){
+                const id = String(c['companion_id'] ?? '');
+                if (!id) continue;
+                if (ledger.insertEvent({
+                    actor: 'system:migrate',
+                    kind: 'companion.imported',
+                    subjectId: id,
+                    payload: {
+                        profile: c
+                    },
+                    idemKey: `import:companion:${id}`
+                }) !== null) imported.companions++;
+            }
+        }
+        ledger.rebuildProjections();
+        ledger.db.prepare(`INSERT INTO kv (k, v) VALUES ('legacy_imported_v1', 'done') ON CONFLICT(k) DO UPDATE SET v = excluded.v`).run();
+    });
+    run();
+    return imported;
+}
+function readLegacyJson(stateRoot, name, fallback) {
+    try {
+        return JSON.parse(readFileSync(join(stateDirOf(stateRoot), name), 'utf-8'));
+    } catch  {
+        return fallback;
+    }
+}
+function readLegacyJsonl(stateRoot, name) {
+    try {
+        return readFileSync(join(stateDirOf(stateRoot), name), 'utf-8').split('\n').filter(Boolean).map((l)=>JSON.parse(l));
+    } catch  {
+        return [];
+    }
+}
+export function readMotivationWithFallback(stateRoot) {
+    const ledger = openLedgerIfExists(stateRoot);
+    if (ledger) return ledger.readMotivation();
+    return readLegacyJson(stateRoot, 'motivation-profile.json', null);
+}
+export function readWishPoolWithFallback(stateRoot) {
+    const ledger = openLedgerIfExists(stateRoot);
+    if (ledger) return ledger.readWishPool();
+    return readLegacyJson(stateRoot, 'wish-pool.json', []);
+}
+export function readUtilityEventsWithFallback(stateRoot) {
+    const ledger = openLedgerIfExists(stateRoot);
+    if (ledger) return ledger.readUtilityEvents();
+    return readLegacyJsonl(stateRoot, 'memory-utility.jsonl');
+}
+export function readTripsWithFallback(stateRoot) {
+    const ledger = openLedgerIfExists(stateRoot);
+    if (ledger) return ledger.readTrips();
+    return readLegacyJsonl(stateRoot, 'trips.jsonl');
+}
+export function readCompanionsWithFallback(stateRoot) {
+    const ledger = openLedgerIfExists(stateRoot);
+    if (ledger) return ledger.readCompanions();
+    return readLegacyJson(stateRoot, 'companions.json', []);
+}
+
+
+//# sourceURL=/Users/bytedance/work/gotry/ts/src/state-ledger.ts