@jskit-ai/assistant-core 0.1.221 → 0.1.222

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.222",
+    "@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.222",
   "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/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/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"] };