@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/session-persistence-sqlite/lib/types/store.js

@@ -0,0 +1,394 @@
+/**
+ * SQLite storage primitives: transactional append-batch packing, physical
+ * reads, schema validation, revisions, repair, and lifecycle closure.
+ * @module @nomix-ai/nomix-session-persistence-sqlite/store
+ */
+import { randomUUID } from 'node:crypto';
+import { statSync } from 'node:fs';
+import { lstat, mkdir, open } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { SessionPersistenceRevision, } from '../../../session-persistence/lib/index.js';
+import { MAX_PACKED_ROW_MEMBERS, packChunkRuns, } from "./codec.js";
+import { bindRecord, decodeRow, scanRows, } from "./compression.js";
+import { decodeEventRow, decodeSessionRow, decodeStoreIdentity, openDatabase, validateSchemaForMutation, rowToMeta, } from "./schema.js";
+import { sql } from "./sql.js";
+/** SQLite implementation of the coordinator's physical backend hooks. */
+export class SqliteStore {
+    options;
+    name = 'session-persistence-sqlite';
+    db;
+    databaseConstructor;
+    storeIdentity;
+    databasePath;
+    opened = false;
+    pathReady;
+    ready;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Validate filesystem ownership without importing or opening Node SQLite.
+     * @returns settlement of the store's one path-validation operation.
+     */
+    validatePath() {
+        this.pathReady ??= this.preparePath(this.options.path);
+        return this.pathReady;
+    }
+    /**
+     * Lazily open and validate the database on first persistence use.
+     * @returns settlement of the store's one database-open operation.
+     */
+    open() {
+        this.ready ??= this.openDb();
+        return this.ready;
+    }
+    async preparePath(path) {
+        const actual = path === ':memory:' ? path : resolve(path);
+        if (actual !== ':memory:') {
+            await mkdir(dirname(actual), { recursive: true, mode: 0o700 });
+            await validateParentDirectory(dirname(actual));
+            await validateDatabaseFileIfPresent(actual);
+        }
+        this.databasePath = actual;
+    }
+    async openDb() {
+        await this.validatePath();
+        if (this.databasePath !== ':memory:') {
+            await createDatabaseFile(this.databasePath);
+            await validateDatabaseFile(this.databasePath);
+        }
+        const { DatabaseSync } = await loadNodeSqlite();
+        this.databaseConstructor = DatabaseSync;
+        this.db = await openDatabase(DatabaseSync, this.databasePath, this.options.journalMode, this.options.busyTimeoutMs);
+        try {
+            const row = this.db.prepare(sql('select-store-id')).get();
+            if (row === undefined) {
+                throw new Error(`session database at "${this.databasePath}" has no valid store identity`);
+            }
+            let storeId;
+            try {
+                storeId = decodeStoreIdentity(row);
+            }
+            catch (error) {
+                throw new Error(`session database at "${this.databasePath}" has no valid store identity`, { cause: error });
+            }
+            if (this.databasePath === ':memory:') {
+                this.storeIdentity = `memory:store:${storeId}`;
+            }
+            else {
+                const identity = statSync(this.databasePath, { bigint: true });
+                this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${storeId}`;
+            }
+            this.opened = true;
+        }
+        catch (error) {
+            this.db.close();
+            throw error;
+        }
+    }
+    async loadStored(id, signal) {
+        await this.observe(signal);
+        const snapshot = this.readTransaction(() => {
+            const row = this.rowFor(id);
+            if (row === undefined)
+                return undefined;
+            const eventRows = this.db.prepare(sql('select-events')).all(id).map(decodeEventRow);
+            return { row, eventRows };
+        });
+        signal?.throwIfAborted();
+        if (snapshot === undefined)
+            return undefined;
+        const scanned = scanRows(snapshot.eventRows);
+        return {
+            meta: rowToMeta(snapshot.row),
+            events: scanned.preserved,
+            revision: sqliteRevision(this.storeIdentity, snapshot.row),
+            ...scanned.tornFrom === undefined ? {} : { tornMarker: scanned.tornFrom },
+        };
+    }
+    async readStoredRevision(id, signal) {
+        await this.observe(signal);
+        const row = this.rowFor(id);
+        signal?.throwIfAborted();
+        return row === undefined ? undefined : sqliteRevision(this.storeIdentity, row);
+    }
+    async loadStoredFrom(id, fromSeq, signal) {
+        await this.observe(signal);
+        const snapshot = this.readTransaction(() => {
+            const row = this.rowFor(id);
+            if (row === undefined)
+                return undefined;
+            return { row, ...this.physicalSpanFrom(id, fromSeq) };
+        });
+        signal?.throwIfAborted();
+        if (snapshot === undefined)
+            return undefined;
+        const { preserved } = scanRows(snapshot.eventRows, snapshot.base);
+        return { meta: rowToMeta(snapshot.row), events: preserved.filter(event => event.seq >= fromSeq) };
+    }
+    async appendBatch(meta, events, isMaterialized) {
+        await this.open();
+        if (events.length === 0)
+            return;
+        this.db.exec(sql('begin-immediate'));
+        try {
+            validateSchemaForMutation(this.databaseConstructor, this.db, this.databasePath);
+            const tailRows = this.tailRows(meta.id);
+            const currentLast = this.logicalLastEvent(meta.id, tailRows);
+            const expected = currentLast === undefined ? 0 : currentLast.seq + 1;
+            const first = events[0];
+            if (first.seq !== expected) {
+                throw new Error(`session ${meta.id} append starts at seq ${first.seq}, stored next seq is ${expected}`);
+            }
+            if (!isMaterialized)
+                this.writeRow(meta);
+            const insert = this.insertStatement();
+            for (const record of packChunkRuns(events))
+                this.insertRecord(insert, meta.id, bindRecord(record));
+            this.incrementRevision(meta.id);
+            this.db.exec(sql('commit'));
+        }
+        catch (error) {
+            this.rollback(error, 'append');
+        }
+    }
+    async commitRepair(meta, tornMarker, closers) {
+        await this.open();
+        if (tornMarker === undefined && closers.length === 0)
+            return;
+        this.db.exec(sql('begin-immediate'));
+        try {
+            validateSchemaForMutation(this.databaseConstructor, this.db, this.databasePath);
+            const row = this.rowFor(meta.id);
+            if (row === undefined)
+                throw new Error(`session ${meta.id} metadata row is missing`);
+            const currentRows = this.db.prepare(sql('select-events')).all(meta.id).map(decodeEventRow);
+            const current = scanRows(currentRows);
+            if (tornMarker !== undefined) {
+                if (current.tornFrom !== tornMarker) {
+                    throw new Error(`session ${meta.id} repair is stale: physical tail no longer starts at seq ${tornMarker}`);
+                }
+                this.db.prepare(sql('delete-events-from'))
+                    .run(meta.id, tornMarker);
+            }
+            else if (current.tornFrom !== undefined) {
+                throw new Error(`session ${meta.id} repair omitted current torn tail at seq ${current.tornFrom}`);
+            }
+            if (closers.length > 0) {
+                const expected = current.preserved.at(-1)?.seq === undefined
+                    ? 0
+                    : current.preserved.at(-1).seq + 1;
+                if (closers[0]?.seq !== expected) {
+                    throw new Error(`session ${meta.id} repair is stale: closer starts at seq ${closers[0]?.seq}, stored next seq is ${expected}`);
+                }
+                const insert = this.insertStatement();
+                for (const closer of closers)
+                    this.insertRecord(insert, meta.id, bindRecord(closer));
+            }
+            this.incrementRevision(meta.id);
+            this.db.exec(sql('commit'));
+        }
+        catch (error) {
+            this.rollback(error, 'repair');
+        }
+    }
+    async list(signal) {
+        await this.observe(signal);
+        const rows = this.sessionRows();
+        signal?.throwIfAborted();
+        return rows.map(rowToMeta);
+    }
+    /**
+     * Return every materialized header with its source-qualified revision.
+     * @param signal - optional cancellation before or after the metadata query.
+     * @returns stored headers and revisions without loading event rows.
+     */
+    async listSnapshots(signal) {
+        await this.observe(signal);
+        const rows = this.sessionRows();
+        signal?.throwIfAborted();
+        return rows.map(row => ({
+            header: rowToMeta(row),
+            revision: sqliteRevision(this.storeIdentity, row),
+        }));
+    }
+    async close() {
+        if (this.ready === undefined) {
+            if (this.pathReady !== undefined)
+                await Promise.allSettled([this.pathReady]);
+            return;
+        }
+        await Promise.allSettled([this.ready]);
+        if (!this.opened)
+            return;
+        this.opened = false;
+        this.db.close();
+    }
+    rowFor(id) {
+        const value = this.db.prepare(sql('select-session')).get(id);
+        return value === undefined ? undefined : decodeSessionRow(value);
+    }
+    async observe(signal) {
+        signal?.throwIfAborted();
+        await this.open();
+        signal?.throwIfAborted();
+    }
+    readTransaction(read) {
+        this.db.exec(sql('begin'));
+        try {
+            const value = read();
+            this.db.exec(sql('commit'));
+            return value;
+        }
+        catch (error) {
+            this.rollback(error, 'read');
+        }
+    }
+    sessionRows() {
+        return this.db.prepare(sql('select-sessions')).all().map(decodeSessionRow);
+    }
+    rollback(error, operation) {
+        try {
+            this.db.exec(sql('rollback'));
+        }
+        catch (rollbackError) {
+            /* v8 ignore next -- requires SQLite to fail both an operation and its immediate rollback. */
+            throw new AggregateError([error, rollbackError], `${this.name} ${operation} failed and rollback also failed`);
+        }
+        throw error;
+    }
+    incrementRevision(id) {
+        const updated = this.db.prepare(sql('update-session-revision'))
+            .run(id);
+        /* v8 ignore next -- materialized writes follow coordinator create(); other writes upsert in this transaction. */
+        if (Number(updated.changes) !== 1)
+            throw new Error(`session ${id} metadata row is missing`);
+    }
+    tailRows(id) {
+        const tail = this.db.prepare(sql('select-tail-events')).all(id, 2).map(decodeEventRow).reverse();
+        if (tail.length === 0)
+            return [];
+        return this.physicalSpanFrom(id, tail[0].seq).eventRows;
+    }
+    /** Select the bounded physical span that may represent `fromSeq`. */
+    physicalSpanFrom(id, fromSeq) {
+        const packedFloor = Math.max(0, fromSeq - MAX_PACKED_ROW_MEMBERS + 1);
+        const packedPredecessors = this.db.prepare(sql('select-packed-predecessors'))
+            .all(id, packedFloor, fromSeq)
+            .map(decodeEventRow);
+        let base = fromSeq;
+        for (const predecessor of packedPredecessors) {
+            try {
+                const last = decodeRow(predecessor).at(-1);
+                if (last !== undefined && last.seq >= fromSeq)
+                    base = Math.min(base, predecessor.seq);
+            }
+            catch {
+                // A malformed bounded predecessor may cover fromSeq; include it so the scanner fails closed.
+                base = Math.min(base, predecessor.seq);
+            }
+        }
+        const eventRows = this.db.prepare(sql('select-events-from')).all(id, base).map(decodeEventRow);
+        return { base, eventRows };
+    }
+    logicalLastEvent(id, tailRows) {
+        if (tailRows.length === 0)
+            return undefined;
+        const { preserved, tornFrom } = scanRows(tailRows, tailRows[0].seq);
+        if (tornFrom !== undefined)
+            throw new Error(`session ${id} has an invalid physical tail at seq ${tornFrom}`);
+        return preserved.at(-1);
+    }
+    insertStatement() {
+        return this.db.prepare(sql('insert-event'));
+    }
+    insertRecord(insert, id, record) {
+        insert.run(id, record.seq, record.type, record.time, record.data, record.sourceEventSeqs, record.surfaceOp, record.ignorable);
+    }
+    writeRow(meta) {
+        this.db.prepare(sql('upsert-session')).run(meta.id, meta.version, meta.createdAt, meta.cwd ?? null, meta.parentSession ?? null, meta.seedLength ?? null, meta.origin ?? null, meta.delegationDepth ?? null, meta.agentPreset ?? null, randomUUID());
+    }
+}
+function sqliteRevision(storeIdentity, row) {
+    return SessionPersistenceRevision(`${storeIdentity}:incarnation:${row.incarnation}:revision:${row.revision}`);
+}
+async function createDatabaseFile(path) {
+    try {
+        const handle = await open(path, 'wx', 0o600);
+        await handle.close();
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+}
+async function validateParentDirectory(path) {
+    const parent = await lstat(path);
+    if (parent.isSymbolicLink() || !parent.isDirectory()) {
+        throw new Error(`session database parent "${path}" must be a real directory`);
+    }
+    const uid = process.getuid?.();
+    /* v8 ignore start -- Windows exposes neither process.getuid nor meaningful
+     * uid/mode bits; POSIX tests cover owner and mode rejection. */
+    if (uid !== undefined && (parent.uid !== uid || (parent.mode & 0o022) !== 0)) {
+        throw new Error(`session database parent "${path}" must be owned by the current user and not group/world-writable`);
+    }
+    /* v8 ignore stop */
+}
+async function validateDatabaseFile(path) {
+    const file = await lstat(path);
+    if (file.isSymbolicLink() || !file.isFile()) {
+        throw new Error(`session database "${path}" must be a regular file, not a symbolic link`);
+    }
+    const uid = process.getuid?.();
+    /* v8 ignore start -- Windows exposes neither process.getuid nor meaningful
+     * uid/mode bits; POSIX tests cover owner and mode rejection. */
+    if (uid !== undefined && (file.uid !== uid || (file.mode & 0o077) !== 0)) {
+        throw new Error(`session database "${path}" must be owned by the current user and accessible only by that user`);
+    }
+    /* v8 ignore stop */
+}
+async function validateDatabaseFileIfPresent(path) {
+    try {
+        await validateDatabaseFile(path);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+let nodeSqlite;
+/** Load Node SQLite once so concurrent stores share one warning-filter lifetime. */
+function loadNodeSqlite() {
+    nodeSqlite ??= importNodeSqlite();
+    return nodeSqlite;
+}
+/** Import Node 22's SQLite dependency without its process-wide experimental warning. */
+async function importNodeSqlite() {
+    const emitWarning = Reflect.get(process, 'emitWarning');
+    /* v8 ignore start -- Node 22 alone emits this warning; primary coverage runs on Node 24. */
+    const filteredEmitWarning = (warning, ...args) => {
+        const message = warning instanceof Error ? warning.message : warning;
+        const first = args[0];
+        const type = warning instanceof Error
+            ? warning.name
+            : typeof first === 'string'
+                ? first
+                : typeof first === 'object' && first !== null && 'type' in first
+                    ? first.type
+                    : undefined;
+        if (message === 'SQLite is an experimental feature and might change at any time'
+            && type === 'ExperimentalWarning')
+            return;
+        Reflect.apply(emitWarning, process, [warning, ...args]);
+    };
+    Reflect.set(process, 'emitWarning', filteredEmitWarning);
+    try {
+        return await import('node:sqlite');
+    }
+    finally {
+        Reflect.set(process, 'emitWarning', emitWarning);
+    }
+    /* v8 ignore stop */
+}
+//# sourceMappingURL=store.js.map

package/dist/kernel/session-persistence-sqlite/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-session-persistence-sqlite",
-  "description": "SQLite durable session persistence backend for the Nomix Harness",
-  "version": "0.2.5",
+  "description": "SQLite durable session persistence with physical chunk-row packing",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },
@@ -28,11 +28,13 @@
   "files": [
     "lib/index.js",
     "lib/invariant.js",
+    "resources/sql/**/*.sql",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
   "peerDependencies": {
     "@nomix-ai/nomix-invariants": "workspace:^",
+    "@nomix-ai/nomix-llm": "workspace:^",
     "@nomix-ai/nomix-session": "workspace:^",
     "@nomix-ai/nomix-session-persistence": "workspace:^",
     "@nomix-ai/cordis": "workspace:^"
@@ -41,9 +43,13 @@
     "@nomix-ai/schemastery": "workspace:^"
   },
   "devDependencies": {
+    "@nomix-ai/cordis-plugin-include": "workspace:^",
+    "@nomix-ai/cordis-plugin-loader": "workspace:^",
     "@nomix-ai/nomix-invariants": "workspace:^",
+    "@nomix-ai/nomix-llm": "workspace:^",
     "@nomix-ai/nomix-session": "workspace:^",
     "@nomix-ai/nomix-session-persistence": "workspace:^",
-    "@nomix-ai/cordis": "workspace:^"
+    "@nomix-ai/cordis": "workspace:^",
+    "typescript": "^6.0.3"
   }
 }

package/dist/kernel/session-persistence-sqlite/resources/sql/begin-immediate.sql

@@ -0,0 +1 @@
+BEGIN IMMEDIATE;

package/dist/kernel/session-persistence-sqlite/resources/sql/begin.sql

@@ -0,0 +1 @@
+BEGIN;

package/dist/kernel/session-persistence-sqlite/resources/sql/commit.sql

@@ -0,0 +1 @@
+COMMIT;

package/dist/kernel/session-persistence-sqlite/resources/sql/delete-events-from.sql

@@ -0,0 +1,2 @@
+DELETE FROM events
+WHERE session_id = ? AND seq >= ?;

package/dist/kernel/session-persistence-sqlite/resources/sql/foreign-keys-on.sql

@@ -0,0 +1 @@
+PRAGMA foreign_keys = ON;

package/dist/kernel/session-persistence-sqlite/resources/sql/insert-event.sql

@@ -0,0 +1,3 @@
+INSERT INTO events
+  (session_id, seq, type, time, data, source_event_seqs, surface_op, ignorable)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?);

package/dist/kernel/session-persistence-sqlite/resources/sql/insert-persistence-state.sql

@@ -0,0 +1,2 @@
+INSERT INTO persistence_state (singleton, store_id)
+VALUES (1, ?);

package/dist/kernel/session-persistence-sqlite/resources/sql/journal-mode-delete.sql

@@ -0,0 +1 @@
+PRAGMA journal_mode = DELETE;

package/dist/kernel/session-persistence-sqlite/resources/sql/journal-mode-persist.sql

@@ -0,0 +1 @@
+PRAGMA journal_mode = PERSIST;

package/dist/kernel/session-persistence-sqlite/resources/sql/journal-mode-truncate.sql

@@ -0,0 +1 @@
+PRAGMA journal_mode = TRUNCATE;

package/dist/kernel/session-persistence-sqlite/resources/sql/journal-mode-wal.sql

@@ -0,0 +1 @@
+PRAGMA journal_mode = WAL;

package/dist/kernel/session-persistence-sqlite/resources/sql/mmap-off.sql

@@ -0,0 +1 @@
+PRAGMA mmap_size = 0;

package/dist/kernel/session-persistence-sqlite/resources/sql/rollback.sql

@@ -0,0 +1 @@
+ROLLBACK;

package/dist/kernel/session-persistence-sqlite/resources/sql/schema.sql

@@ -0,0 +1,30 @@
+CREATE TABLE persistence_state (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  store_id  TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE sessions (
+  id               TEXT PRIMARY KEY,
+  version          INTEGER NOT NULL,
+  created_at       INTEGER NOT NULL,
+  cwd              TEXT,
+  parent_session   TEXT,
+  seed_length      INTEGER,
+  origin           TEXT,
+  delegation_depth INTEGER,
+  agent_preset     TEXT,
+  incarnation      TEXT NOT NULL,
+  revision         INTEGER NOT NULL
+) STRICT;
+
+CREATE TABLE events (
+  session_id        TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  seq               INTEGER NOT NULL,
+  type              TEXT NOT NULL,
+  time              INTEGER NOT NULL,
+  data              ANY NOT NULL,
+  source_event_seqs ANY,
+  surface_op        TEXT,
+  ignorable         INTEGER CHECK (ignorable IS NULL OR ignorable IN (0, 1)),
+  PRIMARY KEY (session_id, seq)
+) STRICT;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-application-id.sql

@@ -0,0 +1 @@
+PRAGMA application_id;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-events-from.sql

@@ -0,0 +1,4 @@
+SELECT seq, type, time, data, source_event_seqs, surface_op, ignorable
+FROM events
+WHERE session_id = ? AND seq >= ?
+ORDER BY seq;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-events.sql

@@ -0,0 +1,4 @@
+SELECT seq, type, time, data, source_event_seqs, surface_op, ignorable
+FROM events
+WHERE session_id = ?
+ORDER BY seq;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-mmap-size.sql

@@ -0,0 +1 @@
+PRAGMA mmap_size;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-packed-predecessors.sql

@@ -0,0 +1,6 @@
+SELECT seq, type, time, data, source_event_seqs, surface_op, ignorable
+FROM events
+WHERE session_id = ? AND seq >= ? AND seq < ?
+  AND type IN ('text-chunks', 'reasoning-chunks', 'tool-call-chunks')
+  AND ignorable = 0
+ORDER BY seq;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-schema-objects.sql

@@ -0,0 +1,4 @@
+SELECT type, name, tbl_name, sql
+FROM sqlite_schema
+WHERE name NOT GLOB 'sqlite_*'
+ORDER BY type, name;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-session.sql

@@ -0,0 +1,4 @@
+SELECT id, version, created_at, cwd, parent_session, seed_length, origin,
+       delegation_depth, agent_preset, incarnation, revision
+FROM sessions
+WHERE id = ?;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-sessions.sql

@@ -0,0 +1,3 @@
+SELECT id, version, created_at, cwd, parent_session, seed_length, origin,
+       delegation_depth, agent_preset, incarnation, revision
+FROM sessions;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-store-id.sql

@@ -0,0 +1,3 @@
+SELECT store_id
+FROM persistence_state
+WHERE singleton = 1;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-synchronous.sql

@@ -0,0 +1 @@
+PRAGMA synchronous;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-tail-events.sql

@@ -0,0 +1,5 @@
+SELECT seq, type, time, data, source_event_seqs, surface_op, ignorable
+FROM events
+WHERE session_id = ?
+ORDER BY seq DESC
+LIMIT ?;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-trusted-schema.sql

@@ -0,0 +1 @@
+PRAGMA trusted_schema;

package/dist/kernel/session-persistence-sqlite/resources/sql/select-user-object-count.sql

@@ -0,0 +1,3 @@
+SELECT COUNT(*) AS count
+FROM sqlite_schema
+WHERE name NOT GLOB 'sqlite_*';

package/dist/kernel/session-persistence-sqlite/resources/sql/select-user-version.sql

@@ -0,0 +1 @@
+PRAGMA user_version;

package/dist/kernel/session-persistence-sqlite/resources/sql/set-application-id.sql

@@ -0,0 +1 @@
+PRAGMA application_id = 1146308688;

package/dist/kernel/session-persistence-sqlite/resources/sql/set-user-version-17.sql

@@ -0,0 +1 @@
+PRAGMA user_version = 17;

package/dist/kernel/session-persistence-sqlite/resources/sql/synchronous-full.sql

@@ -0,0 +1 @@
+PRAGMA synchronous = FULL;

package/dist/kernel/session-persistence-sqlite/resources/sql/trusted-schema-off.sql

@@ -0,0 +1 @@
+PRAGMA trusted_schema = OFF;

package/dist/kernel/session-persistence-sqlite/resources/sql/update-session-revision.sql

@@ -0,0 +1,3 @@
+UPDATE sessions
+SET revision = revision + 1
+WHERE id = ?;

package/dist/kernel/session-persistence-sqlite/resources/sql/upsert-session.sql

@@ -0,0 +1,13 @@
+INSERT INTO sessions
+  (id, version, created_at, cwd, parent_session, seed_length, origin,
+   delegation_depth, agent_preset, incarnation, revision)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+ON CONFLICT(id) DO UPDATE SET
+  version = excluded.version,
+  created_at = excluded.created_at,
+  cwd = excluded.cwd,
+  parent_session = excluded.parent_session,
+  seed_length = excluded.seed_length,
+  origin = excluded.origin,
+  delegation_depth = excluded.delegation_depth,
+  agent_preset = excluded.agent_preset;