@manyoars/oars 0.5.4 → 0.5.5

package/dist/sessions/pool-delta.d.ts

@@ -52,6 +52,11 @@ export interface Carried {
  * again under the same key, builds none it already carried. Nothing is marked here: the caller marks them once the batch is written.
  */
 export declare const carriedDeltas: (account: string, sessions: readonly Gated[], sent: ReadonlySet<string>) => Map<string, Carried>;
+/**
+ * The same deltas as `carriedDeltas`, one window at a time: `sessions` are placed from their session records alone, and `load` reads the full records of the ids one window needs (all of the window before, the first `DELTA_MIN_SESSIONS` after).
+ * What is held at once is one window's records, never the history.
+ */
+export declare const carriedDeltasByWindow: (account: string, sessions: readonly Gated[], sent: ReadonlySet<string>, load: (ids: ReadonlySet<string>) => Promise<ReadonlyMap<string, SessionRecords>>, fillers?: ReadonlySet<string>) => Promise<Map<string, Carried>>;
 /** The delta entries the batch under `key` in this outbox already carries; none when it has no batch, or one this reader does not take. */
 export declare const heldDeltas: (outbox: string, key: string) => Promise<DeltaEntry[]>;
 /**

package/dist/sessions/pool-delta.js

@@ -173,19 +173,39 @@ export const placedOf = (records) => {
 export const carriedDeltas = (account, sessions, sent) => {
     const carried = new Map();
     for (const { index, before, after, filler } of windowsOf(sessions)) {
-        const entries = [];
-        const marks = [];
-        for (const entry of deltasOf(before.map(({ records }) => records), 
         // The outcome is fixed at the fill: sessions after the filler change nothing, so a delta is the same whenever it is built.
-        after.slice(0, DELTA_MIN_SESSIONS).map(({ records }) => records))) {
-            const mark = deltaMark(account, entry, index);
-            if (sent.has(mark))
-                continue;
-            entries.push(entry);
-            marks.push(mark);
-        }
-        if (entries.length > 0)
-            carried.set(filler.id, { entries, marks });
+        const found = carriedIn(account, index, before.map(({ records }) => records), after.slice(0, DELTA_MIN_SESSIONS).map(({ records }) => records), sent);
+        if (found.entries.length > 0)
+            carried.set(filler.id, found);
+    }
+    return carried;
+};
+const carriedIn = (account, index, before, after, sent) => {
+    const found = { entries: [], marks: [] };
+    for (const entry of deltasOf(before, after)) {
+        const mark = deltaMark(account, entry, index);
+        if (sent.has(mark))
+            continue;
+        found.entries.push(entry);
+        found.marks.push(mark);
+    }
+    return found;
+};
+/**
+ * The same deltas as `carriedDeltas`, one window at a time: `sessions` are placed from their session records alone, and `load` reads the full records of the ids one window needs (all of the window before, the first `DELTA_MIN_SESSIONS` after).
+ * What is held at once is one window's records, never the history.
+ */
+export const carriedDeltasByWindow = async (account, sessions, sent, load, fillers) => {
+    const carried = new Map();
+    for (const { index, before, after, filler } of windowsOf(sessions)) {
+        // Only the batch of the session that fills a window carries its delta, so a window whose filler is not being built is not read.
+        if (fillers !== undefined && !fillers.has(filler.id))
+            continue;
+        const needed = [...before, ...after.slice(0, DELTA_MIN_SESSIONS)];
+        const records = await load(new Set(needed.map(({ id }) => id)));
+        const found = carriedIn(account, index, before.flatMap(({ id }) => records.get(id) ?? []), after.slice(0, DELTA_MIN_SESSIONS).flatMap(({ id }) => records.get(id) ?? []), sent);
+        if (found.entries.length > 0)
+            carried.set(filler.id, found);
     }
     return carried;
 };

package/dist/sessions/pool-fold.d.ts

@@ -0,0 +1,22 @@
+import type { CellSet } from './cells.js';
+import { type ReadFolds } from './read-folds.js';
+import type { Recall } from './recall-object.js';
+import { type ReversionIndex } from './reversion.js';
+import type { Store } from './store.js';
+/** What the pool step reads in place of the whole store's tools and prompts. */
+export interface PoolFolds {
+    /** The recalls in `recalls.jsonl` order, each of a held session with its consequence. */
+    recalls: Recall[];
+    cells: CellSet;
+    reads: ReadFolds;
+}
+export interface PoolFold {
+    /** One run of sessions: their main and subagent records, prompts, tools, and own errors. A session of another run is not in it. */
+    add: (run: Store) => void;
+    finish: () => PoolFolds;
+    /** The matching's input as it stands, for a report of its size. */
+    index: ReversionIndex;
+}
+export declare const poolFold: (recalls: readonly Recall[]) => PoolFold;
+/** The folds of a store held whole: one run. */
+export declare const poolFoldsOf: (recalls: readonly Recall[], store: Store) => PoolFolds;

package/dist/sessions/pool-fold.js

@@ -0,0 +1,65 @@
+// What `refreshPool` needs of the rows of every turn, folded one run of sessions at a time (t1243, spec 4 Build 2): each recall's consequence, the cells, and the two read families' inputs.
+// A run is a set of sessions with their prompts, tools, and own errors; the reversion matching waits for the last run, so `reverted` is filled in `finish`.
+import { cellsFold, projectedStore } from './cell-increments.js';
+import { shellReader } from './projection.js';
+import { readFold } from './read-folds.js';
+import { deriveConsequences, NO_RECALLS, recallGraphOf } from './recall-consequence.js';
+import { finishReversions, foldReversions, newReversionIndex } from './reversion.js';
+import { vocabulary } from './vocab-load.js';
+export const poolFold = (recalls) => {
+    const bySid = new Map();
+    for (const [at, recall] of recalls.entries()) {
+        if (recall.sid === null)
+            continue;
+        bySid.set(recall.sid, [...(bySid.get(recall.sid) ?? []), { at, recall }]);
+    }
+    const derived = [...recalls];
+    const index = newReversionIndex();
+    // The cells are tallied with the graph of the run being added.
+    let graph = NO_RECALLS;
+    const cells = cellsFold({ place: (tool, steps) => graph.place(tool, steps), exposedPrompt: (session, at) => graph.exposedPrompt(session, at) });
+    const reads = readFold();
+    const read = shellReader(vocabulary());
+    // The recalls whose outcome holds a reversion lookup, which the last run settles.
+    const pending = [];
+    const add = (run) => {
+        foldReversions(index, run);
+        // In `recalls.jsonl` order, as the whole store's call keeps them.
+        const mine = run.sessions.flatMap((session) => bySid.get(session.session) ?? []).sort((a, b) => a.at - b.at);
+        const asked = [];
+        const placeholder = (session, prompt) => {
+            asked.push({ session, prompt });
+            return null;
+        };
+        const filled = deriveConsequences(run, mine.map(({ recall }) => recall), placeholder);
+        const promptKeys = new Set(run.prompts.map((prompt) => `${prompt.session}#${String(prompt.index)}`));
+        filled.forEach((recall, position) => {
+            const entry = mine[position];
+            const lookup = asked[position];
+            if (entry === undefined || lookup === undefined)
+                return;
+            derived[entry.at] = recall;
+            if (promptKeys.has(`${lookup.session}#${String(lookup.prompt)}`))
+                pending.push({ at: entry.at, filled: recall, ...lookup });
+        });
+        graph = recallGraphOf(run, filled);
+        cells.add(projectedStore(run, read));
+        reads.add(run);
+    };
+    const finish = () => {
+        const reverted = finishReversions(index);
+        for (const { at, filled, session, prompt } of pending) {
+            if (filled.consequence === undefined)
+                continue;
+            derived[at] = { ...filled, consequence: { ...filled.consequence, outcome: { ...filled.consequence.outcome, reverted: reverted(session, prompt) } } };
+        }
+        return { recalls: derived, cells: cells.finish(), reads: reads.finish() };
+    };
+    return { add, finish, index };
+};
+/** The folds of a store held whole: one run. */
+export const poolFoldsOf = (recalls, store) => {
+    const fold = poolFold(recalls);
+    fold.add(store);
+    return fold.finish();
+};

package/dist/sessions/pool-outbox.d.ts

@@ -55,6 +55,12 @@ export declare const heldBatches: (outbox: string, stamp?: string) => Promise<{
     batches: Held[];
     edited: number;
 }>;
+/** A batch file of the outbox, found by its name alone: nothing of it is read yet, so a run over thousands of them holds one at a time. */
+export type HeldName = Omit<Held, 'bytes'>;
+/** The batch files filed under this stamp, by name, in name order (the same ones `heldBatches` reads, whether or not they still hash to their names). */
+export declare function namesHeld(outbox: string, stamp?: string): AsyncGenerator<HeldName>;
+/** `namesHeld` over every stamp a send reads, the current one first. */
+export declare function namesHeldAcross(outbox: string): AsyncGenerator<HeldName>;
 /** The stamps a send reads: the current one, then every other stamp `pulled.json` lists. A listed name that is not a stamp folder is not a path this reads. */
 export declare const sendStamps: (outbox: string) => Promise<string[]>;
 /** `heldBatches` over every stamp a send reads, the current one first. */
@@ -70,6 +76,9 @@ export declare const machineKeys: (outbox: string) => Promise<Set<string>>;
 export declare const noteMachineKey: (outbox: string, key: string) => Promise<void>;
 /** Records that this hash was printed, one line for each print: the lock below sends only a hash that appears here. */
 export declare const markShown: (outbox: string, hash: string, at: number) => Promise<void>;
+/** Every hash `shown.log` holds, read once: a run over thousands of batches must not read the file for each. */
+export declare const shownHashes: (outbox: string) => Promise<Set<string>>;
+export declare const wasShown: (outbox: string, hash: string) => Promise<boolean>;
 export type LockRefusal = 'batch_unknown' | 'batch_not_shown' | 'batch_changed';
 /**
  * The lock on a send: a batch goes only if it is in the outbox, its hash was printed, and its file still hashes to that hash. The first check that fails names why. The detached sender (hook-bin.js nightly) sends with `requireShown: false`,

package/dist/sessions/pool-outbox.js

@@ -246,11 +246,22 @@ export const unchangedBytes = async (file, hash) => {
  * under any other stamp it is only a batch `pulled.json` lists there, since anything else in that folder is stale and is never printed or sent.
  */
 export const heldBatches = async (outbox, stamp = currentStamp()) => {
+    const batches = [];
+    let edited = 0;
+    for await (const named of namesHeld(outbox, stamp)) {
+        const bytes = await unchangedBytes(named.file, named.hash);
+        if (bytes === undefined)
+            edited += 1;
+        else
+            batches.push({ ...named, bytes });
+    }
+    return { batches, edited };
+};
+/** The batch files filed under this stamp, by name, in name order (the same ones `heldBatches` reads, whether or not they still hash to their names). */
+export async function* namesHeld(outbox, stamp = currentStamp()) {
     const folder = join(outbox, stamp);
     const listed = await pulledAt(outbox, stamp);
     const here = stamp === currentStamp();
-    const batches = [];
-    let edited = 0;
     for (const name of await namesIn(folder)) {
         const found = BATCH_FILE.exec(name);
         if (found === null)
@@ -258,15 +269,14 @@ export const heldBatches = async (outbox, stamp = currentStamp()) => {
         const [, key = '', hash = ''] = found;
         if (!here && !listed.has(key))
             continue;
-        const file = join(folder, name);
-        const bytes = await unchangedBytes(file, hash);
-        if (bytes === undefined)
-            edited += 1;
-        else
-            batches.push({ key, stamp, pulled: listed.has(key), hash, file, bytes });
-    }
-    return { batches, edited };
-};
+        yield { key, stamp, pulled: listed.has(key), hash, file: join(folder, name) };
+    }
+}
+/** `namesHeld` over every stamp a send reads, the current one first. */
+export async function* namesHeldAcross(outbox) {
+    for (const stamp of await sendStamps(outbox))
+        yield* namesHeld(outbox, stamp);
+}
 /** The stamps a send reads: the current one, then every other stamp `pulled.json` lists. A listed name that is not a stamp folder is not a path this reads. */
 export const sendStamps = async (outbox) => {
     const others = new Set(Object.values(await readPulled(outbox, POOL_STEP)).filter((stamp) => stamp !== currentStamp() && STAMP_FOLDER.test(stamp)));
@@ -323,7 +333,18 @@ export const markShown = async (outbox, hash, at) => {
     await mkdirOwnerOnly(outbox);
     await appendOwnerOnly(shownFile(outbox), `${hash} ${new Date(at).toISOString()}\n`);
 };
-const wasShown = async (outbox, hash) => {
+/** Every hash `shown.log` holds, read once: a run over thousands of batches must not read the file for each. */
+export const shownHashes = async (outbox) => {
+    try {
+        return new Set((await readFile(shownFile(outbox), 'utf8')).split('\n').map((line) => line.split(' ')[0] ?? '').filter((hash) => hash !== ''));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return new Set();
+        throw error;
+    }
+};
+export const wasShown = async (outbox, hash) => {
     try {
         return (await readFile(shownFile(outbox), 'utf8')).split('\n').some((line) => line.split(' ')[0] === hash);
     }

package/dist/sessions/pool.d.ts

@@ -1,5 +1,7 @@
 import { type Pool } from './cells.js';
 import { type Read } from './read.js';
+import { type PoolFolds } from './pool-fold.js';
+import type { ReadFolds } from './read-folds.js';
 import { type Store } from './store.js';
 export declare const poolFiles: (storeDir: string) => {
     cells: string;
@@ -8,17 +10,20 @@ export declare const poolFiles: (storeDir: string) => {
     reads: (version: string) => string;
 };
 /** Every family's order 1 reads of one pool, in family order and then by slice, so a rerun writes the same bytes. */
-export declare const deriveFirstOrder: (pool: Pool, store: Store) => Read[];
+export declare const deriveFirstOrder: (pool: Pool, store: Store, folds?: ReadFolds) => Read[];
 /** Order 1, then each stage of `relations` over everything before it. */
-export declare const deriveReads: (pool: Pool, store: Store) => Read[];
+export declare const deriveReads: (pool: Pool, store: Store, folds?: ReadFolds) => Read[];
 export declare const serializeReads: (reads: readonly Read[]) => string;
-/** The current pool's reads: already written when this pool has been read before, else derived and written once. */
-export declare const refreshPool: (storeDir: string, store: Store) => Promise<{
+/**
+ * The current pool's reads: already written when this pool has been read before, else derived and written once. `store` holds the sessions, subagents, and errors; the rows of every turn are read through
+ * `folds`, which a refresh folds run by run. Without them `store` is taken whole, with its prompts and tools, and folded as one run.
+ */
+export declare const refreshPool: (storeDir: string, store: Store, folds?: PoolFolds) => Promise<{
     pool: Pool;
     reads: Read[];
 }>;
 /** The pool a deposit's index step reads. It answers without one (spec 2.7): a pool that cannot be read or written costs only the stored read IDs, whose answers keep their stand-ins, and one line on stderr says so. */
-export declare const currentPool: (storeDir: string, store: Store) => Promise<{
+export declare const currentPool: (storeDir: string, store: Store, folds?: PoolFolds | Error) => Promise<{
     pool: Pool;
     reads: Read[];
 } | undefined>;

package/dist/sessions/pool.js

@@ -4,12 +4,9 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { CliError, ExitCode } from '../errors.js';
-import { cellsOf, projectedStore } from './cell-increments.js';
 import { poolOf, serializeCells, UNKNOWN } from './cells.js';
 import { LOAD_STATUS_FILE, loadStatusLines } from './load-status.js';
-import { shellReader } from './projection.js';
 import { contentHash, FIRST_ORDER_FAMILIES, frozenRead, makeRead, orderResolver } from './read.js';
-import { deriveConsequences, recallGraphOf } from './recall-consequence.js';
 import { readRecalls } from './recall-object.js';
 import { deriveAdoption } from './read-adoption.js';
 import { deriveCallShape } from './read-call-shape.js';
@@ -21,7 +18,7 @@ import { deriveMethod } from './read-method.js';
 import { deriveNextStep } from './read-next-step.js';
 import { deriveRecovery } from './read-recovery.js';
 import { deriveToolDay } from './read-tool-day.js';
-import { vocabulary } from './vocab-load.js';
+import { poolFoldsOf } from './pool-fold.js';
 import { deriveDayMove } from './read-day-move.js';
 import { deriveInteraction } from './read-interaction.js';
 import { deriveLeadLag } from './read-lead-lag.js';
@@ -54,19 +51,19 @@ const made = (bodies, asOf, orderOf) => bodies
     .sort((a, b) => (a.key < b.key ? -1 : 1))
     .map(({ read }) => read);
 /** Every family's order 1 reads of one pool, in family order and then by slice, so a rerun writes the same bytes. */
-export const deriveFirstOrder = (pool, store) => {
+export const deriveFirstOrder = (pool, store, folds) => {
     const asOf = { pool: pool.version, day: pool.lastDay };
     const orderOf = orderResolver([]);
     const byFamily = derivers();
-    return FIRST_ORDER_FAMILIES.flatMap((family) => made(byFamily[family]({ pool, store }), asOf, orderOf));
+    return FIRST_ORDER_FAMILIES.flatMap((family) => made(byFamily[family]({ pool, store, ...(folds === undefined ? {} : { folds }) }), asOf, orderOf));
 };
 /** Order 1, then each stage of `relations` over everything before it. */
-export const deriveReads = (pool, store) => {
+export const deriveReads = (pool, store, folds) => {
     const asOf = { pool: pool.version, day: pool.lastDay };
     return relations().reduce((known, stage) => {
         const orderOf = orderResolver(known);
         return [...known, ...stage.flatMap((derive) => made(derive(known), asOf, orderOf))];
-    }, deriveFirstOrder(pool, store));
+    }, deriveFirstOrder(pool, store, folds));
 };
 export const serializeReads = (reads) => reads.map((read) => `${JSON.stringify(read)}\n`).join('');
 const isRead = (value) => typeof value === 'object' && value !== null && 'readId' in value && 'family' in value;
@@ -94,10 +91,12 @@ const storedRows = async (file, isRow) => {
     }
 };
 const readStored = async (file) => (await storedRows(file, isRead))?.map(frozenRead);
-/** The current pool's reads: already written when this pool has been read before, else derived and written once. */
-export const refreshPool = async (storeDir, store) => {
-    const recalls = deriveConsequences(store, await readRecalls(storeDir));
-    const set = cellsOf(projectedStore(store, shellReader(vocabulary())), recallGraphOf(store, recalls));
+/**
+ * The current pool's reads: already written when this pool has been read before, else derived and written once. `store` holds the sessions, subagents, and errors; the rows of every turn are read through
+ * `folds`, which a refresh folds run by run. Without them `store` is taken whole, with its prompts and tools, and folded as one run.
+ */
+export const refreshPool = async (storeDir, store, folds) => {
+    const { recalls, cells: set, reads: readFolds } = folds ?? poolFoldsOf(await readRecalls(storeDir), store);
     const pool = poolOf(set, store.errors);
     const files = poolFiles(storeDir);
     await writeAtomic(files.consequences, recalls.flatMap(({ id, n, consequence }) => (consequence === undefined ? [] : [`${JSON.stringify({ id, n, consequence })}\n`])).join(''));
@@ -108,7 +107,7 @@ export const refreshPool = async (storeDir, store) => {
     const stored = await readStored(file);
     if (stored !== undefined)
         return { pool, reads: stored };
-    const reads = deriveReads(pool, store);
+    const reads = deriveReads(pool, store, readFolds);
     await writeAtomic(file, serializeReads(reads));
     return { pool, reads };
 };
@@ -117,9 +116,11 @@ const unbuilt = (error) => {
     process.stderr.write(`${POOL_FAILED}${error instanceof Error ? error.message : String(error)}\n`);
 };
 /** The pool a deposit's index step reads. It answers without one (spec 2.7): a pool that cannot be read or written costs only the stored read IDs, whose answers keep their stand-ins, and one line on stderr says so. */
-export const currentPool = async (storeDir, store) => {
+export const currentPool = async (storeDir, store, folds) => {
     try {
-        return await refreshPool(storeDir, store);
+        if (folds instanceof Error)
+            throw folds;
+        return await refreshPool(storeDir, store, folds);
     }
     catch (error) {
         unbuilt(error);

package/dist/sessions/read-call-shape.js

@@ -5,9 +5,10 @@
 import { lastDayOfCell, parseShapeClass, UNKNOWN } from './cells.js';
 import { OPEN_GATE, wireKeys } from './pool-wire.js';
 import { CALL_SHAPE_METHOD } from './read.js';
-import { actionOfShape, fitReads, toolShapeId } from './recall-reads.js';
+import { actionOfShape, toolShapeId } from './recall-reads.js';
+import { readFoldsOf } from './read-folds.js';
 import { body, atGrain, rate, wilson } from './read-support.js';
-export const deriveCallShape = ({ pool, store }) => fitReads(store).flatMap((read) => {
+export const deriveCallShape = ({ pool, store, folds }) => (folds ?? readFoldsOf(store)).fit.flatMap((read) => {
     const action = actionOfShape(read.tool, read.harnesses);
     // The cell names the keys as the wire sends them (`projectedStore`); a record captured before steps was never projected, so its raw names are the other spelling.
     const names = new Set([wireKeys(read.keys, read.tool, OPEN_GATE).keys.join(','), read.keys.join(',')]);

package/dist/sessions/read-folds.d.ts

@@ -0,0 +1,21 @@
+import { type RecallRead } from './recall-reads.js';
+import type { PromptObservation } from './schema.js';
+import type { Store } from './store.js';
+export interface ReadFolds {
+    /** `fitReads` over the whole store. */
+    fit: RecallRead[];
+    /** The hook index's fit reads: `fitReads` at the push floors, kept above the base rate of their action. */
+    push: RecallRead[];
+    /** The frame day of each prompt an error of a main session names, by `session#index`. */
+    promptDays: ReadonlyMap<string, string>;
+}
+/** The day a prompt's frame was written under: its frame's, else the day of its stamp. */
+export declare const promptDayOf: (prompt: PromptObservation) => string;
+export interface ReadFold {
+    /** One run of sessions; its errors name prompts of its own sessions only. */
+    add: (run: Store) => void;
+    finish: () => ReadFolds;
+}
+export declare const readFold: () => ReadFold;
+/** The folds of a store held whole: one run. */
+export declare const readFoldsOf: (store: Store) => ReadFolds;

package/dist/sessions/read-folds.js

@@ -0,0 +1,37 @@
+// What the two families that read the rows of every turn keep of them (t1243): the fit shapes `deriveCallShape` cites, and the days of the prompts a recovery read's errors name. A refresh folds
+// them one run of sessions at a time, so neither family holds the tools or prompts of the whole history; a store held whole folds the same way as one run.
+import { UNKNOWN } from './cells.js';
+import { utcDay } from './frame.js';
+import { actionFold, aboveActionRate, fitFold, PUSH_FLOORS } from './recall-reads.js';
+/** The day a prompt's frame was written under: its frame's, else the day of its stamp. */
+export const promptDayOf = (prompt) => prompt.frame?.day ?? utcDay(prompt.ts) ?? UNKNOWN;
+export const readFold = () => {
+    const fit = fitFold();
+    const pushFit = fitFold(PUSH_FLOORS);
+    const actions = actionFold();
+    const promptDays = new Map();
+    return {
+        add: (run) => {
+            fit.add(run);
+            pushFit.add(run);
+            actions.add(run);
+            const prompts = new Map(run.prompts.map((prompt) => [`${prompt.session}#${String(prompt.index)}`, prompt]));
+            for (const error of run.errors) {
+                // A subagent's error is filed under its own session's frame, never a prompt's.
+                if (error.agent !== undefined)
+                    continue;
+                const key = `${error.session}#${String(error.prompt)}`;
+                const prompt = prompts.get(key);
+                if (prompt !== undefined)
+                    promptDays.set(key, promptDayOf(prompt));
+            }
+        },
+        finish: () => ({ fit: fit.finish(), push: aboveActionRate(actions.finish(), pushFit.finish()), promptDays }),
+    };
+};
+/** The folds of a store held whole: one run. */
+export const readFoldsOf = (store) => {
+    const fold = readFold();
+    fold.add(store);
+    return fold.finish();
+};

package/dist/sessions/read-recovery.d.ts

@@ -16,5 +16,5 @@ export interface RecoveryOutcome {
         [reason in RecoveryDrop]: number;
     };
 }
-export declare const recoveryOf: ({ pool, store }: FamilyInput) => RecoveryOutcome;
+export declare const recoveryOf: ({ pool, store, folds }: FamilyInput) => RecoveryOutcome;
 export declare const deriveRecovery: DeriveFamily;

package/dist/sessions/read-recovery.js

@@ -6,6 +6,7 @@ import { UNKNOWN, weekStartOf } from './cells.js';
 import { utcDay } from './frame.js';
 import { shapeMotif } from './motif.js';
 import { contentHash } from './read.js';
+import { readFoldsOf } from './read-folds.js';
 import { atGrain, body, groupBy } from './read-support.js';
 import { harnessOf } from './schema.js';
 import { signatureRecord } from './store.js';
@@ -35,9 +36,9 @@ const oneRowPerCall = (errors) => {
     }
     return [...rows, ...calls.values()];
 };
-export const recoveryOf = ({ pool, store }) => {
+export const recoveryOf = ({ pool, store, folds }) => {
     const sessions = new Map([...store.sessions, ...store.subagents].map((session) => [session.session, session]));
-    const prompts = new Map(store.prompts.map((prompt) => [`${prompt.session}#${String(prompt.index)}`, prompt]));
+    const promptDays = (folds ?? readFoldsOf(store)).promptDays;
     const actionIn = (session, tool) => actionOf(ACTION_TABLES[harnessOf(sessions.get(session) ?? {})], tool).action;
     // The failed call is a one-step shape, which has a live day cell. The step after it is a two-step window, which has a week cell only (rule 6), so it is found on the week its day falls in.
     const cellsAt = groupBy(atGrain(pool, 'day'), (cell) => `${cell.motifId}/${cell.day}`);
@@ -45,9 +46,9 @@ export const recoveryOf = ({ pool, store }) => {
     const cellsOf = groupBy(atGrain(pool, 'day'), (cell) => cell.motifId);
     /** The day a cell files this error's call under: its frame's, which is its prompt's, or its session's for a subagent or a call before the first prompt. An error can run past that midnight. */
     const frameDayOf = (error) => {
-        const prompt = error.agent === undefined ? prompts.get(`${error.session}#${String(error.prompt)}`) : undefined;
-        if (prompt !== undefined)
-            return prompt.frame?.day ?? utcDay(prompt.ts) ?? UNKNOWN;
+        const day = error.agent === undefined ? promptDays.get(`${error.session}#${String(error.prompt)}`) : undefined;
+        if (day !== undefined)
+            return day;
         const session = sessions.get(error.agent ?? error.session);
         return session?.frame?.day ?? utcDay(session?.tsFirst) ?? UNKNOWN;
     };

package/dist/sessions/read-support.d.ts

@@ -1,11 +1,14 @@
 import { type Cell, type Grain, type Pool } from './cells.js';
 import type { Motif } from './motif.js';
 import { type Family, type ReadDraft, type ReadInterval, type ReadSlice, type ReadValue } from './read.js';
+import type { ReadFolds } from './read-folds.js';
 import type { Store } from './store.js';
 export interface FamilyInput {
     pool: Pool;
-    /** Only recovery reads this: an error's signature is not in a cell. */
+    /** Its sessions, subagents, and errors. Only recovery reads this: an error's signature is not in a cell. A refresh holds no tools or prompts here: the two families that read them take `folds`. */
     store: Store;
+    /** What a refresh folded from the rows of every turn, run by run; absent, the two families that need it fold `store` whole. */
+    folds?: ReadFolds;
 }
 /** A read as a family states it; the pool's snapshot is added to all of them in one place. */
 export type ReadBody = Omit<ReadDraft, 'asOf'>;

package/dist/sessions/recall-consequence.d.ts

@@ -1,11 +1,12 @@
 import { type CountedStep } from './motif.js';
 import type { Recall } from './recall-object.js';
+import { reversionsOf } from './reversion.js';
 import { type ToolObservation } from './schema.js';
 import type { Store } from './store.js';
 /** A consequence window ends at the prompt's end or after this many calls (spec Section 2.7). */
 export declare const WINDOW_CALLS = 20;
 /** Fills `n` and `consequence`. A recall with no session, or from a session this store does not hold, has nothing to read and comes back as it was. */
-export declare const deriveConsequences: (store: Store, recalls: readonly Recall[]) => Recall[];
+export declare const deriveConsequences: (store: Store, recalls: readonly Recall[], reverted?: ReturnType<typeof reversionsOf>) => Recall[];
 /** A step as a cell counts it, and whether it sits inside a shown recall's window. */
 export interface PlacedStep {
     step: CountedStep;

package/dist/sessions/recall-consequence.js

@@ -74,11 +74,10 @@ const consequenceOf = (recall, session, line, position, harness, prompts, revert
     };
 };
 /** Fills `n` and `consequence`. A recall with no session, or from a session this store does not hold, has nothing to read and comes back as it was. */
-export const deriveConsequences = (store, recalls) => {
+export const deriveConsequences = (store, recalls, reverted = reversionsOf(store)) => {
     const lines = mainLines(store);
     const prompts = new Map(store.prompts.map((prompt) => [promptKey(prompt.session, prompt.index), prompt]));
     const sessions = new Map(store.sessions.map((session) => [session.session, session]));
-    const reverted = reversionsOf(store);
     return recalls.map((recall) => {
         const session = recall.sid === null ? undefined : sessions.get(recall.sid);
         if (session === undefined)

package/dist/sessions/recall-reads.d.ts

@@ -53,7 +53,16 @@ export declare const FIT_FLOORS: FitFloors;
  * `FIT_FLOORS`: a base rate is still a fact to read on request.
  */
 export declare const PUSH_FLOORS: FitFloors;
-/** `keep` narrows which calls are tallied, not what can come next: the call after a kept one is what followed it, wherever the slice ends. */
+export interface FitFold {
+    add: (store: Store) => void;
+    finish: () => RecallRead[];
+}
+/**
+ * `fitReads` as a fold: each `add` tallies one run of sessions into the same shapes, and `finish` applies the floors. Runs come in the whole store's row order, so the tie order of `followed` matches.
+ * `keep` narrows which calls are tallied, not what can come next: the call after a kept one is what followed it, wherever the slice ends.
+ */
+export declare const fitFold: (floors?: FitFloors, keep?: (call: ToolObservation) => boolean) => FitFold;
+/** `fitFold` over the whole store at once. `keep` narrows the calls tallied, not what follows them. */
 export declare const fitReads: (store: Store, floors?: FitFloors, keep?: (call: ToolObservation) => boolean) => RecallRead[];
 /** The action of a tool under the first of its harnesses whose table lists it, else under the first harness (the default one when a read names none). */
 export declare const actionOfShape: (tool: string, harnesses: readonly string[]) => CanonicalAction;
@@ -63,6 +72,19 @@ export declare const actionOfShape: (tool: string, harnesses: readonly string[])
  * 79 of 79 pushes, at 4.5x and 8.6x their action's share: a real signal, not a defect. Open parameter, like the floors.
  */
 export declare const PUSH_MIN_LIFT = 2;
+/** The per-action call tally `aboveBaseRate` compares against, as a fold: each `add` tallies one run of sessions, so a refresh never holds every call. */
+export declare const actionFold: () => {
+    add: (store: Store) => void;
+    finish: () => Map<CanonicalAction, {
+        calls: number;
+        failed: number;
+    }>;
+};
+/** `aboveBaseRate` over a finished action tally. */
+export declare const aboveActionRate: (byAction: ReadonlyMap<CanonicalAction, {
+    calls: number;
+    failed: number;
+}>, reads: readonly RecallRead[], lift?: number) => RecallRead[];
 /**
  * The reads whose shape fails at `lift` times the share of its whole action or more, where the action's share counts every call of every shape of it, those under the floors too.
  * A tool no table lists is the action `other` (or `mcp.call`), so it is held to that action's share like any other and can enter the index and fire. Compared in integers, so a tie is exact.