stitchkit 0.100.0 → 0.100.2

package/dist/internal/coalesced-task.d.ts

@@ -1,6 +1,8 @@
 import { type BackoffPolicy } from './backoff.js';
 export interface CoalescedTask {
     readonly running: boolean;
+    /** A trigger arrived that no pass has served yet. */
+    readonly pending: boolean;
     trigger(): void;
     pauseRetry(): void;
     close(): void;

package/dist/internal/coalesced-task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coalesced-task.d.ts","sourceRoot":"","sources":["../../src/internal/coalesced-task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,WAAW,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,OAAO,IAAI,IAAI,CAAC;IAChB,UAAU,IAAI,IAAI,CAAC;IACnB,KAAK,IAAI,IAAI,CAAC;CACf;AAED,0FAA0F;AAC1F,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,MAAM,IAAI,OAAO,CAAC;IAClB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,aAAa,CAAC;CACxB,GAAG,aAAa,CAoDhB"}
+{"version":3,"file":"coalesced-task.d.ts","sourceRoot":"","sources":["../../src/internal/coalesced-task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,WAAW,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,OAAO,IAAI,IAAI,CAAC;IAChB,UAAU,IAAI,IAAI,CAAC;IACnB,KAAK,IAAI,IAAI,CAAC;CACf;AAED,0FAA0F;AAC1F,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,MAAM,IAAI,OAAO,CAAC;IAClB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,aAAa,CAAC;CACxB,GAAG,aAAa,CAuDhB"}

package/dist/internal/process-instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"process-instance.d.ts","sourceRoot":"","sources":["../../src/internal/process-instance.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,eAAO,MAAM,qBAAqB;;;;;;;;kBAOvB,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS1E;AAED,iGAAiG;AACjG,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,QAAQ,SAAU,GACjB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwCjC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,YAAY,CAAC;IACnD,QAAQ,CAAC,QAAQ,EACb,SAAS,GACT,gBAAgB,GAChB,YAAY,GACZ,UAAU,GACV,QAAQ,GACR,aAAa,CAAC;CACnB;AAED,yFAAyF;AACzF,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,EAC5C,MAAM;IAAK,IAAI;IAAuB,QAAQ;CAAiB,GAC9D,OAAO,CAAC,oBAAoB,CAAC,CAyB/B"}
+{"version":3,"file":"process-instance.d.ts","sourceRoot":"","sources":["../../src/internal/process-instance.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,eAAO,MAAM,qBAAqB;;;;;;;;kBAOvB,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS1E;AAED,iGAAiG;AACjG,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,QAAQ,SAAU,GACjB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CA6CjC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,YAAY,CAAC;IACnD,QAAQ,CAAC,QAAQ,EACb,SAAS,GACT,gBAAgB,GAChB,YAAY,GACZ,UAAU,GACV,QAAQ,GACR,aAAa,CAAC;CACnB;AAED,yFAAyF;AACzF,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,EAC5C,MAAM;IAAK,IAAI;IAAuB,QAAQ;CAAiB,GAC9D,OAAO,CAAC,oBAAoB,CAAC,CAyB/B"}

package/dist/internal/with-exclusive-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-exclusive-lock.d.ts","sourceRoot":"","sources":["../../src/internal/with-exclusive-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAwB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEjF,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,4CAA4C;AAC5C,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2FAA2F;IAC3F,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,qEAAqE;AACrE,qBAAa,kBAAmB,SAAQ,KAAK;IAGzC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IALnC,IAAI,SAAwB;IACrC,YACW,IAAI,EAAE,cAAc,GAAG,cAAc,EACrC,KAAK,EAAE,MAAM;IACtB,wFAAwF;IAC/E,MAAM,EAAE,kBAAkB,GAAG,IAAI,EAC1C,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAG9B;CACF;AAkCD;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC5C,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,CAAC,CAAC,CAwDZ"}
+{"version":3,"file":"with-exclusive-lock.d.ts","sourceRoot":"","sources":["../../src/internal/with-exclusive-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,4CAA4C;AAC5C,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2FAA2F;IAC3F,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,qEAAqE;AACrE,qBAAa,kBAAmB,SAAQ,KAAK;IAGzC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IALnC,IAAI,SAAwB;IACrC,YACW,IAAI,EAAE,cAAc,GAAG,cAAc,EACrC,KAAK,EAAE,MAAM;IACtB,wFAAwF;IAC/E,MAAM,EAAE,kBAAkB,GAAG,IAAI,EAC1C,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAG9B;CACF;AAyCD;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC5C,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,CAAC,CAAC,CAwDZ"}

package/dist/server/realtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../src/server/realtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACrB,yBAAyB,EAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,wBAAwB,CACvC,eAAe,SAAS,qBAAqB,EAC7C,eAAe,SAAS,qBAAqB,EAC7C,KAAK,GAAG,GAAG;IAEX;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;IACrE,MAAM,EAAE,uBAAuB,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAClE,EAAE,CACA,IAAI,EAAE,MAAM,GACX,IAAI,CAAC,uBAAuB,CAAC,qBAAqB,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,CAAC;CAClF;AAED,MAAM,WAAW,cAAc,CAC7B,eAAe,SAAS,qBAAqB,EAC7C,eAAe,SAAS,qBAAqB,EAC7C,KAAK,GAAG,GAAG;IAEX,YAAY,CACV,OAAO,EAAE,CACP,UAAU,EAAE,wBAAwB,CAAC,eAAe,EAAE,eAAe,EAAE,KAAK,CAAC,KAC1E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,MAAM,IAAI,CAAC;IACd,IAAI,EAAE,uBAAuB,CAAC,qBAAqB,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;IAC9E,EAAE,CACA,IAAI,EAAE,MAAM,GACX,IAAI,CAAC,uBAAuB,CAAC,qBAAqB,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,CAAC;CAClF;AAED,MAAM,WAAW,oBAAoB,CAAC,KAAK,GAAG,GAAG;IAC/C,EAAE,EAAE,cAAc,CAAC,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;CAC7E;AAED,wBAAgB,kBAAkB,CAChC,KAAK,CAAC,eAAe,SAAS,qBAAqB,EACnD,KAAK,CAAC,eAAe,SAAS,qBAAqB,EACnD,KAAK,GAAG,GAAG,EAEX,QAAQ,EAAE,gBAAgB,CAAC,eAAe,EAAE,eAAe,CAAC,EAC5D,MAAM,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACnC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,yBAAyB,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,GAC9E,cAAc,CAAC,eAAe,EAAE,eAAe,EAAE,KAAK,CAAC,CAwCzD"}
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../src/server/realtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACrB,yBAAyB,EAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,wBAAwB,CACvC,eAAe,SAAS,qBAAqB,EAC7C,eAAe,SAAS,qBAAqB,EAC7C,KAAK,GAAG,GAAG;IAEX;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;IACrE,MAAM,EAAE,uBAAuB,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAClE,EAAE,CACA,IAAI,EAAE,MAAM,GACX,IAAI,CAAC,uBAAuB,CAAC,qBAAqB,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,CAAC;CAClF;AAED,MAAM,WAAW,cAAc,CAC7B,eAAe,SAAS,qBAAqB,EAC7C,eAAe,SAAS,qBAAqB,EAC7C,KAAK,GAAG,GAAG;IAEX,YAAY,CACV,OAAO,EAAE,CACP,UAAU,EAAE,wBAAwB,CAAC,eAAe,EAAE,eAAe,EAAE,KAAK,CAAC,KAC1E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,MAAM,IAAI,CAAC;IACd,IAAI,EAAE,uBAAuB,CAAC,qBAAqB,EAAE,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;IAC9E,EAAE,CACA,IAAI,EAAE,MAAM,GACX,IAAI,CAAC,uBAAuB,CAAC,qBAAqB,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,CAAC;CAClF;AAED,MAAM,WAAW,oBAAoB,CAAC,KAAK,GAAG,GAAG;IAC/C,EAAE,EAAE,cAAc,CAAC,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;CAC7E;AAED,wBAAgB,kBAAkB,CAChC,KAAK,CAAC,eAAe,SAAS,qBAAqB,EACnD,KAAK,CAAC,eAAe,SAAS,qBAAqB,EACnD,KAAK,GAAG,GAAG,EAEX,QAAQ,EAAE,gBAAgB,CAAC,eAAe,EAAE,eAAe,CAAC,EAC5D,MAAM,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACnC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,yBAAyB,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,GAC9E,cAAc,CAAC,eAAe,EAAE,eAAe,EAAE,KAAK,CAAC,CAyDzD"}

package/llms/agent-runtime.2.txt

@@ -848,15 +848,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
 
@@ -864,5 +872,5 @@ 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.

package/llms/agent-runtime.3.txt

@@ -111,7 +111,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 |
@@ -272,7 +272,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).
@@ -287,8 +289,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.
 
 ==============================================================================
 # API reference: `stitchkit-tui`  (docs/api/reference.md)

package/llms/agent-runtime.txt

@@ -19,7 +19,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
@@ -636,9 +636,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

package/llms/application.2.txt

@@ -11,12 +11,40 @@ Parts of this slice:
 # Guide: Managed application kernel  (docs/guide/application-kernel.md)  (continued)
 ==============================================================================
 
+## Recovering change subscriptions
+
+`changeSubscriptionResource` is an optional resource over a consumer-owned driver.
+It uses a finite declared key set, subscribes before reading, reconciles after
+reconnect and periodically repairs lost hints. `reconcileIntervalMs` is explicit;
+notifications alone cannot prove freshness. Within a key, hints coalesce into one
+trailing read and a failed read retries with backoff. Use the supplied
+`context.commit(() => publish(value))` after awaits to reject an obsolete connection.
+
+Drivers implement `connect(signal)` and return `subscribe({ signal, hint,
+disconnected })` plus `close()`. Subscribe must establish the notification boundary
+before resolving. A database LISTEN driver owns its connection, channels, decoding
+and transaction ordering; no SQL or database driver is included here. The resource
+owns reconnect, deadlines and shutdown. Drivers must honor abort. If one ignores it,
+its slot remains occupied until settlement; deadlines cannot safely manufacture
+successful cleanup or permit an overlapping connection.
+
+For watched reads, set `reconcileIntervalMs` on the existing `createWatchHub` rather
+than building a second read loop. Its per-key machinery is shared with managed
+subscriptions. Limits default to 1024 sources and 1024 subscribers per hub; set
+explicit finite values for larger workloads. Supply a server-verified admission
+scope to `attach` and abort it on logout, permission revocation or session replacement.
+The read callback receives the trusted scope as its third argument. A client owner
+ID in arguments is not authentication.
+
 ## Multi-action notification delivery
 
 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.
@@ -28,9 +56,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.
@@ -321,7 +353,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 |
@@ -535,7 +567,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.
 
 
@@ -546,7 +581,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

package/llms/application.txt

@@ -876,7 +876,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 |
 
@@ -918,7 +919,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
@@ -991,28 +1007,3 @@ so a scheduler stall on a loaded host cannot pull a live lock from under its
 holder — after which the heartbeat wins and the lock is abandoned. Temporary files a crashed writer left beside the state are swept on
 the store's first update. Ledger corruption may be declared reconstructable;
 an outbox must fail closed rather than silently discard pending delivery.
-
-## Recovering change subscriptions
-
-`changeSubscriptionResource` is an optional resource over a consumer-owned driver.
-It uses a finite declared key set, subscribes before reading, reconciles after
-reconnect and periodically repairs lost hints. `reconcileIntervalMs` is explicit;
-notifications alone cannot prove freshness. Within a key, hints coalesce into one
-trailing read and a failed read retries with backoff. Use the supplied
-`context.commit(() => publish(value))` after awaits to reject an obsolete connection.
-
-Drivers implement `connect(signal)` and return `subscribe({ signal, hint,
-disconnected })` plus `close()`. Subscribe must establish the notification boundary
-before resolving. A database LISTEN driver owns its connection, channels, decoding
-and transaction ordering; no SQL or database driver is included here. The resource
-owns reconnect, deadlines and shutdown. Drivers must honor abort. If one ignores it,
-its slot remains occupied until settlement; deadlines cannot safely manufacture
-successful cleanup or permit an overlapping connection.
-
-For watched reads, set `reconcileIntervalMs` on the existing `createWatchHub` rather
-than building a second read loop. Its per-key machinery is shared with managed
-subscriptions. Limits default to 1024 sources and 1024 subscribers per hub; set
-explicit finite values for larger workloads. Supply a server-verified admission
-scope to `attach` and abort it on logout, permission revocation or session replacement.
-The read callback receives the trusted scope as its third argument. A client owner
-ID in arguments is not authentication.

package/llms/live.txt

@@ -473,6 +473,7 @@ 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.

package/llms/server.3.txt

@@ -1040,6 +1040,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

package/llms/stitchkit.3.txt

@@ -150,18 +150,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

package/llms/upgrading-0.74.0-0.100.0.txt

@@ -47,7 +47,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.
 
@@ -70,7 +73,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
@@ -88,13 +93,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