@moxt-ai/mobius 0.0.175 → 0.0.176

package/dist/index.js

@@ -3380,11 +3380,11 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
     return payload;
   };
 });
-function handleArrayResult(result, final, index) {
+function handleArrayResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
@@ -3995,14 +3995,14 @@ function mergeValues(a, b) {
       return { valid: false, mergeErrorPath: [] };
     }
     const newArray = [];
-    for (let index = 0; index < a.length; index++) {
-      const itemA = a[index];
-      const itemB = b[index];
+    for (let index2 = 0; index2 < a.length; index2++) {
+      const itemA = a[index2];
+      const itemB = b[index2];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [index2, ...sharedValue.mergeErrorPath]
         };
       }
       newArray.push(sharedValue.data);
@@ -4153,11 +4153,11 @@ function getTupleOptStart(items, key) {
   }
   return 0;
 }
-function handleTupleResult(result, final, index) {
+function handleTupleResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 function handleTupleResults(itemResults, final, items, input2, optoutStart) {
   for (let i = 0; i < items.length; i++) {
@@ -18838,7 +18838,7 @@ function detectVersion(schema, defaultTarget) {
   return defaultTarget ?? "draft-2020-12";
 }
 function applyMinItems(items, minItems) {
-  return items.map((item, index) => index < minItems ? item : item.optional());
+  return items.map((item, index2) => index2 < minItems ? item : item.optional());
 }
 function decodeJSONPointerSegment(segment) {
   return segment.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -20023,12 +20023,12 @@ var DEFAULT_AGENT_EXECUTION_CONFIGURATION = Object.freeze({
 });
 var sessionConfigurationSelectionsSchema = external_exports.array(sessionConfigurationSelectionSchema).max(100).superRefine((selections, context) => {
   const identifiers = /* @__PURE__ */ new Set();
-  for (const [index, selection] of selections.entries()) {
+  for (const [index2, selection] of selections.entries()) {
     if (identifiers.has(selection.configId)) {
       context.addIssue({
         code: "custom",
         message: "Session configuration identifiers must be unique",
-        path: [index, "configId"]
+        path: [index2, "configId"]
       });
     }
     identifiers.add(selection.configId);
@@ -21529,12 +21529,12 @@ var sessionExportV2Schema = external_exports.object({
 }).readonly().superRefine((session, context) => {
   let previousPosition = 0n;
   const eventIds = /* @__PURE__ */ new Set();
-  for (const [index, event] of session.events.entries()) {
+  for (const [index2, event] of session.events.entries()) {
     if (event.sessionId !== session.sessionId) {
       context.addIssue({
         code: "custom",
         message: "Exported event belongs to a different Session",
-        path: ["events", index, "sessionId"]
+        path: ["events", index2, "sessionId"]
       });
     }
     const position = BigInt(event.position);
@@ -21542,14 +21542,14 @@ var sessionExportV2Schema = external_exports.object({
       context.addIssue({
         code: "custom",
         message: "Exported events are not in increasing position order",
-        path: ["events", index, "position"]
+        path: ["events", index2, "position"]
       });
     }
     if (eventIds.has(event.eventId)) {
       context.addIssue({
         code: "custom",
         message: "Exported event identities are not unique",
-        path: ["events", index, "eventId"]
+        path: ["events", index2, "eventId"]
       });
     }
     previousPosition = position;
@@ -21600,6 +21600,7 @@ function decode5(value, schema) {
 function encode4(value, schema) {
   return JSON.stringify(decode5(value, schema));
 }
+var decodeSessionEventV2 = (value) => decode5(value, sessionEventV2Schema);
 var decodeSessionEventEnvelopeV2 = (value) => decode5(value, sessionEventEnvelopeV2Schema);
 var encodeSessionEventEnvelopeV2 = (value) => encode4(value, sessionEventEnvelopeV2Schema);
 var decodeAcpSessionUpdateV2 = (value) => decode5(value, acpSessionUpdateV2Schema);
@@ -22915,7 +22916,7 @@ function startsWith(bytes, signature, offset = 0) {
   if (bytes.byteLength < offset + signature.byteLength) {
     return false;
   }
-  return signature.every((value, index) => bytes[offset + index] === value);
+  return signature.every((value, index2) => bytes[offset + index2] === value);
 }
 function sniffRasterMime(bytes) {
   if (startsWith(bytes, PNG_SIGNATURE)) {
@@ -23043,7 +23044,7 @@ function startsWith2(bytes, signature, offset = 0) {
   if (bytes.byteLength < offset + signature.byteLength) {
     return false;
   }
-  return signature.every((value, index) => bytes[offset + index] === value);
+  return signature.every((value, index2) => bytes[offset + index2] === value);
 }
 function sniffVideoMime(bytes) {
   if (startsWith2(bytes, MP4_FILE_TYPE, 4)) {
@@ -23172,10 +23173,10 @@ async function replaceImageMarkers(text2, replace) {
   let cursor = 0;
   let rewritten = "";
   for (const match of matches) {
-    const index = match.index ?? 0;
-    rewritten += text2.slice(cursor, index);
+    const index2 = match.index ?? 0;
+    rewritten += text2.slice(cursor, index2);
     rewritten += await replace(match[1] ?? "");
-    cursor = index + match[0].length;
+    cursor = index2 + match[0].length;
   }
   return `${rewritten}${text2.slice(cursor)}`;
 }
@@ -24493,9 +24494,9 @@ function historyContentCharacters(messages) {
 var AcpHistoryReplay = class {
   #activities = /* @__PURE__ */ new Map();
   #messages = [];
-  #events = [];
-  #records = [];
+  #events;
   #turnActivityIds = /* @__PURE__ */ new Set();
+  #sessionId;
   #activityTracker = new AcpActivityTracker(
     async (activity2) => {
       this.#activities.set(activity2.activityId, activity2);
@@ -24516,10 +24517,16 @@ var AcpHistoryReplay = class {
   #firstMessageIndex = 0;
   #characters = 0;
   #truncated = false;
+  constructor(events, sessionId) {
+    this.#events = events;
+    this.#sessionId = sessionId;
+  }
   record = async (update, rawUpdate, onRecorded = () => Promise.resolve()) => {
-    this.#records.push({ kind: "acp", rawUpdate, update });
-    this.#events.push({ payload: rawUpdate, type: "acp" });
-    await onRecorded(this.#events.length);
+    const position = this.#events.append(this.#sessionId, { payload: rawUpdate, type: "acp" });
+    await onRecorded(position);
+    return await this.#applyUpdate(update, position);
+  };
+  #applyUpdate = async (update, position) => {
     if (update.sessionUpdate === "agent_thought_chunk") {
       if (update.content.type === "text") {
         await this.#activityTracker.recordNarrative(
@@ -24528,30 +24535,30 @@ var AcpHistoryReplay = class {
           update.content.text
         );
       }
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate === "tool_call") {
       await this.#activityTracker.recordToolCall(update);
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate === "tool_call_update") {
       await this.#activityTracker.recordToolCallUpdate(update);
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate === "plan") {
       await this.#activityTracker.recordPlan(update);
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate === "plan_update") {
       await this.#activityTracker.recordPlanUpdate(update);
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate === "plan_removed") {
       await this.#activityTracker.removePlan(update);
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate !== "user_message_chunk" && update.sessionUpdate !== "agent_message_chunk") {
-      return this.#events.length;
+      return position;
     }
     if (update.sessionUpdate === "agent_message_chunk" && isProgressMessage(update)) {
       if (update.content.type === "text") {
@@ -24561,18 +24568,18 @@ var AcpHistoryReplay = class {
           update.content.text
         );
       }
-      return this.#events.length;
+      return position;
     }
     const role = update.sessionUpdate === "user_message_chunk" ? "user" : "assistant";
     const content = update.content;
     if (role === "assistant" && content.type !== "text") {
       await this.#activityTracker.finishNarrative();
       this.recordAssistantContent(update.messageId ?? null, normalizeContentBlock(content));
-      return this.#events.length;
+      return position;
     }
     const text2 = content.type === "text" ? content.text : content.type === "image" ? content.data.length > 0 ? `[@image](data:${content.mimeType};base64,${content.data})` : content.uri != null && content.uri.length > 0 ? `[@image](${content.uri})` : "[image attachment]" : `[${content.type} attachment]`;
     if (text2.length === 0) {
-      return this.#events.length;
+      return position;
     }
     const previous = this.#messages.at(-1);
     const id = update.messageId ?? null;
@@ -24599,41 +24606,32 @@ var AcpHistoryReplay = class {
     this.#characters += bounded2.length;
     this.#lastMessageId = id;
     this.trimMessages();
-    return this.#events.length;
+    return position;
   };
   recordLifecycle = (event) => {
     if (event.type !== "lifecycle-metadata") {
       throw new Error("Lifecycle history only accepts lifecycle metadata");
     }
-    this.#records.push({ event, kind: "lifecycle" });
-    this.#events.push(event);
-    return this.#events.length;
+    return this.#events.append(this.#sessionId, event);
   };
-  eventCount = () => this.#events.length;
   append = async (replay) => {
-    for (const record2 of replay.#records) {
-      if (record2.kind === "acp") {
-        await this.record(record2.update, record2.rawUpdate);
-      } else {
-        this.recordLifecycle(record2.event);
-      }
+    await replay.#activityTracker.finish();
+    for (const [activityId, activity2] of replay.#activities) {
+      this.#activities.set(activityId, activity2);
     }
-  };
-  eventPage = (eventLimit, cursor, appended = null) => {
-    const events = appended === null ? this.#events : [...this.#events, ...appended.#events];
-    const parsedCursor = cursor === null ? events.length : Number(cursor);
-    if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0 || parsedCursor > events.length) {
-      throw new Error("The native event cursor is invalid");
+    for (const message of replay.#messages.slice(replay.#firstMessageIndex)) {
+      this.#messages.push(message);
+      this.#characters += message.text.length;
     }
-    const endUpdate = parsedCursor;
-    const startUpdate = Math.max(0, endUpdate - eventLimit);
-    return {
-      nextCursor: startUpdate === 0 ? null : startUpdate.toString(),
-      startPosition: startUpdate + 1,
-      truncated: startUpdate > 0,
-      events: events.slice(startUpdate, endUpdate)
-    };
+    this.#turnActivityIds.clear();
+    for (const activityId of replay.#turnActivityIds) {
+      this.#turnActivityIds.add(activityId);
+    }
+    this.#lastMessageId = replay.#lastMessageId;
+    this.#truncated ||= replay.#truncated;
+    this.trimMessages();
   };
+  eventPage = (eventLimit, cursor) => this.#events.page(this.#sessionId, eventLimit, cursor);
   snapshot = async () => {
     await this.#activityTracker.finish();
     const messages = this.#messages.slice(this.#firstMessageIndex).map((message) => {
@@ -25266,9 +25264,7 @@ var AcpSessionInteractions = class {
 };
 
 // src/acp/session-store.ts
-import { chmodSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { randomUUID } from "node:crypto";
 
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/entity.js
 var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
@@ -26384,7 +26380,7 @@ function haveSameKeys(left, right) {
   const leftKeys = Object.keys(left);
   const rightKeys = Object.keys(right);
   if (leftKeys.length !== rightKeys.length) return false;
-  for (const [index, key] of leftKeys.entries()) if (key !== rightKeys[index]) return false;
+  for (const [index2, key] of leftKeys.entries()) if (key !== rightKeys[index2]) return false;
   return true;
 }
 function mapUpdateSet(table, values) {
@@ -27137,195 +27133,6 @@ var NoopLogger = class {
   }
 };
 
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
-var SQLiteCountBuilder = class SQLiteCountBuilder2 extends SQL {
-  static [entityKind] = "SQLiteCountBuilder";
-  dialect;
-  session;
-  static buildCount(source, filters, parens) {
-    const query = sql`select count(*) from ${source}${sql` where ${filters}`.if(filters)}`;
-    return parens ? sql`(${query})` : query;
-  }
-  constructor(countConfig) {
-    super(SQLiteCountBuilder2.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
-    this.countConfig = countConfig;
-    this.dialect = countConfig.dialect;
-    this.session = countConfig.session;
-    this.mapWith((e) => {
-      if (typeof e === "number") return e;
-      return Number(e ?? 0);
-    });
-  }
-  executableSql;
-  build() {
-    if (!this.executableSql) {
-      const { source, filters } = this.countConfig;
-      this.executableSql = SQLiteCountBuilder2.buildCount(source, filters);
-    }
-    return this.dialect.sqlToQuery(this.executableSql);
-  }
-};
-
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/async/count.js
-var SQLiteAsyncCountBuilder = class extends SQLiteCountBuilder {
-  static [entityKind] = "SQLiteAsyncCountBuilder";
-  constructor(countConfig) {
-    super(countConfig);
-  }
-  /** @internal */
-  executeRaw(placeholderValues) {
-    return this.session.prepareQuery(this.build(), "arrays", false, "all", (rows) => {
-      const v = rows[0]?.[0];
-      if (typeof v === "number") return v;
-      return v ? Number(v) : 0;
-    }).execute(placeholderValues);
-  }
-  async execute(placeholderValues) {
-    return await this.executeRaw(placeholderValues);
-  }
-};
-applyMixins(SQLiteAsyncCountBuilder, [QueryPromise]);
-var SQLiteSyncCountBuilder = class extends SQLiteAsyncCountBuilder {
-  static [entityKind] = "SQLiteSyncCountBuilder";
-  sync(placeholderValues) {
-    return this.executeRaw(placeholderValues).sync();
-  }
-};
-
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
-var RelationalQueryBuilder = class {
-  static [entityKind] = "SQLiteRelationalQueryBuilderV2";
-  constructor(mode, schema, table, tableConfig, dialect, session, forbidJsonb, builder = SQLiteRelationalQuery) {
-    this.mode = mode;
-    this.schema = schema;
-    this.table = table;
-    this.tableConfig = tableConfig;
-    this.dialect = dialect;
-    this.session = session;
-    this.forbidJsonb = forbidJsonb;
-    this.builder = builder;
-  }
-  findMany(config2) {
-    return new this.builder(this.mode, this.schema, this.table, this.tableConfig, this.dialect, this.session, config2 ?? true, "many", this.forbidJsonb);
-  }
-  findFirst(config2) {
-    return new this.builder(this.mode, this.schema, this.table, this.tableConfig, this.dialect, this.session, config2 ?? true, "first", this.forbidJsonb);
-  }
-};
-var SQLiteRelationalQuery = class {
-  static [entityKind] = "SQLiteRelationalQueryV2";
-  /** @internal */
-  mode;
-  /** @internal */
-  table;
-  /** @internal */
-  resultKind;
-  constructor(resultKind, schema, table, tableConfig, dialect, session, config2, mode, forbidJsonb) {
-    this.schema = schema;
-    this.tableConfig = tableConfig;
-    this.dialect = dialect;
-    this.session = session;
-    this.config = config2;
-    this.forbidJsonb = forbidJsonb;
-    this.resultKind = resultKind;
-    this.mode = mode;
-    this.table = table;
-  }
-  getSQL() {
-    return this._getQuery().sql;
-  }
-  _getQuery() {
-    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
-    return this.dialect.buildRelationalQuery({
-      schema: this.schema,
-      table: this.table,
-      tableConfig: this.tableConfig,
-      queryConfig: this.config,
-      mode: this.mode,
-      jsonb
-    });
-  }
-  _toSQL() {
-    const query = this._getQuery();
-    return {
-      query,
-      builtQuery: this.dialect.sqlToQuery(query.sql)
-    };
-  }
-  toSQL() {
-    return this._toSQL().builtQuery;
-  }
-};
-
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/async/query.js
-var SQLiteAsyncRelationalQuery = class extends SQLiteRelationalQuery {
-  static [entityKind] = "SQLiteAsyncRelationalQueryV2";
-  /** @internal */
-  _prepare(prepare = false) {
-    const { query, builtQuery } = this._toSQL();
-    const mapper = this.dialect.mapperGenerators.relationalRows({
-      isFirst: this.mode === "first",
-      parseJson: true,
-      parseJsonIfString: false,
-      rootJsonMappers: false,
-      selection: query.selection,
-      arrayModeRoot: true
-    });
-    return this.session.prepareQuery(builtQuery, "arrays", prepare, "all", mapper);
-  }
-  prepare() {
-    return this._prepare(true);
-  }
-  async execute(placeholderValues) {
-    return this._prepare().execute(placeholderValues);
-  }
-};
-var SQLiteSyncRelationalQuery = class extends SQLiteAsyncRelationalQuery {
-  static [entityKind] = "SQLiteSyncRelationalQueryV2";
-  sync(placeholderValues) {
-    return this._prepare().execute(placeholderValues).sync();
-  }
-};
-applyMixins(SQLiteAsyncRelationalQuery, [QueryPromise]);
-
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/selection-proxy.js
-var SelectionProxyHandler = class SelectionProxyHandler2 {
-  static [entityKind] = "SelectionProxyHandler";
-  config;
-  constructor(config2) {
-    this.config = { ...config2 };
-  }
-  get(subquery, prop) {
-    if (prop === "_") return {
-      ...subquery["_"],
-      selectedFields: new Proxy(subquery._.selectedFields, this)
-    };
-    if (prop === ViewBaseConfig) return {
-      ...subquery[ViewBaseConfig],
-      selectedFields: new Proxy(subquery[ViewBaseConfig].selectedFields, this)
-    };
-    if (typeof prop === "symbol") return subquery[prop];
-    const value = (is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery)[prop];
-    if (is(value, SQL.Aliased)) {
-      if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) return value.sql;
-      const newValue = value.clone();
-      newValue.isSelectionField = true;
-      newValue.origin = this.config.alias;
-      return newValue;
-    }
-    if (is(value, SQL)) {
-      if (this.config.sqlBehavior === "sql") return value;
-      throw new Error(`You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`);
-    }
-    if (is(value, Column)) {
-      if (this.config.alias) return new Proxy(value, new ColumnTableAliasProxyHandler(new Proxy(value.table, new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false, true)), true));
-      return value;
-    }
-    if (typeof value !== "object" || value === null) return value;
-    return new Proxy(value, new SelectionProxyHandler2(this.config));
-  }
-};
-
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
 var ForeignKeyBuilder = class {
   static [entityKind] = "SQLiteForeignKeyBuilder";
@@ -27890,130 +27697,144 @@ function sqliteTableWithCasing(casing) {
 }
 var sqliteTable = sqliteTableWithCasing(void 0);
 
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/utils.js
-function extractUsedTable(table) {
-  if (is(table, SQLiteTable)) return [`${table[Table.Symbol.BaseName]}`];
-  if (is(table, Subquery)) return table._.usedTables ?? [];
-  if (is(table, SQL)) return table.usedTables ?? [];
-  return [];
-}
-
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
-var SQLiteDeleteBase = class {
-  static [entityKind] = "SQLiteDelete";
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  constructor(name2, unique) {
+    this.name = name2;
+    this.unique = unique;
+  }
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
   /** @internal */
   config;
-  constructor(table, session, dialect, withList) {
-    this.table = table;
-    this.session = session;
-    this.dialect = dialect;
+  constructor(name2, columns, unique) {
     this.config = {
-      table,
-      withList
+      name: name2,
+      columns,
+      unique,
+      where: void 0
     };
   }
   /**
-  * Adds a `where` clause to the query.
-  *
-  * Calling this method will delete only those rows that fulfill a specified condition.
-  *
-  * See docs: {@link https://orm.drizzle.team/docs/delete}
-  *
-  * @param where the `where` clause.
-  *
-  * @example
-  * You can use conditional operators and `sql function` to filter the rows to be deleted.
-  *
-  * ```ts
-  * // Delete all cars with green color
-  * db.delete(cars).where(eq(cars.color, 'green'));
-  * // or
-  * db.delete(cars).where(sql`${cars.color} = 'green'`)
-  * ```
-  *
-  * You can logically combine conditional operators with `and()` and `or()` operators:
-  *
-  * ```ts
-  * // Delete all BMW cars with a green color
-  * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
-  *
-  * // Delete all cars with the green or blue color
-  * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
-  * ```
+  * Condition for partial index.
   */
-  where(where) {
-    this.config.where = where;
+  where(condition) {
+    this.config.where = condition;
     return this;
   }
-  orderBy(...columns) {
-    if (typeof columns[0] === "function") {
-      const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
-        sqlAliasedBehavior: "alias",
-        sqlBehavior: "sql"
-      })));
-      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
-      this.config.orderBy = orderByArray;
-    } else {
-      const orderByArray = columns;
-      this.config.orderBy = orderByArray;
-    }
-    return this;
-  }
-  limit(limit) {
-    this.config.limit = limit;
-    return this;
-  }
-  returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
-    this.config.returning = orderSelectedFields(fields);
-    return this;
-  }
-  getSQL() {
-    return this.dialect.buildDeleteQuery(this.config);
-  }
-  toSQL() {
-    return this.dialect.sqlToQuery(this.getSQL());
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
   }
-  $dynamic() {
-    return this;
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  isNameExplicit;
+  constructor(config2, table) {
+    this.config = {
+      ...config2,
+      table
+    };
+    this.isNameExplicit = !!config2.name;
   }
 };
+function index(name2) {
+  return new IndexBuilderOn(name2, false);
+}
 
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/async/delete.js
-var SQLiteAsyncDeleteBase = class extends SQLiteDeleteBase {
-  static [entityKind] = "SQLiteAsyncDelete";
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config2) {
+  if (config2[0].columns) return new PrimaryKeyBuilder(config2[0].columns, config2[0].name);
+  return new PrimaryKeyBuilder(config2);
+}
+var PrimaryKeyBuilder = class {
+  static [entityKind] = "SQLitePrimaryKeyBuilder";
   /** @internal */
-  _prepare(prepare = false) {
-    return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), "arrays", prepare, this.config.returning ? "all" : "run", this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, void 0) : void 0, {
-      type: "delete",
-      tables: extractUsedTable(this.config.table)
-    });
+  columns;
+  /** @internal */
+  name;
+  constructor(columns, name2) {
+    this.columns = columns;
+    this.name = name2;
   }
-  prepare() {
-    return this._prepare(true);
+  /** @internal */
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
   }
-  run = (placeholderValues) => {
-    return this._prepare().run(placeholderValues);
-  };
-  all = (placeholderValues) => {
-    return this._prepare().all(placeholderValues);
-  };
-  get = (placeholderValues) => {
-    return this._prepare().get(placeholderValues);
-  };
-  values = (placeholderValues) => {
-    return this._prepare().values(placeholderValues);
-  };
-  async execute(placeholderValues) {
-    return this._prepare().execute(placeholderValues);
+};
+var PrimaryKey = class {
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  isNameExplicit;
+  constructor(table, columns, name2) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name2;
+    this.isNameExplicit = !!name2;
+  }
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
   }
 };
-applyMixins(SQLiteAsyncDeleteBase, [QueryPromise]);
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/utils.js
+function extractUsedTable(table) {
+  if (is(table, SQLiteTable)) return [`${table[Table.Symbol.BaseName]}`];
+  if (is(table, Subquery)) return table._.usedTables ?? [];
+  if (is(table, SQL)) return table.usedTables ?? [];
+  return [];
+}
 
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/view-base.js
 var SQLiteViewBase = class extends View {
   static [entityKind] = "SQLiteViewBase";
 };
 
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/selection-proxy.js
+var SelectionProxyHandler = class SelectionProxyHandler2 {
+  static [entityKind] = "SelectionProxyHandler";
+  config;
+  constructor(config2) {
+    this.config = { ...config2 };
+  }
+  get(subquery, prop) {
+    if (prop === "_") return {
+      ...subquery["_"],
+      selectedFields: new Proxy(subquery._.selectedFields, this)
+    };
+    if (prop === ViewBaseConfig) return {
+      ...subquery[ViewBaseConfig],
+      selectedFields: new Proxy(subquery[ViewBaseConfig].selectedFields, this)
+    };
+    if (typeof prop === "symbol") return subquery[prop];
+    const value = (is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery)[prop];
+    if (is(value, SQL.Aliased)) {
+      if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) return value.sql;
+      const newValue = value.clone();
+      newValue.isSelectionField = true;
+      newValue.origin = this.config.alias;
+      return newValue;
+    }
+    if (is(value, SQL)) {
+      if (this.config.sqlBehavior === "sql") return value;
+      throw new Error(`You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`);
+    }
+    if (is(value, Column)) {
+      if (this.config.alias) return new Proxy(value, new ColumnTableAliasProxyHandler(new Proxy(value.table, new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false, true)), true));
+      return value;
+    }
+    if (typeof value !== "object" || value === null) return value;
+    return new Proxy(value, new SelectionProxyHandler2(this.config));
+  }
+};
+
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/query-builders/query-builder.js
 var TypedQueryBuilder = class {
   static [entityKind] = "TypedQueryBuilder";
@@ -28714,8 +28535,8 @@ var SQLiteDialect = class {
   buildJoins(joins) {
     if (!joins || joins.length === 0) return;
     const joinsArray = [];
-    if (joins) for (const [index, joinMeta] of joins.entries()) {
-      if (index === 0) joinsArray.push(sql` `);
+    if (joins) for (const [index2, joinMeta] of joins.entries()) {
+      if (index2 === 0) joinsArray.push(sql` `);
       const table = joinMeta.table;
       const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;
       if (is(table, SQLiteTable)) {
@@ -28725,7 +28546,7 @@ var SQLiteDialect = class {
         const alias = tableName === origTableName ? void 0 : joinMeta.alias;
         joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`);
       } else joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${table}${onSql}`);
-      if (index < joins.length - 1) joinsArray.push(sql` `);
+      if (index2 < joins.length - 1) joinsArray.push(sql` `);
     }
     return sql.join(joinsArray);
   }
@@ -28734,9 +28555,9 @@ var SQLiteDialect = class {
   }
   buildOrderBy(orderBy) {
     const orderByList = [];
-    if (orderBy) for (const [index, orderByValue] of orderBy.entries()) {
+    if (orderBy) for (const [index2, orderByValue] of orderBy.entries()) {
       orderByList.push(orderByValue);
-      if (index < orderBy.length - 1) orderByList.push(sql`, `);
+      if (index2 < orderBy.length - 1) orderByList.push(sql`, `);
     }
     return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : void 0;
   }
@@ -28764,9 +28585,9 @@ var SQLiteDialect = class {
     const whereSql = where ? sql` where ${where}` : void 0;
     const havingSql = having ? sql` having ${having}` : void 0;
     const groupByList = [];
-    if (groupBy) for (const [index, groupByValue] of groupBy.entries()) {
+    if (groupBy) for (const [index2, groupByValue] of groupBy.entries()) {
       groupByList.push(groupByValue);
-      if (index < groupBy.length - 1) groupByList.push(sql`, `);
+      if (index2 < groupBy.length - 1) groupByList.push(sql`, `);
     }
     const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : void 0}${havingSql}${this.buildOrderBy(orderBy)}${this.buildLimit(limit)}${offset ? sql` offset ${offset}` : void 0}`;
     if (setOperators.length > 0) return this.buildSetOperations(finalQuery, setOperators);
@@ -29055,6 +28876,268 @@ var QueryBuilder = class {
   }
 };
 
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
+var SQLiteCountBuilder = class SQLiteCountBuilder2 extends SQL {
+  static [entityKind] = "SQLiteCountBuilder";
+  dialect;
+  session;
+  static buildCount(source, filters, parens) {
+    const query = sql`select count(*) from ${source}${sql` where ${filters}`.if(filters)}`;
+    return parens ? sql`(${query})` : query;
+  }
+  constructor(countConfig) {
+    super(SQLiteCountBuilder2.buildCount(countConfig.source, countConfig.filters, true).queryChunks);
+    this.countConfig = countConfig;
+    this.dialect = countConfig.dialect;
+    this.session = countConfig.session;
+    this.mapWith((e) => {
+      if (typeof e === "number") return e;
+      return Number(e ?? 0);
+    });
+  }
+  executableSql;
+  build() {
+    if (!this.executableSql) {
+      const { source, filters } = this.countConfig;
+      this.executableSql = SQLiteCountBuilder2.buildCount(source, filters);
+    }
+    return this.dialect.sqlToQuery(this.executableSql);
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/async/count.js
+var SQLiteAsyncCountBuilder = class extends SQLiteCountBuilder {
+  static [entityKind] = "SQLiteAsyncCountBuilder";
+  constructor(countConfig) {
+    super(countConfig);
+  }
+  /** @internal */
+  executeRaw(placeholderValues) {
+    return this.session.prepareQuery(this.build(), "arrays", false, "all", (rows) => {
+      const v = rows[0]?.[0];
+      if (typeof v === "number") return v;
+      return v ? Number(v) : 0;
+    }).execute(placeholderValues);
+  }
+  async execute(placeholderValues) {
+    return await this.executeRaw(placeholderValues);
+  }
+};
+applyMixins(SQLiteAsyncCountBuilder, [QueryPromise]);
+var SQLiteSyncCountBuilder = class extends SQLiteAsyncCountBuilder {
+  static [entityKind] = "SQLiteSyncCountBuilder";
+  sync(placeholderValues) {
+    return this.executeRaw(placeholderValues).sync();
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
+var RelationalQueryBuilder = class {
+  static [entityKind] = "SQLiteRelationalQueryBuilderV2";
+  constructor(mode, schema, table, tableConfig, dialect, session, forbidJsonb, builder = SQLiteRelationalQuery) {
+    this.mode = mode;
+    this.schema = schema;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.forbidJsonb = forbidJsonb;
+    this.builder = builder;
+  }
+  findMany(config2) {
+    return new this.builder(this.mode, this.schema, this.table, this.tableConfig, this.dialect, this.session, config2 ?? true, "many", this.forbidJsonb);
+  }
+  findFirst(config2) {
+    return new this.builder(this.mode, this.schema, this.table, this.tableConfig, this.dialect, this.session, config2 ?? true, "first", this.forbidJsonb);
+  }
+};
+var SQLiteRelationalQuery = class {
+  static [entityKind] = "SQLiteRelationalQueryV2";
+  /** @internal */
+  mode;
+  /** @internal */
+  table;
+  /** @internal */
+  resultKind;
+  constructor(resultKind, schema, table, tableConfig, dialect, session, config2, mode, forbidJsonb) {
+    this.schema = schema;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config2;
+    this.forbidJsonb = forbidJsonb;
+    this.resultKind = resultKind;
+    this.mode = mode;
+    this.table = table;
+  }
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _getQuery() {
+    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
+    return this.dialect.buildRelationalQuery({
+      schema: this.schema,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      mode: this.mode,
+      jsonb
+    });
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    return {
+      query,
+      builtQuery: this.dialect.sqlToQuery(query.sql)
+    };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/async/query.js
+var SQLiteAsyncRelationalQuery = class extends SQLiteRelationalQuery {
+  static [entityKind] = "SQLiteAsyncRelationalQueryV2";
+  /** @internal */
+  _prepare(prepare = false) {
+    const { query, builtQuery } = this._toSQL();
+    const mapper = this.dialect.mapperGenerators.relationalRows({
+      isFirst: this.mode === "first",
+      parseJson: true,
+      parseJsonIfString: false,
+      rootJsonMappers: false,
+      selection: query.selection,
+      arrayModeRoot: true
+    });
+    return this.session.prepareQuery(builtQuery, "arrays", prepare, "all", mapper);
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  async execute(placeholderValues) {
+    return this._prepare().execute(placeholderValues);
+  }
+};
+var SQLiteSyncRelationalQuery = class extends SQLiteAsyncRelationalQuery {
+  static [entityKind] = "SQLiteSyncRelationalQueryV2";
+  sync(placeholderValues) {
+    return this._prepare().execute(placeholderValues).sync();
+  }
+};
+applyMixins(SQLiteAsyncRelationalQuery, [QueryPromise]);
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
+var SQLiteDeleteBase = class {
+  static [entityKind] = "SQLiteDelete";
+  /** @internal */
+  config;
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.config = {
+      table,
+      withList
+    };
+  }
+  /**
+  * Adds a `where` clause to the query.
+  *
+  * Calling this method will delete only those rows that fulfill a specified condition.
+  *
+  * See docs: {@link https://orm.drizzle.team/docs/delete}
+  *
+  * @param where the `where` clause.
+  *
+  * @example
+  * You can use conditional operators and `sql function` to filter the rows to be deleted.
+  *
+  * ```ts
+  * // Delete all cars with green color
+  * db.delete(cars).where(eq(cars.color, 'green'));
+  * // or
+  * db.delete(cars).where(sql`${cars.color} = 'green'`)
+  * ```
+  *
+  * You can logically combine conditional operators with `and()` and `or()` operators:
+  *
+  * ```ts
+  * // Delete all BMW cars with a green color
+  * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+  *
+  * // Delete all cars with the green or blue color
+  * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+  * ```
+  */
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
+        sqlAliasedBehavior: "alias",
+        sqlBehavior: "sql"
+      })));
+      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+      this.config.orderBy = orderByArray;
+    } else {
+      const orderByArray = columns;
+      this.config.orderBy = orderByArray;
+    }
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  getSQL() {
+    return this.dialect.buildDeleteQuery(this.config);
+  }
+  toSQL() {
+    return this.dialect.sqlToQuery(this.getSQL());
+  }
+  $dynamic() {
+    return this;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/async/delete.js
+var SQLiteAsyncDeleteBase = class extends SQLiteDeleteBase {
+  static [entityKind] = "SQLiteAsyncDelete";
+  /** @internal */
+  _prepare(prepare = false) {
+    return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), "arrays", prepare, this.config.returning ? "all" : "run", this.config.returning ? this.dialect.mapperGenerators.rows(this.config.returning, void 0) : void 0, {
+      type: "delete",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(true);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  async execute(placeholderValues) {
+    return this._prepare().execute(placeholderValues);
+  }
+};
+applyMixins(SQLiteAsyncDeleteBase, [QueryPromise]);
+
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
 var SQLiteInsertBuilder = class {
   static [entityKind] = "SQLiteInsertBuilder";
@@ -29942,133 +30025,6 @@ var SQLiteAsyncTransaction = class extends SQLiteAsyncDatabase {
   }
 };
 
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/node-sqlite/session.js
-var NodeSQLiteSession = class extends SQLiteAsyncSession {
-  static [entityKind] = "SQLJsSession";
-  logger;
-  constructor(client2, dialect, relations, options = {}) {
-    super(dialect, "sync");
-    this.client = client2;
-    this.relations = relations;
-    this.options = options;
-    this.logger = options.logger ?? new NoopLogger();
-  }
-  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
-    let stmt;
-    try {
-      stmt = this.client.prepare(query.sql);
-    } catch (e) {
-      throw new DrizzleQueryError(query.sql, query.params, e);
-    }
-    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
-      all: (params) => {
-        stmt.setReturnArrays(mode === "arrays");
-        const res = stmt.all(...params);
-        if (mode === "objects") return res.map((row) => ({ ...row }));
-        return res;
-      },
-      get: (params) => {
-        stmt.setReturnArrays(mode === "arrays");
-        const res = stmt.get(...params);
-        if (res && mode === "objects") return { ...res };
-        return res;
-      },
-      run: (params) => {
-        stmt.setReturnArrays(false);
-        return stmt.run(...params);
-      },
-      values: (params) => {
-        stmt.setReturnArrays(true);
-        return stmt.all(...params);
-      }
-    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0);
-  }
-  transaction(transaction, config2 = {}) {
-    const tx = new NodeSQLiteTransaction("sync", this.dialect, this, this.relations);
-    this.run(sql.raw(`begin${config2.behavior ? ` ${config2.behavior}` : ""}`));
-    try {
-      const result = transaction(tx);
-      this.run(sql`commit`);
-      return result;
-    } catch (err) {
-      this.run(sql`rollback`);
-      throw err;
-    }
-  }
-};
-var NodeSQLiteTransaction = class NodeSQLiteTransaction2 extends SQLiteAsyncTransaction {
-  static [entityKind] = "SQLJsTransaction";
-  transaction(transaction) {
-    const savepointName = `sp${this.nestedIndex + 1}`;
-    const tx = new NodeSQLiteTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
-    tx.run(sql.raw(`savepoint ${savepointName}`));
-    try {
-      const result = transaction(tx);
-      tx.run(sql.raw(`release savepoint ${savepointName}`));
-      return result;
-    } catch (err) {
-      tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
-      throw err;
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/node-sqlite/driver.js
-import { DatabaseSync } from "node:sqlite";
-var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
-  static [entityKind] = "NodeSQLiteDatabase";
-};
-function construct(client2, config2 = {}) {
-  const dialect = new SQLiteDialect({ useJitMappers: jitCompatCheck(config2.jit) });
-  let logger;
-  if (config2.logger === true) logger = new DefaultLogger();
-  else if (config2.logger !== false) logger = config2.logger;
-  const relations = config2.relations ?? {};
-  const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client2, dialect, relations, { logger }), relations);
-  db.$client = client2;
-  return db;
-}
-function drizzle(...params) {
-  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
-  const { connection, client: client2, ...config2 } = params[0];
-  if (client2) return construct(client2, config2);
-  if (typeof connection === "object") {
-    const { path: path2, ...options } = connection;
-    return construct(new DatabaseSync(path2 ?? ":memory:", options), config2);
-  }
-  return construct(new DatabaseSync(connection ?? ":memory:"), config2);
-}
-(function(_drizzle) {
-  function mock(config2) {
-    return construct({}, config2);
-  }
-  _drizzle.mock = mock;
-})(drizzle || (drizzle = {}));
-
-// src/generated/acp-session-store-migrations.ts
-var acpSessionStoreMigrations = [
-  {
-    "name": "0000_slimy_captain_midlands.sql",
-    "sql": "CREATE TABLE `acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL,\n	`agent_id` text NOT NULL,\n	`native_session_id` text NOT NULL,\n	`cwd` text NOT NULL,\n	`additional_directories` text NOT NULL,\n	`prompted` integer NOT NULL,\n	`title` text NOT NULL,\n	`updated_at` text NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE `deleted_acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL\n);\n"
-  },
-  {
-    "name": "0001_regular_ultimates.sql",
-    "sql": "ALTER TABLE `acp_session` ADD `last_terminal_command_id` text;"
-  },
-  {
-    "name": "0002_equal_black_queen.sql",
-    "sql": "CREATE TABLE `session_event_v2` (\n	`event_id` text PRIMARY KEY NOT NULL,\n	`event_json` text NOT NULL,\n	`position` integer NOT NULL,\n	`session_id` text NOT NULL\n);\n--> statement-breakpoint\nCREATE UNIQUE INDEX `session_event_v2_session_position_unique` ON `session_event_v2` (`session_id`,`position`);--> statement-breakpoint\nCREATE INDEX `session_event_v2_session_position_index` ON `session_event_v2` (`session_id`,`position`);"
-  },
-  {
-    "name": "0003_silky_ravenous.sql",
-    "sql": "DROP TABLE `session_event_v2`;"
-  },
-  {
-    "name": "0004_special_mathemanic.sql",
-    "sql": "DROP TABLE `deleted_acp_session`;--> statement-breakpoint\nALTER TABLE `acp_session` DROP COLUMN `last_terminal_command_id`;"
-  }
-];
-
 // src/schema/acp-session-store/acp-session.ts
 var acpSession = sqliteTable("acp_session", {
   sessionId: text("session_id").primaryKey(),
@@ -30081,6 +30037,216 @@ var acpSession = sqliteTable("acp_session", {
   updatedAt: text("updated_at").notNull()
 });
 
+// src/schema/session-event-cache/session-event-v2.ts
+var sessionEventV2 = sqliteTable(
+  "session_event_v2",
+  {
+    eventJson: text("event_json").notNull(),
+    generationId: text("generation_id").notNull(),
+    position: integer2("position").notNull(),
+    sessionId: text("session_id").notNull()
+  },
+  (table) => [
+    primaryKey({ columns: [table.generationId, table.sessionId, table.position] }),
+    index("session_event_v2_generation_session_position_index").on(
+      table.generationId,
+      table.sessionId,
+      table.position
+    )
+  ]
+);
+
+// src/acp/session-event-store-v2.ts
+var HOT_EVENT_HIGH_WATER_MARK = 256;
+var HOT_EVENT_RETENTION = 128;
+function eventPage(eventCount, eventLimit, cursor, read) {
+  const parsedCursor = cursor === null ? eventCount : Number(cursor);
+  if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0 || parsedCursor > eventCount) {
+    throw new Error("The native event cursor is invalid");
+  }
+  const endPosition = parsedCursor;
+  const startPosition = Math.max(0, endPosition - eventLimit);
+  return {
+    events: read(startPosition + 1, endPosition),
+    nextCursor: startPosition === 0 ? null : startPosition.toString(),
+    startPosition: startPosition + 1,
+    truncated: startPosition > 0
+  };
+}
+var MemoryAcpSessionEventStoreV2 = class {
+  generationId;
+  #events = /* @__PURE__ */ new Map();
+  constructor(generationId) {
+    this.generationId = generationId;
+  }
+  append = (sessionId, event) => {
+    const events = this.#events.get(sessionId) ?? [];
+    events.push(event);
+    this.#events.set(sessionId, events);
+    return events.length;
+  };
+  close = () => this.#events.clear();
+  page = (sessionId, eventLimit, cursor) => {
+    const events = this.#events.get(sessionId) ?? [];
+    return eventPage(
+      events.length,
+      eventLimit,
+      cursor,
+      (startPosition, endPosition) => events.slice(startPosition - 1, endPosition)
+    );
+  };
+  remove = (sessionId) => {
+    this.#events.delete(sessionId);
+  };
+  reset = this.remove;
+};
+var cachedEventRowSchema = external_exports.object({ eventJson: external_exports.string(), position: external_exports.number().int().positive() });
+function decodeCachedEvent(value) {
+  const payload = external_exports.record(external_exports.string(), external_exports.unknown()).parse(value);
+  const event = decodeSessionEventV2({
+    ...payload,
+    eventId: "cached-event",
+    position: "1",
+    provenance: { kind: "original" },
+    recordedAt: "1970-01-01T00:00:00.000Z",
+    sessionId: "cached-session"
+  });
+  return event.type === "acp" ? { payload: event.payload, type: event.type } : { payload: event.payload, type: event.type };
+}
+var CachedAcpSessionEventStoreV2 = class {
+  generationId;
+  #database;
+  #ignoredPersistedSessions = /* @__PURE__ */ new Set();
+  #localDatabase;
+  #sessions = /* @__PURE__ */ new Map();
+  #flushSchedule = { kind: "idle" };
+  #isLocalDBAvailable = true;
+  constructor(localDatabase, generationId) {
+    this.generationId = generationId;
+    this.#localDatabase = localDatabase;
+    this.#database = localDatabase.orm;
+    try {
+      this.#localDatabase.transaction(() => this.#database.delete(sessionEventV2).run());
+    } catch (error62) {
+      this.#localDatabase.close();
+      throw error62;
+    }
+  }
+  append = (sessionId, event) => {
+    if (this.#flushSchedule.kind === "closed") {
+      throw new Error("The V2 Session event store is closed");
+    }
+    const session = this.#sessions.get(sessionId) ?? { hot: [], nextPosition: 1 };
+    const position = session.nextPosition;
+    session.hot.push({ event, position });
+    session.nextPosition += 1;
+    this.#sessions.set(sessionId, session);
+    if (session.hot.length > HOT_EVENT_HIGH_WATER_MARK) {
+      this.#scheduleFlush();
+    }
+    return position;
+  };
+  #scheduleFlush = () => {
+    if (!this.#isLocalDBAvailable || this.#flushSchedule.kind !== "idle") {
+      return;
+    }
+    const handle = setImmediate(() => {
+      if (this.#flushSchedule.kind !== "scheduled" || this.#flushSchedule.handle !== handle) {
+        return;
+      }
+      this.#flushSchedule = { kind: "idle" };
+      this.#flush(false);
+    });
+    this.#flushSchedule = { handle, kind: "scheduled" };
+  };
+  #flush = (includeHotTail) => {
+    if (!this.#isLocalDBAvailable || this.#flushSchedule.kind === "closed") {
+      return;
+    }
+    const batches = [...this.#sessions.entries()].flatMap(([sessionId, session]) => {
+      const count = includeHotTail ? session.hot.length : Math.max(0, session.hot.length - HOT_EVENT_RETENTION);
+      return count === 0 ? [] : [{ count, events: session.hot.slice(0, count), sessionId }];
+    });
+    const values = batches.flatMap(
+      (batch) => batch.events.map(({ event, position }) => ({
+        eventJson: JSON.stringify(event),
+        generationId: this.generationId,
+        position,
+        sessionId: batch.sessionId
+      }))
+    );
+    if (values.length === 0) {
+      return;
+    }
+    try {
+      this.#localDatabase.transaction(() => {
+        for (let offset = 0; offset < values.length; offset += 200) {
+          this.#database.insert(sessionEventV2).values(values.slice(offset, offset + 200)).run();
+        }
+      });
+      for (const batch of batches) {
+        this.#sessions.get(batch.sessionId)?.hot.splice(0, batch.count);
+      }
+    } catch (cause) {
+      this.#isLocalDBAvailable = false;
+      console.warn("Mobius V2 Session event cache writes are unavailable; retaining events in memory", cause);
+    }
+  };
+  page = (sessionId, eventLimit, cursor) => {
+    const session = this.#sessions.get(sessionId);
+    const eventCount = (session?.nextPosition ?? 1) - 1;
+    return eventPage(eventCount, eventLimit, cursor, (startPosition, endPosition) => {
+      const persisted = this.#ignoredPersistedSessions.has(sessionId) ? [] : this.#database.select({ eventJson: sessionEventV2.eventJson, position: sessionEventV2.position }).from(sessionEventV2).where(
+        and(
+          eq(sessionEventV2.generationId, this.generationId),
+          eq(sessionEventV2.sessionId, sessionId),
+          gte(sessionEventV2.position, startPosition),
+          lte(sessionEventV2.position, endPosition)
+        )
+      ).orderBy(asc(sessionEventV2.position)).all().map((value) => {
+        const row = cachedEventRowSchema.parse(value);
+        return { event: decodeCachedEvent(JSON.parse(row.eventJson)), position: row.position };
+      });
+      const hot = (session?.hot ?? []).filter(
+        ({ position }) => position >= startPosition && position <= endPosition
+      );
+      return [...persisted, ...hot].toSorted((left, right) => left.position - right.position).map(({ event }) => event);
+    });
+  };
+  #deletePersisted = (sessionId) => {
+    if (!this.#isLocalDBAvailable) {
+      this.#ignoredPersistedSessions.add(sessionId);
+      return;
+    }
+    try {
+      this.#database.delete(sessionEventV2).where(and(eq(sessionEventV2.generationId, this.generationId), eq(sessionEventV2.sessionId, sessionId))).run();
+      this.#ignoredPersistedSessions.delete(sessionId);
+    } catch (cause) {
+      this.#isLocalDBAvailable = false;
+      this.#ignoredPersistedSessions.add(sessionId);
+      console.warn("Mobius V2 Session event cache writes are unavailable; retaining events in memory", cause);
+    }
+  };
+  remove = (sessionId) => {
+    this.#deletePersisted(sessionId);
+    this.#sessions.delete(sessionId);
+  };
+  reset = this.remove;
+  close = () => {
+    if (this.#flushSchedule.kind === "closed") {
+      return;
+    }
+    if (this.#flushSchedule.kind === "scheduled") {
+      clearImmediate(this.#flushSchedule.handle);
+    }
+    this.#flushSchedule = { kind: "idle" };
+    this.#flush(true);
+    this.#flushSchedule = { kind: "closed" };
+    this.#localDatabase.close();
+    this.#sessions.clear();
+  };
+};
+
 // src/acp/session-store.ts
 var AcpStoredSession = class {
   additionalDirectories;
@@ -30116,9 +30282,14 @@ var FoundAcpStoredSession = class extends AcpStoredSessionLookup {
   }
 };
 var MemoryAcpSessionStore = class {
+  eventsV2;
   #sessions = /* @__PURE__ */ new Map();
+  constructor(eventsV2 = new MemoryAcpSessionEventStoreV2(randomUUID())) {
+    this.eventsV2 = eventsV2;
+  }
   close = () => {
     this.#sessions.clear();
+    this.eventsV2.close();
   };
   findNative = (agentId, nativeSessionId) => [...this.#sessions.values()].filter(
     (session) => session.agentId === agentId && session.nativeSessionId === nativeSessionId
@@ -30130,6 +30301,7 @@ var MemoryAcpSessionStore = class {
   };
   remove = (sessionId) => {
     this.#sessions.delete(sessionId);
+    this.eventsV2.remove(sessionId);
   };
   write = (session) => {
     this.#sessions.set(session.sessionId, session);
@@ -30161,39 +30333,20 @@ function decodeStoredSession(value) {
   );
 }
 var SqliteAcpSessionStore = class {
+  eventsV2;
   #database;
-  #sqliteDatabase;
-  constructor(path2) {
-    mkdirSync(dirname(path2), { mode: 448, recursive: true });
-    this.#sqliteDatabase = new DatabaseSync2(path2);
-    chmodSync(path2, 384);
-    this.#migrate();
-    this.#database = drizzle({ client: this.#sqliteDatabase });
+  #localDatabase;
+  constructor(localDatabase, eventsV2 = new MemoryAcpSessionEventStoreV2(randomUUID())) {
+    this.eventsV2 = eventsV2;
+    this.#localDatabase = localDatabase;
+    this.#database = localDatabase.orm;
   }
-  #migrate = () => {
-    const version2 = external_exports.object({ user_version: external_exports.number().int().nonnegative() }).parse(this.#sqliteDatabase.prepare("PRAGMA user_version").get()).user_version;
-    if (version2 > acpSessionStoreMigrations.length) {
-      this.#sqliteDatabase.close();
-      throw new Error("The ACP Session database was created by a newer Mobius version");
-    }
-    for (let index = version2; index < acpSessionStoreMigrations.length; index += 1) {
-      const migration = acpSessionStoreMigrations[index];
-      if (migration === void 0) {
-        throw new Error("The ACP Session migration is unavailable");
-      }
-      this.#sqliteDatabase.exec("BEGIN IMMEDIATE");
-      try {
-        this.#sqliteDatabase.exec(migration.sql);
-        this.#sqliteDatabase.exec(`PRAGMA user_version = ${index + 1}`);
-        this.#sqliteDatabase.exec("COMMIT");
-      } catch (error62) {
-        this.#sqliteDatabase.exec("ROLLBACK");
-        throw error62;
-      }
-    }
-  };
   close = () => {
-    this.#sqliteDatabase.close();
+    try {
+      this.#localDatabase.close();
+    } finally {
+      this.eventsV2.close();
+    }
   };
   findNative = (agentId, nativeSessionId) => this.#database.select().from(acpSession).where(and(eq(acpSession.agentId, agentId), eq(acpSession.nativeSessionId, nativeSessionId))).all().map(decodeStoredSession);
   list = () => this.#database.select().from(acpSession).orderBy(desc(acpSession.updatedAt)).all().map(decodeStoredSession);
@@ -30203,6 +30356,7 @@ var SqliteAcpSessionStore = class {
   };
   remove = (sessionId) => {
     this.#database.delete(acpSession).where(eq(acpSession.sessionId, sessionId)).run();
+    this.eventsV2.remove(sessionId);
   };
   write = (session) => {
     const value = {
@@ -30228,7 +30382,7 @@ var RetryableAcpInitializationError = class extends AcpExecutionError {
   }
 };
 function arraysEqual(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
+  return left.length === right.length && left.every((value, index2) => value === right[index2]);
 }
 function recordsEqual(left, right) {
   const leftEntries = Object.entries(left);
@@ -30391,12 +30545,17 @@ var AgentSession = class _AgentSession {
       );
     }
     const history = await this.#completedHistory(signal, "ACP agent exited while loading history");
-    return history.eventPage(eventLimit, cursor, this.#turnHistory);
+    return history.eventPage(eventLimit, cursor);
   };
   async #completedHistory(signal, exitMessage) {
     if (!this.#prompted && this.#nativeHistoryOwnership.kind === "fresh-session") {
       if (this.#sessionLoad.kind === "not-requested") {
-        this.#sessionLoad = { history: new AcpHistoryReplay(), kind: "loaded", response: {} };
+        this.#store.eventsV2.reset(this.#mobiusSessionId);
+        this.#sessionLoad = {
+          history: new AcpHistoryReplay(this.#store.eventsV2, this.#mobiusSessionId),
+          kind: "loaded",
+          response: {}
+        };
       }
       if (this.#sessionLoad.kind === "loaded") {
         return this.#sessionLoad.history;
@@ -30411,7 +30570,8 @@ var AgentSession = class _AgentSession {
     if (this.#sessionLoad.kind === "capturing") {
       return await waitForSharedOperation(this.#sessionLoad.completion, signal);
     }
-    const history = new AcpHistoryReplay();
+    this.#store.eventsV2.reset(this.#mobiusSessionId);
+    const history = new AcpHistoryReplay(this.#store.eventsV2, this.#mobiusSessionId);
     const completion = Promise.resolve().then(async () => {
       try {
         const response = await this.race(
@@ -30886,7 +31046,7 @@ var AgentSession = class _AgentSession {
       this.prepareAgentContent
     );
     this.#turn = running;
-    this.#turnHistory = completedHistory === null ? null : new AcpHistoryReplay();
+    this.#turnHistory = completedHistory === null ? null : new AcpHistoryReplay(this.#store.eventsV2, this.#mobiusSessionId);
     const lifecycleV2 = options.lifecycleV2;
     if (lifecycleV2 !== void 0) {
       await this.#recordLifecycleEventV2({
@@ -31099,7 +31259,7 @@ var AgentSession = class _AgentSession {
     if (event.type !== "lifecycle-metadata" || this.#sessionLoad.kind !== "loaded") {
       return;
     }
-    const position = this.#turnHistory === null ? this.#sessionLoad.history.recordLifecycle(event) : this.#sessionLoad.history.eventCount() + this.#turnHistory.recordLifecycle(event);
+    const position = this.#turnHistory === null ? this.#sessionLoad.history.recordLifecycle(event) : this.#turnHistory.recordLifecycle(event);
     await this.#getObserver().onSessionEventV2?.(this.#mobiusSessionId, event, position);
   };
   selectNativeSession = (sessionId) => {
@@ -31120,13 +31280,8 @@ var AgentSession = class _AgentSession {
     } else {
       const onSessionEventV2 = this.#getObserver().onSessionEventV2;
       if (this.#turnHistory !== null) {
-        const completedEventCount = this.#sessionLoad.kind === "loaded" ? this.#sessionLoad.history.eventCount() : 0;
-        await this.#turnHistory.record(update, rawUpdate, async (turnPosition) => {
-          await onSessionEventV2?.(
-            this.#mobiusSessionId,
-            { payload: rawUpdate, type: "acp" },
-            completedEventCount + turnPosition
-          );
+        await this.#turnHistory.record(update, rawUpdate, async (position) => {
+          await onSessionEventV2?.(this.#mobiusSessionId, { payload: rawUpdate, type: "acp" }, position);
         });
       } else if (this.#sessionLoad.kind === "loaded") {
         await this.#sessionLoad.history.record(update, rawUpdate, async (position) => {
@@ -31769,9 +31924,9 @@ var AcpContentExternalizer = class {
 };
 
 // src/external-content/local-external-content-store.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
 import { lstat, mkdir, readdir as readdir2, realpath as realpath3, rename, rm, stat as stat3, utimes, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { dirname, join as join4 } from "node:path";
 var contentRequest = /^mobius-content:(image|audio|resource):([a-f0-9]{64})$/u;
 var CONTENT_LIFETIME_MILLISECONDS = 24 * 60 * 60 * 1e3;
 var metadataSchema2 = external_exports.strictObject({
@@ -31790,7 +31945,7 @@ var UnretainedExternalContentStore = class {
   };
 };
 async function atomicWrite(path2, bytes, signal) {
-  const temporary = `${path2}.${randomUUID()}.tmp`;
+  const temporary = `${path2}.${randomUUID2()}.tmp`;
   try {
     await writeFile(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -31807,7 +31962,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join4(stateDirectory, "tmp", "session-content", randomUUID());
+    this.#root = join4(stateDirectory, "tmp", "session-content", randomUUID2());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -31818,11 +31973,11 @@ var LocalExternalContentStore = class {
       await mkdir(this.#root, { mode: 448, recursive: true });
       const now = /* @__PURE__ */ new Date();
       await utimes(this.#root, now, now);
-      for (const directory of await readdir2(dirname2(this.#root), { withFileTypes: true })) {
+      for (const directory of await readdir2(dirname(this.#root), { withFileTypes: true })) {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path2 = join4(dirname2(this.#root), directory.name);
+        const path2 = join4(dirname(this.#root), directory.name);
         if (path2 === this.#root) {
           continue;
         }
@@ -31908,12 +32063,12 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath3(dirname2(entry.path)),
+        realpath3(dirname(entry.path)),
         realpath3(entry.path),
         lstat(entry.path)
       ]);
       signal.throwIfAborted();
-      if (!file2.isFile() || file2.isSymbolicLink() || dirname2(resolvedPath) !== resolvedDirectory) {
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname(resolvedPath) !== resolvedDirectory) {
         return null;
       }
       return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
@@ -31990,9 +32145,9 @@ var AcpProcessCapacityLock = class {
       return await waiter.completion.promise;
     } finally {
       signal.removeEventListener("abort", waiter.cancel);
-      const index = this.#waiters.indexOf(waiter);
-      if (index >= 0) {
-        this.#waiters.splice(index, 1);
+      const index2 = this.#waiters.indexOf(waiter);
+      if (index2 >= 0) {
+        this.#waiters.splice(index2, 1);
       }
     }
   };
@@ -32979,7 +33134,7 @@ var LocalAgentInventory = class {
 
 // src/agent-installation/managed-npm-package.ts
 import { mkdir as mkdir2, mkdtemp, open as open3, realpath as realpath4, rename as rename2, rm as rm2, stat as stat4 } from "node:fs/promises";
-import { delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative, sep } from "node:path";
+import { delimiter, dirname as dirname2, isAbsolute as isAbsolute2, join as join5, relative, sep } from "node:path";
 var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
 var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -33209,7 +33364,7 @@ var ManagedNpmPackageInstaller = class {
         throw error62;
       }
     }
-    const parent = dirname3(root);
+    const parent = dirname2(root);
     await mkdir2(parent, { mode: 448, recursive: true });
     const staging = await mkdtemp(join5(parent, `.${definition.version}.staging-`));
     try {
@@ -33244,7 +33399,7 @@ var ManagedNpmPackageInstaller = class {
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
         NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
-        PATH: `${dirname3(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
+        PATH: `${dirname2(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
       };
       if (definition.includeOptionalDependencies) {
         installEnvironment["NPM_CONFIG_INCLUDE"] = "optional";
@@ -35729,7 +35884,7 @@ import { join as join11 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { chmod, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath7, rename as rename3, rm as rm3, stat as stat6, writeFile as writeFile3 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname4, isAbsolute as isAbsolute6, join as join10, relative as relative3, sep as sep3 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute6, join as join10, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch } from "undici";
@@ -36588,9 +36743,9 @@ function comparePrerelease(left, right) {
   if (left.length === 0 || right.length === 0) {
     return left.length === right.length ? 0 : left.length === 0 ? 1 : -1;
   }
-  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
-    const leftPart = left[index];
-    const rightPart = right[index];
+  for (let index2 = 0; index2 < Math.max(left.length, right.length); index2 += 1) {
+    const leftPart = left[index2];
+    const rightPart = right[index2];
     if (leftPart === void 0 || rightPart === void 0) {
       return leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : 1;
     }
@@ -36615,8 +36770,8 @@ function compareAgentVersions(left, right) {
   if (parsedLeft === null || parsedRight === null) {
     return null;
   }
-  for (let index = 0; index < Math.max(parsedLeft.core.length, parsedRight.core.length); index += 1) {
-    const difference = (parsedLeft.core[index] ?? 0) - (parsedRight.core[index] ?? 0);
+  for (let index2 = 0; index2 < Math.max(parsedLeft.core.length, parsedRight.core.length); index2 += 1) {
+    const difference = (parsedLeft.core[index2] ?? 0) - (parsedRight.core[index2] ?? 0);
     if (difference !== 0) {
       return Math.sign(difference);
     }
@@ -37037,9 +37192,9 @@ async function discoverLocalAgentInventory(options) {
 }
 
 // src/storage/runtime-installation-store.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir5, open as open5, readdir as readdir3, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname5, join as join16, resolve as resolve4 } from "node:path";
+import { dirname as dirname4, join as join16, resolve as resolve4 } from "node:path";
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
 var CONNECTION_ID_PATTERN = /^mcn_[a-f0-9]{32}$/;
 var INSTALLATION_ID_PATTERN = /^min_[a-f0-9]{32}$/;
@@ -37167,10 +37322,10 @@ function parseRelayOrigin(value) {
   return origin;
 }
 function connectionId() {
-  return `mcn_${randomUUID2().replaceAll("-", "")}`;
+  return `mcn_${randomUUID3().replaceAll("-", "")}`;
 }
 function installationId() {
-  return `min_${randomUUID2().replaceAll("-", "")}`;
+  return `min_${randomUUID3().replaceAll("-", "")}`;
 }
 function channelIndexFileName(channelId) {
   return `mci_${createHash3("sha256").update(channelId).digest("hex")}.json`;
@@ -37281,8 +37436,8 @@ async function readJsonFile(path2, signal, missingCode) {
 }
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
-  const directory = dirname5(path2);
-  const temporaryPath = join16(directory, `.${randomUUID2()}.tmp`);
+  const directory = dirname4(path2);
+  const temporaryPath = join16(directory, `.${randomUUID3()}.tmp`);
   try {
     await mkdir5(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -37359,16 +37514,16 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
   #readConnectionForChannel = async (channelId, signal) => {
     const normalizedChannelId = validateIdentifier(channelId, "invalid_channel_id");
-    const index = decodeChannelIndex(
+    const index2 = decodeChannelIndex(
       await readJsonFile(this.channelIndexPath(normalizedChannelId), signal, "connection_not_found")
     );
-    if (index.applicationId !== this.applicationId || index.installationId !== this.installationId || index.channelId !== normalizedChannelId) {
+    if (index2.applicationId !== this.applicationId || index2.installationId !== this.installationId || index2.channelId !== normalizedChannelId) {
       throw new RuntimeInstallationStoreError(
         "connection_owner_mismatch",
         "The saved Runtime connection belongs to another installation"
       );
     }
-    return await this.readConnection(index.connectionId, signal);
+    return await this.readConnection(index2.connectionId, signal);
   };
   saveConnection = async (input2, signal) => {
     const stored = new VerifiedRuntimeConnection(
@@ -37563,16 +37718,16 @@ function hasExactKeys2(value, expectedKeys) {
 }
 function readSingleOption(arguments_, option) {
   const values = [];
-  for (let index = 0; index < arguments_.length; index += 1) {
-    if (arguments_[index] !== option) {
+  for (let index2 = 0; index2 < arguments_.length; index2 += 1) {
+    if (arguments_[index2] !== option) {
       continue;
     }
-    const value = arguments_[index + 1];
+    const value = arguments_[index2 + 1];
     if (value === void 0 || value.startsWith("--")) {
       throw new PairingClientError("invalid_arguments", `${option} requires a value`);
     }
     values.push(value);
-    index += 1;
+    index2 += 1;
   }
   if (values.length !== 1) {
     throw new PairingClientError("invalid_arguments", `${option} must be provided exactly once`);
@@ -37580,8 +37735,8 @@ function readSingleOption(arguments_, option) {
   return values[0] ?? "";
 }
 function assertKnownArguments(arguments_) {
-  for (let index = 0; index < arguments_.length; index += 2) {
-    const option = arguments_[index];
+  for (let index2 = 0; index2 < arguments_.length; index2 += 2) {
+    const option = arguments_[index2];
     if (option !== "--url" && option !== "--code" && option !== "--pairing" && option !== "--workspace") {
       throw new PairingClientError("invalid_arguments", `Unknown pairing option: ${option ?? "missing option"}`);
     }
@@ -37872,7 +38027,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID10 } from "node:crypto";
 import { join as join19 } from "node:path";
 import { styleText } from "node:util";
 
@@ -38451,7 +38606,7 @@ var FixedInstallationExecutor = class {
 // src/authorization/workspace-directory.ts
 import { readdir as readdir4, realpath as realpath9, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute9, join as join17, normalize as normalize3, relative as relative4 } from "node:path";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute9, join as join17, normalize as normalize3, relative as relative4 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
   directoryLabel;
@@ -38579,7 +38734,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname6(target);
+      const parent = dirname5(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -38604,7 +38759,7 @@ var WorkspaceDirectoryService = class {
 };
 
 // src/daemon-diagnostic-log.ts
-import { appendFileSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
+import { appendFileSync, mkdirSync, readFileSync as readFileSync2, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
 import { join as join18 } from "node:path";
 var MAXIMUM_DAEMON_LOG_BYTES = 1 * 1024 * 1024;
 var DaemonDiagnosticLog = class {
@@ -38620,7 +38775,7 @@ var DaemonDiagnosticLog = class {
     const encoded = `${diagnostic.replace(/[\r\n]+/gu, " ").trim()}
 `;
     const encodedBytes = Buffer.byteLength(encoded);
-    mkdirSync2(this.#directory, { mode: 448, recursive: true });
+    mkdirSync(this.#directory, { mode: 448, recursive: true });
     let existingBytes = 0;
     try {
       existingBytes = statSync3(this.#path).size;
@@ -39085,7 +39240,7 @@ var DaemonInstallationObserver = class {
 };
 
 // src/daemon-active-turn.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 function activeMessageCharacters(message) {
   return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
 }
@@ -39093,8 +39248,8 @@ var ACTIVE_TURN_TEXT_CHUNK_LIMIT = Math.floor(SESSION_HISTORY_CHARACTER_LIMIT /
 function boundedRecoveryMessages(messages) {
   const selected = [];
   let remainingCharacters = SESSION_HISTORY_CHARACTER_LIMIT;
-  for (let index = messages.length - 1; index >= 0 && selected.length < SESSION_HISTORY_MESSAGE_LIMIT; index -= 1) {
-    const message = messages[index];
+  for (let index2 = messages.length - 1; index2 >= 0 && selected.length < SESSION_HISTORY_MESSAGE_LIMIT; index2 -= 1) {
+    const message = messages[index2];
     if (message === void 0) {
       break;
     }
@@ -39119,7 +39274,7 @@ var ActiveDaemonTurn = class {
   #timeline;
   #sequence = 0;
   #interaction = null;
-  #epoch = decodeIdentifier(randomUUID3());
+  #epoch = decodeIdentifier(randomUUID4());
   constructor(command, attemptId) {
     this.attemptId = attemptId;
     this.command = command;
@@ -39181,7 +39336,7 @@ var ActiveDaemonTurn = class {
       if (!this.#activities.has(event.activityId)) {
         this.#timeline = [
           ...this.#timeline,
-          { activityId: event.activityId, id: decodeIdentifier(randomUUID3()), kind: "activity" }
+          { activityId: event.activityId, id: decodeIdentifier(randomUUID4()), kind: "activity" }
         ];
       }
       this.#activities.set(event.activityId, {
@@ -39202,7 +39357,7 @@ var ActiveDaemonTurn = class {
       if (previous === void 0) {
         this.#timeline = [
           ...this.#timeline,
-          { activityId: event.activityId, id: decodeIdentifier(randomUUID3()), kind: "activity" }
+          { activityId: event.activityId, id: decodeIdentifier(randomUUID4()), kind: "activity" }
         ];
       }
       this.#activities.set(event.activityId, {
@@ -39227,7 +39382,7 @@ var ActiveDaemonTurn = class {
           ...this.#timeline,
           {
             content: /* @__PURE__ */ new Map([[event.contentId, event.content]]),
-            id: decodeIdentifier(randomUUID3()),
+            id: decodeIdentifier(randomUUID4()),
             kind: "message",
             sourceMessageId: event.messageId,
             text: ""
@@ -39235,7 +39390,7 @@ var ActiveDaemonTurn = class {
         ];
       } else {
         this.#timeline = this.#timeline.map(
-          (entry, index) => index === target && entry.kind === "message" ? { ...entry, content: new Map([...entry.content, [event.contentId, event.content]]) } : entry
+          (entry, index2) => index2 === target && entry.kind === "message" ? { ...entry, content: new Map([...entry.content, [event.contentId, event.content]]) } : entry
         );
       }
     } else if (event.kind === SESSION_PERMISSION_REQUESTED_KIND || event.kind === SESSION_ELICITATION_REQUESTED_KIND) {
@@ -39267,7 +39422,7 @@ var ActiveDaemonTurn = class {
         ...this.#timeline,
         {
           content: /* @__PURE__ */ new Map(),
-          id: decodeIdentifier(randomUUID3()),
+          id: decodeIdentifier(randomUUID4()),
           kind: "message",
           sourceMessageId: messageId,
           text: remaining.slice(0, ACTIVE_TURN_TEXT_CHUNK_LIMIT)
@@ -39538,6 +39693,202 @@ var DaemonTurnRegistry = class {
   };
 };
 
+// src/generated/acp-session-store-migrations.ts
+var acpSessionStoreMigrations = [
+  {
+    "name": "0000_slimy_captain_midlands.sql",
+    "sql": "CREATE TABLE `acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL,\n	`agent_id` text NOT NULL,\n	`native_session_id` text NOT NULL,\n	`cwd` text NOT NULL,\n	`additional_directories` text NOT NULL,\n	`prompted` integer NOT NULL,\n	`title` text NOT NULL,\n	`updated_at` text NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE `deleted_acp_session` (\n	`session_id` text PRIMARY KEY NOT NULL\n);\n"
+  },
+  {
+    "name": "0001_regular_ultimates.sql",
+    "sql": "ALTER TABLE `acp_session` ADD `last_terminal_command_id` text;"
+  },
+  {
+    "name": "0002_equal_black_queen.sql",
+    "sql": "CREATE TABLE `session_event_v2` (\n	`event_id` text PRIMARY KEY NOT NULL,\n	`event_json` text NOT NULL,\n	`position` integer NOT NULL,\n	`session_id` text NOT NULL\n);\n--> statement-breakpoint\nCREATE UNIQUE INDEX `session_event_v2_session_position_unique` ON `session_event_v2` (`session_id`,`position`);--> statement-breakpoint\nCREATE INDEX `session_event_v2_session_position_index` ON `session_event_v2` (`session_id`,`position`);"
+  },
+  {
+    "name": "0003_silky_ravenous.sql",
+    "sql": "DROP TABLE `session_event_v2`;"
+  },
+  {
+    "name": "0004_special_mathemanic.sql",
+    "sql": "DROP TABLE `deleted_acp_session`;--> statement-breakpoint\nALTER TABLE `acp_session` DROP COLUMN `last_terminal_command_id`;"
+  }
+];
+
+// src/generated/session-event-cache-migrations.ts
+var sessionEventCacheMigrations = [
+  {
+    "name": "migration.sql",
+    "sql": "CREATE TABLE `session_event_v2` (\n	`event_json` text NOT NULL,\n	`generation_id` text NOT NULL,\n	`position` integer NOT NULL,\n	`session_id` text NOT NULL,\n	CONSTRAINT `session_event_v2_pk` PRIMARY KEY(`generation_id`, `session_id`, `position`)\n);\n--> statement-breakpoint\nCREATE INDEX `session_event_v2_generation_session_position_index` ON `session_event_v2` (`generation_id`,`session_id`,`position`);"
+  }
+];
+
+// src/infra/local-sqlite-database.ts
+import { chmodSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/node-sqlite/session.js
+var NodeSQLiteSession = class extends SQLiteAsyncSession {
+  static [entityKind] = "SQLJsSession";
+  logger;
+  constructor(client2, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client2;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.prepare(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, query.params, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: (params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.all(...params);
+        if (mode === "objects") return res.map((row) => ({ ...row }));
+        return res;
+      },
+      get: (params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.get(...params);
+        if (res && mode === "objects") return { ...res };
+        return res;
+      },
+      run: (params) => {
+        stmt.setReturnArrays(false);
+        return stmt.run(...params);
+      },
+      values: (params) => {
+        stmt.setReturnArrays(true);
+        return stmt.all(...params);
+      }
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0);
+  }
+  transaction(transaction, config2 = {}) {
+    const tx = new NodeSQLiteTransaction("sync", this.dialect, this, this.relations);
+    this.run(sql.raw(`begin${config2.behavior ? ` ${config2.behavior}` : ""}`));
+    try {
+      const result = transaction(tx);
+      this.run(sql`commit`);
+      return result;
+    } catch (err) {
+      this.run(sql`rollback`);
+      throw err;
+    }
+  }
+};
+var NodeSQLiteTransaction = class NodeSQLiteTransaction2 extends SQLiteAsyncTransaction {
+  static [entityKind] = "SQLJsTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new NodeSQLiteTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    tx.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      tx.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      throw err;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/node-sqlite/driver.js
+import { DatabaseSync } from "node:sqlite";
+var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
+  static [entityKind] = "NodeSQLiteDatabase";
+};
+function construct(client2, config2 = {}) {
+  const dialect = new SQLiteDialect({ useJitMappers: jitCompatCheck(config2.jit) });
+  let logger;
+  if (config2.logger === true) logger = new DefaultLogger();
+  else if (config2.logger !== false) logger = config2.logger;
+  const relations = config2.relations ?? {};
+  const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client2, dialect, relations, { logger }), relations);
+  db.$client = client2;
+  return db;
+}
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
+  const { connection, client: client2, ...config2 } = params[0];
+  if (client2) return construct(client2, config2);
+  if (typeof connection === "object") {
+    const { path: path2, ...options } = connection;
+    return construct(new DatabaseSync(path2 ?? ":memory:", options), config2);
+  }
+  return construct(new DatabaseSync(connection ?? ":memory:"), config2);
+}
+(function(_drizzle) {
+  function mock(config2) {
+    return construct({}, config2);
+  }
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+
+// src/infra/local-sqlite-database.ts
+var LocalSqliteDatabase = class {
+  orm;
+  #sqlite;
+  constructor(path2, label, migrations, pragmas = []) {
+    mkdirSync2(dirname6(path2), { mode: 448, recursive: true });
+    this.#sqlite = new DatabaseSync2(path2);
+    chmodSync(path2, 384);
+    try {
+      for (const pragma of pragmas) {
+        this.#sqlite.exec(pragma);
+      }
+      this.#migrate(label, migrations);
+      this.orm = drizzle({ client: this.#sqlite });
+    } catch (error62) {
+      this.#sqlite.close();
+      throw error62;
+    }
+  }
+  #migrate = (label, migrations) => {
+    const version2 = external_exports.object({ user_version: external_exports.number().int().nonnegative() }).parse(this.#sqlite.prepare("PRAGMA user_version").get()).user_version;
+    if (version2 > migrations.length) {
+      throw new Error(`The ${label} was created by a newer Mobius version`);
+    }
+    for (let index2 = version2; index2 < migrations.length; index2 += 1) {
+      const migration = migrations[index2];
+      if (migration === void 0) {
+        throw new Error(`The ${label} migration is unavailable`);
+      }
+      this.transaction(() => {
+        this.#sqlite.exec(migration.sql);
+        this.#sqlite.exec(`PRAGMA user_version = ${index2 + 1}`);
+      });
+    }
+  };
+  transaction = (operation) => {
+    this.#sqlite.exec("BEGIN IMMEDIATE");
+    try {
+      const result = operation();
+      this.#sqlite.exec("COMMIT");
+      return result;
+    } catch (error62) {
+      this.#sqlite.exec("ROLLBACK");
+      throw error62;
+    }
+  };
+  close = () => this.#sqlite.close();
+};
+
+// src/local-databases.ts
+var openAcpSessionDatabase = (path2) => new LocalSqliteDatabase(path2, "ACP Session database", acpSessionStoreMigrations);
+var openSessionEventCacheV2Database = (path2) => new LocalSqliteDatabase(path2, "V2 Session event cache", sessionEventCacheMigrations, [
+  "PRAGMA journal_mode = WAL",
+  "PRAGMA synchronous = OFF"
+]);
+
 // src/native-sessions/codex-history.ts
 import { spawn as spawn5 } from "node:child_process";
 var responseSchema = external_exports.union([
@@ -40242,7 +40593,7 @@ var readCodexFullHistory = async (agent, cwd, nativeSessionId, signal, nativeTur
 });
 
 // src/native-sessions/service.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var NativeSessionService = class {
   #entries = /* @__PURE__ */ new Map();
   #cursors = /* @__PURE__ */ new Map();
@@ -40301,7 +40652,7 @@ var NativeSessionService = class {
       if (authorized === null) {
         return null;
       }
-      const entryId = decodeIdentifier(randomUUID4());
+      const entryId = decodeIdentifier(randomUUID5());
       if (this.#entries.size >= 5e3) {
         this.#entries.clear();
       }
@@ -40357,7 +40708,7 @@ var NativeSessionService = class {
             "invalid_native_session_response"
           );
         }
-        nextCursor = decodeIdentifier(randomUUID4());
+        nextCursor = decodeIdentifier(randomUUID5());
         if (this.#cursors.size >= 500) {
           this.#cursors.clear();
         }
@@ -40535,7 +40886,7 @@ var NativeSessionService = class {
   resolveTarget = async (command, options, selected) => {
     let cursor = null;
     const visited = /* @__PURE__ */ new Set();
-    for (let index = 0; index < 100; index += 1) {
+    for (let index2 = 0; index2 < 100; index2 += 1) {
       const page = await this.#sessions.listNativeSessions(options, cursor);
       const info = page.sessions.find((entry) => entry.sessionId === selected.nativeSessionId);
       if (info !== void 0) {
@@ -40543,7 +40894,7 @@ var NativeSessionService = class {
         if (target === null) {
           throw new LocalAuthorizationError("The selected native session is not authorized");
         }
-        if (target.cwd !== selected.cwd || target.additionalDirectories.length !== selected.additionalDirectories.length || target.additionalDirectories.some((path2, index2) => path2 !== selected.additionalDirectories[index2])) {
+        if (target.cwd !== selected.cwd || target.additionalDirectories.length !== selected.additionalDirectories.length || target.additionalDirectories.some((path2, index3) => path2 !== selected.additionalDirectories[index3])) {
           throw new AcpExecutionError(
             "This session's directory changed. Refresh the list before continuing.",
             {},
@@ -40582,7 +40933,7 @@ var NativeSessionService = class {
 };
 
 // src/relay-connection/daemon-operation-state.ts
-import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID6 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 function isTerminal(state) {
   return state === "succeeded" || state === "failed" || state === "cancelled";
@@ -40599,7 +40950,7 @@ var DaemonOperationState = class {
       }
       return { attemptId: existing.attemptId, commandId, kind: "duplicate", state: existing.state };
     }
-    const attemptId = randomUUID5();
+    const attemptId = randomUUID6();
     this.#executions.set(commandId, { attemptId, commandHash, sessionId, state: "dispatching" });
     return { attemptId, commandId, kind: "accepted", state: "dispatching" };
   };
@@ -41563,7 +41914,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
     const replay = await sessions.loadSessionEventsV2(loadOptions, command.eventLimit, command.cursor);
     signal.throwIfAborted();
     const events = replay.events.map(
-      (event, index) => eventLogV2.event(command.sessionId, replay.startPosition + index, event, "1970-01-01T00:00:00.000Z")
+      (event, index2) => eventLogV2.event(command.sessionId, replay.startPosition + index2, event, "1970-01-01T00:00:00.000Z")
     );
     const tailCursor = events.at(-1)?.eventId ?? "";
     audit.record({
@@ -41614,7 +41965,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
 }
 
 // src/acp/session-config/apply-session-configuration.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 function invalidSessionConfiguration(message) {
   return new AcpExecutionError(message, {}, "invalid_session_configuration");
 }
@@ -41755,7 +42106,7 @@ async function applySessionConfigurationSelection(sessions, audit, options, sele
     booleanValue: selection.booleanValue,
     configId: selection.configId,
     cwd,
-    requestId: `cfg_${randomUUID6()}`,
+    requestId: `cfg_${randomUUID7()}`,
     sessionId,
     signal,
     value: selection.value,
@@ -42805,7 +43156,7 @@ function connectRelay(url2, signal) {
 }
 
 // src/relay-connection/liveness.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 var HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 1e4;
 var HEARTBEAT_INTERVAL_MILLISECONDS = 2e4;
 var RelayLivenessState = class {
@@ -42894,7 +43245,7 @@ var RelayConnectionLiveness = class {
       }
       throw new Error("Heartbeat was scheduled in an invalid state");
     }
-    const heartbeatId = randomUUID7();
+    const heartbeatId = randomUUID8();
     this.#state = new AwaitingHeartbeatAckState(
       heartbeatId,
       this.#timer.schedule(this.#handleTimeout, HEARTBEAT_ACK_TIMEOUT_MILLISECONDS)
@@ -43186,7 +43537,7 @@ var SystemDaemonTimer = class {
 var systemDaemonTimer = new SystemDaemonTimer();
 
 // src/session-event-log-v2.ts
-import { createHash as createHash7, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
 function promptContent(command) {
   const content = [];
   if (command.prompt.length > 0) {
@@ -43210,7 +43561,7 @@ function promptContent(command) {
   }
   return content;
 }
-function sessionEventV2(daemonGenerationId, sessionId, position, event, recordedAt) {
+function sessionEventV22(daemonGenerationId, sessionId, position, event, recordedAt) {
   const sessionPrefix = createHash7("sha256").update(sessionId).digest("hex").slice(0, 16);
   return {
     eventId: `event-${daemonGenerationId}-${sessionPrefix}-${position.toString().padStart(16, "0")}`,
@@ -43222,11 +43573,12 @@ function sessionEventV2(daemonGenerationId, sessionId, position, event, recorded
   };
 }
 var DaemonSessionEventLogV2 = class {
-  daemonGenerationId = randomUUID8();
+  daemonGenerationId;
   #publisher;
   #queued = /* @__PURE__ */ new Map();
-  constructor(publisher) {
+  constructor(publisher, daemonGenerationId = randomUUID9()) {
     this.#publisher = publisher;
+    this.daemonGenerationId = daemonGenerationId;
   }
   requested = (command) => {
     this.#queued.set(command.commandId, {
@@ -43246,7 +43598,7 @@ var DaemonSessionEventLogV2 = class {
   record = (sessionId, event, position) => {
     this.#publisher.publishV2(this.event(sessionId, position, event, (/* @__PURE__ */ new Date()).toISOString()));
   };
-  event = (sessionId, position, event, recordedAt) => sessionEventV2(this.daemonGenerationId, sessionId, position, event, recordedAt);
+  event = (sessionId, position, event, recordedAt) => sessionEventV22(this.daemonGenerationId, sessionId, position, event, recordedAt);
   queueChanged = (_sessionId) => void 0;
   completed = (sessionId, commandId, _stopReason) => {
     const request = this.#queued.get(commandId);
@@ -43313,7 +43665,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID9()}`
+        requestId: `automatic-integration-${randomUUID10()}`
       },
       signal
     );
@@ -43331,13 +43683,24 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     publishCatalog: async (installationSignal) => await publishAgentCatalog(config2, installationSignal),
     stateDirectory
   });
-  const sessionStore = new SqliteAcpSessionStore(
-    join19(stateDirectory, "sessions", `${createHash8("sha256").update(config2.channelId).digest("hex")}.sqlite`)
-  );
+  const channelHash = createHash8("sha256").update(config2.channelId).digest("hex");
+  const daemonGenerationId = randomUUID10();
+  const sessionDatabase = openAcpSessionDatabase(join19(stateDirectory, "sessions", `${channelHash}.sqlite`));
+  let eventsV2;
+  try {
+    eventsV2 = new CachedAcpSessionEventStoreV2(
+      openSessionEventCacheV2Database(join19(stateDirectory, "sessions", `${channelHash}.events.sqlite`)),
+      daemonGenerationId
+    );
+  } catch (error62) {
+    sessionDatabase.close();
+    throw error62;
+  }
+  const sessionStore = new SqliteAcpSessionStore(sessionDatabase, eventsV2);
   await using externalContent = new LocalExternalContentStore(stateDirectory);
   const operations = new DaemonOperationState();
   const publisher = new DaemonSessionEventPublisher();
-  const eventLogV2 = new DaemonSessionEventLogV2(publisher);
+  const eventLogV2 = new DaemonSessionEventLogV2(publisher, daemonGenerationId);
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));
@@ -43383,7 +43746,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
           options2.signal
         );
         return cwd === options2.cwd && additionalDirectories.length === options2.additionalDirectories.length && additionalDirectories.every(
-          (directory, index) => directory === options2.additionalDirectories[index]
+          (directory, index2) => directory === options2.additionalDirectories[index2]
         );
       });
     }