@manyoars/oars 0.3.0 → 0.4.0

package/dist/sessions/pool-wire.js

@@ -1,11 +1,19 @@
-// What crosses the wire between `oars pool` and the pool server (recall spec Sections 2.5, 4, and 5). A skeleton is one session in closed vocabulary: the records a cell is
+// What crosses the wire between `oars pool` and the pool server (recall spec Sections 2.5, 4, and 5). A skeleton is one session as a closed list of fields, each value redacted first: the records a cell is
 // 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, publicModel, publicVersion, PUBLIC_FLAGS, PUBLIC_HOSTS, PUBLIC_MCP_SERVERS, PUBLIC_PACKAGES, PUBLIC_PROGRAMS, PUBLIC_SKILLS, projectedAgentType, PUBLIC_SUBCOMMANDS, REPO_SIZES, VOCAB_VERSION } from './public-vocabulary.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 { recoveryCallsOf, RECOVERY_CALLS } from './recovery-calls.js';
 import { projectLanguage, projectLanguageShare } from './strata.js';
-import { LANGUAGE_SHARES } from './schema.js';
-export const SKELETON_FORMAT = 2;
+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;
+/**
+ * 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 BUNDLE_FORMAT = 1;
 /** One constant: the pool serves only the vocabulary version the client holds. */
 export { VOCAB_VERSION };
@@ -27,6 +35,26 @@ export const bucketOf = (kind, value) => EDGES[kind].filter((edge) => value >= e
 export const projectExplore = (stored) => (stored !== undefined && Number.isSafeInteger(stored) && stored >= 0 ? bucketOf('calls', stored) : null);
 /** The lowest value of a bucket, which is what a derivation counts a bucketed value as: it never reads above what the sender held. */
 export const floorOf = (kind, bucket) => EDGES[kind][bucket - 1] ?? 0;
+/** The closed list of how a step came about (`schema.ts` `StepEdge`). */
+export const EDGE_KINDS = ['next', 'spawned', 'retried', 'after-error'];
+/** How many people the operator's organization has (an operator's setting, read locally, never looked up). */
+export const ORG_SIZES = ['solo', '2-10', '11-100', '101-1000', 'over-1000', 'unknown'];
+/** Whether the repository's local git log shows one commit author or several (distinct authors, counted and then dropped). */
+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'];
+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}$/;
+/** The UTC hour of day, 0 to 23, of a timestamp, whatever offset it was written in; null when there is none or it does not parse. */
+export const hourOf = (ts) => {
+    if (ts === null || ts === undefined || ts === '')
+        return null;
+    const millis = Date.parse(ts);
+    return Number.isNaN(millis) ? null : new Date(millis).getUTCHours();
+};
+/** 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. */
 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). */
@@ -60,65 +88,135 @@ export const sessionsOf = (store, roots) => {
     // A subagent whose main transcript the store does not hold is in no group: it cannot be folded, and counting it alone would raise `n`.
     return store.sessions.map((main) => ({ main, transcripts: [main, ...[...(subagents.get(main.session) ?? [])].sort((a, b) => (a.session < b.session ? -1 : 1))].map(recordsOf) }));
 };
+/** The most characters a name may hold on the wire. A longer value is not a name: it counts as redacted. */
+export const NAME_MAX = 128;
+// A name is a word: letters, digits, and a few joiners, with an optional leading `@` for a scope. A mis-parsed command line, a path, an email, or a quoted string fails it. A `/` is not a joiner here: a name holding one is a path (`src/acme/plan.md`).
+const WIRE_NAME = /^@?[A-Za-z0-9_][A-Za-z0-9_.+-]*(?::[A-Za-z0-9_.+-]+)*$/;
+// A pull's package `name` is the one place a `/` belongs: a scope (`@scope/pkg`) or a Go module path (`golang.org/x/tools`).
+const WIRE_PULL_NAME = /^@?[A-Za-z0-9_][A-Za-z0-9_.+-]*(?:[/:][A-Za-z0-9_.+-]+)*$/;
+/** Whether a value has the shape of a name (and so can be told from a command line, a path, or an email) and is within `NAME_MAX`. */
+export const isWireName = (name) => name.length <= NAME_MAX && WIRE_NAME.test(name);
+/** The shape of a pull's package name: a name, or a scope or module path with `/` in it. */
+export const isWirePullName = (name) => name.length <= NAME_MAX && WIRE_PULL_NAME.test(name);
+/** No redaction and no terms: the name shape and the length limit still apply. A local read, which sends nothing, uses it. */
+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);
+/**
+ * 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;
+};
+const FLAG_DASHES = /^-{1,2}/;
 const SHORT_FLAG = /^-[A-Za-z]$/;
-/** The flags the wire has a row for: the curated list and a single letter. */
-const isWireFlag = (flag) => PUBLIC_FLAGS.has(flag) || SHORT_FLAG.test(flag);
-const PRIVATE_COMMAND = { program: PRIVATE, sub: null, flags: [] };
+// 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.
+const LONG_FLAG = /^--[A-Za-z0-9][A-Za-z0-9_.+-]*$/;
+/**
+ * The shape of a flag name: a long flag (two dashes, then a name with no `:`) or a short one (one dash, one letter), or a single-dash token longer than one letter only when the public flag list holds it (`-NoProfile`, `-Command`). A value joined to its flag
+ * fails it: `--token=abc`, `--password:hunter2`, and a short flag with its value attached (`-psecret123`, `-uuser:pass`), which no list holds.
+ */
+const isWireFlag = (flag) => SHORT_FLAG.test(flag) || PUBLIC_FLAGS.has(flag) || (flag.length <= NAME_MAX && LONG_FLAG.test(flag));
+/** A multi-letter single-dash flag no public list holds (`go test -race`, `-psecret123`): the client before t900 dropped it, so this one does too, and an old and a new client key one motif for one command. */
+const isDroppedFlag = (flag) => flag.length > 2 && flag.startsWith('-') && !flag.startsWith('--') && !PUBLIC_FLAGS.has(flag);
+/** A flag name as the wire holds it: the name after the one gate, or `private` when it counts as redacted. Only the name is ever read, never a value. */
+const wireFlag = (gate, flag) => (isWireFlag(flag) && wireName(gate, flag.replace(FLAG_DASHES, '')) !== PRIVATE ? flag : PRIVATE);
+/**
+ * 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) => {
+    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)));
+    return { keys: kept.sort(), dropped: distinct.length - kept.length };
+};
+/** 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);
+/** The basename of a program as capture read it: a path never goes on the wire. */
+const basenameOf = (program) => program.replace(/^.*[\\/]/, '');
 /**
- * A projected command as the server's parser reads it. The client's snapshot lists more programs than the curated list the server holds, and a name the server has no row for
- * does not go on the wire (Section 1.2): such a program is `private`, and a subcommand or flag outside the curated lists is dropped, as the projection drops an unlisted one.
+ * A projected command as the server's parser reads it: the program as its basename after the gate (the stored identity reads `<literal>` for a program off the curated list, so the name comes from the call's segments),
+ * and the subcommand and flag names the reader gives, each through the same gate and never a flag value. Which of them the reader holds for a program is capture's; the wire adds no list of its own.
  */
