stitchkit 0.110.1 → 0.110.3

package/dist/index-snef22zr.js

@@ -0,0 +1,94 @@
+// src/durability/contract.ts
+import { z } from "zod";
+var DURABILITY_STEP_EVENT_KIND2 = "durability/step";
+var DURABILITY_PARK_EVENT_KIND = "durability/park";
+var DURABILITY_EVENT_EVENT_KIND = "durability/event";
+var DURABILITY_EFFECT_EVENT_KIND = "durability/effect";
+var StepEventPayloadSchema = z.object({
+  runId: z.string().min(1),
+  stepName: z.string().min(1),
+  encoded: z.string()
+});
+var SleepParkSchema = z.object({
+  runId: z.string().min(1),
+  kind: z.literal("sleep"),
+  name: z.string().min(1),
+  deadline: z.number()
+});
+var WaitParkSchema = z.object({
+  runId: z.string().min(1),
+  kind: z.literal("wait"),
+  event: z.string().min(1),
+  id: z.string().min(1)
+});
+var ParkEventPayloadSchema = z.discriminatedUnion("kind", [
+  SleepParkSchema,
+  WaitParkSchema
+]);
+var DeliveredEventPayloadSchema = z.object({
+  runId: z.string().min(1),
+  event: z.string().min(1),
+  id: z.string().min(1),
+  encoded: z.string()
+});
+var EffectIdentity = { runId: z.string().min(1), effectName: z.string().min(1) };
+var EffectEventPayloadSchema = z.discriminatedUnion("phase", [
+  z.object({ ...EffectIdentity, phase: z.literal("intent") }),
+  z.object({
+    ...EffectIdentity,
+    phase: z.literal("accepted"),
+    encoded: z.string(),
+    via: z.enum(["run", "reconcile"])
+  }),
+  z.object({ ...EffectIdentity, phase: z.literal("uncertain") })
+]);
+
+class StepResultDecodeError2 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StepResultDecodeError";
+  }
+}
+
+class StepResultNotSerializableError2 extends Error {
+  constructor(stepName, cause) {
+    super(`Step "${stepName}" returned a value that is not JSON-serializable`, {
+      cause
+    });
+    this.name = "StepResultNotSerializableError";
+  }
+}
+
+class StepAbortedError2 extends Error {
+  constructor(stepName) {
+    super(`Step "${stepName}" was aborted before it started`);
+    this.name = "StepAbortedError";
+  }
+}
+
+class EffectUnresolvedError2 extends Error {
+  effectName;
+  reason;
+  constructor(effectName, reason, options) {
+    super(`Effect "${effectName}" is unresolved (${reason}); its intent stands`, options);
+    this.effectName = effectName;
+    this.reason = reason;
+    this.name = "EffectUnresolvedError";
+  }
+}
+
+class ParkRecordDecodeError2 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ParkRecordDecodeError";
+  }
+}
+
+class ParkAbortedError2 extends Error {
+  constructor(park) {
+    super(`Park "${park}" was aborted before it was satisfied`);
+    this.name = "ParkAbortedError";
+  }
+}
+
+export { DURABILITY_STEP_EVENT_KIND2, DURABILITY_PARK_EVENT_KIND, DURABILITY_EVENT_EVENT_KIND, DURABILITY_EFFECT_EVENT_KIND, StepEventPayloadSchema, ParkEventPayloadSchema, DeliveredEventPayloadSchema, EffectEventPayloadSchema, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2 };

package/dist/{index-5p55xreg.js → index-w619fqvv.js}

@@ -2,7 +2,7 @@ import {
   AgentStoreEventEnvelopeSchema2,
   AgentStoreEventPageSchema2,
   AgentRecoverablePageSchema2
-} from "./index-0gs4ymfj.js";
+} from "./index-4fgg1507.js";
 import {
   AgentRecordIdSchema2,
   AgentMessageSchema2
@@ -15,12 +15,64 @@ import {
   AgentHistoryMutationSchema2,
   isActiveRunState,
   replaceMessage,
+  ArchiveSpillSchema,
   createAgentRuntimeStore2
-} from "./index-d2h99n7d.js";
+} from "./index-j1cwtyk1.js";
 
 // src/agent-runtime/store-memory.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/store-memory-archive.ts
 import { z } from "zod";
