stitchkit 0.68.4 → 0.68.5

package/dist/agent-runtime.js

@@ -305,7 +305,7 @@ function createAgentSessionCoordinator() {
     }
   };
 }
-// src/agent-runtime/events.ts
+// src/agent-runtime/event-schema.ts
 import { z } from "zod";
 var AgentAdmissionEventSchema = z.object({
   type: z.literal("admission"),
@@ -422,6 +422,11 @@ function advanceAgentRuntimeEventCursor(rawCursor, event) {
     cursor: { ...cursor, runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
   };
 }
+function agentDurableEventId(type, runId, snapshotVersion) {
+  return `${runId}:${type}:${snapshotVersion}`;
+}
+
+// src/agent-runtime/events.ts
 function createAgentRuntimeEventSink(config) {
   const manager = createBoundedSinkManager({
     write: config.write,
@@ -441,9 +446,6 @@ function createAgentRuntimeEventSink(config) {
     close: () => manager.close()
   };
 }
-function agentDurableEventId(type, runId, snapshotVersion) {
-  return `${runId}:${type}:${snapshotVersion}`;
-}
 // src/agent-runtime/history.ts
 import { modelMessageSchema } from "ai";
 function providerOptions(envelope) {
@@ -1493,6 +1495,7 @@ function createRunExecutor(dependencies) {
       if (!absorbing?.assistant || !absorbing.run.terminalReason) {
         throw new AgentRuntimeConflictError("absorbed run resolution");
       }
+      input.onAcquired?.();
       return {
         run: absorbing.run,
         message: absorbing.assistant,
@@ -1511,6 +1514,7 @@ function createRunExecutor(dependencies) {
       ownerId: runtimeEpoch
     }), "run acquisition");
     let run = findRun(acquired.runs, input.acceptedRun.id);
+    input.onAcquired?.();
     await publish({
       type: "run-state",
       eventId: agentDurableEventId("run-state", run.id, acquired.version),
@@ -2281,6 +2285,15 @@ function createAgentRuntime(config) {
     const context = config.protocol.parseContext(rawInput.context);
     const accepted = Promise.withResolvers();
     const result = Promise.withResolvers();
+    let acquisitionSettled = false;
+    const resolveAcquisition = () => {
+      acquisitionSettled = true;
+      accepted.resolve();
+    };
+    const rejectAcquisition = (error) => {
+      if (!acquisitionSettled)
+        accepted.reject(error);
+    };
     const handedOff = beginAdmission();
     (async () => {
       try {
@@ -2294,7 +2307,6 @@ function createAgentRuntime(config) {
         if (recoveredRun.state !== "queued") {
           throw new Error("Only a queued recovered agent run can be resumed");
         }
-        accepted.resolve();
         const ticket = coordinator.submit({
           key: rawInput.conversationKey ?? rawInput.conversationId,
           policy: "queue",
@@ -2304,16 +2316,20 @@ function createAgentRuntime(config) {
               acceptedRun: recoveredRun,
               context,
               signal,
-              key: rawInput.conversationKey ?? rawInput.conversationId
+              key: rawInput.conversationKey ?? rawInput.conversationId,
+              onAcquired: resolveAcquisition
             })
           })
         });
         ticket.accepted.catch(() => {
           return;
         });
-        ticket.result.then(result.resolve, result.reject);
+        ticket.result.then(result.resolve, (error) => {
+          rejectAcquisition(error);
+          result.reject(error);
+        });
       } catch (error) {
-        accepted.reject(error);
+        rejectAcquisition(error);
         result.reject(error);
       } finally {
         handedOff();
@@ -2599,101 +2615,129 @@ function createAgentRuntime(config) {
       if (!Number.isSafeInteger(maxRuns) || maxRuns < 1) {
         throw new TypeError("Recovery maxRuns must be a positive safe integer");
       }
-      const outcomes = [];
+      const recoverable = [];
       let cursor;
-      while (outcomes.length < maxRuns && !options.signal?.aborted && !admissionClosed) {
+      while (recoverable.length < maxRuns && !options.signal?.aborted && !admissionClosed) {
         const page = await config.store.scanRecoverable({
           ...cursor && { cursor },
-          limit: Math.min(pageSize, maxRuns - outcomes.length)
+          limit: Math.min(pageSize, maxRuns - recoverable.length)
         });
-        for (const item of page.items) {
-          if (options.signal?.aborted)
-            break;
+        recoverable.push(...page.items);
+        cursor = page.nextCursor;
+        if (!cursor || page.items.length === 0)
+          break;
+      }
+      const grouped = new Map;
+      for (const item of recoverable) {
+        const items = grouped.get(item.conversationId) ?? [];
+        items.push(item);
+        grouped.set(item.conversationId, items);
+      }
+      const ordered = [];
+      for (const [conversationId, items] of grouped) {
+        const active = await config.store.listActiveRuns(conversationId);
+        const position = new Map(active.map((run, index) => [run.id, index]));
+        ordered.push(...items.sort((left, right) => {
+          const leftPosition = position.get(left.run.id);
+          const rightPosition = position.get(right.run.id);
+          if (leftPosition === undefined && rightPosition === undefined)
+            return 0;
+          if (leftPosition === undefined)
+            return 1;
+          if (rightPosition === undefined)
+            return -1;
+          return leftPosition - rightPosition;
+        }));
+      }
+      const outcomes = [];
+      const scheduledRuns = new Map;
+      for (const item of ordered) {
+        if (options.signal?.aborted)
+          break;
+        if (admissionClosed)
+          break;
+        const releaseAdmission = beginAdmission();
+        try {
+          const active = await config.store.listActiveRuns(item.conversationId);
+          const position = active.findIndex((run) => run.id === item.run.id);
+          const scheduled = scheduledRuns.get(item.conversationId) ?? new Set;
+          const blockedByUnscheduledPredecessor = position > 0 && active.slice(0, position).some((run) => !scheduled.has(run.id));
+          if (blockedByUnscheduledPredecessor) {
+            outcomes.push({
+              conversationId: item.conversationId,
+              runId: item.run.id,
+              outcome: "skipped"
+            });
+            continue;
+          }
+          const decision = await options.decide?.(item) ?? (item.run.state === "queued" ? { action: "resume" } : { action: "skip" });
           if (admissionClosed)
-            break;
-          const handedOff = beginAdmission();
-          try {
-            if (item.run.state === "queued") {
-              const active = await config.store.listActiveRuns(item.conversationId);
-              const blockedByAcquiredPredecessor = active.some((run) => run.id !== item.run.id && (run.state === "running" || run.state === "interrupt_requested"));
-              if (blockedByAcquiredPredecessor) {
-                outcomes.push({
-                  conversationId: item.conversationId,
-                  runId: item.run.id,
-                  outcome: "skipped"
-                });
-                continue;
-              }
-            }
-            const decision = await options.decide?.(item) ?? (item.run.state === "queued" ? { action: "resume" } : { action: "skip" });
-            if (admissionClosed)
-              throw closedError();
-            if (decision.action === "skip") {
-              outcomes.push({
-                conversationId: item.conversationId,
-                runId: item.run.id,
-                outcome: "skipped"
-              });
-              continue;
-            }
-            if (decision.action === "abandon") {
-              const abandoned = await config.store.recoverRun({
-                conversationId: item.conversationId,
-                runId: item.run.id,
-                expectedRevision: item.run.revision,
-                action: "abandon"
-              });
-              if (abandoned.outcome !== "applied") {
-                throw new AgentRuntimeConflictError("recovery abandon");
-              }
-              outcomes.push({
-                conversationId: item.conversationId,
-                runId: item.run.id,
-                outcome: "abandoned"
-              });
-              continue;
-            }
-            if (decision.action === "requeue") {
-              const requeued = await config.store.recoverRun({
-                conversationId: item.conversationId,
-                runId: item.run.id,
-                expectedRevision: item.run.revision,
-                action: "requeue",
-                replaySafe: true
-              });
-              if (requeued.outcome !== "applied") {
-                throw new AgentRuntimeConflictError("recovery requeue");
-              }
-            }
-            const context = await options.resolveContext(item);
-            const resumed = resume({
+            throw closedError();
+          if (decision.action === "skip") {
+            outcomes.push({
               conversationId: item.conversationId,
               runId: item.run.id,
-              context
+              outcome: "skipped"
             });
-            resumed.result.catch(() => {
-              return;
+            continue;
+          }
+          if (decision.action === "abandon") {
+            const abandoned = await config.store.recoverRun({
+              conversationId: item.conversationId,
+              runId: item.run.id,
+              expectedRevision: item.run.revision,
+              action: "abandon"
             });
-            await resumed.accepted;
+            if (abandoned.outcome !== "applied") {
+              throw new AgentRuntimeConflictError("recovery abandon");
+            }
             outcomes.push({
               conversationId: item.conversationId,
               runId: item.run.id,
-              outcome: decision.action === "requeue" ? "requeued" : "resumed"
+              outcome: "abandoned"
             });
-          } catch (error) {
-            outcomes.push({
+            continue;
+          }
+          if (decision.action === "requeue") {
+            const requeued = await config.store.recoverRun({
               conversationId: item.conversationId,
               runId: item.run.id,
-              outcome: "failed",
-              error
+              expectedRevision: item.run.revision,
+              action: "requeue",
+              replaySafe: true
             });
-          } finally {
-            handedOff();
+            if (requeued.outcome !== "applied") {
+              throw new AgentRuntimeConflictError("recovery requeue");
+            }
           }
+          const context = await options.resolveContext(item);
+          const resumed = resume({
+            conversationId: item.conversationId,
+            runId: item.run.id,
+            context
+          });
+          resumed.result.catch(() => {
+            return;
+          });
+          await resumed.accepted;
+          scheduled.add(item.run.id);
+          scheduledRuns.set(item.conversationId, scheduled);
+          outcomes.push({
+            conversationId: item.conversationId,
+            runId: item.run.id,
+            outcome: decision.action === "requeue" ? "requeued" : "resumed",
+            result: resumed.result
+          });
+        } catch (error) {
+          outcomes.push({
+            conversationId: item.conversationId,
+            runId: item.run.id,
+            outcome: "failed",
+            error
+          });
+        } finally {
+          releaseAdmission();
         }
-        cursor = page.nextCursor;
-        if (!cursor || page.items.length === 0)
-          break;
       }
       return outcomes;
     },
@@ -3276,7 +3320,10 @@ function createAgentRuntimeStore(driver) {
     });
   });
   const listActiveRuns = (conversationId) => driver.transaction(async (transaction) => {
-    const records = await driver.runs.listActive(transaction, conversationId);
+    const [records, messages] = await Promise.all([
+      driver.runs.listActive(transaction, conversationId),
+      driver.history.load(transaction, conversationId)
+    ]);
     const runs = records.map((record) => AgentStoredRunSchema.parse(record).run);
     for (const run of runs) {
       if (run.conversationId !== conversationId) {
@@ -3286,7 +3333,7 @@ function createAgentRuntimeStore(driver) {
         throw new TypeError("Active run listing returned a terminal run");
       }
     }
-    return runs.sort((left, right) => left.createdAt === right.createdAt ? left.id.localeCompare(right.id) : left.createdAt < right.createdAt ? -1 : 1);
+    return orderRuns(messages, runs);
   });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);

package/dist/browser/cancellation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cancellation.d.ts","sourceRoot":"","sources":["../../src/browser/cancellation.ts"],"names":[],"mappings":"AAAA,KAAK,iBAAiB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9C,4EAA4E;AAC5E,qBAAa,wBAAyB,SAAQ,KAAK;aACrB,KAAK,EAAE,iBAAiB;IAApD,YAA4B,KAAK,EAAE,iBAAiB,EAGnD;CACF;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACrE;AAED,gFAAgF;AAChF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,mBAAmB,CAqCrB"}
+{"version":3,"file":"cancellation.d.ts","sourceRoot":"","sources":["../../src/browser/cancellation.ts"],"names":[],"mappings":"AAAA,KAAK,iBAAiB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9C,4EAA4E;AAC5E,qBAAa,wBAAyB,SAAQ,KAAK;aACrB,KAAK,EAAE,iBAAiB;IAApD,YAA4B,KAAK,EAAE,iBAAiB,EAGnD;CACF;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACrE;AAED,gFAAgF;AAChF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,mBAAmB,CAwCrB"}

package/dist/{index-thcy3w8c.js → index-n34x0q5e.js}

@@ -28,34 +28,34 @@ function createRequestCancellation(caller, timeoutMs) {
   if (!caller && timeoutMs === undefined) {
     return { signal: undefined, run: (operation) => operation() };
   }
-  const controller = new AbortController;
+  const timeoutController = timeoutMs === undefined ? undefined : new AbortController;
+  const signal = caller && timeoutController ? AbortSignal.any([caller, timeoutController.signal]) : caller ?? timeoutController?.signal;
   let cause;
   let timer;
   const abortFromCaller = () => {
     if (cause)
       return;
     cause = "caller";
-    controller.abort(caller?.reason);
   };
   if (caller?.aborted)
     abortFromCaller();
   else
     caller?.addEventListener("abort", abortFromCaller, { once: true });
-  if (timeoutMs !== undefined) {
+  if (timeoutMs !== undefined && timeoutController) {
     timer = setTimeout(() => {
       if (cause)
         return;
       cause = "timeout";
-      controller.abort(new DOMException("Request timed out", "TimeoutError"));
+      timeoutController.abort(new DOMException("Request timed out", "TimeoutError"));
     }, timeoutMs);
   }
   return {
-    signal: controller.signal,
+    signal,
     async run(operation) {
       try {
         if (cause === "caller")
           throw cancellationError(cause);
-        return await operation(controller.signal);
+        return await operation(signal);
       } catch (error) {
         if (cause)
           throw cancellationError(cause);

package/dist/index.js

@@ -42,34 +42,34 @@ function createRequestCancellation(caller, timeoutMs) {
   if (!caller && timeoutMs === undefined) {
     return { signal: undefined, run: (operation) => operation() };
   }
-  const controller = new AbortController;
+  const timeoutController = timeoutMs === undefined ? undefined : new AbortController;
+  const signal = caller && timeoutController ? AbortSignal.any([caller, timeoutController.signal]) : caller ?? timeoutController?.signal;
   let cause;
   let timer;
   const abortFromCaller = () => {
     if (cause)
       return;
     cause = "caller";
-    controller.abort(caller?.reason);
   };
   if (caller?.aborted)
     abortFromCaller();
   else
     caller?.addEventListener("abort", abortFromCaller, { once: true });
-  if (timeoutMs !== undefined) {
+  if (timeoutMs !== undefined && timeoutController) {
     timer = setTimeout(() => {
       if (cause)
         return;
       cause = "timeout";
-      controller.abort(new DOMException("Request timed out", "TimeoutError"));
+      timeoutController.abort(new DOMException("Request timed out", "TimeoutError"));
     }, timeoutMs);
   }
   return {
-    signal: controller.signal,
+    signal,
     async run(operation) {
       try {
         if (cause === "caller")
           throw cancellationError(cause);
-        return await operation(controller.signal);
+        return await operation(signal);
       } catch (error) {
         if (cause)
           throw cancellationError(cause);

package/dist/remote.js

@@ -1,7 +1,7 @@
 import {
   ApiError,
   createClient
-} from "./index-thcy3w8c.js";
+} from "./index-n34x0q5e.js";
 import"./index-r5s4wqb5.js";
 import {
   mergeMeta

package/dist/testing/agent-store-conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/agent-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,WAAW,CACT,OAAO,EAAE,4BAA4B,GACpC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CA2Bf"}
+{"version":3,"file":"agent-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/agent-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,WAAW,CACT,OAAO,EAAE,4BAA4B,GACpC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/testing.js

@@ -25,7 +25,7 @@ import {
 import {
   createClient,
   createClients
-} from "./index-thcy3w8c.js";
+} from "./index-n34x0q5e.js";
 import"./index-r5s4wqb5.js";
 import {
   joinRoutePath
@@ -145,7 +145,13 @@ function requireOutcome(actual, expected) {
 async function runAgentStoreConformance(config) {
   const run = `conformance-${crypto.randomUUID()}`;
   const context = {
-    conversationIds: [run, `${run}-recovery`, `${run}-absorb`, `${run}-causal-history`]
+    conversationIds: [
+      run,
+      `${run}-recovery`,
+      `${run}-absorb`,
+      `${run}-causal-history`,
+      `${run}-causal-active`
+    ]
   };
   const store = await config.createStore(context);
   let failure;
@@ -169,10 +175,11 @@ async function conformanceScenario(store, conversationIds) {
     conversationId,
     recoveryConversationId,
     absorbConversationId,
-    causalHistoryConversationId
+    causalHistoryConversationId,
+    causalActiveConversationId
   ] = conversationIds;
-  if (!conversationId || !recoveryConversationId || !absorbConversationId || !causalHistoryConversationId) {
-    throw new Error("Agent store conformance requires four conversation identities");
+  if (!conversationId || !recoveryConversationId || !absorbConversationId || !causalHistoryConversationId || !causalActiveConversationId) {
+    throw new Error("Agent store conformance requires five conversation identities");
   }
   const absentConversationId = `${conversationId}-absent`;
   const firstInput = userMessage(conversationId, "input-1");
@@ -554,8 +561,23 @@ async function conformanceScenario(store, conversationIds) {
     throw new Error("Abandon recovery did not atomically terminalize its assistant record");
   }
   await assertCausalHistoryOrder(store, causalHistoryConversationId);
+  await assertActiveRunCausalOrder(store, causalActiveConversationId);
   await assertAbsorptionIsAtomic(store, absorbConversationId);
 }
+async function assertActiveRunCausalOrder(store, conversationId) {
+  for (const id of ["z-causal-run", "a-causal-run"]) {
+    const input = userMessage(conversationId, `${id}-input`);
+    requireOutcome(await store.acceptInputAndAssignRun({
+      idempotencyKey: id,
+      input,
+      run: queuedRun(conversationId, input.id, id)
+    }), "applied");
+  }
+  const active = await store.listActiveRuns(conversationId);
+  if (active.map((run) => run.id).join(",") !== "z-causal-run,a-causal-run") {
+    throw new Error("listActiveRuns must preserve causal history order for timestamp ties");
+  }
+}
 async function assertCausalHistoryOrder(store, conversationId) {
   const leadInput = userMessage(conversationId, "causal-input-1");
   const leadRun = queuedRun(conversationId, leadInput.id, "causal-run-1");

package/llms-full.txt

@@ -61,6 +61,7 @@ own, recorded as an ADR.
 | `stitchkit/react` | browser | stable | `createCursorQuery`, `createCacheBridge` |
 | `stitchkit/agent-runtime` | server | evolving<br>_redefined in 9 of the 13 minors since 0.56.2, most recently 0.66.0_ | optional durable conversation/run loop, history, models, prompts, fencing and events |
 | `stitchkit/agent-runtime/openrouter` | server | evolving | isolated OpenRouter language-model adapter |
+| `stitchkit/agent-runtime/browser` | browser + server | evolving | canonical agent records, events and reconnect cursor without execution or sinks |
 | `stitchkit/application` | server | evolving<br>_redefined in 3 of the 13 minors since 0.56.2, most recently 0.67.0_ | managed resource graph, readiness, admission, schedules and bounded shutdown |
 | `stitchkit/application/grammy` | server | evolving | isolated grammY polling and webhook lifecycle adapters |
 | `stitchkit/application/opentelemetry` | server | evolving | maps application snapshots onto an injected OpenTelemetry `Meter` |
@@ -2428,6 +2429,13 @@ wire `end` frame and, when declared, at least one matching terminal item; EOF is
 converge on the request operation. See the
 [server half](./server.md#contract-first-streams). → ADR 0117.
 
+The request deadline bounds the wait for response headers. Once headers arrive,
+that timer is cleared, while the caller signal remains attached to the response
+body until it ends or is cancelled. This is the same for a Fetch-config client,
+`createHttpClient`, the Bun-only `unix` convenience and an injected portable
+Unix transport. Cancelling a quiet stream therefore releases its server source
+and transport connection instead of only settling the local iterator.
+
 An established NDJSON protocol may keep its item schema as the complete wire
 frame. This mode requires a terminal item because an unwrapped response has no
 separate safe error/end envelope:
@@ -3742,6 +3750,21 @@ If the application already owns that loop, continue importing `mountAgent` from
 this entrypoint uses the tool executor from it, but pulls no MCP peer, so
 choosing `mountAgent` alone costs you nothing from here.
 
+UI and shared DTO code must import canonical records and delivery validation from
+`stitchkit/agent-runtime/browser`, not from the server runtime barrel:
+
+```ts
+import {
+  AgentRunSchema,
+  AgentRuntimeEventSchema,
+  advanceAgentRuntimeEventCursor,
+} from 'stitchkit/agent-runtime/browser'
+```
+
+This browser-safe entrypoint re-exports the same schemas and inferred types used
+by the runtime. It intentionally excludes model construction, execution,
+persistence, event sinks and every Node context dependency.
+
 ## Install
 
 ```sh
@@ -4190,12 +4213,18 @@ checkpoint/terminal CAS and tool context, so a distributed adapter can reject an
 an owner label is reused. Lease expiry and renewal remain application-owned.
 
 On startup, `runtime.recover({ resolveContext })` consumes bounded lightweight
-pages. Its safe default resumes queued runs and reports acquired or
+pages, then restores each conversation's canonical causal order before any run
+acquires. Scan identifiers and page boundaries therefore never become queue
+order. Its safe default resumes queued runs and reports acquired or
 `interrupt_requested` runs as skipped. A policy may requeue acquired work only
 with explicit replay-safe evidence, or abandon it only with stale-owner
-evidence. Each attempted run returns its own outcome/error; `pageSize`,
-`maxRuns`, and `signal` bound the pass. `runtime.resume(...)` remains available
-for one known queued record.
+evidence. Each attempted run returns its own outcome/error; a `resumed` or
+`requeued` outcome also exposes the terminal `result` promise. The outcome is
+reported only after durable acquisition, so a lost acquisition is `failed`
+rather than a successful-looking handoff. `pageSize`, `maxRuns`, and `signal`
+bound the pass. `runtime.resume(...)` remains available for one known queued
+record; its `accepted` promise likewise means that the recovered run acquired
+durable ownership, while `result` carries terminal completion.
 
 Canonical records currently write `schemaVersion: 1`. A durable adapter owns
 read-time migration of older rows: migrate to the current shape at its storage
@@ -11516,7 +11545,7 @@ Server-only optional application runtime. See the
 | `AgentRuntimeAdmission` | _type_ | canonical committed input, assigned run, pending assistant projection, compatibility IDs and snapshot version |
 | `AgentAdmissionEventSchema` | schema | post-commit admission projection; removes store rereads but does not imply exactly-once delivery |
 | `AgentRunMetricsSchema` | schema | optional provenance-aware usage and timings; `partial` says the provider never reported the run finished, so the figure beside it is not a confirmed total |
-| `AgentRuntimeRecoverOptions` | _type_ | bounded paged startup recovery with context resolver and explicit evidence policy |
+| `AgentRuntimeRecoverOptions` | _type_ | bounded paged startup recovery with causal per-conversation scheduling, context resolver and explicit evidence policy |
 | `AgentRuntimeConflictError` | class | thrown when a store mutation loses to a concurrent writer — catchable by type from `stitchkit/agent-runtime` |
 | `AgentSessionCloseOptions` | _type_ | `gracePeriodMs` for natural settlement, then abort, then `forceTimeoutMs` for bounded settlement after it |
 | `AgentSessionCloseResult` | _type_ | what `close()` achieved: `settled`, or `timedOut` with `remaining` runs still in flight. Only omitting `forceTimeoutMs` guarantees nothing is in flight on return |
@@ -11629,6 +11658,20 @@ Managed effects and operator telemetry additionally export `AgentToolFenceConfig
 may accompany checkpoint/terminal writes and tool context; internal causes are redacted unless an
 operator-only observability sink explicitly opts in.
 
+## `stitchkit/agent-runtime/browser`
+
+Browser-safe canonical agent data. It re-exports the run, message, part, usage,
+terminal and provider-envelope schemas/types listed under
+`stitchkit/agent-runtime`, together with all runtime delivery event schemas,
+`AgentRuntimeEventCursorSchema`, `advanceAgentRuntimeEventCursor` and
+`agentDurableEventId`. It imports no model provider, executor, store, event sink
+or Node context module.
+
+Use this entrypoint from client components and shared DTO packages. The full
+`stitchkit/agent-runtime` entrypoint remains server-only.
+
+---
+
 ## `stitchkit/agent-runtime/openrouter`
 
 | Export | Kind | Summary |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.68.4",
+  "version": "0.68.5",
   "description": "Contract-first backend framework — one defineContract() into an HTTP API, MCP tools, AI-agent tools and a typed client. Bun and Node.",
   "keywords": [
     "bun",
@@ -84,6 +84,10 @@
       "types": "./dist/agent-runtime.d.ts",
       "import": "./dist/agent-runtime.js"
     },
+    "./agent-runtime/browser": {
+      "types": "./dist/agent-runtime-browser.d.ts",
+      "import": "./dist/agent-runtime-browser.js"
+    },
     "./agent-runtime/openrouter": {
       "types": "./dist/agent-runtime-openrouter.d.ts",
       "import": "./dist/agent-runtime-openrouter.js"
@@ -122,7 +126,7 @@
   },
   "scripts": {
     "check": "bun x tsc --noEmit",
-    "build:browser": "bun build src/index.ts src/react.ts src/contract/index.ts src/declaration.ts --outdir dist --target node --packages external --splitting --root src",
+    "build:browser": "bun build src/index.ts src/react.ts src/contract/index.ts src/declaration.ts src/agent-runtime-browser.ts --outdir dist --target node --packages external --splitting --root src",
     "build:server": "bun build src/server/index.ts src/node.ts src/tools.ts src/tool-invoker.ts src/cli.ts src/remote.ts src/files.ts src/testing.ts src/observability/index.ts src/agent-runtime.ts src/agent-runtime-openrouter.ts src/application.ts src/application-grammy.ts src/application-opentelemetry.ts --outdir dist --target node --packages external --splitting --root src",
     "build:js": "bun run build:browser && bun run build:server && bun scripts/preserve-webpack-ignore.mjs",
     "build:types": "bun x tsc -p tsconfig.build.json --emitDeclarationOnly && bun scripts/rewrite-declaration-specifiers.mjs",