@moxt-ai/mobius 0.0.154 → 0.0.156

package/dist/index.js

@@ -3380,11 +3380,11 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
     return payload;
   };
 });
-function handleArrayResult(result, final, index) {
+function handleArrayResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
@@ -3995,14 +3995,14 @@ function mergeValues(a, b) {
       return { valid: false, mergeErrorPath: [] };
     }
     const newArray = [];
-    for (let index = 0; index < a.length; index++) {
-      const itemA = a[index];
-      const itemB = b[index];
+    for (let index2 = 0; index2 < a.length; index2++) {
+      const itemA = a[index2];
+      const itemB = b[index2];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [index2, ...sharedValue.mergeErrorPath]
         };
       }
       newArray.push(sharedValue.data);
@@ -4153,11 +4153,11 @@ function getTupleOptStart(items, key) {
   }
   return 0;
 }
-function handleTupleResult(result, final, index) {
+function handleTupleResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 function handleTupleResults(itemResults, final, items, input2, optoutStart) {
   for (let i = 0; i < items.length; i++) {
@@ -18838,7 +18838,7 @@ function detectVersion(schema, defaultTarget) {
   return defaultTarget ?? "draft-2020-12";
 }
 function applyMinItems(items, minItems) {
-  return items.map((item, index) => index < minItems ? item : item.optional());
+  return items.map((item, index2) => index2 < minItems ? item : item.optional());
 }
 function decodeJSONPointerSegment(segment) {
   return segment.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -20026,12 +20026,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);
@@ -20767,16 +20767,8 @@ function decodeSessionQueuedEvent(encoded) {
 function decodeRuntimeLivenessReadyEvent(encoded) {
   const value = parseJson2(encoded);
   assertKind(value, RUNTIME_LIVENESS_READY_KIND);
-  if (value["sessionEventDelivery"] === void 0) {
-    assertExactKeys(value, ["kind"]);
-    return { kind: RUNTIME_LIVENESS_READY_KIND };
-  }
-  assertExactKeys(value, ["kind", "sessionEventDelivery"]);
-  const sessionEventDelivery = readString(value, "sessionEventDelivery", 32);
-  if (sessionEventDelivery !== "reliable-v1") {
-    throw new ProtocolMessageError("Unsupported Session event delivery mode");
-  }
-  return { kind: RUNTIME_LIVENESS_READY_KIND, sessionEventDelivery };
+  assertExactKeys(value, ["kind"]);
+  return { kind: RUNTIME_LIVENESS_READY_KIND };
 }
 function decodeRuntimeHeartbeatEvent(encoded) {
   const value = parseJson2(encoded);
@@ -21241,60 +21233,390 @@ var encodeNativeSessionResult = (value) => JSON.stringify(nativeSessionResultSch
 var decodeNativeSessionCancel = (encoded) => decode4(nativeSessionCancelSchema, encoded);
 var encodeNativeSessionCancel = (value) => JSON.stringify(nativeSessionCancelSchema.parse(value));
 
-// ../protocol/src/session-events.ts
-var SESSION_EVENT_KIND = "session.event";
-var SESSION_EVENT_ACK_KIND = "session.event.ack";
-var SESSION_EVENT_DEFERRED_KIND = "session.event.deferred";
-var SESSION_EVENT_REJECTED_KIND = "session.event.rejected";
-var SESSION_FORKED_KIND = "session.forked";
-var SessionEventRejectionCode = {
-  IdempotencyConflict: "idempotency_conflict",
-  InvalidEvent: "invalid_event",
-  RecordingRejected: "recording_rejected"
-};
-var MAX_RECORDED_EVENT_LENGTH = 8 * 1024 * 1024;
-var ephemeralEventEnvelopeSchema = external_exports.strictObject({
-  kind: external_exports.literal(SESSION_EVENT_KIND),
-  payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
-  sessionId: identifierStringSchema
+// ../protocol/src/session-event-log-v2.ts
+var MAX_EVENT_COUNT = 1e4;
+var MAX_COLLECTION_SIZE = 1e3;
+var MAX_CONTENT_LENGTH = 1e6;
+var MAX_JSON_DEPTH = 16;
+var MAX_JSON_KEYS = 1e3;
+var SESSION_EVENT_V2_KIND = "session.event.v2";
+var boundedString = external_exports.string().max(MAX_CONTENT_LENGTH);
+var shortString = external_exports.string().max(2048);
+function boundedJsonIssue(value, depth = 0) {
+  if (depth > MAX_JSON_DEPTH) {
+    return "JSON nesting exceeds the maximum depth";
+  }
+  if (typeof value === "string") {
+    return value.length <= MAX_CONTENT_LENGTH ? null : "JSON string exceeds the maximum length";
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? null : "JSON number must be finite";
+  }
+  if (typeof value === "boolean" || value === null) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > MAX_COLLECTION_SIZE) {
+      return "JSON array exceeds the maximum length";
+    }
+    for (const item of value) {
+      const issue2 = boundedJsonIssue(item, depth + 1);
+      if (issue2 !== null) {
+        return issue2;
+      }
+    }
+    return null;
+  }
+  if (typeof value === "object" && value !== void 0) {
+    const entries = Object.entries(value);
+    if (entries.length > MAX_JSON_KEYS) {
+      return "JSON object exceeds the maximum key count";
+    }
+    for (const [key, item] of entries) {
+      if (key.length > 255) {
+        return "JSON key exceeds the maximum length";
+      }
+      const issue2 = boundedJsonIssue(item, depth + 1);
+      if (issue2 !== null) {
+        return issue2;
+      }
+    }
+    return null;
+  }
+  return "Value is not bounded JSON";
+}
+var boundedJsonSchema = external_exports.unknown().superRefine((value, context) => {
+  const issue2 = boundedJsonIssue(value);
+  if (issue2 !== null) {
+    context.addIssue({ code: "custom", message: issue2 });
+  }
+});
+var metadataSchema = external_exports.record(external_exports.string().max(255), boundedJsonSchema).readonly();
+var optionalMetadata = metadataSchema.nullable().optional();
+var annotationsSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  audience: external_exports.array(external_exports.enum(["assistant", "user"])).max(2).readonly().nullable().optional(),
+  lastModified: shortString.nullable().optional(),
+  priority: external_exports.number().finite().nullable().optional()
 }).readonly();
-var reliableDeliverySchema = external_exports.strictObject({
-  eventId: identifierStringSchema,
-  kind: external_exports.literal("reliable"),
-  sourceSeq: external_exports.string().regex(/^(?:0|[1-9][0-9]*)$/u).max(40),
-  streamId: identifierStringSchema
+var contentFields = { _meta: optionalMetadata, annotations: annotationsSchema.nullable().optional() };
+var textContentSchema = external_exports.strictObject({ ...contentFields, text: boundedString, type: external_exports.literal("text") }).readonly();
+var imageContentSchema = external_exports.strictObject({
+  ...contentFields,
+  data: boundedString,
+  mimeType: shortString,
+  type: external_exports.literal("image"),
+  uri: boundedString.nullable().optional()
 }).readonly();
-var reliableSessionEventEnvelopeSchema = external_exports.strictObject({
-  delivery: reliableDeliverySchema,
-  kind: external_exports.literal(SESSION_EVENT_KIND),
-  payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
-  sessionId: identifierStringSchema
+var audioContentSchema = external_exports.strictObject({ ...contentFields, data: boundedString, mimeType: shortString, type: external_exports.literal("audio") }).readonly();
+var resourceLinkSchema = external_exports.strictObject({
+  ...contentFields,
+  description: boundedString.nullable().optional(),
+  mimeType: shortString.nullable().optional(),
+  name: shortString,
+  size: external_exports.number().int().nonnegative().safe().nullable().optional(),
+  title: shortString.nullable().optional(),
+  type: external_exports.literal("resource_link"),
+  uri: boundedString
+}).readonly();
+var textResourceSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  mimeType: shortString.nullable().optional(),
+  text: boundedString,
+  uri: boundedString
+}).readonly();
+var blobResourceSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  blob: boundedString,
+  mimeType: shortString.nullable().optional(),
+  uri: boundedString
+}).readonly();
+var embeddedResourceSchema = external_exports.strictObject({
+  ...contentFields,
+  resource: external_exports.union([textResourceSchema, blobResourceSchema]),
+  type: external_exports.literal("resource")
+}).readonly();
+var contentBlockV2Schema = external_exports.discriminatedUnion("type", [
+  textContentSchema,
+  imageContentSchema,
+  audioContentSchema,
+  resourceLinkSchema,
+  embeddedResourceSchema
+]);
+var toolCallContentSchema = external_exports.discriminatedUnion("type", [
+  external_exports.strictObject({ _meta: optionalMetadata, content: contentBlockV2Schema, type: external_exports.literal("content") }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    newText: boundedString,
+    oldText: boundedString.nullable().optional(),
+    path: boundedString,
+    type: external_exports.literal("diff")
+  }).readonly(),
+  external_exports.strictObject({ _meta: optionalMetadata, terminalId: shortString, type: external_exports.literal("terminal") }).readonly()
+]);
+var toolCallLocationSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  line: external_exports.number().int().nonnegative().safe().nullable().optional(),
+  path: boundedString
+}).readonly();
+var toolKindSchema = external_exports.enum([
+  "read",
+  "edit",
+  "delete",
+  "move",
+  "search",
+  "execute",
+  "think",
+  "fetch",
+  "switch_mode",
+  "other"
+]);
+var toolStatusSchema = external_exports.enum(["pending", "in_progress", "completed", "failed"]);
+var toolPatchFields = {
+  _meta: optionalMetadata,
+  content: external_exports.array(toolCallContentSchema).max(MAX_COLLECTION_SIZE).readonly().nullable().optional(),
+  kind: toolKindSchema.nullable().optional(),
+  locations: external_exports.array(toolCallLocationSchema).max(MAX_COLLECTION_SIZE).readonly().nullable().optional(),
+  name: shortString.nullable().optional(),
+  rawInput: boundedJsonSchema.optional(),
+  rawOutput: boundedJsonSchema.optional(),
+  status: toolStatusSchema.nullable().optional(),
+  title: boundedString.nullable().optional()
+};
+var planEntrySchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  content: boundedString,
+  priority: external_exports.enum(["high", "medium", "low"]),
+  status: external_exports.enum(["pending", "in_progress", "completed"])
+}).readonly();
+var planContentSchema = external_exports.discriminatedUnion("type", [
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    entries: external_exports.array(planEntrySchema).max(MAX_COLLECTION_SIZE).readonly(),
+    planId: shortString,
+    type: external_exports.literal("items")
+  }).readonly(),
+  external_exports.strictObject({ _meta: optionalMetadata, planId: shortString, type: external_exports.literal("file"), uri: boundedString }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    content: boundedString,
+    planId: shortString,
+    type: external_exports.literal("markdown")
+  }).readonly()
+]);
+var commandSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  description: boundedString,
+  input: external_exports.strictObject({ _meta: optionalMetadata, hint: boundedString }).readonly().nullable().optional(),
+  name: shortString
+}).readonly();
+var configSelectOptionSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  description: boundedString.nullable().optional(),
+  name: shortString,
+  value: shortString
+}).readonly();
+var configSelectGroupSchema = external_exports.strictObject({
+  _meta: optionalMetadata,
+  group: shortString,
+  name: shortString,
+  options: external_exports.array(configSelectOptionSchema).max(MAX_COLLECTION_SIZE).readonly()
 }).readonly();
