stitchkit 0.100.0 → 0.100.2

package/llms-full.txt

@@ -4888,7 +4888,7 @@ description: Configure Stitchkit's optional durable history, stream loop, run co
 type: architecture
 status: active
 created: 2026-08-22
-updated: 2026-09-26 16:00 +07:00
+updated: 2026-09-28 18:39 +07:00
 ---
 
 # Agent application runtime
@@ -5505,9 +5505,14 @@ has invoked a tool is never automatically replayed.
 `createAgentScheduleService` persists `at`, `after` and `every` input. Repeating
 schedules require an explicit IANA time zone. Dispatch uses a stable
 `schedule:<id>:<occurrence>` idempotency key, and restart lateness is recorded.
-Resolve `void` after durable admission; return `{ status: 'retry', reason }` for a
+Resolve after durable admission; return `{ status: 'retry', reason }` for a
 transient refusal or `{ status: 'terminal', reason }` to stop the entire schedule in
-`failed` state. Throws retry too. Backoff is 1, 2, 4, 8, 16, 32, then 60 seconds,
+`failed` state. Only those two shapes are failures: any other returned value — a
+queue length, a receipt — means the callback returned, so it delivered. Throws retry
+too. `maxAttempts` (default 1000, about sixteen hours at the retry ceiling) bounds
+one occurrence: a one-off schedule then becomes `failed`, a recurring one gives up
+that occurrence (`schedule/failed` with `skipped: true` and the `nextAt` it moves
+to) and keeps its cadence. A failure reason is kept to 1000 characters. Backoff is 1, 2, 4, 8, 16, 32, then 60 seconds,
 capped at 60 seconds and persisted across restart. `retryAt`, `attempts` and `lastError`
 show retry diagnostics; success resets them. `nextAt` and `lateByMs` retain the original
 occurrence time. Recurring schedules fire once after an idle stretch and advance to the
@@ -6389,15 +6394,23 @@ hashes; `readPayload({ conversationId, artifactId }, context)` separately author
 `read-payload` and checks authentication tags and hashes. `payloadKey` must be 32
 bytes and is copied at construction. Keep it outside the event store/backups; retain
 the appropriate key when restoring an archive. `maxPayloadBytes` defaults to 4 MiB
-(range 1 KiB–64 MiB); streaming output evidence is capped at 1 MiB. Request headers
+(range 1 KiB–64 MiB). Streaming output evidence keeps parts up to half of it; past
+that the evidence carries `truncated: { parts, sha256 }` over the whole stream, and
+the answer itself is never cut. A receipt that cannot be written never changes an
+outcome: `complete()` returns it with `receiptError` beside it, and a succeeded
+answer keeps its `text`. Request headers
 are excluded. Protect existing agent history independently: enabling receipts does
 not encrypt its ordinary conversation records.
 
 The built-in memory and SQLite stores implement `appendEventOnce`. Custom stores
 must implement its once-only check and append atomically, returning the original
 event on a duplicate key scoped by conversation and kind. A factory without this
-capability refuses receipt setup. The driver-backed implementation reads bounded
-pages under one transaction, without another table or database.
+capability refuses receipt setup. The driver-backed implementation finds the keyed
+event by its identity through the driver's optional `events.find` — one index probe
+in SQLite — so admission costs the same on a long conversation as on a new one; a
+custom driver without `find` falls back to paging the log in one transaction.
+`store.findEventOnce({ conversationId, kind, key })` reads the same event back.
+Invocation payload artifacts are keyed by their artifact id the same way.
 
 ### Migration from direct SDK completions
 
@@ -6405,8 +6418,8 @@ pages under one transaction, without another table or database.
 Replace the direct `generateText` call with `invocations.complete`, configure host
 authorization and a retained payload key, and pass the same ledger in the agent's
 `invocations` option. Use the returned invocation ID and the paginated `read` method
-for receipt queries; do not import runtime internals. This API is unreleased; it is
-not present in 0.99.0. Existing runtime configurations need no migration.
+for receipt queries; do not import runtime internals. Available since 0.100.0;
+existing runtime configurations need no migration.
 
 
 ==============================================================================