-var RecoverableCursorSchema = z.tuple([AgentRecordIdSchema2, AgentRecordIdSchema2]);
+var memoryArchive = {
+  async export(transaction, conversationId) {
+    return {
+      projections: [],
+      spills: z.array(z.json()).parse(structuredClone(transaction.spills.get(conversationId) ?? []))
+    };
+  },
+  async import(transaction, archive) {
+    const spills = archive.spills.map((value) => ArchiveSpillSchema.parse(value));
+    const occupied = new Set([...transaction.spills.values()].flatMap((entries) => entries.map((spill) => spill.reference)));
+    for (const spill of spills) {
+      if (occupied.has(spill.reference))
+        throw new TypeError("Conversation archive spill identity is already present");
+      occupied.add(spill.reference);
+    }
+    transaction.spills.set(archive.conversationId, structuredClone(spills));
+  }
+};
+
+// src/agent-runtime/store-memory-events.ts
+var memoryEvents = {
+  async append(transaction, draft) {
+    const current = transaction.events.get(draft.conversationId) ?? [];
+    const event = AgentStoreEventEnvelopeSchema2.parse({
+      ...draft,
+      seq: (current.at(-1)?.seq ?? 0) + 1
+    });
+    if (current.some((candidate) => candidate.eventId === event.eventId)) {
+      throw new TypeError("Agent store event identity is already present");
+    }
+    transaction.events.set(draft.conversationId, [...current, event]);
+    return event;
+  },
+  async list(transaction, input) {
+    const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
+    const items = selected.slice(0, input.limit);
+    const last = items.at(-1);
+    return AgentStoreEventPageSchema2.parse({
+      items,
+      ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
+    });
+  },
+  async find(transaction, input) {
+    return (transaction.events.get(input.conversationId) ?? []).find((event) => event.eventId === input.eventId);
+  }
+};
+
+// src/agent-runtime/store-memory.ts
+var RecoverableCursorSchema = z2.tuple([AgentRecordIdSchema2, AgentRecordIdSchema2]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -46,6 +98,9 @@ function cloneHistoryMap(source) {
   ]));
 }
 var memoryConversations = {
+  async isEmpty(transaction, id) {
+    return !transaction.heads.has(id) && !transaction.runs.has(id) && !transaction.admissions.has(id) && !transaction.seeds.has(id) && !transaction.histories.has(id) && !transaction.events.has(id) && !transaction.spills.has(id);
+  },
   async isPurged(transaction, conversationId) {
     return transaction.purged.has(conversationId);
   },
@@ -57,6 +112,7 @@ var memoryConversations = {
     transaction.seeds.delete(conversationId);
     transaction.histories.delete(conversationId);
     transaction.events.delete(conversationId);
+    transaction.spills.delete(conversationId);
   }
 };
 var memoryHead = {
@@ -140,6 +196,10 @@ var memorySeeds = {
   }
 };
 var memoryHistory = {
+  async restore(transaction, input) {
+    const compacted = new Set(input.compactedMessageIds);
+    transaction.histories.set(input.conversationId, input.messages.filter((message) => !compacted.has(message.id)).map((message) => AgentMessageSchema2.parse(structuredClone(message))));
+  },
   async load(transaction, conversationId) {
     return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema2.parse(structuredClone(message)));
   },
@@ -181,32 +241,6 @@ var memoryHistory = {
     ]);
   }
 };
