Repository navigation
oars 0.4.0
·
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 pireads 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 piand 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 asrevertthe way it does on the other harnesses (CAPTURE_VERSION25, 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, thatraw/content never leaves (a redacted copy does, after a yes to the raw prompt), or thatoars sessionsuploads nothing; figures from one machine are removed fromdocs/gate.md. Every claim checked, with its evidence, is indocs/copy-audit.md. - The next-node read (t926).
hook installaddsUserPromptSubmitand widensPostToolUseFailureto 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 withpool 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(andUserPromptSubmit, 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 arecalls.jsonlrow under the 10 percent holdback, and the old post-tool signature line moves under it too, someasure'shookHitsPerSessionfalls: 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 gainsprompt. - 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,
localNamesfalls back toUSERorUSERNAMEwhen 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 inC:\Users\...andC--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.mdlists 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_VERSIONis 1, the first shipped rule set. After an explicit no to the raw prompt,depositsays so and namesoars pool raw --consent yes;verifysaysrawMaskedcounts 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 insent.log, a failed night is picked up the next night, andpool-nightly.jsonrecords counts only.oars pool outboxprints 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 anddocs/pool.mdsentences that said nothing is sent are corrected. - The nightly send and
deposit --sendtake one send lock per outbox (asend.lockfile besidesent.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);--sendrecords the hash it sent insent.logtoo and skips a hash that file already holds (one line, "already sent at ", exit 0, no request), the rule the nightly follows, andoars pool outboxmarks each sent batch and raw copysent: <time>(text and document).oars sessions verifyreportssentBatchesandsentRawbesidestaleBatches, andrawCopiesandrawMasked, the values masked in the queued raw copies. The deposit summary names the real command,oars pool raw --consent yes. oars sessions deposit --allow otelreads agent traces written in the OpenTelemetry GenAI conventions (OTLP JSON files in the folderOARS_OTEL_TRACESnames, 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; seedocs/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_VERSION24, so the next deposit re-reads every transcript from the harness orraw/): before, each was<literal>unless a public list held it, sopool deposithad 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 throughpool deposit's one gate (your exclusion terms apply there), sent bydeposit --sendor the nightly task, andpool outboxprints what is queued when you run it. A transcript neither the harness norraw/still holds keeps its<literal>values. - Three interventions read what the transcript shows (
CAPTURE_VERSION23,EXTRACTOR_VERSION15, so the next deposit re-derives the store from its log):git checkout feature/xandgit checkout "fix-1"no longer readrevert, and a checkout with an unlisted flag such as--oursreadsrevertwhen 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 ..., readuser-stopby their fixed text or record type. A Codexturn_abortedwith reasoninterruptedis now written as the interrupt marker prompt (CAPTURE 23), so it setsstoppedinterruptas Claude Code's does and that session's prompt count,tsLast, and skeleton move; a decline leavesstoppednull. That changes theuser-stopbullet below (EXTRACTOR_VERSION14) 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 readuser-stop.docs/sessions-store.mdhas the table by harness. oars sessions deposit --allow opencodereads OpenCode (sst/opencode) sessions into the same store as Claude Code, Cursor, Codex, Copilot, Gemini CLI, and Grok Build (t924): skeletons withharness: opencode, the same field classes and redaction, and the samerecall,measure,books, andverify. It readsopencode.dbread-only, and was written from OpenCode's public source (MIT) and tested on synthetic fixtures; it has never run against a live store (seedocs/sessions-store.md). A new source takes noCAPTURE_VERSION.- Served cells carry what they cover, and a step with no recorded cost is absent (t921). A pool cell holds
tokenSessionsandtokenPrompts(migration0013_token_coverage.sql, optional on the bundle's cells), so the cost read'stokensPerPromptdivides by the prompts that recorded input and isnullwhen none did; a row from before the migration is coverage unknown and the read saystokenCoverage: "unknown"instead of guessing. A tool-step cell (and an error cell) leaves a step whose cost was not recorded out oftokens,tokenSessions, andtokenPrompts, and readsnullwhen 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 indeposit_partsbefore 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 asprivate),keysDropped(acountbucket of the names not sent),targetClass(source,test,config,doc,lockfile,generated,data,none, orother, from the target's base and the path's suffix at capture), andargClass(the sorted set ofpath,url,pattern,command,number,flag,text, andnoneits arguments hold). Each is optional, no path or argument value is on the wire, and a name off a pinned list reads asotheron the server and lands in the extensions bag rather than a 422. This reverses the earlier rule that a tool'skeysstay local; no cell key changes and sending stays disabled. - The serve floors are the pool's configuration, not constants (t888).
K_CELLisPUBLIC_FLOORandk_sigisDISCLOSURE_FLOOR, Worker bindings with the defaults 5 and 2 inwrangler.jsonc, andPUBLIC_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'sETagchanges with the floors.oars pool fetchprints the floors the bundle states and holds none of its own; a signed bundle whosefloorsis not whole numbers of at least 1 is refused. Earlier entries below that say five accounts describe the default. oars telemetry reportprints 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 depositsends the model and harness version strings, and the subcommand and flag names of every program, as they are after redaction (privatewhen 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 packagenamemay 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 depositsends an MCP server, skill, pull name, program basename, native tool name, and host as they are after redaction, andprivateonly 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 (flooron the bundle), and hashes a host on arrival underINGEST_HASH_KEY(an unset key refuses the deposit).oars pool outboxprints what is queued when you run it, hosts included; the nightly task sends the batches it builds that run without printing them first. interventionhas a sixth member,user-stop(EXTRACTOR_VERSION14, 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'sstoppedsignal, 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 readunknown, and a rejected call would otherwise readafter-error; it now wins overrevert,redo, andafter-error. The last prompt of a transcript still readsunknown. Adding a member to the closed list adds no field, so the field-list version stays 6; an older pool reads the new member asother. A bucket is a record of what happened, not a grade.- Local reads honor
usageObserved(t902).bookssums a usage column only over the prompts that recorded it, printsn/a(nullin--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'stokensadds only the recorded categories and isnullwithtokenSessions0 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 CopilotcachedTokensoroutputTokensof 0 that the request carried now stays observed. A Copilot request whosemodelTotalsare all zero still takes its output fromcompletionTokens. The cost read'stokensPerPromptdivides by the prompts that recorded input (tokenPromptson a cell) and isnullwhen none did, which changes the figure for the same records, so thecostmethod 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) andusageResponses(how many did), so a Cursor composer with no token counts or a VS Code Copilot request with nomodelTotalsno 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 aremainingTokenswith no reported tokens after it asnull, which the parser accepts as it already did fortokensandms, and a partial total sendsusageResponses(acountbucket, optional) so the numbers say what they cover; the field list version is 7 (after t882'sinterventionat 6). The capture version is 20. - A derived prompt carries
intervention(EXTRACTOR_VERSION13, so the next deposit re-derives the store from its log): whether a human stepped in after the prompt's work and how, one ofnone,after-error(the prompt's last call failed),redo(the next prompt edited a file it edited),revert(the next prompt undid it withgit revert <commit>,git restore,git checkout ., a baregit checkoutwithout a-,-b,-B,--orphan, or--detachflag (which also reads a checkout offeature/x,origin/main, or a quoted branch, since the stored segment drops those words),git reset --hard, or a request that beginsrevert,undo, orroll back;git revert --abortreadsnone; a checkout with a flag off the public list, such as--theirsor--patch, readsnonetoo), orunknown(the last prompt of a transcript, one the user stopped, or one whose next prompt ran a shell call captured beforesegments). 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 indocs/sessions-store.md("Prompt intervention"); Codex'sbash -lcform hides a git undo, so a Codex session readsnonethere. It rides the pool wire as an optional per-prompt field (field-list version 6; absent means the prompt predates it,unknownmeans computed and not sayable) with a register row indocs/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
hookevent carriesharness(from the closed harness list, elseother), andoars telemetry reportand 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 anunrecordedharness 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. Seedocs/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 reportare 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 reportshows 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. WhenOARS_POOL_URLnames 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. Seedocs/telemetry.md, "The report".oars sessions books --by packageprints 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 asnot measured, never as a zero. Names off the public list are counted, not named. Read-only;--repois refused. Seedocs/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 booksends 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 readno source yetwith a reason and are never printed as 0 (nullin--json, underpool). With no kept bundle it printsno pool bundle yet. The bundle carries abooksblock (migration 0012 addsaccounts.sourceand the dailypanelrow). Seedocs/pool.md.oars sessions depositreads every project folder and harness store by default;--allowstill 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, andoars gate replayread every folder too. Before, at least one--allowwas required and an empty saved list read nothing. An--allow-filethat 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 withsending_disabled. Without an acceptance it reads the covenant and sends no batch (exit 3,covenant_not_accepted).- The
oars poolcommands default to the Many Oars pool,https://pool.manyoars.com, when neither--servernorOARS_POOL_URLnames one; before, a command with neither was a usage error (exit 2). oars gate replayasks the package manager what the registry holds by default, as the live hook does;--no-registry-stateturns it off (before, it was off unless--registry-state).oars sessions hook installanduninstalldefault to the user settings file (--scope user);--scopeor--filenames another. Before, a bare install was a usage error asking for--file.oars loginuses the built-in Many Oars issuer by default and reads no launch file (https://manyoars.com/.well-known/oars.jsonis no longer asked); before, it exited 2 until that file saidlaunched: true. When the built-in issuer does not answer, it exits 2 with an error that nameslogin.manyoars.com(the sign-in host it tried) and mentions the pool atpool.manyoars.com.--issuer-urlandOARS_ISSUER_URLstill win.- On Windows,
oars sessions hook installregisters the nightly taskOarsSessionsNightlywhen it is not already registered, as--schedule nightlydoes; a refusal is reported and does not fail the install.--schedule offremoves it and the choice sticks (recorded in the sessions store): a later plain install leaves the task off until--schedule nightly. docs/flags.mdlists 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_ACCOUNTandMAX_DEPOSIT_BYTES_PER_ACCOUNTdefault 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, andoars pool outboxprinting every part's request (t880). - The pool takes a locally redacted raw transcript (
docs/pool.md, "The raw tier"):PUT /v1/raw/:sha256/parts/:nin parts of at most 1 MB, thenPOST /v1/raw/:sha256/completewith{parts, bytes}. Every request statesoars-redaction-versionandoars-capture-version, and an account's first statesoars-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
completehashes the assembled parts and refuses 422hash_mismatch(fieldsha256) unless they match the hash in the path, so a ledger hash is the object's own. Its other refusals stay 409part_missingand 422bytes_mismatch. - The Codex reader keeps the shell outcomes of Codex 0.166+, which runs commands in a code-mode cell: an
execcell settles from its ownScript completed|failed|running with cell IDheader (failedcarries itsScript error:text) and awaitsettles the cell it polled, and eachCommandExecutionitem no call owns (exec-<uuid>) is its ownBashrecord 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 segmenterror: the segments readnoneand the failure stays on the call; a Codex dynamic tool call settles from itsDynamicToolCallitem (a failed one is an error, one with no item is unsettled, not ok); and a step's cost carriesallocated: 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 newallocatedfield, with its--explainrow 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_URLif 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 whenOARS_POOL_URLwas 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 newPOST /v1/telemetryroute, and only a 2xx answer clears what was sent, so delivery is at least once. Seedocs/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
edgesare{ kind, target }withkindone ofnext,spawned,retried, andafter-errorandtargetthe position of the step it names in its transcript (the client decidesretried, since the pool holds no raw key), and a transcript'sspawnedInis 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 anextthat crosses a prompt; a kind it does not know reads asother. 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 nullspawnedIn). - 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 asotherand is kept in the extensions bag), so a user refusal, a policy denial, and a real failure stay distinct, and a failed call carriesrecoveryCalls(next, the canonical actions of up to the next five calls in the same prompt, andeditFollowed; no signature hash or text). The pool countsliveday cells per (name, model,errorCode) and (name,harnessVersion,errorCode), andrecoveryweek cells per (failed action,errorCode, next action), and the bundle serves therecoveryfamily 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 nullerrorCodeon each call. This replaces the 0.3.0 note thatliveprovider 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'sframes, and a step'sframeandskillare on the wire (t867): the register indocs/pool.mdhas a row for each, the goldens are rebuilt, and an unknown name in a reach is read asotherand 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
otherharness, and the identity of an unknown action are refused astoo largeat their path.docs/pool.mdstates 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 largeat the field's path), counts the extensions bag in the account byte budget, keeps the names of a transcript whose harness readsotherin the bag, and takes a<field>Literalas a literal only beside another. 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 besideother.docs/pool.mdgains 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 newframeslist, which the server refuses when out of range) and the skill whose run it sits in (skill, a list member orprivate), and a frame carriesreach(the MCP servers, skills, and plugins in reach, andfilled, 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 gainsmodelandskill. 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, andrepoVisibilitybands, and a UTChour;oars pool coveragesets 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|showmanages it, andOARS_TELEMETRY=0orDO_NOT_TRACK=1turns it off. Seedocs/telemetry.md. oars pool fetch --harness-version unknownfetches 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 fromrequests[].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 hookincluded (t876): ahookevent with the hook's name, how long its handler took,hit,miss,held, orerror, the bytes it printed, and the harness version and model when the hook saw them (a name off the public list isother). 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 bareoars gate hookrecords nothing. Seedocs/telemetry.md. - Telemetry now records every recall (t876): a
recallevent fromoars sessions recall, theoars_recallMCP tool, and thepre-toolpush, holding only how it was asked (pattern,entity,question,text, orlegacy), 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 (shownorheld). It never holds the query text, a name, or the rendered answer. - Telemetry now records deposit passes, sent batches, and fetches (t876): a
depositevent (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 recordssentand its bytes) and afetchevent (the harness, an ETag hit, a cap hit, and the reads in the bundle). Theoars pool deposit --jsondocument is unchanged. - The first-run telemetry notice, the CLI README, and
docs/telemetry.mdname 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
hookevent for that fire sayserrorwith 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 apre-toolmiss now read them from the tail of the input'stranscript_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
fetchevent too (t876): both reached the pool, sofetchescounts them, with noreads. Exit codes are unchanged. - A 304 to a
oars pool fetchthat named no kept bundle now records itsfetchevent 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-healthevent (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 asother, and the pool outbox's size and the last seven days of bytes sent) and arun-costevent (parse and total time, peak memory, failed or not); a failure oars did not plan for leaves acrashevent with its built-in class and a hash of its stack with paths hashed, never its message; andoars pool depositleaves awireevent for each harness (each register field's presence and bytes) and--sendawire-sendevent with the pool's refusal code. Every event passes the closed schema,docs/telemetry.mddescribes each with an example, and the first-run notice says so. - Every size or count figure in
docs/pool.mdthat the code determines is now computed by a test (t913,packages/pool/src/pool-doc-figures.test.ts): a stale figure failsjust checkinstead 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-domainis 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 depositqueues 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.jsonpool.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 outboxlists each raw part with its hash and bytes and--explainprints its body. A folder set toskeletonoroffqueues no raw copy, andoffqueues nothing.oars sessions books --by packagegroups an MCP server's calls asmcp:<server>(a server off the published list is counted, never named), counts a call that pulls two non-public names once, and applies--sincebefore 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.