@moxxy/core 0.3.0

package/dist/sessions/persistence.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Session persistence — appends each event in `session.log` to a
+ * per-session JSONL file under `~/.moxxy/sessions/`, and maintains an
+ * `index.json` of session metadata so `moxxy resume` can list and
+ * pick a prior session without scanning every event file.
+ *
+ * Layout:
+ *   ~/.moxxy/sessions/
+ *     <sessionId>.meta.json      per-session metadata sidecar (one per session)
+ *     <sessionId>.jsonl          one MoxxyEvent per line
+ *
+ * Each session writes only its OWN `.meta.json` sidecar (write-temp-rename), so
+ * two concurrent moxxy processes can't drop each other's row the way a shared
+ * `index.json` read-modify-write would. `readIndex` assembles the sidecars (and
+ * a legacy `index.json`, if present, for back-compat). JSONL appends are
+ * best-effort (lose at most the last in-flight event on a crash).
+ */
+import { type MoxxyEvent, type SessionId } from '@moxxy/sdk';
+import type { EventLog } from '../events/log.js';
+import { type Logger } from '../logger.js';
+export interface SessionMeta {
+    readonly id: string;
+    readonly cwd: string;
+    readonly startedAt: string;
+    readonly lastActivity: string;
+    readonly eventCount: number;
+    /** First 80 chars of the first user_prompt. Used as the picker label. */
+    readonly firstPrompt: string | null;
+    readonly provider: string | null;
+    readonly model: string | null;
+}
+export interface SessionPersistenceOpts {
+    readonly sessionId: SessionId;
+    readonly cwd: string;
+    /** Override the storage root. Defaults to `~/.moxxy/sessions`. */
+    readonly dir?: string;
+    /** Currently-active provider name — captured into the index for the picker. */
+    readonly providerName?: string;
+    /** Currently-active model id — captured into the index for the picker. */
+    readonly modelId?: string;
+    /**
+     * Structured logger for persistence-degradation warnings. Defaults to a
+     * stderr JSON logger — event-log write failures are the session's source
+     * of truth going dark, so they must be loud even when nothing injects one.
+     */
+    readonly logger?: Logger;
+}
+export declare function defaultSessionsDir(): string;
+/**
+ * Attaches a listener that streams every appended event to disk and
+ * keeps the index in sync. Returns an `unsubscribe` callback the
+ * caller should run on shutdown.
+ */
+export declare class SessionPersistence {
+    private readonly dir;
+    private readonly id;
+    private readonly logPath;
+    private meta;
+    private indexUpdateScheduled;
+    /** Handle for the in-flight debounce timer, so `flush()` can cancel it. */
+    private indexTimer;
+    /**
+     * In-flight writes are serialized through this mutex so the file
+     * stays append-ordered even when events arrive faster than the disk
+     * can flush.
+     */
+    private writeQueue;
+    /**
+     * Memoized one-time setup: `mkdir -p` the sessions dir and create the empty
+     * `.jsonl` (so resume lists the session before any event). Awaited by both
+     * `attach` and `writeIndex` so an early debounced index flush can't race the
+     * initial creation — but it runs the open+close syscalls ONCE, not on every
+     * 250ms flush as before.
+     */
+    private ready;
+    private closed;
+    private readonly logger;
+    /**
+     * Latched while event-log writes are failing. Doubles as the warn-once
+     * gate: only the first failure of a streak logs; a subsequent successful
+     * write clears the latch (and re-arms the warning).
+     */
+    private writeDegraded;
+    constructor(opts: SessionPersistenceOpts);
+    /**
+     * Subscribe to the log; returns the unsubscribe callback. The first
+     * call also writes the initial index row so `moxxy resume` lists
+     * the session before any events arrive.
+     *
+     * Also subscribes to the log's `clear()`, truncating the JSONL in
+     * lockstep so a `/new` wipe can't resurrect on `--resume`. The
+     * session keeps its id and file: post-reset events restart at seq 0
+     * in the same (now empty) JSONL, matching how the in-memory log
+     * reuses the same Session object.
+     */
+    attach(log: EventLog): () => void;
+    /**
+     * Force the pending (debounced) index write to happen now and resolve once
+     * the meta sidecar is on disk. Cancels the in-flight debounce timer so the
+     * write isn't also re-run on its original schedule. Intended for awaitable
+     * shutdown: `detach()` only *schedules* the final write (an `unref`'d timer
+     * an immediate `process.exit` can drop), whereas `await flush()` guarantees
+     * it completed. The steady-state debounce in `scheduleIndexWrite` is
+     * untouched, so calling this mid-session just collapses the next write early.
+     */
+    flush(): Promise<void>;
+    /**
+     * Resolve once every event-log write queued so far has settled. Appends are
+     * enqueued fire-and-forget (`enqueueAppend`), so callers that need to observe
+     * the on-disk result of prior appends — graceful shutdown, or a test that
+     * mutates the filesystem between writes — await this to drain the queue
+     * rather than guessing at timing. Enqueues a no-op at the tail of the same
+     * mutex, so it can only resolve after all earlier appends/truncates have run.
+     */
+    settleWrites(): Promise<void>;
+    /**
+     * Manually update header fields (provider/model) when the user
+     * switches mid-session. The /model picker calls this so the index
+     * reflects the active model when the session is resumed.
+     */
+    updateHeader(patch: {
+        providerName?: string;
+        modelId?: string;
+    }): void;
+    private enqueueAppend;
+    /**
+     * True while event-log writes are failing (history is no longer being
+     * persisted). Cleared automatically by the next successful write.
+     */
+    get degraded(): boolean;
+    private noteWriteOk;
+    private noteWriteFailure;
+    /**
+     * Mirror a `log.clear()` on disk: truncate the JSONL and reset the
+     * sidecar's counters. Rides the same write queue as appends, so
+     * pre-clear appends flush first and post-clear appends land in the
+     * fresh (empty) file — ordering matches the in-memory log exactly.
+     */
+    private enqueueTruncate;
+    private scheduleIndexWrite;
+    private writeIndex;
+    /** One-time, memoized: `mkdir -p` the dir + create the empty `.jsonl`. On
+     *  failure the latch is cleared so a later flush retries (matching the old
+     *  per-write ensureDir/ensureLogFile recoverability). */
+    private ensureReady;
+}
+/**
+ * Read the session index by assembling per-session sidecars (`<id>.meta.json`)
+ * plus a legacy `index.json` if one exists (sidecars win by id). Sessions whose
+ * `.jsonl` is missing are dropped. Sorted most-recent-activity first.
+ */
+export declare function readIndex(dir?: string): Promise<SessionMeta[]>;
+/**
+ * Restore a previously-persisted session's events. Returns the full
+ * event array suitable for passing into `new EventLog(events)`.
+ *
+ * Skips malformed lines (a single corrupted append shouldn't make the
+ * rest of the conversation unreadable) and then RE-SEQUENCES the
+ * survivors to contiguous `seq` 0..n-1, preserving order and ids. This
+ * matters twice over:
+ *
+ *  - Mirror replay: `EventLog.ingest` accepts only `seq === length`, so
+ *    a gap left by one corrupt middle line would silently truncate every
+ *    attached client's history at that point.
+ *  - Future appends: `EventLog.append` mints `seq = events.length`, so a
+ *    gapped seed would mint colliding/out-of-order seqs.
+ *
+ * When anything was skipped or re-sequenced, the file is atomically
+ * rewritten with the repaired events so the NEXT resume starts clean —
+ * otherwise post-resume appends (seq = n-gap..) would interleave with the
+ * stale higher on-disk seqs forever. Safe ordering-wise: restore runs
+ * before `SessionPersistence.attach`, so no append queue is live yet.
+ * Note: compaction/elision events referencing seqs after a gap shift by
+ * the gap size — an accepted, logged trade-off versus losing all
+ * post-gap history.
+ */
+export declare function restoreEvents(sessionId: string, dir?: string, logger?: Logger): Promise<MoxxyEvent[]>;
+/**
+ * Remove a session's log file and its sidecar. A leftover legacy `index.json`
+ * row, if any, is harmless — `readIndex` filters out sessions whose `.jsonl` is
+ * gone, so the deleted session won't reappear.
+ */
+export declare function deleteSession(sessionId: string, dir?: string): Promise<void>;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/sessions/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../src/sessions/persistence.ts"],"names":[],"mappings":"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"}