-var eventEnvelopeSchema = external_exports.union([ephemeralEventEnvelopeSchema, reliableSessionEventEnvelopeSchema]).readonly();
-var acknowledgementOutcomeSchema = external_exports.discriminatedUnion("kind", [
-  external_exports.strictObject({ kind: external_exports.literal("relayed") }).readonly(),
+var configBaseFields = {
+  _meta: optionalMetadata,
+  category: shortString.nullable().optional(),
+  description: boundedString.nullable().optional(),
+  id: shortString,
+  name: shortString
+};
+var sessionConfigOptionSchema2 = external_exports.discriminatedUnion("type", [
+  external_exports.strictObject({
+    ...configBaseFields,
+    currentValue: shortString,
+    options: external_exports.union([
+      external_exports.array(configSelectOptionSchema).max(MAX_COLLECTION_SIZE).readonly(),
+      external_exports.array(configSelectGroupSchema).max(MAX_COLLECTION_SIZE).readonly()
+    ]),
+    type: external_exports.literal("select")
+  }).readonly(),
+  external_exports.strictObject({ ...configBaseFields, currentValue: external_exports.boolean(), type: external_exports.literal("boolean") }).readonly()
+]);
+var contentChunkFields = {
+  _meta: optionalMetadata,
+  content: contentBlockV2Schema,
+  messageId: shortString.nullable().optional()
+};
+var acpSessionUpdateV2Schema = external_exports.discriminatedUnion("sessionUpdate", [
+  external_exports.strictObject({ ...contentChunkFields, sessionUpdate: external_exports.literal("user_message_chunk") }).readonly(),
+  external_exports.strictObject({ ...contentChunkFields, sessionUpdate: external_exports.literal("agent_message_chunk") }).readonly(),
+  external_exports.strictObject({ ...contentChunkFields, sessionUpdate: external_exports.literal("agent_thought_chunk") }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    content: external_exports.array(toolCallContentSchema).max(MAX_COLLECTION_SIZE).readonly().optional(),
+    kind: toolKindSchema.optional(),
+    locations: external_exports.array(toolCallLocationSchema).max(MAX_COLLECTION_SIZE).readonly().optional(),
+    name: shortString.nullable().optional(),
+    rawInput: boundedJsonSchema.optional(),
+    rawOutput: boundedJsonSchema.optional(),
+    sessionUpdate: external_exports.literal("tool_call"),
+    status: toolStatusSchema.optional(),
+    title: boundedString,
+    toolCallId: shortString
+  }).readonly(),
+  external_exports.strictObject({ ...toolPatchFields, sessionUpdate: external_exports.literal("tool_call_update"), toolCallId: shortString }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    entries: external_exports.array(planEntrySchema).max(MAX_COLLECTION_SIZE).readonly(),
+    sessionUpdate: external_exports.literal("plan")
+  }).readonly(),
+  external_exports.strictObject({ _meta: optionalMetadata, plan: planContentSchema, sessionUpdate: external_exports.literal("plan_update") }).readonly(),
+  external_exports.strictObject({ _meta: optionalMetadata, planId: shortString, sessionUpdate: external_exports.literal("plan_removed") }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    availableCommands: external_exports.array(commandSchema).max(MAX_COLLECTION_SIZE).readonly(),
+    sessionUpdate: external_exports.literal("available_commands_update")
+  }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    currentModeId: shortString,
+    sessionUpdate: external_exports.literal("current_mode_update")
+  }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    configOptions: external_exports.array(sessionConfigOptionSchema2).max(MAX_COLLECTION_SIZE).readonly(),
+    sessionUpdate: external_exports.literal("config_option_update")
+  }).readonly(),
   external_exports.strictObject({
-    kind: external_exports.literal("recorded"),
-    providerId: identifierStringSchema,
-    recordingEpoch: identifierStringSchema
+    _meta: optionalMetadata,
+    sessionUpdate: external_exports.literal("session_info_update"),
+    title: boundedString.nullable().optional(),
+    updatedAt: shortString.nullable().optional()
+  }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    cost: external_exports.strictObject({ _meta: optionalMetadata, amount: external_exports.number().finite(), currency: external_exports.string().max(16) }).readonly().nullable().optional(),
+    sessionUpdate: external_exports.literal("usage_update"),
+    size: external_exports.number().int().nonnegative().safe(),
+    used: external_exports.number().int().nonnegative().safe()
+  }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    compactionId: shortString,
+    error: boundedString.nullable().optional(),
+    sessionUpdate: external_exports.literal("compaction_update"),
+    status: shortString,
+    summary: external_exports.array(contentBlockV2Schema).max(MAX_COLLECTION_SIZE).readonly().nullable().optional()
+  }).readonly(),
+  external_exports.strictObject({
+    _meta: optionalMetadata,
+    compactionId: shortString,
+    content: contentBlockV2Schema,
+    sessionUpdate: external_exports.literal("compaction_summary_chunk")
   }).readonly()
 ]);
-var eventAcknowledgementSchema = external_exports.strictObject({
+var lifecycleBase = { commandId: identifierStringSchema };
+var sessionEventPayloadV2Schema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ kind: external_exports.literal("acp.session.update"), update: acpSessionUpdateV2Schema }).readonly(),
+  external_exports.strictObject({
+    ...lifecycleBase,
+    content: external_exports.array(contentBlockV2Schema).min(1).max(100).readonly(),
+    kind: external_exports.literal("prompt.requested")
+  }).readonly(),
+  external_exports.strictObject({ ...lifecycleBase, attemptId: identifierStringSchema, epoch: identifierStringSchema, kind: external_exports.literal("prompt.started") }).readonly(),
+  external_exports.strictObject({ ...lifecycleBase, kind: external_exports.literal("prompt.completed"), stopReason: shortString }).readonly(),
+  external_exports.strictObject({
+    ...lifecycleBase,
+    code: identifierStringSchema,
+    kind: external_exports.literal("prompt.failed-before-start"),
+    message: external_exports.string().min(1).max(500)
+  }).readonly(),
+  external_exports.strictObject({
+    ...lifecycleBase,
+    attemptId: identifierStringSchema,
+    code: identifierStringSchema,
+    kind: external_exports.literal("prompt.failed"),
+    message: external_exports.string().min(1).max(500)
+  }).readonly()
+]);
+var positionSchema = external_exports.string().regex(/^(0|[1-9][0-9]*)$/);
+var provenanceSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ kind: external_exports.literal("original") }).readonly(),
+  external_exports.strictObject({
+    kind: external_exports.literal("imported"),
+    sourceEventId: identifierStringSchema,
+    sourcePosition: positionSchema,
+    sourceSessionId: identifierStringSchema
+  }).readonly(),
+  external_exports.strictObject({
+    kind: external_exports.literal("forked"),
+    sourceEventId: identifierStringSchema,
+    sourcePosition: positionSchema,
+    sourceSessionId: identifierStringSchema
+  }).readonly()
+]);
+var sessionEventV2Schema = external_exports.strictObject({
   eventId: identifierStringSchema,
-  kind: external_exports.literal(SESSION_EVENT_ACK_KIND),
-  outcome: acknowledgementOutcomeSchema,
+  payload: sessionEventPayloadV2Schema,
+  position: positionSchema,
+  provenance: provenanceSchema,
+  recordedAt: external_exports.iso.datetime({ offset: true }),
   sessionId: identifierStringSchema
 }).readonly();
