zidane 7.2.5 → 8.0.4

package/dist/sqlite-DV1DQzN2.js

@@ -0,0 +1,698 @@
+import { u as errorMessage } from "./errors-DKiMrOKq.js";
+import { c as mergeArtifact, u as selectArtifactEvictions } from "./artifacts-CV2hUKnL.js";
+import { i as planWorktreeProjectRootRemaps } from "./project-root-B8zADr4o.js";
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { Database } from "bun:sqlite";
+//#region src/session/sqlite-rows.ts
+const ARTIFACT_COLUMNS = "id, session_id, run_id, turn_id, kind, uri, label, project_root, meta, created_at, updated_at";
+function rowToArtifact(r) {
+	let meta;
+	if (r.meta) try {
+		meta = JSON.parse(r.meta);
+	} catch {
+		meta = void 0;
+	}
+	return {
+		id: r.id,
+		sessionId: r.session_id,
+		...r.run_id ? { runId: r.run_id } : {},
+		...r.turn_id ? { turnId: r.turn_id } : {},
+		kind: r.kind,
+		uri: r.uri,
+		label: r.label,
+		...r.project_root ? { projectRoot: r.project_root } : {},
+		...meta !== void 0 ? { meta } : {},
+		createdAt: r.created_at,
+		updatedAt: r.updated_at
+	};
+}
+/**
+* Compose the WHERE / LIMIT fragments shared by `list` and `listMeta`.
+*
+* `projectRoot: string`    → `WHERE project_root = ?` (excludes untagged).
+* `projectRoot: null`      → `WHERE project_root IS NULL` (untagged only).
+* `projectRoot: undefined` → axis omitted (untagged + tagged).
+*
+* The `null` case lets a future "show legacy" debug toggle query pre-v3
+* sessions explicitly without leaking them into normal per-project lists.
+*/
+function buildListFilter(filter) {
+	const conditions = [];
+	const params = [];
+	if (filter?.agentId) {
+		conditions.push("agent_id = ?");
+		params.push(filter.agentId);
+	}
+	if ("projectRoot" in (filter ?? {})) {
+		const v = filter.projectRoot;
+		if (v === null) conditions.push("project_root IS NULL");
+		else if (typeof v === "string") {
+			conditions.push("project_root = ?");
+			params.push(v);
+		}
+	}
+	return {
+		where: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+		limit: typeof filter?.limit === "number" && filter.limit > 0 ? `LIMIT ${filter.limit}` : "",
+		params
+	};
+}
+/**
+* WHERE / LIMIT fragments for `listArtifacts`. `projectRoot` follows the
+* same tri-state contract as {@link buildListFilter}.
+*/
+function buildArtifactFilter(filter) {
+	const conditions = [];
+	const params = [];
+	if (filter?.sessionId !== void 0) {
+		conditions.push("session_id = ?");
+		params.push(filter.sessionId);
+	}
+	if (filter?.kind !== void 0) {
+		conditions.push("kind = ?");
+		params.push(filter.kind);
+	}
+	if (filter?.uri !== void 0) {
+		conditions.push("uri = ?");
+		params.push(filter.uri);
+	}
+	if (filter && "projectRoot" in filter) {
+		if (filter.projectRoot === null) conditions.push("project_root IS NULL");
+		else if (typeof filter.projectRoot === "string") {
+			conditions.push("project_root = ?");
+			params.push(filter.projectRoot);
+		}
+	}
+	if (typeof filter?.since === "number") {
+		conditions.push("updated_at >= ?");
+		params.push(filter.since);
+	}
+	return {
+		where: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+		limit: typeof filter?.limit === "number" && filter.limit > 0 ? `LIMIT ${filter.limit}` : "",
+		params
+	};
+}
+/**
+* Guarded per-row parse for `turns.data` / `runs.data`. One corrupt row
+* (truncated write, hand-edited DB, disk bitflip) must not make the whole
+* session unloadable — log + skip it instead, mirroring the migration's
+* per-row backfill policy. The structural check matches the minimal shape
+* both `SessionTurn` and `SessionRun` share (an object with a string `id`).
+*/
+function safeParseRow(text, sessionId, kind) {
+	try {
+		const parsed = JSON.parse(text);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.id !== "string") {
+			console.error(`[zidane/sqlite] session "${sessionId}": skipping malformed ${kind} row (not a ${kind}-shaped object)`);
+			return null;
+		}
+		return parsed;
+	} catch (err) {
+		console.error(`[zidane/sqlite] session "${sessionId}": skipping corrupt ${kind} row: ${errorMessage(err)}`);
+		return null;
+	}
+}
+/**
+* `JSON.parse` with a fallback to `{}` for the metadata column. v3→v4
+* migration writes well-formed JSON, fresh v4 writes go through
+* `JSON.stringify(metadata ?? {})` — but a hand-edited DB or a botched
+* external migration could leave a row with malformed JSON, and we'd
+* rather surface an empty metadata object than crash the entire load
+* path. Logged under `ZIDANE_DEBUG` so the corruption isn't fully
+* silent.
+*/
+function safeParseRecord(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/sqlite] metadata JSON parse failed, defaulting to {}: ${errorMessage(err)}\n`);
+		return {};
+	}
+}
+//#endregion
+//#region src/session/sqlite-schema.ts
+const SCHEMA_VERSION = 4;
+/**
+* Connection pragmas, table/index DDL, migrations, and the worktree
+* project-root fix-up — everything `openSqliteStore` runs on a fresh
+* connection before preparing statements.
+*/
+function initSqliteSchema(db, dbPath) {
+	db.run("PRAGMA busy_timeout = 5000");
+	db.run("PRAGMA journal_mode = WAL");
+	db.run("PRAGMA foreign_keys = ON");
+	db.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT,
+      project_root TEXT,
+      status TEXT NOT NULL DEFAULT 'idle',
+      metadata TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      rev INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+	db.run(`CREATE INDEX IF NOT EXISTS idx_sessions_agent_id ON sessions(agent_id)`);
+	db.run(`CREATE INDEX IF NOT EXISTS idx_sessions_project_root ON sessions(project_root)`);
+	db.run(`
+    CREATE TABLE IF NOT EXISTS turns (
+      session_id TEXT NOT NULL,
+      seq INTEGER NOT NULL,
+      role TEXT,
+      data TEXT NOT NULL,
+      PRIMARY KEY (session_id, seq),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    )
+  `);
+	db.run(`
+    CREATE TABLE IF NOT EXISTS runs (
+      session_id TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      data TEXT NOT NULL,
+      PRIMARY KEY (session_id, run_id),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    )
+  `);
+	migrate(db, dbPath);
+	db.run(`
+    CREATE TABLE IF NOT EXISTS artifacts (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      run_id TEXT,
+      turn_id TEXT,
+      kind TEXT NOT NULL,
+      uri TEXT NOT NULL,
+      label TEXT NOT NULL,
+      project_root TEXT,
+      meta TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      UNIQUE (session_id, kind, uri),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    )
+  `);
+	db.run(`CREATE INDEX IF NOT EXISTS idx_artifacts_session ON artifacts(session_id, updated_at)`);
+	db.run(`CREATE INDEX IF NOT EXISTS idx_artifacts_project_kind ON artifacts(project_root, kind, updated_at)`);
+	db.run(`CREATE INDEX IF NOT EXISTS idx_artifacts_kind_uri ON artifacts(kind, uri)`);
+	remapWorktreeProjectRoots(db);
+}
+/**
+* Data fix-up, not a schema step (no `user_version` bump): rows tagged with a
+* linked worktree's checkout root — how sessions started inside a worktree
+* were stamped before `projectRoot` meant the main checkout — move to that
+* main checkout, so they list and group with the rest of the project.
+* Artifacts carry the same column and move with them.
+*
+* Idempotent and cheap (distinct roots are few; each probe is a couple of
+* small file reads), so it runs on every open: a row a live session's stale
+* full-document save wrote back under the old root converges next time.
+* Best-effort — a failure here must never block opening the store.
+*/
+function remapWorktreeProjectRoots(db) {
+	try {
+		const rows = db.query(`
+      SELECT project_root AS root FROM sessions WHERE project_root IS NOT NULL
+      UNION
+      SELECT project_root AS root FROM artifacts WHERE project_root IS NOT NULL
+    `).all();
+		const remaps = planWorktreeProjectRootRemaps(rows.map((row) => row.root));
+		if (remaps.length === 0) return;
+		const sessions = db.prepare("UPDATE sessions SET project_root = ? WHERE project_root = ?");
+		const artifacts = db.prepare("UPDATE artifacts SET project_root = ? WHERE project_root = ?");
+		db.transaction(() => {
+			for (const { from, to } of remaps) {
+				sessions.run(to, from);
+				artifacts.run(to, from);
+			}
+		})();
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/sqlite] worktree project-root remap skipped: ${errorMessage(err)}\n`);
+	}
+}
+/**
+* Forward-only schema migration runner. Idempotent — every step
+* feature-detects rather than relying on the `PRAGMA user_version`
+* number alone, so a partially-migrated DB (e.g. interrupted v3→v4
+* backfill) is brought to a consistent v4 state on the next open.
+*
+* The legacy `data` column is the v3 sentinel: when present we treat
+* the DB as v3-or-older and run the backfill. Before any destructive
+* change we copy the entire DB file to `<path>.zidane-pre-v4.bak` (see
+* {@link backupBeforeV3Migration}) so the user has a guaranteed
+* recovery path if anything goes sideways.
+*
+* After backfill we attempt to drop the column (SQLite 3.35+; Bun
+* ships ≥ 3.43 so this always succeeds in practice). If it does fail,
+* we throw rather than limp along — leaving the column with `NOT NULL`
+* while the new write paths omit it would silently break every future
+* `INSERT`. The `.bak` file lets the user roll back and report the bug.
+*/
+function migrate(db, dbPath) {
+	const onDiskVersion = db.query("PRAGMA user_version").get()?.user_version ?? 0;
+	if (onDiskVersion > SCHEMA_VERSION && onDiskVersion !== 5) throw new Error(`[zidane/sqlite] "${dbPath}" has schema version ${onDiskVersion}, but this zidane build only supports up to ${SCHEMA_VERSION}. A newer zidane wrote it. Upgrade zidane, or point this build at another sessions DB.`);
+	const sessionCols = db.query("PRAGMA table_info(sessions)").all();
+	const hasCol = (n) => sessionCols.some((c) => c.name === n);
+	if (!hasCol("project_root")) db.run("ALTER TABLE sessions ADD COLUMN project_root TEXT");
+	if (!hasCol("status")) db.run(`ALTER TABLE sessions ADD COLUMN status TEXT NOT NULL DEFAULT 'idle'`);
+	if (!hasCol("metadata")) db.run(`ALTER TABLE sessions ADD COLUMN metadata TEXT NOT NULL DEFAULT '{}'`);
+	if (hasCol("data")) {
+		backupBeforeV3Migration(db, dbPath);
+		backfillV3Blobs(db);
+		try {
+			db.run("ALTER TABLE sessions DROP COLUMN data");
+		} catch (err) {
+			throw new Error(`[zidane/sqlite] v3→v4 migration could not drop legacy "data" column: ${errorMessage(err)}. Restore from "${dbPath}.zidane-pre-v4.bak" with an older zidane build and report this. your sessions are intact in the backup file.`);
+		}
+	}
+	if (!db.query("PRAGMA table_info(turns)").all().some((c) => c.name === "role")) db.run("ALTER TABLE turns ADD COLUMN role TEXT");
+	db.run("CREATE INDEX IF NOT EXISTS idx_turns_role_null ON turns(session_id) WHERE role IS NULL");
+	if (db.query(`SELECT 1 FROM turns WHERE role IS NULL AND json_valid(data) LIMIT 1`).get()) db.run(`UPDATE turns SET role = json_extract(data, '$.role') WHERE role IS NULL AND json_valid(data)`);
+	db.run("CREATE INDEX IF NOT EXISTS idx_turns_session_role ON turns(session_id, role, seq)");
+	if (!hasCol("rev")) db.run("ALTER TABLE sessions ADD COLUMN rev INTEGER NOT NULL DEFAULT 0");
+	if ((db.query("PRAGMA user_version").get()?.user_version ?? 0) !== SCHEMA_VERSION) db.run(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+}
+/**
+* Pre-migration safety net for v3 → v4: copy the source DB file to
+* `<path>.zidane-pre-v4.bak` so the user can recover by restoring the
+* snapshot if anything in the migration goes sideways.
+*
+*  - Skipped for non-filesystem paths (`:memory:`, empty string) — no
+*    file to copy.
+*  - Skipped when the file is missing (fresh install, never reached
+*    migration territory).
+*  - Skipped when the backup already exists — re-runs of the migration
+*    (idempotent path) reuse the same snapshot rather than overwrite a
+*    potentially-earlier good copy with a later partial state.
+*  - WAL is checkpointed first so the .db file contains everything that
+*    was committed up to this point (otherwise pending WAL frames would
+*    be missing from the snapshot).
+*  - On copy failure the whole migration is aborted with a thrown error
+*    — we refuse to modify the DB without a recovery path. The user
+*    sees a clear diagnostic; their sessions stay intact.
+*
+* Surfaces a one-line stderr message on success so the user knows where
+* the snapshot landed. They can delete it once they've confirmed the
+* post-migration TUI behaves correctly.
+*/
+function backupBeforeV3Migration(db, dbPath) {
+	if (dbPath === "" || dbPath === ":memory:" || dbPath.startsWith("file::memory:")) return;
+	if (!existsSync(dbPath)) return;
+	const backupPath = `${dbPath}.zidane-pre-v4.bak`;
+	if (existsSync(backupPath)) return;
+	let checkpointed = true;
+	try {
+		db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+	} catch {
+		checkpointed = false;
+	}
+	try {
+		copyFileSync(dbPath, backupPath);
+		if (!checkpointed) for (const ext of ["-wal", "-shm"]) {
+			const sidecar = `${dbPath}${ext}`;
+			if (existsSync(sidecar)) copyFileSync(sidecar, `${backupPath}${ext}`);
+		}
+		process.stderr.write(`[zidane/sqlite] v3→v4 migration: backed up your sessions DB to "${backupPath}".\n  To roll back if anything looks wrong:\n    1. quit zidane\n    2. cp "${backupPath}" "${dbPath}" && rm -f "${dbPath}-wal" "${dbPath}-shm"\n    3. pin an older zidane that knows the v3 schema, or upgrade to a fix\n  Delete the .bak once every session loads correctly.\n`);
+	} catch (err) {
+		throw new Error(`[zidane/sqlite] failed to back up "${dbPath}" before v3→v4 migration: ${errorMessage(err)}. Refusing to modify the DB without a recovery path. Move the file aside or fix the permissions and retry.`);
+	}
+}
+/**
+* Parse each session's legacy `data` blob and fan its `turns` + `runs`
+* arrays out into the dedicated tables, then overwrite the synthetic
+* `status`/`metadata` defaults with the values from the blob.
+*
+* Skips rows that already have at least one entry in `turns` for them —
+* a previous run of this migration already landed those bytes, and
+* re-inserting them would either duplicate (if seq numbering shifted)
+* or crash on the PK. The "header already exists, turns table populated"
+* combination is the idempotency signal.
+*
+* Per-row failures (corrupt JSON, …) log + skip rather than abort the
+* whole migration: one bad row shouldn't prevent the rest of the DB
+* from coming forward to v4.
+*/
+function backfillV3Blobs(db) {
+	const rows = db.query("SELECT id, data FROM sessions").all();
+	if (rows.length === 0) return;
+	const insertTurn = db.prepare("INSERT INTO turns (session_id, seq, data) VALUES (?, ?, ?)");
+	const upsertRun = db.prepare(`
+    INSERT INTO runs (session_id, run_id, started_at, data) VALUES (?, ?, ?, ?)
+    ON CONFLICT(session_id, run_id) DO UPDATE SET
+      data = excluded.data,
+      started_at = excluded.started_at
+  `);
+	const updateHeader = db.prepare("UPDATE sessions SET status = ?, metadata = ? WHERE id = ?");
+	const countTurns = db.prepare("SELECT COUNT(*) as c FROM turns WHERE session_id = ?");
+	for (const row of rows) {
+		if (!row.data) continue;
+		try {
+			const data = JSON.parse(row.data);
+			if (countTurns.get(row.id).c > 0) continue;
+			const turns = Array.isArray(data.turns) ? data.turns : [];
+			const runs = Array.isArray(data.runs) ? data.runs : [];
+			db.transaction(() => {
+				turns.forEach((t, i) => insertTurn.run(row.id, i, JSON.stringify(t)));
+				for (const run of runs) {
+					if (!run || typeof run.id !== "string") continue;
+					upsertRun.run(row.id, run.id, run.startedAt ?? 0, JSON.stringify(run));
+				}
+				updateHeader.run(data.status ?? "idle", JSON.stringify(data.metadata ?? {}), row.id);
+			}).immediate();
+		} catch (err) {
+			process.stderr.write(`[zidane/sqlite] v3→v4 migrate: session "${row.id}" skipped: ${errorMessage(err)}\n`);
+		}
+	}
+}
+//#endregion
+//#region src/session/sqlite-transactions.ts
+function prepareSqliteStatements(db) {
+	return {
+		stmtLoadHeader: db.prepare(`
+    SELECT id, agent_id, project_root, status, metadata, created_at, updated_at
+    FROM sessions WHERE id = ?
+  `),
+		stmtLoadTurns: db.prepare("SELECT data FROM turns WHERE session_id = ? ORDER BY seq"),
+		stmtLoadTurnsRange: db.prepare("SELECT data FROM turns WHERE session_id = ? ORDER BY seq LIMIT ? OFFSET ?"),
+		stmtLoadRuns: db.prepare("SELECT data FROM runs WHERE session_id = ? ORDER BY started_at, run_id"),
+		stmtUpsertHeader: db.prepare(`
+    INSERT INTO sessions (id, agent_id, project_root, status, metadata, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      agent_id = excluded.agent_id,
+      project_root = excluded.project_root,
+      status = excluded.status,
+      metadata = excluded.metadata,
+      updated_at = excluded.updated_at,
+      rev = sessions.rev + 1
+  `),
+		stmtDelete: db.prepare("DELETE FROM sessions WHERE id = ?"),
+		stmtDeleteTurnsForSession: db.prepare("DELETE FROM turns WHERE session_id = ?"),
+		stmtDeleteRunsForSession: db.prepare("DELETE FROM runs WHERE session_id = ?"),
+		stmtInsertTurn: db.prepare("INSERT INTO turns (session_id, seq, role, data) VALUES (?, ?, ?, ?)"),
+		stmtUpsertRun: db.prepare(`
+    INSERT INTO runs (session_id, run_id, started_at, data) VALUES (?, ?, ?, ?)
+    ON CONFLICT(session_id, run_id) DO UPDATE SET
+      data = excluded.data,
+      started_at = excluded.started_at
+  `),
+		stmtMaxSeq: db.prepare("SELECT MAX(seq) as m FROM turns WHERE session_id = ?"),
+		stmtTouch: db.prepare("UPDATE sessions SET updated_at = ?, rev = rev + 1 WHERE id = ?"),
+		stmtUpdateStatus: db.prepare("UPDATE sessions SET status = ?, updated_at = ?, rev = rev + 1 WHERE id = ?"),
+		stmtUpdateStatusOnly: db.prepare("UPDATE sessions SET status = ?, rev = rev + 1 WHERE id = ?"),
+		stmtFindArtifact: db.prepare(`SELECT ${ARTIFACT_COLUMNS} FROM artifacts WHERE session_id = ? AND kind = ? AND uri = ?`),
+		stmtSessionArtifacts: db.prepare(`SELECT ${ARTIFACT_COLUMNS} FROM artifacts WHERE session_id = ? ORDER BY created_at, rowid`),
+		stmtInsertArtifact: db.prepare(`
+    INSERT INTO artifacts (${ARTIFACT_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `),
+		stmtRefreshArtifact: db.prepare(`
+    UPDATE artifacts SET label = ?, project_root = ?, meta = ?, updated_at = ? WHERE id = ?
+  `),
+		stmtDeleteArtifact: db.prepare("DELETE FROM artifacts WHERE session_id = ? AND id = ?")
+	};
+}
+function createSqliteTransactions(db, stmts) {
+	const { stmtLoadHeader, stmtLoadTurns, stmtLoadRuns, stmtUpsertHeader, stmtDeleteTurnsForSession, stmtDeleteRunsForSession, stmtInsertTurn, stmtUpsertRun, stmtMaxSeq, stmtTouch, stmtUpdateStatus, stmtUpdateStatusOnly, stmtFindArtifact, stmtSessionArtifacts, stmtInsertArtifact, stmtRefreshArtifact, stmtDeleteArtifact } = stmts;
+	const loadSync = (sessionId) => {
+		const header = stmtLoadHeader.get(sessionId);
+		if (!header) return null;
+		const turnRows = stmtLoadTurns.all(sessionId);
+		const runRows = stmtLoadRuns.all(sessionId);
+		return {
+			id: header.id,
+			...header.agent_id ? { agentId: header.agent_id } : {},
+			...header.project_root ? { projectRoot: header.project_root } : {},
+			turns: turnRows.map((r) => safeParseRow(r.data, header.id, "turn")).filter((t) => t !== null),
+			runs: runRows.map((r) => safeParseRow(r.data, header.id, "run")).filter((r) => r !== null),
+			status: header.status,
+			metadata: safeParseRecord(header.metadata),
+			createdAt: header.created_at,
+			updatedAt: header.updated_at
+		};
+	};
+	const txnSave = db.transaction((session) => {
+		stmtUpsertHeader.run(session.id, session.agentId ?? null, session.projectRoot ?? null, session.status, JSON.stringify(session.metadata ?? {}), session.createdAt, session.updatedAt);
+		stmtDeleteTurnsForSession.run(session.id);
+		stmtDeleteRunsForSession.run(session.id);
+		session.turns.forEach((t, i) => stmtInsertTurn.run(session.id, i, t.role ?? null, JSON.stringify(t)));
+		for (const run of session.runs) stmtUpsertRun.run(session.id, run.id, run.startedAt, JSON.stringify(run));
+	});
+	const txnSaveMeta = db.transaction((session) => {
+		stmtUpsertHeader.run(session.id, session.agentId ?? null, session.projectRoot ?? null, session.status, JSON.stringify(session.metadata ?? {}), session.createdAt, session.updatedAt);
+		for (const run of session.runs) stmtUpsertRun.run(session.id, run.id, run.startedAt, JSON.stringify(run));
+	});
+	const txnMutateTurns = db.transaction((sessionId, mutate) => {
+		if (!stmtLoadHeader.get(sessionId)) return "no-session";
+		const next = mutate(stmtLoadTurns.all(sessionId).map((r) => safeParseRow(r.data, sessionId, "turn")).filter((t) => t !== null));
+		if (next === null) return "unchanged";
+		stmtDeleteTurnsForSession.run(sessionId);
+		next.forEach((t, i) => stmtInsertTurn.run(sessionId, i, t.role ?? null, JSON.stringify(t)));
+		stmtTouch.run(Date.now(), sessionId);
+		return "ok";
+	});
+	const ensureHeaderSync = (sessionId) => {
+		if (stmtLoadHeader.get(sessionId)) return;
+		const now = Date.now();
+		stmtUpsertHeader.run(sessionId, null, null, "idle", "{}", now, now);
+	};
+	return {
+		loadSync,
+		txnSave,
+		txnSaveMeta,
+		txnMutateTurns,
+		txnAppendTurns: db.transaction((sessionId, turns) => {
+			ensureHeaderSync(sessionId);
+			let nextSeq = (stmtMaxSeq.get(sessionId).m ?? -1) + 1;
+			for (const turn of turns) {
+				stmtInsertTurn.run(sessionId, nextSeq, turn.role ?? null, JSON.stringify(turn));
+				nextSeq += 1;
+			}
+			stmtTouch.run(Date.now(), sessionId);
+		}),
+		txnUpdateRun: db.transaction((sessionId, run) => {
+			if (!stmtLoadHeader.get(sessionId)) return;
+			stmtUpsertRun.run(sessionId, run.id, run.startedAt, JSON.stringify(run));
+			stmtTouch.run(Date.now(), sessionId);
+		}),
+		txnUpdateStatus: db.transaction((sessionId, status, preserveUpdatedAt) => {
+			if (preserveUpdatedAt) stmtUpdateStatusOnly.run(status, sessionId);
+			else stmtUpdateStatus.run(status, Date.now(), sessionId);
+		}),
+		txnUpsertArtifact: db.transaction((artifact) => {
+			if (!stmtLoadHeader.get(artifact.sessionId)) return null;
+			const existingRow = stmtFindArtifact.get(artifact.sessionId, artifact.kind, artifact.uri);
+			if (existingRow) {
+				const merged = mergeArtifact(rowToArtifact(existingRow), artifact);
+				stmtRefreshArtifact.run(merged.label, merged.projectRoot ?? null, merged.meta !== void 0 ? JSON.stringify(merged.meta) : null, merged.updatedAt, merged.id);
+				return merged;
+			}
+			const current = stmtSessionArtifacts.all(artifact.sessionId).map(rowToArtifact);
+			for (const id of selectArtifactEvictions(current)) stmtDeleteArtifact.run(artifact.sessionId, id);
+			stmtInsertArtifact.run(artifact.id, artifact.sessionId, artifact.runId ?? null, artifact.turnId ?? null, artifact.kind, artifact.uri, artifact.label, artifact.projectRoot ?? null, artifact.meta !== void 0 ? JSON.stringify(artifact.meta) : null, artifact.createdAt, artifact.updatedAt);
+			return artifact;
+		})
+	};
+}
+//#endregion
+//#region src/session/sqlite.ts
+/**
+* True when `err` is SQLite reporting a damaged file (`SQLITE_CORRUPT`,
+* `SQLITE_NOTADB`). Matched on the message because bun:sqlite's error
+* class exposes the code inconsistently across versions.
+*/
+function isCorruptDbError(err) {
+	const msg = errorMessage(err);
+	return /database disk image is malformed|SQLITE_CORRUPT|SQLITE_NOTADB|file is not a database/i.test(msg);
+}
+/**
+* Re-wrap a corruption error with the file path and a recovery recipe.
+* The bare SQLite string ("database disk image is malformed") tells the
+* user nothing about WHICH file or what to do; every host (TUI, daemon,
+* headless) surfaces this message instead. Non-corruption errors pass
+* through untouched.
+*
+* Deliberately no auto-repair / quarantine: the file is the only copy of
+* the user's history and `.recover` salvages most of it. Never touch it.
+*/
+function describeCorruptDb(err, dbPath) {
+	if (!isCorruptDbError(err)) return err;
+	return new Error(`[zidane/sqlite] sessions database at "${dbPath}" is corrupt (${errorMessage(err)}).\n  Your sessions are still on disk; zidane will not modify the file. To recover:\n    1. quit zidane (and any running daemon)\n    2. sqlite3 "${dbPath}" ".recover" | sqlite3 "${dbPath}.recovered"\n    3. mv "${dbPath}" "${dbPath}.corrupt" && rm -f "${dbPath}-wal" "${dbPath}-shm" && mv "${dbPath}.recovered" "${dbPath}"\n  Common causes: git checkout/stash swapping a project .zidane/sessions.db under its -wal, a cloud-synced or network folder (iCloud, Dropbox, SMB), or a backup restored without deleting -wal / -shm.`, { cause: err });
+}
+function createSqliteStore(options) {
+	let store;
+	try {
+		store = openSqliteStore(options);
+	} catch (err) {
+		throw describeCorruptDb(err, options.path);
+	}
+	const wrapped = { ...store };
+	for (const key of Object.keys(store)) {
+		const fn = store[key];
+		if (typeof fn !== "function" || key === "close") continue;
+		wrapped[key] = async (...args) => {
+			try {
+				return await fn.apply(store, args);
+			} catch (err) {
+				throw describeCorruptDb(err, options.path);
+			}
+		};
+	}
+	return wrapped;
+}
+function openSqliteStore(options) {
+	const db = new Database(options.path);
+	initSqliteSchema(db, options.path);
+	const stmts = prepareSqliteStatements(db);
+	const { stmtDelete, stmtLoadTurnsRange, stmtDeleteArtifact } = stmts;
+	const { loadSync, txnSave, txnSaveMeta, txnMutateTurns, txnAppendTurns, txnUpdateRun, txnUpdateStatus, txnUpsertArtifact } = createSqliteTransactions(db, stmts);
+	return {
+		async load(sessionId) {
+			return loadSync(sessionId);
+		},
+		async save(session) {
+			txnSave.immediate(session);
+		},
+		async saveMeta(session) {
+			txnSaveMeta.immediate(session);
+		},
+		async delete(sessionId) {
+			stmtDelete.run(sessionId);
+		},
+		async list(filter) {
+			const { where, limit, params } = buildListFilter(filter);
+			const sql = `SELECT id FROM sessions ${where} ORDER BY updated_at DESC ${limit}`.replace(/\s+/g, " ").trim();
+			return db.query(sql).all(...params).map((r) => r.id);
+		},
+		async getMeta(sessionId) {
+			const row = db.query(`
+        SELECT
+          s.id,
+          s.project_root,
+          s.metadata,
+          s.updated_at,
+          s.rev,
+          s.agent_id,
+          s.created_at,
+          s.status,
+          (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id) AS turn_count,
+          (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id AND t.role = 'user') AS user_count,
+          (SELECT COUNT(*) FROM runs r WHERE r.session_id = s.id) AS run_count,
+          (SELECT COUNT(*) FROM artifacts a WHERE a.session_id = s.id) AS artifact_count,
+          NULL AS first_user_turn
+        FROM sessions s WHERE s.id = ?
+      `).get(sessionId);
+			if (!row) return null;
+			return {
+				id: row.id,
+				metadata: safeParseRecord(row.metadata),
+				...row.project_root ? { projectRoot: row.project_root } : {},
+				updatedAt: row.updated_at,
+				rev: row.rev,
+				...row.agent_id ? { agentId: row.agent_id } : {},
+				createdAt: row.created_at,
+				status: row.status,
+				turnCount: row.turn_count,
+				userMessageCount: row.user_count,
+				runCount: row.run_count,
+				artifactCount: row.artifact_count
+			};
+		},
+		async listMeta(filter) {
+			const { where, limit, params } = buildListFilter(filter);
+			const sql = `
+        SELECT
+          s.id,
+          s.project_root,
+          s.metadata,
+          s.updated_at,
+          s.agent_id,
+          s.created_at,
+          s.status,
+          (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id) AS turn_count,
+          (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id AND t.role = 'user') AS user_count,
+          (SELECT COUNT(*) FROM runs r WHERE r.session_id = s.id) AS run_count,
+          (SELECT COUNT(*) FROM artifacts a WHERE a.session_id = s.id) AS artifact_count,
+          CASE WHEN json_valid(s.metadata)
+                 AND TRIM(COALESCE(json_extract(s.metadata, '$.title'), '')) <> '' THEN NULL
+               ELSE (SELECT t.data FROM turns t WHERE t.session_id = s.id AND t.role = 'user'
+                       ORDER BY t.seq LIMIT 1)
+          END AS first_user_turn
+        FROM sessions s ${where} ORDER BY s.updated_at DESC ${limit}
+      `;
+			return db.query(sql).all(...params).map((r) => {
+				const firstUserTurn = r.first_user_turn ? safeParseRow(r.first_user_turn, r.id, "turn") : null;
+				return {
+					id: r.id,
+					metadata: safeParseRecord(r.metadata),
+					...r.project_root ? { projectRoot: r.project_root } : {},
+					updatedAt: r.updated_at,
+					...r.agent_id ? { agentId: r.agent_id } : {},
+					createdAt: r.created_at,
+					status: r.status,
+					turnCount: r.turn_count,
+					userMessageCount: r.user_count,
+					runCount: r.run_count,
+					artifactCount: r.artifact_count,
+					...firstUserTurn ? { firstUserTurn } : {}
+				};
+			});
+		},
+		async appendTurns(sessionId, turns) {
+			txnAppendTurns.immediate(sessionId, turns);
+		},
+		async mutateTurns(sessionId, mutate) {
+			return txnMutateTurns.immediate(sessionId, mutate);
+		},
+		async getTurns(sessionId, from = 0, limit) {
+			const lim = typeof limit === "number" ? limit : -1;
+			return stmtLoadTurnsRange.all(sessionId, lim, from).map((r) => safeParseRow(r.data, sessionId, "turn")).filter((t) => t !== null);
+		},
+		async updateRun(sessionId, run) {
+			txnUpdateRun.immediate(sessionId, run);
+		},
+		async updateStatus(sessionId, status, options) {
+			txnUpdateStatus.immediate(sessionId, status, options?.preserveUpdatedAt === true);
+		},
+		async upsertArtifact(artifact) {
+			return txnUpsertArtifact.immediate(artifact);
+		},
+		async listArtifacts(filter) {
+			const { where, limit, params } = buildArtifactFilter(filter);
+			const sql = `SELECT ${ARTIFACT_COLUMNS} FROM artifacts ${where} ORDER BY updated_at DESC, created_at DESC, id ${limit}`.replace(/\s+/g, " ").trim();
+			return db.query(sql).all(...params).map(rowToArtifact);
+		},
+		async deleteArtifact(sessionId, artifactId) {
+			stmtDeleteArtifact.run(sessionId, artifactId);
+		},
+		close() {
+			db.close(false);
+		}
+	};
+}
+/**
+* Convenience: open a SQLite store at `dbPath`, creating its parent
+* directory if it doesn't yet exist. Used by the TUI launcher to spin up
+* the default session store at `~/.zidane/sessions.db`.
+*
+* Lives here (and not in `chat/store.ts`) so the renderer-agnostic
+* `zidane/chat` entry stays free of `bun:sqlite` — non-Bun consumers
+* (a future GUI, an SDK) can import `zidane/chat` without pulling in the
+* Bun-only binding.
+*/
+function createTuiStore(dbPath) {
+	const dir = dirname(dbPath);
+	if (!existsSync(dir)) try {
+		mkdirSync(dir, { recursive: true });
+	} catch (err) {
+		throw new Error(`Could not create TUI storage directory at "${dir}". Override the location via \`runTui({ storageDir, prefix })\` or the \`ZIDANE_STORAGE_DIR\` env var. Original error: ${errorMessage(err)}`);
+	}
+	return createSqliteStore({ path: dbPath });
+}
+//#endregion
+export { isCorruptDbError as i, createTuiStore as n, describeCorruptDb as r, createSqliteStore as t };
+
+//# sourceMappingURL=sqlite-DV1DQzN2.js.map