-var memoryEvents = {
-  async append(transaction, draft) {
-    const current = transaction.events.get(draft.conversationId) ?? [];
-    const event = AgentStoreEventEnvelopeSchema2.parse({
-      ...draft,
-      seq: (current.at(-1)?.seq ?? 0) + 1
-    });
-    if (current.some((candidate) => candidate.eventId === event.eventId)) {
-      throw new TypeError("Agent store event identity is already present");
-    }
-    transaction.events.set(draft.conversationId, [...current, event]);
-    return event;
-  },
-  async list(transaction, input) {
-    const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
-    const items = selected.slice(0, input.limit);
-    const last = items.at(-1);
-    return AgentStoreEventPageSchema2.parse({
-      items,
-      ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
-    });
-  },
-  async find(transaction, input) {
-    return (transaction.events.get(input.conversationId) ?? []).find((event) => event.eventId === input.eventId);
-  }
-};
 function scanMemoryRecoverable(runs, input) {
   const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => isActiveRunState(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
   const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
@@ -230,6 +264,7 @@ function createMemoryAgentRuntimeStore2() {
   let seeds = new Map;
   let histories = new Map;
   let events = new Map;
+  let spills = new Map;
   let transactionTail = Promise.resolve();
   const driver = {
     async transaction(work) {
@@ -243,6 +278,7 @@ function createMemoryAgentRuntimeStore2() {
       });
       const transaction = {
         purged: new Set(purged),
+        spills: structuredClone(spills),
         heads: cloneHeadMap(heads),
         runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema2.parse(structuredClone(record))),
         admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema2.parse(structuredClone(receipt))),
@@ -256,6 +292,7 @@ function createMemoryAgentRuntimeStore2() {
       try {
         const result = await work(transaction);
         purged = transaction.purged;
+        spills = transaction.spills;
         heads = transaction.heads;
         runs = transaction.runs;
         admissions = transaction.admissions;
@@ -274,6 +311,7 @@ function createMemoryAgentRuntimeStore2() {
     seeds: memorySeeds,
     history: memoryHistory,
     events: memoryEvents,
+    archive: memoryArchive,
     async scanRecoverable(input) {
       return scanMemoryRecoverable(runs, input);
     }

package/llms/agent-runtime.3.txt

@@ -31,6 +31,9 @@ Server-only optional application runtime. See the
 | `AgentMessageSchema` / `AgentRunSchema` / `AgentSnapshotSchema` | schema | versioned canonical engine records |
 | `AgentRunQueuePrioritySchema` | schema | durable opt-in priority for queued `interrupt-next` runs |
 | `AgentRuntimeStore` | _type_ | aggregate CAS transaction boundary for message, run and compaction mutations |
+| `BranchAgentConversationInputSchema` / `BranchAgentConversationInput` | schema / _type_ | strict branch request: stable request key, empty destination, settled conversation boundary or archive bytes, fresh artifact authorization |
+| `AgentConversationBranchReceiptSchema` / `AgentConversationBranchReceipt` | schema / _type_ | durable lineage: request fingerprint, source/destination identities, source sequence/version/digest and creation time |
+| `AgentConversationBranchResultSchema` / `AgentConversationBranchResult` | schema / _type_ | `created` or `duplicate` with the same durable receipt; `AgentRuntimeStore.branchConversation` is optional for hand-written stores |
 | `createAgentRuntimeStore` | function | build the aggregate store from one coherent transaction driver; framework owns every state transition |
 | `AgentRuntimeStoreDriver` | _type_ | ORM-neutral transaction over a bounded head, normalized runs/admissions, product history, a **required** `events: { append, list }` ledger table, an optional `archive: { export, import }` for driver-owned durable payloads, and indexed run recovery; optional `{ access: 'read' }` selects a coherent read transaction while absent options remain write-safe |
 | `recordAgentRetryDecision` / `AgentRetryPolicy` | function / _type_ | `loop.retry` policy and the ledger record of a retry decision: explicit retryability and backoff at a durable provider-step boundary |
@@ -101,6 +104,7 @@ Server-only optional application runtime. See the
 | `AgentStoreEventEnvelopeSchema` / `AgentStoreEventEnvelope` / `AgentStoreEventKindSchema` / `AgentStoreEventKind` / `AgentStoreEventPageSchema` / `AgentStoreEventPage` | schema / _type_ | append-only event envelope, closed current vocabulary (including `provider/request` and `provider/response`) and bounded page |
 | `AppendAgentStoreEventSchema` / `AppendAgentStoreEvent` / `ReadAgentStoreEventsSchema` / `ReadAgentStoreEvents` | schema / _type_ | required append and bounded-read store contracts |
 | `AgentStoreTransitionSchema` / `AgentStoreTransition` / `AgentStoreEventDraft` / `AgentStoreEventDecodeAccepted` / `AgentStoreEventDecodeIgnored` / `AgentStoreEventDecodeResult` / `decodeAgentStoreEvent` | schema / _types_ / function | normalized runtime mutations, append drafts and strict current/ignorable future-event decoding outcomes |
+| `AgentStoreTransitionRecordSchema` / `AgentStoreTransitionRecord` | schema / _type_ | persisted journal payloads: full runtime mutations or hash-only streaming checkpoint observations with numeric part/byte counts; inspection does not authorize replay |
 | `defineAgentProjection` / `AgentProjectionDefinition` / `AgentProjectionValue` / `createAgentProjectionRegistry` / `createSqliteAgentProjectionStore` | functions / _type_ | deterministic folds with persisted version and honest `uptoSeq` checkpoints |
 | `agentSummaryProjection` / `agentUsageProjection` / `agentOutlineProjection` | constants | built-in list summary, provenance-carrying usage and request outline projections |
 | `agentConversationCardProjection` / `agentStateSlotsProjection` / `agentScheduleSummaryProjection` | constants | focused card, durable-state and schedule lifecycle projections |

package/llms/agent-runtime.txt

@@ -567,6 +567,72 @@ failed attempt's reported usage stays in the run's spend. Transient events —
 deltas, reasoning, `attempt-reset` — are numbered from 1 per run, counting only
 what was published, so a cursor sees no gap on an ordinary stream.
 
+### Branch or restore with a new identity
+
+Use `store.branchConversation()` to create an independent conversation. `importConversation()`
+restores the original identity and is not a fork. The built-in memory and SQLite stores and
+`createAgentRuntimeStore()` expose branching; a hand-written `AgentRuntimeStore` can advertise this
+optional capability. The host authorizes the caller's source/archive access and destination
+creation before calling this trusted store boundary.
+
+```ts
+const copy = await sqlite.store.branchConversation({
+  requestKey: 'branch-request-1',
+  destinationConversationId: 'new-conversation',
+  source: { kind: 'conversation', conversationId: 'original', throughRunId: 'finished-run' },
+  // Required when selected history has spills: an explicit policy for this destination.
+  artifactAuthorization: { operation: 'read', path: 'approved-destination-workspace' },
+})
+
+const restored = await sqlite.store.branchConversation({
+  requestKey: 'restore-request-1',
+  destinationConversationId: 'restored-as-new',
+  source: { kind: 'archive', bytes: archiveBytes },
+})
+```
+
+`throughRunId` selects its exact terminal/abandon event. Omit it to include the settled tip and
+compaction recorded after the last run. The selected prefix must contain no queued or acquired
+runs. A later active source run does not prevent branching an earlier settled prefix. A migrated
+baseline has no earlier per-run event boundary; it can be copied at its settled tip.
+
+The result is `{ outcome: 'created' | 'duplicate', receipt }`. Keep the receipt: it binds source
+and destination identity, source kind, exact `sourceSeq`/`sourceVersion`, `sourceDigest`, request
+fingerprint and creation time. A retry with the same destination/key and selector returns the
+original receipt even after the source advances or the destination continues. Changing the
+request conflicts; no existing destination is overwritten. Archive fingerprints bind the supplied
+bytes. The source digest binds the selected canonical events, artifacts and reconstructed snapshot.
+Run update timestamps reconstructed from events use their recorded `occurredAt`. Abandon transitions
+retain the full failed assistant in the same event; a legacy archive must retain that exact assistant
+in its runtime snapshot, otherwise copying refuses instead of inventing historical content or time.
+
+No provider or tool runs during copying. The next ordinary runtime `submit` continues the copied
+history. All engine identities and typed references are new, including repeated references to one
+spill. Compacted content stays in the event history and SQLite inactive rows; the model reads the
+same active summaries. A hash-only checkpoint is historical digest evidence, marked
+`sourceSha256`; a later full terminal record must settle its content.
+
+A branch grants no source authority. Terminal run owners/fences and approval signatures are
+removed. State, schedules, children, retries, sandbox, approval rejection and durability facts are
+retained as inert `runtime/branch-observation` records; they cannot repopulate operational state
+or pending effects. Spills discard source authorization and require the explicit fresh
+`artifactAuthorization`; normal destination read authorization still applies. No cached projection,
+schedule row or child relation is cloned. Ordinary companion projections in the export have
+`{ name, version, uptoSeq, value, updatedAt }` envelopes. Branch validates their envelopes,
+unique names and checkpoints within the supplied journal, then discards their values. They are
+derived application caches, including ones containing source references; their values are never
+replayed as state or copied as authority. Rebuild destination projections with
+`createSqliteAgentProjectionStore().advance(...)` over the destination ledger. An exact earlier
+boundary never inherits a later cache value.
+
+The store validates the complete archive before writing: contiguous events, a matching runtime
+snapshot, known typed forms, reference closure, and spill bytes/digests. Unsupported provider
+envelopes, encrypted invocation payloads, unknown event versions, malformed projection envelopes,
+missing artifacts and undocumented reference fields in opaque JSON refuse atomically. They need
+an owner-defined transfer codec; never recursively rewrite internal JSON in the application.
+Third-party drivers must provide atomic write transactions and archive support for spills;
+`history.restore` is required for migrated baselines with inactive rows.
+
 ### Event ledger, projections and durable capabilities
 
 `AgentRuntimeStore` exposes bounded `readEvents`, declared `appendEvent`, canonical
@@ -578,6 +644,15 @@ upstream name comes from the model provider's own `resolveResponseProvider` —
 supplies it — so the runtime carries the fact without learning any gateway's metadata key. The normalized
 head/run/message tables remain the fast operational projection.
 
+For `runtime/transition` payload inspection, use `AgentStoreTransitionRecordSchema` and its
+inferred `AgentStoreTransitionRecord` type. A checkpoint record may hold either the full assistant
+message or `{ id, status: 'streaming', sha256?, sourceSha256?, parts: number, bytes: number }`;
+exactly one digest is present. Numeric `parts` counts parts; it is not an array of message parts.
+`sourceSha256` preserves a branch's historical source digest. These hash-only records are
+observations, not executable checkpoint inputs. `AgentStoreTransitionSchema` describes full
+store mutations. Shape inspection does not replace branch's complete replay/reference validation.
+Schema v4 archives written by 0.109.4 use the same journal representation.
+
 Use `defineAgentProjection` with `createSqliteAgentProjectionStore` for a
 deterministic versioned fold. Every value reports `uptoSeq`, so a caller can
 distinguish current data from a projection that still has events to consume.

package/llms-full.txt

@@ -5765,6 +5765,72 @@ failed attempt's reported usage stays in the run's spend. Transient events —
 deltas, reasoning, `attempt-reset` — are numbered from 1 per run, counting only
 what was published, so a cursor sees no gap on an ordinary stream.
 
+### Branch or restore with a new identity
+
+Use `store.branchConversation()` to create an independent conversation. `importConversation()`
+restores the original identity and is not a fork. The built-in memory and SQLite stores and
+`createAgentRuntimeStore()` expose branching; a hand-written `AgentRuntimeStore` can advertise this
+optional capability. The host authorizes the caller's source/archive access and destination
+creation before calling this trusted store boundary.
+
+```ts
+const copy = await sqlite.store.branchConversation({
+  requestKey: 'branch-request-1',
+  destinationConversationId: 'new-conversation',
+  source: { kind: 'conversation', conversationId: 'original', throughRunId: 'finished-run' },
+  // Required when selected history has spills: an explicit policy for this destination.
+  artifactAuthorization: { operation: 'read', path: 'approved-destination-workspace' },
+})
+
+const restored = await sqlite.store.branchConversation({
+  requestKey: 'restore-request-1',
+  destinationConversationId: 'restored-as-new',
+  source: { kind: 'archive', bytes: archiveBytes },
+})
+```
+
+`throughRunId` selects its exact terminal/abandon event. Omit it to include the settled tip and
+compaction recorded after the last run. The selected prefix must contain no queued or acquired
+runs. A later active source run does not prevent branching an earlier settled prefix. A migrated
+baseline has no earlier per-run event boundary; it can be copied at its settled tip.
+
+The result is `{ outcome: 'created' | 'duplicate', receipt }`. Keep the receipt: it binds source
+and destination identity, source kind, exact `sourceSeq`/`sourceVersion`, `sourceDigest`, request
+fingerprint and creation time. A retry with the same destination/key and selector returns the
+original receipt even after the source advances or the destination continues. Changing the
+request conflicts; no existing destination is overwritten. Archive fingerprints bind the supplied
+bytes. The source digest binds the selected canonical events, artifacts and reconstructed snapshot.
+Run update timestamps reconstructed from events use their recorded `occurredAt`. Abandon transitions
+retain the full failed assistant in the same event; a legacy archive must retain that exact assistant
+in its runtime snapshot, otherwise copying refuses instead of inventing historical content or time.
+
+No provider or tool runs during copying. The next ordinary runtime `submit` continues the copied
+history. All engine identities and typed references are new, including repeated references to one
+spill. Compacted content stays in the event history and SQLite inactive rows; the model reads the
+same active summaries. A hash-only checkpoint is historical digest evidence, marked
+`sourceSha256`; a later full terminal record must settle its content.
+
+A branch grants no source authority. Terminal run owners/fences and approval signatures are
+removed. State, schedules, children, retries, sandbox, approval rejection and durability facts are
+retained as inert `runtime/branch-observation` records; they cannot repopulate operational state
+or pending effects. Spills discard source authorization and require the explicit fresh
+`artifactAuthorization`; normal destination read authorization still applies. No cached projection,
+schedule row or child relation is cloned. Ordinary companion projections in the export have
+`{ name, version, uptoSeq, value, updatedAt }` envelopes. Branch validates their envelopes,
+unique names and checkpoints within the supplied journal, then discards their values. They are
+derived application caches, including ones containing source references; their values are never
+replayed as state or copied as authority. Rebuild destination projections with
+`createSqliteAgentProjectionStore().advance(...)` over the destination ledger. An exact earlier
+boundary never inherits a later cache value.
+
+The store validates the complete archive before writing: contiguous events, a matching runtime
+snapshot, known typed forms, reference closure, and spill bytes/digests. Unsupported provider
+envelopes, encrypted invocation payloads, unknown event versions, malformed projection envelopes,
+missing artifacts and undocumented reference fields in opaque JSON refuse atomically. They need
+an owner-defined transfer codec; never recursively rewrite internal JSON in the application.
+Third-party drivers must provide atomic write transactions and archive support for spills;
+`history.restore` is required for migrated baselines with inactive rows.
+
 ### Event ledger, projections and durable capabilities
 
 `AgentRuntimeStore` exposes bounded `readEvents`, declared `appendEvent`, canonical
@@ -5776,6 +5842,15 @@ upstream name comes from the model provider's own `resolveResponseProvider` —
 supplies it — so the runtime carries the fact without learning any gateway's metadata key. The normalized
 head/run/message tables remain the fast operational projection.
 
+For `runtime/transition` payload inspection, use `AgentStoreTransitionRecordSchema` and its
+inferred `AgentStoreTransitionRecord` type. A checkpoint record may hold either the full assistant
+message or `{ id, status: 'streaming', sha256?, sourceSha256?, parts: number, bytes: number }`;
+exactly one digest is present. Numeric `parts` counts parts; it is not an array of message parts.
+`sourceSha256` preserves a branch's historical source digest. These hash-only records are
+observations, not executable checkpoint inputs. `AgentStoreTransitionSchema` describes full
+store mutations. Shape inspection does not replace branch's complete replay/reference validation.
+Schema v4 archives written by 0.109.4 use the same journal representation.
+
 Use `defineAgentProjection` with `createSqliteAgentProjectionStore` for a
 deterministic versioned fold. Every value reports `uptoSeq`, so a caller can
 distinguish current data from a projection that still has events to consume.
@@ -21702,6 +21777,9 @@ Server-only optional application runtime. See the
 | `AgentMessageSchema` / `AgentRunSchema` / `AgentSnapshotSchema` | schema | versioned canonical engine records |
 | `AgentRunQueuePrioritySchema` | schema | durable opt-in priority for queued `interrupt-next` runs |
 | `AgentRuntimeStore` | _type_ | aggregate CAS transaction boundary for message, run and compaction mutations |
+| `BranchAgentConversationInputSchema` / `BranchAgentConversationInput` | schema / _type_ | strict branch request: stable request key, empty destination, settled conversation boundary or archive bytes, fresh artifact authorization |
+| `AgentConversationBranchReceiptSchema` / `AgentConversationBranchReceipt` | schema / _type_ | durable lineage: request fingerprint, source/destination identities, source sequence/version/digest and creation time |
+| `AgentConversationBranchResultSchema` / `AgentConversationBranchResult` | schema / _type_ | `created` or `duplicate` with the same durable receipt; `AgentRuntimeStore.branchConversation` is optional for hand-written stores |
 | `createAgentRuntimeStore` | function | build the aggregate store from one coherent transaction driver; framework owns every state transition |
 | `AgentRuntimeStoreDriver` | _type_ | ORM-neutral transaction over a bounded head, normalized runs/admissions, product history, a **required** `events: { append, list }` ledger table, an optional `archive: { export, import }` for driver-owned durable payloads, and indexed run recovery; optional `{ access: 'read' }` selects a coherent read transaction while absent options remain write-safe |
 | `recordAgentRetryDecision` / `AgentRetryPolicy` | function / _type_ | `loop.retry` policy and the ledger record of a retry decision: explicit retryability and backoff at a durable provider-step boundary |
@@ -21772,6 +21850,7 @@ Server-only optional application runtime. See the
 | `AgentStoreEventEnvelopeSchema` / `AgentStoreEventEnvelope` / `AgentStoreEventKindSchema` / `AgentStoreEventKind` / `AgentStoreEventPageSchema` / `AgentStoreEventPage` | schema / _type_ | append-only event envelope, closed current vocabulary (including `provider/request` and `provider/response`) and bounded page |
 | `AppendAgentStoreEventSchema` / `AppendAgentStoreEvent` / `ReadAgentStoreEventsSchema` / `ReadAgentStoreEvents` | schema / _type_ | required append and bounded-read store contracts |
 | `AgentStoreTransitionSchema` / `AgentStoreTransition` / `AgentStoreEventDraft` / `AgentStoreEventDecodeAccepted` / `AgentStoreEventDecodeIgnored` / `AgentStoreEventDecodeResult` / `decodeAgentStoreEvent` | schema / _types_ / function | normalized runtime mutations, append drafts and strict current/ignorable future-event decoding outcomes |
+| `AgentStoreTransitionRecordSchema` / `AgentStoreTransitionRecord` | schema / _type_ | persisted journal payloads: full runtime mutations or hash-only streaming checkpoint observations with numeric part/byte counts; inspection does not authorize replay |
 | `defineAgentProjection` / `AgentProjectionDefinition` / `AgentProjectionValue` / `createAgentProjectionRegistry` / `createSqliteAgentProjectionStore` | functions / _type_ | deterministic folds with persisted version and honest `uptoSeq` checkpoints |
 | `agentSummaryProjection` / `agentUsageProjection` / `agentOutlineProjection` | constants | built-in list summary, provenance-carrying usage and request outline projections |
 | `agentConversationCardProjection` / `agentStateSlotsProjection` / `agentScheduleSummaryProjection` | constants | focused card, durable-state and schedule lifecycle projections |

package/llms.txt

@@ -25,7 +25,7 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/primitives**: [llms/primitives.txt](llms/primitives.txt) 11.7 KB
 - **stitchkit/server**: [llms/server.txt](llms/server.txt) 45.3 KB → [llms/server.2.txt](llms/server.2.txt) 14.6 KB → [llms/server.3.txt](llms/server.3.txt) 45.6 KB → [llms/server.4.txt](llms/server.4.txt) 38.3 KB → [llms/server.5.txt](llms/server.5.txt) 22.1 KB
 - **stitchkit/observability**: [llms/observability.txt](llms/observability.txt) 45.9 KB
-- **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 37.1 KB → [llms/agent-runtime.2.txt](llms/agent-runtime.2.txt) 46.7 KB → [llms/agent-runtime.3.txt](llms/agent-runtime.3.txt) 34.7 KB
+- **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 42.2 KB → [llms/agent-runtime.2.txt](llms/agent-runtime.2.txt) 46.7 KB → [llms/agent-runtime.3.txt](llms/agent-runtime.3.txt) 35.6 KB
 - **stitchkit/agent-runtime/testing**: [llms/agent-runtime-testing.txt](llms/agent-runtime-testing.txt) 2.6 KB
 - **stitchkit/agent-runtime/harness**: [llms/agent-runtime-harness.txt](llms/agent-runtime-harness.txt) 11.0 KB
 - **stitchkit/agent-runtime/coding-tools**: [llms/agent-runtime-coding-tools.txt](llms/agent-runtime-coding-tools.txt) 5.0 KB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.110.1",
+  "version": "0.110.3",
   "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",

package/dist/index-8ks9b85e.js

@@ -1,129 +0,0 @@
-import {
-  AppError2,
-  STITCH_ERROR_STATUS2
-} from "./index-j9gxbztg.js";
-
-// src/agent-runtime/sandbox.ts
-import { z } from "zod";
-var AgentSandboxRestrictionSchema2 = z.enum([
-  "network-denied",
-  "write-contained",
-  "secrets-hidden",
-  "process-contained"
-]);
-var AgentSandboxGradeSchema2 = z.discriminatedUnion("grade", [
-  z.object({ grade: z.literal("full"), restrictions: z.array(AgentSandboxRestrictionSchema2) }).strict(),
-  z.object({
-    grade: z.literal("partial"),
-    restrictions: z.array(AgentSandboxRestrictionSchema2),
-    gaps: z.array(AgentSandboxRestrictionSchema2)
-  }).strict(),
-  z.object({ grade: z.literal("unavailable"), reason: z.string().min(1) }).strict()
-]);
-var probes = new WeakMap;
-var PROBE_FAILED = "sandbox probe failed";
-var PROBE_INVALID = "sandbox probe returned no valid grade";
-async function runProbe(sandbox) {
-  let value;
-  try {
-    value = await sandbox.probe();
-  } catch (cause) {
-    return { grade: { grade: "unavailable", reason: PROBE_FAILED }, cause };
-  }
-  const parsed = AgentSandboxGradeSchema2.safeParse(value);
-  if (parsed.success)
-    return { grade: parsed.data };
-  return { grade: { grade: "unavailable", reason: PROBE_INVALID }, cause: parsed.error };
-}
-function probeAgentProcessSandboxOutcome(sandbox, options = {}) {
-  if (options.refresh)
-    probes.delete(sandbox);
-  const present = probes.get(sandbox);
-  if (present)
-    return present;
-  const pending = runProbe(sandbox);
-  probes.set(sandbox, pending);
-  return pending;
-}
-async function probeAgentProcessSandbox2(sandbox, options = {}) {
-  const fresh = options.refresh === true || !probes.has(sandbox);
-  const outcome = await probeAgentProcessSandboxOutcome(sandbox, options);
-  if (fresh && outcome.cause !== undefined) {
-    process.emitWarning(new Error("Sandbox probe failed", { cause: outcome.cause }));
-  }
-  return outcome.grade;
-}
-function missingSandboxRestrictions2(grade, required) {
-  if (grade.grade === "unavailable")
-    return required;
-  const present = new Set(grade.restrictions);
-  return required.filter((restriction) => !present.has(restriction));
-}
-async function recordAgentSandboxProbe2(input) {
-  const grade = await probeAgentProcessSandbox2(input.sandbox);
-  const missing = missingSandboxRestrictions2(grade, input.required);
-  await input.store.appendEvent({
-    conversationId: input.conversationId,
-    kind: "sandbox/probed",
-    payload: {
-      result: grade,
-      required: [...input.required],
-      missing: [...missing]
-    }
-  });
-  return grade;
-}
-
-// src/agent-runtime/coding-tool-refusals.ts
-function codingRefusal(code, message, options = {}) {
-  throw new AppError2(code, {
-    message,
-    status: STITCH_ERROR_STATUS2[code],
-    details: { message, ...options.details },
-    hint: options.hint,
-    ..."cause" in options && { cause: options.cause }
-  });
-}
-function codingPathRefusal(code, message, path, options = {}) {
-  codingRefusal(code, message, {
-    details: { path, ...options.details },
-    ...options.hint && { hint: options.hint }
-  });
-}
-function refuseMissingCodingPath(error, relative) {
-  const code = error?.code;
-  if (error instanceof Error && error.message.includes("is not a regular file")) {
-    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
-      hint: "Use list_directory to see what is here."
-    });
-  }
-  if (code === "ENOENT") {
-    codingPathRefusal("NOT_FOUND", "This path does not exist", relative, {
-      hint: "Use list_directory or glob to find the right path."
-    });
-  }
-  if (code === "ENOTDIR") {
-    codingPathRefusal("BAD_REQUEST", "A segment of this path is not a directory", relative, {
-      hint: "Check the path with list_directory."
-    });
-  }
-  if (code === "ELOOP") {
-    codingPathRefusal("FORBIDDEN", "This path is a symlink, which is not followed", relative, {
-      hint: "Read or write the target directly, by its own workspace-relative path."
-    });
-  }
-  if (code === "EISDIR") {
-    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
-      hint: "Use list_directory to see what is here."
-    });
-  }
-  throw error;
-}
-function refuseUnknownSpillReference(reference) {
-  codingRefusal("SPILL_REFERENCE_UNKNOWN", `No spilled output is held under \`${reference}\``, {
-    details: { reference },
-    hint: "Use the reference returned by the command that spilled its output, not a session or call id."
-  });
-}
-
-export { AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandboxOutcome, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };