@moxt-ai/mobius 0.0.155 → 0.0.157

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);
@@ -21233,6 +21233,443 @@ var encodeNativeSessionResult = (value) => JSON.stringify(nativeSessionResultSch
 var decodeNativeSessionCancel = (encoded) => decode4(nativeSessionCancelSchema, encoded);
 var encodeNativeSessionCancel = (value) => JSON.stringify(nativeSessionCancelSchema.parse(value));
 
+// ../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 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 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 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({
+    _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 lifecycleBase = { commandId: identifierStringSchema };
+var lifecycleMetadataV2Schema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ kind: external_exports.literal("session.queue.changed") }).readonly(),
+  external_exports.strictObject({ event: sessionPermissionRequestedEventSchema, kind: external_exports.literal("session.permission.requested") }).readonly(),
+  external_exports.strictObject({ event: sessionPermissionResolvedEventSchema, kind: external_exports.literal("session.permission.resolved") }).readonly(),
+  external_exports.strictObject({
+    event: sessionElicitationRequestedEventSchema,
+    kind: external_exports.literal("session.elicitation.requested")
+  }).readonly(),
+  external_exports.strictObject({ event: sessionElicitationResolvedEventSchema, kind: external_exports.literal("session.elicitation.resolved") }).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 sessionEventPayloadV2Schema = external_exports.discriminatedUnion("type", [
+  external_exports.strictObject({ payload: acpSessionUpdateV2Schema, type: external_exports.literal("acp") }).readonly(),
+  external_exports.strictObject({ payload: lifecycleMetadataV2Schema, type: external_exports.literal("lifecycle-metadata") }).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 sessionEventFieldsV2 = {
+  eventId: identifierStringSchema,
+  position: positionSchema,
+  provenance: provenanceSchema,
+  recordedAt: external_exports.iso.datetime({ offset: true }),
+  sessionId: identifierStringSchema
+};
+var sessionEventV2Schema = external_exports.discriminatedUnion("type", [
+  external_exports.strictObject({ ...sessionEventFieldsV2, payload: acpSessionUpdateV2Schema, type: external_exports.literal("acp") }).readonly(),
+  external_exports.strictObject({
+    ...sessionEventFieldsV2,
+    payload: lifecycleMetadataV2Schema,
+    type: external_exports.literal("lifecycle-metadata")
+  }).readonly()
+]);
+var sessionExportV2Schema = external_exports.strictObject({
+  binding: external_exports.strictObject({
+    bindingId: identifierStringSchema,
+    runtimeId: identifierStringSchema
+  }).readonly(),
+  events: external_exports.array(sessionEventV2Schema).max(MAX_EVENT_COUNT).readonly(),
+  sessionId: identifierStringSchema,
+  truncated: external_exports.boolean()
+}).readonly().superRefine((session, context) => {
+  let previousPosition = 0n;
+  const eventIds = /* @__PURE__ */ new Set();
+  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", index2, "sessionId"]
+      });
+    }
+    const position = BigInt(event.position);
+    if (position <= previousPosition) {
+      context.addIssue({
+        code: "custom",
+        message: "Exported events are not in increasing position order",
+        path: ["events", index2, "position"]
+      });
+    }
+    if (eventIds.has(event.eventId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Exported event identities are not unique",
+        path: ["events", index2, "eventId"]
+      });
+    }
+    previousPosition = position;
+    eventIds.add(event.eventId);
+  }
+});
+var mobiusSessionExportV2Schema = external_exports.strictObject({
+  formatVersion: external_exports.literal("2"),
+  session: sessionExportV2Schema
+}).readonly();
+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 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";
@@ -21250,7 +21687,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);
@@ -21265,7 +21702,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", {
@@ -21274,15 +21711,15 @@ var encode4 = (message, schema) => {
   }
   return JSON.stringify(decoded.data);
 };
