@game-infra/game-state-schemas 0.2.0 → 0.4.0

package/README.md

@@ -24,7 +24,7 @@ Keeping both in one resource meant one listing, one delete sweep and one retenti
 // pnpm sibling checkout
 "@game-infra/game-state-schemas": "link:../../game-infra/packages/schemas/game-state-schemas"
 // or from npm
-"@game-infra/game-state-schemas": "^0.1.0"
+"@game-infra/game-state-schemas": "^0.2.0"
 ```
 
 `valibot` is a peer dependency (`^1.4.0`); the consumer provides it. `@game-infra/api-schemas-core` and `@game-infra/event-schemas` are runtime dependencies — the first for the success-response wrapper, the second for the `ActivationDTO` effect vocabulary a freeform turn shares with an authored story branch.
@@ -81,6 +81,20 @@ Memory is a synapse graph. Each `MemoryDTO` connects to **neurons** — `charact
 
 None of these payload schemas is attached to an endpoint — the service stores `data` opaquely — but two clients reading the same session must agree on the shapes.
 
+## Narrative threads — several scenes at once
+
+A linear journal answers "what happened" with one list, which works until a player wants two things happening at once: a negotiation in the capital and a raid on the coast, each worth its own tab. Two of those cannot append to one list — whichever finished second would be narrated as though the first had already happened, and neither player intent was ever "and meanwhile, knowing that".
+
+`NarrativeThreadPayloadSchema` makes a thread a **fork of the journal**. `baseSequence` is the whole of the fork: the number of canon turns the thread could see when it opened. Everything before it is shared; everything the thread writes lands after it and is invisible to its siblings until a merge. The trunk is the degenerate case — `CANON_THREAD_ID`, no parent, base zero. A turn records the thread that wrote it (`threadId`) and the index it held there before a merge renumbered it (`originSequence`); both are optional, so a journal written before threads existed still reads.
+
+Convergence is where the honesty has to be. Two scenes written against the same past will sometimes contradict — a character killed in one and bargaining in the other, an item spent twice. `ThreadMergeReviewPayloadSchema` records the third answer between concatenating and refusing: the `ContradictionDTO`s found, graded `cosmetic` / `continuity` / `blocking`, and the `RetconDTO` amendments that reconcile them. A retcon may only `amend-narration`, `annotate`, `supersede-memory` or `reorder` — a merge agent that may rewrite anything can quietly delete a turn the player was proud of. Retcons are stored beside the journal rather than applied into it, so a reader sees both what was narrated and what was changed to make two scenes one story. `order` is the canon sequence the merge chose, recorded rather than re-derived: model finish times say when a call returned, not when a thing happened.
+
+## Runs in flight
+
+Resolving one turn is many model calls over many seconds, and a client that owns that work loses it whenever the browser reloads. `TurnRunPayloadSchema` is the run as a **server-owned, stage-checkpointed record**: `stages` in execution order with a `RunStageDTO` status each, and every partial output published the moment it exists — `check` as soon as the dice are rolled, `narration` as soon as the prose lands, `effects` once the consequences are interpreted, `memories` once the chronicler has been. A client renders whatever the record already carries and reattaches to a run in flight rather than restarting it.
+
+`status` distinguishes the three states a progressive client actually needs: `running` (nothing to show yet), `narrated` (there is prose on screen) and `settling` (the prose is final, the bookkeeping is still going). `settling` is the one worth spelling out — chronicling and consolidation happen after the player is already reading, so the turn looks finished, but the next turn in the same thread must not start until they land or it is adjudicated against a memory graph missing the turn before it. `leaseUntil` tells a stalled run from a slow one: without it, a worker that dies mid-run leaves the record `running` forever and nothing else dares touch it.
+
 ## Savegames
 
 Slot snapshots are `game-state-service`'s other half, but their contracts predate this package and stay where they are, in `@game-infra/api-schemas-core`: `savegameSaveContract`, `savegameLoadContract`, `savegameListSlotsContract`, at `/users/:userId/games/:gameId/saves/:saveSlot`. A published shape does not move just to sit next to its neighbours.

package/dist/freeformPayloads.d.ts

@@ -344,8 +344,26 @@ export declare const FreeformTurnPayloadSchema: import("valibot").ObjectSchema<{
     readonly model: import("valibot").StringSchema<undefined>;
     /** Milliseconds spent in each named generation-pipeline step. */
     readonly timings: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+    /** Prompt and completion token counts spent in each named pipeline step. */
+    readonly tokenUsage: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").ObjectSchema<{
+        readonly inputTokens: import("valibot").NumberSchema<undefined>;
+        readonly outputTokens: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
     /** Effective canonical model used for each model-backed pipeline step. */
     readonly stageModels: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * The narrative thread that wrote the turn, when the session runs more than
+     * one. Absent on a single-threaded journal, which is what every session
+     * written before threads existed is, so a reader treats absence as the canon
+     * thread rather than as a turn from nowhere.
+     */
+    readonly threadId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * The index the turn held in its own thread, kept after a merge renumbers it
+     * into the canon. Without it a retcon addressed to `{ threadId, sequence }`
+     * stops naming anything the moment the merge lands.
+     */
+    readonly originSequence: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
 }, undefined>;
 export type FreeformTurnPayload = InferOutput<typeof FreeformTurnPayloadSchema>;
 /**

package/dist/freeformPayloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"freeformPayloads.d.ts","sourceRoot":"","sources":["../src/freeformPayloads.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"freeformPayloads.d.ts","sourceRoot":"","sources":["../src/freeformPayloads.ts"],"names":[],"mappings":"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"}

package/dist/freeformPayloads.js

@@ -296,8 +296,23 @@ export const FreeformTurnPayloadSchema = object({
     model: string(),
     /** Milliseconds spent in each named generation-pipeline step. */
     timings: optional(record(string(), number())),
+    /** Prompt and completion token counts spent in each named pipeline step. */
+    tokenUsage: optional(record(string(), object({ inputTokens: number(), outputTokens: number() }))),
     /** Effective canonical model used for each model-backed pipeline step. */
     stageModels: optional(record(string(), string())),
