@animalabs/agent-framework 0.32.0 → 0.34.0

package/dist/src/read-marks.js

@@ -0,0 +1,242 @@
+const HEAD = Symbol('read-mark head');
+const LENGTH = Symbol('read-mark length');
+function mark(branch, head, length) {
+    return Object.freeze({ branch, [HEAD]: head, [LENGTH]: length });
+}
+/**
+ * A mark of where `cm` stands now: its branch, the store's head (the
+ * chronicle head, not the slot's last row: in legacy mode a compile reads
+ * everything stored on the branch that its view keeps, rows merged in from
+ * another slot included; a double without a store gives its last row's
+ * sequence), and
+ * its index length when it is in presented mode, where a compile reads the
+ * window and the mark covers by that length, not by the head. Null for a
+ * double that can't say, or when reading throws.
+ */
+export function readMarkOf(cm) {
+    try {
+        const head = storeHeadOf(cm);
+        if (head === null)
+            return null;
+        const presented = typeof cm.windowMode === 'function' && cm.windowMode() === 'presented'
+            && typeof cm.indexLength === 'function';
+        return mark(cm.currentBranch().name, head, presented ? cm.indexLength() : null);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The store's head as `cm` reads it now, the head a mark readMarkOf takes
+ * keeps: the chronicle head, not the slot's last message, since in legacy
+ * mode a compile reads everything stored on the branch so far, rows merged
+ * in from another slot included (in presented mode it reads the window,
+ * which a mark covers by its index length). A record sequence, on the
+ * branch `cm` is on: for a reader
+ * that compares stored rows' sequences with it on that branch (Agent's
+ * branchHead), not a cover of the window. Null for a context double that
+ * can't say.
+ */
+export function storeHeadOf(cm) {
+    try {
+        if (typeof cm.currentBranch !== 'function' || typeof cm.getAllMessages !== 'function')
+            return null;
+        const store = typeof cm.getStore === 'function' ? cm.getStore() : undefined;
+        let head = typeof store?.currentSequence === 'function' ? store.currentSequence() : undefined;
+        if (head === undefined) {
+            const count = typeof cm.getMessageCount === 'function' ? cm.getMessageCount() : cm.getAllMessages().length;
+            head = count > 0 ? cm.getAllMessages().at(-1)?.sequence ?? 0 : 0;
+        }
+        return head;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A mark of where `cm` stands now, as readMarkOf takes one, that covers its
+ * window only below `length` (an index length of that window, at most its
+ * own): for a redo on the window (AgentFramework.redo), which puts back,
+ * at new ordinals and in their order, rows a mark covered before they were
+ * undone and rows it didn't, so the mark it gives again covers the first
+ * and not the rest. Null where readMarkOf gives null, and in legacy mode,
+ * where a mark has no length.
+ */
+export function readMarkThrough(cm, length) {
+    const now = readMarkOf(cm);
+    if (!now || now[LENGTH] === null)
+        return null;
+    return mark(now.branch, now[HEAD], Math.min(length, now[LENGTH]));
+}
+/**
+ * Whether a mark was taken in presented mode: it keeps the window's index
+ * length, and covers rows by their ordinals there, so a row taken out of the
+ * window and presented again, at a new ordinal past its length, leaves it.
+ * A mark taken in legacy mode keeps none: it covers by sequence while its
+ * window is the record, and, once the window is written down, by ordinal
+ * too, below the first row the window didn't hold by its head (coverTest),
+ * so a row presented again after it leaves it in the same way.
+ */
+export function coversByOrdinal(mark) {
+    return !!mark && mark[LENGTH] !== null;
+}
+/**
+ * A test of many rows against one mark, read against `reader` (the manager
+ * whose window the mark is of), which reads the reader's branch and mode
+ * once. The rules:
+ *
+ * - no mark: doubt;
+ * - a mark on another branch than the reader's: doubt, except that a mark
+ *   taken in legacy mode, read `across` a branch point (`partAt`, the last
+ *   sequence the two branches share), reads as one on the reader's branch
+ *   (below) through the lower of its head and the branch point;
+ * - a mark taken in legacy mode, read against a reader in legacy mode: a
+ *   row at or below its head is covered;
+ * - a mark taken in legacy mode, read against a reader in presented mode:
+ *   a row the window has held where it stands since the head or before is
+ *   covered (windowLengthAt: the window's rows below the ordinal of its first
+ *   row a branch cut at the head wouldn't keep), and no other: not a row
+ *   stored after the head, out of the window, or presented after the head,
+ *   again or for the first time. A reader that can't say where its window
+ *   held a row (a double without ordinalOf, getPresentedMessages,
+ *   branchSequenceOf or indexLength) is read by sequence, as in legacy
+ *   mode; a read of the window that throws is doubt for the rows at or
+ *   below the head;
+ * - a mark taken in presented mode, read against a reader no longer in it:
+ *   doubt;
+ * - else a row is covered when its ordinal is below the mark's length:
+ *   strictly, since the length is the ordinal the next row would take. A row
+ *   out of the window (never presented, or taken out) is not covered.
+ */
+export function coverTest(mark, reader, across) {
+    if (!mark)
+        return () => 'doubt';
+    let branch;
+    let presented = false;
+    try {
+        branch = typeof reader.currentBranch === 'function' ? reader.currentBranch().name : undefined;
+        presented = typeof reader.windowMode === 'function' && reader.windowMode() === 'presented';
+    }
+    catch {
+        return () => 'doubt';
+    }
+    const head = mark[HEAD];
+    const length = mark[LENGTH];
+    if (branch !== mark.branch) {
+        if (!across || length !== null)
+            return () => 'doubt';
+        return legacyCover(reader, presented, Math.min(head, across.partAt));
+    }
+    if (length === null)
+        return legacyCover(reader, presented, head);
+    if (!presented || typeof reader.ordinalOf !== 'function')
+        return () => 'doubt';
+    return byOrdinal(reader.ordinalOf.bind(reader), length);
+}
+function byOrdinal(ordinalOf, length) {
+    return (row) => {
+        const ordinal = ordinalOf(row.id);
+        return ordinal !== undefined && ordinal < length ? 'covered' : 'not-covered';
+    };
+}
+/**
+ * How a mark taken in legacy mode covers through `through` (its head, or the
+ * lower of its head and a branch point): by sequence against a reader in
+ * legacy mode, or one that can't say where its window held a row; against
+ * one in presented mode, by ordinal below windowLengthAt(reader, through),
+ * read once, at the first row that needs it. A row stored after `through`
+ * entered the window after it, wherever it stands, so it is not covered
+ * without that read.
+ */
+function legacyCover(reader, presented, through) {
+    const bySequence = (row) => (row.sequence <= through ? 'covered' : 'not-covered');
+    if (!presented || typeof reader.ordinalOf !== 'function' || typeof reader.getPresentedMessages !== 'function'
+        || typeof reader.branchSequenceOf !== 'function' || typeof reader.indexLength !== 'function') {
+        return bySequence;
+    }
+    let cover;
+    return (row) => {
+        if (row.sequence > through)
+            return 'not-covered';
+        if (!cover) {
+            const length = windowLengthAt(reader, through);
+            cover = length === null ? () => 'doubt' : byOrdinal(reader.ordinalOf.bind(reader), length);
+        }
+        return cover(row);
+    };
+}
+/**
+ * The index length a mark taken in presented mode would hold to cover the
+ * rows `reader`'s window (in presented mode) has held, where they stand
+ * now, since sequence `through` or before: the ordinal of the window's first
+ * row that a branch cut at `through` wouldn't keep in its window, or the
+ * index length when such a cut keeps them all. A cut keeps a row when its
+ * branchSequenceOf (the sequence a cut has to reach for its window to hold
+ * the row) is at or below `through`: a row's own sequence (its body's last
+ * shard's) for a row the write-down put in the window, which lists the
+ * record in record order, and the write that presented it for any other,
+ * which comes after the write-down and after every write that presented a
+ * row before it. So that sequence only grows along the window, and the
+ * first row past `through` is found by a binary search over it: a few reads
+ * per mark, whatever the window's length. Null when a read throws.
+ */
+function windowLengthAt(reader, through) {
+    try {
+        const window = reader.getPresentedMessages();
+        let low = 0;
+        let high = window.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (reader.branchSequenceOf(window[middle].id) <= through)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        if (low === window.length)
+            return reader.indexLength();
+        return reader.ordinalOf(window[low].id) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether `mark` covers `row` in `reader`'s window (see coverTest for the rules). */
+export function covers(mark, reader, row, across) {
+    return coverTest(mark, reader, across)(row);
+}
+/**
+ * Whether mark `a` was taken at or after mark `b`: on one branch, by the
+ * window's index length when both keep one, which only grows there and
+ * grows at every presentation, and by the store's head, which only grows
+ * there too, where the lengths are equal or either mark keeps none;
+ * `'other-branch'` when they are on two. Two marks at one head can keep two
+ * lengths: a mark readMarkThrough gives (a redo's) covers less of the window
+ * than one taken at the same head, and a double without a store reads its
+ * head from its last row, which no presentation moves. The one with the
+ * greater length is the later: a publish noted with it (Agent.notePublished)
+ * is credited with the rows presented between.
+ */
+export function markAtOrAfter(a, b) {
+    if (a.branch !== b.branch)
+        return 'other-branch';
+    const [aLength, bLength] = [a[LENGTH], b[LENGTH]];
+    if (aLength !== null && bLength !== null && aLength !== bLength)
+        return aLength > bLength;
+    return a[HEAD] >= b[HEAD];
+}
+/** A mark for a log line or a test's message: `main@412` in legacy mode, `main@412#57` with its index length. */
+export function describeReadMark(mark) {
+    if (!mark)
+        return 'no mark';
+    return `${mark.branch}@${mark[HEAD]}${mark[LENGTH] === null ? '' : `#${mark[LENGTH]}`}`;
+}
+/**
+ * A mark built from its parts, for a test that needs one taken at a given
+ * place. Production code takes marks with readMarkOf.
+ *
+ * @internal
+ */
+export function readMarkForTest(branch, head, length) {
+    return mark(branch, head, length);
+}
+//# sourceMappingURL=read-marks.js.map

package/dist/src/read-marks.js.map

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

package/dist/src/reasoning-loss.d.ts

@@ -0,0 +1,5 @@
+/** #973: #938 stopped writing these notices, but old stores retain them.
+ *  Exclude deterministically before selection, compression and thinking binding;
+ *  never match text or change stored history. */
+export declare function isReasoningLoss(metadata: unknown): boolean;
+//# sourceMappingURL=reasoning-loss.d.ts.map

package/dist/src/reasoning-loss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-loss.d.ts","sourceRoot":"","sources":["../../src/reasoning-loss.ts"],"names":[],"mappings":"AAAA;;iDAEiD;AACjD,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAG1D"}

package/dist/src/reasoning-loss.js

@@ -0,0 +1,8 @@
+/** #973: #938 stopped writing these notices, but old stores retain them.
+ *  Exclude deterministically before selection, compression and thinking binding;
+ *  never match text or change stored history. */
+export function isReasoningLoss(metadata) {
+    const mark = metadata;
+    return mark?.kind === 'reasoning-loss' && mark.system === true;
+}
+//# sourceMappingURL=reasoning-loss.js.map

package/dist/src/reasoning-loss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-loss.js","sourceRoot":"","sources":["../../src/reasoning-loss.ts"],"names":[],"mappings":"AAAA;;iDAEiD;AACjD,MAAM,UAAU,eAAe,CAAC,QAAiB;IAC/C,MAAM,IAAI,GAAG,QAAmE,CAAC;IACjF,OAAO,IAAI,EAAE,IAAI,KAAK,gBAAgB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC;AACjE,CAAC"}

package/dist/src/recovery/offline-branch.d.ts

@@ -3,12 +3,45 @@ import { type DiscordAwarenessMarks, type DiscordAwarenessRef } from './discord-
 export interface OfflineRecoveryBranchOptions {
     storePath: string;
     agentName: string;
-    /** Preferred: Discord message that remains as the last visible anchor. */
+    /**
+     * Preferred: Discord message that remains as the last visible anchor. On
+     * an agent's window that was presented (#291) the branch is cut at the
+     * write that presented the anchor, so rows stored after the anchor and
+     * before that write stay on the branch: those the window took after the
+     * anchor enter it again at the agent's next presentation point, after the
+     * anchor, and the rows that one write presented together with the anchor
+     * stay after it in the window. Only rows stored after the cut are removed
+     * and counted. A
+     * suppression may name any row the branch keeps that has a Discord
+     * message id, one the cut keeps after the anchor too; one without (an
+     * agent's round, a tool row) takes the live suppressMessages, by its row
+     * id. A recovery on that window that would change nothing (no
+     * row removed, none an arrival again, no suppression) is refused, as the
+     * live rollback refuses it.
+     */
     messageId?: string;
-    /** Exact internal ContextManager message ID that remains as the anchor. */
+    /** Exact internal ContextManager message ID that remains as the anchor (the cut as for `messageId`). */
     contextId?: string;
-    /** Backward-compatible alternative: remove the newest N context entries. */
+    /**
+     * Backward-compatible alternative: remove the newest N context entries,
+     * counted in the agent's window once it was presented (#291), over the
+     * rows of its own slot, and in the record before that; the anchor is the
+     * entry before them, cut as for `messageId`.
+     */
     messages?: number;
+    /**
+     * Remove every row a suppress rule hid (`metadata.suppressed`) on the new
+     * branch, which needs no anchor: the branch then starts from the newest row.
+     * For rolling back to a release that doesn't read the stamp, where a row
+     * hidden between messages a summary covers makes that summary non-contiguous,
+     * and the store is refused at open. The source branch keeps them. Once this
+     * release has made a window write of two or more rows (the first
+     * write-down of a window that holds a row, as at the first boot on a store
+     * with history, or a presentation of more than one row: MANIFEST version
+     * 2), no earlier release opens the store at all, and only a copy taken
+     * before the upgrade goes back.
+     */
+    removeSuppressed?: boolean;
     /** Exact Discord messages to suppress on the new branch. */
     suppressMessageIds?: string[];
     /** Inclusive context-order ranges between Discord message endpoints. */
@@ -38,6 +71,20 @@ export interface OfflineRecoveryBranchResult {
     targetBranch: string;
     messagesRemoved: number;
     messagesSuppressed: number;
+    /**
+     * On a presented window (#291): the rows after the anchor in the agent's
+     * window that the cut keeps in the record (stored before the write that
+     * presented the anchor, presented after it), as the live rollback counts
+     * them, of the agent's own slot: the recovery reads that slot alone, so a
+     * row of a slot the agent observes (the residents' rows in a persistent
+     * subconscious's window), which the live rollback counts, isn't counted
+     * here, and the check of a cut that would change nothing doesn't see it. They leave the window as arrived and not presented, and enter it
+     * again at the agent's next presentation point, after the anchor. Not
+     * removed, so not counted in `messagesRemoved`, and not marked; a row the
+     * same recovery suppresses is counted there instead. 0 for a run with no
+     * anchor; absent on a window that is still the record.
+     */
+    returnedToArrivals?: number;
     /** Removed messages that carry a Discord address. */
     discordAddressable: number;
     /** The publication scope recorded for this recovery. */
@@ -63,9 +110,47 @@ export interface OfflineRecoveryBranchResult {
 /**
  * Create a safe Chronicle branch while the normal agent host is stopped.
  *
- * History is scanned in bounded windows and blobs are not re-inlined. The
- * affected messages are never compiled and their content is never written to
- * the recovery outbox; only Discord addressing metadata leaves Chronicle.
+ * History is scanned in bounded windows and blobs are not re-inlined, but a
+ * presented window (#291) is read whole where its order counts: for a
+ * `messages` count, and for the rows after the anchor that the cut returns
+ * to the arrivals or keeps (windowAfterCut). The affected messages are never
+ * compiled and their content is never written to the recovery outbox; only
+ * Discord addressing metadata leaves Chronicle.
  */
 export declare function createOfflineRecoveryBranch(options: OfflineRecoveryBranchOptions): Promise<OfflineRecoveryBranchResult>;
+/**
+ * Of the rows a no-op cut keeps after its anchor (`kept`), those holding a
+ * result of a call in a row of the agent's window at or before the anchor,
+ * which a suppression would leave without its result: a tool boundary
+ * presents a round's reply and its results in one write, and so does a
+ * write-down for rows stored together. With them, the earliest such call's
+ * row and the window row before it, where a cut keeps the call and its
+ * results together. Undefined where no kept row answers such a call, or the
+ * anchor isn't in `window`. The live rollback's refusal reads it too.
+ */
+export declare function resultsOfAnchoredCalls<R extends {
+    id: unknown;
+    content: readonly unknown[];
+}>(window: readonly R[], anchorId: unknown, kept: readonly R[]): {
+    rows: R[];
+    call: R;
+    before?: R;
+} | undefined;
+/**
+ * A refusal's advice for the kept rows that answer a call at or before the
+ * anchor (resultsOfAnchoredCalls): `verb` (anchor the recovery, roll back)
+ * before the call's row, naming the row before it (`to`: at, to), and why
+ * they aren't to be suppressed.
+ */
+export declare function anchorBefore(split: {
+    rows: ReadonlyArray<{
+        id: unknown;
+    }>;
+    call: {
+        id: unknown;
+    };
+    before?: {
+        id: unknown;
+    };
+}, verb: string, to: string): string;
 //# sourceMappingURL=offline-branch.d.ts.map

package/dist/src/recovery/offline-branch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"offline-branch.d.ts","sourceRoot":"","sources":["../../../src/recovery/offline-branch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAI/D,OAAO,EAQL,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EAEzB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,wEAAwE;IACxE,cAAc,CAAC,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvE,sHAAsH;IACtH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,UAAU,EAAE,MAAM,GAAG,WAAW,GAAG,KAAK,CAAC;IACzC,yEAAyE;IACzE,oBAAoB,EAAE,MAAM,CAAC;IAC7B;2DACuD;IACvD,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,qEAAqE;IACrE,IAAI,EAAE,mBAAmB,EAAE,CAAC;IAC5B;4EACwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB;iEAC6D;IAC7D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,2BAA2B,CAAC,CAqRtC"}
+{"version":3,"file":"offline-branch.d.ts","sourceRoot":"","sources":["../../../src/recovery/offline-branch.ts"],"names":[],"mappings":"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"}