@@ -7277,7 +7290,8 @@ ever became ready:
 | none | — | — | `first-boot` | — |
 | recorded `stoppedAt` | — | — | `clean` / `forced` / `startup-failed` / `abnormal` as recorded | unchanged |
 | still open | yes | — | `hot-reload` | `hot-reload`, closed at the new start |
-| still open | no | changed | `handoff` | stays open; it records its own stop later |
+| still open | no | changed | `handoff` (default) | stays open; it records its own stop later |
+| still open | no | changed, `versionChangeOverlap: 'abnormal'` | `abnormal` / `startup-failed` | closed at the new start, as for the same version |
 | still open, was ready | no | same | `abnormal` (default) | `abnormal`, closed at the new start — an upper bound, the crash time is unknown |
 | still open, never ready | no | same | `startup-failed` (default) | `startup-failed`, closed at the new start |
 
@@ -7319,7 +7333,22 @@ zero-downtime reload of the same build — pass `sameVersionOverlap: 'handoff'`
 to the ledger, and every open run stays open until it records its own
 shutdown. The cost of that setting is symmetric: a real crash under it is
 reported as a handoff and the dead run stays open in the ledger until
-retention drops it. The list is kept in the order the transitions wrote it —
+retention drops it.
+
+A version change is the other axis, and its default is the opposite:
+`handoff`, because a release that starts the new build before stopping the
+old one is the common zero-downtime shape. Where builds never overlap — one
+process per deployment (a pm2 fork, a systemd unit, one container), the old
+one stopped before the new one starts — pass `versionChangeOverlap:
+'abnormal'`. An open predecessor of another build then died without
+recording its exit, most often killed during the release itself: it is closed
+as `abnormal` (or `startup-failed`) at the new start, `downtimeMs` is `null`
+instead of `0`, and `previousVersion` / `versionChanged` still describe the
+release. A predecessor that did record its stop is read as before, and its
+downtime is measured. The two settings compose: `sameVersionOverlap:
+'handoff'` keeps open only the runs of a build allowed to overlap the new one.
+
+The list is kept in the order the transitions wrote it —
 every write goes through one atomic update, so that order is the causal one,
 and a successor whose clock lags its predecessor still finds it at the head;
 `startedAt` is data, not the sort key. Retention (`retain`, default 20) drops
@@ -7424,6 +7453,9 @@ Opt into `delivery: { version, actions, project }` on `createNotificationOutbox`
 The pure `actions(payload)` selector runs at enqueue; the versioned plan remains
 fixed throughout retry. Each `send` receives its action and a stable idempotency
 key; return a small JSON receipt such as a remote message or uploaded object ID.
+An action that returned is confirmed and is never sent again: a result that is not
+JSON, or does not fit the state's byte budget, is kept as `receipt: null` with
+`unrecorded: 'not-json' | 'too-large'` and reported to `onError`.
 `project(notification, receipts)` applies all confirmed results locally and must
 be idempotent. Checkpoints and the final projection timestamp live in the existing
 atomic StateStore; completed receipts retain them within retention/byte limits.
@@ -7435,9 +7467,13 @@ not repeat confirmed sends. A crash after remote success but before receipt comm
 is ambiguous: the provider must deduplicate the action key or reconcile its result.
 A projection can also repeat if its completion checkpoint is lost.
 
-A new executor version must explicitly migrate or terminally classify incompatible
-queued plans. Existing `classify`/`onDropped` handles terminal items; a durable
-quarantine is the application's responsibility. Whole-state file and memory stores
+A plan keeps its actions from enqueue, so an older version needs only its
+projection to finish: a new executor lists it in `retiredVersions: { v1: project }`
+until the queue has drained. A plan version the executor does not know is reported
+to `onError` as `NotificationPlanVersionError` and waits — at least a poll interval,
+spending no attempt, without `classify` — for a process that knows it: the other
+side of a rolling deploy, the version a rollback returns to, or this one once it
+lists the version. Whole-state file and memory stores
 remain supported. Atomic enqueue with an unrelated business transaction is not
 provided by this contract; retain the application's transactional adapter when that
 boundary is required. Send and projection callbacks own their external deadlines.
@@ -9927,6 +9963,28 @@ The nonce is not authorization: the server still admits a verified identity and
 uses `hub.attach(subscriber, { key: verifiedScope, signal: revocationSignal })`.
 The scope key must change with session and permission boundaries.
 