-var eventDeferredSchema = external_exports.strictObject({
-  eventId: identifierStringSchema,
-  kind: external_exports.literal(SESSION_EVENT_DEFERRED_KIND),
-  retryAfterMilliseconds: external_exports.number().int().min(100).max(6e4),
-  sessionId: identifierStringSchema
+var sessionEventEnvelopeV2Schema = external_exports.strictObject({ event: sessionEventV2Schema, kind: external_exports.literal(SESSION_EVENT_V2_KIND) }).readonly();
+var sessionEventLogPageV2Schema = external_exports.strictObject({
+  events: external_exports.array(sessionEventV2Schema).max(MAX_EVENT_COUNT).readonly(),
+  nextCursor: external_exports.string().min(1).max(512).nullable(),
+  tailCursor: external_exports.string().max(512),
+  truncated: external_exports.boolean(),
+  version: external_exports.literal(2)
 }).readonly();
-var eventRejectedSchema = external_exports.strictObject({
-  code: external_exports.enum(SessionEventRejectionCode),
-  eventId: identifierStringSchema,
-  kind: external_exports.literal(SESSION_EVENT_REJECTED_KIND),
+var nativeEventPageRequestV2Schema = external_exports.strictObject({ cursor: external_exports.string().min(1).max(512).nullable(), eventLimit: external_exports.number().int().min(1).max(1e4) }).readonly();
+var executingPromptRequestEventLogV2Schema = external_exports.strictObject({
+  attemptId: identifierStringSchema,
+  commandId: identifierStringSchema,
+  epoch: identifierStringSchema,
+  events: external_exports.array(sessionEventV2Schema).max(MAX_EVENT_COUNT).readonly(),
+  tailCursor: external_exports.string().max(512),
+  truncated: external_exports.boolean()
+}).readonly();
+var nativeSessionEventsV2Schema = external_exports.strictObject({
+  executingPromptRequest: executingPromptRequestEventLogV2Schema.nullable(),
+  history: sessionEventLogPageV2Schema
+}).readonly();
+function inputValue(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch (cause) {
+    throw new ProtocolMessageError("Session Event Log V2 message is not valid JSON", { cause });
+  }
+}
+function decode5(value, schema) {
+  const result = schema.safeParse(inputValue(value));
+  if (!result.success) {
+    throw new ProtocolMessageError("Session Event Log V2 message does not match its schema", {
+      cause: result.error
+    });
+  }
+  return result.data;
+}
+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);
+
+// ../protocol/src/session-events.ts
+var SESSION_EVENT_KIND = "session.event";
+var SESSION_FORKED_KIND = "session.forked";
+var MAX_RECORDED_EVENT_LENGTH = 8 * 1024 * 1024;
+var sessionEventEnvelopeSchema = external_exports.strictObject({
+  kind: external_exports.literal(SESSION_EVENT_KIND),
+  payload: external_exports.string().min(2).max(MAX_RECORDED_EVENT_LENGTH),
   sessionId: identifierStringSchema
 }).readonly();
 var SESSION_QUEUE_CHANGED_KIND = "session.queue.changed";
@@ -21305,7 +21627,7 @@ var sessionForkedSchema = external_exports.strictObject({
   sourceSessionId: identifierStringSchema,
   throughCommandId: identifierStringSchema
 }).readonly();
-function decode5(encoded, schema) {
+function decode6(encoded, schema) {
   let value;
   try {
     value = JSON.parse(encoded);
@@ -21320,7 +21642,7 @@ function decode5(encoded, schema) {
   }
   return decoded.data;
 }
-var encode4 = (message, schema) => {
+var encode5 = (message, schema) => {
   const decoded = schema.safeParse(message);
   if (!decoded.success) {
     throw new ProtocolMessageError("Message does not match its schema", {
@@ -21329,21 +21651,15 @@ var encode4 = (message, schema) => {
   }
   return JSON.stringify(decoded.data);
 };
-var decodeSessionEventEnvelope = (encoded) => decode5(encoded, eventEnvelopeSchema);
-var encodeSessionEventEnvelope = (message) => encode4(message, eventEnvelopeSchema);
-var decodeSessionEventAcknowledgement = (encoded) => decode5(encoded, eventAcknowledgementSchema);
-var encodeSessionEventAcknowledgement = (message) => encode4(message, eventAcknowledgementSchema);
-var decodeSessionEventDeferred = (encoded) => decode5(encoded, eventDeferredSchema);
-var encodeSessionEventDeferred = (message) => encode4(message, eventDeferredSchema);
-var decodeSessionEventRejected = (encoded) => decode5(encoded, eventRejectedSchema);
-var encodeSessionEventRejected = (message) => encode4(message, eventRejectedSchema);
+var decodeSessionEventEnvelope = (encoded) => decode6(encoded, sessionEventEnvelopeSchema);
+var encodeSessionEventEnvelope = (message) => encode5(message, sessionEventEnvelopeSchema);
 function decodeRecordedSessionEvent(encoded) {
   const kind = decodeMessageKind(encoded);
   switch (kind) {
     case SESSION_QUEUE_CHANGED_KIND:
-      return decode5(encoded, sessionQueueChangedSchema);
+      return decode6(encoded, sessionQueueChangedSchema);
     case SESSION_FORKED_KIND:
-      return decode5(encoded, sessionForkedSchema);
+      return decode6(encoded, sessionForkedSchema);
     case AGENT_ACTIVITY_KIND:
       return decodeAgentActivityEvent(encoded);
     case AGENT_ACTIVITY_NARRATION_KIND:
@@ -21387,6 +21703,8 @@ var SESSION_LIVE_HISTORY_LOAD_KIND = "session.live-history.load";
 var SESSION_LIVE_HISTORY_LOADED_KIND = "session.live-history.loaded";
 var SESSION_LIVE_HISTORY_PAGE_LOAD_KIND = "session.live-history.page.load";
 var SESSION_LIVE_HISTORY_PAGE_LOADED_KIND = "session.live-history.page.loaded";
+var SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND = "session.live-history.v2.page.load";
+var SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND = "session.live-history.v2.page.loaded";
 var directoryIdentifier = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,2047}$/);
 var sessionLiveHistoryLoadSchema = external_exports.strictObject({
   additionalDirectoryIds: external_exports.array(directoryIdentifier).max(16).readonly(),
@@ -21420,7 +21738,24 @@ var sessionLiveHistoryPageLoadedSchema = external_exports.strictObject({
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
 }).readonly();
-function decode6(schema, encoded) {
+var sessionLiveHistoryV2PageLoadSchema = external_exports.strictObject({
+  additionalDirectoryIds: external_exports.array(directoryIdentifier).max(16).readonly(),
+  agentId: identifierStringSchema,
+  bindingId: identifierStringSchema,
+  cursor: external_exports.string().min(1).max(512).nullable(),
+  directoryId: directoryIdentifier,
+  kind: external_exports.literal(SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND),
+  eventLimit: external_exports.number().int().min(1).max(1e4),
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+}).readonly();
+var sessionLiveHistoryV2PageLoadedSchema = external_exports.strictObject({
+  events: nativeSessionEventsV2Schema,
+  kind: external_exports.literal(SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND),
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+}).readonly();
+function decode7(schema, encoded) {
   try {
     const value = JSON.parse(encoded);
     return schema.parse(value);
@@ -21428,14 +21763,18 @@ function decode6(schema, encoded) {
     throw new ProtocolMessageError("Invalid live Session history message", { cause });
   }
 }
-var decodeSessionLiveHistoryLoad = (encoded) => decode6(sessionLiveHistoryLoadSchema, encoded);
-var decodeSessionLiveHistoryLoaded = (encoded) => decode6(sessionLiveHistoryLoadedSchema, encoded);
+var decodeSessionLiveHistoryLoad = (encoded) => decode7(sessionLiveHistoryLoadSchema, encoded);
+var decodeSessionLiveHistoryLoaded = (encoded) => decode7(sessionLiveHistoryLoadedSchema, encoded);
 var encodeSessionLiveHistoryLoad = (value) => JSON.stringify(sessionLiveHistoryLoadSchema.parse(value));
 var encodeSessionLiveHistoryLoaded = (value) => JSON.stringify(sessionLiveHistoryLoadedSchema.parse(value));
-var decodeSessionLiveHistoryPageLoad = (encoded) => decode6(sessionLiveHistoryPageLoadSchema, encoded);
-var decodeSessionLiveHistoryPageLoaded = (encoded) => decode6(sessionLiveHistoryPageLoadedSchema, encoded);
+var decodeSessionLiveHistoryPageLoad = (encoded) => decode7(sessionLiveHistoryPageLoadSchema, encoded);
+var decodeSessionLiveHistoryPageLoaded = (encoded) => decode7(sessionLiveHistoryPageLoadedSchema, encoded);
 var encodeSessionLiveHistoryPageLoad = (value) => JSON.stringify(sessionLiveHistoryPageLoadSchema.parse(value));
 var encodeSessionLiveHistoryPageLoaded = (value) => JSON.stringify(sessionLiveHistoryPageLoadedSchema.parse(value));
+var decodeSessionLiveHistoryV2PageLoad = (encoded) => decode7(sessionLiveHistoryV2PageLoadSchema, encoded);
+var decodeSessionLiveHistoryV2PageLoaded = (encoded) => decode7(sessionLiveHistoryV2PageLoadedSchema, encoded);
+var encodeSessionLiveHistoryV2PageLoad = (value) => JSON.stringify(sessionLiveHistoryV2PageLoadSchema.parse(value));
+var encodeSessionLiveHistoryV2PageLoaded = (value) => JSON.stringify(sessionLiveHistoryV2PageLoadedSchema.parse(value));
 
 // ../protocol/src/daemon-transport.ts
 function defineMessageSignature(kind, encoder, decoder) {
@@ -21510,21 +21849,6 @@ var serviceToDaemonSignatures = {
     encodeSessionElicitationRespondCommand,
     decodeSessionElicitationRespondCommand
   ),
-  [SESSION_EVENT_ACK_KIND]: defineMessageSignature(
-    SESSION_EVENT_ACK_KIND,
-    encodeSessionEventAcknowledgement,
-    decodeSessionEventAcknowledgement
-  ),
-  [SESSION_EVENT_DEFERRED_KIND]: defineMessageSignature(
-    SESSION_EVENT_DEFERRED_KIND,
-    encodeSessionEventDeferred,
-    decodeSessionEventDeferred
-  ),
-  [SESSION_EVENT_REJECTED_KIND]: defineMessageSignature(
-    SESSION_EVENT_REJECTED_KIND,
-    encodeSessionEventRejected,
-    decodeSessionEventRejected
-  ),
   [SESSION_LIVE_HISTORY_LOAD_KIND]: defineMessageSignature(
     SESSION_LIVE_HISTORY_LOAD_KIND,
     encodeSessionLiveHistoryLoad,
@@ -21535,6 +21859,11 @@ var serviceToDaemonSignatures = {
     encodeSessionLiveHistoryPageLoad,
     decodeSessionLiveHistoryPageLoad
   ),
+  [SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND]: defineMessageSignature(
+    SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND,
+    encodeSessionLiveHistoryV2PageLoad,
+    decodeSessionLiveHistoryV2PageLoad
+  ),
   [SESSION_PERMISSION_RESPOND_KIND]: defineMessageSignature(
     SESSION_PERMISSION_RESPOND_KIND,
     encodeSessionPermissionRespondCommand,
@@ -21650,6 +21979,11 @@ var daemonToServiceSignatures = {
     encodeSessionEventEnvelope,
     decodeSessionEventEnvelope
   ),
+  [SESSION_EVENT_V2_KIND]: defineMessageSignature(
+    SESSION_EVENT_V2_KIND,
+    encodeSessionEventEnvelopeV2,
+    decodeSessionEventEnvelopeV2
+  ),
   [SESSION_OPERATION_FAILED_KIND]: defineMessageSignature(
     SESSION_OPERATION_FAILED_KIND,
     encodeSessionOperationFailedEvent,
@@ -21665,6 +21999,11 @@ var daemonToServiceSignatures = {
     encodeSessionLiveHistoryPageLoaded,
     decodeSessionLiveHistoryPageLoaded
   ),
+  [SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND]: defineMessageSignature(
+    SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND,
+    encodeSessionLiveHistoryV2PageLoaded,
+    decodeSessionLiveHistoryV2PageLoaded
+  ),
   [SESSION_READY_KIND]: defineMessageSignature(SESSION_READY_KIND, encodeSessionReadyEvent, decodeSessionReadyEvent),
   [WORKSPACE_ENTRIES_KIND]: defineMessageSignature(
     WORKSPACE_ENTRIES_KIND,
@@ -22654,7 +22993,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)) {
@@ -22782,7 +23121,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)) {
@@ -22911,10 +23250,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)}`;
 }
@@ -24107,6 +24446,7 @@ function sessionConfigProtocolForAgent(_agentId) {
 
 // src/acp/session-contracts.ts
 var NullAcpSessionObserver = class {
+  onAcpUpdate = (_sessionId, _update) => Promise.resolve();
   onCommands = () => Promise.resolve();
   onConfig = () => Promise.resolve();
   onContent = () => Promise.resolve();
@@ -24231,6 +24571,7 @@ function historyContentCharacters(messages) {
 var AcpHistoryReplay = class {
   #activities = /* @__PURE__ */ new Map();
   #messages = [];
+  #updates = [];
   #turnActivityIds = /* @__PURE__ */ new Set();
   #activityTracker = new AcpActivityTracker(
     async (activity2) => {
@@ -24252,7 +24593,8 @@ var AcpHistoryReplay = class {
   #firstMessageIndex = 0;
   #characters = 0;
   #truncated = false;
-  record = async (update) => {
+  record = async (update, rawUpdate) => {
+    this.#updates.push(rawUpdate);
     if (update.sessionUpdate === "agent_thought_chunk") {
       if (update.content.type === "text") {
         await this.#activityTracker.recordNarrative(
@@ -24333,6 +24675,20 @@ var AcpHistoryReplay = class {
     this.#lastMessageId = id;
     this.trimMessages();
   };
+  eventPage = (eventLimit, cursor) => {
+    const parsedCursor = cursor === null ? this.#updates.length : Number(cursor);
+    if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0 || parsedCursor > this.#updates.length) {
+      throw new Error("The native event cursor is invalid");
+    }
+    const endUpdate = parsedCursor;
+    const startUpdate = Math.max(0, endUpdate - eventLimit);
+    return {
+      nextCursor: startUpdate === 0 ? null : startUpdate.toString(),
+      startPosition: startUpdate + 1,
+      truncated: startUpdate > 0,
+      updates: this.#updates.slice(startUpdate, endUpdate)
+    };
+  };
   snapshot = async () => {
     await this.#activityTracker.finish();
     const messages = this.#messages.slice(this.#firstMessageIndex).map((message) => {
@@ -26320,8 +26676,8 @@ function haveSameKeys(left, right) {
   if (leftKeys.length !== rightKeys.length) {
     return false;
   }
-  for (const [index, key] of leftKeys.entries()) {
-    if (key !== rightKeys[index]) {
+  for (const [index2, key] of leftKeys.entries()) {
+    if (key !== rightKeys[index2]) {
       return false;
     }
   }
@@ -27509,6 +27865,55 @@ var sqliteTable = (name, columns, extraConfig) => {
   return sqliteTableBase(name, columns, extraConfig);
 };
 
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6.13_better-sqlite3@12.4.1/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name, columns, unique) {
+    this.config = {
+      name,
+      columns,
+      unique,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config2, table) {
+    this.config = { ...config2, table };
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(name, true);
+}
+
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6.13_better-sqlite3@12.4.1/node_modules/drizzle-orm/sqlite-core/utils.js
 function extractUsedTable(table) {
   if (is(table, SQLiteTable)) {
@@ -27857,8 +28262,8 @@ var SQLiteDialect = class {
     }
     const joinsArray = [];
     if (joins) {
-      for (const [index, joinMeta] of joins.entries()) {
-        if (index === 0) {
+      for (const [index2, joinMeta] of joins.entries()) {
+        if (index2 === 0) {
           joinsArray.push(sql` `);
         }
         const table = joinMeta.table;
@@ -27878,7 +28283,7 @@ var SQLiteDialect = class {
             sql`${sql.raw(joinMeta.joinType)} join ${table}${onSql}`
           );
         }
-        if (index < joins.length - 1) {
+        if (index2 < joins.length - 1) {
           joinsArray.push(sql` `);
         }
       }
@@ -27891,9 +28296,9 @@ var SQLiteDialect = class {
   buildOrderBy(orderBy) {
     const orderByList = [];
     if (orderBy) {
-      for (const [index, orderByValue] of orderBy.entries()) {
+      for (const [index2, orderByValue] of orderBy.entries()) {
         orderByList.push(orderByValue);
-        if (index < orderBy.length - 1) {
+        if (index2 < orderBy.length - 1) {
           orderByList.push(sql`, `);
         }
       }
@@ -27946,9 +28351,9 @@ var SQLiteDialect = class {
     const havingSql = having ? sql` having ${having}` : void 0;
     const groupByList = [];
     if (groupBy) {
-      for (const [index, groupByValue] of groupBy.entries()) {
+      for (const [index2, groupByValue] of groupBy.entries()) {
         groupByList.push(groupByValue);
-        if (index < groupBy.length - 1) {
+        if (index2 < groupBy.length - 1) {
           groupByList.push(sql`, `);
         }
       }
@@ -30362,6 +30767,10 @@ var acpSessionStoreMigrations = [
   {
     "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`);"
   }
 ];
 
@@ -30369,7 +30778,8 @@ var acpSessionStoreMigrations = [
 var acp_session_store_exports = {};
 __export(acp_session_store_exports, {
   acpSession: () => acpSession,
-  deletedAcpSession: () => deletedAcpSession
+  deletedAcpSession: () => deletedAcpSession,
+  sessionEventV2: () => sessionEventV2
 });
 
 // src/schema/acp-session-store/acp-session.ts
@@ -30390,6 +30800,21 @@ var deletedAcpSession = sqliteTable("deleted_acp_session", {
   sessionId: text("session_id").primaryKey()
 });
 
+// src/schema/acp-session-store/session-event-v2.ts
+var sessionEventV2 = sqliteTable(
+  "session_event_v2",
+  {
+    eventId: text("event_id").primaryKey(),
+    eventJson: text("event_json").notNull(),
+    position: integer2("position").notNull(),
+    sessionId: text("session_id").notNull()
+  },
+  (table) => [
+    uniqueIndex("session_event_v2_session_position_unique").on(table.sessionId, table.position),
+    index("session_event_v2_session_position_index").on(table.sessionId, table.position)
+  ]
+);
+
 // src/acp/session-store.ts
 var AcpStoredSession = class {
   additionalDirectories;
@@ -30432,9 +30857,14 @@ var DeletedAcpStoredSession = class extends AcpStoredSessionLookup {
 var MemoryAcpSessionStore = class {
   #sessions = /* @__PURE__ */ new Map();
   #deleted = /* @__PURE__ */ new Set();
+  #eventsV2 = /* @__PURE__ */ new Map();
+  appendEventV2 = (event) => {
+    this.#eventsV2.set(event.sessionId, [...this.#eventsV2.get(event.sessionId) ?? [], event]);
+  };
   close = () => {
     this.#sessions.clear();
     this.#deleted.clear();
+    this.#eventsV2.clear();
   };
   findNative = (agentId, nativeSessionId) => [...this.#sessions.values()].filter(
     (session) => session.agentId === agentId && session.nativeSessionId === nativeSessionId
@@ -30445,6 +30875,7 @@ var MemoryAcpSessionStore = class {
     for (const id of ids) {
       this.#sessions.delete(id);
       this.#deleted.add(id);
+      this.#eventsV2.delete(id);
     }
     return ids;
   };
@@ -30457,7 +30888,9 @@ var MemoryAcpSessionStore = class {
   };
   remove = (sessionId) => {
     this.#sessions.delete(sessionId);
+    this.#eventsV2.delete(sessionId);
   };
+  readEventsV2 = (sessionId) => this.#eventsV2.get(sessionId) ?? [];
   write = (session) => {
     this.#sessions.set(session.sessionId, session);
   };
@@ -30506,15 +30939,15 @@ var SqliteAcpSessionStore = class {
       this.#sqliteDatabase.close();
       throw new Error("The ACP Session database was created by a newer Mobius version");
     }
-    for (let index = version3; index < acpSessionStoreMigrations.length; index += 1) {
-      const migration = acpSessionStoreMigrations[index];
+    for (let index2 = version3; index2 < acpSessionStoreMigrations.length; index2 += 1) {
+      const migration = acpSessionStoreMigrations[index2];
       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.pragma(`user_version = ${index + 1}`);
+        this.#sqliteDatabase.pragma(`user_version = ${index2 + 1}`);
         this.#sqliteDatabase.exec("COMMIT");
       } catch (error62) {
         this.#sqliteDatabase.exec("ROLLBACK");
@@ -30525,6 +30958,14 @@ var SqliteAcpSessionStore = class {
   close = () => {
     this.#sqliteDatabase.close();
   };
+  appendEventV2 = (event) => {
+    this.#database.insert(sessionEventV2).values({
+      eventId: event.eventId,
+      eventJson: JSON.stringify(event),
+      position: Number(event.position),
+      sessionId: event.sessionId
+    }).run();
+  };
   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) => {
@@ -30533,6 +30974,7 @@ var SqliteAcpSessionStore = class {
       transaction.delete(acpSession).where(and(eq(acpSession.agentId, agentId), eq(acpSession.nativeSessionId, nativeSessionId))).run();
       for (const id of ids) {
         transaction.insert(deletedAcpSession).values({ sessionId: id }).onConflictDoNothing().run();
+        transaction.delete(sessionEventV2).where(eq(sessionEventV2.sessionId, id)).run();
       }
     });
     return ids;
@@ -30546,8 +30988,12 @@ var SqliteAcpSessionStore = class {
     const row = this.#database.select().from(acpSession).where(eq(acpSession.sessionId, sessionId)).get();
     return row === void 0 ? new MissingAcpStoredSession() : new FoundAcpStoredSession(decodeStoredSession(row));
   };
+  readEventsV2 = (sessionId) => this.#database.select({ eventJson: sessionEventV2.eventJson }).from(sessionEventV2).where(eq(sessionEventV2.sessionId, sessionId)).orderBy(asc(sessionEventV2.position)).all().map((row) => decodeSessionEventV2(row.eventJson));
   remove = (sessionId) => {
-    this.#database.delete(acpSession).where(eq(acpSession.sessionId, sessionId)).run();
+    this.#database.transaction((transaction) => {
+      transaction.delete(acpSession).where(eq(acpSession.sessionId, sessionId)).run();
+      transaction.delete(sessionEventV2).where(eq(sessionEventV2.sessionId, sessionId)).run();
+    });
   };
   write = (session) => {
     const value = {
@@ -30580,7 +31026,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);
@@ -30727,6 +31173,17 @@ var AgentSession = class _AgentSession {
     const loaded = await this.#loadSession(signal, "ACP agent exited while loading history");
     return await embedLocalHistoryImages(await loaded.history.snapshot(), signal);
   };
+  loadHistoryEventsV2 = async (eventLimit, cursor, signal) => {
+    if (!this.#capabilities.loadSession) {
+      throw new AcpExecutionError(
+        "This Agent restores context but does not provide message history.",
+        {},
+        "native_history_unsupported"
+      );
+    }
+    const loaded = await this.#loadSession(signal, "ACP agent exited while loading history");
+    return loaded.history.eventPage(eventLimit, cursor);
+  };
   async #loadSession(signal, exitMessage) {
     if (this.#sessionLoad.kind === "loaded") {
       return this.#sessionLoad;
@@ -31373,8 +31830,14 @@ var AgentSession = class _AgentSession {
   #processUpdate = async (notification) => {
     this.assertNativeSession(notification.sessionId);
     const update = notification.update;
+    const rawUpdate = decodeAcpSessionUpdateV2(JSON.stringify(update));
     if (this.#sessionLoad.kind !== "not-requested") {
-      await this.#sessionLoad.history.record(update);
+      await this.#sessionLoad.history.record(update, rawUpdate);
+    } else {
+      const onAcpUpdate = this.#getObserver().onAcpUpdate;
+      if (onAcpUpdate !== void 0) {
+        await onAcpUpdate(this.#mobiusSessionId, rawUpdate);
+      }
     }
     if (this.#sessionLoad.kind === "capturing" && (update.sessionUpdate === "user_message_chunk" || update.sessionUpdate === "agent_message_chunk" || update.sessionUpdate === "agent_thought_chunk" || update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update" || update.sessionUpdate === "plan" || update.sessionUpdate === "plan_update" || update.sessionUpdate === "plan_removed")) {
       return;
@@ -31756,6 +32219,21 @@ var AgentQueryProcesses = class {
       async (runtime) => await runtime.closeProcess()
     );
   };
+  previewEventsV2 = async (options, nativeSessionId, eventLimit, cursor) => {
+    return await this.#processes.runTransient(
+      options.signal,
+      async () => await AgentSession.startNativeSessionBrowser(
+        options,
+        () => this.#observer,
+        new MemoryAcpSessionStore()
+      ),
+      async (runtime) => {
+        runtime.selectNativeSession(nativeSessionId);
+        return await runtime.loadHistoryEventsV2(eventLimit, cursor, options.signal);
+      },
+      async (runtime) => await runtime.closeProcess()
+    );
+  };
   close = async () => {
     await Promise.all(
       this.#processesByQuery.entries().map(async ([id, runtime]) => await this.retire(id, runtime))
@@ -31825,9 +32303,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);
       }
     }
   };
@@ -32457,6 +32935,22 @@ var AgentRuntimeManager = class {
       this.#nativeOperations.delete(key);
     }
   });
+  previewNativeSessionEventsV2 = async (options, nativeSessionId, eventLimit, cursor) => this.#operations.run(options, async (options2) => {
+    const key = `${options2.agent.id}:${nativeSessionId}`;
+    if (this.#nativeOperations.has(key)) {
+      throw new AcpExecutionError(
+        "Wait for the native session's running operation to finish",
+        {},
+        "session_busy"
+      );
+    }
+    this.#nativeOperations.add(key);
+    try {
+      return await this.#queryProcesses.previewEventsV2(options2, nativeSessionId, eventLimit, cursor);
+    } finally {
+      this.#nativeOperations.delete(key);
+    }
+  });
   loadSessionHistory = async (options) => this.#operations.run(options, async (options2) => {
     return await this.#executionProcesses.use(options2.sessionId, async () => {
       const runtime = await this.ensureSession(options2);
@@ -32474,6 +32968,12 @@ var AgentRuntimeManager = class {
       return await runtime.loadHistory(options2.signal);
     });
   });
+  loadSessionEventsV2 = async (options, eventLimit, cursor) => this.#operations.run(options, async (options2) => {
+    return await this.#executionProcesses.use(options2.sessionId, async () => {
+      const runtime = await this.ensureSession(options2);
+      return await runtime.loadHistoryEventsV2(eventLimit, cursor, options2.signal);
+    });
+  });
   openNativeSession = async (options, origin) => this.#operations.run(options, async (options2) => {
     const key = `${options2.agent.id}:${origin.nativeSessionId}`;
     if (this.#nativeOperations.has(key)) {
@@ -36376,9 +36876,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;
     }
@@ -36403,8 +36903,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);
     }
@@ -37147,16 +37647,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(
@@ -37351,16 +37851,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`);
@@ -37368,8 +37868,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"}`);
     }
@@ -37660,7 +38160,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID7 } from "node:crypto";
 import { join as join18 } from "node:path";
 import { styleText } from "node:util";
 