-var decodeSessionEventEnvelope = (encoded) => decode5(encoded, sessionEventEnvelopeSchema);
-var encodeSessionEventEnvelope = (message) => encode4(message, sessionEventEnvelopeSchema);
+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:
@@ -21326,6 +21763,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(),
@@ -21359,7 +21798,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);
@@ -21367,14 +21823,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) {
@@ -21459,6 +21919,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,
@@ -21574,6 +22039,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,
@@ -21589,6 +22059,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,
@@ -22578,7 +23053,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)) {
@@ -22706,7 +23181,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)) {
@@ -22835,10 +23310,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)}`;
 }
@@ -24031,6 +24506,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();
@@ -24155,6 +24631,7 @@ function historyContentCharacters(messages) {
 var AcpHistoryReplay = class {
   #activities = /* @__PURE__ */ new Map();
   #messages = [];
+  #updates = [];
   #turnActivityIds = /* @__PURE__ */ new Set();
   #activityTracker = new AcpActivityTracker(
     async (activity2) => {
@@ -24176,7 +24653,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(
@@ -24257,6 +24735,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) => {
@@ -26244,8 +26736,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;
     }
   }
@@ -27433,6 +27925,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)) {
@@ -27781,8 +28322,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;
@@ -27802,7 +28343,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` `);
         }
       }
@@ -27815,9 +28356,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`, `);
         }
       }
@@ -27870,9 +28411,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`, `);
         }
       }
@@ -30286,6 +30827,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`);"
   }
 ];
 
@@ -30293,7 +30838,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
@@ -30314,6 +30860,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;
@@ -30356,9 +30917,21 @@ var DeletedAcpStoredSession = class extends AcpStoredSessionLookup {
 var MemoryAcpSessionStore = class {
   #sessions = /* @__PURE__ */ new Map();
   #deleted = /* @__PURE__ */ new Set();
+  #eventsV2 = /* @__PURE__ */ new Map();
+  appendExecutingPromptEventV2 = (event) => {
+    const events = this.#eventsV2.get(event.sessionId);
+    if (events === void 0) {
+      throw new Error("The executing prompt event log has not started");
+    }
+    events.push(event);
+  };
+  clearExecutingPromptEventsV2 = (sessionId) => {
+    this.#eventsV2.delete(sessionId);
+  };
   close = () => {
     this.#sessions.clear();
     this.#deleted.clear();
+    this.#eventsV2.clear();
   };
   findNative = (agentId, nativeSessionId) => [...this.#sessions.values()].filter(
     (session) => session.agentId === agentId && session.nativeSessionId === nativeSessionId
@@ -30369,6 +30942,7 @@ var MemoryAcpSessionStore = class {
     for (const id of ids) {
       this.#sessions.delete(id);
       this.#deleted.add(id);
+      this.#eventsV2.delete(id);
     }
     return ids;
   };
@@ -30381,6 +30955,13 @@ var MemoryAcpSessionStore = class {
   };
   remove = (sessionId) => {
     this.#sessions.delete(sessionId);
+    this.#eventsV2.delete(sessionId);
+  };
+  readExecutingPromptEventsV2 = (sessionId) => [
+    ...this.#eventsV2.get(sessionId) ?? []
+  ];
+  startExecutingPromptEventsV2 = (sessionId, events) => {
+    this.#eventsV2.set(sessionId, [...events]);
   };
   write = (session) => {
     this.#sessions.set(session.sessionId, session);
@@ -30430,15 +31011,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");
@@ -30449,6 +31030,30 @@ var SqliteAcpSessionStore = class {
   close = () => {
     this.#sqliteDatabase.close();
   };
+  appendExecutingPromptEventV2 = (event) => {
+    this.#database.insert(sessionEventV2).values({
+      eventId: event.eventId,
+      eventJson: JSON.stringify(event),
+      position: Number(event.position),
+      sessionId: event.sessionId
+    }).run();
+  };
+  clearExecutingPromptEventsV2 = (sessionId) => {
+    this.#database.delete(sessionEventV2).where(eq(sessionEventV2.sessionId, sessionId)).run();
+  };
+  startExecutingPromptEventsV2 = (sessionId, events) => {
+    this.#database.transaction((transaction) => {
+      transaction.delete(sessionEventV2).where(eq(sessionEventV2.sessionId, sessionId)).run();
+      for (const event of events) {
+        transaction.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) => {
@@ -30457,6 +31062,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;
@@ -30470,8 +31076,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));
   };
+  readExecutingPromptEventsV2 = (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 = {
@@ -30504,7 +31114,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);
@@ -30651,6 +31261,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;
@@ -31133,6 +31754,19 @@ var AgentSession = class _AgentSession {
     if (this.#turn.running) {
       throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
     }
+    switch (this.#sessionLoad.kind) {
+      case "not-requested":
+        break;
+      case "loaded":
+        this.#sessionLoad = { kind: "not-requested" };
+        break;
+      case "capturing":
+        throw new AcpExecutionError("Session history is still loading", {}, "session_busy");
+      default: {
+        const unexpected = this.#sessionLoad;
+        throw new Error(`Unexpected Session load state: ${JSON.stringify(unexpected)}`);
+      }
+    }
     const prompt = this.buildPrompt(options);
     if (this.#sessionTitle === null || this.#sessionTitle.length === 0) {
       this.#sessionTitle = truncate2(options.prompt, 500);
@@ -31297,8 +31931,14 @@ var AgentSession = class _AgentSession {
   #processUpdate = async (notification) => {
     this.assertNativeSession(notification.sessionId);
     const update = notification.update;
-    if (this.#sessionLoad.kind !== "not-requested") {
-      await this.#sessionLoad.history.record(update);
+    const rawUpdate = decodeAcpSessionUpdateV2(JSON.stringify(update));
+    if (this.#sessionLoad.kind === "capturing") {
+      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;
@@ -31680,6 +32320,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))
@@ -31749,9 +32404,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);
       }
     }
   };
@@ -32381,6 +33036,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);
@@ -32398,6 +33069,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)) {
@@ -36300,9 +36977,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;
     }