+One scope and one question share one source and one read, however many client
+instances watch it: the hub routes each frame to every instance under its own
+key. A new tab of the same session costs a route, not a read.
+
+### Capacity
+
+A hub admits at most `maxSources` sources (1024) and `maxSubscribers` attached
+subscribers (1024); a client holds at most `maxKeys` keys (1024) and
+`maxListenersPerKey` listeners per key (128). Every excess is a refusal, never
+unbounded state: `open` answers `{ accepted: false, reason }` — including for a
+subscriber attached over capacity, whose `attach` returns a watcher that refuses
+every `open` — and a client's `subscribe` throws. A client handle takes its key
+when it subscribes, so handles a render creates and never subscribes cost
+nothing. A connection handler that throws closes that connection and is logged;
+the server goes on. A subscriber attached over capacity is not tracked: its
+refusals stand until it reconnects.
+
+A read that fails sends its subscribers `unavailable` / `source-error` with the
+`code` and `message` of an `AppError`, which is written for its caller. Any other
+error reaches only the hub's `logger`; the browser reads `The watched read failed`. Set larger finite limits for larger workloads, and
+`reconcileIntervalMs` when a lost invalidation must recover without a reconnect.
+
 `createCacheBridge` can bind watched handles directly:
 
 ```ts
@@ -13297,7 +13355,10 @@ must recover without a reconnect.
 For multi-action outboxes, enqueue new items with a versioned delivery plan and
 return small JSON receipts from `send`. Existing queued single-send items should
 be drained before enabling a delivery executor on that queue, or migrated under
-the store's atomic transition. Preserve executor versions until their queues drain.
+the store's atomic transition. When a new executor version ships, list the old
+version's projection in `delivery.retiredVersions` until its queued items drain;
+a plan version with no executor waits, reported to `onError` as
+`NotificationPlanVersionError` (from 0.100.1).
 Make projection idempotent. Provider idempotency/reconciliation remains necessary
 for a crash between remote success and checkpoint. These APIs are available starting with 0.100.0.
 
@@ -13320,7 +13381,9 @@ write the modern record; no journal data migration is needed.
 Darwin distributions must retain the package's architecture-matched native
 `.node` asset for process birth measurement, as for contained filesystem access.
 If native/proc identity cannot be read, new locks explicitly record null and
-recovery refuses rather than treating unknown ownership as death. Existing
+recovery refuses rather than treating unknown ownership as death. From 0.100.1 a
+Linux kernel without time namespaces (before 5.6) records the PID namespace alone
+instead of null, so its locks recover like any other. Existing
 `refuse` policy and the separately configured ownerless-file grace are unchanged.
 
 ## Released migration: 0.99.0
@@ -13338,13 +13401,20 @@ Colliding object/array fields retain their complete structural alternatives:
 { type: ['object', 'array'] }
 // After: structural alternatives live inside the property schema.
 { anyOf: [
-  { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
   { type: 'array', items: {
     type: 'object', properties: { id: { type: 'string' } }, required: ['id'],
   } },
+  { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
 ] }
 ```
 
+Alternatives come in kind order, independent of variant order. The same shape
+covers every collision of different kinds, scalars included: `string` against
+`string[]` becomes `{ anyOf: [{ type: 'array', items: { type: 'string' } }, { type:
+'string' }] }`. A nullable field keeps `null` in each alternative's `type`, and
+differing nested object unions remain nested `anyOf` inside the alternatives. Update
+snapshots to this order.
+
 Traverse each nested alternative when inspecting schemas and regenerate schema
 snapshots. Verify the actual manifest with the chosen provider. Keep flatten
 enabled when a top-level discriminated union needs to be advertised as an
@@ -17292,18 +17362,22 @@ can emit / propagate a `traceparent` (see `HttpClientConfig.trace`).
 
 `createSessionScope` (`stitchkit`) returns the generic `SessionScope`: `replace(context)`
 creates a new login lifetime (including same-account relogin), `capture()` returns