@@ -38732,9 +39232,15 @@ function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTi
 // src/daemon-observers.ts
 var DaemonAcpObserver = class {
   #record;
-  constructor(record2) {
+  #recordV2;
+  constructor(record2, recordV2 = () => void 0) {
     this.#record = record2;
+    this.#recordV2 = recordV2;
   }
+  onAcpUpdate = (sessionId, update) => {
+    this.#recordV2(sessionId, update);
+    return Promise.resolve();
+  };
   onCommands = (event) => {
     this.#record(event.sessionId, event);
     return Promise.resolve();
@@ -38871,8 +39377,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;
     }
@@ -39013,7 +39519,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) {
@@ -40024,7 +40530,7 @@ async function readAcpHistory(sessions, directories, bindingId, options, nativeS
           async (directory) => await directories.identify(bindingId, directory, options.signal)
         )
       );
-      if (primary.path !== options.cwd || additional.length !== options.additionalDirectories.length || additional.some((directory, index) => directory.path !== options.additionalDirectories[index])) {
+      if (primary.path !== options.cwd || additional.length !== options.additionalDirectories.length || additional.some((directory, index2) => directory.path !== options.additionalDirectories[index2])) {
         throw new AcpExecutionError(
           "The native Session belongs to another workspace.",
           {},
@@ -40157,7 +40663,7 @@ var NativeSessionService = class {
           "native_session_not_found"
         );
       }
-      if (source.agentId !== command.agentId || source.cwd !== cwd || source.additionalDirectories.length !== additionalDirectories.length || source.additionalDirectories.some((path2, index) => path2 !== additionalDirectories[index])) {
+      if (source.agentId !== command.agentId || source.cwd !== cwd || source.additionalDirectories.length !== additionalDirectories.length || source.additionalDirectories.some((path2, index2) => path2 !== additionalDirectories[index2])) {
         throw new AcpExecutionError(
           "The source conversation execution target does not match the fork request",
           {},
@@ -40178,8 +40684,8 @@ var NativeSessionService = class {
       signal.throwIfAborted();
       const directory = await this.#directories.list(this.#config.bindingId, command.directoryId, signal);
       const ready2 = {
-        additionalDirectories: additionalDirectories.map((path2, index) => ({
-          directoryId: command.additionalDirectoryIds[index] ?? command.directoryId,
+        additionalDirectories: additionalDirectories.map((path2, index2) => ({
+          directoryId: command.additionalDirectoryIds[index2] ?? command.directoryId,
           name: basename5(path2) || path2
         })),
         agentId: command.agentId,
@@ -40511,7 +41017,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) {
@@ -40519,7 +41025,7 @@ var NativeSessionService = class {
         if (target === null) {
           throw new LocalAuthorizationError("The selected native session is not authorized");
         }
-        if (target.cwd !== selected.cwd || target.additionalDirectories.length !== selected.additionalDirectories.length || target.additionalDirectories.some((path2, index2) => path2 !== selected.additionalDirectories[index2])) {
+        if (target.cwd !== selected.cwd || target.additionalDirectories.length !== selected.additionalDirectories.length || target.additionalDirectories.some((path2, index3) => path2 !== selected.additionalDirectories[index3])) {
           throw new AcpExecutionError(
             "This session's directory changed. Refresh the list before continuing.",
             {},
@@ -41607,6 +42113,9 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
   });
 }
 
+// src/daemon-history-commands.ts
+import { createHash as createHash6 } from "node:crypto";
+
 // src/authorization/resolve-session-directories.ts
 import { basename as basename7 } from "node:path";
 var ResolvedSessionDirectories = class {
@@ -41706,8 +42215,8 @@ function selectMessagesBefore(messages, endIndex, messageLimit, characterLimit)
   const selected = [];
   let remainingCharacters = characterLimit;
   let startIndex = endIndex;
-  for (let index = endIndex - 1; index >= 0 && selected.length < messageLimit; index -= 1) {
-    const message = messages[index];
+  for (let index2 = endIndex - 1; index2 >= 0 && selected.length < messageLimit; index2 -= 1) {
+    const message = messages[index2];
     if (message === void 0) {
       break;
     }
@@ -41717,7 +42226,7 @@ function selectMessagesBefore(messages, endIndex, messageLimit, characterLimit)
     }
     selected.unshift(message);
     remainingCharacters -= characters;
-    startIndex = index;
+    startIndex = index2;
   }
   if (selected.length === 0 && endIndex > 0) {
     throw new AcpExecutionError(
@@ -41997,6 +42506,79 @@ async function executeSessionLiveHistoryPageLoad(socket, command, config2, direc
     });
   }
 }
+function replayEvent(sessionId, position, update) {
+  const encoded = JSON.stringify(update);
+  const eventId = `native-${createHash6("sha256").update(sessionId).update(":").update(position.toString()).update(":").update(encoded).digest("hex")}`;
+  return {
+    eventId,
+    payload: { kind: "acp.session.update", update },
+    position: position.toString(),
+    provenance: { kind: "original" },
+    recordedAt: "1970-01-01T00:00:00.000Z",
+    sessionId
+  };
+}
+async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, sessions, localRecovery, executingPromptRequest, signal) {
+  try {
+    const local = localRecovery(command.sessionId, command.eventLimit, command.cursor);
+    if (local !== null) {
+      send(socket, {
+        events: local,
+        kind: "session.live-history.v2.page.loaded",
+        requestId: command.requestId,
+        sessionId: command.sessionId
+      });
+      return;
+    }
+    const resolved = await resolveSessionDirectories(
+      directories,
+      config2.bindingId,
+      command.directoryId,
+      command.additionalDirectoryIds,
+      signal
+    );
+    const replay = await sessions.loadSessionEventsV2(
+      {
+        additionalDirectories: resolved.additionalDirectories,
+        agent: config2.catalog.find(command.agentId),
+        cwd: resolved.cwd,
+        sessionId: command.sessionId,
+        signal
+      },
+      command.eventLimit,
+      command.cursor
+    );
+    signal.throwIfAborted();
+    const events = replay.updates.map(
+      (update, index2) => replayEvent(command.sessionId, replay.startPosition + index2, update)
+    );
+    const tailCursor = events.at(-1)?.eventId ?? "";
+    audit.record({
+      commandId: command.requestId,
+      event: "session_event_log_v2_loaded",
+      sessionId: command.sessionId
+    });
+    send(socket, {
+      events: {
+        executingPromptRequest: executingPromptRequest(command.sessionId),
+        history: {
+          events,
+          nextCursor: replay.nextCursor,
+          tailCursor,
+          truncated: replay.truncated,
+          version: 2
+        }
+      },
+      kind: "session.live-history.v2.page.loaded",
+      requestId: command.requestId,
+      sessionId: command.sessionId
+    });
+  } catch (error62) {
+    if (!signal.aborted) {
+      reportOperationFailure(socket, command.requestId, command.sessionId, error62);
+    }
+  }
+}
 
 // src/acp/session-config/apply-session-configuration.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -42311,6 +42893,7 @@ function daemonActivity(command, activity2) {
 async function executePrompt({
   operations,
   publisher,
+  eventLogV2,
   command,
   config: config2,
   directories,
@@ -42415,6 +42998,7 @@ async function executePrompt({
       }
     }
     const stream = activateAttempt();
+    eventLogV2.started(command.sessionId, command.commandId, attemptId, stream.epoch);
     if (!prepared.prompted) {
       const listing = await directories.list(config2.bindingId, command.directoryId, signal);
       publisher.publish(command.sessionId, {
@@ -42484,6 +43068,7 @@ async function executePrompt({
       sessionId: command.sessionId,
       stopReason
     });
+    eventLogV2.completed(command.sessionId, command.commandId, stopReason);
     operations.transitionExecution(command.commandId, stopReason === "cancelled" ? "cancelled" : "succeeded");
     audit.record({
       commandId: command.commandId,
@@ -42499,6 +43084,7 @@ async function executePrompt({
         sessionId: command.sessionId,
         stopReason: "cancelled"
       });
+      eventLogV2.completed(command.sessionId, command.commandId, "cancelled");
       operations.transitionExecution(command.commandId, "cancelled");
       audit.record({
         commandId: command.commandId,
@@ -42513,12 +43099,10 @@ async function executePrompt({
       sessionId: command.sessionId
     });
     const code = operationErrorCode(error62);
-    reportFailure(
-      publisher,
-      command,
-      code === "session_operation_failed" ? "agent_execution_failed" : code,
-      code === "session_operation_failed" ? "The local agent could not complete the request" : operationErrorMessage(error62)
-    );
+    const failureCode = code === "session_operation_failed" ? "agent_execution_failed" : code;
+    const failureMessage = code === "session_operation_failed" ? "The local agent could not complete the request" : operationErrorMessage(error62);
+    eventLogV2.failed(command.sessionId, command.commandId, failureCode, failureMessage);
+    reportFailure(publisher, command, failureCode, failureMessage);
     operations.transitionExecution(command.commandId, "failed");
     console.error("Mobius daemon command failed", error62);
   }
@@ -42801,6 +43385,7 @@ function createDaemonCommandHandler({
   nativeSessions,
   operations,
   publisher,
+  eventLogV2,
   activeTurns,
   diagnostics,
   socket,
@@ -42870,6 +43455,20 @@ function createDaemonCommandHandler({
         );
         return;
       }
+      if (kind === SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND) {
+        void executeSessionLiveHistoryV2PageLoad(
+          socket,
+          message,
+          config2,
+          directories,
+          audit,
+          sessions,
+          eventLogV2.recovery,
+          eventLogV2.executingPromptRequest,
+          signal
+        );
+        return;
+      }
       if (kind === NATIVE_SESSION_CANCEL_KIND) {
         nativeRequestHandler.cancel(message);
         return;
@@ -43055,9 +43654,11 @@ function createDaemonCommandHandler({
         return;
       }
       const turn = activeTurns.start(command, receipt.attemptId);
+      eventLogV2.requested(command);
       void executePrompt({
         operations,
         publisher,
+        eventLogV2,
         command,
         config: config2,
         directories,
@@ -43327,6 +43928,7 @@ async function runRelayConnection({
   nativeSessions,
   operations,
   publisher,
+  eventLogV2,
   activeTurns,
   connectionEpoch,
   diagnostics,
@@ -43337,7 +43939,6 @@ async function runRelayConnection({
 }) {
   const relayUrl = new URL(config2.relayUrl);
   relayUrl.searchParams.set("liveness", "1");
-  relayUrl.searchParams.set("sessionEventDelivery", "reliable-v1");
   const socket = await connectRelay(relayUrl, signal);
   diagnostics.connectionOpened(connectionEpoch);
   const connectionController = new AbortController();
@@ -43350,6 +43951,7 @@ async function runRelayConnection({
     nativeSessions,
     operations,
     publisher,
+    eventLogV2,
     activeTurns,
     diagnostics,
     socket,
@@ -43457,10 +44059,7 @@ async function runRelayConnection({
           const message = decodeServiceToDaemonMessage(encoded);
           const kind = message.kind;
           if (kind === RUNTIME_LIVENESS_READY_KIND) {
-            publisher.connect(
-              socket,
-              message.sessionEventDelivery === "reliable-v1" ? "reliable" : "ephemeral"
-            );
+            publisher.connect(socket);
             connectionLiveness.start();
             return;
           }
@@ -43468,18 +44067,6 @@ async function runRelayConnection({
             connectionLiveness.acknowledge(message);
             return;
           }
-          if (kind === SESSION_EVENT_ACK_KIND) {
-            publisher.acknowledge(message);
-            return;
-          }
-          if (kind === SESSION_EVENT_DEFERRED_KIND) {
-            publisher.defer(message);
-            return;
-          }
-          if (kind === SESSION_EVENT_REJECTED_KIND) {
-            publisher.reject(message);
-            return;
-          }
           commands.handle(message);
         } catch (error62) {
           console.error("Mobius daemon rejected a message", error62);
@@ -43506,245 +44093,304 @@ async function runRelayConnection({
 
 // src/relay-connection/session-event-publisher.ts
 import { WebSocket as WebSocket9 } from "undici";
-
-// src/relay-connection/session-event-queue.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
-var STANDARD_EVENT_BYTES = 96 * 1024 * 1024;
-var CRITICAL_EVENT_BYTES = 128 * 1024 * 1024;
-var SessionEventQueueCapacityError = class extends Error {
-  code = "session_event_queue_full";
-  constructor() {
-    super("The in-memory Session event queue is full");
-    this.name = "SessionEventQueueCapacityError";
-  }
-};
-var SessionEventQueue = class {
-  #streamId = randomUUID7();
-  #events = /* @__PURE__ */ new Map();
-  #nextSourceSeq = 1;
-  #totalBytes = 0;
-  enqueueBatch = (sessionId, payloads, critical) => {
-    if (payloads.length < 1 || payloads.length > 32) {
-      throw new Error("A Session event batch must contain between 1 and 32 events");
-    }
-    if (!Number.isSafeInteger(this.#nextSourceSeq + payloads.length)) {
-      throw new Error("The Session event source sequence is exhausted");
-    }
-    const entries = payloads.map((payload, index) => {
-      const envelope2 = {
-        delivery: {
-          eventId: randomUUID7(),
-          kind: "reliable",
-          sourceSeq: (this.#nextSourceSeq + index).toString(),
-          streamId: this.#streamId
-        },
-        kind: SESSION_EVENT_KIND,
-        payload,
-        sessionId
-      };
-      return { envelope: envelope2, byteLength: Buffer.byteLength(encodeSessionEventEnvelope(envelope2), "utf8") };
+var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+var DaemonSessionEventPublisher = class {
+  #socket = null;
+  connect = (socket) => {
+    this.#socket = socket;
+  };
+  disconnect = (socket) => {
+    if (this.#socket === socket) {
+      this.#socket = null;
+    }
+  };
+  close = () => {
+    this.#socket = null;
+  };
+  publish = (sessionId, event) => {
+    const socket = this.#socket;
+    if (socket === null || socket.readyState !== WebSocket9.OPEN) {
+      return;
+    }
+    const encoded = encodeDaemonToServiceMessage({
+      kind: SESSION_EVENT_KIND,
+      payload: encodeRecordedSessionEvent(event),
+      sessionId
     });
-    const byteLength = entries.reduce((total, entry) => total + entry.byteLength, 0);
-    if (this.#totalBytes + byteLength > (critical ? CRITICAL_EVENT_BYTES : STANDARD_EVENT_BYTES)) {
-      throw new SessionEventQueueCapacityError();
+    if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
+      socket.close(1013, "Live event transport overloaded");
+      return;
     }
-    for (const entry of entries) {
-      this.#events.set(entry.envelope.delivery.eventId, entry);
+    try {
+      socket.send(encoded);
+    } catch {
     }
-    this.#nextSourceSeq += entries.length;
-    this.#totalBytes += byteLength;
   };
-  pending = (limit, excludedEventIds) => {
-    const result = [];
-    for (const [eventId, entry] of this.#events) {
-      if (!excludedEventIds.has(eventId)) {
-        result.push(entry.envelope);
-        if (result.length === limit) {
-          break;
-        }
-      }
+  publishBatch = (sessionId, events) => {
+    for (const event of events) {
+      this.publish(sessionId, event);
     }
-    return result;
   };
-  remove = (eventId, sessionId) => {
-    const entry = this.#events.get(eventId);
-    if (entry === void 0 || entry.envelope.sessionId !== sessionId) {
-      return false;
+  publishV2 = (event) => {
+    const socket = this.#socket;
+    if (socket === null || socket.readyState !== WebSocket9.OPEN) {
+      return;
+    }
+    const encoded = encodeDaemonToServiceMessage({ event, kind: SESSION_EVENT_V2_KIND });
+    if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
+      socket.close(1013, "Live event transport overloaded");
+      return;
+    }
+    try {
+      socket.send(encoded);
+    } catch {
     }
-    this.#events.delete(eventId);
-    this.#totalBytes -= entry.byteLength;
-    return true;
   };
-  clear = () => {
-    this.#events.clear();
-    this.#totalBytes = 0;
+};
+
+// src/relay-connection/timer.ts
+var SystemDaemonTimer = class {
+  schedule = (callback, milliseconds) => {
+    const timeout = setTimeout(callback, milliseconds);
+    return { cancel: () => clearTimeout(timeout) };
   };
 };
+var systemDaemonTimer = new SystemDaemonTimer();
 
-// src/relay-connection/session-event-publisher.ts
-var SESSION_EVENT_REPLAY_WINDOW = 16;
-var SESSION_EVENT_REPLAY_BYTE_LIMIT = 32 * 1024 * 1024;
-function reservesSessionEventCapacity(event) {
-  if (event.kind === SESSION_COMPLETED_KIND || event.kind === SESSION_FAILED_KIND || event.kind === SESSION_FORKED_KIND || event.kind === SESSION_READY_KIND) {
-    return true;
+// src/session-event-log-v2.ts
+var EXECUTING_PROMPT_EVENT_LIMIT = 1e4;
+function promptContent(command) {
+  const content = [];
+  if (command.prompt.length > 0) {
+    content.push({ text: command.prompt, type: "text" });
+  }
+  for (const image of command.images) {
+    content.push({
+      _meta: { mobius: { name: image.name } },
+      data: image.data,
+      mimeType: image.mimeType,
+      type: "image"
+    });
   }
-  return event.kind === AGENT_ACTIVITY_KIND && (event.activityType === "progress" || event.activityType === "reasoning") && (event.status === "completed" || event.status === "failed");
-}
-var DaemonSessionEventPublisher = class {
-  #inFlight = /* @__PURE__ */ new Map();
-  #queue = new SessionEventQueue();
-  #reportedCapacityKinds = /* @__PURE__ */ new Set();
-  #timer;
-  #connection = { kind: "disconnected" };
-  #deferredReplay = null;
-  #inFlightBytes = 0;
-  constructor(timer) {
-    this.#timer = timer;
+  for (const resource of command.resources) {
+    content.push(
+      resource.type === "embedded" ? {
+        resource: { mimeType: resource.mimeType, text: resource.text, uri: resource.uri },
+        type: "resource"
+      } : { mimeType: resource.mimeType, name: resource.name, type: "resource_link", uri: resource.uri }
+    );
   }
-  acknowledge = (acknowledgement) => {
-    if (!this.#queue.remove(acknowledgement.eventId, acknowledgement.sessionId)) {
-      return;
+  return content;
+}
+function encodeLocalEventCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeLocalEventCursor(sessionId, cursor) {
+  try {
+    const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).sort().join(",") !== "endEvent,sessionId" || Reflect.get(value, "sessionId") !== sessionId) {
+      throw new Error("Invalid V2 event cursor target");
     }
-    this.#removeInFlight(acknowledgement.eventId);
-    this.#publishNextBatch();
-  };
-  close = () => {
-    this.#deferredReplay?.cancel();
-    this.#deferredReplay = null;
-    this.#connection = { kind: "disconnected" };
-    this.#clearInFlight();
-    this.#queue.clear();
-  };
-  connect = (socket, delivery) => {
-    this.#connection = { delivery, kind: "connected", socket };
-    this.#clearInFlight();
-    this.#publishNextBatch();
-  };
-  defer = (deferred) => {
-    if (!this.#inFlight.has(deferred.eventId)) {
-      return;
+    const endEvent = Reflect.get(value, "endEvent");
+    if (typeof endEvent !== "number" || !Number.isSafeInteger(endEvent) || endEvent < 0) {
+      throw new Error("Invalid V2 event cursor boundary");
     }
-    this.#clearInFlight();
-    if (this.#deferredReplay !== null) {
-      return;
+    return { endEvent, sessionId };
+  } catch (cause) {
+    throw new AcpExecutionError("The native Session event cursor is invalid", { cause }, "invalid_cursor");
+  }
+}
+var DaemonSessionEventLogV2 = class {
+  #positions = /* @__PURE__ */ new Map();
+  #events = /* @__PURE__ */ new Map();
+  #requests = /* @__PURE__ */ new Map();
+  #loadedRequestSessions = /* @__PURE__ */ new Set();
+  #publisher;
+  #store;
+  constructor(publisher, store) {
+    this.#publisher = publisher;
+    this.#store = store;
+  }
+  #eventsFor = (sessionId) => {
+    const cached2 = this.#events.get(sessionId);
+    if (cached2 !== void 0) {
+      return cached2;
+    }
+    const stored = this.#store.readEventsV2(sessionId);
+    this.#events.set(sessionId, stored);
+    const lastPosition = stored.at(-1)?.position;
+    if (lastPosition !== void 0) {
+      this.#positions.set(sessionId, Number(lastPosition));
     }
-    this.#deferredReplay = this.#timer.schedule(() => {
-      this.#deferredReplay = null;
-      this.#publishNextBatch();
-    }, deferred.retryAfterMilliseconds);
+    return stored;
   };
-  disconnect = (socket) => {
-    if (this.#connection.kind !== "connected" || this.#connection.socket !== socket) {
+  #loadRequests = (sessionId) => {
+    if (this.#loadedRequestSessions.has(sessionId)) {
       return;
     }
-    this.#connection = { kind: "disconnected" };
-    this.#clearInFlight();
-  };
-  publish = (sessionId, event) => {
-    try {
-      this.#queue.enqueueBatch(
-        sessionId,
-        [encodeRecordedSessionEvent(event)],
-        reservesSessionEventCapacity(event)
-      );
-    } catch (error62) {
-      if (!(error62 instanceof SessionEventQueueCapacityError)) {
-        throw error62;
+    for (const event of this.#eventsFor(sessionId)) {
+      const payload = event.payload;
+      if (payload.kind === "prompt.requested") {
+        this.#requests.set(payload.commandId, {
+          commandId: payload.commandId,
+          events: [event],
+          kind: "requested",
+          sessionId
+        });
+        continue;
       }
-      if (!this.#reportedCapacityKinds.has(event.kind)) {
-        this.#reportedCapacityKinds.add(event.kind);
-        console.warn(`Mobius daemon could not buffer "${event.kind}" because the Session event queue is full`);
+      if (payload.kind === "acp.session.update") {
+        const executing = [...this.#requests.values()].find(
+          (request) => request.sessionId === sessionId && request.kind === "executing"
+        );
+        if (executing !== void 0) {
+          this.#requests.set(executing.commandId, {
+            ...executing,
+            events: [...executing.events, event]
+          });
+        }
+        continue;
       }
-      return;
-    }
-    this.#publishNextBatch();
+      if (!("commandId" in payload)) {
+        continue;
+      }
+      const state = this.#requests.get(payload.commandId);
+      if (state === void 0) {
+        continue;
+      }
+      const events = [...state.events, event];
+      if (payload.kind === "prompt.started") {
+        this.#requests.set(payload.commandId, {
+          attemptId: payload.attemptId,
+          commandId: payload.commandId,
+          epoch: payload.epoch,
+          events,
+          kind: "executing",
+          sessionId
+        });
+      } else if (payload.kind === "prompt.completed" || payload.kind === "prompt.failed" || payload.kind === "prompt.failed-before-start") {
+        this.#requests.delete(payload.commandId);
+      }
+    }
+    this.#loadedRequestSessions.add(sessionId);
+  };
+  #append = (sessionId, payload) => {
+    this.#eventsFor(sessionId);
+    const position = (this.#positions.get(sessionId) ?? 0) + 1;
+    const event = {
+      eventId: `event-${crypto.randomUUID()}`,
+      payload,
+      position: position.toString(),
+      provenance: { kind: "original" },
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId
+    };
+    this.#store.appendEventV2(event);
+    this.#positions.set(sessionId, position);
+    this.#events.set(sessionId, [...this.#eventsFor(sessionId), event]);
+    this.#publisher.publishV2(event);
+    return event;
   };
-  publishBatch = (sessionId, events) => {
-    const critical = events.some(reservesSessionEventCapacity);
-    this.#queue.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
-    this.#publishNextBatch();
+  requested = (command) => {
+    const event = this.#append(command.sessionId, {
+      commandId: command.commandId,
+      content: promptContent(command),
+      kind: "prompt.requested"
+    });
+    this.#requests.set(command.commandId, {
+      commandId: command.commandId,
+      events: [event],
+      kind: "requested",
+      sessionId: command.sessionId
+    });
   };
-  reject = (rejection) => {
-    if (!this.#queue.remove(rejection.eventId, rejection.sessionId)) {
+  started = (sessionId, commandId, attemptId, epoch) => {
+    this.#loadRequests(sessionId);
+    const request = this.#requests.get(commandId);
+    if (request?.sessionId !== sessionId) {
       return;
     }
-    this.#removeInFlight(rejection.eventId);
-    console.error(`Mobius Relay rejected Session event ${rejection.eventId} with code ${rejection.code}`);
-    this.#publishNextBatch();
-  };
-  #clearInFlight = () => {
-    this.#inFlight.clear();
-    this.#inFlightBytes = 0;
+    const event = this.#append(sessionId, { attemptId, commandId, epoch, kind: "prompt.started" });
+    this.#requests.set(commandId, {
+      attemptId,
+      commandId,
+      epoch,
+      events: [...request.events, event],
+      kind: "executing",
+      sessionId
+    });
   };
-  #publishNextBatch = () => {
-    if (this.#deferredReplay !== null || this.#connection.kind !== "connected") {
-      return;
-    }
-    while (this.#inFlight.size < SESSION_EVENT_REPLAY_WINDOW) {
-      const batch = this.#queue.pending(
-        SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size,
-        new Set(this.#inFlight.keys())
-      );
-      let sent = 0;
-      for (const envelope2 of batch) {
-        const encoded = encodeDaemonToServiceMessage(
-          this.#connection.delivery === "reliable" ? envelope2 : {
-            kind: envelope2.kind,
-            payload: envelope2.payload,
-            sessionId: envelope2.sessionId
-          }
-        );
-        const byteLength = Buffer.byteLength(encoded, "utf8");
-        if (this.#inFlightBytes + byteLength > SESSION_EVENT_REPLAY_BYTE_LIMIT) {
-          return;
-        }
-        if (!this.#send(encoded)) {
-          this.#clearInFlight();
-          return;
-        }
-        if (this.#connection.delivery === "ephemeral") {
-          this.#queue.remove(envelope2.delivery.eventId, envelope2.sessionId);
-          sent += 1;
-          continue;
-        }
-        this.#inFlight.set(envelope2.delivery.eventId, { byteLength });
-        this.#inFlightBytes += byteLength;
-        sent += 1;
-      }
-      if (sent === 0) {
-        return;
-      }
+  acpUpdate = (sessionId, update) => {
+    this.#loadRequests(sessionId);
+    const event = this.#append(sessionId, { kind: "acp.session.update", update });
+    const executing = [...this.#requests.values()].find(
+      (request) => request.sessionId === sessionId && request.kind === "executing"
+    );
+    if (executing !== void 0) {
+      this.#requests.set(executing.commandId, { ...executing, events: [...executing.events, event] });
     }
   };
-  #removeInFlight = (eventId) => {
-    const inFlight = this.#inFlight.get(eventId);
-    if (inFlight === void 0) {
-      return;
-    }
-    this.#inFlight.delete(eventId);
-    this.#inFlightBytes -= inFlight.byteLength;
+  completed = (sessionId, commandId, stopReason) => {
+    this.#append(sessionId, { commandId, kind: "prompt.completed", stopReason });
+    this.#requests.delete(commandId);
   };
-  #send = (encoded) => {
-    if (this.#connection.kind !== "connected" || this.#connection.socket.readyState !== WebSocket9.OPEN) {
-      return false;
+  failed = (sessionId, commandId, code, message) => {
+    this.#loadRequests(sessionId);
+    const request = this.#requests.get(commandId);
+    if (request?.kind === "executing" && request.commandId === commandId) {
+      this.#append(sessionId, { attemptId: request.attemptId, code, commandId, kind: "prompt.failed", message });
+    } else {
+      this.#append(sessionId, { code, commandId, kind: "prompt.failed-before-start", message });
     }
-    try {
-      this.#connection.socket.send(encoded);
-      return true;
-    } catch {
-      return false;
+    this.#requests.delete(commandId);
+  };
+  executingPromptRequest = (sessionId) => {
+    this.#loadRequests(sessionId);
+    const request = [...this.#requests.values()].find(
+      (candidate) => candidate.sessionId === sessionId && candidate.kind === "executing"
+    );
+    if (request?.kind !== "executing") {
+      return null;
     }
+    const events = request.events.slice(-EXECUTING_PROMPT_EVENT_LIMIT);
+    return {
+      attemptId: request.attemptId,
+      commandId: request.commandId,
+      epoch: request.epoch,
+      events,
+      tailCursor: events.at(-1)?.eventId ?? "",
+      truncated: events.length < request.events.length
+    };
   };
-};
-
-// src/relay-connection/timer.ts
-var SystemDaemonTimer = class {
-  schedule = (callback, milliseconds) => {
-    const timeout = setTimeout(callback, milliseconds);
-    return { cancel: () => clearTimeout(timeout) };
+  recovery = (sessionId, eventLimit, cursor) => {
+    const events = this.#eventsFor(sessionId);
+    if (events.length === 0) {
+      return null;
+    }
+    const executingPromptRequest = this.executingPromptRequest(sessionId);
+    const executingRequestState = [...this.#requests.values()].find(
+      (request) => request.sessionId === sessionId && request.kind === "executing"
+    );
+    const firstExecutingPosition = executingRequestState?.events[0]?.position;
+    const historyEvents = firstExecutingPosition === void 0 ? events : events.filter((event) => BigInt(event.position) < BigInt(firstExecutingPosition));
+    const endEvent = cursor === null ? historyEvents.length : decodeLocalEventCursor(sessionId, cursor).endEvent;
+    if (endEvent > historyEvents.length) {
+      throw new AcpExecutionError("The native Session event cursor is invalid", {}, "invalid_cursor");
+    }
+    const startEvent = Math.max(0, endEvent - eventLimit);
+    const pageEvents = historyEvents.slice(startEvent, endEvent);
+    return {
+      executingPromptRequest,
+      history: {
+        events: pageEvents,
+        nextCursor: startEvent === 0 ? null : encodeLocalEventCursor({ endEvent: startEvent, sessionId }),
+        tailCursor: pageEvents.at(-1)?.eventId ?? "",
+        truncated: startEvent > 0,
+        version: 2
+      }
+    };
   };
 };
-var systemDaemonTimer = new SystemDaemonTimer();
 
 // src/run-daemon.ts
 var RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
@@ -43794,7 +44440,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID8()}`
+        requestId: `automatic-integration-${randomUUID7()}`
       },
       signal
     );
@@ -43813,16 +44459,17 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     stateDirectory
   });
   const sessionStore = new SqliteAcpSessionStore(
-    join18(stateDirectory, "sessions", `${createHash6("sha256").update(config2.channelId).digest("hex")}.sqlite`)
+    join18(stateDirectory, "sessions", `${createHash7("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
   const operations = new DaemonOperationState();
-  const publisher = new DaemonSessionEventPublisher(timer);
+  const publisher = new DaemonSessionEventPublisher();
+  const eventLogV2 = new DaemonSessionEventLogV2(publisher, sessionStore);
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));
   };
   const agentRuntime = new AgentRuntimeManager(
-    new DaemonAcpObserver(recordSessionEvent),
+    new DaemonAcpObserver(recordSessionEvent, eventLogV2.acpUpdate),
     sessionStore,
     {
       read: async (options2, nativeSessionId, nativeTurn) => options2.agent.id === "codex" ? (await readCodexFullHistory(
@@ -43860,7 +44507,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]
         );
       });
     }
@@ -43946,6 +44593,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
           nativeSessions,
           operations,
           publisher,
+          eventLogV2,
           activeTurns,
           connectionEpoch,
           diagnostics,