@moxt-ai/mobius 0.0.174 → 0.0.176

package/dist/cli.js

@@ -2340,11 +2340,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     };
     this._checkNumberOfArguments();
     const processedArgs = [];
-    this.registeredArguments.forEach((declaredArg, index) => {
+    this.registeredArguments.forEach((declaredArg, index2) => {
       let value = declaredArg.defaultValue;
       if (declaredArg.variadic) {
-        if (index < this.args.length) {
-          value = this.args.slice(index);
+        if (index2 < this.args.length) {
+          value = this.args.slice(index2);
           if (declaredArg.parseArg) {
             value = value.reduce((processed, v) => {
               return myParseArg(declaredArg, v, processed);
@@ -2353,13 +2353,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
         } else if (value === void 0) {
           value = [];
         }
-      } else if (index < this.args.length) {
-        value = this.args[index];
+      } else if (index2 < this.args.length) {
+        value = this.args[index2];
         if (declaredArg.parseArg) {
           value = myParseArg(declaredArg, value, declaredArg.defaultValue);
         }
       }
-      processedArgs[index] = value;
+      processedArgs[index2] = value;
     });
     this.processedArgs = processedArgs;
   }
@@ -2653,10 +2653,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
       }
       if (/^--[^=]+=/.test(arg)) {
-        const index = arg.indexOf("=");
-        const option = this._findOption(arg.slice(0, index));
+        const index2 = arg.indexOf("=");
+        const option = this._findOption(arg.slice(0, index2));
         if (option && (option.required || option.optional)) {
-          this.emit(`option:${option.name()}`, arg.slice(index + 1));
+          this.emit(`option:${option.name()}`, arg.slice(index2 + 1));
           continue;
         }
       }
@@ -3381,7 +3381,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.174",
+  version: "0.0.176",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -3435,6 +3435,7 @@ var package_default = {
   devDependencies: {
     "@moxt-ai/mobius-protocol": "workspace:*",
     "@types/node": "^24.13.5",
+    "drizzle-kit": "1.0.0-rc.4",
     "drizzle-orm": "1.0.0-rc.4",
     esbuild: "0.28.2",
     "@moxt-ai/mobius-sdk": "workspace:*",
@@ -8320,11 +8321,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);
@@ -8935,14 +8936,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);
@@ -9093,11 +9094,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++) {
@@ -23778,7 +23779,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, "~");
@@ -27852,9 +27853,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;
     }
@@ -27879,8 +27880,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);
     }
@@ -28624,12 +28625,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);
@@ -29666,17 +29667,6 @@ var nativeSessionRequestSchema = external_exports.discriminatedUnion("action", [
     action: external_exports.enum(["import", "fork"]),
     entryId: identifierStringSchema,
     targetSessionId: identifierStringSchema
-  }).readonly(),
-  external_exports.object({
-    ...identity,
-    action: external_exports.literal("fork-recorded"),
-    targetSessionId: identifierStringSchema,
-    throughCommandId: identifierStringSchema
-  }).readonly(),
-  external_exports.object({
-    ...identity,
-    action: external_exports.literal("delete"),
-    entryId: identifierStringSchema
   }).readonly()
 ]);
 var nativeSessionCommandSchema = external_exports.discriminatedUnion("action", [
@@ -29692,17 +29682,6 @@ var nativeSessionCommandSchema = external_exports.discriminatedUnion("action", [
     action: external_exports.enum(["import", "fork"]),
     entryId: identifierStringSchema,
     targetSessionId: identifierStringSchema
-  }).readonly(),
-  external_exports.object({
-    ...identity,
-    action: external_exports.literal("fork-recorded"),
-    targetSessionId: identifierStringSchema,
-    throughCommandId: identifierStringSchema
-  }).readonly(),
-  external_exports.object({
-    ...identity,
-    action: external_exports.literal("delete"),
-    entryId: identifierStringSchema
   }).readonly()
 ]);
 var nativeSessionEntrySchema = external_exports.object({
@@ -29747,16 +29726,10 @@ var nativeSessionResultSchema = external_exports.discriminatedUnion("action", [
   }).readonly(),
   external_exports.object({
     ...resultEnvelope,
-    action: external_exports.enum(["import", "fork", "fork-recorded"]),
+    action: external_exports.enum(["import", "fork"]),
     targetSessionId: identifierStringSchema,
     ready: sessionReadyEventSchema,
     title: external_exports.string().max(500)
-  }).readonly(),
-  external_exports.object({
-    ...resultEnvelope,
-    action: external_exports.literal("delete"),
-    entryId: identifierStringSchema,
-    deletedSessionIds: external_exports.array(identifierStringSchema).max(500).readonly()
   }).readonly()
 ]);
 var nativeSessionCancelSchema = external_exports.object({ ...envelope, kind: external_exports.literal(NATIVE_SESSION_CANCEL_KIND) }).readonly();
@@ -30158,12 +30131,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);
@@ -30171,14 +30144,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;
@@ -30229,6 +30202,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);
@@ -30974,16 +30948,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(
@@ -31178,16 +31152,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`);
@@ -31195,8 +31169,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"}`);
     }
@@ -31473,7 +31447,7 @@ var AuditStore = class {
 };
 
 // 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";
 
@@ -31596,7 +31570,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)) {
@@ -31724,7 +31698,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)) {
@@ -31853,10 +31827,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)}`;
 }
@@ -33090,9 +33064,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);
@@ -33113,10 +33087,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(
@@ -33125,30 +33105,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") {
@@ -33158,18 +33138,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;
@@ -33196,41 +33176,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) => {
@@ -33863,9 +33834,7 @@ var AcpSessionInteractions = class {
 };
 
 // src/acp/session-store.ts
-import { chmodSync, mkdirSync } from "node:fs";
-import { dirname as dirname4 } from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { randomUUID as randomUUID2 } 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");
@@ -34981,7 +34950,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) {
@@ -35734,195 +35703,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";
@@ -36487,130 +36267,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;
-    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);
+  where(condition) {
+    this.config.where = condition;
     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";
@@ -37311,8 +37105,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)) {
@@ -37322,7 +37116,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);
   }
@@ -37331,9 +37125,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;
   }
@@ -37361,9 +37155,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);
@@ -37652,6 +37446,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";
@@ -38539,129 +38595,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: path3, ...options } = connection;
-    return construct(new DatabaseSync(path3 ?? ":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`;"
-  }
-];
-
 // src/schema/acp-session-store/acp-session.ts
 var acpSession = sqliteTable("acp_session", {
   sessionId: text("session_id").primaryKey(),
@@ -38669,33 +38602,235 @@ var acpSession = sqliteTable("acp_session", {
   nativeSessionId: text("native_session_id").notNull(),
   cwd: text("cwd").notNull(),
   additionalDirectories: text("additional_directories").notNull(),
-  lastTerminalCommandId: text("last_terminal_command_id"),
   prompted: integer2("prompted", { mode: "boolean" }).notNull(),
   title: text("title").notNull(),
   updatedAt: text("updated_at").notNull()
 });
 
-// src/schema/acp-session-store/deleted-acp-session.ts
-var deletedAcpSession = sqliteTable("deleted_acp_session", {
-  sessionId: text("session_id").primaryKey()
-});
+// 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;
   agentId;
   cwd;
-  lastTerminalCommandId;
   nativeSessionId;
   prompted;
   sessionId;
   title;
   updatedAt;
-  constructor(sessionId, agentId, nativeSessionId, cwd, additionalDirectories, prompted, title2, updatedAt = (/* @__PURE__ */ new Date()).toISOString(), lastTerminalCommandId = null) {
+  constructor(sessionId, agentId, nativeSessionId, cwd, additionalDirectories, prompted, title2, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
     this.additionalDirectories = [...additionalDirectories];
     this.agentId = agentId;
     this.cwd = cwd;
-    this.lastTerminalCommandId = lastTerminalCommandId;
     this.nativeSessionId = nativeSessionId;
     this.prompted = prompted;
     this.sessionId = sessionId;
@@ -38716,37 +38851,27 @@ var FoundAcpStoredSession = class extends AcpStoredSessionLookup {
     this.session = session;
   }
 };
-var DeletedAcpStoredSession = class extends AcpStoredSessionLookup {
-  found = false;
-};
 var MemoryAcpSessionStore = class {
+  eventsV2;
   #sessions = /* @__PURE__ */ new Map();
-  #deleted = /* @__PURE__ */ new Set();
+  constructor(eventsV2 = new MemoryAcpSessionEventStoreV2(randomUUID2())) {
+    this.eventsV2 = eventsV2;
+  }
   close = () => {
     this.#sessions.clear();
-    this.#deleted.clear();
+    this.eventsV2.close();
   };
   findNative = (agentId, nativeSessionId) => [...this.#sessions.values()].filter(
     (session) => session.agentId === agentId && session.nativeSessionId === nativeSessionId
   );
   list = () => [...this.#sessions.values()].toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-  markDeleted = (agentId, nativeSessionId) => {
-    const ids = this.findNative(agentId, nativeSessionId).map((session) => session.sessionId);
-    for (const id of ids) {
-      this.#sessions.delete(id);
-      this.#deleted.add(id);
-    }
-    return ids;
-  };
   read = (sessionId) => {
-    if (this.#deleted.has(sessionId)) {
-      return new DeletedAcpStoredSession();
-    }
     const session = this.#sessions.get(sessionId);
     return session === void 0 ? new MissingAcpStoredSession() : new FoundAcpStoredSession(session);
   };
   remove = (sessionId) => {
     this.#sessions.delete(sessionId);
+    this.eventsV2.remove(sessionId);
   };
   write = (session) => {
     this.#sessions.set(session.sessionId, session);
@@ -38756,14 +38881,12 @@ var storedSessionRowSchema = external_exports.object({
   additionalDirectories: external_exports.string(),
   agentId: external_exports.string(),
   cwd: external_exports.string(),
-  lastTerminalCommandId: external_exports.string().nullable(),
   nativeSessionId: external_exports.string(),
   prompted: external_exports.boolean(),
   sessionId: external_exports.string(),
   title: external_exports.string(),
   updatedAt: external_exports.string()
 });
-var sessionIdRowSchema = external_exports.object({ sessionId: external_exports.string() });
 function decodeStoredSession(value) {
   const row = storedSessionRowSchema.parse(value);
   const decodedAdditionalDirectories = JSON.parse(row.additionalDirectories);
@@ -38776,98 +38899,47 @@ function decodeStoredSession(value) {
     additionalDirectories,
     row.prompted,
     row.title,
-    row.updatedAt,
-    row.lastTerminalCommandId
+    row.updatedAt
   );
 }
 var SqliteAcpSessionStore = class {
+  eventsV2;
   #database;
-  #sqliteDatabase;
-  constructor(path3) {
-    mkdirSync(dirname4(path3), { mode: 448, recursive: true });
-    this.#sqliteDatabase = new DatabaseSync2(path3);
-    chmodSync(path3, 384);
-    this.#migrate();
-    this.#database = drizzle({ client: this.#sqliteDatabase });
+  #localDatabase;
+  constructor(localDatabase, eventsV2 = new MemoryAcpSessionEventStoreV2(randomUUID2())) {
+    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;
-      }
-    }
-  };
-  #transaction = (operation) => {
-    this.#sqliteDatabase.exec("BEGIN IMMEDIATE");
+  close = () => {
     try {
-      operation();
-      this.#sqliteDatabase.exec("COMMIT");
-    } catch (error62) {
-      this.#sqliteDatabase.exec("ROLLBACK");
-      throw error62;
+      this.#localDatabase.close();
+    } finally {
+      this.eventsV2.close();
     }
   };
-  close = () => {
-    this.#sqliteDatabase.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);
-  markDeleted = (agentId, nativeSessionId) => {
-    const ids = this.#database.select({ sessionId: acpSession.sessionId }).from(acpSession).where(and(eq(acpSession.agentId, agentId), eq(acpSession.nativeSessionId, nativeSessionId))).all().map((row) => sessionIdRowSchema.parse(row).sessionId);
-    this.#transaction(() => {
-      this.#database.delete(acpSession).where(and(eq(acpSession.agentId, agentId), eq(acpSession.nativeSessionId, nativeSessionId))).run();
-      for (const id of ids) {
-        this.#database.insert(deletedAcpSession).values({ sessionId: id }).onConflictDoNothing().run();
-      }
-    });
-    return ids;
-  };
   read = (sessionId) => {
-    const deleted = this.#database.select({ sessionId: deletedAcpSession.sessionId }).from(deletedAcpSession).where(eq(deletedAcpSession.sessionId, sessionId)).get();
-    if (deleted !== void 0) {
-      sessionIdRowSchema.parse(deleted);
-      return new DeletedAcpStoredSession();
-    }
     const row = this.#database.select().from(acpSession).where(eq(acpSession.sessionId, sessionId)).get();
     return row === void 0 ? new MissingAcpStoredSession() : new FoundAcpStoredSession(decodeStoredSession(row));
   };
   remove = (sessionId) => {
     this.#database.delete(acpSession).where(eq(acpSession.sessionId, sessionId)).run();
+    this.eventsV2.remove(sessionId);
   };
   write = (session) => {
     const value = {
       additionalDirectories: JSON.stringify(session.additionalDirectories),
       agentId: session.agentId,
       cwd: session.cwd,
-      lastTerminalCommandId: session.lastTerminalCommandId,
       nativeSessionId: session.nativeSessionId,
       prompted: session.prompted,
       sessionId: session.sessionId,
       title: session.title,
       updatedAt: session.updatedAt
     };
-    this.#transaction(() => {
-      this.#database.delete(deletedAcpSession).where(eq(deletedAcpSession.sessionId, session.sessionId)).run();
-      this.#database.insert(acpSession).values(value).onConflictDoUpdate({
-        target: acpSession.sessionId,
-        set: value
-      }).run();
-    });
+    this.#database.insert(acpSession).values(value).onConflictDoUpdate({ target: acpSession.sessionId, set: value }).run();
   };
 };
 
