@guuey/threads 0.31.1 → 0.33.0

package/dist/store.js

@@ -8,11 +8,26 @@
  * DynamoDB).
  */
 import { randomUUID } from "node:crypto";
-import { agMessageToRow, agArtifactToCardRow, keepUnchangedThreadMemory, producingToolName, toolNamesByCallId, uiCardArtifactsFromMessages, storedTextParts, } from "./fold-rows.js";
+import { agMessageToBoundedRow, agArtifactToCardRow, assertRowFits, cardUiDataByCallId, isStoredRowRefusal, StoredRowTooLargeError, keepUnchangedThreadMemory, producingMessageIndex, producingToolName, toolNamesByCallId, toolResultMessageIndexByCallId, uiCardArtifactsFromMessages, storedTextParts, } from "./fold-rows.js";
 import { classifyStoredRow } from "./stored-row.js";
+import { threadClosure } from "./closed.js";
+import { planSnapshot } from "./snapshot-plan.js";
+import { writeTapLabels } from "@guuey/mcp-apps-host/narrowing";
 /** Max history messages fed back as context — bounds latency on long threads. */
 const DEFAULT_HISTORY_LIMIT = 40;
 const PREVIEW_MAX_LEN = 240;
+/** The failure code of a turn stored as one row because it could not fit (guuey#1794). */
+export const STORED_TURN_TOO_LARGE_CODE = 'stored_turn_too_large';
+/**
+ * The failure code of a turn stored as one row because a row of it carried a
+ * number its store cannot hold, outside any tool-call value (guuey#1794).
+ */
+export const STORED_TURN_UNSTORABLE_NUMBER_CODE = 'stored_turn_unstorable_number';
+/**
+ * The seq a planned row is measured with before its real seq is allocated:
+ * no real seq has more digits, so the real row is never larger.
+ */
+const PROVISIONAL_SEQ = Number.MAX_SAFE_INTEGER;
 // ───────────────────────────────────────────────────────────────────────
 // ThreadStore — the logic.
 // ───────────────────────────────────────────────────────────────────────
@@ -34,14 +49,17 @@ export class ThreadStore {
      * continues on a new conversation) AND safe — the caller never sees another
      * user's thread, and there's no existence oracle. The pod never honours a
      * client-chosen id, so squatting is impossible.