-const wireCommand = ({ program, subcommand, flags }) => {
-    if (!PUBLIC_PROGRAMS.has(program))
-        return PRIVATE_COMMAND;
-    return { program, sub: subcommand !== null && PUBLIC_SUBCOMMANDS.get(program)?.has(subcommand) === true ? subcommand : null, flags: flags.filter(isWireFlag) };
-};
-/** The wire's one spelling of "not admitted": a name the server's list does not hold goes as `private`, whatever the local store spells it. */
-const listed = (allowed, name) => (allowed.has(name) ? name : PRIVATE);
-/** A pull in the wire's spelling: its package name is a list member or `private`. A version beside a masked name could identify it, so it goes as `<literal>` (null stays null), the rule capture applies. */
-const wirePull = (pull) => {
-    const name = listed(PUBLIC_PACKAGES, pull.name);
-    return { ...pull, name, version: name === PRIVATE && pull.version !== null ? LITERAL : pull.version };
-};
-/** A non-shell step's identity in the wire's spelling; a shell step's comes from `wireCommand`. */
-const wireIdentity = (identity, harness) => {
+const wireCommand = ({ program, subcommand, flags }, raw, gate) => {
+    const named = program !== PRIVATE ? program : raw;
+    if (named === undefined)
+        return { program: PRIVATE, sub: null, flags: [] };
+    const sent = wireName(gate, basenameOf(named));
+    // A private program holds no subcommand or flag: the parser refuses one that does.
+    if (sent === PRIVATE)
+        return { program: PRIVATE, sub: null, flags: [] };
+    return { program: sent, sub: subcommand === null ? null : wireName(gate, subcommand), flags: flags.filter((flag) => !isDroppedFlag(flag)).map((flag) => wireFlag(gate, flag)) };
+};
+/** A pull in the wire's spelling: its package name after the gate. A version beside a name that is not on the public list could identify it, so it goes as `<literal>` (null stays null), the rule capture applies. */
+const wirePull = (pull, gate) => {
+    const name = wireName(gate, pull.name, isWirePullName);
+    return { ...pull, name, version: !PUBLIC_PACKAGES.has(name) && pull.version !== null ? LITERAL : pull.version };
+};
+/** A non-shell step's identity in the wire's spelling; a shell step's comes from `wireCommand`. `raw` is the harness's own tool name, class A, which an MCP call's masked identity is read back from. */
+const wireIdentity = (identity, harness, raw, gate) => {
     if (identity === null || 'program' in identity)
         return identity;
     if ('server' in identity) {
-        const server = listed(PUBLIC_MCP_SERVERS, identity.server);
-        // A tool beside a masked server has no list to be checked against, so it goes as the literal. Beside a listed one it goes as itself only where the server's list still holds it
-        // and the harness's spelling delimits the server (the parser's rule); a tool an older list held, or one stored before that rule, goes as the literal rather than refusing the session.
-        const named = server !== PRIVATE && ACTION_TABLES[harness].toolDelimited && isPublicMcpTool(server, identity.tool);
-        return { server, tool: named ? identity.tool : LITERAL };
+        const table = ACTION_TABLES[harness];
+        const parsed = mcpOf(table, raw);
+        const server = wireName(gate, identity.server === LITERAL ? (parsed?.server ?? LITERAL) : identity.server);
+        // A tool beside a masked server has no server to belong to, and a harness that does not delimit the server cannot split the tool from it: both go as the literal.
+        const name = identity.tool === LITERAL ? parsed?.tool : identity.tool;
+        const tool = server === PRIVATE || !table.toolDelimited || name === undefined ? PRIVATE : wireName(gate, name);
+        return { server, tool: tool === PRIVATE ? LITERAL : tool };
     }
     if ('skill' in identity)
-        return { skill: listed(PUBLIC_SKILLS, identity.skill) };
-    return { host: identity.host === null ? null : listed(PUBLIC_HOSTS, identity.host) };
+        return { skill: wireName(gate, identity.skill) };
+    return { host: identity.host === null ? null : wireName(gate, identity.host) };
 };
 /**
- * A stored tool's steps as the wire holds them: each shell step's identity is replaced by the projected command, and every name the server has no row for (a native name, MCP server,
- * skill, host, or pull name) reads `private`. A `private` program holds no pull, so a stored step whose public program has since left the list carries none. The one place a deposit and a local read take it from.
+ * A stored tool's steps as the wire holds them: each shell step's identity is replaced by the projected command, and every long-tail name (a native name, MCP server, skill, host, program, or pull name) is
+ * sent as it is after the gate, or `private` when it counts as redacted. A `private` program holds no pull. The one place a deposit and a local read take it from.
  */
-export const projectedSteps = (tool, read, harness) => {
+export const projectedSteps = (tool, read, harness, gate = OPEN_GATE) => {
     const commands = read(tool);
-    return (tool.steps ?? []).map((step, at) => {
-        const native = admittedNative(harness, step.native) ? step.native : PRIVATE;
+    const steps = tool.steps ?? [];
+    // `segments` pair with the steps when their counts agree (`projectLiteralStep`): segment `at` is step `at`, and its `run` starts with the program's basename.
+    const segments = tool.segments?.length === steps.length ? tool.segments : undefined;
+    return steps.map((step, at) => {
+        const native = admittedNative(harness, step.native) ? step.native : wireName(gate, step.native === LITERAL ? tool.tool : step.native);
         if (step.action !== 'shell.exec')
-            return { ...step, native, identity: wireIdentity(step.identity, harness) };
-        const command = wireCommand(commands[at] ?? { program: PRIVATE, subcommand: null, flags: [] });
+            return { ...step, native, identity: wireIdentity(step.identity, harness, tool.tool, gate) };
+        const command = wireCommand(commands[at] ?? { program: PRIVATE, subcommand: null, flags: [] }, segments?.[at]?.run.split(' ')[0], gate);
         const pulls = step.identity !== null && 'program' in step.identity ? step.identity.pulls : undefined;
-        return { ...step, native, identity: pulls === undefined || command.program === PRIVATE ? command : { ...command, pulls: pulls.map(wirePull) } };
+        return { ...step, native, identity: pulls === undefined || command.program === PRIVATE ? command : { ...command, pulls: pulls.map((pull) => wirePull(pull, gate)) } };
     });
 };
+/** A failed call's stored `errorCode` as the wire holds it: a member of the closed list, else `other`; null for a call that did not fail and for one captured without a code (the wire does not guess one). */
+const wireErrorCode = ({ status, errorCode }) => (status !== 'error' || errorCode === undefined ? null : ERROR_CODES.has(errorCode) ? errorCode : 'other');
 /** A transcript's calls in the order they ran, which is the order a skeleton holds them in. */
 const byCall = (tools) => [...tools].sort((a, b) => a.n - b.n);
+const placesOf = (tools) => {
+    const calls = new Map();
+    const steps = new Map();
+    for (const [position, { n, steps: held }] of byCall(tools).entries()) {
+        calls.set(n, position);
+        for (const step of held ?? [])
+            steps.set(`${String(n)}/${String(step.seg)}`, steps.size);
+    }
+    return { calls, steps };
+};
 /** The step of a call that carries the runs it spawned: its first spawn step, else its first step. A call with no step carries none. */
 const carrier = (steps) => Math.max(0, steps.findIndex(({ action }) => action === 'agent.spawn'));
 /**
- * A stored frame with its stack's language shares: each stored share is read through its projection, so a share outside the list is dropped and its language stays in `languages`. A stored
+ * A model or harness version string as the wire holds it: the string after the gate (`wireName`), null staying null. The pool assigns its class. Capture's closed value (`<literal>`) goes as it is, the form a client before
+ * t900 sent, so an old and a new client key one closed frame to one pool cell; the parser accepts it.
+ */
+const wireString = (gate, value) => (value === null || value === LITERAL ? value : wireName(gate, value));
+/**
+ * A stored frame with the UTC hour of `ts` beside its day, and its stack's language shares: each stored share is read through its projection, so a share outside the list is dropped and its language stays in `languages`. A stored
  * language outside the pinned list is `other`, and `other` holds the first share a record gives it. A record captured before the strata holds none.
  */
-const wireFrame = (frame, strata) => {
+const wireFrame = (frame, strata, gate, ts) => {
     const shares = new Map();
     for (const { language, share } of strata?.languages ?? []) {
         const held = projectLanguageShare(share);
@@ -126,15 +224,45 @@ const wireFrame = (frame, strata) => {
         if (held !== null && !shares.has(name))
             shares.set(name, held);
     }
-    return { ...frame, stack: { ...frame.stack, languageShares: [...shares].map(([language, languageShare]) => ({ language, languageShare })) } };
+    const hour = hourOf(ts);
+    return { ...frame, harnessVersion: wireString(gate, frame.harnessVersion), model: wireString(gate, frame.model), stack: { ...frame.stack, languageShares: [...shares].map(([language, languageShare]) => ({ language, languageShare })) }, ...(hour === null ? {} : { hour }) };
+};
+/** Each of `names` after the gate (a name that counts as redacted reads `private`), sorted. */
+const listedAll = (gate, names) => [...new Set(names)].map((name) => wireName(gate, name)).sort();
+/**
+ * The reach a session's record shows (t867): the servers of the tools its `funnel` offered or loaded and of the MCP tools it called, the skills it called, and the plugins its `setup` names. A record
+ * with neither `setup` nor `funnel` is unfilled (a harness that records none, or a capture before version 12) and lists nothing, so the absence is not read as no tools.
+ */
+const reachOf = (session, tools, harness, gate) => {
+    if (session.setup === undefined && session.funnel === undefined)
+        return { filled: false, mcp: [], skills: [], plugins: [] };
+    const table = ACTION_TABLES[harness];
+    const servers = new Set();
+    const skills = new Set();
+    for (const name of [...(session.funnel?.offered ?? []), ...(session.funnel?.loaded ?? [])]) {
+        const server = mcpOf(table, name)?.server;
+        if (server !== undefined)
+            servers.add(server);
+    }
+    for (const { steps, skill } of tools) {
+        if (skill !== undefined)
+            skills.add(skill);
+        for (const { identity } of steps ?? []) {
+            if (identity !== null && 'server' in identity)
+                servers.add(identity.server);
+            if (identity !== null && 'skill' in identity)
+                skills.add(identity.skill);
+        }
+    }
+    return { filled: true, mcp: listedAll(gate, servers), skills: listedAll(gate, skills), plugins: (session.setup?.plugins ?? []).map(() => PRIVATE) };
 };
-const transcriptOf = ({ session, prompts, tools, root }, spawners, spawned, agentType, read) => {
+const transcriptOf = ({ session, prompts, tools, root }, spawner, spawned, agentType, read, gate, coverage) => {
     if (session.frame === undefined || root === null)
         return null;
     const harness = session.harness ?? 'claude-code';
     const framedPrompts = [];
     const promptAt = new Map();
-    for (const { index, cls, errors, wallSec, usage, frame, strata } of [...prompts].sort((a, b) => a.index - b.index)) {
+    for (const { index, cls, errors, wallSec, usage, usageObserved, usageResponses, frame, strata, ts, intervention } of [...prompts].sort((a, b) => a.index - b.index)) {
         if (frame === undefined)
             return null;
         promptAt.set(index, framedPrompts.length);
@@ -142,41 +270,108 @@ const transcriptOf = ({ session, prompts, tools, root }, spawners, spawned, agen
             cls,
             errors: bucketOf('count', errors),
             wallSec: wallSec === null ? null : bucketOf('seconds', wallSec),
-            usage: { input: bucketOf('tokens', usage.input), cacheWrite: bucketOf('tokens', usage.cacheWrite), cacheRead: bucketOf('tokens', usage.cacheRead), output: bucketOf('tokens', usage.output), thinking: bucketOf('tokens', usage.thinking) },
+            usage: {
+                input: observedBucket(usage.input, usageObserved, 'input'),
+                cacheWrite: observedBucket(usage.cacheWrite, usageObserved, 'cacheWrite'),
+                cacheRead: observedBucket(usage.cacheRead, usageObserved, 'cacheRead'),
+                output: observedBucket(usage.output, usageObserved, 'output'),
+                thinking: observedBucket(usage.thinking, usageObserved, 'thinking'),
+            },
             explore: projectExplore(strata?.explore),
-            frame: wireFrame(frame, strata),
+            ...(usageResponses === undefined ? {} : { usageResponses: bucketOf('count', usageResponses) }),
+            ...(intervention === undefined ? {} : { intervention }),
+            frame: wireFrame(frame, strata, gate, ts),
         });
     }
+    // The frames the steps ran in: the transcript's own first, then one for each distinct (prompt frame, call model, call harness version) a call shows, so a model that changes in the middle of a prompt
+    // reaches the steps that ran on it. A call that recorded neither takes its prompt's frame, or the transcript's before the first prompt.
+    const reach = reachOf(session, tools, harness, gate);
+    // The repo key and the bands describe the session, not a prompt, so they sit where the reach does. A session in no repository sends no key, and so does one whose record holds anything but a key's shape: the emitter is the privacy control.
+    const where = { reach, ...(session.repo !== null && REPO_KEY.test(session.repo) ? { repoKey: session.repo } : {}), ...coverage };
+    const transcriptFrame = { ...wireFrame(session.frame, session.strata, gate, session.tsFirst), ...where };
+    const frames = [transcriptFrame];
+    const frameAtKey = new Map([[JSON.stringify(transcriptFrame), 0]]);
+    const frameOfCall = ({ model, harnessVersion }, promptPosition) => {
+        const base = promptPosition === null ? undefined : framedPrompts[promptPosition]?.frame;
+        const held = {
+            ...(base ?? transcriptFrame),
+            ...(model === undefined ? {} : { model: wireString(gate, model) }),
+            ...(harnessVersion === null ? {} : { harnessVersion: wireString(gate, harnessVersion) }),
+            ...where,
+        };
+        const key = JSON.stringify(held);
+        const found = frameAtKey.get(key);
+        if (found !== undefined)
+            return found;
+        frames.push(held);
+        frameAtKey.set(key, frames.length - 1);
+        return frames.length - 1;
+    };
     const steppedTools = [];
+    const own = placesOf(tools);
     // The exact tokens of every step, by call and step, which the `remainingTokens` buckets below are computed from: a bucket of a sum is not a sum of buckets.
     const exact = [];
     let unrecorded = 0;
-    for (const tool of byCall(tools)) {
+    const ordered = byCall(tools);
+    for (const [at, tool] of ordered.entries()) {
         if (tool.steps === undefined)
             return null;
         const { side, prompt, status, durationMs } = tool;
+        const errorCode = wireErrorCode(tool);
+        const recoveryCalls = recoveryCallsOf(ordered, at);
         // A subagent's call names the prompt that spawned it, which its own transcript holds no record of: such a number takes the next position past the prompts, one per distinct number, so
         // the calls that shared a prompt still share one, and no position reads as a prompt.
         if (prompt !== null && !promptAt.has(prompt))
             promptAt.set(prompt, framedPrompts.length + unrecorded++);
         const promptPosition = prompt === null ? null : (promptAt.get(prompt) ?? null);
-        const projected = projectedSteps(tool, read, harness);
-        exact.push(projected.map(({ cost }) => cost.tokens ?? 0));
-        const steps = projected.map(({ action, native, identity, status: reported, cost, parent }) => ({
-            action,
-            native,
-            identity,
-            status: reported,
-            tokens: cost.tokens === null ? null : bucketOf('tokens', cost.tokens),
-            ms: cost.durationMs === null ? null : bucketOf('ms', cost.durationMs),
-            remainingTokens: 0,
-            agentType,
-            parent: parent === null || spawners === null ? null : (spawners.get(parent) ?? null),
-        }));
-        steppedTools.push({ side, prompt: promptPosition, status, durationMs, steps });
+        const projected = projectedSteps(tool, read, harness, gate);
+        exact.push(projected.map(({ cost }) => cost.tokens));
+        const frame = frameOfCall(tool, promptPosition);
+        const steps = projected.map(({ action, native, identity, status: reported, cost, parent, edges }) => {
+            // An edge names a step by its position in the transcript it sits in; a `spawned` edge sits in the spawner, and one with no spawner in the batch goes unsent, since it names nothing here.
+            const arriving = edges.flatMap(({ kind, n: from, seg: fromSeg }) => {
+                const target = (kind === 'spawned' ? spawner?.places : own)?.steps.get(`${String(from)}/${String(fromSeg)}`);
+                return target === undefined ? [] : [{ kind, target }];
+            });
+            return {
+                action,
+                native,
+                identity,
+                status: reported,
+                tokens: cost.tokens === null ? null : bucketOf('tokens', cost.tokens),
+                ms: cost.durationMs === null ? null : bucketOf('ms', cost.durationMs),
+                ...(cost.allocated === true ? { allocated: true } : {}),
+                remainingTokens: 0,
+                agentType,
+                parent: parent === null || spawner === null ? null : (spawner.places.calls.get(parent) ?? null),
+                frame,
+                ...(arriving.length === 0 ? {} : { edges: arriving }),
+                ...(tool.skill === undefined ? {} : { skill: wireName(gate, tool.skill) }),
+            };
+        });
+        const { keys, dropped } = wireKeys(tool.keys, steps[0]?.native, gate);
+        const targetClass = memberOf(TARGET_CLASSES, tool.targetClass);
+        const stored = tool.argClass;
+        const argClass = stored === undefined ? undefined : ARG_CLASSES.filter((kind) => stored.includes(kind));
+        steppedTools.push({
+            side,
+            prompt: promptPosition,
+            status,
+            durationMs,
+            errorCode,
+            ...(recoveryCalls === null ? {} : { recoveryCalls }),
+            ...(keys.length === 0 ? {} : { keys }),
+            ...(dropped === 0 ? {} : { keysDropped: bucketOf('count', dropped) }),
+            ...(targetClass === undefined ? {} : { targetClass }),
+            ...(argClass === undefined ? {} : { argClass: argClass.sort() }),
+            steps,
+        });
     }
     // A step's remaining tokens are those of the steps after it in its own run; a main-run step also counts the subagent runs its later steps spawned (a run belongs to the spawning call's carrier step).
+    // `later` sums the steps that reported tokens; `laterKnown` is how many did, so a run whose later steps all reported nothing stays null instead of reading as zero.
     let later = 0;
+    let laterSteps = 0;
+    let laterKnown = 0;
     for (let call = steppedTools.length - 1; call >= 0; call -= 1) {
         const steps = steppedTools[call]?.steps ?? [];
         const held = carrier(steps);
@@ -184,25 +379,41 @@ const transcriptOf = ({ session, prompts, tools, root }, spawners, spawned, agen
             const step = steps[at];
             if (step === undefined)
                 continue;
-            step.remainingTokens = bucketOf('tokens', later);
-            later += (exact[call]?.[at] ?? 0) + (at === held ? (spawned.get(call) ?? 0) : 0);
+            step.remainingTokens = laterSteps > 0 && laterKnown === 0 ? null : bucketOf('tokens', later);
+            const own = exact[call]?.[at] ?? null;
+            const spawnedTokens = at === held ? (spawned.get(call) ?? 0) : 0;
+            later += (own ?? 0) + spawnedTokens;
+            laterSteps += 1;
+            if (own !== null || spawnedTokens > 0)
+                laterKnown += 1;
         }
     }
-    return { merkleRoot: root.merkleRoot, leaves: root.leaves, harness, frame: wireFrame(session.frame, session.strata), prompts: framedPrompts, tools: steppedTools };
+    return { merkleRoot: root.merkleRoot, leaves: root.leaves, harness, frame: transcriptFrame, frames, spawnedIn: spawner?.index ?? null, prompts: framedPrompts, tools: steppedTools };
 };
 /**
  * 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 = []) => {
+export const skeletonOf = (records, id, read, print, deltas = [], gate = OPEN_GATE, coverage = NO_COVERAGE) => {
     const mainTools = byCall(records.transcripts[0]?.tools ?? []);
-    // A subagent's step names the call that spawned it by that call's `n` in the main run, which the skeleton holds as the call's position.
-    const spawners = new Map(mainTools.map(({ n }, position) => [n, position]));
-    const spawnedBy = (entry) => entry.session.spawnedIn === records.main.session;
+    const places = records.transcripts.map(({ tools }) => placesOf(tools));
+    const spawners = places[0]?.calls ?? new Map();
+    // A subagent's step names the call that spawned it by that call's `n` in the transcript its session record names as `spawnedIn`, which the skeleton holds as a position in the batch: that transcript's, and the call's within it.
+    // A record that names none the batch holds, or itself, or lies on a cycle of spawners, sends no link; one whose spawner sits on a cycle it is not on keeps its link.
+    const spawnerOf = records.transcripts.map(({ session }, index) => {
+        const at = index === 0 || session.spawnedIn === null ? -1 : records.transcripts.findIndex((held) => held.session.session === session.spawnedIn);
+        return at === -1 ? null : at;
+    });
+    const cyclic = (index) => {
+        let at = spawnerOf[index] ?? null;
+        for (let hop = 0; hop < spawnerOf.length && at !== null && at !== index; hop += 1)
+            at = spawnerOf[at] ?? null;
+        return at === index;
+    };
     // The exact tokens of the runs each main-run call spawned. A run a subagent spawned names a call of that other transcript, so it joins no main-run step.
     const spawned = new Map();
-    for (const entry of records.transcripts.slice(1)) {
-        if (!spawnedBy(entry))
+    for (const [index, entry] of records.transcripts.entries()) {
+        if (spawnerOf[index] !== 0)
             continue;
         for (const tool of entry.tools) {
             for (const { cost, parent } of tool.steps ?? []) {
@@ -214,17 +425,23 @@ export const skeletonOf = (records, id, read, print, deltas = []) => {
     }
     const transcripts = [];
     for (const [index, entry] of records.transcripts.entries()) {
-        // Only a call of the main run has a position here: a step of a subagent a subagent spawned names a call of that other transcript, so it sends no link rather than a false one.
-        const transcript = transcriptOf(entry, index > 0 && spawnedBy(entry) ? spawners : null, index === 0 ? spawned : new Map(), index === 0 ? null : projectedAgentType(entry.session.agentType ?? CUSTOM_AGENT), read);
+        const at = spawnerOf[index] ?? null;
+        const spawnerPlaces = at === null || cyclic(index) ? undefined : places[at];
+        const transcript = transcriptOf(entry, at === null || spawnerPlaces === undefined ? null : { index: at, places: spawnerPlaces }, index === 0 ? spawned : new Map(), index === 0 ? null : projectedAgentType(entry.session.agentType ?? CUSTOM_AGENT), read, gate, coverage);
         if (transcript === null)
             return null;
         transcripts.push(transcript);
     }
     const durations = mainTools.flatMap(({ durationMs }) => (durationMs === null ? [] : [durationMs]));
-    return { format: SKELETON_FORMAT, 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] };
 };
-/** A harness version a bundle can be asked for: public, so the request carries nothing private. The admitted list replaces this shape rule when it ships. */
-export const isBundleVersion = (version) => version !== LITERAL && publicVersion(version) === version;
+/**
+ * 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
+ * `<harness>/unknown/<model>`. It is the one non-numeric word a bundle can be asked for, so those harnesses are served the cells they have.
+ */
+export const UNKNOWN_VERSION = 'unknown';
+/** A harness version a bundle can be asked for: public, so the request carries nothing private, or `unknown` for a harness with none on record. The admitted list replaces this shape rule when it ships. */
+export const isBundleVersion = (version) => version === UNKNOWN_VERSION || (version !== LITERAL && publicVersion(version) === version);
 /** Whether `name` is a harness the schema names. */
 export const isHarness = (name) => HARNESSES.some((harness) => harness === name);
 class Refused extends Error {
@@ -238,16 +455,65 @@ class Refused extends Error {
 }
 const isFields = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const under = (at, key) => (at === '' ? key : `${at}.${key}`);
-/** The object at `at`, holding every field of `known` and, of the rest, only `optional`. Nothing unnamed passes, which is what keeps a class A field out. */
-const fieldsOf = (value, at, known, optional = []) => {
+/** The value a reader gives an enumerated field whose value it does not know (conclusion section 17, rule 3). */
+export const OTHER = 'other';
+/** The one way into the bag: an entry over `MAX_EXTENSION_BYTES` (as JSON, in UTF-8) is refused as too large at its path, whatever kind it is and whatever the deposit's own cap is. */
+const bagged = (held, entry) => {
+    if (new TextEncoder().encode(JSON.stringify(entry.value)).length > MAX_EXTENSION_BYTES)
+        throw new Refused(entry.at, 'too large');
+    held.extensions.push(entry);
+};
+/**
+ * A value no vocabulary of this reader holds: counted, kept as sent in the bag, and read as `other`. The bag is the stored form of what the reader does not serve; the client's projection is the gate on what it
+ * sends (lead 194), so the pool keeps the value and serves nothing from it.
+ */
+const unknownValue = (held, at, sent) => {
+    held.others += 1;
+    bagged(held, { at, kind: 'value', value: sent });
+    return OTHER;
+};
+/** 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
+ * 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'],
+    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'],
+    step: ['tokens', 'ms', 'allocated', 'parent', 'skill', 'edges', 'remainingTokens'],
+    transcript: ['spawnedIn'],
+};
+/** 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';
+const FIELD_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+/**
+ * The object at `at`, holding every field of `known` and, of the rest, any of `optional`. A name that is neither is not refused: it goes to the bag as it came (rule 3), so a newer client loses nothing
+ * against this reader. The emitter is what keeps a class A field out of a batch, not this check. A shape error still refuses: a name that is no field name, a missing field, a literal that is not text.
+ */
+const fieldsOf = (held, value, at, known, optional = []) => {
     if (!isFields(value))
         throw new Refused(at === '' ? 'skeleton' : at, 'not an object');
-    for (const key of Object.keys(value))
-        if (!known.includes(key) && !optional.includes(key))
-            throw new Refused(under(at, key), 'not a field of a skeleton');
     for (const key of known)
         if (!Object.hasOwn(value, key))
             throw new Refused(under(at, key), 'missing');
+    for (const key of Object.keys(value)) {
+        if (known.includes(key) || optional.includes(key))
+            continue;
+        if (!FIELD_NAME.test(key))
+            throw new Refused(under(at, key), 'not a field name');
+        const entry = value[key];
+        const stem = key.endsWith(LITERAL_SUFFIX) ? key.slice(0, -LITERAL_SUFFIX.length) : undefined;
+        // A literal sits beside an `other` and nowhere else; beside a value this reader knows it is a field it does not know.
+        const literal = stem !== undefined && ENUMERATED_FIELDS.has(stem) && (known.includes(stem) || optional.includes(stem)) && value[stem] === OTHER;
+        if (literal)
+            textOf(entry, under(at, key));
+        bagged(held, { at: under(at, key), kind: literal ? 'literal' : 'field', value: entry });
+    }
     return value;
 };
 const listOf = (value, at, item) => {
@@ -267,48 +533,67 @@ const countOf = (value, at) => {
         throw new Refused(at, 'not a count');
     return value;
 };
-const orNull = (value, at, item) => (value === null ? null : item(value, at));
+/** The allocation marker is `true` or absent: a depositor cannot say `false`, since an unmarked step is the measured one. */
+const allocatedOf = (value, at) => {
+    if (value !== true)
+        throw new Refused(at, 'not true');
+    return true;
+};
+/** An absent field reads as null: an optional field is absent or null alike. */
+const orNull = (value, at, item) => (value === null || value === undefined ? null : item(value, at));
+/** An absent list reads as empty. */
+const listOrEmpty = (value, at, item) => (value === undefined ? [] : listOf(value, at, item));
 const booleanOf = (value, at) => {
     if (typeof value !== 'boolean')
         throw new Refused(at, 'not a boolean');
     return value;
 };
-/** A value from a closed list; the list narrows the type, so no caller needs a cast. */
-const oneOf = (list, value, at) => {
-    const found = list.find((entry) => entry === value);
-    if (found === undefined)
-        throw new Refused(at, 'outside the vocabulary');
-    return found;
+/** A value from a closed list, or `other` for a text the list does not hold; the list narrows the type, so no caller needs a cast. A value that is no text is a shape error. */
+const oneOf = (held, list, value, at) => {
+    const name = textOf(value, at);
+    return list.find((entry) => entry === name) ?? (name === OTHER ? OTHER : unknownValue(held, at, name));
 };
-const inSet = (allowed, value, at) => {
+const inSet = (held, allowed, value, at) => {
     const name = textOf(value, at);
-    if (name !== PRIVATE && !allowed.has(name))
-        throw new Refused(at, 'outside the vocabulary');
-    return name;
+    return name === PRIVATE || name === OTHER || allowed.has(name) ? name : unknownValue(held, at, name);
 };
-const exactlyIn = (allowed) => (value, at) => {
-    if (typeof value !== 'string' || !allowed.has(value))
-        throw new Refused(at, 'outside the vocabulary');
-    return value;
+/** A long-tail name field: `private`, `other`, or a name (the pool assigns its class, `packages/pool/src/field-classes.ts`). A value that is no name is refused: a client that sends one has not run its gate. */
+const nameIn = (value, at, hasShape = isWireName) => {
+    const name = textOf(value, at);
+    if (name === PRIVATE || name === OTHER || hasShape(name))
+        return name;
+    throw new Refused(at, 'not a name');
 };
-/** `publicModel` and its like hand back what is public and the literal for what is not, so only a value they return unchanged is in the vocabulary. */
-const heldTo = (isHeld, value, at) => {
-    if (value === null)
+/** A model or harness version: null, or a long-tail name (`private`, `other`, the older client's literal, or a name). A value that is no name is set aside, as a native name is. */
+const nameOrNull = (held, value, at) => {
+    if (value === null || value === undefined)
         return null;
     const name = textOf(value, at);
-    if (isHeld(name) !== name)
-        throw new Refused(at, 'outside the vocabulary');
-    return name;
+    return name === LITERAL ? name : nameValue(held, name, at);
+};
+/** A long-tail name in a field whose value the pool classes: `private`, `other`, or a name; a value that is no name is set aside. */
+const nameValue = (held, name, at) => (name === PRIVATE || name === OTHER || isWireName(name) ? name : unknownValue(held, at, name));
+const exactlyIn = (held, allowed) => (value, at) => {
+    const name = textOf(value, at);
+    return allowed.has(name) || name === OTHER ? name : unknownValue(held, at, name);
+};
+/** `publicEffort` and its like hand back what is public and the literal for what is not, so only a value they return unchanged is in the vocabulary. */
+const heldTo = (held, isHeld, value, at) => {
+    if (value === null || value === undefined)
+        return null;
+    const name = textOf(value, at);
+    return name === OTHER || isHeld(name) === name ? name : unknownValue(held, at, name);
 };
 // `satisfies` checks every entry is a `Harness` but not that every `Harness` is listed; this refuses a list that leaves one out at compile time.
 const allHarnesses = (list) => list;
-export const HARNESSES = allHarnesses(['claude-code', 'cursor', 'codex', 'copilot', 'gemini', 'grok', 'vscode-copilot']);
+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)));
 /** 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();
 const REGISTRIES = [...PACKAGE_REGISTRIES, 'skill', 'plugin', 'mcp'];
 const DAY = /^\d{4}-\d{2}-\d{2}$/;
 const ID = /^[0-9a-f]{16}$/;
@@ -321,14 +606,40 @@ const isCalendarDay = (text) => {
 };
 /** The languages a share can name: the pinned list and `other`, which `projectLanguage` gives any language off the list. The frame's own `languages` stay closed to the list. */
 const SHARE_LANGUAGES = new Set([...LANGUAGES, 'other']);
-const parseLanguageShare = (value, at) => {
-    const raw = fieldsOf(value, at, ['language', 'languageShare']);
-    return { language: exactlyIn(SHARE_LANGUAGES)(raw.language, under(at, 'language')), languageShare: oneOf(LANGUAGE_SHARES, raw.languageShare, under(at, 'languageShare')) };
+const parseLanguageShare = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['language', 'languageShare']);
+    return { language: exactlyIn(held, SHARE_LANGUAGES)(raw.language, under(at, 'language')), languageShare: oneOf(held, LANGUAGE_SHARES, raw.languageShare, under(at, 'languageShare')) };
+};
+/** A reach, each list held to its own row; an unfilled reach lists nothing. A plugin has no pinned list, so only the word `private` stands for one. */
+const parseReach = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['filled', 'mcp', 'skills', 'plugins']);
+    const filled = booleanOf(raw.filled, under(at, 'filled'));
+    const reach = {
+        filled,
+        mcp: listOf(raw.mcp, under(at, 'mcp'), (entry, entryAt) => nameIn(entry, entryAt)),
+        skills: listOf(raw.skills, under(at, 'skills'), (entry, entryAt) => nameIn(entry, entryAt)),
+        plugins: listOf(raw.plugins, under(at, 'plugins'), (entry, entryAt) => inSet(held, NO_NAME, entry, entryAt)),
+    };
+    if (!filled && reach.mcp.length + reach.skills.length + reach.plugins.length > 0)
+        throw new Refused(at, 'an unfilled reach lists nothing');
+    return reach;
+};
+/** 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);
+    if (!REPO_KEY.test(text))
+        throw new Refused(at, 'outside the vocabulary');
+    return text;
 };
-const parseFrame = (value, at) => {
-    const raw = fieldsOf(value, at, ['harness', 'harnessVersion', 'model', 'effort', 'day', 'platform', 'shell', 'stack']);
+const parseHour = (value, at) => {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 23)
+        throw new Refused(at, 'not an hour');
+    return value;
+};
+const parseFrame = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['harness', 'platform', 'stack'], OPTIONAL.frame);
     const stackAt = under(at, 'stack');
-    const stack = fieldsOf(raw.stack, stackAt, ['languages', 'frameworks', 'size', 'languageShares']);
+    const stack = fieldsOf(held, raw.stack, stackAt, ['languages', 'frameworks'], OPTIONAL.stack);
     const day = orNull(raw.day, under(at, 'day'), (entry, entryAt) => {
         const text = textOf(entry, entryAt);
         if (!isCalendarDay(text))
@@ -336,19 +647,25 @@ const parseFrame = (value, at) => {
         return text;
     });
     return {
-        harness: oneOf(HARNESSES, raw.harness, under(at, 'harness')),
-        harnessVersion: heldTo(publicVersion, raw.harnessVersion, under(at, 'harnessVersion')),
-        model: heldTo(publicModel, raw.model, under(at, 'model')),
-        effort: heldTo(publicEffort, raw.effort, under(at, 'effort')),
+        harness: oneOf(held, HARNESSES, raw.harness, under(at, 'harness')),
+        harnessVersion: nameOrNull(held, raw.harnessVersion, under(at, 'harnessVersion')),
+        model: nameOrNull(held, raw.model, under(at, 'model')),
+        effort: heldTo(held, publicEffort, raw.effort, under(at, 'effort')),
         day,
-        platform: exactlyIn(PLATFORMS)(raw.platform, under(at, 'platform')),
-        shell: orNull(raw.shell, under(at, 'shell'), exactlyIn(SHELLS)),
+        platform: exactlyIn(held, PLATFORMS)(raw.platform, under(at, 'platform')),
+        shell: orNull(raw.shell, under(at, 'shell'), exactlyIn(held, SHELLS)),
         stack: {
-            languages: listOf(stack.languages, under(stackAt, 'languages'), exactlyIn(LANGUAGES)),
-            frameworks: listOf(stack.frameworks, under(stackAt, 'frameworks'), exactlyIn(FRAMEWORKS)),
-            size: orNull(stack.size, under(stackAt, 'size'), (entry, entryAt) => oneOf(REPO_SIZES, entry, entryAt)),
-            languageShares: listOf(stack.languageShares, under(stackAt, 'languageShares'), parseLanguageShare),
+            languages: listOf(stack.languages, under(stackAt, 'languages'), exactlyIn(held, LANGUAGES)),
+            frameworks: listOf(stack.frameworks, under(stackAt, 'frameworks'), exactlyIn(held, FRAMEWORKS)),
+            size: orNull(stack.size, under(stackAt, 'size'), (entry, entryAt) => oneOf(held, REPO_SIZES, entry, entryAt)),
+            languageShares: listOrEmpty(stack.languageShares, under(stackAt, 'languageShares'), (entry, entryAt) => parseLanguageShare(held, entry, entryAt)),
         },
+        ...(raw.reach === undefined ? {} : { reach: parseReach(held, raw.reach, under(at, 'reach')) }),
+        ...(raw.repoKey === undefined ? {} : { repoKey: parseRepoKey(raw.repoKey, under(at, 'repoKey')) }),
+        ...(raw.orgSize === undefined ? {} : { orgSize: oneOf(held, ORG_SIZES, raw.orgSize, under(at, 'orgSize')) }),
+        ...(raw.team === undefined ? {} : { team: oneOf(held, TEAMS, raw.team, under(at, 'team')) }),
+        ...(raw.repoVisibility === undefined ? {} : { repoVisibility: oneOf(held, REPO_VISIBILITIES, raw.repoVisibility, under(at, 'repoVisibility')) }),
+        ...(raw.hour === undefined ? {} : { hour: parseHour(raw.hour, under(at, 'hour')) }),
     };
 };
 const bucketIn = (kind, value, at) => {
@@ -356,70 +673,81 @@ const bucketIn = (kind, value, at) => {
         throw new Refused(at, 'not a bucket');
     return value;
 };
-const parseUsage = (value, at) => {
-    const raw = fieldsOf(value, at, ['input', 'cacheWrite', 'cacheRead', 'output', 'thinking']);
-    return {
-        input: bucketIn('tokens', raw.input, under(at, 'input')),
-        cacheWrite: bucketIn('tokens', raw.cacheWrite, under(at, 'cacheWrite')),
-        cacheRead: bucketIn('tokens', raw.cacheRead, under(at, 'cacheRead')),
-        output: bucketIn('tokens', raw.output, under(at, 'output')),
-        thinking: bucketIn('tokens', raw.thinking, under(at, 'thinking')),
-    };
+const parseUsage = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['input', 'cacheWrite', 'cacheRead', 'output', 'thinking']);
+    const bucket = (field) => orNull(raw[field], under(at, field), (entry, entryAt) => bucketIn('tokens', entry, entryAt));
+    return { input: bucket('input'), cacheWrite: bucket('cacheWrite'), cacheRead: bucket('cacheRead'), output: bucket('output'), thinking: bucket('thinking') };
 };
-const parsePull = (value, at) => {
-    const raw = fieldsOf(value, at, ['registry', 'name', 'version']);
-    const name = inSet(PUBLIC_PACKAGES, raw.name, under(at, 'name'));
+const parsePull = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['registry', 'name', 'version']);
+    const name = nameIn(raw.name, under(at, 'name'), isWirePullName);
     const version = orNull(raw.version, under(at, 'version'), (entry, entryAt) => {
         const text = textOf(entry, entryAt);
-        if (text !== LITERAL && !isRegistryVersion(text))
-            throw new Refused(entryAt, 'outside the vocabulary');
         // A version beside a masked name could identify it: capture masks the two together.
-        if (name === PRIVATE && text !== LITERAL)
-            throw new Refused(entryAt, 'a private name holds no version');
-        return text;
+        if (!PUBLIC_PACKAGES.has(name) && text !== LITERAL)
+            throw new Refused(entryAt, 'a name off the public list holds no version');
+        return text === LITERAL || text === OTHER || isRegistryVersion(text) ? text : unknownValue(held, entryAt, text);
     });
-    return { registry: oneOf(REGISTRIES, raw.registry, under(at, 'registry')), name, version };
+    return { registry: oneOf(held, REGISTRIES, raw.registry, under(at, 'registry')), name, version };
 };
-const parseFlag = (value, at) => {
+const parseFlag = (held, value, at) => {
     const flag = textOf(value, at);
-    if (!isWireFlag(flag))
-        throw new Refused(at, 'outside the vocabulary');
-    return flag;
+    return flag === PRIVATE || flag === OTHER || isWireFlag(flag) ? flag : unknownValue(held, at, flag);
+};
+/** What a reader sets aside whole: a part of a step it cannot read against a vocabulary. Its place is noted and its content kept as sent, as for any value it does not know (see `unknownValue`). */
+const setAside = (held, at, sent) => {
+    bagged(held, { at, kind: 'value', value: sent });
 };
-const parseIdentity = (harness, action, value, at) => {
+const parseIdentity = (held, harness, action, value, at) => {
     if (value === null)
         return null;
+    // An action this reader does not know holds an identity it cannot read: the step goes without one and the place of what it held is noted.
+    if (action === OTHER) {
+        setAside(held, at, value);
+        return null;
+    }
     if (action === 'shell.exec') {
-        const raw = fieldsOf(value, at, ['program', 'sub', 'flags'], ['pulls']);
-        // A program is a list member or `private`, and a `private` program holds no subcommand, flag, or pull.
+        const raw = fieldsOf(held, value, at, ['program', 'sub', 'flags'], ['pulls']);
+        // A program is a name, `private`, or `other`; only `other` holds no subcommand, flag, or pull here.
         const program = textOf(raw.program, under(at, 'program'));
-        if (program !== PRIVATE && !PUBLIC_PROGRAMS.has(program))
-            throw new Refused(under(at, 'program'), 'outside the vocabulary');
+        nameIn(program, under(at, 'program'));
+        // The subcommands, flags, and pulls of a program this reader does not know cannot be read against its lists: it takes none, and notes what it left.
+        if (program === OTHER) {
+            for (const key of ['sub', 'flags', 'pulls'])
+                if (raw[key] !== undefined && !(raw[key] === null || (Array.isArray(raw[key]) && raw[key].length === 0)))
+                    setAside(held, under(at, key), raw[key]);
+            return { program: OTHER, sub: null, flags: [] };
+        }
         if (program === PRIVATE) {
             if (!(Array.isArray(raw.flags) && raw.flags.length === 0))
                 throw new Refused(under(at, 'flags'), 'a private program holds no flags');
             if (raw.pulls !== undefined)
                 throw new Refused(under(at, 'pulls'), 'a private program holds no pulls');
         }
-        const subs = PUBLIC_SUBCOMMANDS.get(program) ?? new Set();
-        const sub = orNull(raw.sub, under(at, 'sub'), exactlyIn(subs));
-        const flags = listOf(raw.flags, under(at, 'flags'), parseFlag);
-        return raw.pulls === undefined ? { program, sub, flags } : { program, sub, flags, pulls: listOf(raw.pulls, under(at, 'pulls'), parsePull) };
+        // A private program holds no subcommand, so one it sends is set aside, as its flags are refused.
+        const sub = orNull(raw.sub, under(at, 'sub'), (entry, entryAt) => (program === PRIVATE ? unknownValue(held, entryAt, textOf(entry, entryAt)) : nameValue(held, textOf(entry, entryAt), entryAt)));
+        const flags = listOf(raw.flags, under(at, 'flags'), (entry, entryAt) => parseFlag(held, entry, entryAt));
+        return raw.pulls === undefined ? { program, sub, flags } : { program, sub, flags, pulls: listOf(raw.pulls, under(at, 'pulls'), (entry, entryAt) => parsePull(held, entry, entryAt)) };
     }
     if (action === 'mcp.call') {
-        const raw = fieldsOf(value, at, ['server', 'tool']);
-        const server = inSet(PUBLIC_MCP_SERVERS, raw.server, under(at, 'server'));
+        const raw = fieldsOf(held, value, at, ['server', 'tool']);
+        const server = nameIn(raw.server, under(at, 'server'));
         const tool = textOf(raw.tool, under(at, 'tool'));
         // The same rule capture applies (`callIdentity`), so a name it would have masked is refused here rather than stored.
-        if (tool !== LITERAL && !(ACTION_TABLES[harness].toolDelimited && isPublicMcpTool(server, tool)))
-            throw new Refused(under(at, 'tool'), 'outside the vocabulary');
-        return { server, tool };
+        if (harness === OTHER) {
+            // The name crosses as the literal, and what the client sent is kept in the bag.
+            if (tool !== OTHER && tool !== LITERAL)
+                setAside(held, under(at, 'tool'), tool);
+            return { server, tool: tool === OTHER ? tool : LITERAL };
+        }
+        const admitted = tool === LITERAL || tool === OTHER || (server !== PRIVATE && ACTION_TABLES[harness].toolDelimited && (isPublicMcpTool(server, tool) || isWireName(tool)));
+        return { server, tool: admitted ? tool : unknownValue(held, under(at, 'tool'), tool) };
     }
     if (action === 'skill.run')
-        return { skill: inSet(PUBLIC_SKILLS, fieldsOf(value, at, ['skill']).skill, under(at, 'skill')) };
+        return { skill: nameIn(fieldsOf(held, value, at, ['skill']).skill, under(at, 'skill')) };
     if (action === 'web.fetch' || action === 'web.search') {
-        const { host } = fieldsOf(value, at, ['host']);
-        return { host: orNull(host, under(at, 'host'), (entry, entryAt) => inSet(PUBLIC_HOSTS, entry, entryAt)) };
+        const { host } = fieldsOf(held, value, at, ['host']);
+        return { host: orNull(host, under(at, 'host'), (entry, entryAt) => nameIn(entry, entryAt)) };
     }
     throw new Refused(at, 'this action has no identity');
 };
@@ -427,59 +755,119 @@ const parseIdentity = (harness, action, value, at) => {
 const admittedNative = (harness, native) => {
     if (native === PRIVATE)
         return true;
+    if (harness === OTHER)
+        return false;
     const table = ACTION_TABLES[harness];
     if (Object.hasOwn(table.rows, native))
         return true;
     const mcp = mcpOf(table, native);
     return mcp !== undefined && table.toolDelimited && isPublicMcpTool(mcp.server, mcp.tool);
 };
-const parseNative = (harness, value, at) => {
+const parseNative = (held, harness, value, at) => {
     const native = textOf(value, at);
-    if (!admittedNative(harness, native))
-        throw new Refused(at, 'outside the vocabulary');
-    return native;
+    // The tools of a harness this reader does not know are off any table it holds, so they cross as `private`, the way capture masks a name its table lacks.
+    if (harness === OTHER)
+        return native === OTHER || isWireName(native) ? native : unknownValue(held, at, native);
+    return native === OTHER || admittedNative(harness, native) || isWireName(native) ? native : unknownValue(held, at, native);
 };
 /** A subagent type as the projection leaves it: a built-in of a harness, or `custom`; a custom agent's own name is private and never admitted. */
-const parseAgentType = (value, at) => {
+const parseAgentType = (held, value, at) => {
     const name = textOf(value, at);
-    if (projectedAgentType(name) !== name)
-        throw new Refused(at, 'outside the vocabulary');
-    return name;
+    return name === OTHER || projectedAgentType(name) === name ? name : unknownValue(held, at, name);
 };
-const parseStep = (harness, value, at) => {
-    const raw = fieldsOf(value, at, ['action', 'native', 'identity', 'status', 'tokens', 'ms', 'remainingTokens', 'agentType', 'parent']);
-    const action = oneOf(CANONICAL_ACTIONS, raw.action, under(at, 'action'));
+const parseEdge = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['kind', 'target']);
+    return { kind: oneOf(held, EDGE_KINDS, raw.kind, under(at, 'kind')), target: countOf(raw.target, under(at, 'target')) };
+};
+const parseStep = (held, harness, value, at) => {
+    const raw = fieldsOf(held, value, at, ['action', 'native', 'identity', 'status', 'agentType', 'frame'], OPTIONAL.step);
+    const action = oneOf(held, CANONICAL_ACTIONS, raw.action, under(at, 'action'));
     return {
         action,
-        native: parseNative(harness, raw.native, under(at, 'native')),
-        identity: parseIdentity(harness, action, raw.identity, under(at, 'identity')),
-        status: oneOf(STATUSES, raw.status, under(at, 'status')),
+        native: parseNative(held, harness, raw.native, under(at, 'native')),
+        identity: parseIdentity(held, harness, action, raw.identity, under(at, 'identity')),
+        status: oneOf(held, STATUSES, raw.status, under(at, 'status')),
         tokens: orNull(raw.tokens, under(at, 'tokens'), (entry, entryAt) => bucketIn('tokens', entry, entryAt)),
         ms: orNull(raw.ms, under(at, 'ms'), (entry, entryAt) => bucketIn('ms', entry, entryAt)),
-        remainingTokens: bucketIn('tokens', raw.remainingTokens, under(at, 'remainingTokens')),
-        agentType: orNull(raw.agentType, under(at, 'agentType'), parseAgentType),
+        ...(raw.allocated === undefined ? {} : { allocated: allocatedOf(raw.allocated, under(at, 'allocated')) }),
+        remainingTokens: orNull(raw.remainingTokens, under(at, 'remainingTokens'), (entry, entryAt) => bucketIn('tokens', entry, entryAt)),
+        agentType: orNull(raw.agentType, under(at, 'agentType'), (entry, entryAt) => parseAgentType(held, entry, entryAt)),
         parent: orNull(raw.parent, under(at, 'parent'), countOf),
+        frame: countOf(raw.frame, under(at, 'frame')),
+        ...(raw.edges === undefined ? {} : { edges: listOf(raw.edges, under(at, 'edges'), (entry, entryAt) => parseEdge(held, entry, entryAt)) }),
+        ...(raw.skill === undefined ? {} : { skill: nameIn(raw.skill, under(at, 'skill')) }),
     };
 };
-const parseTool = (harness, value, at) => {
-    const raw = fieldsOf(value, at, ['side', 'prompt', 'status', 'durationMs', 'steps']);
+/** A call's `errorCode`: absent or null is none; otherwise a member of the closed list (a value off it reads as `other` and goes to the bag), and only on a call that did not succeed or sit out. */
+const parseErrorCode = (held, status, value, at) => {
+    if (value === undefined || value === null)
+        return null;
+    const code = exactlyIn(held, ERROR_CODES)(value, at);
+    if (status === 'ok' || status === 'none')
+        throw new Refused(at, 'only a failed call has one');
+    return code;
+};
+/** A call's `recoveryCalls`: absent is none; otherwise at most 5 actions (a value off the list reads as `other`) and a flag, and only on a call that did not succeed or sit out; the transcript parse then refuses one on a call whose status is not `error`. */
+const parseRecovery = (held, status, value, at) => {
+    if (value === undefined)
+        return undefined;
+    if (status === 'ok' || status === 'none')
+        throw new Refused(at, 'only a failed call has one');
+    const raw = fieldsOf(held, value, at, ['next', 'editFollowed']);
+    const next = listOf(raw.next, under(at, 'next'), (entry, entryAt) => oneOf(held, CANONICAL_ACTIONS, entry, entryAt));
+    if (next.length > RECOVERY_CALLS)
+        throw new Refused(under(at, 'next'), `more than ${String(RECOVERY_CALLS)} calls`);
+    return { next, editFollowed: booleanOf(raw.editFollowed, under(at, 'editFollowed')) };
+};
+/**
+ * A call's `keys`: absent is none. A tool with a pinned input list sends names on it, and a name off it reads as `other` and goes to the bag; any other tool's names must have the shape of a name. Key names
+ * only, so a value that is no name shape is not a key.
+ */
+const parseKeys = (held, native, value, at) => {
+    if (value === undefined)
+        return undefined;
+    const listed = native === undefined ? undefined : TOOL_INPUT_KEYS.get(native);
+    return listOf(value, at, (entry, entryAt) => {
+        const name = textOf(entry, entryAt);
+        return (listed === undefined ? isWireName(name) : listed.has(name)) ? name : unknownValue(held, entryAt, name);
+    });
+};
+const parseTool = (held, harness, value, at) => {
+    const raw = fieldsOf(held, value, at, ['side', 'status', 'steps'], OPTIONAL.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'));
+    const steps = listOf(raw.steps, under(at, 'steps'), (entry, entryAt) => parseStep(held, harness, entry, entryAt));
+    const keys = parseKeys(held, steps[0]?.native, raw.keys, under(at, 'keys'));
+    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));
     return {
         side: booleanOf(raw.side, under(at, 'side')),
         prompt: orNull(raw.prompt, under(at, 'prompt'), countOf),
-        status: oneOf(STATUSES, raw.status, under(at, 'status')),
+        status,
         durationMs: orNull(raw.durationMs, under(at, 'durationMs'), countOf),
-        steps: listOf(raw.steps, under(at, 'steps'), (entry, entryAt) => parseStep(harness, entry, entryAt)),
+        errorCode,
+        ...(recoveryCalls === undefined ? {} : { recoveryCalls }),
+        ...(keys === undefined ? {} : { keys }),
+        ...(keysDropped === undefined ? {} : { keysDropped }),
+        ...(targetClass === undefined ? {} : { targetClass }),
+        ...(argClass === undefined ? {} : { argClass }),
+        steps,
     };
 };
-const parsePrompt = (value, at) => {
-    const raw = fieldsOf(value, at, ['cls', 'errors', 'wallSec', 'usage', 'explore', 'frame']);
+const parsePrompt = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['cls', 'errors', 'usage', 'frame'], OPTIONAL.prompt);
     return {
-        cls: oneOf(PROMPT_CLASSES, raw.cls, under(at, 'cls')),
+        cls: oneOf(held, PROMPT_CLASSES, raw.cls, under(at, 'cls')),
         errors: bucketIn('count', raw.errors, under(at, 'errors')),
         wallSec: orNull(raw.wallSec, under(at, 'wallSec'), (entry, entryAt) => bucketIn('seconds', entry, entryAt)),
-        usage: parseUsage(raw.usage, under(at, 'usage')),
+        usage: parseUsage(held, raw.usage, under(at, 'usage')),
         explore: orNull(raw.explore, under(at, 'explore'), (entry, entryAt) => bucketIn('calls', entry, entryAt)),
-        frame: parseFrame(raw.frame, under(at, 'frame')),
+        ...(raw.usageResponses === undefined ? {} : { usageResponses: bucketIn('count', raw.usageResponses, under(at, 'usageResponses')) }),
+        // A sent null reads as an absent field, the way every optional field does.
+        ...(raw.intervention === undefined || raw.intervention === null ? {} : { intervention: oneOf(held, PROMPT_INTERVENTIONS, raw.intervention, under(at, 'intervention')) }),
+        frame: parseFrame(held, raw.frame, under(at, 'frame')),
     };
 };
 const ROOT = /^[0-9a-f]{64}$/;
@@ -490,17 +878,24 @@ const parseRoot = (value, at) => {
         throw new Refused(at, 'not a SHA-256');
     return root;
 };
-const parseTranscript = (value, at) => {
-    const raw = fieldsOf(value, at, ['merkleRoot', 'leaves', 'harness', 'frame', 'prompts', 'tools']);
-    const harness = oneOf(HARNESSES, raw.harness, under(at, 'harness'));
-    return {
-        merkleRoot: parseRoot(raw.merkleRoot, under(at, 'merkleRoot')),
-        leaves: countOf(raw.leaves, under(at, 'leaves')),
-        harness,
-        frame: parseFrame(raw.frame, under(at, 'frame')),
-        prompts: listOf(raw.prompts, under(at, 'prompts'), parsePrompt),
-        tools: listOf(raw.tools, under(at, 'tools'), (entry, entryAt) => parseTool(harness, entry, entryAt)),
-    };
+const parseTranscript = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['merkleRoot', 'leaves', 'harness', 'frame', 'frames', 'prompts', 'tools'], OPTIONAL.transcript);
+    const harness = oneOf(held, HARNESSES, raw.harness, under(at, 'harness'));
+    const merkleRoot = parseRoot(raw.merkleRoot, under(at, 'merkleRoot'));
+    const leaves = countOf(raw.leaves, under(at, 'leaves'));
+    // Read in the order the fields are met, so the bag holds what was set aside in that order.
+    const frame = parseFrame(held, raw.frame, under(at, 'frame'));
+    const frames = listOf(raw.frames, under(at, 'frames'), (entry, entryAt) => parseFrame(held, entry, entryAt));
+    // Absent reads as null: a client that names no spawner sends none.
+    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.
+    tools.forEach((tool, index) => {
+        if (tool.recoveryCalls !== undefined && JSON.stringify(tool.recoveryCalls) !== JSON.stringify(recoveryCallsOf(tools, index)))
+            throw new Refused(`${at}.tools[${String(index)}].recoveryCalls`, 'not what followed the call');
+    });
+    return { merkleRoot, leaves, harness, frame, frames, spawnedIn, prompts, tools };
 };
 const DELTA_FIELDS = ['plugin', 'package', 'permissionMode', 'effort'];
 /** The kinds each field can take: a plugin comes or goes, a package only goes (an addition is adoption, which `pool` reads from the calls), and a mode or an effort changes. */
@@ -508,7 +903,8 @@ const KINDS_OF = { plugin: ['added', 'removed'], package: ['removed'], permissio
 /** The one metric each field's change is measured in, and the bucket edges that metric is held to. */
 const METRIC_OF = { plugin: 'callsPerSession', package: 'callsPerSession', permissionMode: 'callsPerSession', effort: 'thinking' };
 const METRIC_EDGES = { callsPerSession: 'count', thinking: 'tokens' };
-const NO_NAME = new Set();
+const ALL_KINDS = ['added', 'removed', 'changed'];
+const ALL_METRICS = ['callsPerSession', 'thinking'];
 const nullOnly = (value, at) => {
     if (value !== null)
         throw new Refused(at, 'outside the vocabulary');
@@ -518,32 +914,47 @@ const nullOnly = (value, at) => {
  * The entry of a delta, held to its field's own row. A plugin has no registry to pass, so only the word `private` stands for one; a package is a public name with its registry, or `private` with none; a mode
  * and an effort are named by their field and carry no name. The change is a signed bucket of the field's metric.
  */
-const parseDelta = (value, at) => {
-    const raw = fieldsOf(value, at, ['deltaKind', 'field', 'name', 'registry', 'metric', 'change']);
-    const field = oneOf(DELTA_FIELDS, raw.field, under(at, 'field'));
-    const deltaKind = oneOf(KINDS_OF[field], raw.deltaKind, under(at, 'deltaKind'));
-    const metric = oneOf([METRIC_OF[field]], raw.metric, under(at, 'metric'));
-    const name = field === 'plugin' || field === 'package' ? inSet(field === 'package' ? PUBLIC_PACKAGES : NO_NAME, raw.name, under(at, 'name')) : nullOnly(raw.name, under(at, 'name'));
-    const registry = field === 'package' && name !== PRIVATE ? oneOf(PACKAGE_REGISTRIES, raw.registry, under(at, 'registry')) : nullOnly(raw.registry, under(at, 'registry'));
+const parseDelta = (held, value, at) => {
+    const raw = fieldsOf(held, value, at, ['deltaKind', 'field', 'name', 'registry', 'metric', 'change']);
+    const field = oneOf(held, DELTA_FIELDS, raw.field, under(at, 'field'));
+    // A field this reader does not know has no row to hold its kind, metric, name, or registry to: the first two read against every kind and metric, and the last two are kept as sent.
+    const kinds = field === OTHER ? ALL_KINDS : KINDS_OF[field];
+    const deltaKind = oneOf(held, kinds, raw.deltaKind, under(at, 'deltaKind'));
+    const metric = oneOf(held, field === OTHER ? ALL_METRICS : [METRIC_OF[field]], raw.metric, under(at, 'metric'));
+    const named = field === 'plugin' || field === 'package';
+    if (field === OTHER) {
+        for (const key of ['name', 'registry'])
+            if (raw[key] !== null)
+                setAside(held, under(at, key), raw[key]);
+    }
+    const name = named ? inSet(held, field === 'package' ? PUBLIC_PACKAGES : NO_NAME, raw.name, under(at, 'name')) : field === OTHER ? null : nullOnly(raw.name, under(at, 'name'));
+    const registry = field === 'package' && name !== PRIVATE ? oneOf(held, PACKAGE_REGISTRIES, raw.registry, under(at, 'registry')) : field === OTHER ? null : nullOnly(raw.registry, under(at, 'registry'));
     const change = raw.change;
-    if (typeof change !== 'number' || !Number.isInteger(change) || Math.abs(change) > EDGES[METRIC_EDGES[metric]].length)
+    const limit = metric === OTHER ? Math.max(...ALL_METRICS.map((kind) => EDGES[METRIC_EDGES[kind]].length)) : EDGES[METRIC_EDGES[metric]].length;
+    if (typeof change !== 'number' || !Number.isInteger(change) || Math.abs(change) > limit)
         throw new Refused(under(at, 'change'), 'not a signed bucket');
     return { deltaKind, field, name, registry, metric, change };
 };
-/** The skeleton in `value`, rebuilt from the fields read; else the first field that is not closed vocabulary, and why. */
+const VOCAB_TEXT = /^[0-9A-Za-z._-]{1,32}$/;
+/** 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 };
     try {
-        // The first form sent exact usage; it is named here, since its fields would otherwise read as a list of strangers.
-        if (isFields(value) && value.format === 1)
-            throw new Refused('format', 'the exact-count form (format 1) is no longer read; send format 2');
-        const raw = fieldsOf(value, '', ['format', 'id', 'transcripts', 'timingPrint', 'deltas']);
+        // 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)
+            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)
             throw new Refused('format', 'not a format this version reads');
+        const vocabVersion = textOf(raw.vocabVersion, 'vocabVersion');
+        if (!VOCAB_TEXT.test(vocabVersion))
+            throw new Refused('vocabVersion', 'not a version');
+        const fieldsVersion = countOf(raw.fieldsVersion, 'fieldsVersion');
         const id = textOf(raw.id, 'id');
         if (!ID.test(id))
             throw new Refused('id', 'not a hash');
-        const deltas = listOf(raw.deltas, 'deltas', parseDelta);
-        const transcripts = listOf(raw.transcripts, 'transcripts', parseTranscript);
+        const deltas = listOrEmpty(raw.deltas, 'deltas', (entry, entryAt) => parseDelta(held, entry, entryAt));
+        const transcripts = listOf(raw.transcripts, 'transcripts', (entry, entryAt) => parseTranscript(held, entry, entryAt));
         if (transcripts.length === 0)
             throw new Refused('transcripts', 'empty');
         // A counting batch is what lifts the fetch cap, so a deposit has to hold something to derive from.
@@ -569,20 +980,62 @@ export const parseSkeleton = (value) => {
             });
         });
         // Positions are the only ordinals on the wire, so each must name something the batch holds.
-        const mainCalls = transcripts[0]?.tools.length ?? 0;
-        transcripts.forEach(({ prompts, tools }, index) => {
+        // A spawner is another transcript of the batch whose own spawners lead to a run with none, so the batch is a forest and the main run is its first root.
+        transcripts.forEach(({ spawnedIn }, index) => {
+            if (spawnedIn === null)
+                return;
+            const spawnedAt = `transcripts[${String(index)}].spawnedIn`;
+            if (index === 0)
+                throw new Refused(spawnedAt, 'the main run has no spawner');
+            if (spawnedIn >= transcripts.length || spawnedIn === index)
+                throw new Refused(spawnedAt, 'no such transcript');
+            let above = spawnedIn;
+            for (let hop = 0; hop < transcripts.length && above !== null; hop += 1)
+                above = transcripts[above]?.spawnedIn ?? null;
+            if (above !== null)
+                throw new Refused(spawnedAt, 'a spawner cycle');
+        });
+        const stepsOf = transcripts.map(({ tools }) => tools.reduce((all, { steps }) => all + steps.length, 0));
+        transcripts.forEach(({ prompts, tools, frames, spawnedIn }, index) => {
+            if (frames.length === 0)
+                throw new Refused(`transcripts[${String(index)}].frames`, 'empty');
+            // The call and prompt of every step in the transcript's order, which an edge's target is a position in.
+            const placed = tools.flatMap(({ prompt, steps }) => steps.map(() => ({ prompt })));
+            let before = 0;
             tools.forEach(({ prompt, steps }, call) => {
                 const callAt = `transcripts[${String(index)}].tools[${String(call)}]`;
                 // Past the prompts it names a prompt with no record, numbered in order of appearance: no more of those than calls.
                 if (prompt !== null && prompt >= prompts.length + tools.length)
                     throw new Refused(`${callAt}.prompt`, 'no such prompt position');
-                steps.forEach(({ parent }, position) => {
-                    if (parent !== null && parent >= mainCalls)
-                        throw new Refused(`${callAt}.steps[${String(position)}].parent`, 'no such call in the main run');
+                steps.forEach(({ parent, frame, edges }, position) => {
+                    const stepAt = `${callAt}.steps[${String(position)}]`;
+                    if (parent !== null && (spawnedIn === null || parent >= (transcripts[spawnedIn]?.tools.length ?? 0)))
+                        throw new Refused(`${stepAt}.parent`, 'no such call in the spawning transcript');
+                    if (frame >= frames.length)
+                        throw new Refused(`${stepAt}.frame`, 'no such frame position');
+                    const here = before + position;
+                    (edges ?? []).forEach(({ kind, target }, edge) => {
+                        const edgeAt = `${stepAt}.edges[${String(edge)}]`;
+                        if (kind === OTHER)
+                            return;
+                        if (kind === 'spawned') {
+                            if (spawnedIn === null)
+                                throw new Refused(`${edgeAt}.kind`, 'a spawned edge needs a spawning transcript');
+                            if (target >= (stepsOf[spawnedIn] ?? 0))
+                                throw new Refused(`${edgeAt}.target`, 'no such step in the spawning transcript');
+                            return;
+                        }
+                        // The other kinds name an earlier step of the same transcript; a next stays inside one prompt.
+                        if (target >= here)
+                            throw new Refused(`${edgeAt}.target`, 'not an earlier step of this transcript');
+                        if (kind === 'next' && placed[target]?.prompt !== prompt)
+                            throw new Refused(`${edgeAt}.target`, 'a next edge crosses a prompt');
+                    });
                 });
+                before += steps.length;
             });
         });
-        return { ok: true, skeleton: { format: SKELETON_FORMAT, id, transcripts, timingPrint, deltas } };
+        return { ok: true, skeleton: { format: SKELETON_FORMAT, vocabVersion, fieldsVersion, id, transcripts, timingPrint, deltas }, extensions: held.extensions, others: held.others };
     }
     catch (error) {
         if (error instanceof Refused)
@@ -591,7 +1044,34 @@ export const parseSkeleton = (value) => {
     }
 };
 const isSignedBundle = (value) => isFields(value) && typeof value.payload === 'string' && typeof value.signature === 'string';
-const isBundle = (value) => isFields(value) && value.format === BUNDLE_FORMAT && typeof value.harness === 'string' && isHarness(value.harness) && typeof value.harnessVersion === 'string' && typeof value.vocabVersion === 'string' && isFields(value.asOf) && Array.isArray(value.cells) && Array.isArray(value.motifs) && Array.isArray(value.reads) && Array.isArray(value.strata);
+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 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. */
+const isBooks = (value) => isFields(value) &&
+    isFloor(value.floor) &&
+    value.format === BUNDLE_FORMAT &&
+    typeof value.vocabVersion === 'string' &&
+    isFields(value.asOf) &&
+    (value.asOf.day === null || typeof value.asOf.day === 'string') &&
+    isFields(value.served) &&
+    isCount(value.served.total) &&
+    Array.isArray(value.served.byWeek) &&
+    Array.isArray(value.served.byTuple) &&
+    isCount(value.backlog) &&
+    isSourced(value.panel) &&
+    (value.panelDay === null || typeof value.panelDay === 'string') &&
+    isFields(value.demand) &&
+    isSourced(value.demand.comparisonReadOwners) &&
+    isSourced(value.demand.followOnReads) &&
+    isFields(value.goal) &&
+    isSourced(value.goal.readYield) &&
+    isSourced(value.goal.costPerServedCell) &&
+    isSourced(value.goal.yieldPerServedCell);
+// A bundle states the floor it applied (`floor`), and a client cannot tell which floor a bundle without one applied, so a format 1 bundle with no `floor` is refused as not a bundle this version reads.
+const isBundle = (value) => isFields(value) && value.format === BUNDLE_FORMAT && typeof value.harness === 'string' && isHarness(value.harness) && typeof value.harnessVersion === 'string' && typeof value.vocabVersion === 'string' && typeof value.floor === 'number' && isFields(value.asOf) && Array.isArray(value.cells) && Array.isArray(value.motifs) && Array.isArray(value.reads) && Array.isArray(value.strata) && (value.floors === undefined || isFloors(value.floors)) && (value.books === undefined || isBooks(value.books));
 const signatureHolds = async ({ payload, signature }, key) => {
     try {
         const verifier = await crypto.subtle.importKey('jwk', { kty: key.kty, crv: key.crv, x: key.x }, 'Ed25519', false, ['verify']);