@@ -36327,8 +37004,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);
     }
@@ -37071,16 +37748,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(
@@ -37275,16 +37952,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`);
@@ -37292,8 +37969,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"}`);
     }
@@ -37584,7 +38261,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash6, randomUUID as randomUUID7 } 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";
 
@@ -38656,9 +39333,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, { payload: update, type: "acp" });
+    return Promise.resolve();
+  };
   onCommands = (event) => {
     this.#record(event.sessionId, event);
     return Promise.resolve();
@@ -38673,10 +39356,18 @@ var DaemonAcpObserver = class {
   };
   onElicitation = (event) => {
     this.#record(event.sessionId, event);
+    this.#recordV2(event.sessionId, {
+      payload: { event, kind: "session.elicitation.requested" },
+      type: "lifecycle-metadata"
+    });
     return Promise.resolve();
   };
   onElicitationResolved = (event) => {
     this.#record(event.sessionId, event);
+    this.#recordV2(event.sessionId, {
+      payload: { event, kind: "session.elicitation.resolved" },
+      type: "lifecycle-metadata"
+    });
     return Promise.resolve();
   };
   onInfo = (event) => {
@@ -38685,10 +39376,18 @@ var DaemonAcpObserver = class {
   };
   onPermission = (event) => {
     this.#record(event.sessionId, event);
+    this.#recordV2(event.sessionId, {
+      payload: { event, kind: "session.permission.requested" },
+      type: "lifecycle-metadata"
+    });
     return Promise.resolve();
   };
   onPermissionResolved = (event) => {
     this.#record(event.sessionId, event);
+    this.#recordV2(event.sessionId, {
+      payload: { event, kind: "session.permission.resolved" },
+      type: "lifecycle-metadata"
+    });
     return Promise.resolve();
   };
   onUsage = (event) => {
@@ -38795,8 +39494,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;
     }