+     *
+     * A CLOSED thread ({@link ThreadRow.closedAt}) is answered the same way: it
+     * takes no new message, so a send on it starts a new conversation.
      */
     async ensureThread(input) {
         if (input.threadId) {
             const existing = await this.db.getThread(input.threadId);
-            if (existing && existing.userId === input.userId) {
+            if (existing && existing.userId === input.userId && threadClosure(existing) === undefined) {
                 return existing.id;
             }
-            // Not found OR owned by a different identity → fall through, mint fresh.
+            // Not found, owned by a different identity, OR closed → fall through, mint fresh.
         }
         const now = new Date().toISOString();
         const row = {
@@ -68,11 +86,33 @@ export class ThreadStore {
      * exposed for doors that must BIND a client-echoed thread to the verified
      * caller without minting anything (the pod's consent-answer door binds a
      * `once` grant to a thread this way — guuey#207). No existence oracle: a
-     * missing thread and another user's thread are the same `false`.
+     * missing thread and another user's thread are the same `false`, and so is
+     * a closed one: nothing binds to a conversation that has ended.
      */
     async ownsThread(threadId, userId) {
         const existing = await this.db.getThread(threadId);
-        return existing !== undefined && existing.userId === userId;
+        return existing !== undefined && existing.userId === userId && threadClosure(existing) === undefined;
+    }
+    /**
+     * Whether this binding can close a thread ({@link ThreadPersistencePort.closeThread}
+     * present). A caller that writes something before closing (a closing
+     * message) reads this first, so a binding that cannot close is left as it was.
+     */
+    canCloseThreads() {
+        return this.db.closeThread !== undefined;
+    }
+    /**
+     * End the conversation (see {@link ThreadRow.closedAt}): `closed` when this
+     * call closed it, `already_closed` when it was closed before (the first
+     * closure is kept), `unsupported` when the binding cannot close
+     * ({@link ThreadPersistencePort.closeThread} absent; nothing changes).
+     * Rejects for a missing thread or a store failure.
+     */
+    async closeThread(threadId, closure) {
+        const close = this.db.closeThread;
+        if (close === undefined)
+            return "unsupported";
+        return close.call(this.db, threadId, closure);
     }
     /** Prior messages for the thread (seq-ASC, capped to the most recent N). */
     async loadHistory(threadId, limit = DEFAULT_HISTORY_LIMIT) {
@@ -91,7 +131,9 @@ export class ThreadStore {
         // since narration split out of it, so reading `text` here would change what
         // the model is replayed. For rows written before the split, `all` is the same
         // bytes their `text` holds. A row whose content is not a stored AgMessage
-        // (an event, a managed-adapter row) keeps its `text`.
+        // (an event, a managed-adapter row) keeps its `text`. A stored message whose
+        // answer block is elided (its `text` the elided marker) replays
+        // the row's `text` as that answer, in place.
         //
         // Only CONVERSATION reaches this lane: a failed turn's reader line, a
         // framework notice and a blank agent message are stored rows, never words
@@ -107,9 +149,10 @@ export class ThreadStore {
             seq: r.seq,
             authorRole: r.authorRole,
             kind: r.kind,
-            text: storedTextParts(r.content)?.all || (r.text ?? null),
+            text: storedTextParts(r.content, r.text)?.all || (r.text ?? null),
             content: r.content ?? null,
             at: r.at,
+            ...(r.inputKind !== undefined ? { inputKind: r.inputKind } : {}),
         }));
         return conversation;
     }
@@ -124,11 +167,22 @@ export class ThreadStore {
             return { seq: prior.seq, deduped: true };
         }
         const now = new Date().toISOString();
-        const preview = input.text ? input.text.slice(0, PREVIEW_MAX_LEN) : '';
-        const seq = await this.db.incrementSeq(input.threadId, preview, now);
-        const row = {
+        // An event row (a hand-off, a report) is a record ABOUT the conversation,
+        // written from all of it (a model-written ask or summary), not a message in
+        // it: like a card row it leaves the prior preview standing (null), so the
+        // conversation list never shows a copy drawn from the whole thread.
+        // guuey#2549: a turn without words has no words to preview either, so it
+        // also leaves the prior preview standing rather than blanking it.
+        const preview = input.event !== undefined || input.inputKind !== undefined
+            ? null
+            : input.text
+                ? input.text.slice(0, PREVIEW_MAX_LEN)
+                : '';
+        // guuey#2031: the store re-judges a row's tap labels; it never trusts its caller's check.
+        const tapLabels = input.tapLabels !== undefined ? writeTapLabels(input.tapLabels) : undefined;
+        const draft = {
             threadId: input.threadId,
-            seq,
+            seq: PROVISIONAL_SEQ,
             userId: input.userId,
             clientMessageId: input.clientMessageId,
             at: now,
@@ -139,10 +193,16 @@ export class ThreadStore {
             ...(input.untrustedOrigin === true ? { untrustedOrigin: true } : {}),
             ...(input.event !== undefined ? { event: input.event } : {}),
             ...(input.turnOrigin !== undefined ? { turnOrigin: input.turnOrigin } : {}),
+            ...(input.inputKind !== undefined ? { inputKind: input.inputKind } : {}),
             ...(input.answeredCardSessionId !== undefined ? { answeredCardSessionId: input.answeredCardSessionId } : {}),
             ...(input.clientClass !== undefined ? { clientClass: input.clientClass } : {}),
+            ...(tapLabels !== undefined ? { tapLabels } : {}),
         };
-        await this.db.putMessage(row);
+        // guuey#1794: measured before the seq is allocated, so an oversized row
+        // spends no seq. The real seq is never longer than the provisional one.
+        assertRowFits(draft, this.db.rowBudget, 'append', 0);
+        const seq = await this.db.incrementSeq(input.threadId, preview, now);
+        await this.db.putMessage({ ...draft, seq });
         return { seq, deduped: false };
     }
     /** The thread's latest fold snapshot, or undefined when none persisted yet. */
@@ -166,45 +226,163 @@ export class ThreadStore {
      * Durable (non-thread) memory is logged-and-dropped in v1. `skipSnapshot`
      * suppresses the snapshot upsert so a degraded/parked fold never overwrites
      * a good snapshot.
+     *
+     * The snapshot is planned with the rows, before any row is written
+     * (guuey#2120): a working state its store cannot hold is refused (the
+     * snapshot keeps `priorWorkingState`), and a memory element that cannot be
+     * stored is left out, reported as `refusedSnapshot`. The snapshot write is
+     * never the write that fails after the turn's rows landed.
      */
     async appendFold(input) {
-        const { threadId, userId, fold, clientMessageIdBase, skipSnapshot } = input;
+        const { threadId, clientMessageIdBase } = input;
         // Turn-level idempotency gate: a committed agent turn is never re-merged.
         const sentinelKey = `${clientMessageIdBase}#agentTurn`;
         const existing = await this.db.findByClientMessageId(threadId, sentinelKey);
         if (existing) {
-            return { messageSeqs: [existing.seq], artifactSeqs: [], droppedDurableMemory: 0, deduped: true };
+            return { messageSeqs: [existing.seq], artifactSeqs: [], droppedDurableMemory: 0, deduped: true, elidedToolInputs: [] };
+        }
+        // guuey#1794 — plan every row of the turn, then write. Nothing is written
+        // (no seq spent, no sentinel claimed) until every row is known to fit the
+        // store's row budget: a row that failed mid-loop used to leave a partial
+        // turn whose sentinel short-circuited every retry. Planned rows carry a
+        // provisional seq and timestamp no smaller than the real ones, so the real
+        // values can only shrink a row that fit.
+        const provisionalAt = new Date().toISOString();
+        // guuey#2120 — the snapshot is planned with the rows: what its store
+        // cannot hold is left out here, before any row is written, so the
+        // snapshot write that follows the rows is never the one that fails.
+        const snapshot = this.planFoldSnapshot(input, provisionalAt);
+        const planned = [];
+        try {
+            this.planFoldRows(input, sentinelKey, provisionalAt, planned);
+        }
+        catch (err) {
+            if (!isStoredRowRefusal(err) || input.unstorableNotice === undefined)
+                throw err;
+            return this.writeUnstorableMarker(input, input.unstorableNotice, sentinelKey, err, snapshot);
         }
         const messageSeqs = [];
         const artifactSeqs = [];
-        // Whichever row is written first claims the sentinel key.
-        let sentinelClaimed = false;
-        for (let i = 0; i < fold.messages.length; i++) {
-            const msg = fold.messages[i];
-            const clientMessageId = sentinelClaimed ? `${clientMessageIdBase}#agent#${i}` : sentinelKey;
-            sentinelClaimed = true;
-            // The preview is the ANSWER: interim narration (`phase: "interim"`) never becomes a thread's preview,
-            // and neither does a framework notice (a non-conversational row).
-            const text = msg.role === 'notice'
-                ? ''
-                : msg.content.reduce((acc, b) => (b.type === 'text' && b.phase !== 'interim' ? acc + b.text : acc), '');
+        const elidedToolInputs = [];
+        for (const p of planned) {
             const now = new Date().toISOString();
-            // Text-less agent messages (tool-call + tool-result only — the canonical
-            // card-producing turn) must not blank the preview: '' takes the SET
-            // branch, null leaves the prior preview standing.
-            const seq = await this.db.incrementSeq(threadId, text ? text.slice(0, PREVIEW_MAX_LEN) : null, now);
-            const turnRecord = fold.turns.find((t) => t.turnId === msg.turnId);
-            await this.db.putMessage(agMessageToRow(msg, {
-                threadId,
-                userId,
-                seq,
-                at: now,
-                clientMessageId,
-                ...(turnRecord ? { turnRecord } : {}),
-                ...(input.untrustedOrigin === true ? { untrustedOrigin: true } : {}),
-            }));
-            messageSeqs.push(seq);
+            const seq = await this.db.incrementSeq(threadId, p.preview, now);
+            await this.db.putMessage({ ...p.row, seq, at: now });
+            (p.kind === 'message' ? messageSeqs : artifactSeqs).push(seq);
+            for (const e of p.elided) {
+                elidedToolInputs.push({ seq, toolCallId: e.toolCallId, name: e.name, field: e.field, reason: e.reason, bytes: e.bytes });
+            }
         }
+        await this.writeSnapshot(snapshot);
+        return {
+            messageSeqs,
+            artifactSeqs,
+            droppedDurableMemory: snapshot.droppedDurableMemory,
+            deduped: false,
+            elidedToolInputs,
+            ...(snapshot.refusal !== undefined ? { refusedSnapshot: snapshot.refusal } : {}),
+        };
+    }
+    /**
+     * The snapshot a fold persists (working state + thread memory + last turn),
+     * planned under the store's row budget (guuey#2120). Writes nothing.
+     * `row` is undefined when `skipSnapshot` is set or the snapshot cannot be
+     * stored at all.
+     */
+    planFoldSnapshot(input, provisionalAt) {
+        const { fold } = input;
+        const threadMemory = keepUnchangedThreadMemory(input.priorThreadMemory ?? [], fold.memory.filter((m) => m.scope === 'thread'));
+        const droppedDurableMemory = fold.memory.length - threadMemory.length;
+        if (input.skipSnapshot === true)
+            return { row: undefined, droppedDurableMemory };
+        const lastTurnId = fold.turns.length ? fold.turns[fold.turns.length - 1].turnId : undefined;
+        const planned = planSnapshot({
+            row: {
+                threadId: input.threadId,
+                userId: input.userId,
+                threadMemory,
+                ...(input.carriedThreadMemory !== undefined && input.carriedThreadMemory.length > 0
+                    ? { carriedThreadMemory: [...input.carriedThreadMemory] }
+                    : {}),
+                updatedAt: provisionalAt,
+                ...(fold.state !== undefined ? { workingState: fold.state } : {}),
+                ...(lastTurnId ? { lastTurnId } : {}),
+            },
+            ...(input.priorWorkingState !== undefined ? { priorWorkingState: input.priorWorkingState } : {}),
+            ...(input.priorThreadMemory !== undefined ? { priorThreadMemory: input.priorThreadMemory } : {}),
+        }, this.db.rowBudget);
+        return {
+            row: planned.row,
+            droppedDurableMemory,
+            ...(planned.refusal !== undefined ? { refusal: planned.refusal } : {}),
+        };
+    }
+    /** Write a planned snapshot, stamped now (the same length as the provisional stamp it was measured with). */
+    async writeSnapshot(plan) {
+        if (plan.row === undefined)
+            return;
+        await this.db.putSnapshot({ ...plan.row, updatedAt: new Date().toISOString() });
+    }
+    /**
+     * The turn's one row when a row of it cannot be stored: the caller's notice
+     * text, under the turn sentinel (so a retry short-circuits and the turn is
+     * final), carrying the failure code readers classify as a failed turn
+     * (`stored_turn_too_large` with the counts, or `stored_turn_unstorable_number`).
+     * No other row of the turn is written.
+     */
+    async writeUnstorableMarker(input, notice, sentinelKey, err, snapshot) {
+        const { text } = notice;
+        const error = err instanceof StoredRowTooLargeError
+            ? { code: STORED_TURN_TOO_LARGE_CODE, bytes: err.bytes, maxBytes: err.maxBytes }
+            : { code: STORED_TURN_UNSTORABLE_NUMBER_CODE };
+        const now = new Date().toISOString();
+        const seq = await this.db.incrementSeq(input.threadId, text.slice(0, PREVIEW_MAX_LEN), now);
+        await this.db.putMessage({
+            threadId: input.threadId,
+            seq,
+            userId: input.userId,
+            clientMessageId: sentinelKey,
+            at: now,
+            kind: 'text',
+            authorRole: 'agent',
+            text,
+            content: {
+                kind: 'text',
+                text,
+                error,
+            },
+            ...(input.untrustedOrigin === true ? { untrustedOrigin: true } : {}),
+        });
+        await this.writeSnapshot(snapshot);
+        return {
+            messageSeqs: [],
+            artifactSeqs: [],
+            droppedDurableMemory: snapshot.droppedDurableMemory,
+            deduped: false,
+            elidedToolInputs: [],
+            ...(snapshot.refusal !== undefined ? { refusedSnapshot: snapshot.refusal } : {}),
+            unstorable: err instanceof StoredRowTooLargeError
+                ? { seq, rowKind: err.rowKind, index: err.index, reason: 'size', bytes: err.bytes, maxBytes: err.maxBytes }
+                : { seq, rowKind: err.rowKind, index: err.index, reason: 'number' },
+        };
+    }
+    /**
+     * Build every row a fold writes, in write order, with a provisional seq and
+     * timestamp, bounded by the store's row budget (throws a
+     * {@link StoredRowRefusal} when one cannot be stored). Writes nothing.
+     */
+    planFoldRows(input, sentinelKey, provisionalAt, planned) {
+        const { threadId, userId, fold, clientMessageIdBase } = input;
+        const budget = this.db.rowBudget;
+        const seq = PROVISIONAL_SEQ;
+        // Whichever row is written first claims the sentinel key: the first
+        // message, or the first card when the fold has no message. The WRITE
+        // order below interleaves the cards, and a card only ever follows a
+        // message, so the first row written is still the first row keyed.
+        const messageRows = [];
+        /** Per message index, the card rows drawn with it (guuey#2396). */
+        const cardsAfterMessage = new Map();
+        const tailCards = [];
         // Cards can arrive two ways: first-class artifact events (fold.artifacts)
         // or UI-carrying tool-result blocks inside messages (the Claude facet's
         // only channel — see uiCardArtifactsFromMessages). Persist both through
@@ -220,38 +398,68 @@ export class ThreadStore {
         // beside the snapshot. Unresolvable (a first-class artifact event with
         // no tool-result part) persists no name; readers fall back.
         const toolNames = toolNamesByCallId(fold.messages);
-        for (let i = 0; i < cardArtifacts.length; i++) {
-            const art = cardArtifacts[i];
-            const clientMessageId = sentinelClaimed ? `${clientMessageIdBase}#card#${i}` : sentinelKey;
-            sentinelClaimed = true;
-            const now = new Date().toISOString();
-            const seq = await this.db.incrementSeq(threadId, art.name ?? null, now);
-            await this.db.putMessage(agArtifactToCardRow(art, {
+        const cardRows = cardArtifacts.map((art, i) => agArtifactToCardRow(art, {
+            threadId,
+            userId,
+            seq,
+            at: provisionalAt,
+            clientMessageId: fold.messages.length > 0 || i > 0 ? `${clientMessageIdBase}#card#${i}` : sentinelKey,
+            ...(input.untrustedOrigin === true ? { untrustedOrigin: true } : {}),
+        }, producingToolName(art, toolNames)));
+        // The card rows are built before the message rows, so a message row over
+        // its budget can leave out a UI resource a card row of this turn carries
+        // whole (agMessageToBoundedRow).
+        const cards = cardUiDataByCallId(cardRows);
+        for (let i = 0; i < fold.messages.length; i++) {
+            const msg = fold.messages[i];
+            const clientMessageId = i > 0 ? `${clientMessageIdBase}#agent#${i}` : sentinelKey;
+            // The preview is the ANSWER: interim narration (`phase: "interim"`) never becomes a thread's preview,
+            // and neither does a framework notice (a non-conversational row).
+            const text = msg.role === 'notice'
+                ? ''
+                : msg.content.reduce((acc, b) => (b.type === 'text' && b.phase !== 'interim' ? acc + b.text : acc), '');
+            const turnRecord = fold.turns.find((t) => t.turnId === msg.turnId);
+            const { row, elided } = agMessageToBoundedRow(msg, {
                 threadId,
                 userId,
                 seq,
-                at: now,
+                at: provisionalAt,
                 clientMessageId,
+                ...(turnRecord ? { turnRecord } : {}),
                 ...(input.untrustedOrigin === true ? { untrustedOrigin: true } : {}),
-            }, producingToolName(art, toolNames)));
-            artifactSeqs.push(seq);
+            }, budget, i, cards);
+            // Text-less agent messages (tool-call + tool-result only — the canonical
+            // card-producing turn) must not blank the preview: '' takes the SET
+            // branch, null leaves the prior preview standing.
+            messageRows.push({ kind: 'message', row, preview: text ? text.slice(0, PREVIEW_MAX_LEN) : null, elided });
         }
-        const threadMemory = keepUnchangedThreadMemory(input.priorThreadMemory ?? [], fold.memory.filter((m) => m.scope === 'thread'));
-        const droppedDurableMemory = fold.memory.length - threadMemory.length;
-        if (skipSnapshot !== true) {
-            const lastTurnId = fold.turns.length ? fold.turns[fold.turns.length - 1].turnId : undefined;
-            await this.db.putSnapshot({
-                threadId,
-                userId,
-                threadMemory,
-                ...(input.carriedThreadMemory !== undefined && input.carriedThreadMemory.length > 0
-                    ? { carriedThreadMemory: [...input.carriedThreadMemory] }
-                    : {}),
-                updatedAt: new Date().toISOString(),
-                ...(fold.state !== undefined ? { workingState: fold.state } : {}),
-                ...(lastTurnId ? { lastTurnId } : {}),
-            });
+        const resultIndices = toolResultMessageIndexByCallId(fold.messages);
+        for (let i = 0; i < cardArtifacts.length; i++) {
+            const art = cardArtifacts[i];
+            const row = cardRows[i];
+            assertRowFits(row, budget, 'card', i);
+            const card = { kind: 'card', row, preview: art.name ?? null, elided: [] };
+            const anchor = producingMessageIndex(art, resultIndices);
+            if (anchor === undefined) {
+                tailCards.push(card);
+            }
+            else {
+                const after = cardsAfterMessage.get(anchor);
+                if (after === undefined)
+                    cardsAfterMessage.set(anchor, [card]);
+                else
+                    after.push(card);
+            }
         }
-        return { messageSeqs, artifactSeqs, droppedDurableMemory, deduped: false };
+        // guuey#2396: the stored order is the drawn order. A card is drawn when
+        // its tool-result arrives, so its row follows the message carrying that
+        // result, BEFORE any text the turn writes after it. Writing every message
+        // first and every card after it put a turn's closing text above the card
+        // it describes on every reload. A card with no producing result in the
+        // fold keeps the turn's tail, as before.
+        messageRows.forEach((message, index) => {
+            planned.push(message, ...(cardsAfterMessage.get(index) ?? []));
+        });
+        planned.push(...tailCards);
     }
 }

package/dist/stored-row.d.ts

@@ -11,14 +11,19 @@
  *  - a NOTICE row: a stored message with `role: "notice"` (a framework notice
  *    the agent facet emits), a non-conversational, user-facing row;
  *  - a BLANK row: an agent message whose every block shows the reader nothing
- *    (an empty text part, or a provider carry with nothing in it).
+ *    (an empty text part, or a provider carry with nothing in it). The
+ *    message is read as every row reader reads it (`readStoredRowMessage`,
+ *    fold-rows.ts): an answer block elided because the row's `text` carries
+ *    it reads as that `text`, and on a row with no `text` it is left out
+ *    (every other block still counts).
  *
  * The reader is lenient: it reads the stored `content` through the core's
  * stored-record reader, so a row written before any of this is classified the
  * same way, with no migration.
  */
-import { type AgBlock, type JsonValue } from "@silverprotocol/core";
+import type { AgBlock, JsonValue } from "@silverprotocol/core";
 import type { ThreadMessageRow } from "./rows.js";
+import { type StoredRowText } from "./fold-rows.js";
 /** The clientMessageId suffix the runtime gives a failed turn's reader-line row. */
 export declare const AGENT_ERROR_ROW_SUFFIX = "#agentError";
 /**
@@ -52,6 +57,15 @@ export type StoredRowClass = {
 } | {
     kind: "blank";
 };
+/**
+ * What {@link classifyStoredRow} reads of a row: a whole stored row, or the
+ * fields it reads. In the second shape `text` is required (`undefined` or null
+ * when the row has none): an elided answer reads from it, so a caller that picks
+ * the fields out of a row passes the row's `text` on purpose.
+ */
+export type ClassifiedRowInput = ThreadMessageRow | (Pick<ThreadMessageRow, "clientMessageId" | "authorRole" | "content"> & {
+    text: StoredRowText;
+});
 /** Classify one stored row (see the module doc). */
-export declare function classifyStoredRow(row: Pick<ThreadMessageRow, "clientMessageId" | "authorRole" | "content">): StoredRowClass;
+export declare function classifyStoredRow(row: ClassifiedRowInput): StoredRowClass;
 //# sourceMappingURL=stored-row.d.ts.map

package/dist/stored-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stored-row.d.ts","sourceRoot":"","sources":["../src/stored-row.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAuB,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAIpD;AAED,mCAAmC;AACnC,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE;AAC1B,+FAA+F;GAC7F;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAC1C,kFAAkF;GAChF;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAUtB,oDAAoD;AACpD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,IAAI,CAAC,gBAAgB,EAAE,iBAAiB,GAAG,YAAY,GAAG,SAAS,CAAC,GACxE,cAAc,CAWhB"}
+{"version":3,"file":"stored-row.d.ts","sourceRoot":"","sources":["../src/stored-row.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE1E,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAIpD;AAED,mCAAmC;AACnC,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE;AAC1B,+FAA+F;GAC7F;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAC1C,kFAAkF;GAChF;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAUtB;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAC1B,gBAAgB,GAChB,CAAC,IAAI,CAAC,gBAAgB,EAAE,iBAAiB,GAAG,YAAY,GAAG,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AAErG,oDAAoD;AACpD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,GAAG,cAAc,CAWzE"}

package/dist/stored-row.js

@@ -1,23 +1,4 @@
-/**
- * What a stored thread row IS, for every reader that turns rows back into
- * conversation. Some stored rows are not "the agent said this", and reading
- * them as such replays them to the model as the agent's own words and draws
- * them as answer bubbles:
- *
- *  - a FAILURE row: the runtime's reader line for a failed turn, keyed
- *    `…#agentError`. It carries `content.error.code` from the runtime release
- *    that added codes; rows written before it carry only `{kind:'text', text}`,
- *    so the key suffix alone must classify them too;
- *  - a NOTICE row: a stored message with `role: "notice"` (a framework notice
- *    the agent facet emits), a non-conversational, user-facing row;
- *  - a BLANK row: an agent message whose every block shows the reader nothing
- *    (an empty text part, or a provider carry with nothing in it).
- *
- * The reader is lenient: it reads the stored `content` through the core's
- * stored-record reader, so a row written before any of this is classified the
- * same way, with no migration.
- */
-import { readStoredAgMessage } from "@silverprotocol/core";
+import { readStoredRowMessage } from "./fold-rows.js";
 /** The clientMessageId suffix the runtime gives a failed turn's reader-line row. */
 export const AGENT_ERROR_ROW_SUFFIX = "#agentError";
 /**
@@ -68,7 +49,7 @@ export function classifyStoredRow(row) {
     }
     if (row.authorRole === "user")
         return { kind: "conversation" };
-    const stored = readStoredAgMessage(row.content).value;
+    const stored = readStoredRowMessage(row.content, row.text);
     if (stored === undefined)
         return { kind: "conversation" };
     if (stored.role === "notice")

package/dist/testing/contract-suite.d.ts

@@ -3,9 +3,45 @@ export interface ThreadPersistenceHarness {
     port: ThreadPersistencePort;
     cleanup?: () => void | Promise<void>;
 }
+/** What the binding under test claims beyond the required port. */
+export interface ThreadPersistenceContractOptions {
+    /**
+     * The binding implements `closeThread`: the suite then requires it and
+     * holds it to the close contract (a closure is recorded once, and a closed
+     * thread allocates no seq).
+     */
+    canClose?: boolean;
+}
 /**
  * Run the port contract against a binding. `make` must yield a FRESH,
  * empty store per call.
  */
-export declare function runThreadPersistenceContractSuite(name: string, make: () => Promise<ThreadPersistenceHarness>): void;
+export declare function runThreadPersistenceContractSuite(name: string, make: () => Promise<ThreadPersistenceHarness>, options?: ThreadPersistenceContractOptions): void;
+/**
+ * The error {@link withItemSizeLimit} rejects an oversized row with: the shape
+ * DynamoDB answers a too-large `PutItem` with.
+ */
+export declare class ItemSizeExceededError extends Error {
+    readonly bytes: number;
+    readonly name = "ValidationException";
+    constructor(bytes: number);
+}
+/**
+ * The error {@link withItemSizeLimit} rejects a row carrying a number DynamoDB
+ * cannot hold with: like the DocumentClient's own, its message names the number.
+ */
+export declare class UnstorableNumberError extends Error {
+    readonly value: number;
+    constructor(value: number);
+}
+/**
+ * Wrap a port so it behaves like a DynamoDB-backed binding on what a row may
+ * hold (guuey#1794): it declares the DynamoDB row budget, and its
+ * `putMessage` (and, guuey#2120, its `putSnapshot`) rejects a row over DynamoDB's 400 KB item limit (measured by
+ * `dynamoItemBytes`) with {@link ItemSizeExceededError}, and a row carrying a
+ * number DynamoDB cannot hold with {@link UnstorableNumberError}, instead of
+ * storing it. Run a `ThreadStore` over it to test what happens at those
+ * limits without a real table.
+ */
+export declare function withItemSizeLimit(port: ThreadPersistencePort): ThreadPersistencePort;
 //# sourceMappingURL=contract-suite.d.ts.map

package/dist/testing/contract-suite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract-suite.d.ts","sourceRoot":"","sources":["../../src/testing/contract-suite.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,qBAAqB,EAAa,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAiCD;;;GAGG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,OAAO,CAAC,wBAAwB,CAAC,GAC5C,IAAI,CA0KN"}
+{"version":3,"file":"contract-suite.d.ts","sourceRoot":"","sources":["../../src/testing/contract-suite.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,qBAAqB,EAAa,MAAM,YAAY,CAAC;AAInE,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,mEAAmE;AACnE,MAAM,WAAW,gCAAgC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiCD;;;GAGG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,OAAO,CAAC,wBAAwB,CAAC,EAC7C,OAAO,GAAE,gCAAqC,GAC7C,IAAI,CAmNN;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAGlC,QAAQ,CAAC,KAAK,EAAE,MAAM;IAFlC,SAAkB,IAAI,yBAAyB;gBAE1B,KAAK,EAAE,MAAM;CAGnC;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;CAGnC;AAYD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,qBAAqB,CA0BpF"}