+    /**
+     * The narrative thread that wrote the turn, when the session runs more than
+     * one. Absent on a single-threaded journal, which is what every session
+     * written before threads existed is, so a reader treats absence as the canon
+     * thread rather than as a turn from nowhere.
+     */
+    threadId: optional(string()),
+    /**
+     * The index the turn held in its own thread, kept after a merge renumbers it
+     * into the canon. Without it a retcon addressed to `{ threadId, sequence }`
+     * stops naming anything the moment the merge lands.
+     */
+    originSequence: optional(number()),
 });
 /**
  * A freeform session's header payload — what goes inside a

package/dist/freeformPayloads.js.map

@@ -1 +1 @@
-{"version":3,"file":"freeformPayloads.js","sourceRoot":"","sources":["../src/freeformPayloads.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"freeformPayloads.js","sourceRoot":"","sources":["../src/freeformPayloads.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -35,5 +35,7 @@ export { GameJournalAppendRequestSchema, GameJournalAppendResponseSchema, GameJo
 export type { GameJournalAppendRequest, GameJournalAppendResponse, GameJournalEntryRecord, GameJournalListResponse, GameJournalTruncateResponse, GameSessionDeleteResponse, GameSessionListResponse, GameSessionLoadResponse, GameSessionRecord, GameSessionSaveRequest, GameSessionSaveResponse, JournalTruncation, } from "./sessionState.js";
 export { CheckModifierDTOSchema, ConsolidationDTOSchema, FREEFORM_COMPLEXITIES, FREEFORM_DOMAINS, FREEFORM_OUTCOMES, FreeformComplexitySchema, FreeformOutcomeSchema, FreeformSessionPayloadSchema, FreeformTurnPayloadSchema, IntroducedEntityDTOSchema, MemoryDTOSchema, NEURON_KEY_SEPARATOR, ResolvedCheckDTOSchema, neuronKey, parseNeuronKey, } from "./freeformPayloads.js";
 export type { CheckModifierDTO, ConsolidationDTO, FreeformComplexity, FreeformOutcome, FreeformSessionPayload, FreeformTurnPayload, IntroducedEntityDTO, MemoryDTO, ResolvedCheckDTO, } from "./freeformPayloads.js";
+export { CANON_THREAD_ID, CONTRADICTION_SEVERITIES, ContradictionDTOSchema, ContradictionSeveritySchema, NarrativeThreadPayloadSchema, RETCON_KINDS, RUN_STAGE_STATUSES, RetconDTOSchema, RetconKindSchema, RunStageDTOSchema, RunStageStatusSchema, THREAD_STATUSES, TURN_RUN_STATUSES, ThreadMergeReviewPayloadSchema, ThreadStatusSchema, ThreadTurnRefSchema, TurnRunPayloadSchema, TurnRunStatusSchema, } from "./narrativeThreads.js";
+export type { ContradictionDTO, ContradictionSeverity, NarrativeThreadPayload, RetconDTO, RetconKind, RunStageDTO, RunStageStatus, ThreadMergeReviewPayload, ThreadStatus, ThreadTurnRef, TurnRunPayload, TurnRunStatus, } from "./narrativeThreads.js";
 export { gameJournalAppendContract, gameJournalListContract, gameJournalTruncateContract, gameSessionDeleteContract, gameSessionListContract, gameSessionLoadContract, gameSessionSaveContract, } from "./contracts.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,EAC5B,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,SAAS,EACT,UAAU,EACV,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,aAAa,GACd,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -38,6 +38,10 @@ export { GameJournalAppendRequestSchema, GameJournalAppendResponseSchema, GameJo
 // synapse memory graph — memories connected to neurons, consolidated over time
 // — that decides what a narrator is reminded of.
 export { CheckModifierDTOSchema, ConsolidationDTOSchema, FREEFORM_COMPLEXITIES, FREEFORM_DOMAINS, FREEFORM_OUTCOMES, FreeformComplexitySchema, FreeformOutcomeSchema, FreeformSessionPayloadSchema, FreeformTurnPayloadSchema, IntroducedEntityDTOSchema, MemoryDTOSchema, NEURON_KEY_SEPARATOR, ResolvedCheckDTOSchema, neuronKey, parseNeuronKey, } from "./freeformPayloads.js";
+// Narrative threads: several scenes of one playthrough advancing at once, the
+// merge that converges them (with the retcons that keep the canon honest), and
+// the server-owned, stage-checkpointed record of the work in flight.
+export { CANON_THREAD_ID, CONTRADICTION_SEVERITIES, ContradictionDTOSchema, ContradictionSeveritySchema, NarrativeThreadPayloadSchema, RETCON_KINDS, RUN_STAGE_STATUSES, RetconDTOSchema, RetconKindSchema, RunStageDTOSchema, RunStageStatusSchema, THREAD_STATUSES, TURN_RUN_STATUSES, ThreadMergeReviewPayloadSchema, ThreadStatusSchema, ThreadTurnRefSchema, TurnRunPayloadSchema, TurnRunStatusSchema, } from "./narrativeThreads.js";
 // Typed endpoint contracts (toad-contracts). Each contract carries its own
 // `pathResolver`; wire them into a client via @toad-contracts/frontend-http-client
 // and into a Hono service via @toad-contracts/hono.

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,2EAA2E;AAC3E,sDAAsD;AACtD,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAgB3B,0EAA0E;AAC1E,+EAA+E;AAC/E,iDAAiD;AACjD,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,cAAc,GACf,MAAM,uBAAuB,CAAC;AAa/B,2EAA2E;AAC3E,mFAAmF;AACnF,oDAAoD;AACpD,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,2EAA2E;AAC3E,sDAAsD;AACtD,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAgB3B,0EAA0E;AAC1E,+EAA+E;AAC/E,iDAAiD;AACjD,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,cAAc,GACf,MAAM,uBAAuB,CAAC;AAa/B,8EAA8E;AAC9E,+EAA+E;AAC/E,qEAAqE;AACrE,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,sBAAsB,EACtB,2BAA2B,EAC3B,4BAA4B,EAC5B,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAgB/B,2EAA2E;AAC3E,mFAAmF;AACnF,oDAAoD;AACpD,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}

package/dist/narrativeThreads.d.ts

@@ -0,0 +1,458 @@
+import { type InferOutput } from "valibot";
+/**
+ * **Narrative threads**: several scenes of one playthrough advancing at once,
+ * and the durable record of the work that advances them.
+ *
+ * A linear journal answers "what happened" with one list, which is the right
+ * shape right up until a player wants two things happening at once — a
+ * negotiation in the capital and a raid on the coast, each worth its own tab.
+ * Two of those cannot append to one list: whichever turn finished second would
+ * be narrated as though the first had already happened, and neither player
+ * intent was ever "and meanwhile, knowing that".
+ *
+ * So a thread is a **fork of the journal**, not a copy of the run. It records
+ * the point in the shared journal it forked from ({@link
+ * NarrativeThreadPayload.baseSequence}) and appends its own turns after it.
+ * Every thread reads the same state up to that point and none of them sees
+ * another's turns while they are still being written. Threads converge later,
+ * by a **merge**, which is the only moment their outputs meet.
+ *
+ * Convergence is where the honesty has to be. Two scenes written against the
+ * same past will sometimes contradict — a character killed in one and
+ * bargaining in the other, an item spent twice, two people in one room a
+ * province apart. A merge that simply concatenates produces a canon that reads
+ * as broken, and a merge that refuses produces a game that cannot use threads
+ * at all. {@link ThreadMergeReviewPayloadSchema} records the third answer: the
+ * contradictions found, and the {@link RetconDTOSchema} amendments that
+ * reconcile them, each naming the turn it rewrites and why. Retcons are stored
+ * rather than applied in place, so the journal keeps what was originally
+ * narrated and a reader can always see what was changed to make the two scenes
+ * one story.
+ *
+ * The third shape here is not about threads at all but about *time*. Resolving
+ * one turn is many model calls over many seconds, and a client that owns that
+ * work loses it whenever the browser reloads. {@link TurnRunPayloadSchema} is
+ * the run as a **server-owned, stage-checkpointed record**: every stage's
+ * status, and every partial output the moment it exists — the roll before the
+ * prose, the prose before the consequences, the chronicle after both. A client
+ * renders whatever the record already carries and reattaches to a run in
+ * flight rather than restarting it.
+ *
+ * As everywhere else in this package these are payload shapes, not endpoints:
+ * `game-state-service` stores `data` opaquely. They live here because two
+ * clients reading one playthrough have to agree on what a thread is.
+ */
+/** The trunk every playthrough starts on, and the thread a merge lands in. */
+export declare const CANON_THREAD_ID = "canon";
+/**
+ * Where a thread is in its life.
+ *
+ * `open` accepts turns. `merging` is under review by the merge agent and
+ * accepts none — a turn written against a base that is being rewritten is a
+ * contradiction manufactured after the fact. `merged` has been folded into the
+ * canon and is kept for the record. `abandoned` was closed without merging, and
+ * its turns are read as what-ifs rather than as things that happened.
+ */
+export declare const THREAD_STATUSES: readonly ["open", "merging", "merged", "abandoned"];
+export declare const ThreadStatusSchema: import("valibot").PicklistSchema<readonly ["open", "merging", "merged", "abandoned"], undefined>;
+export type ThreadStatus = InferOutput<typeof ThreadStatusSchema>;
+/**
+ * One thread of a playthrough: a tab in the story.
+ *
+ * `baseSequence` is the whole of the fork: the number of canon turns the thread
+ * could see when it opened. Everything before it is shared with every other
+ * thread; everything the thread writes lands after it and is invisible to its
+ * siblings until a merge. The canon thread itself is the degenerate case —
+ * {@link CANON_THREAD_ID}, no parent, base zero.
+ *
+ * @example
+ * ```ts
+ * import { CANON_THREAD_ID, type NarrativeThreadPayload } from '@game-infra/game-state-schemas'
+ *
+ * const raid: NarrativeThreadPayload = {
+ *   id: 'the-coast-raid',
+ *   title: 'The coast raid',
+ *   parentThreadId: CANON_THREAD_ID,
+ *   baseSequence: 12,
+ *   status: 'open',
+ *   createdAt: '2026-08-31T09:00:00.000Z',
+ * }
+ * ```
+ */
+export declare const NarrativeThreadPayloadSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** What to call the tab. */
+    readonly title: import("valibot").StringSchema<undefined>;
+    /** The thread this one forked from. Absent on the canon thread. */
+    readonly parentThreadId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Canon turns visible to this thread. Its own turns are numbered from here. */
+    readonly baseSequence: import("valibot").NumberSchema<undefined>;
+    readonly status: import("valibot").PicklistSchema<readonly ["open", "merging", "merged", "abandoned"], undefined>;
+    readonly createdAt: import("valibot").StringSchema<undefined>;
+    /** Canon length after the merge that closed this thread, when one has. */
+    readonly mergedAtSequence: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type NarrativeThreadPayload = InferOutput<typeof NarrativeThreadPayloadSchema>;
+/** One turn, addressed the way a merge has to address it: thread, then index. */
+export declare const ThreadTurnRefSchema: import("valibot").ObjectSchema<{
+    readonly threadId: import("valibot").StringSchema<undefined>;
+    readonly sequence: import("valibot").NumberSchema<undefined>;
+}, undefined>;
+export type ThreadTurnRef = InferOutput<typeof ThreadTurnRefSchema>;
+/**
+ * How badly two threads disagree.
+ *
+ * `cosmetic` is a difference a reader would not notice and a merge may keep as
+ * it is. `continuity` is a fact stated two ways, which reads as sloppy and is
+ * what a retcon is for. `blocking` is a fact stated two ways where *both* are
+ * load-bearing — a character who cannot be both dead and negotiating — and the
+ * merge is not honest until something is amended.
+ */
+export declare const CONTRADICTION_SEVERITIES: readonly ["cosmetic", "continuity", "blocking"];
+export declare const ContradictionSeveritySchema: import("valibot").PicklistSchema<readonly ["cosmetic", "continuity", "blocking"], undefined>;
+export type ContradictionSeverity = InferOutput<typeof ContradictionSeveritySchema>;
+/**
+ * One disagreement between threads, named so a reader can check the judgement.
+ *
+ * `between` carries the turns that disagree rather than a prose description of
+ * them, so a client can link straight to both sides instead of asking the
+ * reader to find them.
+ *
+ * @example
+ * ```ts
+ * import type { ContradictionDTO } from '@game-infra/game-state-schemas'
+ *
+ * const clash: ContradictionDTO = {
+ *   id: 'k1',
+ *   severity: 'blocking',
+ *   description: 'Warden Ilse dies on the coast and opens the ledger in the capital.',
+ *   between: [
+ *     { threadId: 'the-coast-raid', sequence: 3 },
+ *     { threadId: 'the-ledger', sequence: 2 },
+ *   ],
+ * }
+ * ```
+ */
+export declare const ContradictionDTOSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly severity: import("valibot").PicklistSchema<readonly ["cosmetic", "continuity", "blocking"], undefined>;
+    /** What the two turns each claim, in one sentence. */
+    readonly description: import("valibot").StringSchema<undefined>;
+    /** The turns that disagree. At least two, or there is no disagreement. */
+    readonly between: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly threadId: import("valibot").StringSchema<undefined>;
+        readonly sequence: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type ContradictionDTO = InferOutput<typeof ContradictionDTOSchema>;
+/**
+ * What a retcon is allowed to do.
+ *
+ * The list is short on purpose. A merge agent that may rewrite anything is one
+ * that can quietly delete a turn the player is proud of, and "the story changed
+ * while you were reading it" is worse than the contradiction it fixed.
+ *
+ * - `amend-narration` rewrites one turn's prose, keeping its check, effects and
+ *   memories exactly as they were rolled and recorded.
+ * - `annotate` adds a reconciling sentence without touching what is already
+ *   written — the answer when both turns are fine and only their meeting needs
+ *   explaining.
+ * - `supersede-memory` retires memories that the merged canon has made false,
+ *   which is the memory graph's own vocabulary rather than a new one.
+ * - `reorder` states that a turn belongs elsewhere in the canon order, which
+ *   resolves most "meanwhile" contradictions without changing a word.
+ */
+export declare const RETCON_KINDS: readonly ["amend-narration", "annotate", "supersede-memory", "reorder"];
+export declare const RetconKindSchema: import("valibot").PicklistSchema<readonly ["amend-narration", "annotate", "supersede-memory", "reorder"], undefined>;
+export type RetconKind = InferOutput<typeof RetconKindSchema>;
+/**
+ * One amendment the merge agent proposes, against one turn.
+ *
+ * Stored beside the journal rather than applied into it. The turn keeps what it
+ * originally said, the retcon says what it says now, and a reader can see both
+ * — which is the difference between a story that was reconciled and a story
+ * that was silently edited.
+ *
+ * @example
+ * ```ts
+ * import type { RetconDTO } from '@game-infra/game-state-schemas'
+ *
+ * const patch: RetconDTO = {
+ *   id: 'r1',
+ *   kind: 'amend-narration',
+ *   target: { threadId: 'the-coast-raid', sequence: 3 },
+ *   reason: 'Ilse cannot die here and open the ledger in the capital two turns later.',
+ *   narration: 'The blade takes her shoulder, not her throat; she goes down cursing you.',
+ *   resolves: ['k1'],
+ * }
+ * ```
+ */
+export declare const RetconDTOSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly kind: import("valibot").PicklistSchema<readonly ["amend-narration", "annotate", "supersede-memory", "reorder"], undefined>;
+    /** The turn being amended. */
+    readonly target: import("valibot").ObjectSchema<{
+        readonly threadId: import("valibot").StringSchema<undefined>;
+        readonly sequence: import("valibot").NumberSchema<undefined>;
+    }, undefined>;
+    /** Why the amendment is needed, in the merge agent's own words. */
+    readonly reason: import("valibot").StringSchema<undefined>;
+    /** Replacement prose, for `amend-narration`. */
+    readonly narration: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** The reconciling sentence, for `annotate`. */
+    readonly note: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Memories the merged canon has made false, for `supersede-memory`. */
+    readonly memoryIds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+    /** Canon position the turn should hold, for `reorder`. */
+    readonly sequence: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** The {@link ContradictionDTO} ids this amendment answers. */
+    readonly resolves: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type RetconDTO = InferOutput<typeof RetconDTOSchema>;
+/**
+ * One merge: the threads that converged, what disagreed, what was amended, and
+ * the order the canon ended up in.
+ *
+ * `order` is the whole merge decision made explicit. Threads produce turns
+ * concurrently and their timestamps say only when a model finished, which is
+ * not when a thing happened; the merge agent decides the sequence the canon
+ * reads in and records it, so a replay is deterministic without re-asking a
+ * model what order the day went in.
+ *
+ * @example
+ * ```ts
+ * import type { ThreadMergeReviewPayload } from '@game-infra/game-state-schemas'
+ *
+ * const review: ThreadMergeReviewPayload = {
+ *   id: 'merge-0003',
+ *   threadIds: ['the-coast-raid', 'the-ledger'],
+ *   baseSequence: 12,
+ *   order: [
+ *     { threadId: 'the-ledger', sequence: 0 },
+ *     { threadId: 'the-coast-raid', sequence: 0 },
+ *   ],
+ *   contradictions: [],
+ *   retcons: [],
+ *   summary: 'Two scenes, one afternoon, nothing in conflict.',
+ *   model: 'aion',
+ *   createdAt: '2026-08-31T09:31:00.000Z',
+ * }
+ * ```
+ */
+export declare const ThreadMergeReviewPayloadSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** The threads folded in, in the order they were opened. */
+    readonly threadIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Canon length the threads shared before the merge. */
+    readonly baseSequence: import("valibot").NumberSchema<undefined>;
+    /** The canon order the merge chose, one entry per turn folded in. */
+    readonly order: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly threadId: import("valibot").StringSchema<undefined>;
+        readonly sequence: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly contradictions: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly severity: import("valibot").PicklistSchema<readonly ["cosmetic", "continuity", "blocking"], undefined>;
+        /** What the two turns each claim, in one sentence. */
+        readonly description: import("valibot").StringSchema<undefined>;
+        /** The turns that disagree. At least two, or there is no disagreement. */
+        readonly between: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly threadId: import("valibot").StringSchema<undefined>;
+            readonly sequence: import("valibot").NumberSchema<undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly retcons: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly kind: import("valibot").PicklistSchema<readonly ["amend-narration", "annotate", "supersede-memory", "reorder"], undefined>;
+        /** The turn being amended. */
+        readonly target: import("valibot").ObjectSchema<{
+            readonly threadId: import("valibot").StringSchema<undefined>;
+            readonly sequence: import("valibot").NumberSchema<undefined>;
+        }, undefined>;
+        /** Why the amendment is needed, in the merge agent's own words. */
+        readonly reason: import("valibot").StringSchema<undefined>;
+        /** Replacement prose, for `amend-narration`. */
+        readonly narration: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** The reconciling sentence, for `annotate`. */
+        readonly note: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        /** Memories the merged canon has made false, for `supersede-memory`. */
+        readonly memoryIds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+        /** Canon position the turn should hold, for `reorder`. */
+        readonly sequence: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** The {@link ContradictionDTO} ids this amendment answers. */
+        readonly resolves: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** What the merge did, for a reader who does not want to read every retcon. */
+    readonly summary: import("valibot").StringSchema<undefined>;
+    /** The model that reviewed the merge. */
+    readonly model: import("valibot").StringSchema<undefined>;
+    readonly createdAt: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type ThreadMergeReviewPayload = InferOutput<typeof ThreadMergeReviewPayloadSchema>;
+/**
+ * Where a run is. The three middle values are what a progressive client needs:
+ * they are the difference between "nothing to show yet", "there is prose on
+ * screen" and "the prose is final and the bookkeeping is still going".
+ *
+ * `settling` is the one worth spelling out. Chronicling and consolidation
+ * happen after the player is already reading, so the turn looks finished; but
+ * the next turn in the same thread must not start until they land, or it is
+ * adjudicated against a memory graph missing the turn before it.
+ */
+export declare const TURN_RUN_STATUSES: readonly ["queued", "running", "narrated", "settling", "completed", "failed", "cancelled"];
+export declare const TurnRunStatusSchema: import("valibot").PicklistSchema<readonly ["queued", "running", "narrated", "settling", "completed", "failed", "cancelled"], undefined>;
+export type TurnRunStatus = InferOutput<typeof TurnRunStatusSchema>;
+/** Where one stage of a run is. `skipped` is a stage the turn did not need. */
+export declare const RUN_STAGE_STATUSES: readonly ["pending", "running", "completed", "skipped", "failed"];
+export declare const RunStageStatusSchema: import("valibot").PicklistSchema<readonly ["pending", "running", "completed", "skipped", "failed"], undefined>;
+export type RunStageStatus = InferOutput<typeof RunStageStatusSchema>;
+/**
+ * One stage of a run, as the server checkpoints it.
+ *
+ * `attempt` is stored rather than derived because a resumed run has to know
+ * whether it is retrying or starting: a stage that has already burnt its
+ * retries should fail the run rather than loop for as long as the storage
+ * keeps the record.
+ */
+export declare const RunStageDTOSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    /** What to show a player waiting on it. */
+    readonly label: import("valibot").StringSchema<undefined>;
+    /** Which agent does the work — or the engine, for a local stage. */
+    readonly agent: import("valibot").StringSchema<undefined>;
+    /** The canonical model behind it, or `local` for a stage that asks nobody. */
+    readonly model: import("valibot").StringSchema<undefined>;
+    readonly status: import("valibot").PicklistSchema<readonly ["pending", "running", "completed", "skipped", "failed"], undefined>;
+    /** Epoch milliseconds; absent until the stage starts. */
+    readonly startedAt: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly durationMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** Total prompt tokens consumed by successful calls in this stage. */
+    readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** Total completion tokens produced by successful calls in this stage. */
+    readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly attempt: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type RunStageDTO = InferOutput<typeof RunStageDTOSchema>;
+/**
+ * One turn's adjudication, owned by the server and readable at any moment.
+ *
+ * This is the record that makes a reload survivable. The work belongs to the
+ * service rather than to the tab that asked for it, every stage is written down
+ * as it finishes, and each output is published the moment it exists rather than
+ * at the end: `check` as soon as the dice are rolled, `narration` as soon as
+ * the prose lands, `effects` once the consequences are interpreted, `memories`
+ * once the chronicler has been. A client that reconnects renders whatever is
+ * already here and waits only for what is genuinely still missing.
+ *
+ * `leaseUntil` is how a stalled run is told from a slow one. A worker that dies
+ * mid-run leaves the record `running` forever otherwise, and nothing else dares
+ * touch it; with a lease, whoever finds it expired may resume from the last
+ * completed stage.
+ *
+ * @example
+ * ```ts
+ * import type { TurnRunPayload } from '@game-infra/game-state-schemas'
+ *
+ * const run: TurnRunPayload = {
+ *   id: 'run-8f2c',
+ *   threadId: 'the-coast-raid',
+ *   sequence: 3,
+ *   input: 'I put my shoulder to the door and shout for Ilse.',
+ *   status: 'narrated',
+ *   stages: [
+ *     { id: 'assessment', label: 'Choosing whether and how to roll',
+ *       agent: 'Assessor', model: 'aion-mini', status: 'completed', durationMs: 1840 },
+ *   ],
+ *   traceId: 'turn-8f2c',
+ *   startedAt: '2026-08-31T09:12:00.000Z',
+ *   updatedAt: '2026-08-31T09:12:09.000Z',
+ * }
+ * ```
+ */
+export declare const TurnRunPayloadSchema: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly threadId: import("valibot").StringSchema<undefined>;
+    /** The index this turn takes in its thread. */
+    readonly sequence: import("valibot").NumberSchema<undefined>;
+    /** What the player wrote. Empty on a session's opening turn. */
+    readonly input: import("valibot").StringSchema<undefined>;
+    readonly status: import("valibot").PicklistSchema<readonly ["queued", "running", "narrated", "settling", "completed", "failed", "cancelled"], undefined>;
+    /** Every stage, in execution order, whether or not it has run. */
+    readonly stages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        /** What to show a player waiting on it. */
+        readonly label: import("valibot").StringSchema<undefined>;
+        /** Which agent does the work — or the engine, for a local stage. */
+        readonly agent: import("valibot").StringSchema<undefined>;
+        /** The canonical model behind it, or `local` for a stage that asks nobody. */
+        readonly model: import("valibot").StringSchema<undefined>;
+        readonly status: import("valibot").PicklistSchema<readonly ["pending", "running", "completed", "skipped", "failed"], undefined>;
+        /** Epoch milliseconds; absent until the stage starts. */
+        readonly startedAt: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly durationMs: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Total prompt tokens consumed by successful calls in this stage. */
+        readonly inputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        /** Total completion tokens produced by successful calls in this stage. */
+        readonly outputTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly attempt: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** Joins every model call this run made. */
+    readonly traceId: import("valibot").StringSchema<undefined>;
+    readonly startedAt: import("valibot").StringSchema<undefined>;
+    readonly updatedAt: import("valibot").StringSchema<undefined>;
+    /** Epoch milliseconds after which an unfinished run may be resumed by anyone. */
+    readonly leaseUntil: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /** The neurons the assessor judged relevant. */
+    readonly focus: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+    /** The roll — available before a word of prose has been written. */
+    readonly check: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly skillId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly statId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly complexity: import("valibot").PicklistSchema<readonly ["trivial", "easy", "moderate", "hard", "formidable"], undefined>;
+        readonly difficulty: import("valibot").NumberSchema<undefined>;
+        readonly roll: import("valibot").NumberSchema<undefined>;
+        readonly modifiers: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly label: import("valibot").StringSchema<undefined>;
+            readonly amount: import("valibot").NumberSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly total: import("valibot").NumberSchema<undefined>;
+        readonly outcome: import("valibot").PicklistSchema<readonly ["critical-success", "success", "failure", "critical-failure"], undefined>;
+    }, undefined>, undefined>;
+    readonly title: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly narration: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly effects: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly type: import("valibot").StringSchema<undefined>;
+        readonly params: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").UnknownSchema, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly introduced: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly memories: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").StringSchema<undefined>;
+        readonly text: import("valibot").StringSchema<undefined>;
+        readonly neuronIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly turn: import("valibot").NumberSchema<undefined>;
+        readonly weight: import("valibot").NumberSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly consolidations: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+        readonly memoryIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly memory: import("valibot").ObjectSchema<{
+            readonly id: import("valibot").StringSchema<undefined>;
+            readonly text: import("valibot").StringSchema<undefined>;
+            readonly neuronIds: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly turn: import("valibot").NumberSchema<undefined>;
+            readonly weight: import("valibot").NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, undefined>, undefined>;
+    /** The model that narrated, once one has. */
+    readonly model: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Milliseconds per named stage, as they complete. */
+    readonly timings: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+    /** Why the run failed, when it did. */
+    readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type TurnRunPayload = InferOutput<typeof TurnRunPayloadSchema>;
+//# sourceMappingURL=narrativeThreads.d.ts.map

package/dist/narrativeThreads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrativeThreads.d.ts","sourceRoot":"","sources":["../src/narrativeThreads.ts"],"names":[],"mappings":"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"}

package/dist/narrativeThreads.js

@@ -0,0 +1,367 @@
+import { ActivationDTOSchema } from "@game-infra/event-schemas";
+import { array, number, object, optional, picklist, record, string, } from "valibot";
+import { ConsolidationDTOSchema, IntroducedEntityDTOSchema, MemoryDTOSchema, ResolvedCheckDTOSchema, } from "./freeformPayloads.js";
+/**
+ * **Narrative threads**: several scenes of one playthrough advancing at once,
+ * and the durable record of the work that advances them.
+ *
+ * A linear journal answers "what happened" with one list, which is the right
+ * shape right up until a player wants two things happening at once — a
+ * negotiation in the capital and a raid on the coast, each worth its own tab.
+ * Two of those cannot append to one list: whichever turn finished second would
+ * be narrated as though the first had already happened, and neither player
+ * intent was ever "and meanwhile, knowing that".
+ *
+ * So a thread is a **fork of the journal**, not a copy of the run. It records
+ * the point in the shared journal it forked from ({@link
+ * NarrativeThreadPayload.baseSequence}) and appends its own turns after it.
+ * Every thread reads the same state up to that point and none of them sees
+ * another's turns while they are still being written. Threads converge later,
+ * by a **merge**, which is the only moment their outputs meet.
+ *
+ * Convergence is where the honesty has to be. Two scenes written against the
+ * same past will sometimes contradict — a character killed in one and
+ * bargaining in the other, an item spent twice, two people in one room a
+ * province apart. A merge that simply concatenates produces a canon that reads
+ * as broken, and a merge that refuses produces a game that cannot use threads
+ * at all. {@link ThreadMergeReviewPayloadSchema} records the third answer: the
+ * contradictions found, and the {@link RetconDTOSchema} amendments that
+ * reconcile them, each naming the turn it rewrites and why. Retcons are stored
+ * rather than applied in place, so the journal keeps what was originally
+ * narrated and a reader can always see what was changed to make the two scenes
+ * one story.
+ *
+ * The third shape here is not about threads at all but about *time*. Resolving
+ * one turn is many model calls over many seconds, and a client that owns that
+ * work loses it whenever the browser reloads. {@link TurnRunPayloadSchema} is
+ * the run as a **server-owned, stage-checkpointed record**: every stage's
+ * status, and every partial output the moment it exists — the roll before the
+ * prose, the prose before the consequences, the chronicle after both. A client
+ * renders whatever the record already carries and reattaches to a run in
+ * flight rather than restarting it.
+ *
+ * As everywhere else in this package these are payload shapes, not endpoints:
+ * `game-state-service` stores `data` opaquely. They live here because two
+ * clients reading one playthrough have to agree on what a thread is.
+ */
+/** The trunk every playthrough starts on, and the thread a merge lands in. */
+export const CANON_THREAD_ID = "canon";
+/**
+ * Where a thread is in its life.
+ *
+ * `open` accepts turns. `merging` is under review by the merge agent and
+ * accepts none — a turn written against a base that is being rewritten is a
+ * contradiction manufactured after the fact. `merged` has been folded into the
+ * canon and is kept for the record. `abandoned` was closed without merging, and
+ * its turns are read as what-ifs rather than as things that happened.
+ */
+export const THREAD_STATUSES = ["open", "merging", "merged", "abandoned"];
+export const ThreadStatusSchema = picklist(THREAD_STATUSES);
+/**
+ * One thread of a playthrough: a tab in the story.
+ *
+ * `baseSequence` is the whole of the fork: the number of canon turns the thread
+ * could see when it opened. Everything before it is shared with every other
+ * thread; everything the thread writes lands after it and is invisible to its
+ * siblings until a merge. The canon thread itself is the degenerate case —
+ * {@link CANON_THREAD_ID}, no parent, base zero.
+ *
+ * @example
+ * ```ts
+ * import { CANON_THREAD_ID, type NarrativeThreadPayload } from '@game-infra/game-state-schemas'
+ *
+ * const raid: NarrativeThreadPayload = {
+ *   id: 'the-coast-raid',
+ *   title: 'The coast raid',
+ *   parentThreadId: CANON_THREAD_ID,
+ *   baseSequence: 12,
+ *   status: 'open',
+ *   createdAt: '2026-08-31T09:00:00.000Z',
+ * }
+ * ```
+ */
+export const NarrativeThreadPayloadSchema = object({
+    id: string(),
+    /** What to call the tab. */
+    title: string(),
+    /** The thread this one forked from. Absent on the canon thread. */
+    parentThreadId: optional(string()),
+    /** Canon turns visible to this thread. Its own turns are numbered from here. */
+    baseSequence: number(),
+    status: ThreadStatusSchema,
+    createdAt: string(),
+    /** Canon length after the merge that closed this thread, when one has. */
+    mergedAtSequence: optional(number()),
+});
+/** One turn, addressed the way a merge has to address it: thread, then index. */
+export const ThreadTurnRefSchema = object({
+    threadId: string(),
+    sequence: number(),
+});
+/**
+ * How badly two threads disagree.
+ *
+ * `cosmetic` is a difference a reader would not notice and a merge may keep as
+ * it is. `continuity` is a fact stated two ways, which reads as sloppy and is
+ * what a retcon is for. `blocking` is a fact stated two ways where *both* are
+ * load-bearing — a character who cannot be both dead and negotiating — and the
+ * merge is not honest until something is amended.
+ */
+export const CONTRADICTION_SEVERITIES = ["cosmetic", "continuity", "blocking"];
+export const ContradictionSeveritySchema = picklist(CONTRADICTION_SEVERITIES);
+/**
+ * One disagreement between threads, named so a reader can check the judgement.
+ *
+ * `between` carries the turns that disagree rather than a prose description of
+ * them, so a client can link straight to both sides instead of asking the
+ * reader to find them.
+ *
+ * @example
+ * ```ts
+ * import type { ContradictionDTO } from '@game-infra/game-state-schemas'
+ *
+ * const clash: ContradictionDTO = {
+ *   id: 'k1',
+ *   severity: 'blocking',
+ *   description: 'Warden Ilse dies on the coast and opens the ledger in the capital.',
+ *   between: [
+ *     { threadId: 'the-coast-raid', sequence: 3 },
+ *     { threadId: 'the-ledger', sequence: 2 },
+ *   ],
+ * }
+ * ```
+ */
+export const ContradictionDTOSchema = object({
+    id: string(),
+    severity: ContradictionSeveritySchema,
+    /** What the two turns each claim, in one sentence. */
+    description: string(),
+    /** The turns that disagree. At least two, or there is no disagreement. */
+    between: array(ThreadTurnRefSchema),
+});
+/**
+ * What a retcon is allowed to do.
+ *
+ * The list is short on purpose. A merge agent that may rewrite anything is one
+ * that can quietly delete a turn the player is proud of, and "the story changed
+ * while you were reading it" is worse than the contradiction it fixed.
+ *
+ * - `amend-narration` rewrites one turn's prose, keeping its check, effects and
+ *   memories exactly as they were rolled and recorded.
+ * - `annotate` adds a reconciling sentence without touching what is already
+ *   written — the answer when both turns are fine and only their meeting needs
+ *   explaining.
+ * - `supersede-memory` retires memories that the merged canon has made false,
+ *   which is the memory graph's own vocabulary rather than a new one.
+ * - `reorder` states that a turn belongs elsewhere in the canon order, which
+ *   resolves most "meanwhile" contradictions without changing a word.
+ */
+export const RETCON_KINDS = ["amend-narration", "annotate", "supersede-memory", "reorder"];
+export const RetconKindSchema = picklist(RETCON_KINDS);
+/**
+ * One amendment the merge agent proposes, against one turn.
+ *
+ * Stored beside the journal rather than applied into it. The turn keeps what it
+ * originally said, the retcon says what it says now, and a reader can see both
+ * — which is the difference between a story that was reconciled and a story
+ * that was silently edited.
+ *
+ * @example
+ * ```ts
+ * import type { RetconDTO } from '@game-infra/game-state-schemas'
+ *
+ * const patch: RetconDTO = {
+ *   id: 'r1',
+ *   kind: 'amend-narration',
+ *   target: { threadId: 'the-coast-raid', sequence: 3 },
+ *   reason: 'Ilse cannot die here and open the ledger in the capital two turns later.',
+ *   narration: 'The blade takes her shoulder, not her throat; she goes down cursing you.',
+ *   resolves: ['k1'],
+ * }
+ * ```
+ */
+export const RetconDTOSchema = object({
+    id: string(),
+    kind: RetconKindSchema,
+    /** The turn being amended. */
+    target: ThreadTurnRefSchema,
+    /** Why the amendment is needed, in the merge agent's own words. */
+    reason: string(),
+    /** Replacement prose, for `amend-narration`. */
+    narration: optional(string()),
+    /** The reconciling sentence, for `annotate`. */
+    note: optional(string()),
+    /** Memories the merged canon has made false, for `supersede-memory`. */
+    memoryIds: optional(array(string())),
+    /** Canon position the turn should hold, for `reorder`. */
+    sequence: optional(number()),
+    /** The {@link ContradictionDTO} ids this amendment answers. */
+    resolves: array(string()),
+});
+/**
+ * One merge: the threads that converged, what disagreed, what was amended, and
+ * the order the canon ended up in.
+ *
+ * `order` is the whole merge decision made explicit. Threads produce turns
+ * concurrently and their timestamps say only when a model finished, which is
+ * not when a thing happened; the merge agent decides the sequence the canon
+ * reads in and records it, so a replay is deterministic without re-asking a
+ * model what order the day went in.
+ *
+ * @example
+ * ```ts
+ * import type { ThreadMergeReviewPayload } from '@game-infra/game-state-schemas'
+ *
+ * const review: ThreadMergeReviewPayload = {
+ *   id: 'merge-0003',
+ *   threadIds: ['the-coast-raid', 'the-ledger'],
+ *   baseSequence: 12,
+ *   order: [
+ *     { threadId: 'the-ledger', sequence: 0 },
+ *     { threadId: 'the-coast-raid', sequence: 0 },
+ *   ],
+ *   contradictions: [],
+ *   retcons: [],
+ *   summary: 'Two scenes, one afternoon, nothing in conflict.',
+ *   model: 'aion',
+ *   createdAt: '2026-08-31T09:31:00.000Z',
+ * }
+ * ```
+ */
+export const ThreadMergeReviewPayloadSchema = object({
+    id: string(),
+    /** The threads folded in, in the order they were opened. */
+    threadIds: array(string()),
+    /** Canon length the threads shared before the merge. */
+    baseSequence: number(),
+    /** The canon order the merge chose, one entry per turn folded in. */
+    order: array(ThreadTurnRefSchema),
+    contradictions: array(ContradictionDTOSchema),
+    retcons: array(RetconDTOSchema),
+    /** What the merge did, for a reader who does not want to read every retcon. */
+    summary: string(),
+    /** The model that reviewed the merge. */
+    model: string(),
+    createdAt: string(),
+});
+/**
+ * Where a run is. The three middle values are what a progressive client needs:
+ * they are the difference between "nothing to show yet", "there is prose on
+ * screen" and "the prose is final and the bookkeeping is still going".
+ *
+ * `settling` is the one worth spelling out. Chronicling and consolidation
+ * happen after the player is already reading, so the turn looks finished; but
+ * the next turn in the same thread must not start until they land, or it is
+ * adjudicated against a memory graph missing the turn before it.
+ */
+export const TURN_RUN_STATUSES = [
+    "queued",
+    "running",
+    "narrated",
+    "settling",
+    "completed",
+    "failed",
+    "cancelled",
+];
+export const TurnRunStatusSchema = picklist(TURN_RUN_STATUSES);
+/** Where one stage of a run is. `skipped` is a stage the turn did not need. */
+export const RUN_STAGE_STATUSES = ["pending", "running", "completed", "skipped", "failed"];
+export const RunStageStatusSchema = picklist(RUN_STAGE_STATUSES);
+/**
+ * One stage of a run, as the server checkpoints it.
+ *
+ * `attempt` is stored rather than derived because a resumed run has to know
+ * whether it is retrying or starting: a stage that has already burnt its
+ * retries should fail the run rather than loop for as long as the storage
+ * keeps the record.
+ */
+export const RunStageDTOSchema = object({
+    id: string(),
+    /** What to show a player waiting on it. */
+    label: string(),
+    /** Which agent does the work — or the engine, for a local stage. */
+    agent: string(),
+    /** The canonical model behind it, or `local` for a stage that asks nobody. */
+    model: string(),
+    status: RunStageStatusSchema,
+    /** Epoch milliseconds; absent until the stage starts. */
+    startedAt: optional(number()),
+    durationMs: optional(number()),
+    /** Total prompt tokens consumed by successful calls in this stage. */
+    inputTokens: optional(number()),
+    /** Total completion tokens produced by successful calls in this stage. */
+    outputTokens: optional(number()),
+    attempt: optional(number()),
+    error: optional(string()),
+});
+/**
+ * One turn's adjudication, owned by the server and readable at any moment.
+ *
+ * This is the record that makes a reload survivable. The work belongs to the
+ * service rather than to the tab that asked for it, every stage is written down
+ * as it finishes, and each output is published the moment it exists rather than
+ * at the end: `check` as soon as the dice are rolled, `narration` as soon as
+ * the prose lands, `effects` once the consequences are interpreted, `memories`
+ * once the chronicler has been. A client that reconnects renders whatever is
+ * already here and waits only for what is genuinely still missing.
+ *
+ * `leaseUntil` is how a stalled run is told from a slow one. A worker that dies
+ * mid-run leaves the record `running` forever otherwise, and nothing else dares
+ * touch it; with a lease, whoever finds it expired may resume from the last
+ * completed stage.
+ *
+ * @example
+ * ```ts
+ * import type { TurnRunPayload } from '@game-infra/game-state-schemas'
+ *
+ * const run: TurnRunPayload = {
+ *   id: 'run-8f2c',
+ *   threadId: 'the-coast-raid',
+ *   sequence: 3,
+ *   input: 'I put my shoulder to the door and shout for Ilse.',
+ *   status: 'narrated',
+ *   stages: [
+ *     { id: 'assessment', label: 'Choosing whether and how to roll',
+ *       agent: 'Assessor', model: 'aion-mini', status: 'completed', durationMs: 1840 },
+ *   ],
+ *   traceId: 'turn-8f2c',
+ *   startedAt: '2026-08-31T09:12:00.000Z',
+ *   updatedAt: '2026-08-31T09:12:09.000Z',
+ * }
+ * ```
+ */
+export const TurnRunPayloadSchema = object({
+    id: string(),
+    threadId: string(),
+    /** The index this turn takes in its thread. */
+    sequence: number(),
+    /** What the player wrote. Empty on a session's opening turn. */
+    input: string(),
+    status: TurnRunStatusSchema,
+    /** Every stage, in execution order, whether or not it has run. */
+    stages: array(RunStageDTOSchema),
+    /** Joins every model call this run made. */
+    traceId: string(),
+    startedAt: string(),
+    updatedAt: string(),
+    /** Epoch milliseconds after which an unfinished run may be resumed by anyone. */
+    leaseUntil: optional(number()),
+    // Partial outputs, each published the moment it exists.
+    /** The neurons the assessor judged relevant. */
+    focus: optional(array(string())),
+    /** The roll — available before a word of prose has been written. */
+    check: optional(ResolvedCheckDTOSchema),
+    title: optional(string()),
+    narration: optional(string()),
+    effects: optional(array(ActivationDTOSchema)),
+    introduced: optional(array(IntroducedEntityDTOSchema)),
+    memories: optional(array(MemoryDTOSchema)),
+    consolidations: optional(array(ConsolidationDTOSchema)),
+    /** The model that narrated, once one has. */
+    model: optional(string()),
+    /** Milliseconds per named stage, as they complete. */
+    timings: optional(record(string(), number())),
+    /** Why the run failed, when it did. */
+    error: optional(string()),
+});
+//# sourceMappingURL=narrativeThreads.js.map

package/dist/narrativeThreads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrativeThreads.js","sourceRoot":"","sources":["../src/narrativeThreads.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@game-infra/game-state-schemas",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Play-state API contract: the sessions a player has in progress, the journal each one is rebuilt from, and freeform mode's turn and memory payloads",
   "homepage": "https://github.com/kibertoad/game-infra/tree/main/packages/schemas/game-state-schemas#readme",
   "bugs": {