@@ -38937,7 +39636,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) {
@@ -39948,7 +40647,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.",
           {},
@@ -40081,7 +40780,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",
           {},
@@ -40102,8 +40801,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,
@@ -40435,7 +41134,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) {
@@ -40443,7 +41142,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.",
             {},
@@ -41531,6 +42230,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 {
@@ -41630,8 +42332,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;
     }
@@ -41641,7 +42343,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(
@@ -41921,6 +42623,70 @@ 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: update,
+    position: position.toString(),
+    provenance: { kind: "original" },
+    recordedAt: "1970-01-01T00:00:00.000Z",
+    sessionId,
+    type: "acp"
+  };
+}
+async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, sessions, executingPromptRequest, signal) {
+  try {
+    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";
@@ -42235,6 +43001,7 @@ function daemonActivity(command, activity2) {
 async function executePrompt({
   operations,
   publisher,
+  eventLogV2,
   command,
   config: config2,
   directories,
@@ -42339,6 +43106,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, {
@@ -42408,6 +43176,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,
@@ -42423,6 +43192,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,
@@ -42437,12 +43207,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);
   }
@@ -42725,6 +43493,7 @@ function createDaemonCommandHandler({
   nativeSessions,
   operations,
   publisher,
+  eventLogV2,
   activeTurns,
   diagnostics,
   socket,
@@ -42752,7 +43521,10 @@ function createDaemonCommandHandler({
     timer,
     resolveEnvironment: resolveAgentCatalogEnvironment
   });
-  const queueChanged = (sessionId) => publisher.publish(sessionId, { kind: "session.queue.changed", sessionId });
+  const queueChanged = (sessionId) => {
+    publisher.publish(sessionId, { kind: "session.queue.changed", sessionId });
+    eventLogV2.queueChanged(sessionId);
+  };
   const activeTurnRecovery = (sessionId) => activeTurns.recovery((command) => command.sessionId === sessionId);
   const nativeRequestHandler = createNativeSessionRequestHandler({
     audit,
@@ -42794,6 +43566,19 @@ function createDaemonCommandHandler({
         );
         return;
       }
+      if (kind === SESSION_LIVE_HISTORY_V2_PAGE_LOAD_KIND) {
+        void executeSessionLiveHistoryV2PageLoad(
+          socket,
+          message,
+          config2,
+          directories,
+          audit,
+          sessions,
+          eventLogV2.executingPromptRequest,
+          signal
+        );
+        return;
+      }
       if (kind === NATIVE_SESSION_CANCEL_KIND) {
         nativeRequestHandler.cancel(message);
         return;
@@ -42979,9 +43764,11 @@ function createDaemonCommandHandler({
         return;
       }
       const turn = activeTurns.start(command, receipt.attemptId);
+      eventLogV2.requested(command);
       void executePrompt({
         operations,
         publisher,
+        eventLogV2,
         command,
         config: config2,
         directories,
@@ -43251,6 +44038,7 @@ async function runRelayConnection({
   nativeSessions,
   operations,
   publisher,
+  eventLogV2,
   activeTurns,
   connectionEpoch,
   diagnostics,
@@ -43273,6 +44061,7 @@ async function runRelayConnection({
     nativeSessions,
     operations,
     publisher,
+    eventLogV2,
     activeTurns,
     diagnostics,
     socket,
@@ -43452,6 +44241,21 @@ var DaemonSessionEventPublisher = class {
       this.publish(sessionId, event);
     }
   };
+  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 {
+    }
+  };
 };
 
 // src/relay-connection/timer.ts
@@ -43463,6 +44267,266 @@ var SystemDaemonTimer = class {
 };
 var systemDaemonTimer = new SystemDaemonTimer();
 
+// src/session-event-log-v2.ts
+var EXECUTING_PROMPT_EVENT_LIMIT = 1e4;
+function eventArray(tail) {
+  const reversed = [];
+  let node2 = tail;
+  while (node2 !== null) {
+    reversed.push(node2.event);
+    node2 = node2.previous;
+  }
+  return reversed.reverse();
+}
+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"
+    });
+  }
+  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 }
+    );
+  }
+  return content;
+}
+var DaemonSessionEventLogV2 = class {
+  #positions = /* @__PURE__ */ new Map();
+  #requests = /* @__PURE__ */ new Map();
+  #loadedRequestSessions = /* @__PURE__ */ new Set();
+  #publisher;
+  #store;
+  constructor(publisher, store) {
+    this.#publisher = publisher;
+    this.#store = store;
+  }
+  #loadStoredEvents = (sessionId) => {
+    const stored = this.#store.readExecutingPromptEventsV2(sessionId);
+    const lastPosition = stored.at(-1)?.position;
+    if (lastPosition !== void 0) {
+      this.#positions.set(sessionId, Number(lastPosition));
+    }
+    return stored;
+  };
+  #loadRequests = (sessionId) => {
+    if (this.#loadedRequestSessions.has(sessionId)) {
+      return;
+    }
+    for (const event of this.#loadStoredEvents(sessionId)) {
+      if (event.type === "acp") {
+        const executing = [...this.#requests.values()].find(
+          (request) => request.sessionId === sessionId && request.kind === "executing"
+        );
+        if (executing !== void 0) {
+          this.#requests.set(executing.commandId, {
+            ...executing,
+            eventTail: { event, previous: executing.eventTail }
+          });
+        }
+        continue;
+      }
+      const payload = event.payload;
+      if (payload.kind === "prompt.requested") {
+        this.#requests.set(payload.commandId, {
+          commandId: payload.commandId,
+          eventTail: { event, previous: null },
+          kind: "requested",
+          sessionId
+        });
+        continue;
+      }
+      if ("event" in payload) {
+        const executing = [...this.#requests.values()].find(
+          (request) => request.sessionId === sessionId && request.kind === "executing"
+        );
+        if (executing !== void 0) {
+          this.#requests.set(executing.commandId, {
+            ...executing,
+            eventTail: { event, previous: executing.eventTail }
+          });
+        }
+        continue;
+      }
+      if (!("commandId" in payload)) {
+        continue;
+      }
+      const state = this.#requests.get(payload.commandId);
+      if (state === void 0) {
+        continue;
+      }
+      if (payload.kind === "prompt.started") {
+        this.#requests.set(payload.commandId, {
+          attemptId: payload.attemptId,
+          commandId: payload.commandId,
+          epoch: payload.epoch,
+          eventTail: { event, previous: state.eventTail },
+          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.#loadRequests(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.#positions.set(sessionId, position);
+    this.#publisher.publishV2(event);
+    return event;
+  };
+  requested = (command) => {
+    const content = promptContent(command);
+    const event = this.#append(command.sessionId, {
+      payload: { commandId: command.commandId, content, kind: "prompt.requested" },
+      type: "lifecycle-metadata"
+    });
+    let eventTail = { event, previous: null };
+    for (const block of content) {
+      const userMessageEvent = this.#append(command.sessionId, {
+        payload: {
+          content: block,
+          messageId: command.commandId,
+          sessionUpdate: "user_message_chunk"
+        },
+        type: "acp"
+      });
+      eventTail = { event: userMessageEvent, previous: eventTail };
+    }
+    this.#requests.set(command.commandId, {
+      commandId: command.commandId,
+      eventTail,
+      kind: "requested",
+      sessionId: command.sessionId
+    });
+  };
+  started = (sessionId, commandId, attemptId, epoch) => {
+    this.#loadRequests(sessionId);
+    const request = this.#requests.get(commandId);
+    if (request?.sessionId !== sessionId) {
+      return;
+    }
+    const event = this.#append(sessionId, {
+      payload: { attemptId, commandId, epoch, kind: "prompt.started" },
+      type: "lifecycle-metadata"
+    });
+    this.#requests.set(commandId, {
+      attemptId,
+      commandId,
+      epoch,
+      eventTail: { event, previous: request.eventTail },
+      kind: "executing",
+      sessionId
+    });
+    this.#store.startExecutingPromptEventsV2(sessionId, eventArray({ event, previous: request.eventTail }));
+  };
+  record = (sessionId, payload) => {
+    this.#loadRequests(sessionId);
+    const event = this.#append(sessionId, payload);
+    this.#appendToExecutingRequest(sessionId, event);
+  };
+  #appendToExecutingRequest = (sessionId, event) => {
+    const executing = [...this.#requests.values()].find(
+      (request) => request.sessionId === sessionId && request.kind === "executing"
+    );
+    if (executing !== void 0) {
+      this.#requests.set(executing.commandId, {
+        ...executing,
+        eventTail: { event, previous: executing.eventTail }
+      });
+      this.#store.appendExecutingPromptEventV2(event);
+    }
+  };
+  queueChanged = (sessionId) => {
+    const event = this.#append(sessionId, {
+      payload: { kind: "session.queue.changed" },
+      type: "lifecycle-metadata"
+    });
+    this.#appendToExecutingRequest(sessionId, event);
+  };
+  completed = (sessionId, commandId, stopReason) => {
+    this.#loadRequests(sessionId);
+    const request = this.#requests.get(commandId);
+    const event = this.#append(sessionId, {
+      payload: { commandId, kind: "prompt.completed", stopReason },
+      type: "lifecycle-metadata"
+    });
+    this.#requests.delete(commandId);
+    if (request?.kind === "executing" && request.sessionId === sessionId) {
+      this.#store.clearExecutingPromptEventsV2(sessionId);
+    } else {
+      this.#appendToExecutingRequest(sessionId, event);
+    }
+  };
+  failed = (sessionId, commandId, code, message) => {
+    this.#loadRequests(sessionId);
+    const request = this.#requests.get(commandId);
+    let event;
+    if (request?.kind === "executing" && request.commandId === commandId) {
+      event = this.#append(sessionId, {
+        payload: {
+          attemptId: request.attemptId,
+          code,
+          commandId,
+          kind: "prompt.failed",
+          message
+        },
+        type: "lifecycle-metadata"
+      });
+    } else {
+      event = this.#append(sessionId, {
+        payload: { code, commandId, kind: "prompt.failed-before-start", message },
+        type: "lifecycle-metadata"
+      });
+    }
+    this.#requests.delete(commandId);
+    if (request?.kind === "executing" && request.sessionId === sessionId) {
+      this.#store.clearExecutingPromptEventsV2(sessionId);
+    } else {
+      this.#appendToExecutingRequest(sessionId, event);
+    }
+  };
+  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 requestEvents = eventArray(request.eventTail);
+    const events = requestEvents.slice(-EXECUTING_PROMPT_EVENT_LIMIT);
+    return {
+      attemptId: request.attemptId,
+      commandId: request.commandId,
+      epoch: request.epoch,
+      events,
+      tailCursor: events.at(-1)?.eventId ?? "",
+      truncated: events.length < requestEvents.length
+    };
+  };
+};
+
 // src/run-daemon.ts
 var RELAY_RECONNECT_DELAY_MILLISECONDS = 500;
 function waitForRelayRetry(signal, timer) {
@@ -43530,16 +44594,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();
+  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.record),
     sessionStore,
     {
       read: async (options2, nativeSessionId, nativeTurn) => options2.agent.id === "codex" ? (await readCodexFullHistory(
@@ -43577,7 +44642,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]
         );
       });
     }
@@ -43663,6 +44728,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
           nativeSessions,
           operations,
           publisher,
+          eventLogV2,
           activeTurns,
           connectionEpoch,
           diagnostics,