@guuey/threads 0.31.1 → 0.33.0

package/dist/seal.js

@@ -0,0 +1,120 @@
+/**
+ * Sealed conversations: how a reader tells which messages of a thread the
+ * app's operator may not read.
+ *
+ * A thread may carry seal intervals ({@link ThreadRow.sealIntervals}). Each
+ * one covers the messages from `fromSeq` to `toSeq`, both inclusive; an
+ * interval without `toSeq` is still open, so it also covers every message
+ * written after it. The writer records the intervals in the same atomic
+ * update that allocates a message's seq, so a boundary always falls between
+ * two messages.
+ *
+ * The rules every reader applies:
+ *
+ *   - no `sealIntervals` attribute: a legacy thread, wholly readable;
+ *   - a well-formed list: a message is sealed when any interval covers its seq;
+ *   - an attribute that is present but not a well-formed list: the reader
+ *     cannot tell which messages it covers, so the WHOLE thread reads as
+ *     sealed (fail closed, never open).
+ *
+ * The functions here are pure. They take the stored attribute as it came off
+ * the row, so a reader never trusts a shape it did not check.
+ */
+import { createHash } from "node:crypto";
+function isSeq(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function readInterval(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    if (!("fromSeq" in value))
+        return undefined;
+    const fromSeq = value.fromSeq;
+    if (!isSeq(fromSeq))
+        return undefined;
+    const toSeq = "toSeq" in value ? value.toSeq : undefined;
+    if (toSeq === undefined)
+        return { fromSeq };
+    if (!isSeq(toSeq) || toSeq < fromSeq)
+        return undefined;
+    return { fromSeq, toSeq };
+}
+/**
+ * Check a stored `sealIntervals` attribute. Absent (`undefined` or `null`) is
+ * a legacy thread; anything else must be an array of well-formed intervals,
+ * or the whole thread reads as sealed.
+ */
+export function readSealState(stored) {
+    if (stored === undefined || stored === null)
+        return { kind: "none" };
+    if (!Array.isArray(stored))
+        return { kind: "unreadable" };
+    const intervals = [];
+    for (const entry of stored) {
+        const interval = readInterval(entry);
+        if (interval === undefined)
+            return { kind: "unreadable" };
+        intervals.push(interval);
+    }
+    return { kind: "intervals", intervals };
+}
+/** Whether the message at `seq` is sealed under `state`. */
+export function isSeqSealed(state, seq) {
+    if (state.kind === "none")
+        return false;
+    if (state.kind === "unreadable")
+        return true;
+    return state.intervals.some((interval) => seq >= interval.fromSeq && (interval.toSeq === undefined || seq <= interval.toSeq));
+}
+/**
+ * Whether ANY part of the thread is, or was, sealed. A copy built from the
+ * whole conversation (a model-written summary, a report) is refused when this
+ * is true, since it may carry sealed messages whatever message triggered it.
+ */
+export function hasSealedPart(state) {
+    if (state.kind === "none")
+        return false;
+    if (state.kind === "unreadable")
+        return true;
+    return state.intervals.length > 0;
+}
+/**
+ * The digest a writer stores beside a preview (`lastMessagePreviewDigest`), in
+ * the same update that sets the preview and its source seq. It binds the seq to
+ * the text: a writer that replaces the preview without stamping its seq (one
+ * from before the stamp) leaves a digest that no longer matches, so a reader
+ * cannot mistake the old seq for the new text's source.
+ */
+export function previewDigest(preview) {
+    return createHash("sha256").update(preview, "utf8").digest("hex").slice(0, 32);
+}
+/**
+ * The preview an operator-side reader may show: the stored preview, or `''`
+ * when the message it was taken from is sealed. On a thread with any sealed
+ * part, a preview whose source the reader cannot place is withheld too: no
+ * recorded seq, or a digest absent or not matching the stored text (an older
+ * writer replaced the text and left the previous seq beside it). A thread with
+ * no sealed part shows its preview as stored.
+ *
+ * One case reads as placed though it is not: an older writer that stored the
+ * very same text again. The text is then that of the stamped, readable
+ * message, so nothing new is shown.
+ */
+export function readableThreadPreview(row) {
+    const preview = row.lastMessagePreview ?? "";
+    if (preview.length === 0)
+        return "";
+    const state = readSealState(row.sealIntervals);
+    if (!hasSealedPart(state))
+        return preview;
+    const source = row.lastMessagePreviewSeq;
+    if (!isSeq(source))
+        return "";
+    if (row.lastMessagePreviewDigest !== previewDigest(preview))
+        return "";
+    return isSeqSealed(state, source) ? "" : preview;
+}
+/** {@link readSealState} over a typed {@link ThreadRow}. */
+export function threadSealState(row) {
+    return readSealState(row.sealIntervals);
+}

package/dist/snapshot-plan.d.ts

@@ -0,0 +1,61 @@
+/**
+ * guuey#2120 — the thread snapshot is planned against the store's
+ * {@link RowBudget} before a turn writes any row, the way guuey#1794 plans the
+ * rows. A snapshot carrying a value its store cannot hold used to fail
+ * `putSnapshot` AFTER the rows were written: the turn's sentinel was already
+ * claimed, so the snapshot was never retried, and a `workingState` value the
+ * next turn re-wrote failed every later snapshot too.
+ *
+ * The plan never fails. What cannot be stored is left out, and said so:
+ *
+ * - a `workingState` carrying a number the store cannot hold is refused as
+ *   one update: the snapshot keeps the state the turn was seeded with;
+ * - a thread-memory element carrying such a number is left out;
+ * - over the size budget, the turn's working state is refused first (it is
+ *   one opaque blob) when the seeded state is smaller, so the swap shrinks
+ *   the row; then the thread-memory records this turn wrote or
+ *   changed are left out, largest first. A record stored unchanged from the
+ *   prior snapshot, and every carried element, stays: they were stored before.
+ * - a snapshot that still does not fit is not written; the prior one stands.
+ *
+ * Pure: no I/O. Counts only in the report, never a value.
+ */
+import type { AgMemoryRecord, JsonValue } from "@silverprotocol/core";
+import type { RowBudget, ThreadSnapshotRow } from "./rows.js";
+/** Why part of a snapshot was not stored: a number its store cannot hold, or its size. */
+export type SnapshotRefusalReason = "number" | "size";
+/** What a planned snapshot left out (guuey#2120). Counts only. */
+export interface SnapshotRefusal {
+    /**
+     * The turn's working state was not stored, and why. The snapshot keeps the
+     * state the turn was seeded with ({@link PlanSnapshotInput.priorWorkingState}),
+     * or none when it had none.
+     */
+    state?: SnapshotRefusalReason;
+    /** Thread-memory elements left out because they carried a number the store cannot hold. */
+    memoryNumber: number;
+    /** Thread-memory records this turn wrote, left out so the snapshot fits. */
+    memorySize: number;
+    /** True when the snapshot could not fit even so and is not written: the prior snapshot stands. */
+    notWritten: boolean;
+}
+export interface PlanSnapshotInput {
+    /** The snapshot the turn would write. */
+    row: ThreadSnapshotRow;
+    /** The working state the turn was seeded with; absent = none. */
+    priorWorkingState?: JsonValue;
+    /** The thread records the turn was seeded with (`keepUnchangedThreadMemory` keeps an unchanged one by identity). */
+    priorThreadMemory?: readonly AgMemoryRecord[];
+}
+export interface PlannedSnapshot {
+    /** The snapshot to write, or `undefined` when it cannot be stored at all. */
+    row: ThreadSnapshotRow | undefined;
+    /** Set when anything was left out. */
+    refusal?: SnapshotRefusal;
+}
+/**
+ * Plan `input.row` under `budget` (see the module comment). Without a budget
+ * the row is returned as it is.
+ */
+export declare function planSnapshot(input: PlanSnapshotInput, budget: RowBudget | undefined): PlannedSnapshot;
+//# sourceMappingURL=snapshot-plan.d.ts.map

package/dist/snapshot-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-plan.d.ts","sourceRoot":"","sources":["../src/snapshot-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9D,0FAA0F;AAC1F,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtD,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,2FAA2F;IAC3F,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC;IACnB,kGAAkG;IAClG,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,GAAG,EAAE,iBAAiB,CAAC;IACvB,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B,oHAAoH;IACpH,iBAAiB,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,GAAG,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACnC,sCAAsC;IACtC,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAQD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,eAAe,CA4DrG"}

package/dist/snapshot-plan.js

@@ -0,0 +1,71 @@
+import { carriesUnfitNumber, jsonEqual } from "./fold-rows.js";
+/** `row` with `workingState` set to `state`, or without it when `state` is undefined. */
+function withState(row, state) {
+    const { workingState: _dropped, ...rest } = row;
+    return state === undefined ? rest : { ...rest, workingState: state };
+}
+/**
+ * Plan `input.row` under `budget` (see the module comment). Without a budget
+ * the row is returned as it is.
+ */
+export function planSnapshot(input, budget) {
+    if (budget === undefined)
+        return { row: input.row };
+    const fits = budget.numberFits;
+    const unfit = (value) => fits !== undefined && carriesUnfitNumber(value, fits);
+    // The seeded state was read back from the store, so it can be stored; the
+    // check only keeps a binding that held an unfit one from writing it again.
+    const prior = unfit(input.priorWorkingState) ? undefined : input.priorWorkingState;
+    let state;
+    let row = input.row;
+    if (row.workingState !== undefined && unfit(row.workingState)) {
+        state = "number";
+        row = withState(row, prior);
+    }
+    let memoryNumber = 0;
+    const threadMemory = row.threadMemory.filter((rec) => {
+        if (!unfit(rec))
+            return true;
+        memoryNumber++;
+        return false;
+    });
+    const carried = (row.carriedThreadMemory ?? []).filter((el) => {
+        if (!unfit(el))
+            return true;
+        memoryNumber++;
+        return false;
+    });
+    const { carriedThreadMemory: _carried, ...rest } = row;
+    row = { ...rest, threadMemory, ...(carried.length > 0 ? { carriedThreadMemory: carried } : {}) };
+    let memorySize = 0;
+    if (budget.bytesOf(row) > budget.maxBytes && state === undefined && !jsonEqual(row.workingState, prior)) {
+        // Only a swap that shrinks the row: a prior state larger than this turn's
+        // would grow it, drop more records than needed and lose a state that fits.
+        const swapped = withState(row, prior);
+        if (budget.bytesOf(swapped) < budget.bytesOf(row)) {
+            state = "size";
+            row = swapped;
+        }
+    }
+    if (budget.bytesOf(row) > budget.maxBytes) {
+        const seeded = new Set(input.priorThreadMemory ?? []);
+        const written = row.threadMemory
+            .filter((rec) => !seeded.has(rec))
+            .map((rec) => ({ rec, bytes: budget.bytesOf({ threadId: "", userId: "", updatedAt: "", threadMemory: [rec] }) }))
+            .sort((a, b) => b.bytes - a.bytes);
+        for (const { rec } of written) {
+            memorySize++;
+            row = { ...row, threadMemory: row.threadMemory.filter((r) => r !== rec) };
+            if (budget.bytesOf(row) <= budget.maxBytes)
+                break;
+        }
+    }
+    const notWritten = budget.bytesOf(row) > budget.maxBytes;
+    const refused = state !== undefined || memoryNumber > 0 || memorySize > 0 || notWritten;
+    return {
+        row: notWritten ? undefined : row,
+        ...(refused
+            ? { refusal: { ...(state !== undefined ? { state } : {}), memoryNumber, memorySize, notWritten } }
+            : {}),
+    };
+}

package/dist/store.d.ts

@@ -1,5 +1,8 @@
 import type { AgMemoryRecord, AgReduceResult, JsonValue } from "@silverprotocol/core";
-import type { ThreadMessageEvent, StoredHistoryMessage, ThreadMessageKind, ThreadMessageRole, ThreadPersistencePort, ThreadSnapshotRow, TurnOrigin, ClientClass } from "./rows.js";
+import { type ElidedField, type ElisionReason, type RefusedRowKind } from "./fold-rows.js";
+import { type SnapshotRefusal } from "./snapshot-plan.js";
+import { type TapLabels } from "@guuey/mcp-apps-host/narrowing";
+import type { ThreadMessageEvent, StoredHistoryMessage, ThreadMessageKind, ThreadMessageRole, ThreadClosure, ThreadPersistencePort, ThreadSnapshotRow, TurnOrigin, ClientClass, ThreadInputKind } from "./rows.js";
 export interface EnsureThreadInput {
     /** Client-supplied thread id (localStorage). Absent on first contact. */
     threadId?: string;
@@ -35,10 +38,21 @@ export interface AppendMessageInput {
     event?: ThreadMessageEvent;
     /** A user row's origin (see {@link ThreadMessageRow.turnOrigin}); carried verbatim. */
     turnOrigin?: TurnOrigin;
+    /** guuey#2549: a user row whose empty text means its content rode on the page context; carried verbatim. */
+    inputKind?: ThreadInputKind;
     /** A `card_action` user row's answered card session id; carried verbatim. */
     answeredCardSessionId?: string;
     /** A user row's client class (see {@link ThreadMessageRow.clientClass}); carried verbatim. */
     clientClass?: ClientClass;
+    /**
+     * A card-action user row's tap labels (see {@link ThreadMessageRow.tapLabels}).
+     * The store re-judges them by the writer contract (`writeTapLabels`) before
+     * it writes: a list the contract refuses is not stored (the row lands
+     * without the key, so it draws the continuation copy), and an admitted one is
+     * stored as the writer's fresh copy. The reader contract is a display guard,
+     * never a store's check.
+     */
+    tapLabels?: TapLabels;
 }
 export interface AppendMessageResult {
     seq: number;
@@ -77,7 +91,55 @@ export interface AppendFoldInput {
      * the fold's rebuild of it. Absent = the fold's records as they are.
      */
     priorThreadMemory?: readonly AgMemoryRecord[];
+    /**
+     * guuey#2120: the prior snapshot's `workingState`: the state the reducer was
+     * seeded with. When the turn's state cannot be stored (a number its store
+     * cannot hold, or a snapshot over the row budget), the snapshot keeps this
+     * one instead and the result reports `refusedSnapshot.state`. Absent = none.
+     */
+    priorWorkingState?: JsonValue;
+    /**
+     * guuey#1794: what to store when a row of this turn cannot be stored even
+     * with its tool-call values elided: it does not fit the store's row budget,
+     * or it carries a number the store cannot hold. Given, the turn is stored
+     * as ONE agent row carrying this text and the failure code
+     * `stored_turn_too_large` or `stored_turn_unstorable_number` (under the
+     * turn sentinel, so the turn is final), and the result reports
+     * `unstorable`. Absent, `appendFold` throws the refusal
+     * ({@link StoredRowTooLargeError} or `StoredRowUnstorableNumberError`).
+     * Either way no other row of the turn is written.
+     */
+    unstorableNotice?: {
+        text: string;
+    };
 }
+/** One value stored as the elided marker (guuey#1794); see {@link ElidedField}. */
+export interface ElidedToolInput {
+    /** The seq of the message row that carries the marker. */
+    seq: number;
+    toolCallId: string;
+    /** The tool's name (for a `uiData` elision, the name its card row stores). */
+    name: string;
+    field: ElidedField;
+    reason: ElisionReason;
+    /** UTF-8 length of the elided value's JSON. */
+    bytes: number;
+}
+/** The turn was stored as its one failure row (see {@link AppendFoldInput.unstorableNotice}). */
+export type AppendFoldUnstorable = {
+    /** The failure row's seq. */
+    seq: number;
+    /** The first row that could not be stored. */
+    rowKind: RefusedRowKind;
+    index: number;
+} & ({
+    reason: 'size';
+    /** That row as its store measured it. */
+    bytes: number;
+    maxBytes: number;
+} | {
+    reason: 'number';
+});
 export interface AppendFoldResult {
     messageSeqs: number[];
     artifactSeqs: number[];
@@ -88,7 +150,26 @@ export interface AppendFoldResult {
      * WHOLE fold-persist was short-circuited (no rows written this call).
      */
     deduped: boolean;
+    /**
+     * Values stored as the elided marker so their rows fit (tool-call inputs, and
+     * tool-result UI resources a card row of the turn carries); `[]` when none.
+     */
+    elidedToolInputs: ElidedToolInput[];
+    /** Set when the turn was stored as its one failure row instead of its rows. */
+    unstorable?: AppendFoldUnstorable;
+    /**
+     * guuey#2120: set when part of the turn's snapshot could not be stored and
+     * was left out (planned before any row was written; see `planSnapshot`).
+     */
+    refusedSnapshot?: SnapshotRefusal;
 }
+/** The failure code of a turn stored as one row because it could not fit (guuey#1794). */
+export declare 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 declare const STORED_TURN_UNSTORABLE_NUMBER_CODE = "stored_turn_unstorable_number";
 export declare class ThreadStore {
     private readonly db;
     constructor(db: ThreadPersistencePort);
@@ -105,6 +186,9 @@ export declare 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.
      */
     ensureThread(input: EnsureThreadInput): Promise<string>;
     /**
@@ -113,9 +197,24 @@ export declare 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.
      */
     ownsThread(threadId: string, userId: string): Promise<boolean>;
+    /**
+     * 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(): boolean;
+    /**
+     * 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.
+     */
+    closeThread(threadId: string, closure: ThreadClosure): Promise<"closed" | "already_closed" | "unsupported">;
     /** Prior messages for the thread (seq-ASC, capped to the most recent N). */
     loadHistory(threadId: string, limit?: number): Promise<StoredHistoryMessage[]>;
     /**
@@ -143,7 +242,36 @@ export declare 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.
      */
     appendFold(input: AppendFoldInput): Promise<AppendFoldResult>;
+    /**
+     * 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.
+     */
+    private planFoldSnapshot;
+    /** Write a planned snapshot, stamped now (the same length as the provisional stamp it was measured with). */
+    private writeSnapshot;
+    /**
+     * 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.
+     */
+    private writeUnstorableMarker;
+    /**
+     * 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.
+     */
+    private planFoldRows;
 }
 //# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

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