@manyoars/oars 0.4.1 → 0.5.2

package/dist/sessions/pool-wire.js

@@ -2,18 +2,38 @@
 // computed from, with every class A field left out, so any later derivation can run over old data while nothing private leaves. The client builds a skeleton and checks it before
 // sending, and the server parses it again, field by field, because a live URL takes anything from anyone. This file imports nothing from the file system: the Worker bundles it.
 import { ACTION_TABLES, CANONICAL_ACTIONS, mcpOf } from './actions.js';
-import { CUSTOM_AGENT, FRAMEWORKS, isPublicMcpTool, isRegistryVersion, LANGUAGES, LITERAL, PRIVATE, publicEffort, publicVersion, PUBLIC_PACKAGES, projectedAgentType, PUBLIC_FLAGS, REPO_SIZES, TOOL_INPUT_KEYS, VOCAB_VERSION } from './public-vocabulary.js';
-import { ARG_CLASSES, TARGET_CLASSES } from './call-shape.js';
+import { CLOSED_ARG_VALUES, CUSTOM_AGENT, FRAMEWORKS, isPublicMcpTool, isRegistryVersion, LANGUAGES, LITERAL, PRIVATE, publicEffort, publicVersion, PUBLIC_PACKAGES, projectedAgentType, PUBLIC_FLAGS, REPO_SIZES, TOOL_INPUT_KEYS, VOCAB_VERSION } from './public-vocabulary.js';
+import { ARG_CLASSES, CHANGE_KINDS, DIFF_SHAPES, DIRECTORY_KINDS, EXTENSION_CLASSES, NAME_KINDS, PATH_DEPTHS, PATTERN_FEATURES, TARGET_CLASSES, TEMPLATE_SLOTS, VALUE_SIZES } from './call-shape.js';
 import { recoveryCallsOf, RECOVERY_CALLS } from './recovery-calls.js';
 import { projectLanguage, projectLanguageShare } from './strata.js';
 import { ERROR_CODES, LANGUAGE_SHARES, PROMPT_INTERVENTIONS } from './schema.js';
 // Format 3 (step 1 of the wire): a tool carries its `errorCode` and, for a failed call, what followed it (`recoveryCalls`). Formats 1 and 2 are refused by name; nothing is deployed, so nothing is migrated.
-export const SKELETON_FORMAT = 3;
+// Format 4 (layer 1 of a call's parameters): a tool may carry `argFeatures`, `argValues`, and `changeKind`. The pool reads formats 3 and 4 (`READ_FORMATS`): a format 3 batch is read as before, and one of those
+// three names in it is a field format 3 does not know, so it goes to the bag and is served from nowhere. The table is "Formats on open" in docs/pool.md.
+// Format 5 (layer 2 of a call's parameters): a tool may carry `names`, the file, directory, and variable names its values held. The pool reads formats 3, 4, and 5, and a name field in a batch of an older format goes to the bag the same way.
+// Format 6 (exposure): a batch may carry `recommendations`, one entry for each recommendation the session was shown or held back from, so the pool can tell shown from held. A batch with none says nothing, and the pool reads that as unknown, never as unexposed.
+// Format 7 (edit digests): a tool may carry `digests`, the digest of the old and new text of an Edit, MultiEdit, or Write call, so an edit that restores earlier content can be told from one that does not. A `git restore` names its path the way an edit
+// does, in `names`, so it needs no field of its own. The pool reads formats 3 to 7, and a recommendations or digests list in an older batch goes to the bag the same way.
+export const SKELETON_FORMAT = 7;
+/** The formats the parser reads, oldest first: the client builds only the last. */
+export const READ_FORMATS = [3, 4, 5, 6, SKELETON_FORMAT];
+/** The tool fields format 4 added: a format 3 batch that holds one is holding a field it does not define. */
+export const FORMAT_4_TOOL_FIELDS = ['argFeatures', 'argValues', 'changeKind'];
+/** The tool fields format 5 added: a batch of format 4 or 3 that holds one is holding a field it does not define. */
+export const FORMAT_5_TOOL_FIELDS = ['names', 'namesDropped', 'templates', 'templatesDropped', 'diffShape'];
+/** The batch fields format 6 added: a batch of an older format that holds one is holding a field it does not define. */
+export const FORMAT_6_BATCH_FIELDS = ['recommendations'];
+/** The format that added exposure. A batch of an older format holds no `recommendations`, and its failed calls are checked with the rule they were built under. */
+export const EXPOSURE_FORMAT = 6;
+/** The format that added edit digests. */
+export const DIGEST_FORMAT = 7;
+/** The tool fields format 7 added: a batch of format 6 or older that holds one is holding a field it does not define. */
+export const FORMAT_7_TOOL_FIELDS = ['digests'];
 /**
  * The version of the field list: every field name a batch can hold (`BATCH_FIELDS` in `pool-outbox.ts`). It moves with any field added, so a server told the version knows which names a batch may carry,
  * and a test pins the list to it (`pool-wire-additive.test.ts`). A field is deprecated and left on the list, never removed (conclusion section 17, rule 3).
  */
-export const FIELD_LIST_VERSION = 8;
+export const FIELD_LIST_VERSION = 14;
 export const BUNDLE_FORMAT = 1;
 /** One constant: the pool serves only the vocabulary version the client holds. */
 export { VOCAB_VERSION };