@@ -38880,7 +38952,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);
@@ -38908,7 +38980,6 @@ var AgentSession = class _AgentSession {
   #commands = [];
   #configRevision = 0;
   #configOptions = [];
-  #lastTerminalCommandId = null;
   #nativeHistoryOwnership = { kind: "unbound" };
   #prompted = false;
   #nativePrompt = null;
@@ -39044,12 +39115,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;
@@ -39064,7 +39140,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(
@@ -39221,13 +39298,6 @@ var AgentSession = class _AgentSession {
       this.#store.remove(this.#mobiusSessionId);
       stored = this.#metrics.measureSync("session-state-read", () => this.#store.read(this.#mobiusSessionId));
     }
-    if (stored instanceof DeletedAcpStoredSession) {
-      throw new AcpExecutionError(
-        "The native Agent session was deleted. Start a new chat.",
-        {},
-        "native_session_deleted"
-      );
-    }
     let lifecycleResponse;
     if (origin?.kind === "fork") {
       if (!this.#capabilities.unstableForkSession) {
@@ -39275,7 +39345,6 @@ var AgentSession = class _AgentSession {
     } else if (stored instanceof FoundAcpStoredSession && stored.session.agentId === this.#agentId && stored.session.cwd === this.#cwd && arraysEqual(stored.session.additionalDirectories, this.#additionalDirectories)) {
       this.selectNativeSession(stored.session.nativeSessionId);
       this.#prompted = stored.session.prompted;
-      this.#lastTerminalCommandId = stored.session.lastTerminalCommandId;
       this.#sessionTitle = stored.session.title;
       this.#restored = true;
       if (this.#capabilities.resumeSession) {
@@ -39351,8 +39420,7 @@ var AgentSession = class _AgentSession {
         this.#additionalDirectories,
         this.#prompted,
         this.#sessionTitle ?? "",
-        (/* @__PURE__ */ new Date()).toISOString(),
-        this.#lastTerminalCommandId
+        (/* @__PURE__ */ new Date()).toISOString()
       )
     );
   };
@@ -39381,24 +39449,6 @@ var AgentSession = class _AgentSession {
     }
     return decoded.data;
   };
-  deleteNativeSession = async (nativeSessionId, signal) => {
-    if (!this.#capabilities.deleteSession || !this.#capabilities.listSessions) {
-      throw new AcpExecutionError(
-        "This Agent does not support native session deletion",
-        {},
-        "native_session_unsupported"
-      );
-    }
-    await this.race(
-      this.#connection.connection.agent.request(
-        methods8.agent.session.delete,
-        { sessionId: nativeSessionIdSchema.parse(nativeSessionId) },
-        { cancellationSignal: signal }
-      ),
-      "ACP agent exited while deleting a session",
-      signal
-    );
-  };
   nativeSessionId = () => this.#updates.sessionId();
   adoptNativeSessionId = (sessionId) => {
     if (this.#prompted || this.#updates.sessionId() !== sessionId) {
@@ -39554,8 +39604,7 @@ var AgentSession = class _AgentSession {
         this.#additionalDirectories,
         true,
         this.#sessionTitle,
-        (/* @__PURE__ */ new Date()).toISOString(),
-        this.#lastTerminalCommandId
+        (/* @__PURE__ */ new Date()).toISOString()
       )
     );
     this.#prompted = true;
@@ -39567,7 +39616,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({
@@ -39624,7 +39673,6 @@ var AgentSession = class _AgentSession {
           usage: result.usage ?? null
         });
       }
-      this.#lastTerminalCommandId = options.commandId;
       this.#store.write(
         new AcpStoredSession(
           this.#mobiusSessionId,
@@ -39634,8 +39682,7 @@ var AgentSession = class _AgentSession {
           this.#additionalDirectories,
           true,
           this.#sessionTitle ?? "",
-          (/* @__PURE__ */ new Date()).toISOString(),
-          this.#lastTerminalCommandId
+          (/* @__PURE__ */ new Date()).toISOString()
         )
       );
       if (lifecycleV2 !== void 0) {
@@ -39782,7 +39829,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) => {
@@ -39803,13 +39850,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) => {
@@ -39923,8 +39965,7 @@ var AgentSession = class _AgentSession {
             this.#additionalDirectories,
             this.#prompted,
             this.#sessionTitle ?? "",
-            (/* @__PURE__ */ new Date()).toISOString(),
-            this.#lastTerminalCommandId
+            (/* @__PURE__ */ new Date()).toISOString()
           )
         );
       }
@@ -40453,9 +40494,9 @@ var AcpContentExternalizer = class {
 };
 
 // src/external-content/local-external-content-store.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import { lstat, mkdir as mkdir6, readdir as readdir3, realpath as realpath8, rename as rename4, rm as rm3, stat as stat7, utimes, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname5, join as join16 } from "node:path";
+import { dirname as dirname4, join as join16 } 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({
@@ -40474,7 +40515,7 @@ var UnretainedExternalContentStore = class {
   };
 };
 async function atomicWrite(path3, bytes, signal) {
-  const temporary = `${path3}.${randomUUID2()}.tmp`;
+  const temporary = `${path3}.${randomUUID3()}.tmp`;
   try {
     await writeFile4(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -40491,7 +40532,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join16(stateDirectory, "tmp", "session-content", randomUUID2());
+    this.#root = join16(stateDirectory, "tmp", "session-content", randomUUID3());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -40502,11 +40543,11 @@ var LocalExternalContentStore = class {
       await mkdir6(this.#root, { mode: 448, recursive: true });
       const now = /* @__PURE__ */ new Date();
       await utimes(this.#root, now, now);
-      for (const directory of await readdir3(dirname5(this.#root), { withFileTypes: true })) {
+      for (const directory of await readdir3(dirname4(this.#root), { withFileTypes: true })) {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path3 = join16(dirname5(this.#root), directory.name);
+        const path3 = join16(dirname4(this.#root), directory.name);
         if (path3 === this.#root) {
           continue;
         }
@@ -40592,12 +40633,12 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath8(dirname5(entry.path)),
+        realpath8(dirname4(entry.path)),
         realpath8(entry.path),
         lstat(entry.path)
       ]);
       signal.throwIfAborted();
-      if (!file2.isFile() || file2.isSymbolicLink() || dirname5(resolvedPath) !== resolvedDirectory) {
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname4(resolvedPath) !== resolvedDirectory) {
         return null;
       }
       return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
@@ -40674,9 +40715,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);
       }
     }
   };
@@ -40965,13 +41006,6 @@ var AgentRuntimeManager = class {
   }
   prepareSession = async (options, metrics = unmeasuredOperationMetrics) => this.#operations.run(options, async (options2) => {
     const stored = metrics.measureSync("session-state-read", () => this.#store.read(options2.sessionId));
-    if (stored instanceof DeletedAcpStoredSession) {
-      throw new AcpExecutionError(
-        "The native Agent session was deleted. Start a new chat.",
-        {},
-        "native_session_deleted"
-      );
-    }
     if (stored instanceof FoundAcpStoredSession && this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`)) {
       throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
     }
@@ -41420,7 +41454,7 @@ var AgentRuntimeManager = class {
         }
       });
     }
-    if (this.#executionProcesses.get(options2.sessionId) !== void 0 || this.#executionProcesses.pending(options2.sessionId) !== void 0 || this.#store.read(options2.sessionId) instanceof FoundAcpStoredSession || this.#store.read(options2.sessionId) instanceof DeletedAcpStoredSession) {
+    if (this.#executionProcesses.get(options2.sessionId) !== void 0 || this.#executionProcesses.pending(options2.sessionId) !== void 0 || this.#store.read(options2.sessionId) instanceof FoundAcpStoredSession) {
       throw new AcpExecutionError(
         "The destination conversation already exists",
         {},
@@ -41466,40 +41500,6 @@ var AgentRuntimeManager = class {
       }
     });
   });
-  deleteNativeSession = async (options, nativeSessionId) => this.#operations.run(options, async (options2) => {
-    return await this.#queryProcesses.use(options2, async (runtime) => {
-      const key = `${options2.agent.id}:${nativeSessionId}`;
-      const linked = this.#store.findNative(options2.agent.id, nativeSessionId);
-      if (this.#nativeOperations.has(key) || linked.some(
-        (entry) => this.#executions.command(entry.sessionId) !== void 0 || this.#executionProcesses.pending(entry.sessionId) !== void 0
-      )) {
-        throw new AcpExecutionError(
-          "Wait for the native session's running operation to finish",
-          {},
-          "session_busy"
-        );
-      }
-      this.#nativeOperations.add(key);
-      try {
-        for (const entry of linked) {
-          const active = this.#executionProcesses.get(entry.sessionId);
-          if (active !== void 0 && active !== runtime) {
-            await this.#retireSessionProcess(entry.sessionId, active, async () => await active.close());
-          }
-        }
-        options2.signal.throwIfAborted();
-        await runtime.deleteNativeSession(nativeSessionId, options2.signal);
-        const deleted = this.#store.markDeleted(options2.agent.id, nativeSessionId);
-        if (runtime.nativeSessionId() === nativeSessionId) {
-          await this.#queryProcesses.retire(options2.sessionId, runtime);
-        }
-        return deleted;
-      } finally {
-        this.#nativeOperations.delete(key);
-        this.#processes.notifyChanged();
-      }
-    });
-  });
 };
 
 // src/agent-catalog/publish-agent-catalog.ts
@@ -42077,7 +42077,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";
 
 // src/authorization/local-authorization-error.ts
 var LocalAuthorizationError = class extends Error {
@@ -42216,7 +42216,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),
@@ -42241,7 +42241,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 {
@@ -42257,7 +42257,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;
@@ -42722,7 +42722,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);
 }
@@ -42730,8 +42730,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;
     }
@@ -42756,7 +42756,7 @@ var ActiveDaemonTurn = class {
   #timeline;
   #sequence = 0;
   #interaction = null;
-  #epoch = decodeIdentifier(randomUUID3());
+  #epoch = decodeIdentifier(randomUUID4());
   constructor(command, attemptId) {
     this.attemptId = attemptId;
     this.command = command;
@@ -42818,7 +42818,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, {
@@ -42839,7 +42839,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, {
@@ -42864,7 +42864,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: ""
@@ -42872,7 +42872,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) {
@@ -42904,7 +42904,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)
@@ -43175,6 +43175,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: path3, ...options } = connection;
+    return construct(new DatabaseSync(path3 ?? ":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(path3, label, migrations, pragmas = []) {
+    mkdirSync2(dirname6(path3), { mode: 448, recursive: true });
+    this.#sqlite = new DatabaseSync2(path3);
+    chmodSync(path3, 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 = (path3) => new LocalSqliteDatabase(path3, "ACP Session database", acpSessionStoreMigrations);
+var openSessionEventCacheV2Database = (path3) => new LocalSqliteDatabase(path3, "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([
@@ -43879,8 +44075,7 @@ var readCodexFullHistory = async (agent, cwd, nativeSessionId, signal, nativeTur
 });
 
 // src/native-sessions/service.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { basename as basename5 } from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var NativeSessionService = class {
   #entries = /* @__PURE__ */ new Map();
   #cursors = /* @__PURE__ */ new Map();
@@ -43924,64 +44119,6 @@ var NativeSessionService = class {
         ...await this.#activeTurn(command, options)
       };
     }
-    if (command.action === "fork-recorded") {
-      const source = this.#sessions.findSessions([command.sessionId])[0];
-      if (source === void 0 || !source.prompted) {
-        throw new AcpExecutionError(
-          "The source conversation has no resumable native Agent session",
-          {},
-          "native_session_not_found"
-        );
-      }
-      if (source.agentId !== command.agentId || source.cwd !== cwd || source.additionalDirectories.length !== additionalDirectories.length || source.additionalDirectories.some((path3, index) => path3 !== additionalDirectories[index])) {
-        throw new AcpExecutionError(
-          "The source conversation execution target does not match the fork request",
-          {},
-          "native_session_target_changed"
-        );
-      }
-      if (source.lastTerminalCommandId !== command.throughCommandId) {
-        throw new AcpExecutionError(
-          "The selected Turn is no longer the source conversation head",
-          {},
-          "fork_point_stale"
-        );
-      }
-      const opened2 = await this.#sessions.openNativeSession(
-        { ...options, sessionId: command.targetSessionId },
-        { kind: "fork", nativeSessionId: source.nativeSessionId }
-      );
-      signal.throwIfAborted();
-      const directory = await this.#directories.list(this.#config.bindingId, command.directoryId, signal);
-      const ready2 = {
-        additionalDirectories: additionalDirectories.map((path3, index) => ({
-          directoryId: command.additionalDirectoryIds[index] ?? command.directoryId,
-          name: basename5(path3) || path3
-        })),
-        agentId: command.agentId,
-        agentName: opened2.prepared.agentName,
-        agentVersion: opened2.prepared.agentVersion,
-        capabilities: opened2.prepared.capabilities,
-        commands: opened2.prepared.commands,
-        configOptions: opened2.prepared.configOptions,
-        directoryId: command.directoryId,
-        directoryLabel: directory.directoryLabel,
-        kind: "session.ready",
-        requestId: command.requestId,
-        restored: true,
-        sessionId: opened2.sessionId
-      };
-      this.record(command, "native_recorded_session_forked");
-      return {
-        action: "fork-recorded",
-        kind: "native.session.result",
-        ready: ready2,
-        requestId: command.requestId,
-        sessionId: command.sessionId,
-        targetSessionId: command.targetSessionId,
-        title: source.title || "Untitled session"
-      };
-    }
     const prepared = await this.#sessions.prepareNativeSessionBrowser(options);
     if (!prepared.capabilities.listSessions) {
       throw new AcpExecutionError(
@@ -43997,7 +44134,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();
       }
@@ -44053,7 +44190,7 @@ var NativeSessionService = class {
             "invalid_native_session_response"
           );
         }
-        nextCursor = decodeIdentifier(randomUUID4());
+        nextCursor = decodeIdentifier(randomUUID5());
         if (this.#cursors.size >= 500) {
           this.#cursors.clear();
         }
@@ -44116,25 +44253,6 @@ var NativeSessionService = class {
       );
     }
     const target = await this.resolveTarget(command, options, selected);
-    if (command.action === "delete") {
-      if (!prepared.capabilities.deleteSession) {
-        throw new AcpExecutionError(
-          "This Agent does not support native session deletion",
-          {},
-          "native_session_unsupported"
-        );
-      }
-      signal.throwIfAborted();
-      this.record(command, "native_session_delete_authorized");
-      const deletedSessionIds = await this.#sessions.deleteNativeSession(options, target.info.sessionId);
-      this.record(command, "native_session_deleted");
-      return {
-        ...envelope2,
-        action: "delete",
-        entryId: command.entryId,
-        deletedSessionIds: deletedSessionIds.map(decodeIdentifier)
-      };
-    }
     const action = command.action;
     if (action === "import" && !prepared.capabilities.loadSession && !prepared.capabilities.resumeSession) {
       throw new AcpExecutionError("This Agent cannot import native sessions", {}, "native_session_unsupported");
@@ -44250,7 +44368,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) {
@@ -44258,7 +44376,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((path3, index2) => path3 !== selected.additionalDirectories[index2])) {
+        if (target.cwd !== selected.cwd || target.additionalDirectories.length !== selected.additionalDirectories.length || target.additionalDirectories.some((path3, index3) => path3 !== selected.additionalDirectories[index3])) {
           throw new AcpExecutionError(
             "This session's directory changed. Refresh the list before continuing.",
             {},
@@ -44297,7 +44415,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";
@@ -44314,7 +44432,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" };
   };
@@ -45144,7 +45262,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
 import { realpath as realpath10, stat as stat9 } from "node:fs/promises";
-import { basename as basename6, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve7 } from "node:path";
+import { basename as basename5, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
 function requestedPath(value) {
@@ -45196,7 +45314,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
     kind: FILE_BEGIN_KIND,
     mediaType: external?.mediaType ?? raster?.mimeType ?? "application/octet-stream",
     modifiedAt: before.mtime.toISOString(),
-    name: external?.name ?? (basename6(target) || "file"),
+    name: external?.name ?? (basename5(target) || "file"),
     requestId: command.requestId,
     sessionId: command.sessionId
   });
@@ -45226,7 +45344,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
 }
 
 // src/authorization/resolve-session-directories.ts
-import { basename as basename7 } from "node:path";
+import { basename as basename6 } from "node:path";
 var ResolvedSessionDirectories = class {
   additionalDirectories;
   additionalDirectoryEntries;
@@ -45251,7 +45369,7 @@ async function resolveSessionDirectories(directories, bindingId, directoryId2, a
     additionalDirectories.push(directory);
     additionalDirectoryEntries.push({
       directoryId: additionalDirectoryId,
-      name: basename7(directory)
+      name: basename6(directory)
     });
   }
   return new ResolvedSessionDirectories(cwd, additionalDirectories, additionalDirectoryEntries);
@@ -45278,7 +45396,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({
@@ -45329,7 +45447,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");
 }
@@ -45470,7 +45588,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,
@@ -46030,7 +46148,7 @@ async function executeSessionConfigure(publisher, socket, command, config2, dire
 // src/native-sessions/handle-native-requests.ts
 import { WebSocket as WebSocket4 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
-  const { audit, diagnostics, nativeSessions, publisher, signal, socket, timer } = dependencies;
+  const { audit, diagnostics, nativeSessions, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
   const cancel = (command) => {
     const request = pending.get(command.requestId);
@@ -46082,17 +46200,6 @@ function createNativeSessionRequestHandler(dependencies) {
         }
         operationSignal.throwIfAborted();
         const result = await nativeSessions.execute(command, operationSignal);
-        if (command.action === "fork-recorded" && result.action === "fork-recorded") {
-          publisher.publishBatch(result.ready.sessionId, [
-            result.ready,
-            {
-              kind: "session.forked",
-              sessionId: result.ready.sessionId,
-              sourceSessionId: command.sessionId,
-              throughCommandId: command.throughCommandId
-            }
-          ]);
-        }
         if (socket.readyState === WebSocket4.OPEN) {
           send(socket, result);
         }
@@ -46172,7 +46279,6 @@ function createDaemonCommandHandler({
     audit,
     diagnostics,
     nativeSessions,
-    publisher,
     signal,
     socket,
     timer
@@ -46552,7 +46658,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 {
@@ -46641,7 +46747,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)
@@ -46933,7 +47039,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) {
@@ -46957,7 +47063,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")}`,
@@ -46969,11 +47075,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, {
@@ -46993,7 +47100,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);
@@ -47060,7 +47167,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID9()}`
+        requestId: `automatic-integration-${randomUUID10()}`
       },
       signal
     );
@@ -47078,13 +47185,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));
@@ -47130,7 +47248,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]
         );
       });
     }
@@ -47595,12 +47713,12 @@ var RuntimeSupervisor = class {
   }
 };
 function pairingIdentifier(arguments_) {
-  const indexes = arguments_.flatMap((argument, index2) => argument === "--pairing" ? [index2] : []);
+  const indexes = arguments_.flatMap((argument, index3) => argument === "--pairing" ? [index3] : []);
   if (indexes.length !== 1) {
     return null;
   }
-  const index = indexes[0];
-  return index === void 0 ? null : arguments_[index + 1] ?? null;
+  const index2 = indexes[0];
+  return index2 === void 0 ? null : arguments_[index2 + 1] ?? null;
 }
 async function waitForReady(active, signal) {
   if (active.status === "online") {
@@ -47895,9 +48013,9 @@ function formatPairTable(pairs) {
   const headers = ["connection_id", "app_id", "runtime_id", "workspace", "status"];
   const rows = pairs.map((pair) => [pair.connectionId, pair.appId, pair.runtimeId, pair.workspace, pair.status]);
   const widths = headers.map(
-    (header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0))
+    (header, index2) => Math.max(header.length, ...rows.map((row) => row[index2]?.length ?? 0))
   );
-  const line = (row) => `| ${row.map((value, index) => value.padEnd(widths[index] ?? value.length)).join(" | ")} |`;
+  const line = (row) => `| ${row.map((value, index2) => value.padEnd(widths[index2] ?? value.length)).join(" | ")} |`;
   const divider = `|-${widths.map((width) => "-".repeat(width)).join("-|-")}-|`;
   return `${line(headers)}
 ${divider}