@jskit-ai/assistant-core 0.1.221 → 0.1.223

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.221",
-    "@jskit-ai/http-runtime": "0.1.241",
-    "@jskit-ai/kernel": "0.1.243",
+    "@jskit-ai/assistant-core": "0.1.223",
+    "@jskit-ai/http-runtime": "0.1.242",
+    "@jskit-ai/kernel": "0.1.244",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.1.60",
-    "@jskit-ai/connectors-catalog": "0.1.60"
+    "@jskit-ai/connectors-core": "0.1.61",
+    "@jskit-ai/connectors-catalog": "0.1.61"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.221",
+  "version": "0.1.223",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -47,8 +47,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.185",
-    "@jskit-ai/resource-crud-core": "0.1.185",
+    "@jskit-ai/resource-core": "0.1.186",
+    "@jskit-ai/resource-crud-core": "0.1.186",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -57,8 +57,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.241",
-    "@jskit-ai/kernel": "0.1.243",
+    "@jskit-ai/http-runtime": "0.1.242",
+    "@jskit-ai/kernel": "0.1.244",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/server/conversation/claudeTurn.js

@@ -449,6 +449,7 @@ export function createClaudeConversationOwner({
         thread: { id: entry.id }, turn: snapshot(entry), workdir: context.workdir, conversationTurn };
     }
     async function accept() {
+      (command || input).onNativeReceipt?.();
       // The new native ACK retires old effect custody while its canonical
       // admission/commit is awaited; it cannot retag a delayed old failure.
       if (applicationCommand) applicationCommand.active.nativeOwner = null;
@@ -465,6 +466,7 @@ export function createClaudeConversationOwner({
         if (admission) conversationTurn = await admission;
       }
       if (!command) await entry.nativeTurn.updateState("active");
+      (command || input).onReceiptPersisted?.();
       if (applicationCommand && conversationTurn) {
         const value = deliveryResult();
         const active = applicationCommand.active;
@@ -736,7 +738,8 @@ export function createClaudeConversationOwner({
       entry.command = active;
       entry.toolSchemas = active.tools?.schemas || [];
     }
-    const value = await send(entry, { ...command.input.nativeMessage, onPromptSending: command.beforeDispatch }, { applicationCommand });
+    const value = await send(entry, { ...command.input.nativeMessage, onPromptSending: command.beforeDispatch,
+      onNativeReceipt: command.onNativeReceipt, onReceiptPersisted: command.onReceiptPersisted }, { applicationCommand });
     const completion = value.conversationTurn ? entry.completion?.promise : null;
     const delivered = { value, completion };
     if (!applicationCommand && value.delivered === true && value.conversationTurn) {
@@ -766,9 +769,10 @@ export function createClaudeConversationOwner({
     control.current = active;
     const ready = Promise.withResolvers();
     ready.promise.catch(() => {});
-    active.steer = async ({ input, beforeDispatch, accept }) => {
+    active.steer = async ({ input, beforeDispatch, accept, onNativeReceipt, onReceiptPersisted }) => {
       await ready.promise;
-      const nativeDispatch = { active, signal, beforeDispatch, accept, timeoutMs, steering: true, interrupted: false, attempted: false, admitted: false };
+      const nativeDispatch = { active, signal, beforeDispatch, accept, onNativeReceipt, onReceiptPersisted,
+        timeoutMs, steering: true, interrupted: false, attempted: false, admitted: false };
       try { await dispatch(control, { input, context, signal }, { acquire, entry, dispatch: nativeDispatch }); }
       catch (error) {
         if (nativeDispatch.attempted && !nativeDispatch.admitted) error.delivery = "uncertain";
@@ -776,7 +780,8 @@ export function createClaudeConversationOwner({
         throw error;
       }
     };
-    const nativeDispatch = { active, signal, beforeDispatch, accept, timeoutMs, maximumOutput, attempted: false, admitted: false };
+    const nativeDispatch = { active, signal, beforeDispatch, accept, onNativeReceipt: command.onNativeReceipt,
+      onReceiptPersisted: command.onReceiptPersisted, timeoutMs, maximumOutput, attempted: false, admitted: false };
     let entry;
     let cancellation;
     let problem;

package/src/server/conversation/codexMessageCommands.js

@@ -499,6 +499,7 @@ export function createCodexMessageCommands({
     if (!deliveredTurnId) {
       throw new Error("Codex app-server accepted the prompt without returning a turn id.");
     }
+    codexAppServerPendingUserMessages.get(`${promptDeliveryKey}\0${clientUserMessageId}`)?.onNativeReceipt?.();
     await markCodexAppServerTurnActive(sessionId, {
       requireTrackedTurn: true,
       status: "inProgress",
@@ -624,6 +625,7 @@ export function createCodexMessageCommands({
         turnId
       } };
     }
+    codexAppServerPendingUserMessages.get(`${namespace(sessionId)}\0${clientUserMessageId}`)?.onNativeReceipt?.();
     const conversationTurn = await writeCodexAppServerDeliveredUserMessage(
       runtime,
       sessionId,

package/src/server/conversation/codexMessageDelivery.js

@@ -95,6 +95,7 @@ export function createCodexAppServerMessageDelivery({
       if (!written) {
         return null;
       }
+      pendingMessage?.onReceiptPersisted?.();
       await publish(normalizedSessionId, {
         payload: {
           conversationLogPatch: {
@@ -144,6 +145,7 @@ export function createCodexAppServerMessageDelivery({
       Array.isArray(recoveredMessage?.displayAttachments) && recoveredMessage.displayAttachments.length
     ))) return;
     if (ownership) {
+      pendingMessage?.onNativeReceipt?.();
       // The provider's user-message receipt precedes its answer notifications.
       // Persist the authored message here so answers cannot overtake it while
       // the original HTTP request is still finishing startup bookkeeping.

package/src/server/conversation/deliveryTiming.js

@@ -0,0 +1,23 @@
+const stages = new Set([
+  "received", "preparation-started", "provider-started", "runtime-ready", "dispatch-started",
+  "native-acknowledged", "receipt-persisted", "accepted", "first-response", "failed"
+]);
+
+// Observer results are never awaited and failures cannot change delivery.
+export function createConversationDeliveryTiming({ engine, conversationId, messageId, report, clock = () => performance.now() }) {
+  const startedAt = clock();
+  let previousAt = startedAt;
+  let previousStage = "";
+  const timings = {};
+  return stage => {
+    if (!report || !stages.has(stage) || Object.hasOwn(timings, stage)) return;
+    const at = clock();
+    timings[stage] = Math.max(0, at - startedAt);
+    const event = { engine, conversationId, messageId, stage, previousStage,
+      durationMs: Math.max(0, at - previousAt), elapsedMs: timings[stage], timings: { ...timings } };
+    previousAt = at;
+    previousStage = stage;
+    try { Promise.resolve(report(event)).catch(() => {}); }
+    catch { /* Instrumentation never changes admission or provider work. */ }
+  };
+}

package/src/server/conversation/providers/codexDriver.js

@@ -700,11 +700,14 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
         return saved;
       }
 
-      async function withDelivery(input, operation) {
+      async function withDelivery(command, operation) {
+        const input = command.input;
         return owner.withMessageDelivery(sessionId, input.messageId, {
           attachments: input.attachments, text: input.authoredInput?.text ?? input.text,
           turnMetadata: input.nativeMessage?.turnMetadata || null, actorContext: input.nativeMessage?.actorContext || null,
-          authoredInput: input.authoredInput
+          authoredInput: input.authoredInput,
+          onNativeReceipt: command.onNativeReceipt,
+          onReceiptPersisted: command.onReceiptPersisted
         }, operation);
       }
 
@@ -788,7 +791,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       }
 
       async function sendMessage(command, configuration, context, signal, tools) {
-        return withDelivery(command.input, async () => {
+        return withDelivery(command, async () => {
           let attempted = false;
           let rejected = false;
           let accepted = false;
@@ -1013,7 +1016,8 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
           if (!current || current.finished && !current.finishIfCurrent) throw new Error("Codex has no active turn to steer.");
           return current.steer(command);
         },
-        async run({ configuration, context, input, tools, signal, beforeDispatch, accept, onEvent, onNativeTurn, finishIfCurrent }) {
+        async run({ configuration, context, input, tools, signal, beforeDispatch, accept, onNativeReceipt, onReceiptPersisted,
+          onEvent, onNativeTurn, finishIfCurrent }) {
           if (disposed || current) throw new Error("This Codex conversation is closed or already working.");
           const completion = Promise.withResolvers();
           const admission = Promise.withResolvers();
@@ -1130,7 +1134,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
               executingProvider = native;
             }
             if (!supplied) native.setServerRequestHandler(toolHandler(executingProvider));
-            const command = { input, beforeDispatch, accept };
+            const command = { input, beforeDispatch, accept, onNativeReceipt, onReceiptPersisted };
             delivered = await sendMessage(command, configuration, context, signal, tools);
             waitForTurn = !supplied || delivered.value?.delivered === true;
             if (!finishIfCurrent && waitForTurn) {

package/src/server/conversation/providers/opencodeDriver.js

@@ -257,6 +257,15 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
             active.messageIds.set(prepared.input.id, { messageId: input.messageId, committed: command.deliveryCommitted });
           } : beforeDispatch;
           prepared = await supplied.preparation.message({ ...input.nativeMessage, onPromptSending: dispatch }, options);
+          if (prepared.application?.commit) {
+            const application = prepared.application;
+            prepared.application = { ...application, async commit(admitted) {
+              command.onNativeReceipt?.();
+              const result = await application.commit(admitted);
+              command.onReceiptPersisted?.();
+              return result;
+            } };
+          }
           if (active?.tools && prepared.application?.monitor) {
             const monitor = prepared.application.monitor;
             const create = monitor.create;
@@ -639,7 +648,9 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
               };
             },
             async commit() {
+              command.onNativeReceipt?.();
               await command.accept();
+              command.onReceiptPersisted?.();
               active.deliveryCommitted = command.deliveryCommitted;
               accepted = true;
             },

package/src/server/conversation/runtime.js

@@ -1,4 +1,5 @@
 import { createConversationProviderFactory } from "./provider.js";
+import { createConversationDeliveryTiming } from "./deliveryTiming.js";
 import { normalizeConversationConfiguration } from "./configuration.js";
 import { runScopedConversationTurn, readPersistentConversation, startPersistentConversationTurn,
   inspectPersistentConversationAdmission, preparePersistentConversationChangeover,
@@ -36,8 +37,9 @@ const sameRequest = (left, right) => left.text === right.text && (left.origin ||
 
 /** One application conversation API. Storage and authorization remain host facilities. */
 export function createConversationRuntime({ engine: defaultEngine = "api", defaultIntegrationId, storage, authorize, connections, apiClientFactory, apiHistory,
-  actions, toolPolicy, toolCatalog, attachments, fetch, host: defaultHost, persistCommentary = true, completedEnvelope = false, limits = {} } = {}) {
+  actions, toolPolicy, toolCatalog, attachments, fetch, host: defaultHost, onDeliveryTiming, persistCommentary = true, completedEnvelope = false, limits = {} } = {}) {
   if (typeof authorize !== "function") throw new TypeError("Conversation access requires an authorize function.");
+  if (onDeliveryTiming !== undefined && typeof onDeliveryTiming !== "function") throw new TypeError("Delivery timing requires a server-owned observer.");
   if (typeof completedEnvelope !== "boolean") throw new TypeError("Completed envelope policy requires a server-side boolean.");
   if (typeof persistCommentary !== "boolean") throw new TypeError("Conversation commentary persistence requires an explicit server-side boolean.");
   if (apiHistory !== undefined && typeof apiHistory !== "function") throw new TypeError("API request history requires a server-owned selector.");
@@ -97,6 +99,19 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
 
   async function emit(entry, event, isCurrent) {
     const { completedEnvelope: _untrustedMarker, ...payload } = event;
+    if (payload.type === "message" && ["assistant", "commentary", "thinking"].includes(payload.role) && payload.text?.trim()) {
+      // Bound live streams deliberately omit private native turn identities.
+      // Their current admitted request owns them; historical rows retain IDs.
+      let request;
+      if (payload.turnId) {
+        request = [...(entry.active?.requests.values() || [])].find(request =>
+          !request.sealed && (request.turnId === payload.turnId || request.nativeTurnId === payload.turnId));
+      } else if (entry.conversation) {
+        const current = entry.active?.request;
+        if (current?.accepted && !current.sealed) request = current;
+      }
+      request?.deliveryTiming?.("first-response");
+    }
     if (completedEnvelope && !entry.conversation) {
       const request = payload.messageId && entry.active?.requests.get(payload.messageId) ||
         payload.turnId && [...(entry.active?.requests.values() || [])].find(request => request.turnId === payload.turnId);
@@ -777,6 +792,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     }
 
     async function publishAdmission(request, nativeResult) {
+      request.deliveryTiming?.("accepted");
       const receipt = { status: "accepted", messageId: request.input.messageId, turnId: request.turnId, origin: request.input.origin };
       request.admission.resolve(entry.conversation ? { receipt, nativeResult } : receipt);
       request.admissionSettled = true;
@@ -856,6 +872,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         if (!driver.canonicalTranscript) streams.clear(entry.id);
       }
       request.accepted = true;
+      if (!entry.conversation) request.deliveryTiming?.("receipt-persisted");
       request.nativeTurnId = nativeTurnId;
       if (request.input.goal) goalOwner = request;
       current = active.request = request;
@@ -1027,6 +1044,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         committed = Promise.withResolvers();
         committed.promise.catch(() => {});
         request.deliveryCommitted = committed.promise;
+        request.deliveryTiming?.("provider-started");
         completion = Promise.resolve().then(() => dispatch({
           context: request.context,
           input: { ...request.input, authoredInput: { ...request.input, at: request.at },
@@ -1034,8 +1052,11 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
             text: input.message, contextText: input.contextText || "",
             content: [...contextFiles.content, ...files.content], localFiles, attachmentManifest },
           signal: active.controller.signal,
+          onNativeReceipt: () => request.deliveryTiming?.("native-acknowledged"),
+          onReceiptPersisted: () => request.deliveryTiming?.("receipt-persisted"),
           ...(engine === "opencode" ? { deliveryCommitted: committed.promise } : {}),
           async beforeDispatch(native) {
+            request.deliveryTiming?.("runtime-ready");
             await beforeDispatch(request);
             threadId = native?.threadId;
             if (!threadId) throw new Error("Native admission requires the saved conversation identity.");
@@ -1043,6 +1064,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
               turnMetadata: { runtime: { engine, segmentId, origin: request.input.origin,
                 ...(request.completedEnvelope ? { completedEnvelope: true } : {}),
                 ...(typeof request.nativeToolAttempt === "boolean" ? { nativeToolAttempt: request.nativeToolAttempt } : {}) } } });
+            request.deliveryTiming?.("dispatch-started");
           },
           async accept(native) {
             if (entry.conversation) nativeResult = native.nativeResult;
@@ -1396,25 +1418,34 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
   }
 
   async function send(entry, context, input, origin = "user", goal, representation, wakeOptions) {
-    await access(context, entry.id, goal ? "goal" : input?.steer === true ? "steer" : origin === "application" ? "wake" : "send", entry);
-    if (entry.conversation?.commands) {
-      if (origin !== "user" || goal) throw failure("This conversation supports its original application Send operation.", "conversation_unsupported", 400);
-      return entry.conversation.commands.send(input, context);
-    }
-    if (entry.conversation?.native?.scoped) return entry.provider.sendNative({ input, context });
-    const originalInput = representation === "native" ? input : undefined;
-    const message = originalInput ? { ...input, text: input.displayMessage ?? input.message ?? input.text ?? "" } : input;
-    const admission = await serial(entry, () => admitSend(entry, context, message, origin, goal, originalInput, wakeOptions));
-    const result = await (admission.receipt || admission.promise);
-    if (!entry.conversation) return result;
-    if (representation === "native") return result.nativeResult;
-    if (result.error) throw result.error;
-    return result.receipt;
+    const deliveryTiming = createConversationDeliveryTiming({ engine: entry.engine,
+      conversationId: entry.id, messageId: input?.messageId, report: onDeliveryTiming });
+    deliveryTiming("received");
+    try {
+      await access(context, entry.id, goal ? "goal" : input?.steer === true ? "steer" : origin === "application" ? "wake" : "send", entry);
+      if (entry.conversation?.commands) {
+        if (origin !== "user" || goal) throw failure("This conversation supports its original application Send operation.", "conversation_unsupported", 400);
+        return entry.conversation.commands.send(input, context);
+      }
+      if (entry.conversation?.native?.scoped) return entry.provider.sendNative({ input, context });
+      const originalInput = representation === "native" ? input : undefined;
+      const message = originalInput ? { ...input, text: input.displayMessage ?? input.message ?? input.text ?? "" } : input;
+      const admission = await serial(entry, () => admitSend(entry, context, message, origin, goal, originalInput, wakeOptions, deliveryTiming));
+      const result = await (admission.receipt || admission.promise);
+      if (!entry.conversation) return result;
+      if (representation === "native") return result.nativeResult;
+      if (result.error) throw result.error;
+      return result.receipt;
+    } catch (error) {
+      deliveryTiming("failed");
+      throw error;
+    }
   }
 
   // Called while holding the conversation queue, including Claude's existing
   // stop-then-Send goal commands. All commands retain the ordinary receipt path.
-  async function admitSend(entry, context, input, origin = "user", goal, originalInput, wakeOptions) {
+  async function admitSend(entry, context, input, origin = "user", goal, originalInput, wakeOptions, deliveryTiming) {
+    deliveryTiming?.("preparation-started");
     const operation = goal ? "goal" : input?.steer === true ? "steer" : origin === "application" ? "wake" : "send";
     await access(context, entry.id, operation, entry);
     await entry.conversation?.admission(context, operation);
@@ -1484,7 +1515,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       // No native dispatch has occurred for this request. Finish the previous
       // waiter before reserving the same authored request on the ordinary path.
       await working.done;
-      return admitSend(entry, context, input, origin, goal, originalInput, wakeOptions);
+      return admitSend(entry, context, input, origin, goal, originalInput, wakeOptions, deliveryTiming);
     }
     const nativeSteering = !working && (nativeState.nativeTurn?.active || entry.driver.canonicalTranscript && nativeState.binding?.codexAppServerRun &&
       codexAppServerTurnStateFromAgentRun(nativeState.binding.codexAppServerRun).active);
@@ -1537,7 +1568,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       await transaction.writeMetadata(metadata);
       return metadata.runtime.configuration;
     }); } catch (error) { release(); throw error; }
-    const request = { input: message, originalInput, operation, context, at: requestAt,
+    const request = { input: message, originalInput, operation, context, at: requestAt, deliveryTiming,
       ...(markedResponse ? { completedEnvelope: true, excludedMessageIds } : {}),
       ...(typeof nativeToolAttempt === "boolean" ? { nativeToolAttempt } : {}), steering: Boolean(working || input.steer && nativeSteering),
       admission: Promise.withResolvers(), progress: new Map() };

package/src/server/conversation/transcript.js

@@ -1,4 +1,5 @@
 import { normalizeText } from "./normalize.js";
+import { conversationLogPage } from "../../shared/conversation/pagination.js";
 
 /** Conversation policy, independent of database, filesystem, identity and HTTP. */
 export function createConversationTranscript({ storage, clock = () => new Date(), applicationTurns = false } = {}) {
@@ -15,30 +16,43 @@ export function createConversationTranscript({ storage, clock = () => new Date()
     });
   }
 
-  async function readConversationLogPage(scope, { beforeTurnId = "", limit = 0, presentation = false } = {}) {
+  async function readConversationLogPage(scope, { beforeTurnId = "", limit = 0, presentation = false, pageUnit = "turns" } = {}) {
     if (typeof presentation !== "boolean") throw new TypeError("Transcript presentation requires an explicit boolean.");
+    if (!["turns", "messages"].includes(pageUnit)) throw new TypeError("Transcript pageUnit must be turns or messages.");
     return storage.read(scope, async (transaction) => {
       const allIds = await transaction.listTurnIds();
-      const visible = presentation ? (await Promise.all(allIds.map(id => transaction.readTurn(id))))
-        .filter(turn => hasMessages(turn) && !isCompletedEnvelopeTurn(turn)) : null;
+      const visible = presentation || pageUnit === "messages"
+        ? (await Promise.all(allIds.map(id => transaction.readTurn(id))))
+          .filter(turn => hasMessages(turn) && (!presentation || !isCompletedEnvelopeTurn(turn))) : null;
       const ids = visible ? visible.map(turn => turn.turnId) : allIds;
       const before = normalizeText(beforeTurnId);
       const requestedLimit = Number.parseInt(String(limit || ""), 10);
       const pageLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? Math.min(requestedLimit, 100) : 0;
-      const end = before && ids.includes(before) ? ids.indexOf(before) : ids.length;
-      const start = pageLimit ? Math.max(0, end - pageLimit) : 0;
-      const selected = ids.slice(start, end);
-      const turns = visible ? visible.slice(start, end)
-        : (await Promise.all(selected.map((id) => transaction.readTurn(id)))).filter(hasMessages);
+      let page;
+      if (pageUnit === "messages") {
+        page = conversationLogPage(visible, { beforeTurnId: before, limit: pageLimit });
+      } else {
+        const end = before && ids.includes(before) ? ids.indexOf(before) : ids.length;
+        const start = pageLimit ? Math.max(0, end - pageLimit) : 0;
+        const selected = ids.slice(start, end);
+        page = {
+          conversationLog: visible ? visible.slice(start, end)
+            : (await Promise.all(selected.map(id => transaction.readTurn(id)))).filter(hasMessages),
+          hasMoreBefore: start > 0,
+          nextBeforeTurnId: start > 0 ? ids[start] : ""
+        };
+      }
+      const turns = page.conversationLog;
       return {
         conversationLog: turns,
         pagination: {
+          ...(pageUnit === "messages" ? { pageUnit } : {}),
           beforeTurnId: before,
           count: turns.length,
-          hasMoreBefore: start > 0,
+          hasMoreBefore: page.hasMoreBefore,
           limit: pageLimit,
           newestTurnId: turns.at(-1)?.turnId || "",
-          nextBeforeTurnId: start > 0 ? turns[0]?.turnId || selected[0] || "" : "",
+          nextBeforeTurnId: page.nextBeforeTurnId,
           oldestTurnId: turns[0]?.turnId || "",
           totalTurnCount: ids.length
         }

package/src/shared/conversation/pagination.js

@@ -1,5 +1,78 @@
 // Original paged transcript representation, shared by all browser bindings.
-const CONVERSATION_LOG_PAGE_LIMIT = 20;
+const CONVERSATION_LOG_PAGE_LIMIT = 10;
+
+const messageRoles = ["system", "user", "assistant"];
+
+// Live updates retain whole boundary turns. Reasoning/progress never uses the
+// message allowance, and never evicts the question it follows.
+function conversationLogPageStart(turns, limit, end = turns.length) {
+  if (!limit) return 0;
+  let remaining = limit;
+  let start = end;
+  while (start > 0 && remaining > 0) {
+    start -= 1;
+    remaining -= messageRoles.filter(role => turns[start]?.[role]).length;
+  }
+  return turns.slice(0, start).some(turn => messageRoles.some(role => turn?.[role])) ? start : 0;
+}
+
+// A cursor can stop between the question and answer of one stored turn. It is
+// read-only presentation state; stored turn and message identities never change.
+function conversationLogPage(turns, { beforeTurnId = "", limit = 0 } = {}) {
+  const messages = turns.flatMap((turn, index) => messageRoles.filter(role => turn[role])
+    .map(role => ({ index, role, turnId: turn.turnId })));
+  let boundary = turns.findIndex(turn => turn.turnId === beforeTurnId);
+  let beforeRole = "";
+  if (boundary < 0 && beforeTurnId.startsWith("message:")) {
+    try {
+      const [id, role] = JSON.parse(beforeTurnId.slice(8));
+      if (messageRoles.includes(role)) {
+        boundary = turns.findIndex(turn => turn.turnId === id);
+        beforeRole = role;
+      }
+    } catch { /* An unknown cursor retains the existing latest-page behavior. */ }
+  }
+  const beforeRoleIndex = beforeRole ? messageRoles.indexOf(beforeRole) : 0;
+  const foundEnd = boundary < 0 ? -1 : messages.findIndex(message =>
+    message.index > boundary ||
+      (message.index === boundary && messageRoles.indexOf(message.role) >= beforeRoleIndex));
+  const end = foundEnd < 0 ? messages.length : foundEnd;
+  const start = limit > 0 ? Math.max(0, end - limit) : 0;
+  const first = messages[start];
+  const firstRoleIndex = start > 0 ? messageRoles.indexOf(first.role) : 0;
+  const startTurn = start > 0 ? first.index : 0;
+  const endTurn = boundary < 0 ? turns.length : boundary + (beforeRole ? 1 : 0);
+  const selected = turns.slice(startTurn, endTurn).map((turn, offset) => {
+    const index = startTurn + offset;
+    const roles = messageRoles.filter(role => turn[role]);
+    const fromRole = index === startTurn ? firstRoleIndex : 0;
+    const toRole = index === boundary && beforeRole ? beforeRoleIndex : messageRoles.length;
+    const keep = roles.filter(role => {
+      const position = messageRoles.indexOf(role);
+      return position >= fromRole && position < toRole;
+    });
+    if (keep.length === roles.length) return turn;
+    // Progress belongs to the later part of a split turn, next to its answer.
+    const keepActivity = keep.includes(roles.at(-1));
+    const result = { ...turn, paginationPartial: true,
+      thinking: keepActivity ? turn.thinking : [], commentary: keepActivity ? turn.commentary : [] };
+    for (const role of messageRoles) if (!keep.includes(role)) result[role] = null;
+    result.messages = (turn.messages || [turn.system, turn.user, ...(turn.thinking || []),
+      ...(turn.commentary || []), turn.assistant].filter(Boolean))
+      .filter(message => keep.includes(message.role) || (keepActivity && !messageRoles.includes(message.role)));
+    return result;
+  }).filter(turn => messageRoles.some(role => turn[role]) || turn.thinking?.length || turn.commentary?.length);
+  let nextBeforeTurnId = "";
+  if (start > 0) {
+    const split = messageRoles.slice(0, firstRoleIndex).some(role => turns[first.index][role]);
+    nextBeforeTurnId = split ? `message:${JSON.stringify([first.turnId, first.role])}` : first.turnId;
+  }
+  return {
+    conversationLog: selected,
+    hasMoreBefore: start > 0,
+    nextBeforeTurnId
+  };
+}
 
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -8,6 +81,7 @@ function isRecord(value) {
 function normalizeConversationLogPagination(pagination = {}) {
   const source = isRecord(pagination) ? pagination : {};
   return {
+    ...(source.pageUnit === "messages" ? { pageUnit: "messages" } : {}),
     beforeTurnId: String(source.beforeTurnId || "").trim(),
     count: Number.isFinite(Number(source.count)) ? Number(source.count) : 0,
     hasMoreBefore: source.hasMoreBefore === true,
@@ -47,7 +121,22 @@ function mergeConversationLogPages(pages = []) {
         continue;
       }
       if (indexes.has(turnId)) {
-        orderedTurns[indexes.get(turnId)] = turn;
+        const index = indexes.get(turnId);
+        const previous = orderedTurns[index];
+        if (!turn.paginationPartial && !previous.paginationPartial) {
+          orderedTurns[index] = turn;
+          continue;
+        }
+        const merged = { ...previous, ...turn };
+        for (const role of messageRoles) merged[role] = turn[role] || previous[role];
+        const [activity, previousActivity] = [turn, previous].map(part =>
+          (part.messages || [...(part.thinking || []), ...(part.commentary || [])])
+            .filter(message => !messageRoles.includes(message.role)));
+        const retainedActivity = activity.length ? activity : previousActivity;
+        merged.thinking = retainedActivity.filter(message => message.role === "thinking");
+        merged.commentary = retainedActivity.filter(message => message.role === "commentary");
+        merged.messages = [merged.system, merged.user, ...retainedActivity, merged.assistant].filter(Boolean);
+        orderedTurns[index] = merged;
         continue;
       }
       indexes.set(turnId, orderedTurns.length);
@@ -71,6 +160,8 @@ function conversationLogReadQuery({
 
 export {
   CONVERSATION_LOG_PAGE_LIMIT,
+  conversationLogPageStart,
+  conversationLogPage,
   normalizeConversationLogPagination,
   normalizeConversationLogPage,
   mergeConversationLogPages,

package/src/shared/conversation/patches.js

@@ -1,5 +1,5 @@
 import { normalizeThinkingMessageText } from "./thinkingText.js";
-import { normalizeConversationLogPagination } from "./pagination.js";
+import { conversationLogPageStart, normalizeConversationLogPagination } from "./pagination.js";
 
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -125,14 +125,17 @@ function applyConversationLogPatch(payload = {}, patch = null, options = {}) {
       numeric: true
     }
   ));
+  const pagination = normalizeConversationLogPagination(source.pagination);
   const limit = Number.parseInt(String(options.limit || ""), 10);
   const limitedTurns = Number.isFinite(limit) && limit > 0
-    ? nextTurns.slice(-limit)
+    ? nextTurns.slice(pagination.pageUnit === "messages" ? conversationLogPageStart(nextTurns, limit) : -limit)
     : nextTurns;
   const wasTrimmed = limitedTurns.length < nextTurns.length;
-  const pagination = normalizeConversationLogPagination(source.pagination);
   const hasMoreBefore = pagination.hasMoreBefore || wasTrimmed;
   const oldestTurnId = String(limitedTurns[0]?.turnId || "").trim();
+  const beforeCursor = oldestTurnId === pagination.oldestTurnId
+    ? pagination.nextBeforeTurnId || oldestTurnId
+    : oldestTurnId;
   return {
     ...source,
     conversationLog: limitedTurns,
@@ -141,7 +144,7 @@ function applyConversationLogPatch(payload = {}, patch = null, options = {}) {
       count: limitedTurns.length,
       hasMoreBefore,
       newestTurnId: String(limitedTurns.at(-1)?.turnId || "").trim(),
-      nextBeforeTurnId: hasMoreBefore ? oldestTurnId : "",
+      nextBeforeTurnId: hasMoreBefore ? beforeCursor : "",
       oldestTurnId
     }
   };

package/test/claudeTurn.test.js

@@ -746,7 +746,7 @@ test("Claude verified native cleanup retains interrupted checkpoint refusal with
 
 // Retain the original supplied-store/native process fixture and drive it through
 // the actual common runtime, including its completion-only admitted receipt.
-async function suppliedCommonFixture(t, { tools = true } = {}) {
+async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming } = {}) {
   const f = await publishedClaudeFixture(t, { canonicalAdmission: true });
   const storage = createMemoryConversationStorage();
   const transcript = createConversationTranscript({ storage });
@@ -786,7 +786,7 @@ async function suppliedCommonFixture(t, { tools = true } = {}) {
     ...(tools ? { applicationTools: { storage, prepareContext(actual, admission) {
       admissions.push(admission); return actual;
     } } } : {}) };
-  const runtime = createConversationRuntime({ ...(tools ? { actions } : {}), authorize: () => true,
+  const runtime = createConversationRuntime({ ...(tools ? { actions } : {}), authorize: () => true, onDeliveryTiming,
     host: { conversation: () => binding } });
   t.after(() => runtime.close());
   const conversation = await runtime.open({ id: "lesson", context });
@@ -822,6 +822,25 @@ async function sendCommon(f, messageId) {
   return receipt;
 }
 
+test("Claude delivery timing separates native acknowledgement from the held canonical receipt", { timeout: 10_000 }, async t => {
+  const timings = [];
+  const f = await suppliedCommonFixture(t, { onDeliveryTiming: event => timings.push(event) });
+  const writing = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  f.behavior.beforeAdmit = async () => { writing.resolve(); await release.promise; };
+  const sending = f.conversation.send({ messageId: "timed-request", text: "Private message" });
+  await writing.promise;
+  assert.deepEqual(timings.map(event => event.stage), [
+    "received", "preparation-started", "provider-started", "runtime-ready", "dispatch-started", "native-acknowledged"
+  ]);
+  release.resolve();
+  assert.equal((await sending).status, "accepted");
+  assert.deepEqual(timings.slice(-2).map(event => event.stage), ["receipt-persisted", "accepted"]);
+  await f.frame({ type: "result", subtype: "success", result: "Public answer" });
+  await f.conversation.wait();
+  assert.equal(JSON.stringify(timings).includes("Private message"), false);
+});
+
 for (const tools of [true, false]) test(`Claude supplied common runtime checkpoints after its completion fence with tools=${tools}`, { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t, { tools });
   const receipt = await sendCommon(f, "common-question");

package/test/codexConversationSession.test.js

@@ -1214,6 +1214,7 @@ async function fixture(t, options = {}) {
     TEST_HISTORY: path.join(directory, "history.json"), ...options.environment };
   function runtime({ nativeTools = options.nativeTools } = {}) {
     const value = createConversationRuntime({ engine: "codex", storage, authorize: options.authorize || (() => true),
+      onDeliveryTiming: options.onDeliveryTiming,
       actions: options.actions, connections: options.connections, fetch: options.fetch, attachments: options.attachments,
       host: { workdir: directory, runtimeDirectory: directory, env, commands: { codex: command }, execution, nativeTools, commandWrapper: options.commandWrapper },
       limits: { admissionTimeoutMs: 2000, ...options.limits } });
@@ -1235,6 +1236,18 @@ async function fixture(t, options = {}) {
     async trace() { return (await readFile(trace, "utf8")).trim().split("\n").map(line => JSON.parse(line)); } };
 }
 
+test("Codex delivery timing uses the common native receipt and first-response stages", async t => {
+  const timings = [];
+  const f = await fixture(t, { onDeliveryTiming: event => timings.push(event) });
+  assert.equal((await f.conversation.send({ messageId: "timed-request", text: "Private message" })).status, "accepted");
+  await f.conversation.wait();
+  const stages = timings.map(event => event.stage);
+  assert.deepEqual(stages.slice(0, 8), ["received", "preparation-started", "provider-started", "runtime-ready",
+    "dispatch-started", "native-acknowledged", "receipt-persisted", "accepted"]);
+  assert.equal(stages.filter(stage => stage === "first-response").length, 1);
+  assert.equal(JSON.stringify(timings).includes("Private message"), false);
+});
+
 test("Codex admits, streams, persists reasoning and deduplicates using native receipts", async t => {
   const f = await fixture(t);
   const events = [];

package/test/codexTurn.test.js

@@ -1079,10 +1079,13 @@ test("original receipt owner persists authored metadata before releasing the rec
   f.run = { ...f.run, state: "starting", providerTurnId: "", pendingUserMessageClientIds: [messageId] };
   const receipt = Promise.withResolvers();
   let received = false;
+  const deliveryTimings = [];
   receipt.promise.then(() => { received = true; f.operations.push("receipt"); });
   f.owner.pendingUserMessages.set(`project:${f.sessionId}\0${messageId}`, {
     attachments: [{ id: "attachment-1", name: "Diagram" }], actorContext,
     turnMetadata: { actorId: "saved-actor", label: "authored" }, receipt,
+    onNativeReceipt: () => deliveryTimings.push("native-acknowledged"),
+    onReceiptPersisted: () => deliveryTimings.push("receipt-persisted"),
     text: "Review the diagram."
   });
   f.observe();
@@ -1090,11 +1093,13 @@ test("original receipt owner persists authored metadata before releasing the rec
   f.emit({ method: "item/completed", params: { threadId: f.threadId, turnId: f.turnId,
     item: outputItem("early-commentary", "I am reviewing the diagram.", "commentary") } });
   await decorating.promise;
+  assert.deepEqual(deliveryTimings, ["native-acknowledged"], "Native acknowledgement precedes the held canonical write");
   assert.equal(received, false);
   assert.equal(await f.store.conversationMessageIdExists(f.sessionId, messageId), false);
   assert.equal(f.publications.some(event => event.payload?.conversationLogPatch?.turn?.commentary), false);
   release.resolve();
   await f.drain();
+  assert.deepEqual(deliveryTimings, ["native-acknowledged", "receipt-persisted"]);
   assert.deepEqual(await receipt.promise, { id: f.turnId });
   const turns = await f.store.readConversationLog(f.sessionId);
   const authored = turns.find(row => row.user?.messageId === messageId);

package/test/conversation.test.js

@@ -4,6 +4,8 @@ import { createMemoryConversationStorage } from "../src/server/conversation/memo
 import { createConversationStorage } from "../src/server/conversation/storage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { conversationTurnsFromMessages } from "../src/shared/conversation/turns.js";
+import { CONVERSATION_LOG_PAGE_LIMIT, conversationLogReadQuery, mergeConversationLogPages } from "../src/shared/conversation/pagination.js";
+import { applyConversationLogPatch } from "../src/shared/conversation/patches.js";
 import { verifyConversationStorageContract } from "../src/testing/conversationStorageContract.js";
 
 test("new output identity persists on its original message while older records remain unchanged", async () => {
@@ -248,3 +250,63 @@ test("completed envelope presentation has an honest empty page when all canonica
     newestTurnId: "", nextBeforeTurnId: "", oldestTurnId: "", totalTurnCount: 0 });
   assert.equal((await transcript.readConversationLog("empty")).length, 1);
 });
+
+
+test("history pages load ten real messages across reasoning rows and split turns without rewriting storage", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await storage.write("large", async tx => {
+    let id = 0;
+    const append = async (role, turnId = String(++id).padStart(6, "0")) => {
+      await tx.appendMessage(turnId, { role, messageId: `${turnId}-${role}`, text: `${role} ${turnId}`, at: "2026-10-14" });
+      return turnId;
+    };
+    await append("thinking");
+    for (let index = 0; index < 123; index++) {
+      const turnId = await append("user");
+      await append("commentary", turnId);
+      if (index < 122) await append("assistant", turnId);
+      for (let reasoning = 0; reasoning < 9; reasoning++) await append("thinking");
+    }
+  });
+  const before = await transcript.readConversationLog("large");
+  assert.equal(CONVERSATION_LOG_PAGE_LIMIT, 10);
+  assert.equal(conversationLogReadQuery().limit, "10");
+  const pages = [];
+  let cursor = "";
+  let remaining = 245;
+  do {
+    const page = await transcript.readConversationLogPage("large", { limit: 10, beforeTurnId: cursor, pageUnit: "messages" });
+    const count = page.conversationLog.reduce((sum, turn) => sum + [turn.system, turn.user, turn.assistant].filter(Boolean).length, 0);
+    assert.equal(count, Math.min(10, remaining));
+    remaining -= count;
+    assert.equal(page.pagination.hasMoreBefore, remaining > 0);
+    assert.notEqual(page.pagination.nextBeforeTurnId, cursor);
+    pages.unshift(page);
+    cursor = page.pagination.nextBeforeTurnId;
+  } while (cursor);
+  assert.equal(remaining, 0);
+  assert.match(pages.at(-1).pagination.nextBeforeTurnId, /^message:/);
+  const merged = mergeConversationLogPages(pages).conversationLog;
+  const identities = rows => rows.flatMap(turn => turn.messages.map(message => message.messageId));
+  assert.deepEqual(identities(merged), identities(before), "all messages and reasoning survive pagination exactly once and in order");
+  assert.deepEqual(await transcript.readConversationLog("large"), before, "reading pages never changes saved rows");
+  const firstAnswer = pages.at(-1).conversationLog[0];
+  assert.equal(firstAnswer.user, null);
+  assert.ok(firstAnswer.assistant);
+  const patched = applyConversationLogPatch(pages.at(-1), { type: "upsert-turn", turn: {
+    turnId: "999999", thinking: [{ role: "thinking", text: "More reasoning" }]
+  } }, { limit: 10 });
+  assert.equal(patched.conversationLog[0].turnId, firstAnswer.turnId);
+  assert.equal(patched.pagination.nextBeforeTurnId, pages.at(-1).pagination.nextBeforeTurnId);
+});
+
+test("reasoning-only histories remain readable without creating phantom message pages", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  for (let index = 0; index < 25; index++) await transcript.writeConversationThinkingMessage("activity", { text: `Thought ${index}` });
+  const page = await transcript.readConversationLogPage("activity", { limit: 10, pageUnit: "messages" });
+  assert.equal(page.conversationLog.length, 25);
+  assert.equal(page.pagination.hasMoreBefore, false);
+  assert.equal(page.pagination.nextBeforeTurnId, "");
+});

package/test/conversationDeliveryTiming.test.js

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createConversationDeliveryTiming } from "../src/server/conversation/deliveryTiming.js";
+
+test("native engines share bounded, content-free timing and independent message identities", () => {
+  for (const engine of ["codex", "claude", "opencode"]) {
+    let now = 0;
+    const events = [];
+    const mark = createConversationDeliveryTiming({ engine, conversationId: "chat", messageId: "one",
+      report: event => events.push(event), clock: () => now });
+    mark("received");
+    now = 3; mark("dispatch-started");
+    now = 1003; mark("native-acknowledged");
+    now = 1013; mark("receipt-persisted");
+    now = 1015; mark("accepted");
+    now = 1020; mark("first-response");
+    mark("first-response");
+    mark("arbitrary-provider-payload");
+    assert.equal(events.length, 6);
+    assert.equal(events[2].durationMs, 1000);
+    assert.equal(events[3].durationMs, 10);
+    assert.deepEqual(events[4].timings, {
+      received: 0, "dispatch-started": 3, "native-acknowledged": 1003, "receipt-persisted": 1013, accepted: 1015
+    });
+    assert.equal(events[0].timings.accepted, undefined, "Earlier reports are snapshots");
+    for (const event of events) assert.deepEqual(Object.keys(event).sort(),
+      ["engine", "conversationId", "messageId", "stage", "previousStage", "durationMs", "elapsedMs", "timings"].sort());
+    const next = createConversationDeliveryTiming({ engine, conversationId: "chat", messageId: "two",
+      report: event => events.push(event), clock: () => now });
+    next("received");
+    assert.equal(events.at(-1).messageId, "two");
+    assert.equal(events.at(-1).elapsedMs, 0);
+  }
+});
+
+test("diagnostic failures and unfinished asynchronous observers never block delivery", async () => {
+  const pending = Promise.withResolvers();
+  let calls = 0;
+  const mark = createConversationDeliveryTiming({ engine: "claude", conversationId: "chat", messageId: "one",
+    report() {
+      calls++;
+      if (calls === 1) throw new Error("Observer unavailable");
+      if (calls === 2) return Promise.reject(new Error("Observer rejected"));
+      return pending.promise;
+    } });
+  mark("received"); mark("dispatch-started"); mark("native-acknowledged"); mark("receipt-persisted");
+  assert.equal(calls, 4);
+  await Promise.resolve();
+  pending.resolve();
+});

package/test/opencodeConversationSession.test.js

@@ -227,6 +227,7 @@ async function fixture(t, options = {}) {
   });
   const runtime = () => {
     const value = createConversationRuntime({ engine: "opencode", storage, authorize: options.authorize || (() => true), actions: options.actions, attachments: options.attachments,
+      onDeliveryTiming: options.onDeliveryTiming,
       connections: { resolve: options.resolve || (async () => ({ providerId: "test", model: "test-model", sdkPackage: "@ai-sdk/openai-compatible",
         modelLimits: { context: 32000, output: 4000 }, apiKey: key })) },
       host: { workdir: directory, env: { ...process.env, UNRELATED_SECRET: "must-not-inherit" },
@@ -249,6 +250,19 @@ async function fixture(t, options = {}) {
     async trace() { return (await readFile(trace, "utf8")).trim().split("\n").map(line => JSON.parse(line)); } };
 }
 
+test("OpenCode delivery timing uses the common receipt stages without recording authored content", async t => {
+  const timings = [];
+  const f = await fixture(t, { onDeliveryTiming: event => timings.push(event) });
+  const receipt = await f.conversation.send({ messageId: "timed-request", text: "Private message" });
+  assert.equal(receipt.status, "accepted");
+  await f.conversation.wait();
+  const stages = timings.map(event => event.stage);
+  assert.deepEqual(stages.slice(0, 8), ["received", "preparation-started", "provider-started", "runtime-ready", "dispatch-started",
+    "native-acknowledged", "receipt-persisted", "accepted"]);
+  assert.equal(stages.filter(stage => stage === "first-response").length, 1);
+  assert.equal(JSON.stringify(timings).includes("Private message"), false);
+});
+
 test("OpenCode structured output shares the original prompt and completed-result normalization across reopen", async t => {
   const outputSchema = { type: "object", additionalProperties: false,
     properties: { answer: { type: "string", maxLength: 32 } }, required: ["answer"] };