-its `SessionOperation<T>`, `clear()` invalidates it, and `stop()` permanently closes
-the host. Operations expose `id`, `generation`, `context`, `signal`, `current()` and
+its `SessionOperation<T>`, `clear()` invalidates it, `stop()` permanently closes
+the host, and `owns(operation)` answers whether an operation is this scope's current
+one — `current()` alone cannot tell an operation of another scope. Operations expose `id`, `generation`, `context`, `signal`, `current()` and
 `assertCurrent()`. `run(callback)` checks both success and failure across an await;
 `deliver(callback)` admits a synchronous final send/state change or returns false.
 `bindFetch(fetch, headers?)` guards every attempt and scopes its abort signal. Wrap
 the complete client call in `run` too: headers are not the response body boundary.
-Expired work throws `SessionExpiredError`, not a refresh instruction.
+Expired work throws `SessionExpiredError`, not a refresh instruction; when the work
+itself failed, that failure is its `cause`.
 
 `createSessionCredentials` accepts `SessionCredentialsConfig`:
 `scope`, `refresh(credentials, signal)`, `storage.write(session, credentials)`,
-`storage.clear()`, `maxPendingWrites` (128), and `refreshTimeoutMs` (30000, at most one
-hour). `SessionCredentials` provides `login`, `logout`, `read(operation)` and
+`storage.clear()`, `maxPendingWrites` (128), `refreshTimeoutMs` (30000, at most one
+hour) and `storageTimeoutMs` (30000, at most one hour): a storage call past it
+rejects and frees the queue, so `logout()` still clears; when the late call settles,
+storage is written again from memory, or cleared when nobody is logged in. `SessionCredentials` provides `login`, `logout`, `read(operation)` and
 `refresh(operation)`. Concurrent refresh calls in one generation share the same
 promise. Logout invalidates memory before its returned persistence promise settles.
 Storage errors and queue-capacity refusals reject; callers must handle them. All