@@ -43,6 +63,10 @@ export const ORG_SIZES = ['solo', '2-10', '11-100', '101-1000', 'over-1000', 'un
 export const TEAMS = ['solo', 'team', 'unknown'];
 /** Whether the repository is public or private (an operator's setting, read locally, never looked up). */
 export const REPO_VISIBILITIES = ['public', 'private', 'unknown'];
+/** Where a session ran, as a trusted machine states it for a batch it admitted: the five host classes an enrollment knows (`HOST_CLASSES` in `machine.ts`, not imported: the pool bundles this file). */
+export const CLAIMED_HOST_CLASSES = ['local', 'vps', 'cloud', 'ci', 'hosted'];
+/** What started the session, as an enrollment declares it. */
+export const CLAIMED_LAUNCHERS = ['interactive', 'orchestrated', 'scheduled', 'ci', 'hosted-run', 'unknown'];
 export const NO_COVERAGE = { orgSize: 'unknown', team: 'unknown', repoVisibility: 'unknown' };
 /** A repo key is the store-salted hash a session record holds of its repository's identity: sixteen lowercase hex characters. */
 const REPO_KEY = /^[0-9a-f]{16}$/;
@@ -53,6 +77,8 @@ export const hourOf = (ts) => {
     const millis = Date.parse(ts);
     return Number.isNaN(millis) ? null : new Date(millis).getUTCHours();
 };
+/** Whether a recommendation reached the asker (`shown`) or was withheld by the holdback (`held`). The local row's arm, as the closed list holds it. */
+export const RECOMMENDATION_ARMS = ['shown', 'held'];
 /** A usage category's `tokens` bucket, or null when the record says the source never recorded it. A record that predates `usageObserved` reads every category as observed. */
 const observedBucket = (value, observed, field) => (observed === undefined || observed.includes(field) ? bucketOf('tokens', value) : null);
 /** W's minimum for a timing print (deposit-weighting spec, layer 5): fewer timed calls than this say too little to tell sessions apart. */
@@ -60,12 +86,24 @@ export const MIN_TIMED_CALLS = 50;
 /** A session has ended once no transcript of it has gained a line for this long (`session_idle_hours`, spec Section 7). */
 export const SESSION_IDLE_HOURS = 6;
 const HOUR_MS = 60 * 60 * 1000;
+/** No session leaves this machine sooner than this after it ends, whatever `session_idle_hours` is: time for `oars sessions deposit --deny` or a delete to act on it first. Today the longer idle window governs; this is the floor under it. */
+export const HOLD_WINDOW_MS = HOUR_MS;
 /**
- * Whether a session's batch may be built at `now`: no transcript of it, main or subagent, has gained a line for `SESSION_IDLE_HOURS`. A transcript gains a line when capture sees it change, which
- * stamps a new `rev` in epoch milliseconds, but a transcript can grow after the last capture, so `written` (the newest write to any raw file of the session, 0 when none is known) counts too: the
- * session was last active at the later of the two. A subagent that died without an end marker holds its session back at most that long.
+ * Whether a session's batch may be built at `now`: no transcript of it, main or subagent, has gained a line for `SESSION_IDLE_HOURS`. A transcript was last active at its own last line (`tsLast`, the
+ * session's clock, not ours), or at its capture (`rev`, epoch milliseconds) when it has none, so a store captured a minute ago from days-old transcripts holds sessions that ended days ago. A transcript can
+ * also grow after the last capture, so `written` (the newest write to any raw file of the session, 0 when none is known) counts when it is later than every capture: a write at or before the capture is the
+ * file arriving, not the session going on. A last line later than the capture is a bad clock, and the capture caps it. A person's build (`sender` false) takes the ended session at once. The sender, which builds and sends in one run, also waits `HOLD_WINDOW_MS` after the newest capture, so a session oars is seeing for the first time (a days-old transcript of a new harness) leaves no sooner than an hour later, time for `--deny` or a delete. A subagent that died without an end marker holds its session back at most that long.
  */
-export const hasEnded = (records, now, written) => now - Math.max(written, ...records.transcripts.map(({ session }) => session.rev)) >= SESSION_IDLE_HOURS * HOUR_MS;
+export const hasEnded = (records, now, written, idleMs = SESSION_IDLE_HOURS * HOUR_MS, sender = false) => {
+    const lastLines = records.transcripts.map(({ session }) => {
+        const ts = session.tsLast === null ? Number.NaN : Date.parse(session.tsLast);
+        return Number.isNaN(ts) ? session.rev : Math.min(ts, session.rev);
+    });
+    const captured = Math.max(...records.transcripts.map(({ session }) => session.rev));
+    if (sender && now - captured < HOLD_WINDOW_MS)
+        return false;
+    return now - Math.max(written > captured ? written : 0, ...lastLines) >= Math.max(idleMs, HOLD_WINDOW_MS);
+};
 const groupBy = (items, keyOf) => {
     const groups = new Map();
     for (const item of items) {
@@ -102,14 +140,16 @@ export const isWirePullName = (name) => name.length <= NAME_MAX && WIRE_PULL_NAM
 export const OPEN_GATE = { redact: (text) => text, terms: [] };
 /** The redactor leaves the name and each of its underscore-delimited parts as they are: `_` is a word character to it, so a host inside `mcp__git.acme.internal__run` is invisible to a pass over the whole name. */
 const unchanged = (gate, name) => gate.redact(name) === name && name.split(/_+/).every((part) => gate.redact(part) === part);
+/** Whether a name clears the one gate: it has the name shape, the redactor leaves it as it is, and it holds none of the exclusion terms. A name token that is really the word `private` passes; only this says a name was refused. */
+const passesGate = (gate, name, hasShape) => {
+    const lower = name.toLowerCase();
+    return hasShape(name) && unchanged(gate, name) && !gate.terms.some((term) => term !== '' && lower.includes(term.toLowerCase()));
+};
 /**
  * A name as the wire holds it: the value itself, or `private` when it counts as redacted. A value counts as redacted when the redactor changes it, it holds an exclusion term, it fails the name shape, or it is over
  * `NAME_MAX` characters, because a secret, an employer's name, or a mis-parsed command is not a name and nothing downstream can take it back. `keys` (t870) sends its names through this same function.
  */
-export const wireName = (gate, name, hasShape = isWireName) => {
-    const lower = name.toLowerCase();
-    return hasShape(name) && unchanged(gate, name) && !gate.terms.some((term) => term !== '' && lower.includes(term.toLowerCase())) ? name : PRIVATE;
-};
+export const wireName = (gate, name, hasShape = isWireName) => (passesGate(gate, name, hasShape) ? name : PRIVATE);
 const FLAG_DASHES = /^-{1,2}/;
 const SHORT_FLAG = /^-[A-Za-z]$/;
 // The long form has its own shape, with no `:` (the joiner `WIRE_NAME` allows for `scope:name`), because `--password:hunter2` is a value joined to its flag and no part of it is a name.
@@ -127,7 +167,7 @@ const wireFlag = (gate, flag) => (isWireFlag(flag) && wireName(gate, flag.replac
  * A call's key names as the wire holds them (t870): names only, never a value. A public tool (one with a pinned input list) sends the names on its list and counts the rest; any other tool sends a name only when it passes the
  * name gate, and a tool that went as `private` sends none, so a private tool's keys name no private work. `dropped` counts the distinct names not sent.
  */
-const wireKeys = (stored, native, gate) => {
+export const wireKeys = (stored, native, gate) => {
     const distinct = [...new Set(stored)];
     const listed = native === undefined ? undefined : TOOL_INPUT_KEYS.get(native);
     const kept = native === undefined || native === PRIVATE ? [] : distinct.filter((name) => (listed === undefined ? wireName(gate, name) !== PRIVATE : listed.has(name)));
@@ -135,6 +175,65 @@ const wireKeys = (stored, native, gate) => {
 };
 /** A stored closed-list member, else dropped: a hand-edited record never puts a value off the list on the wire. */
 const memberOf = (list, value) => list.find((entry) => entry === value);
+/** Whether a closed value is one the wire may carry for a tool's key: a boolean's two words, or a member of the tool's list. */
+export const isClosedValue = (native, key, value) => value === 'true' || value === 'false' || (native !== undefined && CLOSED_ARG_VALUES.get(native)?.get(key)?.has(value) === true);
+/**
+ * A call's value features as the wire sends them (layer 1): only a sent key's, and only closed-list members, so a hand-edited record never puts a value on the wire. An entry whose size is off its list is dropped whole, a
+ * path or pattern field off its list is left out, and a pattern holding no listed feature sends none.
+ */
+export const wireFeatures = (stored, sent) => (stored ?? []).flatMap((feature) => {
+    const valueSize = memberOf(VALUE_SIZES, feature.valueSize);
+    if (!sent.has(feature.key) || valueSize === undefined)
+        return [];
+    const pathDepth = memberOf(PATH_DEPTHS, feature.pathDepth);
+    const extension = memberOf(EXTENSION_CLASSES, feature.extension);
+    const dirKind = memberOf(DIRECTORY_KINDS, feature.dirKind);
+    const patternFeatures = PATTERN_FEATURES.filter((entry) => feature.patternFeatures?.includes(entry) === true);
+    return [{ key: feature.key, valueSize, ...(pathDepth === undefined ? {} : { pathDepth }), ...(extension === undefined ? {} : { extension }), ...(dirKind === undefined ? {} : { dirKind }), ...(patternFeatures.length === 0 ? {} : { patternFeatures }) }];
+});
+/** A call's closed values as the wire sends them (layer 1): only a sent key's, and only a value `isClosedValue` admits. */
+export const wireValues = (stored, sent, native) => (stored ?? []).filter(({ key, enumValue }) => sent.has(key) && isClosedValue(native, key, enumValue)).map(({ key, enumValue }) => ({ key, enumValue }));
+/** A call's change kinds as the wire sends them: the closed-list members, in the list's order. */
+export const wireChange = (stored) => CHANGE_KINDS.filter((kind) => stored?.includes(kind) === true);
+/** A call's diff shapes as the wire sends them: the closed-list members, in the list's order. */
+export const wireDiffShape = (stored) => DIFF_SHAPES.filter((shape) => stored?.includes(shape) === true);
+/**
+ * A call's name tokens as the wire sends them (layer 2): every stored token whose kind is on the closed list, through the one gate (`wireName`): a token the operator's exclusion terms or the redactor's secret shapes match, or that has no name shape,
+ * is dropped and counted in `dropped`. No floor, no threshold: a name is sent as it is.
+ */
+export const wireNames = (stored, gate) => {
+    const known = (stored ?? []).filter(({ kind }) => NAME_KINDS.includes(kind));
+    const names = known.filter(({ name }) => passesGate(gate, name, isWireName));
+    return { names, dropped: known.length - names.length };
+};
+/** A digest as capture writes it: the first 32 hex digits of a SHA-256, lowercase. */
+const DIGEST = /^[0-9a-f]{32}$/;
+/** A call's edit digests as the wire sends them: a pair whose digest is not that shape is dropped whole, so a corrupt store row costs the pair and never the deposit. */
+export const wireDigests = (stored) => (stored ?? []).filter((pair) => DIGEST.test(pair.new) && (pair.old === undefined || DIGEST.test(pair.old))).map((pair) => (pair.old === undefined ? { new: pair.new } : { old: pair.old, new: pair.new }));
+const TEMPLATE_SLOT_LIST = TEMPLATE_SLOTS;
+/**
+ * Whether every word of a template is one the wire may carry: a slot of `TEMPLATE_SLOTS`, the `--` marker, a flag with a slot joined to it, a flag, or a name (the program or subcommand), the last two as the caller judges them. A template is a single line of words
+ * set apart by one space, since no name or flag holds a space.
+ */
+const templateHolds = (template, name, flag) => template.split(' ').every((word) => {
+    if (TEMPLATE_SLOT_LIST.includes(word) || word === '--')
+        return true;
+    if (!word.startsWith('-'))
+        return name(word);
+    const joined = word.indexOf('=');
+    return joined < 0 ? flag(word) : flag(word.slice(0, joined)) && TEMPLATE_SLOT_LIST.includes(word.slice(joined + 1));
+});
+/** Whether a received template has the shape the wire sends: the pool's check, which holds no operator terms and no redactor. */
+export const isWireTemplate = (template) => templateHolds(template, isWireName, isWireFlag);
+/**
+ * A call's command templates as the wire sends them (layer 3): every stored template whose kept words (program, subcommand, flags) all clear the one gate, as a name or a flag does. A template with a word the redactor changes, an exclusion term matches, or that
+ * has no name shape is dropped whole and counted in `dropped`. No floor, no threshold: a template is sent as it is, and a literal is only ever a slot.
+ */
+export const wireTemplates = (stored, gate) => {
+    const known = stored ?? [];
+    const templates = known.filter((template) => templateHolds(template, (word) => wireName(gate, word) !== PRIVATE, (flag) => wireFlag(gate, flag) !== PRIVATE));
+    return { templates, dropped: known.length - templates.length };
+};
 /** The basename of a program as capture read it: a path never goes on the wire. */
 const basenameOf = (program) => program.replace(/^.*[\\/]/, '');
 /**
@@ -353,6 +452,14 @@ const transcriptOf = ({ session, prompts, tools, root }, spawner, spawned, agent
         const targetClass = memberOf(TARGET_CLASSES, tool.targetClass);
         const stored = tool.argClass;
         const argClass = stored === undefined ? undefined : ARG_CLASSES.filter((kind) => stored.includes(kind));
+        const sent = new Set(keys);
+        const argFeatures = wireFeatures(tool.argFeatures, sent);
+        const argValues = wireValues(tool.argValues, sent, steps[0]?.native);
+        const changeKind = wireChange(tool.changeKind);
+        const { names, dropped: namesDropped } = wireNames(tool.names, gate);
+        const digests = wireDigests(tool.digests);
+        const { templates, dropped: templatesDropped } = wireTemplates(tool.templates, gate);
+        const diffShape = wireDiffShape(tool.diffShape);
         steppedTools.push({
             side,
             prompt: promptPosition,
@@ -364,6 +471,15 @@ const transcriptOf = ({ session, prompts, tools, root }, spawner, spawned, agent
             ...(dropped === 0 ? {} : { keysDropped: bucketOf('count', dropped) }),
             ...(targetClass === undefined ? {} : { targetClass }),
             ...(argClass === undefined ? {} : { argClass: argClass.sort() }),
+            ...(argFeatures.length === 0 ? {} : { argFeatures }),
+            ...(argValues.length === 0 ? {} : { argValues }),
+            ...(changeKind.length === 0 ? {} : { changeKind }),
+            ...(names.length === 0 ? {} : { names }),
+            ...(namesDropped === 0 ? {} : { namesDropped: bucketOf('count', namesDropped) }),
+            ...(digests.length === 0 ? {} : { digests }),
+            ...(templates.length === 0 ? {} : { templates }),
+            ...(templatesDropped === 0 ? {} : { templatesDropped: bucketOf('count', templatesDropped) }),
+            ...(diffShape.length === 0 ? {} : { diffShape }),
             steps,
         });
     }
@@ -390,11 +506,18 @@ const transcriptOf = ({ session, prompts, tools, root }, spawner, spawned, agent
     }
     return { merkleRoot: root.merkleRoot, leaves: root.leaves, harness, frame: transcriptFrame, frames, spawnedIn: spawner?.index ?? null, prompts: framedPrompts, tools: steppedTools };
 };
+/**
+ * The recommendations of one session, from the local rows after `deriveConsequences` has given each its window. Only a row that showed or withheld something is carried: a miss recommended nothing, so it is neither shown nor held, and
+ * a row with no window has no calls to place. They go in window order, then by id, so one store builds one batch.
+ */
+export const recommendationsOf = (recalls, session) => recalls
+    .flatMap(({ sid, id, arm, poolVersion, answer, consequence }) => (sid === session && answer.kind === 'hit' && consequence !== undefined ? [{ id, arm, poolVersion, from: consequence.window.from, to: consequence.window.to }] : []))
+    .sort((a, b) => a.from - b.from || a.to - b.to || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
 /**
  * The skeleton of a session; null when any record of it was captured before steps and frames, or a transcript of it has no root, which holds no closed reading to send. The batch holds the main
  * transcript's run first, then each subagent's as its own run; its `id` is the main session's, and its one `timingPrint` is over the main transcript's calls alone.
  */
-export const skeletonOf = (records, id, read, print, deltas = [], gate = OPEN_GATE, coverage = NO_COVERAGE) => {
+export const skeletonOf = (records, id, read, print, deltas = [], gate = OPEN_GATE, coverage = NO_COVERAGE, recommendations = []) => {
     const mainTools = byCall(records.transcripts[0]?.tools ?? []);
     const places = records.transcripts.map(({ tools }) => placesOf(tools));
     const spawners = places[0]?.calls ?? new Map();
@@ -433,7 +556,7 @@ export const skeletonOf = (records, id, read, print, deltas = [], gate = OPEN_GA
         transcripts.push(transcript);
     }
     const durations = mainTools.flatMap(({ durationMs }) => (durationMs === null ? [] : [durationMs]));
-    return { format: SKELETON_FORMAT, vocabVersion: VOCAB_VERSION, fieldsVersion: FIELD_LIST_VERSION, id, transcripts, timingPrint: durations.length < MIN_TIMED_CALLS ? null : print(durations), deltas: [...deltas] };
+    return { format: SKELETON_FORMAT, vocabVersion: VOCAB_VERSION, fieldsVersion: FIELD_LIST_VERSION, id, transcripts, timingPrint: durations.length < MIN_TIMED_CALLS ? null : print(durations), deltas: [...deltas], ...(recommendations.length === 0 ? {} : { recommendations: recommendations.map((entry) => ({ ...entry })) }) };
 };
 /**
  * The version bucket of a session that recorded none: Cursor, Gemini, and Grok Build keep no harness version in their local files, and neither does a VS Code Copilot Chat session whose requests carry no `agent.extensionVersion`, so their cells are
@@ -475,18 +598,20 @@ const unknownValue = (held, at, sent) => {
 /** The fields a client may send a literal beside (`<field>Literal`) when the field itself says `other`: the enumerated fields, whose values a closed list holds. */
 export const ENUMERATED_FIELDS = new Set(['harness', 'harnessVersion', 'model', 'effort', 'platform', 'shell', 'size', 'languages', 'frameworks', 'language', 'languageShare', 'cls', 'status', 'action', 'native', 'agentType', 'program', 'sub', 'flags', 'registry', 'name', 'version', 'server', 'tool', 'skill', 'host', 'deltaKind', 'field', 'metric', 'intervention']);
 /**
- * The fields that may be absent at format 3, by the level of the batch that holds them. An absent one reads as null, or as empty for a list, exactly as a sent null does, so a batch with all of them left out is
+ * The fields that may be absent at formats 3, 4, and 5 (a format 4 batch reads `OPTIONAL.tool` less `FORMAT_5_TOOL_FIELDS`, and a format 3 batch also less `FORMAT_4_TOOL_FIELDS`), by the level of the batch that holds them. An absent one reads as null, or as empty for a list, exactly as a sent null does, so a batch with all of them left out is
  * served from what remains. A field the cells need to be sound (a harness, a status, a bucket of tokens) is never here.
  */
 export const OPTIONAL = {
-    batch: ['timingPrint', 'deltas'],
+    batch: ['timingPrint', 'deltas', 'claimed', 'recommendations'],
     frame: ['harnessVersion', 'model', 'effort', 'day', 'shell', 'reach', 'repoKey', 'orgSize', 'team', 'repoVisibility', 'hour'],
     stack: ['size', 'languageShares'],
     prompt: ['wallSec', 'explore', 'usageResponses', 'intervention'],
-    tool: ['prompt', 'durationMs', 'errorCode', 'recoveryCalls', 'keys', 'keysDropped', 'targetClass', 'argClass'],
+    tool: ['prompt', 'durationMs', 'errorCode', 'recoveryCalls', 'keys', 'keysDropped', 'targetClass', 'argClass', 'argFeatures', 'argValues', 'changeKind', 'names', 'namesDropped', 'templates', 'templatesDropped', 'diffShape', 'digests'],
     step: ['tokens', 'ms', 'allocated', 'parent', 'skill', 'edges', 'remainingTokens'],
     transcript: ['spawnedIn'],
 };
+/** The fields of a value feature that only a path or a pattern holds: absent, never null, since a feature of another kind of value has no such field. */
+const FEATURE_OPTIONAL = ['pathDepth', 'extension', 'dirKind', 'patternFeatures'];
 /** The most bytes (as JSON) one field this reader does not know, or one literal, may hold: an enumerated value or a literal never needs more, and a newer client's larger structure belongs in a new format version. The deposit's own cap is no part of this. */
 export const MAX_EXTENSION_BYTES = 8 * 1024;
 const LITERAL_SUFFIX = 'Literal';
@@ -589,8 +714,8 @@ const allHarnesses = (list) => list;
 export const HARNESSES = allHarnesses(['claude-code', 'cursor', 'codex', 'copilot', 'gemini', 'grok', 'opencode', 'pi', 'vscode-copilot', 'otel']);
 const PROMPT_CLASSES = ['no-tools', 'orchestration', 'research', 'edit-verify', 'edit-only', 'explore-only', 'shell-only', 'mixed'];
 const STATUSES = ['ok', 'error', 'none'];
-const PLATFORMS = new Set(['aix', 'android', 'cygwin', 'darwin', 'freebsd', 'haiku', 'linux', 'netbsd', 'openbsd', 'sunos', 'win32']);
-const SHELLS = new Set(Object.values(ACTION_TABLES).flatMap((table) => Object.values(table.shells)));
+export const PLATFORMS = new Set(['aix', 'android', 'cygwin', 'darwin', 'freebsd', 'haiku', 'linux', 'netbsd', 'openbsd', 'sunos', 'win32']);
+export const SHELLS = new Set(Object.values(ACTION_TABLES).flatMap((table) => Object.values(table.shells)));
 /** The registries a package comes from; a pull may also come from a skill, plugin, or MCP registry. */
 export const PACKAGE_REGISTRIES = ['npm', 'pypi', 'crates', 'go', 'rubygems', 'homebrew'];
 const NO_NAME = new Set();
@@ -624,6 +749,11 @@ const parseReach = (held, value, at) => {
         throw new Refused(at, 'an unfilled reach lists nothing');
     return reach;
 };
+/** A claim, each member held to its closed list. */
+const parseClaimed = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['hostClass', 'launcher']);
+    return { hostClass: oneOf(held, CLAIMED_HOST_CLASSES, raw.hostClass, under(at, 'hostClass')), launcher: oneOf(held, CLAIMED_LAUNCHERS, raw.launcher, under(at, 'launcher')) };
+};
 /** Sixteen lowercase hex characters and nothing else, so no path or remote text can ride in a repo key. */
 const parseRepoKey = (value, at) => {
     const text = textOf(value, at);
@@ -752,7 +882,7 @@ const parseIdentity = (held, harness, action, value, at) => {
     throw new Refused(at, 'this action has no identity');
 };
 /** Whether the harness's table names this native, so it can cross as itself; anything else (including the literal) crosses as `private`. */
-const admittedNative = (harness, native) => {
+export const admittedNative = (harness, native) => {
     if (native === PRIVATE)
         return true;
     if (harness === OTHER)
@@ -832,8 +962,69 @@ const parseKeys = (held, native, value, at) => {
         return (listed === undefined ? isWireName(name) : listed.has(name)) ? name : unknownValue(held, entryAt, name);
     });
 };
+/** A sent key's entry names a key of the call's own `keys`, so a feature or a value never names a key the call did not send. */
+const sentKey = (held, keys, value, at) => {
+    const key = textOf(value, at);
+    const index = keys.sent.indexOf(key);
+    if (index < 0)
+        throw new Refused(at, 'not a key the call sent');
+    return keys.read[index] === OTHER ? unknownValue(held, at, key) : key;
+};
+const parseFeature = (held, keys, value, at) => {
+    const raw = fieldsOf(held, value, at, ['key', 'valueSize'], FEATURE_OPTIONAL);
+    const pathDepth = raw.pathDepth === undefined ? undefined : oneOf(held, PATH_DEPTHS, raw.pathDepth, under(at, 'pathDepth'));
+    const extension = raw.extension === undefined ? undefined : oneOf(held, EXTENSION_CLASSES, raw.extension, under(at, 'extension'));
+    const dirKind = raw.dirKind === undefined ? undefined : oneOf(held, DIRECTORY_KINDS, raw.dirKind, under(at, 'dirKind'));
+    const patternFeatures = raw.patternFeatures === undefined ? undefined : listOf(raw.patternFeatures, under(at, 'patternFeatures'), (entry, entryAt) => oneOf(held, PATTERN_FEATURES, entry, entryAt));
+    return {
+        key: sentKey(held, keys, raw.key, under(at, 'key')),
+        valueSize: oneOf(held, VALUE_SIZES, raw.valueSize, under(at, 'valueSize')),
+        ...(pathDepth === undefined ? {} : { pathDepth }),
+        ...(extension === undefined ? {} : { extension }),
+        ...(dirKind === undefined ? {} : { dirKind }),
+        ...(patternFeatures === undefined ? {} : { patternFeatures }),
+    };
+};
+/** A closed value this reader does not hold for the key reads as `other` and goes to the bag, as any value off a list does. */
+const parseValue = (held, keys, native, value, at) => {
+    const raw = fieldsOf(held, value, at, ['key', 'enumValue']);
+    const key = sentKey(held, keys, raw.key, under(at, 'key'));
+    const enumValue = textOf(raw.enumValue, under(at, 'enumValue'));
+    return { key, enumValue: key !== OTHER && isClosedValue(native, key, enumValue) ? enumValue : unknownValue(held, under(at, 'enumValue'), enumValue) };
+};
+/** The tool fields a format 5 or 6 batch may hold: format 7's are fields it does not know. */
+const FORMAT_6_TOOL = OPTIONAL.tool.filter((name) => !FORMAT_7_TOOL_FIELDS.some((added) => added === name));
+/** The tool fields a format 4 batch may hold: format 5's are fields it does not know. */
+const FORMAT_4_TOOL = FORMAT_6_TOOL.filter((name) => !FORMAT_5_TOOL_FIELDS.some((added) => added === name));
+/** The tool fields a format 3 batch may hold: format 4's three are fields it does not know too. */
+const FORMAT_3_TOOL = FORMAT_4_TOOL.filter((name) => !FORMAT_4_TOOL_FIELDS.some((added) => added === name));
+/** A name token: its kind off the closed list, and a name that has the shape of one. Either off its list or shape reads as `other` and goes to the bag, as any value off a list does. */
+const parseName = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['kind', 'name']);
+    const name = textOf(raw.name, under(at, 'name'));
+    return { kind: oneOf(held, NAME_KINDS, raw.kind, under(at, 'kind')), name: isWireName(name) ? name : unknownValue(held, under(at, 'name'), name) };
+};
+/** A digest is the shape capture writes, or the batch is refused: unlike a name, no newer client's value is a digest of another shape, and the field holds only what a hash can. */
+const digestOf = (value, at) => {
+    const digest = textOf(value, at);
+    if (!DIGEST.test(digest))
+        throw new Refused(at, 'not a digest');
+    return digest;
+};
+const parseDigest = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['new'], ['old']);
+    const old = raw.old === undefined ? undefined : digestOf(raw.old, under(at, 'old'));
+    return { ...(old === undefined ? {} : { old }), new: digestOf(raw.new, under(at, 'new')) };
+};
+const parseTemplate = (held, value, at) => {
+    const template = textOf(value, at);
+    return isWireTemplate(template) ? template : unknownValue(held, at, template);
+};
 const parseTool = (held, harness, value, at) => {
-    const raw = fieldsOf(held, value, at, ['side', 'status', 'steps'], OPTIONAL.tool);
+    const layered = held.format >= 4;
+    const named = held.format >= 5;
+    const digested = held.format >= DIGEST_FORMAT;
+    const raw = fieldsOf(held, value, at, ['side', 'status', 'steps'], digested ? OPTIONAL.tool : named ? FORMAT_6_TOOL : layered ? FORMAT_4_TOOL : FORMAT_3_TOOL);
     const status = oneOf(held, STATUSES, raw.status, under(at, 'status'));
     const errorCode = parseErrorCode(held, status, raw.errorCode, under(at, 'errorCode'));
     const recoveryCalls = parseRecovery(held, status, raw.recoveryCalls, under(at, 'recoveryCalls'));
@@ -842,6 +1033,16 @@ const parseTool = (held, harness, value, at) => {
     const keysDropped = raw.keysDropped === undefined ? undefined : bucketIn('count', raw.keysDropped, under(at, 'keysDropped'));
     const targetClass = raw.targetClass === undefined ? undefined : oneOf(held, TARGET_CLASSES, raw.targetClass, under(at, 'targetClass'));
     const argClass = raw.argClass === undefined ? undefined : listOf(raw.argClass, under(at, 'argClass'), (entry, entryAt) => oneOf(held, ARG_CLASSES, entry, entryAt));
+    const sentKeys = { sent: Array.isArray(raw.keys) ? raw.keys : [], read: keys ?? [] };
+    const argFeatures = !layered || raw.argFeatures === undefined ? undefined : listOf(raw.argFeatures, under(at, 'argFeatures'), (entry, entryAt) => parseFeature(held, sentKeys, entry, entryAt));
+    const argValues = !layered || raw.argValues === undefined ? undefined : listOf(raw.argValues, under(at, 'argValues'), (entry, entryAt) => parseValue(held, sentKeys, steps[0]?.native, entry, entryAt));
+    const changeKind = !layered || raw.changeKind === undefined ? undefined : listOf(raw.changeKind, under(at, 'changeKind'), (entry, entryAt) => oneOf(held, CHANGE_KINDS, entry, entryAt));
+    const names = !named || raw.names === undefined ? undefined : listOf(raw.names, under(at, 'names'), (entry, entryAt) => parseName(held, entry, entryAt));
+    const namesDropped = !named || raw.namesDropped === undefined ? undefined : bucketIn('count', raw.namesDropped, under(at, 'namesDropped'));
+    const digests = !digested || raw.digests === undefined ? undefined : listOf(raw.digests, under(at, 'digests'), (entry, entryAt) => parseDigest(held, entry, entryAt));
+    const templates = !named || raw.templates === undefined ? undefined : listOf(raw.templates, under(at, 'templates'), (entry, entryAt) => parseTemplate(held, entry, entryAt));
+    const templatesDropped = !named || raw.templatesDropped === undefined ? undefined : bucketIn('count', raw.templatesDropped, under(at, 'templatesDropped'));
+    const diffShape = !named || raw.diffShape === undefined ? undefined : listOf(raw.diffShape, under(at, 'diffShape'), (entry, entryAt) => oneOf(held, DIFF_SHAPES, entry, entryAt));
     return {
         side: booleanOf(raw.side, under(at, 'side')),
         prompt: orNull(raw.prompt, under(at, 'prompt'), countOf),
@@ -853,6 +1054,15 @@ const parseTool = (held, harness, value, at) => {
         ...(keysDropped === undefined ? {} : { keysDropped }),
         ...(targetClass === undefined ? {} : { targetClass }),
         ...(argClass === undefined ? {} : { argClass }),
+        ...(argFeatures === undefined ? {} : { argFeatures }),
+        ...(argValues === undefined ? {} : { argValues }),
+        ...(changeKind === undefined ? {} : { changeKind }),
+        ...(names === undefined ? {} : { names }),
+        ...(namesDropped === undefined ? {} : { namesDropped }),
+        ...(digests === undefined ? {} : { digests }),
+        ...(templates === undefined ? {} : { templates }),
+        ...(templatesDropped === undefined ? {} : { templatesDropped }),
+        ...(diffShape === undefined ? {} : { diffShape }),
         steps,
     };
 };
@@ -890,9 +1100,9 @@ const parseTranscript = (held, value, at) => {
     const spawnedIn = orNull(raw.spawnedIn, under(at, 'spawnedIn'), countOf);
     const prompts = listOf(raw.prompts, under(at, 'prompts'), (entry, entryAt) => parsePrompt(held, entry, entryAt));
     const tools = listOf(raw.tools, under(at, 'tools'), (entry, entryAt) => parseTool(held, harness, entry, entryAt));
-    // What followed a call is read off the calls themselves, so a list that disagrees with them is a wrong deposit, not a new reading.
+    // What followed a call is read off the calls themselves, so a list that disagrees with them is a wrong deposit, not a new reading. A batch of a format before 6 was built when a failed edit still counted, so it is checked with that rule.
     tools.forEach((tool, index) => {
-        if (tool.recoveryCalls !== undefined && JSON.stringify(tool.recoveryCalls) !== JSON.stringify(recoveryCallsOf(tools, index)))
+        if (tool.recoveryCalls !== undefined && JSON.stringify(tool.recoveryCalls) !== JSON.stringify(recoveryCallsOf(tools, index, held.format < EXPOSURE_FORMAT)))
             throw new Refused(`${at}.tools[${String(index)}].recoveryCalls`, 'not what followed the call');
     });
     return { merkleRoot, leaves, harness, frame, frames, spawnedIn, prompts, tools };
@@ -936,16 +1146,39 @@ const parseDelta = (held, value, at) => {
     return { deltaKind, field, name, registry, metric, change };
 };
 const VOCAB_TEXT = /^[0-9A-Za-z._-]{1,32}$/;
+/** The deposit time of the pool a recommendation answered from: an instant, or a version word. */
+const POOL_VERSION = /^[0-9A-Za-z:.+_-]{1,40}$/;
+/** The batch fields a batch of format 5 or older may hold: format 6's are fields it does not know. */
+const FORMAT_5_BATCH = OPTIONAL.batch.filter((name) => !FORMAT_6_BATCH_FIELDS.some((added) => added === name));
+/** One recommendation: a hash id, its arm off the closed list, the version it answered from, and a window that is two counts in order. Past-the-calls is checked once the transcripts are known. */
+const parseRecommendation = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['id', 'arm', 'poolVersion', 'from', 'to']);
+    const id = textOf(raw.id, under(at, 'id'));
+    if (!ID.test(id))
+        throw new Refused(under(at, 'id'), 'not a hash');
+    const poolVersion = textOf(raw.poolVersion, under(at, 'poolVersion'));
+    if (!POOL_VERSION.test(poolVersion))
+        throw new Refused(under(at, 'poolVersion'), 'not a version');
+    const from = countOf(raw.from, under(at, 'from'));
+    const to = countOf(raw.to, under(at, 'to'));
+    if (to < from)
+        throw new Refused(under(at, 'to'), 'ends before it starts');
+    return { id, arm: oneOf(held, RECOMMENDATION_ARMS, raw.arm, under(at, 'arm')), poolVersion, from, to };
+};
 /** The skeleton in `value`, rebuilt from the fields read, with the bag of what was set aside; else the first field that is a shape error, and why. */
 export const parseSkeleton = (value) => {
-    const held = { extensions: [], others: 0 };
+    const held = { extensions: [], others: 0, format: SKELETON_FORMAT };
     try {
         // The earlier forms are named, since their fields would otherwise read as a list of strangers; any other format is a form this reader does not know.
-        if (isFields(value) && typeof value.format === 'number' && value.format < SKELETON_FORMAT)
+        if (isFields(value) && typeof value.format === 'number' && value.format < READ_FORMATS[0])
             throw new Refused('format', `the format ${String(value.format)} form is no longer read; send format ${String(SKELETON_FORMAT)}`);
-        const raw = fieldsOf(held, value, '', ['format', 'vocabVersion', 'fieldsVersion', 'id', 'transcripts'], OPTIONAL.batch);
-        if (raw.format !== SKELETON_FORMAT)
+        // The format is read first, since which batch fields it defines depends on it.
+        const declared = isFields(value) ? READ_FORMATS.find((known) => known === value.format) : undefined;
+        const raw = fieldsOf(held, value, '', ['format', 'vocabVersion', 'fieldsVersion', 'id', 'transcripts'], declared !== undefined && declared < EXPOSURE_FORMAT ? FORMAT_5_BATCH : OPTIONAL.batch);
+        const format = READ_FORMATS.find((known) => known === raw.format);
+        if (format === undefined)
             throw new Refused('format', 'not a format this version reads');
+        held.format = format;
         const vocabVersion = textOf(raw.vocabVersion, 'vocabVersion');
         if (!VOCAB_TEXT.test(vocabVersion))
             throw new Refused('vocabVersion', 'not a version');
@@ -957,6 +1190,13 @@ export const parseSkeleton = (value) => {
         const transcripts = listOf(raw.transcripts, 'transcripts', (entry, entryAt) => parseTranscript(held, entry, entryAt));
         if (transcripts.length === 0)
             throw new Refused('transcripts', 'empty');
+        const recommendations = format < EXPOSURE_FORMAT ? [] : listOrEmpty(raw.recommendations, 'recommendations', (entry, entryAt) => parseRecommendation(held, entry, entryAt));
+        // Positions are the only ordinals on the wire, so a window must lie within the main run's own calls: the ones that are not sidechain, which is the line the windows were counted on.
+        const mainCalls = (transcripts[0]?.tools ?? []).filter(({ side }) => !side).length;
+        recommendations.forEach(({ to }, index) => {
+            if (to > mainCalls)
+                throw new Refused(`recommendations[${String(index)}].to`, 'past the main run\'s calls');
+        });
         // A counting batch is what lifts the fetch cap, so a deposit has to hold something to derive from.
         if (transcripts.every(({ prompts, tools }) => prompts.length === 0 && tools.length === 0))
             throw new Refused('transcripts', 'holds no prompt and no tool');
@@ -1035,7 +1275,8 @@ export const parseSkeleton = (value) => {
                 before += steps.length;
             });
         });
-        return { ok: true, skeleton: { format: SKELETON_FORMAT, vocabVersion, fieldsVersion, id, transcripts, timingPrint, deltas }, extensions: held.extensions, others: held.others };
+        const claimed = raw.claimed === undefined ? {} : { claimed: parseClaimed(held, raw.claimed, 'claimed') };
+        return { ok: true, skeleton: { format, vocabVersion, fieldsVersion, id, transcripts, timingPrint, deltas, ...claimed, ...(recommendations.length === 0 ? {} : { recommendations }) }, extensions: held.extensions, others: held.others };
     }
     catch (error) {
         if (error instanceof Refused)
@@ -1043,10 +1284,21 @@ export const parseSkeleton = (value) => {
         throw error;
     }
 };
-const isSignedBundle = (value) => isFields(value) && typeof value.payload === 'string' && typeof value.signature === 'string';
+/** The key id of a bundle that names none, and of a sign-in file written before key ids: the pool's default `BUNDLE_KEY_ID`. */
+export const LEGACY_KEY_ID = 'k1';
+/** Key ids this release no longer trusts: the way a leaked signing key is rotated out (docs/pool.md, "Rotating the bundle signing key"). A bundle signed under one is refused even when its key is pinned. */
+export const RETIRED_KEY_IDS = new Set();
+/**
+ * Public keys this release of oars ships, by key id: the only way a key id the login did not pin becomes trusted, because a server at a pool's URL must not be able to introduce a key by naming a new id (S17). Empty until the pool's first rotation
+ * (docs/pool.md, "Rotating the bundle signing key"); a bundle is checked against the keys pinned at login and these, a shipped key winning under a shared id, so a server cannot shadow it with a key of its own.
+ */
+export const RELEASE_KEYS = Object.freeze({});
+/** The first key id a login offers that the server's entry does not hold and no release ships, or none: such an id could only have come from the server. */
+export const unpinnedKid = (held, offered, released = RELEASE_KEYS) => Object.keys(offered).find((kid) => !Object.hasOwn(held, kid) && !Object.hasOwn(released, kid));
+const isSignedBundle = (value) => isFields(value) && typeof value.payload === 'string' && typeof value.signature === 'string' && (value.kid === undefined || typeof value.kid === 'string');
 const isFloor = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 1;
 /** The floors a bundle states, or none: a client prints what is here, so a value that is not a whole number of at least 1 is refused and not shown, while a family this client does not know is carried (in `--json`) and not printed, since `floorSentence` prints only the families this client knows (additive, section 17 rule 3). */
-const isFloors = (value) => isFields(value) && isFloor(value.public) && isFloor(value.disclosure) && (value.families === undefined || (isFields(value.families) && Object.values(value.families).every(isFloor)));
+const isFloors = (value) => isFields(value) && isFloor(value.public) && isFloor(value.disclosure) && (value.clear === undefined || isFloor(value.clear)) && (value.families === undefined || (isFields(value.families) && Object.values(value.families).every(isFloor)));
 const isSourced = (value) => isFields(value) && ((value.state === 'value' && typeof value.value === 'number') || (value.state === 'no source yet' && typeof value.reason === 'string'));
 const isCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
 /** The set of four a bundle may carry: every field the `books` read prints is present and of its type, with its format, vocabulary version, and the two served lists checked as well, so a signed bundle with a malformed block reads as not a bundle, not as a crash in the printer. */
@@ -1081,12 +1333,24 @@ const signatureHolds = async ({ payload, signature }, key) => {
         return false;
     }
 };
+/** A key id as the pool sends them: letters, digits, dot, dash, and underscore, 1 to 32 characters. */
+export const isKeyId = (kid) => /^[A-Za-z0-9._-]{1,32}$/.test(kid);
+/** A key id for a message: the id as the pool sends them (letters, digits, dot, dash, underscore), and a stand-in for anything else, since the pool or a man in the middle chose it. */
+const keyIdName = (kid) => (isKeyId(kid) ? kid : '(unreadable key id)');
 /** The bundle, only when the pinned key signed these bytes for the harness and version that were asked for: another harness's or version's bundle, under a good signature, is still the wrong answer. */
-export const verifyBundle = async (signed, key, harness, harnessVersion) => {
+export const verifyBundle = async (signed, keys, harness, harnessVersion, retired = RETIRED_KEY_IDS, released = RELEASE_KEYS) => {
     if (!isSignedBundle(signed))
         return { ok: false, reason: 'not a signed bundle' };
+    const kid = signed.kid ?? LEGACY_KEY_ID;
+    const named = keyIdName(kid);
+    if (retired.has(kid))
+        return { ok: false, reason: `this bundle is signed with key ${named}, which this release of oars no longer trusts. Upgrade with npm install -g @manyoars/oars` };
+    const trusted = { ...keys, ...released };
+    const key = Object.hasOwn(trusted, kid) ? trusted[kid] : undefined;
+    if (key === undefined)
+        return { ok: false, reason: `this bundle is signed with key ${named}, which is not pinned for this server and not shipped in this release of oars. Upgrade with npm install -g @manyoars/oars` };
     if (!(await signatureHolds(signed, key)))
-        return { ok: false, reason: 'the signature does not match the key pinned at login' };
+        return { ok: false, reason: `the signature does not match the key ${named} pinned at login` };
     const bundle = JSON.parse(signed.payload);
     if (!isBundle(bundle))
         return { ok: false, reason: 'not a signed bundle this version reads' };

package/dist/sessions/pool.js

@@ -6,6 +6,7 @@ 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';
@@ -14,7 +15,7 @@ import { deriveAdoption } from './read-adoption.js';
 import { deriveCallShape } from './read-call-shape.js';
 import { deriveChange } from './read-change.js';
 import { deriveCost } from './read-cost.js';
-import { deriveFit } from './read-fit.js';
+import { deriveFit, deriveFitShape } from './read-fit.js';
 import { deriveLive } from './read-live.js';
 import { deriveMethod } from './read-method.js';
 import { deriveNextStep } from './read-next-step.js';
@@ -30,7 +31,7 @@ import { writeAtomic } from './store.js';
 // Built on call.
 const derivers = () => ({
     recovery: deriveRecovery,
-    fit: (input) => [...deriveFit(input), ...deriveCallShape(input)],
+    fit: (input) => [...deriveFit(input), ...deriveFitShape(input), ...deriveCallShape(input)],
     cost: deriveCost,
     change: deriveChange,
     live: deriveLive,
@@ -100,6 +101,7 @@ export const refreshPool = async (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(''));
+    await writeAtomic(join(storeDir, LOAD_STATUS_FILE), await loadStatusLines(storeDir, store.sessions));
     await writeAtomic(files.cells, serializeCells(set.cells));
     await writeAtomic(files.motifs, set.motifs.map((motif) => `${JSON.stringify(motif)}\n`).join(''));
     const file = files.reads(pool.version);

package/dist/sessions/public-vocabulary.d.ts

@@ -60,6 +60,9 @@ export declare const HARNESS_TOOLS: ReadonlyMap<string, ReadonlySet<string>>;
  * is pinned yet, so an admitted plugin agent is not on this list and pools as `custom` (spec Section 2).
  */
 export declare const HARNESS_AGENT_TYPES: ReadonlyMap<string, ReadonlySet<string>>;
+export declare const CLOSED_ARG_VALUES: ReadonlyMap<string, ReadonlyMap<string, ReadonlySet<string>>>;
+/** The keys of `CLOSED_ROWS` whose list is not exhaustive: a custom agent's name or a full model id is off it and has no `enum` cell, so the key's on-list values do not sum to the calls that send it. */
+export declare const OPEN_LIST_KEYS: ReadonlySet<string>;
 /** What a subagent type pools as when it is not a built-in: a custom agent's name is private. */
 export declare const CUSTOM_AGENT = "custom";
 /** A subagent type as it pools: a built-in of a harness as itself, anything else as `custom`. */
@@ -70,3 +73,5 @@ export declare const projectedAgentType: (agentType: string) => string;
  * the name gate and counts the rest in `keysDropped`.
  */
 export declare const TOOL_INPUT_KEYS: ReadonlyMap<string, ReadonlySet<string>>;
+/** Every key name a public tool's pinned list holds: a value feature or closed value keyed on one of these names nothing private, so the pool serves its cell at the clear floor. */
+export declare const PUBLIC_INPUT_KEYS: ReadonlySet<string>;