package/dist/sessions/persistence.js

@@ -0,0 +1,442 @@
+/**
+ * Session persistence — appends each event in `session.log` to a
+ * per-session JSONL file under `~/.moxxy/sessions/`, and maintains an
+ * `index.json` of session metadata so `moxxy resume` can list and
+ * pick a prior session without scanning every event file.
+ *
+ * Layout:
+ *   ~/.moxxy/sessions/
+ *     <sessionId>.meta.json      per-session metadata sidecar (one per session)
+ *     <sessionId>.jsonl          one MoxxyEvent per line
+ *
+ * Each session writes only its OWN `.meta.json` sidecar (write-temp-rename), so
+ * two concurrent moxxy processes can't drop each other's row the way a shared
+ * `index.json` read-modify-write would. `readIndex` assembles the sidecars (and
+ * a legacy `index.json`, if present, for back-compat). JSONL appends are
+ * best-effort (lose at most the last in-flight event on a crash).
+ */
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createMutex } from '@moxxy/sdk';
+import { writeFileAtomic } from '@moxxy/sdk/server';
+import { createLogger } from '../logger.js';
+export function defaultSessionsDir() {
+    return path.join(os.homedir(), '.moxxy', 'sessions');
+}
+/**
+ * Attaches a listener that streams every appended event to disk and
+ * keeps the index in sync. Returns an `unsubscribe` callback the
+ * caller should run on shutdown.
+ */
+export class SessionPersistence {
+    dir;
+    id;
+    logPath;
+    meta;
+    indexUpdateScheduled = false;
+    /** Handle for the in-flight debounce timer, so `flush()` can cancel it. */
+    indexTimer = null;
+    /**
+     * In-flight writes are serialized through this mutex so the file
+     * stays append-ordered even when events arrive faster than the disk
+     * can flush.
+     */
+    writeQueue = createMutex();
+    /**
+     * Memoized one-time setup: `mkdir -p` the sessions dir and create the empty
+     * `.jsonl` (so resume lists the session before any event). Awaited by both
+     * `attach` and `writeIndex` so an early debounced index flush can't race the
+     * initial creation — but it runs the open+close syscalls ONCE, not on every
+     * 250ms flush as before.
+     */
+    ready = null;
+    closed = false;
+    logger;
+    /**
+     * Latched while event-log writes are failing. Doubles as the warn-once
+     * gate: only the first failure of a streak logs; a subsequent successful
+     * write clears the latch (and re-arms the warning).
+     */
+    writeDegraded = false;
+    constructor(opts) {
+        this.dir = opts.dir ?? defaultSessionsDir();
+        this.id = String(opts.sessionId);
+        this.logger = opts.logger ?? createLogger();
+        this.logPath = path.join(this.dir, `${this.id}.jsonl`);
+        const now = new Date().toISOString();
+        this.meta = {
+            id: this.id,
+            cwd: opts.cwd,
+            startedAt: now,
+            lastActivity: now,
+            eventCount: 0,
+            firstPrompt: null,
+            provider: opts.providerName ?? null,
+            model: opts.modelId ?? null,
+        };
+    }
+    /**
+     * Subscribe to the log; returns the unsubscribe callback. The first
+     * call also writes the initial index row so `moxxy resume` lists
+     * the session before any events arrive.
+     *
+     * Also subscribes to the log's `clear()`, truncating the JSONL in
+     * lockstep so a `/new` wipe can't resurrect on `--resume`. The
+     * session keeps its id and file: post-reset events restart at seq 0
+     * in the same (now empty) JSONL, matching how the in-memory log
+     * reuses the same Session object.
+     */
+    attach(log) {
+        void this.ensureReady()
+            .then(() => this.scheduleIndexWrite())
+            .catch(() => undefined);
+        const unsub = log.subscribe((event) => {
+            if (this.closed)
+                return;
+            this.enqueueAppend(event);
+        });
+        const unsubClear = log.onClear(() => {
+            if (this.closed)
+                return;
+            this.enqueueTruncate();
+        });
+        return () => {
+            this.closed = true;
+            unsub();
+            unsubClear();
+            // Schedule a final index write so lastActivity reflects the close time
+            // even if no events arrived in the last debounce window. This is the
+            // best-effort, fire-and-forget path; the debounce timer is `unref`'d, so
+            // a process that exits immediately after detach would drop it. Shutdown
+            // paths that MUST not lose the final row should `await persistence.flush()`
+            // instead — it bypasses the debounce and resolves once the row is on disk.
+            this.scheduleIndexWrite();
+        };
+    }
+    /**
+     * Force the pending (debounced) index write to happen now and resolve once
+     * the meta sidecar is on disk. Cancels the in-flight debounce timer so the
+     * write isn't also re-run on its original schedule. Intended for awaitable
+     * shutdown: `detach()` only *schedules* the final write (an `unref`'d timer
+     * an immediate `process.exit` can drop), whereas `await flush()` guarantees
+     * it completed. The steady-state debounce in `scheduleIndexWrite` is
+     * untouched, so calling this mid-session just collapses the next write early.
+     */
+    async flush() {
+        if (this.indexTimer) {
+            clearTimeout(this.indexTimer);
+            this.indexTimer = null;
+        }
+        this.indexUpdateScheduled = false;
+        await this.writeIndex();
+    }
+    /**
+     * Resolve once every event-log write queued so far has settled. Appends are
+     * enqueued fire-and-forget (`enqueueAppend`), so callers that need to observe
+     * the on-disk result of prior appends — graceful shutdown, or a test that
+     * mutates the filesystem between writes — await this to drain the queue
+     * rather than guessing at timing. Enqueues a no-op at the tail of the same
+     * mutex, so it can only resolve after all earlier appends/truncates have run.
+     */
+    async settleWrites() {
+        await this.writeQueue.run(() => undefined);
+    }
+    /**
+     * Manually update header fields (provider/model) when the user
+     * switches mid-session. The /model picker calls this so the index
+     * reflects the active model when the session is resumed.
+     */
+    updateHeader(patch) {
+        this.meta = {
+            ...this.meta,
+            provider: patch.providerName ?? this.meta.provider,
+            model: patch.modelId ?? this.meta.model,
+        };
+        this.scheduleIndexWrite();
+    }
+    enqueueAppend(event) {
+        // Update in-memory meta synchronously so multiple events in the
+        // same tick share one debounced index write.
+        this.meta = {
+            ...this.meta,
+            eventCount: this.meta.eventCount + 1,
+            lastActivity: new Date().toISOString(),
+            firstPrompt: this.meta.firstPrompt ??
+                (event.type === 'user_prompt' ? event.text.slice(0, 80) : null),
+        };
+        this.scheduleIndexWrite();
+        const line = JSON.stringify(event) + '\n';
+        // Never propagate a write error into the listener chain — but never
+        // swallow it silently either: the JSONL is the session's source of
+        // truth, so a failing disk must at least be loud.
+        //
+        // Serialize the append behind `ensureReady()` (memoized mkdir -p + open):
+        // `fs.appendFile` with flag 'a' creates the FILE but not its parent dir, so
+        // a first event that arrives before `attach()`'s detached `ensureReady()`
+        // resolves on a machine without `~/.moxxy/sessions` would ENOENT, latch the
+        // misleading "persistence degraded" warning, and lose that event. Because
+        // `ready` is memoized, every later append pays nothing.
+        void this.writeQueue
+            .run(() => this.ensureReady().then(() => fs.appendFile(this.logPath, line, 'utf8')))
+            .then(() => this.noteWriteOk())
+            .catch((err) => this.noteWriteFailure('append', err));
+    }
+    /**
+     * True while event-log writes are failing (history is no longer being
+     * persisted). Cleared automatically by the next successful write.
+     */
+    get degraded() {
+        return this.writeDegraded;
+    }
+    noteWriteOk() {
+        if (!this.writeDegraded)
+            return;
+        this.writeDegraded = false;
+        this.logger.info('session event-log writes recovered', { path: this.logPath });
+    }
+    noteWriteFailure(op, err) {
+        const alreadyDegraded = this.writeDegraded;
+        this.writeDegraded = true;
+        if (alreadyDegraded)
+            return; // warn once per failure streak, not per event
+        this.logger.warn('session event-log write failed — history persistence degraded (resume will miss these events)', {
+            op,
+            path: this.logPath,
+            sessionId: this.id,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    /**
+     * Mirror a `log.clear()` on disk: truncate the JSONL and reset the
+     * sidecar's counters. Rides the same write queue as appends, so
+     * pre-clear appends flush first and post-clear appends land in the
+     * fresh (empty) file — ordering matches the in-memory log exactly.
+     */
+    enqueueTruncate() {
+        this.meta = {
+            ...this.meta,
+            eventCount: 0,
+            firstPrompt: null,
+            lastActivity: new Date().toISOString(),
+        };
+        this.scheduleIndexWrite();
+        void this.writeQueue
+            .run(() => this.ensureReady().then(() => fs.writeFile(this.logPath, '', 'utf8')))
+            .then(() => this.noteWriteOk())
+            .catch((err) => this.noteWriteFailure('truncate', err));
+    }
+    scheduleIndexWrite() {
+        if (this.indexUpdateScheduled)
+            return;
+        this.indexUpdateScheduled = true;
+        // 250ms debounce — fast enough that the picker stays current,
+        // slow enough that a chatty turn doesn't rewrite the index per
+        // assistant_chunk.
+        const timer = setTimeout(() => {
+            this.indexUpdateScheduled = false;
+            this.indexTimer = null;
+            void this.writeIndex();
+        }, 250);
+        timer.unref?.();
+        this.indexTimer = timer;
+    }
+    async writeIndex() {
+        try {
+            // Once closed (the final detach/flush write), don't re-create the dir or
+            // log file: setup already made them, and resurrecting a directory a
+            // concurrent `deleteSession`/teardown is removing would leave a stray
+            // sidecar behind. A live session awaits the (memoized) one-time setup so
+            // an early write can't race the initial creation — but this no longer
+            // re-runs the mkdir/open+close syscalls on every 250ms flush.
+            if (!this.closed) {
+                await this.ensureReady();
+            }
+            // Write ONLY this session's sidecar (`<id>.meta.json`), never a
+            // read-modify-write of a shared index.json — that loses rows when two
+            // moxxy processes update "their" row concurrently (each reads the index,
+            // re-adds only itself, and the last writer drops the other's row).
+            // `writeJsonAtomic` already `mkdir -p`s the sidecar's dir, so this owns no
+            // ensureLogFile — the `.jsonl` is the append path's responsibility.
+            await writeJsonAtomic(metaPath(this.dir, this.meta.id), this.meta);
+        }
+        catch {
+            // Index write failures shouldn't bring down a session; the
+            // user can always re-resume by id from the filename.
+        }
+    }
+    /** One-time, memoized: `mkdir -p` the dir + create the empty `.jsonl`. On
+     *  failure the latch is cleared so a later flush retries (matching the old
+     *  per-write ensureDir/ensureLogFile recoverability). */
+    ensureReady() {
+        if (!this.ready) {
+            this.ready = (async () => {
+                await fs.mkdir(this.dir, { recursive: true });
+                const handle = await fs.open(this.logPath, 'a');
+                await handle.close();
+            })().catch((err) => {
+                this.ready = null;
+                throw err;
+            });
+        }
+        return this.ready;
+    }
+}
+/**
+ * Read the session index by assembling per-session sidecars (`<id>.meta.json`)
+ * plus a legacy `index.json` if one exists (sidecars win by id). Sessions whose
+ * `.jsonl` is missing are dropped. Sorted most-recent-activity first.
+ */
+export async function readIndex(dir = defaultSessionsDir()) {
+    const byId = new Map();
+    // Legacy single-file index (pre-sidecar layout). Sidecars override it below.
+    try {
+        const raw = await fs.readFile(path.join(dir, 'index.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            for (const m of parsed.filter(isSessionMeta))
+                byId.set(m.id, m);
+        }
+    }
+    catch {
+        // no legacy index — fine
+    }
+    let dirents;
+    try {
+        dirents = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        dirents = [];
+    }
+    await Promise.all(dirents
+        .filter((d) => d.isFile() && d.name.endsWith('.meta.json'))
+        .map(async (d) => {
+        try {
+            const raw = await fs.readFile(path.join(dir, d.name), 'utf8');
+            const parsed = JSON.parse(raw);
+            if (isSessionMeta(parsed))
+                byId.set(parsed.id, parsed);
+        }
+        catch {
+            // skip a malformed/half-written sidecar
+        }
+    }));
+    const metas = [...byId.values()];
+    const checks = await Promise.all(metas.map(async (meta) => {
+        try {
+            await fs.access(path.join(dir, `${meta.id}.jsonl`));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }));
+    return metas
+        .filter((_, index) => checks[index])
+        .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+}
+/**
+ * Restore a previously-persisted session's events. Returns the full
+ * event array suitable for passing into `new EventLog(events)`.
+ *
+ * Skips malformed lines (a single corrupted append shouldn't make the
+ * rest of the conversation unreadable) and then RE-SEQUENCES the
+ * survivors to contiguous `seq` 0..n-1, preserving order and ids. This
+ * matters twice over:
+ *
+ *  - Mirror replay: `EventLog.ingest` accepts only `seq === length`, so
+ *    a gap left by one corrupt middle line would silently truncate every
+ *    attached client's history at that point.
+ *  - Future appends: `EventLog.append` mints `seq = events.length`, so a
+ *    gapped seed would mint colliding/out-of-order seqs.
+ *
+ * When anything was skipped or re-sequenced, the file is atomically
+ * rewritten with the repaired events so the NEXT resume starts clean —
+ * otherwise post-resume appends (seq = n-gap..) would interleave with the
+ * stale higher on-disk seqs forever. Safe ordering-wise: restore runs
+ * before `SessionPersistence.attach`, so no append queue is live yet.
+ * Note: compaction/elision events referencing seqs after a gap shift by
+ * the gap size — an accepted, logged trade-off versus losing all
+ * post-gap history.
+ */
+export async function restoreEvents(sessionId, dir = defaultSessionsDir(), logger = createLogger()) {
+    const logPath = path.join(dir, `${sessionId}.jsonl`);
+    let raw;
+    try {
+        raw = await fs.readFile(logPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Session not found: ${sessionId}`);
+    }
+    const events = [];
+    let corruptLines = 0;
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+            corruptLines += 1;
+        }
+    }
+    // Re-sequence to contiguous 0..n-1 (order + ids preserved). A clean log is
+    // already contiguous, so this is a no-op in the common case.
+    let resequenced = 0;
+    for (let i = 0; i < events.length; i += 1) {
+        if (events[i].seq !== i) {
+            events[i] = { ...events[i], seq: i };
+            resequenced += 1;
+        }
+    }
+    if (corruptLines > 0 || resequenced > 0) {
+        logger.warn('session log restored with gaps — re-sequenced to keep full history replayable', {
+            sessionId,
+            path: logPath,
+            corruptLines,
+            resequencedEvents: resequenced,
+            restoredEvents: events.length,
+        });
+        try {
+            const repaired = events.map((e) => JSON.stringify(e) + '\n').join('');
+            await writeFileAtomic(logPath, repaired);
+        }
+        catch (err) {
+            // Restore still succeeds — the in-memory log is repaired; only the
+            // next resume would re-run this same repair.
+            logger.warn('failed to rewrite repaired session log on disk', {
+                sessionId,
+                path: logPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return events;
+}
+/**
+ * Remove a session's log file and its sidecar. A leftover legacy `index.json`
+ * row, if any, is harmless — `readIndex` filters out sessions whose `.jsonl` is
+ * gone, so the deleted session won't reappear.
+ */
+export async function deleteSession(sessionId, dir = defaultSessionsDir()) {
+    await fs.rm(path.join(dir, `${sessionId}.jsonl`), { force: true });
+    await fs.rm(metaPath(dir, sessionId), { force: true });
+}
+/** Per-session metadata sidecar path. */
+function metaPath(dir, id) {
+    return path.join(dir, `${id}.meta.json`);
+}
+async function writeJsonAtomic(target, value) {
+    await writeFileAtomic(target, JSON.stringify(value, null, 2) + '\n');
+}
+function isSessionMeta(v) {
+    if (!v || typeof v !== 'object')
+        return false;
+    const m = v;
+    return (typeof m.id === 'string' &&
+        typeof m.cwd === 'string' &&
+        typeof m.startedAt === 'string' &&
+        typeof m.lastActivity === 'string' &&
+        typeof m.eventCount === 'number');
+}
+//# sourceMappingURL=persistence.js.map

package/dist/sessions/persistence.js.map

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