Skip to content

oars 0.4.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 14:22
· 1526 commits to main since this release

Changes since 0.3.0. The next-node read (hook install adds UserPromptSubmit, and recall reads the kept pool bundle for the session's own harness), the raw-log consent prompt, the nightly send, Pi coding agent sessions (--allow pi), and quoting of a Codex argv word that holds a space.

  • oars sessions deposit --allow pi reads Pi coding agent session files (~/.pi/agent/sessions, or $PI_CODING_AGENT_DIR) into the same store as the other harnesses: harness: pi, the active branch of its entry tree, the real exit code of a failed shell call, and usage that Pi already reports net of cache reads. The reader is written from Pi's public docs and source and has never run against a live store (docs/sessions-store.md, "The Pi source", names the hand run that would settle it); pool fetch --harness pi and the closed telemetry list accept the new harness name.
  • A Codex shell call sent as an argv keeps a word that holds a space or quote as one quoted word (bash -lc 'git revert HEAD'), so a git undo run through the wrapper reads as revert the way it does on the other harnesses (CAPTURE_VERSION 25, so the next deposit re-reads every transcript).
  • Public text states what the code does at this commit (t897): the READMEs, docs/, the CLI help, the telemetry notice, the raw prompt, and the package description no longer say the pool is reachable, that a batch is always printed before the nightly task sends it, that raw/ content never leaves (a redacted copy does, after a yes to the raw prompt), or that oars sessions uploads nothing; figures from one machine are removed from docs/gate.md. Every claim checked, with its evidence, is in docs/copy-audit.md.
  • The next-node read (t926). hook install adds UserPromptSubmit and widens PostToolUseFailure to every tool the action table maps. Recall reads the kept pool bundle for the session's own harness and version beside the local store (pool-replica.ts, shared with pool fetch; none or a corrupt one is local only). A failed call is answered with what followed that failure (same action and error class), silent on a same-step retry or a local edge under 5 followed steps; SessionStart (and UserPromptSubmit, when it changed) adds a table of the positions where earlier sessions split on the next step (at most 600 bytes). Every such read is a recalls.jsonl row under the 10 percent holdback, and the old post-tool signature line moves under it too, so measure's hookHitsPerSession falls: a post-tool hit now needs a read that was served or held back. The pre-tool push keeps its gate role and no longer pushes a base rate: it needs a shape that fails half its calls or more (PUSH_FLOORS). Telemetry's hook name list gains prompt.
  • The send lock treats EPERM and EACCES on Windows as contention, like EEXIST: an open that meets a delete still pending on the lock file is retried within the wait instead of failing the send.
  • The raw prompt names every class the redactor cannot make safe, localNames falls back to USER or USERNAME when the account has no passwd entry (a container run with --user <uid>), and a stale send lock is taken over under a guard file that re-reads the lock first, so a live lock is never moved or removed, and a waiter gives up after its wait even while a guard is held (t884).
  • The raw copy masks a local name before the path rules run, and also in its encoded-folder form, so a hyphenated or spaced name (mary-jane, John Smith) is masked whole in C:\Users\... and C--Users-... instead of leaving its second word (t884). A name that is a common word (dev, node, app) is masked wherever it stands as a word, which mangles the copy but never leaks a name. docs/sessions-store.md lists both under what the redactor cannot catch.
  • The send lock is kept alive while its holder runs (touched every quarter of the stale window), a stale lock is taken over by one waiter only (under a guard file), and a run removes the lock only if it still names that run, so a long first night of raw parts cannot be taken over by a second sender (t884).
  • The redacted raw copy masks the local username (the account's and the home folder's name, as a whole word, as <user>), the harness's encoded project folders (-Users-name-, C--Users-name-, -home-name-), shell prompts (name@box:~$), and IPv6 addresses. REDACTION_VERSION is 1, the first shipped rule set. After an explicit no to the raw prompt, deposit says so and names oars pool raw --consent yes; verify says rawMasked counts placeholders (t884).
  • The nightly task sends the pool outbox after covenant acceptance (t884): new skeleton batches, and the redacted raw copies (PUT /v1/raw/:sha256/parts/:n, then /complete) only after a yes to the raw prompt and for a folder not at skeleton only or off. It never accepts a covenant; with an unusable server, no sign-in, or no acceptance it sends nothing. Sent hashes are kept in sent.log, a failed night is picked up the next night, and pool-nightly.json records counts only. oars pool outbox prints what is queued when you run it; the nightly task builds new batches and sends them in the same run without printing them first. The README and docs/pool.md sentences that said nothing is sent are corrected.
  • The nightly send and deposit --send take one send lock per outbox (a send.lock file beside sent.log), so two runs wait for each other instead of posting one batch twice (one case is left: two waiters that clear a dead guard file at the same moment can both take it over); --send records the hash it sent in sent.log too and skips a hash that file already holds (one line, "already sent at ", exit 0, no request), the rule the nightly follows, and oars pool outbox marks each sent batch and raw copy sent: <time> (text and document). oars sessions verify reports sentBatches and sentRaw beside staleBatches, and rawCopies and rawMasked, the values masked in the queued raw copies. The deposit summary names the real command, oars pool raw --consent yes.
  • oars sessions deposit --allow otel reads agent traces written in the OpenTelemetry GenAI conventions (OTLP JSON files in the folder OARS_OTEL_TRACES names, else <config>/oars/otel-traces) into the same store as the coding harnesses, with the same field classes, redaction, and verify checks (t927). It is convention-derived and has not run on a real trace; see docs/sessions-store.md.
  • Capture keeps a skill-run name, a web host, and a pull's package name as they are after your redaction (t903, CAPTURE_VERSION 24, so the next deposit re-reads every transcript from the harness or raw/): before, each was <literal> unless a public list held it, so pool deposit had no name to send for a real session. <literal> stays for a value your redaction changes, that is not a name, or that is over 128 characters, and a pull's version is still masked beside a package no public list holds. They leave the machine only in pool batches built through pool deposit's one gate (your exclusion terms apply there), sent by deposit --send or the nightly task, and pool outbox prints what is queued when you run it. A transcript neither the harness nor raw/ still holds keeps its <literal> values.
  • Three interventions read what the transcript shows (CAPTURE_VERSION 23, EXTRACTOR_VERSION 15, so the next deposit re-derives the store from its log): git checkout feature/x and git checkout "fix-1" no longer read revert, and a checkout with an unlisted flag such as --ours reads revert when it restores a file; capture keeps whether the target was a path or a word, never its text, and a step captured before keeps its old reading. A Codex decline (exec command rejected by user, patch rejected by user) and interrupted turn, and Gemini CLI's [Operation Cancelled] User cancelled ..., read user-stop by their fixed text or record type. A Codex turn_aborted with reason interrupted is now written as the interrupt marker prompt (CAPTURE 23), so it sets stopped interrupt as Claude Code's does and that session's prompt count, tsLast, and skeleton move; a decline leaves stopped null. That changes the user-stop bullet below (EXTRACTOR_VERSION 14) where it says Codex records no interrupt marker as a prompt record: a Codex interrupt now does, and Codex and Gemini declines still do not. The same bullet's "so their prompts read as before" is also no longer true for Codex and Gemini declines: their declines no longer read as before, they read user-stop. docs/sessions-store.md has the table by harness.
  • oars sessions deposit --allow opencode reads OpenCode (sst/opencode) sessions into the same store as Claude Code, Cursor, Codex, Copilot, Gemini CLI, and Grok Build (t924): skeletons with harness: opencode, the same field classes and redaction, and the same recall, measure, books, and verify. It reads opencode.db read-only, and was written from OpenCode's public source (MIT) and tested on synthetic fixtures; it has never run against a live store (see docs/sessions-store.md). A new source takes no CAPTURE_VERSION.
  • Served cells carry what they cover, and a step with no recorded cost is absent (t921). A pool cell holds tokenSessions and tokenPrompts (migration 0013_token_coverage.sql, optional on the bundle's cells), so the cost read's tokensPerPrompt divides by the prompts that recorded input and is null when none did; a row from before the migration is coverage unknown and the read says tokenCoverage: "unknown" instead of guessing. A tool-step cell (and an error cell) leaves a step whose cost was not recorded out of tokens, tokenSessions, and tokenPrompts, and reads null when none was, where it used to read 0. The cost method version stays 2.
  • The pool seals each staged part of a batch sent in parts (AES-GCM under a key derived from INGEST_HASH_KEY), so no host is readable in deposit_parts before the join or after a refused join that keeps its parts; the joined batch is hashed as before, and the client and wire are unchanged (t907).
  • A call on the wire says what it touched in shape, not in value (the field list moves to version 8, and the capture version to 22, so a store's next deposit captures every transcript again): keys (the input key names, sorted: a public tool's from its pinned list, any other tool's only through the name gate, none for a tool that went as private), keysDropped (a count bucket of the names not sent), targetClass (source, test, config, doc, lockfile, generated, data, none, or other, from the target's base and the path's suffix at capture), and argClass (the sorted set of path, url, pattern, command, number, flag, text, and none its arguments hold). Each is optional, no path or argument value is on the wire, and a name off a pinned list reads as other on the server and lands in the extensions bag rather than a 422. This reverses the earlier rule that a tool's keys stay local; no cell key changes and sending stays disabled.
  • The serve floors are the pool's configuration, not constants (t888). K_CELL is PUBLIC_FLOOR and k_sig is DISCLOSURE_FLOOR, Worker bindings with the defaults 5 and 2 in wrangler.jsonc, and PUBLIC_FLOOR_FAMILIES (live=3,tool-day=8) gives single read families a floor of their own. An unset binding, and one that is not a whole number of at least 1, is the default, with one line logged. A floor is applied when a bundle is served, to cells that keep their held counts, so changing one is a deploy with no client release and no redeposit. The signed bundle states both floors (floors, additive and optional), every served read states the floor it cleared (floor, additive and optional, and part of the read's ID), and the bundle's ETag changes with the floors. oars pool fetch prints the floors the bundle states and holds none of its own; a signed bundle whose floors is not whole numbers of at least 1 is refused. Earlier entries below that say five accounts describe the default.
  • oars telemetry report prints a hook cell as (harness/version claude-code/2.1.5), where it read (harnessVersion claude-code/2.1.5): the value holds the harness and its version. The wire field name is unchanged.
  • Model, harness version, subcommand, and flag names follow the same gate (t900): pool deposit sends the model and harness version strings, and the subcommand and flag names of every program, as they are after redaction (private when redaction changes one, an exclusion term matches it, it is not a name, or it is over 128 characters), never a flag value (a single-dash flag goes only as one letter, or as a public flag such as -NoProfile, and any other single-dash token longer than one letter, such as -psecret, is dropped); the pool parses any name in those fields. The curated lists no longer decide what the wire carries: the pool's class table says which model, version, program, subcommand, flag, and name values are on a public list, and a bundle serves a cell at the floor of its class. A package name may hold a / (a scope or a module path); no other name may. Capture still drops a subcommand or flag off the pinned vocabulary of its program, so a real session sends no off-list subcommand or flag until a capture bump; a call's own model and version already reach the pool as strings after the gate, and a closed frame model or version goes as <literal>.
  • The client has one gate and the pool enforces the rest (t881): pool deposit sends an MCP server, skill, pull name, program basename, native tool name, and host as they are after redaction, and private only for a name the redactor changes, an exclusion term matches, that is not a name, or that is over 128 characters. The pool holds a name off the public lists and serves it only at the pool's floor (floor on the bundle), and hashes a host on arrival under INGEST_HASH_KEY (an unset key refuses the deposit). oars pool outbox prints what is queued when you run it, hosts included; the nightly task sends the batches it builds that run without printing them first.
  • intervention has a sixth member, user-stop (EXTRACTOR_VERSION 14, so the next deposit re-derives the store from its log): the human stopped the agent in that prompt, by rejecting a tool call or interrupting the turn. It reads the same records as the prompt's stopped signal, so Claude Code (both), Cursor and VS Code Copilot Chat (a rejected call) read it; Codex, Copilot CLI, Gemini CLI, and Grok Build record neither the rejection sentence nor the interrupt marker as a prompt record, so their prompts read as before. A stop used to read unknown, and a rejected call would otherwise read after-error; it now wins over revert, redo, and after-error. The last prompt of a transcript still reads unknown. Adding a member to the closed list adds no field, so the field-list version stays 6; an older pool reads the new member as other. A bucket is a record of what happened, not a grade.
  • Local reads honor usageObserved (t902). books sums a usage column only over the prompts that recorded it, prints n/a (null in --json) when none did, and names a partial column (2 of 3 prompts recorded); measure's cache-write mean is over the sessions that recorded cache writes; a derived cell's tokens adds only the recorded categories and is null with tokenSessions 0 when no session recorded input (the pool server's cells follow, as they share the derivation); the self-baseline skips a cache-read share or an output rate whose category was never recorded. A VS Code Copilot cachedTokens or outputTokens of 0 that the request carried now stays observed. A Copilot request whose modelTotals are all zero still takes its output from completionTokens. The cost read's tokensPerPrompt divides by the prompts that recorded input (tokenPrompts on a cell) and is null when none did, which changes the figure for the same records, so the cost method version is 2. The Copilot reader stores different values for the same transcripts, so the capture version is 21.
  • A usage total the source never recorded is absent, not a measured zero (t891). A session and a prompt now carry usageObserved (the categories any response reported) and usageResponses (how many did), so a Cursor composer with no token counts or a VS Code Copilot request with no modelTotals no longer reads as a session that cost nothing, and a partial sum says what it covers. The pool wire sends an unobserved usage category and a remainingTokens with no reported tokens after it as null, which the parser accepts as it already did for tokens and ms, and a partial total sends usageResponses (a count bucket, optional) so the numbers say what they cover; the field list version is 7 (after t882's intervention at 6). The capture version is 20.
  • A derived prompt carries intervention (EXTRACTOR_VERSION 13, so the next deposit re-derives the store from its log): whether a human stepped in after the prompt's work and how, one of none, after-error (the prompt's last call failed), redo (the next prompt edited a file it edited), revert (the next prompt undid it with git revert <commit>, git restore, git checkout ., a bare git checkout without a -, -b, -B, --orphan, or --detach flag (which also reads a checkout of feature/x, origin/main, or a quoted branch, since the stored segment drops those words), git reset --hard, or a request that begins revert, undo, or roll back; git revert --abort reads none; a checkout with a flag off the public list, such as --theirs or --patch, reads none too), or unknown (the last prompt of a transcript, one the user stopped, or one whose next prompt ran a shell call captured before segments). The rule is deterministic over the stored records, is a record of what the next prompt did and not a grade, and each limit is in docs/sessions-store.md ("Prompt intervention"); Codex's bash -lc form hides a git undo, so a Codex session reads none there. It rides the pool wire as an optional per-prompt field (field-list version 6; absent means the prompt predates it, unknown means computed and not sayable) with a register row in docs/pool.md. The pool stores it with the prompt and serves it to no read, cell, or bundle; only the bucket leaves the machine, never the next prompt's words.
  • Hook telemetry is read per harness and harness version: the hook event carries harness (from the closed harness list, else other), and oars telemetry report and the fleet read key hook cells by <harness>/<version>, so a Claude Code and a Codex hook on the same version number are two cells. A hook event written before this reads as an unrecorded harness in your own report (unrecorded/<version>), and the nightly run, which runs under no harness, carries none; fleet rows rolled up before this release keep the bare version, which matches no cell of the report, until they age out of the 30-day window. See docs/telemetry.md.
  • The fleet read weighs every install the same in a latency percentile, so one install that fires thousands of times no longer becomes the fleet's number. Your own latency percentiles in oars telemetry report are counted in the fleet's buckets (each bucket's upper edge), so yours and the fleet's read on one scale, and when a fleet read answers your windows end with the day it is as of.
  • oars telemetry report shows your own hook latency, hit rates, and store health over the last 7 and 30 days, from the spool on this machine, with no server and no account. When OARS_POOL_URL names a pool server, it asks that server for the fleet's numbers (GET /v1/telemetry/fleet, a request that carries nothing of yours) and prints the fleet's percentile beside yours for each cell the server serves, or says plainly why there is none. The server serves a cell only where at least 5 installs report it, as percentiles with no counts; it rolls the kept batches up nightly. See docs/telemetry.md, "The report".
  • oars sessions books --by package prints per public package, from the local store, the calls, failed calls, main sessions, first and last day, calls and failed calls by harness and model, and failed calls by error class, with the A38 exclusion applied on every run (the output says how many transcripts and calls it removed) and no rank or share. A failed call captured before error classes were recorded (capture version 14) is counted as not measured, never as a zero. Names off the public list are counted, not named. Read-only; --repo is refused. See docs/sessions-store.md.
  • The books block's constructor-tuple rows (served.byTuple) name only full tuples (harness, version bucket, and model). An environment cell and a version-free cell still count in the served total and by week, but name no tuple, so a version-free cell's calls are not counted a second time beside the versioned cell.
  • oars sessions books ends with the pool's set of four from the last fetched bundle: served cells and the below-floor backlog (a total, never a list), accounts that deposited in the last four weeks, and the demand and goal-metric places, which read no source yet with a reason and are never printed as 0 (null in --json, under pool). With no kept bundle it prints no pool bundle yet. The bundle carries a books block (migration 0012 adds accounts.source and the daily panel row). See docs/pool.md.
  • oars sessions deposit reads every project folder and harness store by default; --allow still narrows it, and the new --deny <folder> (saved, and !<entry> in an --allow-file) keeps a folder out and wins over every allow. With no saved list, the SessionEnd hook, the nightly task, oars pool deposit, and oars gate replay read every folder too. Before, at least one --allow was required and an empty saved list read nothing. An --allow-file that names nothing is still refused.
  • oars pool deposit --send <hash> sends the printed batch once the account has accepted the pool covenant (--accept-covenant <version>, or an earlier acceptance); before, every send stopped with sending_disabled. Without an acceptance it reads the covenant and sends no batch (exit 3, covenant_not_accepted).
  • The oars pool commands default to the Many Oars pool, https://pool.manyoars.com, when neither --server nor OARS_POOL_URL names one; before, a command with neither was a usage error (exit 2).
  • oars gate replay asks the package manager what the registry holds by default, as the live hook does; --no-registry-state turns it off (before, it was off unless --registry-state).
  • oars sessions hook install and uninstall default to the user settings file (--scope user); --scope or --file names another. Before, a bare install was a usage error asking for --file.
  • oars login uses the built-in Many Oars issuer by default and reads no launch file (https://manyoars.com/.well-known/oars.json is no longer asked); before, it exited 2 until that file said launched: true. When the built-in issuer does not answer, it exits 2 with an error that names login.manyoars.com (the sign-in host it tried) and mentions the pool at pool.manyoars.com. --issuer-url and OARS_ISSUER_URL still win.
  • On Windows, oars sessions hook install registers the nightly task OarsSessionsNightly when it is not already registered, as --schedule nightly does; a refusal is reported and does not fail the install. --schedule off removes it and the choice sticks (recorded in the sessions store): a later plain install leaves the task off until --schedule nightly.
  • docs/flags.md lists every switch, what it was, what it is now, and why any stayed.
  • The pool no longer limits what an account contributes: MAX_DEPOSITS_PER_ACCOUNT and MAX_DEPOSIT_BYTES_PER_ACCOUNT default to unlimited and stay only as an operator's brake, and a batch past the 1 MiB request cap is cut into 512 KiB parts (oars-part, oars-batch) that the server keeps as one deposit, a part sent again changing nothing, staging held to the join cap, and oars pool outbox printing every part's request (t880).
  • The pool takes a locally redacted raw transcript (docs/pool.md, "The raw tier"): PUT /v1/raw/:sha256/parts/:n in parts of at most 1 MB, then POST /v1/raw/:sha256/complete with {parts, bytes}. Every request states oars-redaction-version and oars-capture-version, and an account's first states oars-raw-consent: granted, which is the raw consent prompt's answer and separate from covenant acceptance; the pool refuses a raw request without all of them, and when the covenant is unset or not accepted. Nothing serves, publishes, or licenses raw. The client side lands in 0.4.0 (t884).
  • The pool's raw complete hashes the assembled parts and refuses 422 hash_mismatch (field sha256) unless they match the hash in the path, so a ledger hash is the object's own. Its other refusals stay 409 part_missing and 422 bytes_mismatch.
  • The Codex reader keeps the shell outcomes of Codex 0.166+, which runs commands in a code-mode cell: an exec cell settles from its own Script completed|failed|running with cell ID header (failed carries its Script error: text) and a wait settles the cell it polled, and each CommandExecution item no call owns (exec-<uuid>) is its own Bash record with its exit code, output, and duration. A live 0.166/0.167 store had read every cell as ok and lost all 77 failing commands.
  • A failed call of several commands (a && b) no longer marks each segment error: the segments read none and the failure stays on the call; a Codex dynamic tool call settles from its DynamicToolCall item (a failed one is an error, one with no item is unsettled, not ok); and a step's cost carries allocated: true, on the wire too, where its tokens were divided among a response's calls rather than measured. The wire's field list moves to version 4 (the new allocated field, with its --explain row and register row, so batches built under version 3 are discarded and built again), and the capture version moves to 19 because stored segment and Codex values change, so the next capture re-reads every transcript.
  • Telemetry sending is on: to the pool server in OARS_POOL_URL if you set one, else to the Many Oars pool (https://pool.manyoars.com, not deployed yet, so until it is a send fails and the spool is kept) (before, it sent only when OARS_POOL_URL was set, and with none set nothing left the machine), and only while telemetry is on and the notice has been shown. The nightly task sends, and a command sends at most once a day from a detached process that blocks nothing; a hook never sends. Batches hold at most 250 events and go to the new POST /v1/telemetry route, and only a 2xx answer clears what was sent, so delivery is at least once. See docs/telemetry.md.
  • The sender treats a spool line the route would refuse (an object with no type, or one that is empty or over 64 characters) as junk and drops it with the first batch the server takes, so one malformed line cannot block every later send. A batch is kept without an account, not refused, when the pool's database fails while it reads the credential.
  • The skeleton carries edges and the spawn link (format 3): a step's edges are { kind, target } with kind one of next, spawned, retried, and after-error and target the position of the step it names in its transcript (the client decides retried, since the pool holds no raw key), and a transcript's spawnedIn is the position of the transcript that spawned it, so a subagent two deep rebuilds its tree from the batch. Only Claude Code fills the spawn link; Codex and Gemini send null. The server refuses an out-of-range target and a next that crosses a prompt; a kind it does not know reads as other. The field-list version is 3. Cells are unchanged. The batch only grows by the new fields (the 3,400-step test deposit is 876,815 bytes of skeleton, 17 more for the transcript's null spawnedIn).
  • The pool wire is skeleton format 3 (format 2 is refused like format 1). A tool carries its errorCode (the closed list, or null when none was captured; a value off the list reads as other and is kept in the extensions bag), so a user refusal, a policy denial, and a real failure stay distinct, and a failed call carries recoveryCalls (next, the canonical actions of up to the next five calls in the same prompt, and editFollowed; no signature hash or text). The pool counts live day cells per (name, model, errorCode) and (name, harnessVersion, errorCode), and recovery week cells per (failed action, errorCode, next action), and the bundle serves the recovery family at the floor, worded as what others did next, never a fix. The 3,400-step test deposit grows to 876,798 bytes of skeleton (876,802 stored) from the null errorCode on each call. This replaces the 0.3.0 note that live provider errors are not built. The field-list version is 3, and the goldens carry it.
  • The field-list version is 2 now that a frame's reach, a transcript's frames, and a step's frame and skill are on the wire (t867): the register in docs/pool.md has a row for each, the goldens are rebuilt, and an unknown name in a reach is read as other and kept as sent in the bag, not refused.
  • Every entry of the extensions bag is held to 8 KiB, not only an unknown field: an unknown value, a native or MCP tool name set aside under an other harness, and the identity of an unknown action are refused as too large at their path. docs/pool.md states the refusal and that the account byte budget counts the bag.
  • The additive wire holds each field the server does not know to 8 KiB (refused as too large at the field's path), counts the extensions bag in the account byte budget, keeps the names of a transcript whose harness reads other in the bag, and takes a <field>Literal as a literal only beside an other. The register's class column is clear, thresholded, hashed at ingest, or raw tier.
  • The pool deposit wire is additive (skeleton format 3): a batch carries its format, vocabulary, and field-list versions; a field name the server does not know is kept in a stored extensions bag instead of a 422, and an enumerated value it does not know is read as other (the value is kept as sent in the bag, served by nothing). Format 1 and 2 batches are refused by name. The client sends no literal beside other. docs/pool.md gains a wire field register, with a test that fails on an emitted field with no row.
  • The skeleton is format 3: a step names its frame (frame, a position in the transcript's new frames list, which the server refuses when out of range) and the skill whose run it sits in (skill, a list member or private), and a frame carries reach (the MCP servers, skills, and plugins in reach, and filled, which says whether the harness recorded any). A call's model and harness version come from its own line, so a model that changes in the middle of a prompt reaches the steps that ran on it. Cells are unchanged. A tool record gains model and skill. Format 2 batches are refused; nothing is migrated.
  • Pool frames carry a repo key (salted with the store's own salt, so it joins one machine's harnesses), orgSize, team, and repoVisibility bands, and a UTC hour; oars pool coverage sets the two the operator states.
  • Telemetry, on by default, with a notice on the first run that is not a hook (stderr, once) and a one-command off switch. Each CLI command except the bare oars gate hook (which skips the full CLI to stay inside its time budget) leaves one event in a local, capped spool under <config>/oars/telemetry/: the command path, flag names (never values), duration, exit code, and a closed error class, with a random per-install id, the oars version, the OS, the time, and a schema version. Nothing else is recorded: no session content, prompts, paths, URLs, or arguments. Events go to the Many Oars pool or the pool server you name, sent in batches by the nightly run. oars telemetry status|on|off|show manages it, and OARS_TELEMETRY=0 or DO_NOT_TRACK=1 turns it off. See docs/telemetry.md.
  • oars pool fetch --harness-version unknown fetches the bundle of a harness that records no version in its local files (Cursor, Gemini, Grok Build, and a VS Code Copilot Chat session whose requests carry no agent version), which were absent from every numbered bundle: their cells are <harness>/unknown/<model>, and the pool route /bundle/<harness>/unknown/<vocabVersion> serves them under the same account floor and withholding as a numbered bundle. The VS Code Copilot Chat reader now fills the harness version from requests[].agent.extensionVersion (the Copilot Chat extension's version, read only from the Copilot Chat agent and not from a third-party participant's, from public source and a synthetic fixture, never from a live store); Cursor, Gemini, and Grok Build expose none, so they stay null.
  • Telemetry now records every hook fire, the bare oars gate hook included (t876): a hook event with the hook's name, how long its handler took, hit, miss, held, or error, the bytes it printed, and the harness version and model when the hook saw them (a name off the public list is other). The bare hook is recorded by its own process after its answer is printed, so its stdout and exit code are those of a run without telemetry. This replaces the earlier note that the bare oars gate hook records nothing. See docs/telemetry.md.
  • Telemetry now records every recall (t876): a recall event from oars sessions recall, the oars_recall MCP tool, and the pre-tool push, holding only how it was asked (pattern, entity, question, text, or legacy), push or pull, the read families it served from a closed list, hit or miss, counts of reads, evidence rows, and tokens, and its arm (shown or held). It never holds the query text, a name, or the rendered answer.
  • Telemetry now records deposit passes, sent batches, and fetches (t876): a deposit event (sessions counted, batches built and their bytes, and how many sessions each session gate kept out, as counts with no folder, term, or name; a batch sent records sent and its bytes) and a fetch event (the harness, an ETag hit, a cap hit, and the reads in the bundle). The oars pool deposit --json document is unchanged.
  • The first-run telemetry notice, the CLI README, and docs/telemetry.md name the hook, recall, deposit, and fetch events, so the notice still lists everything that is recorded (t876).
  • A hook that the process deadline ends is still recorded (t876): the hook event for that fire says error with no bytes, written once before the process exits, so the slowest fires reach the spool.
  • Every hook fire records the harness version and model when its transcript states them (t876): the bare oars gate hook, post-tool, stop, and a pre-tool miss now read them from the tail of the input's transcript_path, the same bounded read a push uses. The path itself is never recorded.
  • A fetch the pool refuses, and a bundle that fails verification, now record a fetch event too (t876): both reached the pool, so fetches counts them, with no reads. Exit codes are unchanged.
  • A 304 to a oars pool fetch that named no kept bundle now records its fetch event before it fails, so every fetch that reached the pool counts (t876). A hook that reaches its deadline while the transcript is still being read now keeps its event, recorded without the harness version and model (t876).
  • Telemetry reports the health of an install and polices the wire (t877). The nightly run leaves a store-health event (sessions, skeletons, raw size, verify results, unparseable counts, the capture and extractor versions the store holds (a store with an older session lists both), the harness and model versions seen with off-list values as other, and the pool outbox's size and the last seven days of bytes sent) and a run-cost event (parse and total time, peak memory, failed or not); a failure oars did not plan for leaves a crash event with its built-in class and a hash of its stack with paths hashed, never its message; and oars pool deposit leaves a wire event for each harness (each register field's presence and bytes) and --send a wire-send event with the pool's refusal code. Every event passes the closed schema, docs/telemetry.md describes each with an example, and the first-run notice says so.
  • Every size or count figure in docs/pool.md that the code determines is now computed by a test (t913, packages/pool/src/pool-doc-figures.test.ts): a stale figure fails just check instead of surviving to review. History figures read "about". No change to what the pool sends or stores.
  • A transcript the harness no longer has, captured again from the raw archive, is also captured again when a --redact-domain is named after it was captured, so a domain added later is masked in what was captured before it (it was kept as captured).
  • oars pool deposit queues a locally redacted copy of each transcript of a session that passed both gates, beside its skeleton, once the raw prompt is answered yes (state.json pool.rawConsent). The redactor now also masks home paths and usernames, environment values (NAME=value), and hosts (URL hosts, IP addresses, internal names) in a transcript body; oars pool outbox lists each raw part with its hash and bytes and --explain prints its body. A folder set to skeleton or off queues no raw copy, and off queues nothing.
  • oars sessions books --by package groups an MCP server's calls as mcp:<server> (a server off the published list is counted, never named), counts a call that pulls two non-public names once, and applies --since before it counts the calls the exclusion removed. A Codex command the user refused inside a code-mode cell is recorded with its refusal, a namespaced Codex call is no longer held unsettled because its bare name matches a declared dynamic tool, and a run that lost the store lock no longer sweeps the later holder's temporary log files.