@@ -17453,7 +17527,8 @@ realtime contract from `stitchkit`, and the server halves live in `stitchkit/app
 ### Session-scoped watch lifetime
 
 `WatchClientConfig.session` captures a `SessionOperation`; `maxKeys` (1024) and
-`maxListenersPerKey` (128) bound retained subscriptions. Its lifetime nonce travels
+`maxListenersPerKey` (128) bound retained subscriptions; a handle takes its key on
+`subscribe`, which is where capacity refuses. Its lifetime nonce travels
 in optional `WatchKey.instance`, preventing old-session frames from matching a new
 client on the same socket. This is routing identity, never authorization.
 
@@ -17752,7 +17827,7 @@ cutovers are covered by the executable
 | `LifecycleRunSchema` / `LifecycleRun` / `LifecycleStateSchema` / `LifecycleState` / `LifecycleTerminationSchema` / `LifecycleTermination` | schema / _type_ | versioned process-run state — open (`active`, `draining` with `unavailableAt`) and ended (`clean`, `forced`, `startup-failed`, `hot-reload`, `abnormal`) |
 | `PreviousExitSchema` / `PreviousExit` / `StartFact` / `ReadyFact` / `DrainingFact` / `ShutdownFact` / `ProcessLifecycleFact` | schema / _type_ | first-boot, hot-reload, clean, forced, startup-failed, handoff and abnormal lifecycle facts; `processGapMs` on start, `downtimeMs` (unavailable → ready) on ready |
 | `transitionProcessStart` / `transitionProcessReady` / `transitionProcessDraining` / `transitionProcessShutdown` | function | pure idempotent runId+pid-owned transitions |
-| `LifecycleTransition` / `TransitionStartInput` / `TransitionRunInput` / `TransitionShutdownInput` / `SameVersionOverlap` | _type_ | pure transition inputs (`TransitionRunInput` for ready and draining, extended with `forced` for shutdown), the same-build overlap policy (`abnormal` default / `handoff`) and state+fact result |
+| `LifecycleTransition` / `TransitionStartInput` / `TransitionRunInput` / `TransitionShutdownInput` / `SameVersionOverlap` / `VersionChangeOverlap` | _type_ | pure transition inputs (`TransitionRunInput` for ready and draining, extended with `forced` for shutdown), the same-build overlap policy (`abnormal` default / `handoff`), the version-change overlap policy (`handoff` default / `abnormal`) and state+fact result |
 | `lifecycleLedgerResource` / `LifecycleLedgerResource` / `LifecycleLedgerResourceConfig` | function / _type_ | managed-resource adapter that records start, readiness, admission stop (draining) and shutdown |
 | `createNotificationOutbox` / `NotificationOutbox` / `NotificationOutboxConfig` | function / _type_ | bounded at-least-once queue with durable claims, leases, retries and supersede |
 | `NotificationOutboxItem` / `NotificationOutboxReceipt` / `NotificationOutboxState` / `NotificationSend` / `NotificationFailureClassification` / `DroppedNotification` / `EnqueueNotification` | _type_ | versioned queue records, stable send identity and delivery decisions |
@@ -17966,7 +18041,10 @@ periodically even when no notification arrives.
 `reconcileIntervalMs` (10 ms–1 h). `hub.attach(subscriber, scope?)` accepts a
 `WatchAdmissionScope` containing a **server-verified** `key` (1–512 characters) and
 revocation `signal`. The key separates sharing and is the optional third argument
-of `read(operation, args, scope)`. It must represent account, session and permissions;
+of `read(operation, args, scope)`; a key's `instance` routes frames and never
+separates sources. Attached over `maxSubscribers`, a subscriber gets a watcher whose
+`open` refuses with `Watch subscriber capacity exceeded`; `attach` does not throw
+for capacity. It must represent account, session and permissions;
 never trust a client-supplied owner ID as that scope.
 
 
@@ -17977,7 +18055,13 @@ never trust a client-supplied owner ID as that scope.
 immutable executor `version`, pure `actions(payload)` plan selector (1–128 unique
 names, each at most 128 characters), and idempotent `project(notification, receipts)`.
 `send` receives optional `action` and stable `idempotencyKey`, and returns a JSON
-remote receipt (void becomes null). `NotificationDeliveryStateSchema` validates the
+remote receipt (void becomes null). A result that is not JSON or does not fit the
+byte budget is kept as `receipt: null` with `unrecorded: 'not-json' | 'too-large'`;
+the action stays confirmed and is not sent again. `retiredVersions` maps earlier
+plan versions to their `NotificationProjection` so queued items drain after an
+executor upgrade; an unknown version is reported to `onError` as
+`NotificationPlanVersionError` and waits, spending no attempt and not consulting
+`classify`, for an executor that knows it. `NotificationDeliveryStateSchema` validates the
 optional `NotificationDeliveryState` on queued items and completed receipts:
 `version`, `actions`, `receipts` and optional `projectedAt`. Checkpoints share the
 existing atomic StateStore and lease fence. Receipt retention and serialized byte
@@ -18163,7 +18247,7 @@ Server-only optional application runtime. See the
 | `AgentSandboxProcess` / `AgentSandboxOutputStream` | _types_ | structural child/output interface for optional lifecycle-owned `AgentProcessSandbox.spawn`, without Node ambient type dependencies |
 | `AgentEventSearchResultSchema` / `AgentEventSearchResult` / `createSqliteAgentEventSearch` / `createAgentEventSearchTools` | schema / _type_ / functions | authorized FTS5 search with exact event addresses and `session_*` tools |
 | `createSqliteAgentSpillStore` | function | durable content-address-checked artifact storage, bounded read/search, retention facts and archive participation |
-| `AgentScheduleSchema` / `AgentSchedule` / `AgentScheduleService` / `AgentScheduleDeliveryOutcomeSchema` / `AgentScheduleDeliveryOutcome` / `createAgentScheduleService` / `createAgentScheduleTools` | schemas / _types_ / functions | durable `at`/`after`/timezone-explicit `every`, indexed retry eligibility, typed retry/terminal failure, bounded dispatch and fenced stable occurrence identity (ADR 0202) |
+| `AgentScheduleSchema` / `AgentSchedule` / `AgentScheduleService` / `AgentScheduleDeliveryOutcomeSchema` / `AgentScheduleDeliveryOutcome` / `createAgentScheduleService` / `createAgentScheduleTools` | schemas / _types_ / functions | durable `at`/`after`/timezone-explicit `every`, indexed retry eligibility, typed retry/terminal failure (any other returned value delivers), `maxAttempts` (default 1000) per occurrence — a one-off ends `failed`, a recurring schedule skips to its next slot — bounded dispatch and fenced stable occurrence identity (ADR 0202) |
 | `AgentChildBudgetSchema` / `AgentChildBudget` / `AgentChildStateSchema` / `AgentChildState` / `AgentChildRecordSchema` / `AgentChildRecord` | schema / _type_ | durable child graph, bounded seed and measured budget state |
 | `AgentChildBlockingKindSchema` / `AgentChildBlockingKind` / `AgentChildBlockingSourceSchema` / `AgentChildBlockingSource` / `AgentChildBlockingEventSchema` / `AgentChildBlockingEvent` / `AgentChildBlockingDecision` | schemas / _types_ | parent-owned request identities; responses discriminate approval decisions from JSON input values |
 | `AgentChildHandle` / `AgentChildManager` / `SqliteAgentChildManagerConfig` / `createSqliteAgentChildManager` / `createAgentChildTools` / `agentChildBudgetStopPolicy` | _type_ / functions | host execution port, child lifecycle, cascade (given to `createAgentRuntime` as `children`), messaging, Agent tools, and the child runtime's own budget stop policy — `recordStepUsage` at every step boundary, `policy_stop` as `child-budget` when spent |
@@ -18324,7 +18408,9 @@ operator-only observability sink explicitly opts in.
 `ModelInvocationConfig`: the existing store and model registry, a 32-byte payload
 key, required host authorization, optional bounded payload size and `onAttempt`.
 `complete(input, context, signal?)` executes only the supplied prompt, with no tools
-or framework instructions; repeated keys return the existing invocation ID.
+or framework instructions; repeated keys return the existing invocation ID. It
+resolves `{ invocationId, outcome, text?, receiptError? }`: `receiptError` says a
+receipt could not be written and never changes `outcome` or drops `text`.
 `read(input, context)` returns a bounded event page shared by agent and completion;
 `readPayload(input, context)` requires a separate authorization action to decrypt
 one protected artifact. See the [guide and migration example](../guide/agent-runtime.md#plain-completions-and-shared-invocation-receipts).
@@ -18339,8 +18425,11 @@ one protected artifact. See the [guide and migration example](../guide/agent-run
 
 The runtime `invocations` option takes this ledger and a trace callback; it requires
 the same store and preserves the existing tool loop. `AgentRuntimeStore.appendEventOnce`
-is an optional atomic capability required by receipt admission. Built-in stores
-supply it; custom adapters must honor its once-only transaction contract.
+is an optional atomic capability required by receipt admission, and
+`AgentRuntimeStore.findEventOnce` reads the event it wrote by kind and key. Built-in
+stores supply both; custom adapters must honor the once-only transaction contract.
+A driver's optional `events.find(transaction, { conversationId, eventId })` makes
+both one lookup instead of a scan of the conversation log.
 
 ## `stitchkit/agent-runtime/testing`
 

package/llms.txt

@@ -9,7 +9,7 @@ Build with stitchkit: define a contract once, then `implement` it and serve it (
 Load the slice for each entrypoint your code imports — `import … from 'stitchkit/server'` → `llms/server.txt`; the root `stitchkit` import → `llms/stitchkit.txt`. A slice holds that entrypoint's API reference section and the guide pages whose home it is; every guide lives in exactly one slice, and a slice that needs another's guide names it under "Also read". Each file is at most 50.0 KB; a longer one continues in numbered parts, each naming the next at its top. Moving across versions: load `llms/upgrading.txt` and the range slices it lists between your version and the target. `llms-full.txt` inlines everything; it is far larger than a context window, so do not read it whole.
 
 ## Entrypoint slices
-- **stitchkit**: [llms/stitchkit.txt](llms/stitchkit.txt) 15.6 KB → [llms/stitchkit.2.txt](llms/stitchkit.2.txt) 37.2 KB → [llms/stitchkit.3.txt](llms/stitchkit.3.txt) 15.7 KB
+- **stitchkit**: [llms/stitchkit.txt](llms/stitchkit.txt) 15.6 KB → [llms/stitchkit.2.txt](llms/stitchkit.2.txt) 37.2 KB → [llms/stitchkit.3.txt](llms/stitchkit.3.txt) 16.1 KB
 - **stitchkit/live**: [llms/live.txt](llms/live.txt) 21.6 KB
 - **stitchkit/react**: [llms/react.txt](llms/react.txt) 9.0 KB
 - **stitchkit/tools**: [llms/tools.txt](llms/tools.txt) 45.0 KB → [llms/tools.2.txt](llms/tools.2.txt) 26.3 KB → [llms/tools.3.txt](llms/tools.3.txt) 25.4 KB
@@ -20,9 +20,9 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/remote**: [llms/remote.txt](llms/remote.txt) 1.0 KB
 - **stitchkit/contract**: [llms/contract.txt](llms/contract.txt) 31.9 KB
 - **stitchkit/primitives**: [llms/primitives.txt](llms/primitives.txt) 9.3 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) 44.3 KB → [llms/server.4.txt](llms/server.4.txt) 37.5 KB → [llms/server.5.txt](llms/server.5.txt) 21.8 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) 37.5 KB → [llms/server.5.txt](llms/server.5.txt) 21.8 KB
 - **stitchkit/observability**: [llms/observability.txt](llms/observability.txt) 43.4 KB
-- **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 36.4 KB → [llms/agent-runtime.2.txt](llms/agent-runtime.2.txt) 46.1 KB → [llms/agent-runtime.3.txt](llms/agent-runtime.3.txt) 33.8 KB
+- **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 36.8 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.3 KB
 - **stitchkit/agent-runtime/testing**: [llms/agent-runtime-testing.txt](llms/agent-runtime-testing.txt) 2.2 KB
 - **stitchkit/agent-runtime/harness**: [llms/agent-runtime-harness.txt](llms/agent-runtime-harness.txt) 4.1 KB
 - **stitchkit/agent-runtime/coding-tools**: [llms/agent-runtime-coding-tools.txt](llms/agent-runtime-coding-tools.txt) 4.9 KB
@@ -30,7 +30,7 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/agent-runtime/openrouter**: [llms/agent-runtime-openrouter.txt](llms/agent-runtime-openrouter.txt) 1.1 KB
 - **stitchkit/agent-runtime/sqlite/bun**: [llms/agent-runtime-sqlite-bun.txt](llms/agent-runtime-sqlite-bun.txt) 1.8 KB
 - **stitchkit/agent-runtime/sqlite/node**: [llms/agent-runtime-sqlite-node.txt](llms/agent-runtime-sqlite-node.txt) 1.7 KB
-- **stitchkit/application**: [llms/application.txt](llms/application.txt) 46.6 KB → [llms/application.2.txt](llms/application.2.txt) 37.2 KB
+- **stitchkit/application**: [llms/application.txt](llms/application.txt) 46.0 KB → [llms/application.2.txt](llms/application.2.txt) 40.0 KB
 - **stitchkit/application/grammy**: [llms/application-grammy.txt](llms/application-grammy.txt) 2.3 KB
 - **stitchkit/application/opentelemetry**: [llms/application-opentelemetry.txt](llms/application-opentelemetry.txt) 1.6 KB
 - **stitchkit/application/directory-inbox**: [llms/application-directory-inbox.txt](llms/application-directory-inbox.txt) 0.3 KB
@@ -52,7 +52,7 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 
 ## Upgrading slices
 - **Upgrading — how to move across versions**: [llms/upgrading.txt](llms/upgrading.txt) 10.3 KB
-- **Upgrading 0.74.0 → 0.100.0**: [llms/upgrading-0.74.0-0.100.0.txt](llms/upgrading-0.74.0-0.100.0.txt) 44.3 KB
+- **Upgrading 0.74.0 → 0.100.0**: [llms/upgrading-0.74.0-0.100.0.txt](llms/upgrading-0.74.0-0.100.0.txt) 45.1 KB
 - **Upgrading 0.61.0 → 0.73.0**: [llms/upgrading-0.61.0-0.73.0.txt](llms/upgrading-0.61.0-0.73.0.txt) 41.2 KB
 - **Upgrading 0.44.0 → 0.60.0**: [llms/upgrading-0.44.0-0.60.0.txt](llms/upgrading-0.44.0-0.60.0.txt) 43.9 KB
 - **Upgrading 0.37.0 → 0.37.0**: [llms/upgrading-0.37.0.txt](llms/upgrading-0.37.0.txt) 6.2 KB

package/package.json

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