@morlay/session-rdb 0.1.10-alpha.0 → 0.1.10-alpha.3

package/dist/sqlite-BNRd1aqR.mjs

@@ -1,1778 +0,0 @@
-import { COUNTED_EVENT_TYPES, addActivityTotals, addTokenTotals, addTotals, emptyTotals, localDayKey } from "./usage.mjs";
-import { _ as sessionConflictRow, b as titleOfEventData, v as sessionInsertRow } from "./log-CcWy46VE.mjs";
-import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
-import { randomUUID } from "node:crypto";
-import { and, desc, eq, gte, inArray, isNotNull, lt, notInArray, sql } from "drizzle-orm";
-import { check, index, integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
-import { bigint, check as check$1, index as index$1, integer as integer$1, pgSchema, pgTable, serial, text as text$1, unique as unique$1 } from "drizzle-orm/pg-core";
-import { mkdir, open, readdir, stat } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { DatabaseSync } from "node:sqlite";
-import { drizzle } from "drizzle-orm/node-sqlite";
-import { migrate } from "drizzle-orm/node-sqlite/migrator";
-// src/write-guard.ts
-var WriteGuard = class {
-	headSeqs = /* @__PURE__ */ new Map();
-	confirmHead(id, head) {
-		this.headSeqs.set(id, head);
-	}
-	has(id) {
-		return this.headSeqs.has(id);
-	}
-	assertNoConcurrentWriter(id, storedHead) {
-		const known = this.headSeqs.get(id);
-		if (known === void 0) {
-			if (storedHead !== -1) throw new Error(`session "${id}" has a persisted log this instance has not read; another writer may own it — load the session first`);
-			return;
-		}
-		if (known !== storedHead) throw new Error(`session "${id}" was modified by another writer (stored head ${storedHead}, this instance last confirmed head ${known}); concurrent writers on one session are not supported`);
-	}
-};
-// src/adapters/types.ts
-function toProperty(name) {
-	return name.replace(/_([a-z])/g, (_match, char) => char.toUpperCase());
-}
-// src/adapters/to-sqlite.ts
-function buildColumn$1(name, c, tables) {
-	let col;
-	switch (c.type) {
-		case "text": {
-			const built = text(name);
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-		case "serial":
-			col = integer(name).primaryKey({ autoIncrement: true });
-			break;
-		case "integer":
-		case "bigint": {
-			const built = integer(name);
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-	}
-	if (c.notNull) col = col.notNull();
-	if (c.default !== void 0) col = col.default(c.default);
-	if (c.unique) col = col.unique();
-	if (c.references) {
-		const { table, column, onDelete } = c.references;
-		col = col.references(() => tables[table][toProperty(column)], { onDelete });
-	}
-	return col;
-}
-function toSqliteSchema(defs) {
-	const tables = {};
-	for (const def of defs) {
-		const columns = {};
-		for (const [name, c] of Object.entries(def.columns)) columns[toProperty(name)] = buildColumn$1(name, c, tables);
-		const extra = (self) => [
-			...Object.entries(def.checks ?? {}).map(([name, c]) => check(name, sql.raw(c.expression))),
-			...Object.entries(def.uniques ?? {}).map(([name, u]) => unique(name).on(...u.columns.map((n) => self[toProperty(n)]))),
-			...Object.entries(def.indexes ?? {}).map(([name, i]) => index(name).on(...i.columns.map((n) => self[toProperty(n)])))
-		];
-		tables[def.name] = sqliteTable(def.name, columns, extra);
-	}
-	return tables;
-}
-// src/adapters/to-postgres.ts
-function buildColumn(name, c, tables) {
-	let col;
-	switch (c.type) {
-		case "text": {
-			const built = text$1(name);
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-		case "serial":
-			col = serial(name).primaryKey();
-			break;
-		case "integer": {
-			const built = integer$1(name);
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-		case "bigint": {
-			const built = bigint(name, { mode: "number" });
-			col = c.primaryKey ? built.primaryKey() : built;
-			break;
-		}
-	}
-	if (c.notNull) col = col.notNull();
-	if (c.default !== void 0) col = col.default(c.default);
-	if (c.unique) col = col.unique();
-	if (c.references) {
-		const { table, column, onDelete } = c.references;
-		col = col.references(() => tables[table][toProperty(column)], { onDelete });
-	}
-	return col;
-}
-function toPostgresSchema(defs, schemaName = "public") {
-	const tables = {};
-	const table = schemaName === "public" ? pgTable : pgSchema(schemaName).table;
-	for (const def of defs) {
-		const columns = {};
-		for (const [name, c] of Object.entries(def.columns)) columns[toProperty(name)] = buildColumn(name, c, tables);
-		const extra = (self) => [
-			...Object.entries(def.checks ?? {}).map(([name, c]) => check$1(name, sql.raw(c.expression))),
-			...Object.entries(def.uniques ?? {}).map(([name, u]) => unique$1(name).on(...u.columns.map((n) => self[toProperty(n)]))),
-			...Object.entries(def.indexes ?? {}).map(([name, i]) => index$1(name).on(...i.columns.map((n) => self[toProperty(n)])))
-		];
-		tables[def.name] = table(def.name, columns, extra);
-	}
-	return tables;
-}
-// src/entities/v3/persistence-state.ts
-const persistenceState = {
-	name: "t_persistence_state",
-	columns: {
-		f_singleton: {
-			type: "integer",
-			primaryKey: true
-		},
-		f_store_id: {
-			type: "text",
-			notNull: true
-		}
-	},
-	checks: { ck_persistence_state_singleton: { expression: "f_singleton = 1" } }
-};
-// src/entities/v3/schema-meta.ts
-const schemaMeta = {
-	name: "t_schema_meta",
-	columns: {
-		f_key: {
-			type: "text",
-			primaryKey: true
-		},
-		f_value: {
-			type: "text",
-			notNull: true
-		}
-	}
-};
-// src/entities/v3/sessions.ts
-const sessions = {
-	name: "t_sessions",
-	columns: {
-		f_id: {
-			type: "serial",
-			primaryKey: true
-		},
-		f_session_id: {
-			type: "text",
-			notNull: true,
-			unique: true
-		},
-		f_head_event_id: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_head_sequence: {
-			type: "integer",
-			notNull: true,
-			default: -1
-		},
-		f_version: {
-			type: "integer",
-			notNull: true
-		},
-		f_created_at: {
-			type: "bigint",
-			notNull: true
-		},
-		f_cwd: { type: "text" },
-		f_parent_session: { type: "text" },
-		f_seed_length: { type: "integer" },
-		f_origin: { type: "text" },
-		f_delegation_depth: { type: "integer" },
-		f_agent_preset: { type: "text" },
-		f_incarnation: {
-			type: "text",
-			notNull: true
-		},
-		f_revision: {
-			type: "integer",
-			notNull: true
-		},
-		f_archived_at: { type: "bigint" },
-		f_pinned_seq: { type: "integer" },
-		f_last_event_at: { type: "bigint" },
-		f_title: { type: "text" },
-		f_title_seq: { type: "integer" }
-	}
-};
-// src/entities/v3/events.ts
-const events = {
-	name: "t_events",
-	columns: {
-		f_id: {
-			type: "serial",
-			primaryKey: true
-		},
-		f_event_id: {
-			type: "text",
-			notNull: true,
-			unique: true
-		},
-		f_parent_id: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_type: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_kind: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_role: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_name: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_action_id: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_encoding: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_data: {
-			type: "text",
-			notNull: true
-		},
-		f_created_at: {
-			type: "bigint",
-			notNull: true,
-			default: 0
-		}
-	},
-	indexes: {
-		idx_events_kind: { columns: ["f_kind"] },
-		idx_events_role: { columns: ["f_role"] },
-		idx_events_name: { columns: ["f_name"] },
-		idx_events_action_id: { columns: ["f_action_id"] }
-	}
-};
-// src/entities/v3/session-events.ts
-const sessionEvents$1 = {
-	name: "t_session_events",
-	columns: {
-		f_id: {
-			type: "serial",
-			primaryKey: true
-		},
-		f_session_id: {
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_sessions",
-				column: "f_session_id",
-				onDelete: "cascade"
-			}
-		},
-		f_event_id: {
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_events",
-				column: "f_event_id",
-				onDelete: "cascade"
-			}
-		},
-		f_sequence: {
-			type: "integer",
-			notNull: true
-		},
-		f_surface_op: { type: "text" }
-	},
-	uniques: { uq_session_events_session_sequence: { columns: ["f_session_id", "f_sequence"] } },
-	indexes: { idx_session_events_event_id: { columns: ["f_event_id"] } }
-};
-// src/entities/v3/storage-units.ts
-const storageUnits = {
-	name: "t_storage_units",
-	columns: {
-		f_name: {
-			type: "text",
-			primaryKey: true
-		},
-		f_version: {
-			type: "integer",
-			notNull: true
-		}
-	}
-};
-// src/entities/v3/workspaces.ts
-const workspaces = {
-	name: "t_workspaces",
-	columns: {
-		f_id: {
-			type: "serial",
-			primaryKey: true
-		},
-		f_workspace_id: {
-			type: "text",
-			notNull: true,
-			unique: true
-		},
-		f_path: {
-			type: "text",
-			notNull: true
-		},
-		f_title: {
-			type: "text",
-			notNull: true
-		},
-		f_created_at: {
-			type: "text",
-			notNull: true
-		},
-		f_updated_at: {
-			type: "text",
-			notNull: true
-		},
-		f_position: {
-			type: "integer",
-			notNull: true,
-			default: -1
-		}
-	}
-};
-// src/entities/v3/workspace-sessions.ts
-const workspaceSessions = {
-	name: "t_workspace_sessions",
-	columns: {
-		f_id: {
-			type: "serial",
-			primaryKey: true
-		},
-		f_workspace_id: {
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_workspaces",
-				column: "f_workspace_id",
-				onDelete: "cascade"
-			}
-		},
-		f_session_id: {
-			type: "text",
-			notNull: true
-		},
-		f_position: {
-			type: "integer",
-			notNull: true
-		}
-	},
-	uniques: { uq_workspace_sessions_workspace_session: { columns: ["f_workspace_id", "f_session_id"] } },
-	indexes: { idx_workspace_sessions_session_id: { columns: ["f_session_id"] } }
-};
-// src/entities/v3/workspace-state.ts
-const workspaceState = {
-	name: "t_workspace_state",
-	columns: {
-		f_singleton: {
-			type: "integer",
-			primaryKey: true
-		},
-		f_initialized: {
-			type: "integer",
-			notNull: true
-		},
-		f_pending_operation: { type: "text" },
-		f_pending_workspace_id: { type: "text" }
-	},
-	checks: { ck_workspace_state_singleton: { expression: "f_singleton = 1" } }
-};
-// src/entities/v3/schedule-tasks.ts
-const scheduleTasks = {
-	name: "t_schedule_tasks",
-	columns: {
-		f_id: {
-			type: "text",
-			primaryKey: true
-		},
-		f_session_id: {
-			type: "text",
-			notNull: true
-		},
-		f_status: {
-			type: "text",
-			notNull: true
-		},
-		f_record: {
-			type: "text",
-			notNull: true
-		},
-		f_last_delivery: { type: "text" },
-		f_delivery_history: { type: "text" }
-	},
-	indexes: { idx_schedule_tasks_session_id: { columns: ["f_session_id"] } }
-};
-// src/entities/v3/session-projcache-rows.ts
-const sessionProjcacheRows = {
-	name: "t_session_projcache_row",
-	columns: {
-		f_id: {
-			type: "serial",
-			primaryKey: true
-		},
-		f_session_id: {
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_sessions",
-				column: "f_session_id",
-				onDelete: "cascade"
-			}
-		},
-		f_key: {
-			type: "text",
-			notNull: true
-		},
-		f_ver: {
-			type: "integer",
-			notNull: true
-		},
-		f_seq: {
-			type: "integer",
-			notNull: true
-		},
-		f_val: {
-			type: "text",
-			notNull: true
-		}
-	},
-	uniques: { uq_session_projcache_row_session_key: { columns: ["f_session_id", "f_key"] } },
-	indexes: { idx_session_projcache_row_key: { columns: ["f_key"] } }
-};
-// src/entities/v3/event-usage.ts
-const eventUsage = {
-	name: "t_event_usage",
-	columns: {
-		f_event_id: {
-			type: "text",
-			primaryKey: true,
-			references: {
-				table: "t_events",
-				column: "f_event_id",
-				onDelete: "cascade"
-			}
-		},
-		f_created_at: {
-			type: "bigint",
-			notNull: true
-		},
-		f_day: {
-			type: "text",
-			notNull: true
-		},
-		f_provider: { type: "text" },
-		f_model: { type: "text" },
-		f_referenced: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_subagent: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_input_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_output_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_cache_read_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_reasoning_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_total_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		}
-	},
-	indexes: { idx_event_usage_created_at: { columns: ["f_created_at"] } }
-};
-// src/entities/v3/session-usage.ts
-const sessionUsage = {
-	name: "t_session_usage",
-	columns: {
-		f_session_id: {
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_sessions",
-				column: "f_session_id",
-				onDelete: "cascade"
-			}
-		},
-		f_day: {
-			type: "text",
-			notNull: true
-		},
-		f_provider: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_model: {
-			type: "text",
-			notNull: true,
-			default: ""
-		},
-		f_input_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_output_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_cache_read_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_reasoning_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_total_tokens: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		}
-	},
-	uniques: { uq_session_usage_key: { columns: [
-		"f_session_id",
-		"f_day",
-		"f_provider",
-		"f_model"
-	] } }
-};
-// src/entities/v3/session-counts.ts
-const sessionCounts = {
-	name: "t_session_counts",
-	columns: {
-		f_session_id: {
-			type: "text",
-			notNull: true,
-			references: {
-				table: "t_sessions",
-				column: "f_session_id",
-				onDelete: "cascade"
-			}
-		},
-		f_day: {
-			type: "text",
-			notNull: true
-		},
-		f_turns: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_steps: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_user_inputs: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		},
-		f_tool_calls: {
-			type: "integer",
-			notNull: true,
-			default: 0
-		}
-	},
-	uniques: { uq_session_counts_key: { columns: ["f_session_id", "f_day"] } }
-};
-// src/entities/v3/index.ts
-const sqliteTableDefs = [
-	persistenceState,
-	schemaMeta,
-	sessions,
-	events,
-	sessionEvents$1,
-	storageUnits,
-	workspaces,
-	workspaceSessions,
-	workspaceState,
-	scheduleTasks,
-	sessionProjcacheRows,
-	eventUsage,
-	sessionUsage,
-	sessionCounts
-];
-const postgresTableDefs = [
-	persistenceState,
-	schemaMeta,
-	sessions,
-	events,
-	sessionEvents$1,
-	storageUnits,
-	workspaces,
-	workspaceSessions,
-	workspaceState,
-	scheduleTasks,
-	sessionProjcacheRows,
-	eventUsage,
-	sessionUsage,
-	sessionCounts
-];
-({ ...sessionEvents$1 }), { ...sessionEvents$1.columns };
-// src/schema.ts
-const SCHEMA_VERSION = 3;
-const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 1146308688;
-const EVENT_ENCODING = "json";
-const sqliteTables = toSqliteSchema(sqliteTableDefs);
-const tPersistenceState = sqliteTables["t_persistence_state"];
-const tSchemaMeta = sqliteTables["t_schema_meta"];
-const tSessions = sqliteTables["t_sessions"];
-const tEvents = sqliteTables["t_events"];
-const tSessionEvents = sqliteTables["t_session_events"];
-const tStorageUnits = sqliteTables["t_storage_units"];
-const tWorkspaces = sqliteTables["t_workspaces"];
-const tWorkspaceSessions = sqliteTables["t_workspace_sessions"];
-const tWorkspaceState = sqliteTables["t_workspace_state"];
-const tScheduleTasks = sqliteTables["t_schedule_tasks"];
-const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"];
-const tEventUsage = sqliteTables["t_event_usage"];
-const tSessionUsage = sqliteTables["t_session_usage"];
-const tSessionCounts = sqliteTables["t_session_counts"];
-const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
-function eventKind(event) {
-	switch (event.type) {
-		case "user/message": return "message";
-		case "assistant/message":
-			if ((event.data.message?.content)?.some((block) => block?.type === "reasoning")) return "thinking";
-			return "message";
-		case "turn/start":
-		case "turn/end":
-		case "step/start":
-		case "step/end":
-		case "session/end-seed": return "turn";
-		case "tool/call":
-		case "tool/result":
-		case "tool/ptc-dispatch-start":
-		case "tool/ptc-dispatch":
-		case "tool/code-dispatch-start":
-		case "tool/code-dispatch": return "tool";
-		case "request/header":
-		case "request/context": return "request";
-		case "model/selection":
-		case "permission/preset":
-		case "approval/policy":
-		case "sandbox/mode":
-		case "plan/mode":
-		case "agent-preset/selected": return "config";
-		case "approval/asked":
-		case "approval/decided":
-		case "command/run":
-		case "command/done":
-		case "hook/invoked":
-		case "hook/result":
-		case "feedback/record": return "audit";
-		case "session/title":
-		case "session/title-llm-request":
-		case "session-log-deepseek/delivery-accepted": return "lifecycle";
-		case "agent/inbox/spliced": return "inbox";
-		case "compaction/start":
-		case "compaction/end":
-		case "compaction/summary":
-		case "compaction/prune": return "compaction";
-		case "llm/retry":
-		case "llm/retry-started": return "llm";
-		case "subagent/descriptor":
-		case "subagent/model-selection-policy": return "subagent";
-		case "team/member":
-		case "team/task":
-		case "team/message/queued":
-		case "team/message/delivered": return "team";
-		case "tool-workflow/run-start":
-		case "tool-workflow/run-end":
-		case "tool-workflow/agent-start":
-		case "tool-workflow/agent-end": return "workflow";
-		case "goal/change": return "goal";
-		case "schedule/change": return "schedule";
-		case "todo/write": return "todo";
-		case "web/deepseek-search-llm-request": return "web";
-		default: return "";
-	}
-}
-function eventDimensions(event) {
-	const kind = eventKind(event);
-	const type = event.type;
-	const data = event.data;
-	switch (type) {
-		case "user/message": return {
-			kind,
-			role: "user",
-			name: "",
-			actionId: ""
-		};
-		case "assistant/message": return {
-			kind,
-			role: "assistant",
-			name: "",
-			actionId: ""
-		};
-		case "tool/result": return {
-			kind,
-			role: "tool",
-			name: "",
-			actionId: data["message"]?.toolCallId ?? ""
-		};
-		case "tool/call": return {
-			kind,
-			role: "",
-			name: typeof data["name"] === "string" ? data["name"] : "",
-			actionId: typeof data["callId"] === "string" ? data["callId"] : ""
-		};
-		case "tool/ptc-dispatch-start":
-		case "tool/ptc-dispatch":
-		case "tool/code-dispatch-start":
-		case "tool/code-dispatch": return {
-			kind,
-			role: "",
-			name: "",
-			actionId: typeof data["subCallId"] === "string" ? data["subCallId"] : ""
-		};
-		case "command/run":
-		case "command/done": return {
-			kind,
-			role: "",
-			name: type === "command/run" && typeof data["name"] === "string" ? data["name"] : "",
-			actionId: typeof data["commandId"] === "string" ? data["commandId"] : ""
-		};
-		case "approval/asked":
-		case "approval/decided": return {
-			kind,
-			role: "",
-			name: "",
-			actionId: typeof data["id"] === "string" ? data["id"] : ""
-		};
-		case "hook/invoked":
-		case "hook/result": return {
-			kind,
-			role: "",
-			name: "",
-			actionId: typeof data["handlerId"] === "string" ? data["handlerId"] : ""
-		};
-		case "llm/retry":
-		case "llm/retry-started": return {
-			kind,
-			role: "",
-			name: "",
-			actionId: typeof data["retryId"] === "string" ? data["retryId"] : ""
-		};
-		case "tool-workflow/run-start":
-		case "tool-workflow/run-end":
-		case "tool-workflow/agent-start":
-		case "tool-workflow/agent-end": return {
-			kind,
-			role: "",
-			name: "",
-			actionId: typeof data["runId"] === "string" ? data["runId"] : ""
-		};
-		case "todo/write": return {
-			kind,
-			role: "",
-			name: "todos",
-			actionId: ""
-		};
-		case "subagent/descriptor": return {
-			kind,
-			role: "",
-			name: typeof data["label"] === "string" ? data["label"] : "",
-			actionId: ""
-		};
-		default: return {
-			kind,
-			role: "",
-			name: "",
-			actionId: ""
-		};
-	}
-}
-// src/storage-takeover/repository.ts
-async function allRows(query) {
-	const q = query;
-	if (typeof q.all === "function") return q.all();
-	return await query;
-}
-async function oneRow(query) {
-	const q = query;
-	if (typeof q.get === "function") return q.get();
-	return (await query)[0];
-}
-async function runQuery(query) {
-	const q = query;
-	if (typeof q.run === "function") {
-		q.run();
-		return;
-	}
-	await query;
-}
-function identityOfSession(row) {
-	return {
-		formatVersion: row.fVersion,
-		createdAt: row.fCreatedAt,
-		...row.fCwd === null ? {} : { cwd: row.fCwd },
-		isSeeded: row.fSeedLength !== null,
-		...row.fSeedLength === null ? {} : { inheritedEventCount: SessionLogOffset(row.fSeedLength) }
-	};
-}
-function seqCursor(seq) {
-	return seq === -1 ? -1 : SessionSeq(seq);
-}
-function pendingMutationOf(row) {
-	const operation = row.fPendingOperation;
-	if (operation !== "create" && operation !== "delete") return void 0;
-	return {
-		operation,
-		workspaceId: row.fPendingWorkspaceId ?? ""
-	};
-}
-function taskFromRow(row) {
-	return {
-		sessionId: row.fSessionId,
-		record: JSON.parse(row.fRecord),
-		status: row.fStatus === "inactive" ? "inactive" : "active",
-		...row.fLastDelivery === null ? {} : { lastDelivery: JSON.parse(row.fLastDelivery) },
-		...row.fDeliveryHistory === null ? {} : { deliveryHistory: JSON.parse(row.fDeliveryHistory) }
-	};
-}
-function rowFromTask(id, task) {
-	return {
-		fId: id,
-		fSessionId: task.sessionId,
-		fStatus: task.status === "inactive" ? "inactive" : "active",
-		fRecord: JSON.stringify(task.record),
-		fLastDelivery: task.lastDelivery === void 0 ? null : JSON.stringify(task.lastDelivery),
-		fDeliveryHistory: task.deliveryHistory === void 0 ? null : JSON.stringify(task.deliveryHistory)
-	};
-}
-function createStorageRepository(host) {
-	const tables = host.tables;
-	const tUnits = tables["t_storage_units"];
-	const tSessions = tables["t_sessions"];
-	const tWorkspaces = tables["t_workspaces"];
-	const tWorkspaceSessions = tables["t_workspace_sessions"];
-	const tWorkspaceState = tables["t_workspace_state"];
-	const tScheduleTasks = tables["t_schedule_tasks"];
-	const tProjcacheRows = tables["t_session_projcache_row"];
-	const sessionIdentity = {
-		fSessionId: tSessions.fSessionId,
-		fVersion: tSessions.fVersion,
-		fCreatedAt: tSessions.fCreatedAt,
-		fCwd: tSessions.fCwd,
-		fSeedLength: tSessions.fSeedLength
-	};
-	const dbx = async () => await host.db();
-	return {
-		async readUnitVersion(name) {
-			return (await oneRow((await dbx()).select().from(tUnits).where(eq(tUnits.fName, name))))?.fVersion;
-		},
-		async insertUnitVersion(name, version) {
-			await runQuery((await dbx()).insert(tUnits).values({
-				fName: name,
-				fVersion: version
-			}).onConflictDoNothing());
-		},
-		async listWorkspaces() {
-			const db = await dbx();
-			const rows = await allRows(db.select().from(tWorkspaces));
-			const links = await allRows(db.select().from(tWorkspaceSessions));
-			const sessions = /* @__PURE__ */ new Map();
-			for (const link of links) {
-				const owned = sessions.get(link.fWorkspaceId) ?? [];
-				owned.push({
-					id: link.fSessionId,
-					position: link.fPosition
-				});
-				sessions.set(link.fWorkspaceId, owned);
-			}
-			return rows.map((row) => ({
-				id: row.fWorkspaceId,
-				record: {
-					path: row.fPath,
-					title: row.fTitle,
-					sessionIds: (sessions.get(row.fWorkspaceId) ?? []).sort((left, right) => left.position - right.position).map((entry) => SessionId(entry.id)),
-					createdAt: row.fCreatedAt,
-					updatedAt: row.fUpdatedAt
-				}
-			}));
-		},
-		async putWorkspace(id, record) {
-			await host.writeAtomically(async () => {
-				const db = await dbx();
-				const values = {
-					fWorkspaceId: id,
-					fPath: record.path,
-					fTitle: record.title,
-					fCreatedAt: record.createdAt,
-					fUpdatedAt: record.updatedAt
-				};
-				await runQuery(db.insert(tWorkspaces).values(values).onConflictDoUpdate({
-					target: tWorkspaces.fWorkspaceId,
-					set: values
-				}));
-				await runQuery(db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fWorkspaceId, id)));
-				const links = record.sessionIds.map((sessionId, position) => ({
-					fWorkspaceId: id,
-					fSessionId: sessionId,
-					fPosition: position
-				}));
-				if (links.length > 0) await runQuery(db.insert(tWorkspaceSessions).values(links));
-			});
-		},
-		async deleteWorkspace(id) {
-			await host.writeAtomically(async () => {
-				const db = await dbx();
-				await runQuery(db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fWorkspaceId, id)));
-				await runQuery(db.delete(tWorkspaces).where(eq(tWorkspaces.fWorkspaceId, id)));
-			});
-		},
-		async deleteWorkspaces(ids) {
-			if (ids.length === 0) return;
-			await host.writeAtomically(async () => {
-				const db = await dbx();
-				await runQuery(db.delete(tWorkspaceSessions).where(inArray(tWorkspaceSessions.fWorkspaceId, [...ids])));
-				await runQuery(db.delete(tWorkspaces).where(inArray(tWorkspaces.fWorkspaceId, [...ids])));
-			});
-		},
-		async readWorkspaceState() {
-			const db = await dbx();
-			const row = await oneRow(db.select().from(tWorkspaceState).where(eq(tWorkspaceState.fSingleton, 1)));
-			if (row === void 0) return null;
-			const ordered = await allRows(db.select().from(tWorkspaces).where(gte(tWorkspaces.fPosition, 0)).orderBy(tWorkspaces.fPosition));
-			const archives = await allRows(db.select({ fSessionId: tSessions.fSessionId }).from(tSessions).where(isNotNull(tSessions.fArchivedAt)).orderBy(tSessions.fArchivedAt));
-			const pinned = await allRows(db.select({
-				fSessionId: tSessions.fSessionId,
-				fPinnedSeq: tSessions.fPinnedSeq
-			}).from(tSessions).where(isNotNull(tSessions.fPinnedSeq)).orderBy(tSessions.fPinnedSeq));
-			const pendingMutation = pendingMutationOf(row);
-			return {
-				initialized: row.fInitialized !== 0,
-				workspaceIds: ordered.map((entry) => entry.fWorkspaceId),
-				archivedSessionIds: archives.map((entry) => entry.fSessionId),
-				pinnedSessionIds: pinned.map((entry) => entry.fSessionId),
-				...pendingMutation === void 0 ? {} : { pendingMutation }
-			};
-		},
-		async writeWorkspaceState(state) {
-			await host.writeAtomically(async () => {
-				const db = await dbx();
-				const pending = state.pendingMutation;
-				const values = {
-					fSingleton: 1,
-					fInitialized: state.initialized ? 1 : 0,
-					fPendingOperation: pending === void 0 || typeof pending.operation !== "string" ? null : pending.operation,
-					fPendingWorkspaceId: pending === void 0 || typeof pending.workspaceId !== "string" ? null : pending.workspaceId
-				};
-				await runQuery(db.insert(tWorkspaceState).values(values).onConflictDoUpdate({
-					target: tWorkspaceState.fSingleton,
-					set: values
-				}));
-				await runQuery(db.update(tWorkspaces).set({ fPosition: -1 }));
-				for (const [position, workspaceId] of state.workspaceIds.entries()) await runQuery(db.update(tWorkspaces).set({ fPosition: position }).where(eq(tWorkspaces.fWorkspaceId, workspaceId)));
-				const pinned = state.pinnedSessionIds ?? [];
-				await runQuery(pinned.length === 0 ? db.update(tSessions).set({ fPinnedSeq: null }).where(isNotNull(tSessions.fPinnedSeq)) : db.update(tSessions).set({ fPinnedSeq: null }).where(and(isNotNull(tSessions.fPinnedSeq), notInArray(tSessions.fSessionId, pinned))));
-				for (const [position, sessionId] of pinned.entries()) await runQuery(db.update(tSessions).set({ fPinnedSeq: position }).where(eq(tSessions.fSessionId, sessionId)));
-				const archived = state.archivedSessionIds;
-				await runQuery(archived.length === 0 ? db.update(tSessions).set({ fArchivedAt: null }).where(isNotNull(tSessions.fArchivedAt)) : db.update(tSessions).set({ fArchivedAt: null }).where(and(isNotNull(tSessions.fArchivedAt), notInArray(tSessions.fSessionId, archived))));
-				const stamp = Date.now();
-				for (const sessionId of archived) await runQuery(db.insert(tSessions).values({
-					fSessionId: sessionId,
-					fHeadEventId: "",
-					fHeadSequence: -1,
-					fVersion: SESSION_FORMAT_VERSION,
-					fCreatedAt: stamp,
-					fCwd: null,
-					fParentSession: null,
-					fSeedLength: null,
-					fOrigin: null,
-					fDelegationDepth: null,
-					fIncarnation: randomUUID(),
-					fRevision: 0,
-					fArchivedAt: stamp
-				}).onConflictDoUpdate({
-					target: tSessions.fSessionId,
-					set: { fArchivedAt: sql`COALESCE(${tSessions.fArchivedAt}, ${stamp})` }
-				}));
-			});
-		},
-		async listScheduleTasks() {
-			return (await allRows((await dbx()).select().from(tScheduleTasks))).map((row) => ({
-				id: row.fId,
-				task: taskFromRow(row)
-			}));
-		},
-		async putScheduleTask(id, task) {
-			await host.writeAtomically(async () => {
-				const db = await dbx();
-				const values = rowFromTask(id, task);
-				await runQuery(db.insert(tScheduleTasks).values(values).onConflictDoUpdate({
-					target: tScheduleTasks.fId,
-					set: values
-				}));
-			});
-		},
-		async deleteScheduleTask(id) {
-			await host.writeAtomically(async () => {
-				await runQuery((await dbx()).delete(tScheduleTasks).where(eq(tScheduleTasks.fId, id)));
-			});
-		},
-		async deleteScheduleTasks(ids) {
-			if (ids.length === 0) return;
-			await host.writeAtomically(async () => {
-				await runQuery((await dbx()).delete(tScheduleTasks).where(inArray(tScheduleTasks.fId, [...ids])));
-			});
-		},
-		async loadProjcache() {
-			const db = await dbx();
-			const rows = await allRows(db.select().from(tProjcacheRows));
-			if (rows.length === 0) return [];
-			const sessions = await allRows(db.select(sessionIdentity).from(tSessions));
-			const entries = /* @__PURE__ */ new Map();
-			for (const session of sessions) entries.set(session.fSessionId, {
-				sessionId: SessionId(session.fSessionId),
-				identity: identityOfSession(session),
-				rows: {}
-			});
-			for (const row of rows) {
-				const entry = entries.get(row.fSessionId);
-				if (entry === void 0) continue;
-				entry.rows[row.fKey] = {
-					ver: row.fVer,
-					seq: seqCursor(row.fSeq),
-					val: JSON.parse(row.fVal)
-				};
-			}
-			return [...entries.values()].filter((entry) => Object.keys(entry.rows).length > 0);
-		},
-		async putProjcache(sessionId, rows) {
-			await host.writeAtomically(async () => {
-				const db = await dbx();
-				await runQuery(db.delete(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)));
-				const values = Object.entries(rows).map(([key, row]) => ({
-					fSessionId: sessionId,
-					fKey: key,
-					fVer: row.ver,
-					fSeq: row.seq,
-					fVal: JSON.stringify(row.val)
-				}));
-				if (values.length > 0) await runQuery(db.insert(tProjcacheRows).values(values));
-			});
-		},
-		async pruneStaleProjcache() {
-			const db = await dbx();
-			const stale = await allRows(db.select({ fSessionId: tProjcacheRows.fSessionId }).from(tProjcacheRows).where(and(lt(tProjcacheRows.fSeq, 0), inArray(tProjcacheRows.fSessionId, db.select({ fSessionId: tSessions.fSessionId }).from(tSessions).where(gte(tSessions.fHeadSequence, 0))))));
-			if (stale.length === 0) return 0;
-			await runQuery(db.delete(tProjcacheRows).where(inArray(tProjcacheRows.fSessionId, stale.map((row) => row.fSessionId))));
-			return stale.length;
-		},
-		...host.dbDirect === void 0 ? {} : {
-			readProjcacheDirect: (sessionId) => {
-				const db = host.dbDirect();
-				const stored = db.select().from(tProjcacheRows).where(eq(tProjcacheRows.fSessionId, sessionId)).all();
-				if (stored.length === 0) return void 0;
-				const session = db.select(sessionIdentity).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
-				if (session === void 0) return void 0;
-				const rows = {};
-				for (const row of stored) rows[row.fKey] = {
-					ver: row.fVer,
-					seq: seqCursor(row.fSeq),
-					val: JSON.parse(row.fVal)
-				};
-				return {
-					sessionId: SessionId(sessionId),
-					identity: identityOfSession(session),
-					rows
-				};
-			},
-			readSessionTitleDirect: (sessionId) => {
-				const row = host.dbDirect().select({
-					fTitle: tSessions.fTitle,
-					fTitleSeq: tSessions.fTitleSeq
-				}).from(tSessions).where(eq(tSessions.fSessionId, sessionId)).get();
-				if (row === void 0 || row.fTitle === null || row.fTitleSeq === null) return void 0;
-				return {
-					title: row.fTitle,
-					seq: row.fTitleSeq
-				};
-			}
-		}
-	};
-}
-// src/sqlite.ts
-const EVENT_REFERENCED_SQL = `EXISTS (SELECT 1 FROM t_session_events rb
-                                       WHERE rb.f_event_id = %EVENT%)`;
-const EVENT_SUBAGENT_SQL = `EXISTS (SELECT 1 FROM t_session_events sb
-                                     JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
-                                    WHERE sb.f_event_id = %EVENT% AND ss.f_origin = 'subagent')`;
-const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
-const REFRESH_FLAG_CHUNK = 400;
-function withEvent(expression, column) {
-	return expression.replace("%EVENT%", column);
-}
-function backfillUsageTables(db) {
-	backfillEventUsage(db);
-	backfillSessionUsage(db);
-	backfillSessionCounts(db);
-}
-function tableIsEmpty(db, table) {
-	return db.prepare(`SELECT count(*) AS n FROM ${table}`).get().n === 0;
-}
-function backfillEventUsage(db) {
-	if (!tableIsEmpty(db, "t_event_usage")) return;
-	db.exec(`INSERT OR IGNORE INTO t_event_usage (
-      f_event_id, f_created_at, f_day, f_provider, f_model, f_referenced, f_subagent,
-      f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-    SELECT e.f_event_id, e.f_created_at,
-           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
-           coalesce(json_extract(e.f_data, '$.data.message.source.provider'),
-                    json_extract(e.f_data, '$.message.source.provider')),
-           coalesce(json_extract(e.f_data, '$.data.message.source.model'),
-                    json_extract(e.f_data, '$.message.source.model')),
-           ${withEvent(EVENT_REFERENCED_SQL, "e.f_event_id")},
-           ${withEvent(EVENT_SUBAGENT_SQL, "e.f_event_id")},
-           coalesce(json_extract(e.f_data, '$.data.usage.inputTokens'),
-                    json_extract(e.f_data, '$.usage.inputTokens'), 0),
-           coalesce(json_extract(e.f_data, '$.data.usage.outputTokens'),
-                    json_extract(e.f_data, '$.usage.outputTokens'), 0),
-           coalesce(json_extract(e.f_data, '$.data.usage.cacheReadTokens'),
-                    json_extract(e.f_data, '$.usage.cacheReadTokens'), 0),
-           coalesce(json_extract(e.f_data, '$.data.usage.reasoningTokens'),
-                    json_extract(e.f_data, '$.usage.reasoningTokens'), 0),
-           coalesce(json_extract(e.f_data, '$.data.usage.totalTokens'),
-                    json_extract(e.f_data, '$.usage.totalTokens'), 0)
-      FROM t_events e
-     WHERE e.f_type = 'assistant/message'
-       AND (json_extract(e.f_data, '$.data.usage') IS NOT NULL
-            OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
-}
-function backfillSessionUsage(db) {
-	if (!tableIsEmpty(db, "t_session_usage")) return;
-	db.exec(`INSERT OR IGNORE INTO t_session_usage (
-      f_session_id, f_day, f_provider, f_model,
-      f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-    SELECT b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, ''),
-           sum(u.f_input_tokens), sum(u.f_output_tokens), sum(u.f_cache_read_tokens),
-           sum(u.f_reasoning_tokens), sum(u.f_total_tokens)
-      FROM t_session_events b
-      JOIN t_event_usage u ON u.f_event_id = b.f_event_id
-     GROUP BY b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, '')`);
-}
-function backfillSessionCounts(db) {
-	if (!tableIsEmpty(db, "t_session_counts")) return;
-	db.exec(`INSERT OR IGNORE INTO t_session_counts (
-      f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
-    SELECT b.f_session_id,
-           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
-           sum(CASE WHEN e.f_type = 'turn/start' THEN 1 ELSE 0 END),
-           sum(CASE WHEN e.f_type = 'step/start' THEN 1 ELSE 0 END),
-           sum(CASE WHEN e.f_type = 'user/message' THEN 1 ELSE 0 END),
-           sum(CASE WHEN e.f_type = 'tool/call' THEN 1 ELSE 0 END)
-      FROM t_session_events b
-      JOIN t_events e ON e.f_event_id = b.f_event_id
-     WHERE e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
-     GROUP BY b.f_session_id, 2`);
-}
-function sessionListRowOf(row) {
-	return {
-		sessionId: typeof row["session_id"] === "string" ? row["session_id"] : String(row["session_id"]),
-		title: typeof row["title"] === "string" ? row["title"] : null,
-		origin: typeof row["origin"] === "string" ? row["origin"] : null,
-		cwd: typeof row["cwd"] === "string" ? row["cwd"] : null,
-		createdAt: Number(row["created_at"]),
-		updatedAt: Number(row["updated_at"]),
-		archived: row["archived"] === 1 || row["archived"] === true,
-		subagent: row["origin"] === "subagent",
-		workspace: typeof row["workspace"] === "string" ? row["workspace"] : null
-	};
-}
-function tokenTotalsOf(row) {
-	return {
-		inputTokens: row.input_tokens ?? 0,
-		outputTokens: row.output_tokens ?? 0,
-		cacheReadTokens: row.cache_read_tokens ?? 0,
-		reasoningTokens: row.reasoning_tokens ?? 0,
-		totalTokens: row.total_tokens ?? 0
-	};
-}
-function activityTotalsOf(row) {
-	return {
-		turns: row.turns ?? 0,
-		steps: row.steps ?? 0,
-		userInputs: row.user_inputs ?? 0,
-		toolCalls: row.tool_calls ?? 0
-	};
-}
-function emptyActivity() {
-	return {
-		turns: 0,
-		steps: 0,
-		userInputs: 0,
-		toolCalls: 0
-	};
-}
-function hasUsageSession(column) {
-	return `EXISTS (SELECT 1 FROM t_session_usage ub WHERE ub.f_session_id = ${column})`;
-}
-const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
-const sqliteTxQueues = /* @__PURE__ */ new Map();
-function enqueueSqliteTx(path, fn) {
-	const run = (sqliteTxQueues.get(path) ?? Promise.resolve()).then(fn);
-	sqliteTxQueues.set(path, run.then(() => void 0, () => void 0));
-	return run;
-}
-async function createDatabaseFile(path) {
-	try {
-		await (await open(path, "wx", 384)).close();
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-	}
-}
-async function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOUT_MS) {
-	const db = new DatabaseSync(path);
-	try {
-		configureDatabase(db, path, journalMode, busyTimeout);
-		const dbx = drizzle({ client: db });
-		const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
-		if (onDisk === 2 && !hasMigrationsTable(db)) await baselineV2(db);
-		migrate(dbx, { migrationsFolder: sqliteMigrationsDir });
-		backfillUsageTables(db);
-		dbx.insert(tPersistenceState).values({
-			fSingleton: 1,
-			fStoreId: randomUUID()
-		}).onConflictDoNothing().run();
-		if (onDisk === 0 || onDisk === 2) db.exec(`PRAGMA user_version = 3`);
-		db.exec(`PRAGMA journal_mode = ${journalMode.toUpperCase()}`);
-		return db;
-	} catch (error) {
-		db.close();
-		throw error;
-	}
-}
-function hasMigrationsTable(db) {
-	return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '__drizzle_migrations'").get() !== void 0;
-}
-async function baselineV2(db) {
-	const dir = (await readdir(sqliteMigrationsDir)).find((name) => name.endsWith("_v2_initial"));
-	if (dir === void 0) throw new Error("missing v2 baseline migration in drizzle/sqlite");
-	db.exec(`
-    CREATE TABLE __drizzle_migrations (
-      id INTEGER PRIMARY KEY,
-      hash text NOT NULL,
-      created_at numeric,
-      name text,
-      applied_at TEXT
-    )
-  `);
-	db.prepare("INSERT INTO __drizzle_migrations (hash, created_at, name, applied_at) VALUES (?, ?, ?, ?)").run("baseline", 0, dir, (/* @__PURE__ */ new Date()).toISOString());
-}
-function configureDatabase(db, path, journalMode, busyTimeout) {
-	db.exec("PRAGMA foreign_keys = ON");
-	db.exec(`PRAGMA busy_timeout = ${busyTimeout}`);
-	db.exec("PRAGMA cache_size = -65536");
-	db.exec("PRAGMA mmap_size = 268435456");
-	drizzle({ client: db }).transaction((tx) => {
-		const { user_version: onDisk } = tx.get(sql`PRAGMA user_version`);
-		const { application_id: applicationId } = tx.get(sql`PRAGMA application_id`);
-		const { count: userObjectCount } = tx.get(sql`SELECT COUNT(*) AS count FROM sqlite_schema WHERE name NOT GLOB 'sqlite_*'`);
-		if (onDisk === 0 && (applicationId !== 0 || userObjectCount > 0)) throw new Error(`session database at "${path}" has an unversioned schema or application identity`);
-		if (onDisk !== 0 && onDisk !== 2 && onDisk !== 3) throw new Error(`session database at "${path}" has schema version ${onDisk}, incompatible with this build (3)`);
-		if (onDisk >= 1 && applicationId !== 1146308688) throw new Error(`session database at "${path}" has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
-		if (onDisk === 0) {
-			tx.run(sql.raw(`PRAGMA application_id = ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`));
-			tx.run(sql.raw(`PRAGMA user_version = 3`));
-		}
-	}, { behavior: "immediate" });
-}
-var SqliteBackend = class SqliteBackend {
-	options;
-	kind = "sqlite";
-	storeIdentity;
-	storage;
-	dbPath = "";
-	db;
-	dbReady;
-	resolveDb;
-	rejectDb;
-	constructor(options) {
-		this.options = options;
-		this.dbReady = new Promise((resolve, reject) => {
-			this.resolveDb = resolve;
-			this.rejectDb = reject;
-		});
-		this.dbReady.catch(() => {});
-		this.storage = createStorageRepository({
-			db: () => this.dbReady,
-			dbDirect: () => {
-				if (this.db === void 0) throw new Error("sqlite session database is not open");
-				return this.db;
-			},
-			writeAtomically: (fn) => enqueueSqliteTx(this.dbPath, async () => {
-				const db = await this.dbReady;
-				db.$client.exec("BEGIN IMMEDIATE");
-				try {
-					const result = await fn();
-					db.$client.exec("COMMIT");
-					return result;
-				} catch (error) {
-					try {
-						db.$client.exec("ROLLBACK");
-					} catch {}
-					throw error;
-				}
-			}),
-			tables: {
-				t_sessions: tSessions,
-				t_storage_units: tStorageUnits,
-				t_workspaces: tWorkspaces,
-				t_workspace_sessions: tWorkspaceSessions,
-				t_workspace_state: tWorkspaceState,
-				t_schedule_tasks: tScheduleTasks,
-				t_session_projcache_row: tSessionProjcacheRows
-			}
-		});
-	}
-	async open() {
-		try {
-			await this.doOpen();
-			this.resolveDb(this.db);
-		} catch (error) {
-			this.rejectDb(error);
-			throw error;
-		}
-	}
-	async doOpen() {
-		const actual = this.options.path === ":memory:" ? this.options.path : resolve(this.options.path);
-		this.dbPath = actual;
-		if (actual !== ":memory:") {
-			await mkdir(dirname(actual), {
-				recursive: true,
-				mode: 448
-			});
-			await createDatabaseFile(actual);
-		}
-		await enqueueSqliteTx(actual, async () => {
-			this.db = drizzle({ client: await openDatabase(actual, this.options.journalMode, this.options.busyTimeout) });
-			migrate(this.db, { migrationsFolder: sqliteMigrationsDir });
-		});
-		try {
-			const row = this.db.select({ fStoreId: tPersistenceState.fStoreId }).from(tPersistenceState).where(eq(tPersistenceState.fSingleton, 1)).get();
-			if (row === void 0) throw new Error(`session database at "${actual}" has no store identity`);
-			if (row.fStoreId.length === 0) throw new Error(`session database at "${actual}" has no valid store identity`);
-			if (actual !== ":memory:") {
-				const identity = await stat(actual, { bigint: true });
-				this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${row.fStoreId}`;
-			} else this.storeIdentity = `memory:store:${row.fStoreId}`;
-		} catch (error) {
-			this.db.$client.close();
-			throw error;
-		}
-	}
-	async close() {
-		if (this.db === void 0) return;
-		this.db.$client.close();
-	}
-	async getSession(id) {
-		return this.db.select().from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-	}
-	async getEventRows(id, fromSequence) {
-		const sql = `select se.f_event_id as fEventId, se.f_sequence as fSequence, e.f_type as fType,
-              e.f_kind as fKind, e.f_role as fRole, e.f_name as fName, e.f_action_id as fActionId,
-              e.f_created_at as fCreatedAt, e.f_data as fData, se.f_surface_op as fSurfaceOp
-         from t_session_events se join t_events e on se.f_event_id = e.f_event_id
-        where se.f_session_id = ?${fromSequence === void 0 ? "" : " and se.f_sequence >= ?"}
-        order by se.f_sequence`;
-		const statement = this.db.$client.prepare(sql);
-		return fromSequence === void 0 ? statement.all(id) : statement.all(id, fromSequence);
-	}
-	async getEventTypeAt(id, sequence) {
-		return this.db.select({ fType: tEvents.fType }).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get()?.fType;
-	}
-	async getEventTypesBefore(id, beforeSequence, limit) {
-		return this.db.select({
-			fSequence: tSessionEvents.fSequence,
-			fType: tEvents.fType
-		}).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence))).orderBy(desc(tSessionEvents.fSequence)).limit(limit).all();
-	}
-	async listSessions() {
-		return this.db.select().from(tSessions).all();
-	}
-	async transaction(fn) {
-		return enqueueSqliteTx(this.dbPath, async () => {
-			this.db.$client.exec("BEGIN IMMEDIATE");
-			try {
-				const result = await fn(this.tx);
-				this.db.$client.exec("COMMIT");
-				return result;
-			} catch (error) {
-				try {
-					this.db.$client.exec("ROLLBACK");
-				} catch {}
-				throw error;
-			}
-		});
-	}
-	tx = {
-		upsertSession: (storage, incarnation) => this.upsertSession(storage, incarnation),
-		getHead: (id) => this.getHead(id),
-		getSeedLength: (id) => this.getSeedLength(id),
-		updateSeedLength: (id, seedLength) => this.updateSeedLength(id, seedLength),
-		insertEvents: (events, usageRows) => this.insertEvents(events, usageRows),
-		insertBridges: (rows) => this.insertBridges(rows),
-		updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
-		bumpRevision: (id, lastEventAt) => this.bumpRevision(id, lastEventAt),
-		refreshTitle: (id) => this.refreshTitle(id),
-		deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
-		getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence),
-		deleteSession: (id) => this.deleteSession(id),
-		deleteSessions: (ids) => this.deleteSessions(ids)
-	};
-	async upsertSession(storage, incarnation) {
-		this.db.insert(tSessions).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
-			target: tSessions.fSessionId,
-			set: sessionConflictRow(storage)
-		}).run();
-	}
-	async getHead(id) {
-		const head = this.db.select({
-			fHeadEventId: tSessions.fHeadEventId,
-			fHeadSequence: tSessions.fHeadSequence
-		}).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
-		return head;
-	}
-	async getSeedLength(id) {
-		const row = this.db.select({ fSeedLength: tSessions.fSeedLength }).from(tSessions).where(eq(tSessions.fSessionId, id)).get();
-		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
-		return row.fSeedLength;
-	}
-	async updateSeedLength(id, seedLength) {
-		this.db.update(tSessions).set({ fSeedLength: seedLength }).where(eq(tSessions.fSessionId, id)).run();
-	}
-	static INSERT_BATCH_ROWS = 1e3;
-	async insertEvents(events, usageRows) {
-		if (events.length === 0) return;
-		for (let i = 0; i < events.length; i += SqliteBackend.INSERT_BATCH_ROWS) this.db.insert(tEvents).values(events.slice(i, i + SqliteBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).run();
-		if (usageRows.length > 0) this.db.insert(tEventUsage).values(usageRows.map((row) => ({ ...row }))).onConflictDoNothing().run();
-	}
-	async insertBridges(rows) {
-		if (rows.length === 0) return;
-		for (let i = 0; i < rows.length; i += SqliteBackend.INSERT_BATCH_ROWS) this.db.insert(tSessionEvents).values(rows.slice(i, i + SqliteBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).run();
-	}
-	async updateHead(id, headEventId, headSequence) {
-		this.db.update(tSessions).set({
-			fHeadEventId: headEventId,
-			fHeadSequence: headSequence
-		}).where(eq(tSessions.fSessionId, id)).run();
-	}
-	async bumpRevision(id, lastEventAt) {
-		this.db.update(tSessions).set({
-			fRevision: sql`${tSessions.fRevision} + 1`,
-			...lastEventAt === void 0 ? {} : { fLastEventAt: sql`MAX(COALESCE(${tSessions.fLastEventAt}, 0), ${lastEventAt})` }
-		}).where(eq(tSessions.fSessionId, id)).run();
-	}
-	async refreshTitle(id) {
-		const row = this.db.select({
-			fSequence: tSessionEvents.fSequence,
-			fData: tEvents.fData
-		}).from(tSessionEvents).innerJoin(tEvents, eq(tEvents.fEventId, tSessionEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), eq(tEvents.fType, "session/title"))).orderBy(desc(tSessionEvents.fSequence)).limit(1).get();
-		const title = row === void 0 ? void 0 : titleOfEventData(row.fData);
-		this.db.update(tSessions).set({
-			fTitle: title ?? null,
-			fTitleSeq: title === void 0 ? null : row.fSequence
-		}).where(eq(tSessions.fSessionId, id)).run();
-	}
-	async deleteBridgeTail(id, fromSequence) {
-		return this.db.$client.prepare("DELETE FROM t_session_events WHERE f_session_id = ? AND f_sequence >= ? RETURNING f_event_id").all(id, fromSequence).map((row) => row.f_event_id);
-	}
-	async getPrevBridge(id, sequence) {
-		return this.db.select({
-			fEventId: tSessionEvents.fEventId,
-			fSequence: tSessionEvents.fSequence
-		}).from(tSessionEvents).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get();
-	}
-	async deleteSession(id) {
-		const rows = this.db.$client.prepare("DELETE FROM t_session_events WHERE f_session_id = ? RETURNING f_event_id").all(id);
-		this.db.delete(tWorkspaceSessions).where(eq(tWorkspaceSessions.fSessionId, id)).run();
-		this.db.delete(tSessionProjcacheRows).where(eq(tSessionProjcacheRows.fSessionId, id)).run();
-		this.db.delete(tSessions).where(eq(tSessions.fSessionId, id)).run();
-		return rows.map((row) => row.f_event_id);
-	}
-	async collectOrphans() {
-		const referenced = this.db.select({ fEventId: tSessionEvents.fEventId }).from(tSessionEvents);
-		const info = this.db.delete(tEvents).where(notInArray(tEvents.fEventId, referenced)).run();
-		this.db.delete(tEventUsage).where(notInArray(tEventUsage.fEventId, this.db.select({ fEventId: tEvents.fEventId }).from(tEvents))).run();
-		return Number(info.changes);
-	}
-	async listOrphanSubagentSessions() {
-		return this.db.$client.prepare(`SELECT f_session_id AS id FROM t_sessions
-         WHERE f_origin = 'subagent'
-           AND (f_parent_session IS NULL
-                OR f_parent_session NOT IN (SELECT f_session_id FROM t_sessions))`).all().map((row) => row.id);
-	}
-	async deleteSessions(ids) {
-		if (ids.length === 0) return {
-			deleted: 0,
-			eventIds: []
-		};
-		const placeholders = ids.map(() => "?").join(", ");
-		const rows = this.db.$client.prepare(`DELETE FROM t_session_events WHERE f_session_id IN (${placeholders}) RETURNING f_event_id`).all(...ids);
-		this.db.delete(tWorkspaceSessions).where(inArray(tWorkspaceSessions.fSessionId, ids)).run();
-		this.db.delete(tSessionProjcacheRows).where(inArray(tSessionProjcacheRows.fSessionId, ids)).run();
-		const info = this.db.delete(tSessions).where(inArray(tSessions.fSessionId, ids)).run();
-		return {
-			deleted: Number(info.changes),
-			eventIds: rows.map((row) => row.f_event_id)
-		};
-	}
-	async listSessionRows(query = {}) {
-		const needle = query.query?.trim().toLowerCase() ?? "";
-		const like = `%${needle}%`;
-		const where = `WHERE (? = '' OR lower(COALESCE(s.f_title, '')) LIKE ? OR lower(COALESCE(w.f_title, '')) LIKE ?)
-                     AND (? = 1 OR s.f_origin IS NOT 'subagent')`;
-		const filterParams = [
-			needle,
-			like,
-			like,
-			query.includeSubagents === true ? 1 : 0
-		];
-		const limit = query.limit ?? 20;
-		const offset = query.offset ?? 0;
-		const rows = this.db.$client.prepare(`SELECT s.f_session_id AS session_id,
-                s.f_title AS title,
-                s.f_origin AS origin,
-                s.f_cwd AS cwd,
-                s.f_created_at AS created_at,
-                (s.f_archived_at IS NOT NULL) AS archived,
-                COALESCE(s.f_last_event_at, s.f_created_at) AS updated_at,
-                w.f_title AS workspace
-           FROM t_sessions s
-           LEFT JOIN t_workspaces w ON w.f_workspace_id = (
-                 SELECT b.f_workspace_id FROM t_workspace_sessions b
-                  WHERE b.f_session_id = s.f_session_id ORDER BY b.f_position LIMIT 1)
-          ${where}
-          ORDER BY updated_at DESC, s.f_session_id
-          LIMIT ? OFFSET ?`).all(...filterParams, limit, offset);
-		const counted = this.db.$client.prepare(`SELECT count(*) AS n
-           FROM t_sessions s
-           LEFT JOIN t_workspaces w ON w.f_workspace_id = (
-                 SELECT b.f_workspace_id FROM t_workspace_sessions b
-                  WHERE b.f_session_id = s.f_session_id ORDER BY b.f_position LIMIT 1)
-          ${where}`).get(...filterParams);
-		return {
-			items: rows.map((row) => sessionListRowOf(row)),
-			total: Number(counted.n)
-		};
-	}
-	async usageReport(sinceMs) {
-		const usageSince = sinceMs === void 0 ? "" : " AND f_created_at >= ?";
-		const params = sinceMs === void 0 ? [] : [sinceMs];
-		const daySince = sinceMs === void 0 ? "" : " AND %COL% >= ?";
-		const dayParams = sinceMs === void 0 ? [] : [localDayKey(sinceMs)];
-		const dayFilter = (column) => daySince.replace("%COL%", column);
-		const buckets = this.db.$client.prepare(`SELECT f_day AS day,
-                f_provider AS provider,
-                f_model AS model,
-                f_subagent AS subagent,
-                sum(f_input_tokens) AS input_tokens,
-                sum(f_output_tokens) AS output_tokens,
-                sum(f_cache_read_tokens) AS cache_read_tokens,
-                sum(f_reasoning_tokens) AS reasoning_tokens,
-                sum(f_total_tokens) AS total_tokens
-           FROM t_event_usage
-          WHERE f_referenced = 1${usageSince}
-          GROUP BY f_day, f_provider, f_model, f_subagent`).all(...params);
-		const tokenScope = this.db.$client.prepare(`SELECT f_subagent AS subagent,
-                sum(f_input_tokens) AS input_tokens,
-                sum(f_output_tokens) AS output_tokens,
-                sum(f_cache_read_tokens) AS cache_read_tokens,
-                sum(f_reasoning_tokens) AS reasoning_tokens,
-                sum(f_total_tokens) AS total_tokens
-           FROM t_event_usage
-          WHERE f_referenced = 1${usageSince}
-          GROUP BY f_subagent`).all(...params);
-		const activityScope = this.db.$client.prepare(`SELECT (s.f_origin = 'subagent') AS subagent,
-                sum(c.f_turns) AS turns,
-                sum(c.f_steps) AS steps,
-                sum(c.f_user_inputs) AS user_inputs,
-                sum(c.f_tool_calls) AS tool_calls
-           FROM t_session_counts c
-           JOIN t_sessions s ON s.f_session_id = c.f_session_id
-          WHERE ${hasUsageSession("c.f_session_id")}${dayFilter("c.f_day")}
-          GROUP BY subagent`).all(...dayParams);
-		const tokenSessions = this.db.$client.prepare(`SELECT u.f_session_id AS session_id,
-                s.f_title AS title,
-                (s.f_origin = 'subagent') AS subagent,
-                (s.f_archived_at IS NOT NULL) AS archived,
-                sum(u.f_input_tokens) AS input_tokens,
-                sum(u.f_output_tokens) AS output_tokens,
-                sum(u.f_cache_read_tokens) AS cache_read_tokens,
-                sum(u.f_reasoning_tokens) AS reasoning_tokens,
-                sum(u.f_total_tokens) AS total_tokens
-           FROM t_session_usage u
-           JOIN t_sessions s ON s.f_session_id = u.f_session_id
-          WHERE 1 = 1${dayFilter("u.f_day")}
-          GROUP BY u.f_session_id, s.f_title, s.f_origin, s.f_archived_at`).all(...dayParams);
-		const activitySessions = this.db.$client.prepare(`SELECT f_session_id AS session_id,
-                sum(f_turns) AS turns,
-                sum(f_steps) AS steps,
-                sum(f_user_inputs) AS user_inputs,
-                sum(f_tool_calls) AS tool_calls
-           FROM t_session_counts
-          WHERE 1 = 1${dayFilter("f_day")}
-          GROUP BY f_session_id`).all(...dayParams);
-		const human = emptyTotals();
-		const subagent = emptyTotals();
-		for (const row of tokenScope) addTokenTotals(row.subagent === 1 ? subagent : human, tokenTotalsOf(row));
-		for (const row of activityScope) addActivityTotals(row.subagent === 1 ? subagent : human, activityTotalsOf(row));
-		const totals = addTotals(addTotals(emptyTotals(), human), subagent);
-		const activityBySession = /* @__PURE__ */ new Map();
-		for (const row of activitySessions) activityBySession.set(row.session_id, activityTotalsOf(row));
-		return {
-			totals,
-			subagent,
-			human,
-			buckets: buckets.map((row) => ({
-				day: row.day,
-				provider: row.provider,
-				model: row.model,
-				subagent: row.subagent === 1,
-				...tokenTotalsOf(row)
-			})),
-			sessions: tokenSessions.map((row) => ({
-				sessionId: row.session_id,
-				title: row.title,
-				subagent: row.subagent === 1,
-				archived: row.archived === 1,
-				...tokenTotalsOf(row),
-				...activityBySession.get(row.session_id) ?? emptyActivity()
-			}))
-		};
-	}
-	async incrementSessionUsage(id, buckets) {
-		if (buckets.length === 0) return;
-		const statement = this.db.$client.prepare(`INSERT INTO t_session_usage (f_session_id, f_day, f_provider, f_model,
-          f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(f_session_id, f_day, f_provider, f_model) DO UPDATE SET
-         f_input_tokens = f_input_tokens + excluded.f_input_tokens,
-         f_output_tokens = f_output_tokens + excluded.f_output_tokens,
-         f_cache_read_tokens = f_cache_read_tokens + excluded.f_cache_read_tokens,
-         f_reasoning_tokens = f_reasoning_tokens + excluded.f_reasoning_tokens,
-         f_total_tokens = f_total_tokens + excluded.f_total_tokens`);
-		for (const bucket of buckets) statement.run(id, bucket.day, bucket.provider ?? "", bucket.model ?? "", bucket.inputTokens, bucket.outputTokens, bucket.cacheReadTokens, bucket.reasoningTokens, bucket.totalTokens);
-	}
-	async incrementSessionCounts(id, buckets) {
-		if (buckets.length === 0) return;
-		const statement = this.db.$client.prepare(`INSERT INTO t_session_counts (f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
-       VALUES (?, ?, ?, ?, ?, ?)
-       ON CONFLICT(f_session_id, f_day) DO UPDATE SET
-         f_turns = f_turns + excluded.f_turns,
-         f_steps = f_steps + excluded.f_steps,
-         f_user_inputs = f_user_inputs + excluded.f_user_inputs,
-         f_tool_calls = f_tool_calls + excluded.f_tool_calls`);
-		for (const bucket of buckets) statement.run(id, bucket.day, bucket.turns, bucket.steps, bucket.userInputs, bucket.toolCalls);
-	}
-	async rebuildSessionStats(id) {
-		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
-		this.db.$client.prepare(`INSERT INTO t_session_usage (
-             f_session_id, f_day, f_provider, f_model,
-             f_input_tokens, f_output_tokens, f_cache_read_tokens, f_reasoning_tokens, f_total_tokens)
-         SELECT b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, ''),
-                sum(u.f_input_tokens), sum(u.f_output_tokens), sum(u.f_cache_read_tokens),
-                sum(u.f_reasoning_tokens), sum(u.f_total_tokens)
-           FROM t_session_events b
-           JOIN t_event_usage u ON u.f_event_id = b.f_event_id
-          WHERE b.f_session_id = ?
-          GROUP BY b.f_session_id, u.f_day, coalesce(u.f_provider, ''), coalesce(u.f_model, '')`).run(id);
-		this.db.$client.prepare("DELETE FROM t_session_counts WHERE f_session_id = ?").run(id);
-		this.db.$client.prepare(`INSERT INTO t_session_counts (
-             f_session_id, f_day, f_turns, f_steps, f_user_inputs, f_tool_calls)
-         SELECT b.f_session_id,
-                date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
-                sum(CASE WHEN e.f_type = 'turn/start' THEN 1 ELSE 0 END),
-                sum(CASE WHEN e.f_type = 'step/start' THEN 1 ELSE 0 END),
-                sum(CASE WHEN e.f_type = 'user/message' THEN 1 ELSE 0 END),
-                sum(CASE WHEN e.f_type = 'tool/call' THEN 1 ELSE 0 END)
-           FROM t_session_events b
-           JOIN t_events e ON e.f_event_id = b.f_event_id
-          WHERE b.f_session_id = ? AND e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
-          GROUP BY b.f_session_id, 2`).run(id);
-	}
-	async refreshEventUsageFlags(eventIds) {
-		for (let at = 0; at < eventIds.length; at += REFRESH_FLAG_CHUNK) {
-			const chunk = eventIds.slice(at, at + REFRESH_FLAG_CHUNK);
-			const placeholders = chunk.map(() => "?").join(", ");
-			this.db.$client.prepare(`UPDATE t_event_usage SET
-             f_referenced = ${withEvent(EVENT_REFERENCED_SQL, "f_event_id")},
-             f_subagent = ${withEvent(EVENT_SUBAGENT_SQL, "f_event_id")}
-           WHERE f_event_id IN (${placeholders})`).run(...chunk);
-		}
-	}
-	async deleteSessionStats(id) {
-		this.db.$client.prepare("DELETE FROM t_session_usage WHERE f_session_id = ?").run(id);
-		this.db.$client.prepare("DELETE FROM t_session_counts WHERE f_session_id = ?").run(id);
-	}
-	async vacuum() {
-		await enqueueSqliteTx(this.dbPath, async () => {
-			this.db.$client.exec("VACUUM");
-		});
-	}
-	eventRows() {
-		return this.db.select({
-			fEventId: tSessionEvents.fEventId,
-			fSequence: tSessionEvents.fSequence,
-			fType: tEvents.fType,
-			fKind: tEvents.fKind,
-			fRole: tEvents.fRole,
-			fName: tEvents.fName,
-			fActionId: tEvents.fActionId,
-			fCreatedAt: tEvents.fCreatedAt,
-			fData: tEvents.fData,
-			fSurfaceOp: tSessionEvents.fSurfaceOp
-		}).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId));
-	}
-};
-export { tWorkspaces as C, WriteGuard as E, tWorkspaceState as S, toPostgresSchema as T, tSessionProjcacheRows as _, EVENT_ENCODING as a, tStorageUnits as b, eventDimensions as c, tEvents as d, tPersistenceState as f, tSessionEvents as g, tSessionCounts as h, DEFAULT_BUSY_TIMEOUT_MS as i, eventKind as l, tSchemaMeta as m, openDatabase as n, SCHEMA_VERSION as o, tScheduleTasks as p, createStorageRepository as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, SqliteBackend as t, tEventUsage as u, tSessionUsage as v, postgresTableDefs as w, tWorkspaceSessions as x, tSessions as y };