@manyoars/oars 0.5.3 → 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`,
@@ -94,6 +103,19 @@ export interface Pulled {
 export declare const readPulled: (outbox: string, step: string) => Promise<Pulled>;
 /** Staged and renamed, so a crash leaves the whole old file or the whole new one. */
 export declare const writePulled: (outbox: string, pulled: Pulled) => Promise<void>;
+/** One session a person took out with `oars pool remove`: the hash of the batch that was removed, which is how `--restore` names the way back, and the session id when it could be resolved. The outbox key derives from the account or the machine's environment, so only the session id keeps the session out after either changes; an entry with no id (the session was gone from the store, or the file is older) skips by key alone. */
+export interface RemovedEntry {
+    hash: string;
+    session?: string;
+}
+/** The sessions a person took out of the outbox with `oars pool remove`, by outbox key. Local only; nothing in it goes to the pool. */
+export interface Removed {
+    [key: string]: RemovedEntry;
+}
+/** `removed.json` as it stands; none when the file is missing. A file that is not a list of keys and entries fails the command that reads it, so a damaged list never becomes "send everything". A bare string is an entry with only a hash, the form before session ids were kept. */
+export declare const readRemoved: (outbox: string, step: string) => Promise<Removed>;
+/** Staged and renamed, like `pulled.json`: a crash leaves the whole old list or the whole new one. */
+export declare const writeRemoved: (outbox: string, removed: Removed) => Promise<void>;
 /** Whether any string or key in `value` holds one of `terms`, compared lowercased the way the local gate compares a transcript. */
 export declare const holdsTerm: (value: unknown, terms: readonly string[]) => boolean;
 /**

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 });
+        yield { key, stamp, pulled: listed.has(key), hash, file: join(folder, name) };
     }
-    return { batches, edited };
-};
+}
+/** `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);
     }
@@ -385,6 +406,52 @@ export const writePulled = async (outbox, pulled) => {
     await writeOwnerOnly(staged, `${JSON.stringify(Object.fromEntries(Object.entries(pulled).sort(([a], [b]) => (a < b ? -1 : 1))), null, 2)}\n`);
     await rename(staged, join(outbox, PULLED));
 };
+const REMOVED = 'removed.json';
+const removedEntryOf = (value) => {
+    if (typeof value === 'string')
+        return { hash: value };
+    if (typeof value !== 'object' || value === null || Array.isArray(value) || !('hash' in value) || typeof value.hash !== 'string')
+        return undefined;
+    if (!('session' in value))
+        return { hash: value.hash };
+    return typeof value.session === 'string' ? { hash: value.hash, session: value.session } : undefined;
+};
+/** `removed.json` as it stands; none when the file is missing. A file that is not a list of keys and entries fails the command that reads it, so a damaged list never becomes "send everything". A bare string is an entry with only a hash, the form before session ids were kept. */
+export const readRemoved = async (outbox, step) => {
+    let text;
+    try {
+        text = await readFile(join(outbox, REMOVED), 'utf8');
+    }
+    catch (error) {
+        if (isMissing(error))
+            return {};
+        throw error;
+    }
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        value = undefined;
+    }
+    const entries = typeof value !== 'object' || value === null || Array.isArray(value) ? undefined : Object.entries(value).map(([key, entry]) => [key, removedEntryOf(entry)]);
+    const kept = [];
+    for (const [key, entry] of entries ?? [])
+        if (entry !== undefined)
+            kept.push([key, entry]);
+    if (entries === undefined || kept.length !== entries.length) {
+        throw new CliError(`${join(outbox, REMOVED)} is not a list of removed sessions. Move it aside and run the command again; nothing was changed, built, or sent.`, ExitCode.INVALID, step);
+    }
+    return Object.fromEntries(kept);
+};
+/** Staged and renamed, like `pulled.json`: a crash leaves the whole old list or the whole new one. */
+export const writeRemoved = async (outbox, removed) => {
+    await mkdirOwnerOnly(outbox);
+    const staged = join(outbox, `${REMOVED}.tmp`);
+    await writeOwnerOnly(staged, `${JSON.stringify(Object.fromEntries(Object.entries(removed).sort(([a], [b]) => (a < b ? -1 : 1))), null, 2)}
+`);
+    await rename(staged, join(outbox, REMOVED));
+};
 const POOL_STEP = 'pool-outbox';
 /** Whether any string or key in `value` holds one of `terms`, compared lowercased the way the local gate compares a transcript. */
 export const holdsTerm = (value, terms) => {

package/dist/sessions/pool-send-lock.d.ts

@@ -68,7 +68,8 @@ export declare const withSendLock: <T>(outbox: string, run: () => Promise<T>, ti
 /** Why an interactive send ended before it finished: a signal reached it, or the process that launched it is gone. */
 export declare class SendInterrupted extends Error {
     readonly kind: 'signal' | 'launcher';
-    constructor(kind: 'signal' | 'launcher', message: string);
+    readonly signal?: NodeJS.Signals | undefined;
+    constructor(kind: 'signal' | 'launcher', message: string, signal?: NodeJS.Signals | undefined);
 }
 /** What a test replaces: the process's signal hooks, its launcher, and how that launcher's liveness is read. */
 export interface InterruptHost {

package/dist/sessions/pool-send-lock.js

@@ -147,9 +147,11 @@ export const withSendLock = async (outbox, run, times = {}, fs = { stat }, wait
 /** Why an interactive send ended before it finished: a signal reached it, or the process that launched it is gone. */
 export class SendInterrupted extends Error {
     kind;
-    constructor(kind, message) {
+    signal;
+    constructor(kind, message, signal) {
         super(message);
         this.kind = kind;
+        this.signal = signal;
         this.name = 'SendInterrupted';
     }
 }
@@ -164,7 +166,7 @@ export const watchInterrupt = (host = { on: (event, listener) => process.on(even
     const listeners = SIGNALS.map((name) => [
         name,
         () => {
-            controller.abort(new SendInterrupted('signal', `Interrupted by ${name}.`));
+            controller.abort(new SendInterrupted('signal', `Interrupted by ${name}.`, name));
         },
     ]);
     for (const [name, listener] of listeners)

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)