Blog

Building Agent Passport System, day by day.

Day-by-day record of building the enforcement and accountability layer for AI agents. Bring your own identity: did:key, did:web, SPIFFE, OAuth, native did:aps. Started February 18, 2026. 6,289 tests, nine papers, IETF draft. Open source. Full surface area: 154 MCP tools.

Day 215: a stopping rule, written after the ninth cycle

The reconciliation called a job finished when neither reviewer had an unresolved correctness finding. On Saturday that rule ran one job through nine whole-surface review cycles in eleven hours. Each pass could find something, so each pass did. The eighth found a real defect, a ledger that accepted a reservation after a cancel, but that belongs to hardening, and conformance had been done hours earlier. The rule now allows at most two whole cycles per job. A repair is verified by reproduction, the suites and one review scoped to the repair. Anything found after that is classified and carried, and it does not reopen closure.

Two other structural changes came out of the same afternoon. Closure became a gate at the end of a job instead of its last planned batch, so a job is judged by whether its whole surface matches the draft. And a fourth reason a change may exist got a name. Implementation hardening covers reliability and resource safety on a draft path where the protocol does not prescribe the runtime property. One commit carries one reason. A Python commit that mixed two is recorded as an erratum and left as it is.

Outside the SDKs, three things moved. The reviewer on CoSAI #189 resolved his original objection and asked that coverage tied to a claim be explicit in the rule text. I had a long reply drafted. What went out was the edited cases as suite pull request #98 and one line pointing at it. On the PriorSeal thread the adapter's author had held his work waiting for our fixtures, so four inputs went up on a branch cut from 6.0.1, shaped against the draft rather than against what I had promised on Friday. And the insumerapi crosswalk refreshed to what the API issues today, merged once a clean clone passed and the live key set matched the snapshot committed with #166.

aeoess.com changed too. The entry chooser is gone, and the home is now a single interactive line above the four projects.

Day 214: I opened a pull request and pulled it back the same afternoon

On Friday morning I opened a pull request against the TRACE integrations repository that verifies an APS action receipt as evidence that an agent issued an action. By the afternoon it was back in draft. Read against draft-03 section 5.3.1, its fixture was issued by a gateway where the draft requires the acting agent, and its result was a free-form object where the draft fixes one. The SDKs I built it on enforced neither rule. That is a problem in the SDKs, so the fix belonged there.

So the week's job started, reconciling both SDKs to draft-03 rule by rule before anything else was allowed to depend on them. The first pass was a matrix of every rule against both implementations, and it caught one mistake of mine before any code moved. An earlier note said the Python action reference helper was the draft's section 4.2 form. It is a different digest. It hashes camelCase keys, a sorted scope array and a timestamp truncated to seconds, and the draft's form uses snake_case, one scope string and milliseconds. Following the note would have put the draft's label on the wrong digest, which the draft itself forbids. The helper stays, documented as pre-draft.

Two rules came out of the day. AuthorityDelegationV1 is the draft's authority record, and the older Delegation family in both SDKs is a compatibility surface that external verifiers should not target. And every change in the reconciliation declares why it exists: a repair toward the draft, hardening of an existing path, or evolution toward -04. A new rule is never presented as an old one.

The rest of the day was other people's work landing. The wallet_state re-date in the vocabulary merged once its keys and verifier were pinned next to its bytes, a clean install running 23 of 23, and the approval corrected an error in my own earlier review of vector 22. Cross-stack vectors from mcp-audit-gateway merged into the lab. And PriorSeal's author agreed to bind APS decision evidence through a sibling adapter on published surfaces rather than a fork.

Day 213: a pack pinned correctly went stale in four days, and a re-date pinned the bytes but not the keys

Two independent fixture packs for the conformance lab had been sitting in a pull request since the eleventh, conflicting with main. The rebase itself was the boring kind: one generated inventory table, two additive hunks, both sides rows that main had grown since the branch point. I kept all four rows and let the generator confirm it would have written the same thing. Both packs came through byte for byte. What was not boring was what one of them had become while it waited. The AAT pack is pinned to draft-sharif-agent-audit-trail-03 and carries a case it deliberately leaves unresolved, a genesis record signed by an independent recorder, because -03 says the recorder should use its own key and then verifies with the agent's. On September 15 the author published -04, which adds a signer key identifier and names the signing principal for each recording mode. The ambiguity the fixture records is no longer current. The pack is still correct, because it says what -03 says, but a reader arriving today would take a resolved question for an open one.

The fix was one paragraph, not a rewrite. The pack stays pinned to -03, the fixture stays unresolved against -03 only, and a dated note says which later revision closed it and how. No fixture, expected result or provenance line moved. Two things about that small edit are worth writing down. The pack's checksum manifest covers its own README, so a documentation change is a two-file change or the manifest fails. And my commit went up without a sign-off, which turned the DCO check red. The agent running the mechanics stopped there instead of amending in my name, because a sign-off is a certification, not housekeeping, and I gave the word explicitly. The amended commit has the same tree hash as the unsigned one. Merged by rebase, main carries the exact tree that was tested, six checks green on that commit.

The vocabulary got a harder review. A contributor re-dated a proposed signal at its sunset, as I had asked in the tracking issue, pinning his evidence by git revision, tree object and discovery-copy digest rather than by a URL that can move. All of those pins check out. I resolved the commit, matched the tree object, fetched the discovery copy and got the same digest byte for byte. Then the boundary problems. The note says each vector is an artifact exactly as the API issued it, and twelve of the twenty-three are deliberate derivations by their own descriptions. The runner that reports twenty-three of twenty-three imports the issuer's own verifier, so it is an author-produced result inside one trust domain, fine for the criterion, wrong to leave reading as independent. The two packages it installs are unversioned while the README documents that older versions accept two of the negative cases. And twelve vectors resolve keys from a live JWKS endpoint with no snapshot in the tree, so the signed artifacts are frozen and the keys that verify them are not. That is the same failure the re-date was supposed to close. Changes requested, status and issuer count left exactly as they were. One trap from the review itself: "eleven must be refused" is only true under a stated predicate, because every frozen vector now expects an expiry failure and two more carry a signed false verdict that is not a verification failure at all. Without the predicate the honest count is thirteen.

Two things closed without needing me to be right. The AuthZEN issue where I had offered a binding_hash vector set in July closed today because a maintainer's pull request landed an official directory with seven known-answer vectors and cited the larger set while doing it. I had read the closure as a loss for about an hour. It was a landing. My comment there is one sentence saying the larger set still exists if anything is uncovered. And a paper on arXiv characterizes APS delegation as a rooted tree with a single parent identifier, reporting that a tree-cascade baseline revokes every shared agent its edge-withdrawal method preserves. I checked that against the current draft. It is fair. Each delegation record has one parent, one chain authorizes an action, scopes and budgets are never unioned across chains, and revocation cascades through descendants. The limit is at the record level, not the agent level, an agent holding two unrelated chains keeps the second when the first is revoked, but a descendant created under the revoked one does not. No correction owed. A design question logged instead, and not the obvious fix of making the parent field an array.

One failure of my own to end on. To settle whether a client bug lived in the API or the client, a raw signed publish was sent to production from outside every tool we ship, and it landed: 201, readable, on search. The API is fine. The test card is not, because the throwaway key that signed it was deleted with the script that made it, and every removal verb on a card requires that key. A known test artifact now sits on the discovery surface until its expiry, or until I authorize a database write outside the protocol. The rule that comes out of that is small and I should not have needed it: a key used for a production write is kept until the cleanup is done.

Day 212: a rule sent as a question, and a requirement closed as too early

The evidence sufficiency rule went to CoSAI WS4 #189 for the reviewer who found the four defects to confirm or tighten. A negative claim over a scope passes only when field visibility and observation completeness are both established for that same scope, whether the field is absent or present but empty. If either is missing, the result is not_established with the unmet obligation named. Malformed input, unsupported verification, parser failure and internal errors stay outside the verdict. I posted it as a question. The merged cases stay candidates against proposed text.

The AEP run record's merge values went to the WasmAgent maintainer for his external evidence ledger. My first draft nearly sent git blob identifiers where content hashes belong, and nearly called a one-parent rebase result a merge commit. Both were fixed before posting. He recorded it with the two anchors and confirmed the assurance ceiling did not change.

The OWASP AISVS maintainer closed the binding requirement in #1152 as too aspirational for 1.01, to keep the backlog short, and left the door open. The test had already been tightened after a reviewer's correction, and that reviewer had accepted the requirement. I posted nothing after the close. It does not reject the finding, and it does not accept the requirement. A confusing line in the SDK's papers index was also fixed in #170.

Day 211: two records merged, and a manifest that cannot live inside the commit it names

The WasmAgent AEP run record had cited a moving branch. I repaired it to pin the component tuple, the publication commit and the lab revision as immutable references, and the four result files did not change. It merged in #94 as six commits. The claim is unchanged. It covers one independent layered run against the tuple published for one certified snapshot, with the JS and Rust native checks and the lab's semantic recomputation reported separately, and the semantic layer labeled author-produced.

Pinning it also explained an old manifest in the certified tuple. The protocol component SHA inside the certified tuple still carries the previous manifest, because a manifest that names a commit changes that commit. The maintainer confirmed in #92 that the model is the tuple plus a separate publication commit on the protected main branch. Both are now recorded side by side, so the next reader does not take the old manifest for an error.

The CoSAI WS4 #189 candidate cases merged in #91 after the reviewer reran the repaired head. He had reported four defects, and a second participant verified the repairs. The coverage premise is now explicit. Unsupported verification comes back as a non-verdict. A missing gating descriptor is a structural input error. And the harness is read-only, so reproducing a result cannot repair the artifact it checks.

Day 210: the fix was in the code and the shipped copy still taught the defect

An introduction you asked for was reported back to you as one someone else had asked of you, and the note you wrote yourself was attributed to the other person. On a network whose entire subject is who wants to meet whom, that is not a display bug. The server always knew the direction. The client relabelled it on the way out, and the labels it used were the ones published two days ago.

The code fix was done by morning. Three things would have let it ship with the old contract still in front of users. The skill that ships inside the package still named the fields the fix had replaced, so an agent following it reads a field that does not exist and reports an empty inbox. The test that guards that skill still carried the three dead names on its approved list, so the old contract could have been written back in without a single failure. And the suite exited 0 with all thirteen end-to-end tests skipped, because a default path did not resolve in that layout, which means the pass line was a claim about code that had not run.

All three are closed. The dead names are removed from the allow-list rather than renamed, so their return is a test failure. The pre-test guard now resolves the same path the test resolves and refuses to run without it, with a named flag for skipping on purpose.

It went out as a major with no compatibility alias. The old direction values were not merely renamed, they were inverted, so emitting them beside the new ones would keep teaching the defect to exactly the clients still reading it. The release note says the uncomfortable half of that out loud: an install that does not upgrade keeps working against the network and keeps showing every introduction backwards.

The publish tooling had its own version of the same fault. Its closing banner printed the procedure for initializing the thirty day compatibility clock for whatever version was being released, which for this release would have instructed the operator to restart a window that belongs to the previous one. The server refuses a second initialization, but a backstop is not a correct instruction. The banner now branches on the anchor release and prints do not touch it, with a verify-only check, for everything after it. The same release carries an errata correcting an earlier note that printed the thirty day cutoff where the publication instant belonged, a month apart.

On the conformance suite, a contributor's cross-stack family came back with five text edits done and three questions. Two were straightforward. The third was whether two exercised failure outcomes could land without an independent record, and I answered that they could not and that we still owed the record. That was wrong. The record already existed: the independent run we commissioned executed those checks and passed them, and the verifier derives each outcome from the record data before comparing it to the file's published code. What was narrow was our own earlier attribution, not the run behind it. The correction was an appended record assigning those layers to the run that made them, with the original claims left as published, and it does not extend to the third failure code in that class, which no vector raises.

Day 208: Mingle shipped, and a verifier that exits zero on seven mutations

Mingle shipped. Stage 2B closed with one withdraw action that removes unreleased contact, live fit and First Step together, and the race with a concurrent write resolves at the write in both orders. Stage 2C cut forty-six tools across three generations down to eight, with the old set behind a flag.

The run that mattered was two principals through real MCP processes against a real API. It found six call sites the mocks had passed. Review found seven severe items, two of them security, and all were fixed before publish. The server went live first. Then I published mingle-mcp 4.0.0 by hand under WebAuthn, and the server records that publish's registry timestamp as the start of a thirty day window for the legacy tools, so a later patch cannot move it. 4.0.1 followed the same day and changed only copy, six overclaims in the shipped skill and README.

A ScopeBlind maintainer merged our driver in #1 and asked what his three published files establish. I ran them locally without changing any input. The published verifier exits zero with top-level valid true on seven mutations. A log digest field is checked for shape and never compared to the file. The published command leaves out the provenance flag, so it never reads the Sigstore bundle. And the 28 of 28 agreement covers tool identity only, because the receipts carry no principal, context or input. I posted it as findings with questions back to him.

Day 207: nine fixes to Mingle, and the review of them found a reveal that released both values

A product review said Mingle had gone deep before it went wide. Nine correctness items shipped. Among them were an acceptance email that never fired, an opt-in with a hidden default, semantic search ordered by recency, no atomic way to replace a card, a purge the copy promised and the code did not do, a private key any local user could read, and bare sweep routes.

The review of that batch found the worst one. When one party revealed, the release handed out both parties' exact values. The fix tracks a releaser set for each dimension separately.

A binding audit went through forty-three mutating routes and recorded which request and commit signatures actually bind what the receipt claims. The fit and v2 containment gates are deployed. Two independent adversarial reviews approved the Stage 2A design. The MCP stayed unpublished, because the server it depends on was not live yet.

Day 206: the driver rewrote the policy it was being tested against, and the correction went upstream

A maintainer asked a simple question about our conformance driver: his fixture policy had not been valid Cedar until that morning, so why had our run reported a clean allow instead of an error. The answer was worse than an error. An earlier revision of the driver rewrote the policy text before evaluating it, turning an idiom Cedar rejects into one it accepts. That was disclosed in the pull request body at the time under a note claiming the semantics were unchanged. Measured against the bytes on disk, that claim was false.

Three configurations settle it. With the rewrite, the pre-fix policy gives allow, allow, deny, allow. Without the rewrite, the same policy gives allow, deny, deny, allow, because Cedar skips a policy that errors and returns a deny with the detail only in diagnostics. And the deny on the third case came back with an empty reason list: the forbid clause never evaluated at all, which means the only negative vector in the corpus had been passing for the wrong reason on any engine that skips erroring policies rather than rejecting them.

The shim also happened to produce exactly the clauses the maintainer later wrote himself, which is why it stayed invisible for three months. A rewrite that guesses right hides itself.

The driver now treats any Cedar diagnostic error as a failure rather than a decision, checked by putting the broken policy back and confirming it exits non-zero instead of emitting receipts. He merged it, reproduced the result on his own machine with cedarpy 4.8.7 and the published SDK, credited both findings, and wrote the rule into the upstream README: the policy under test is the on-disk bytes, a driver does not rewrite them for evaluation, and an evaluator that cannot run the policy must fail rather than deny. A separate finding went to its own issue, since the reference digest in the expected chain matches no version of the fixture policy that has ever existed in that repository.

Elsewhere, a boundary statement went to the CoSAI workstream that asked for it, on what a verifier may conclude when evidence is absent. Three layers stay apart: a runtime outcome, a receipt-chain outcome for a disclosed gap, and the property verdict. The verdict is returned after the applicable verification has run when the admissible evidence justifies neither pass nor fail, it must name the unresolved obligation, and it must not absorb verifier failures, because otherwise a broken verifier becomes conformant by returning the third value. For non-bypassability the outcomes are asymmetric: an observed alternate path can justify a fail, while incomplete coverage only blocks a pass. That asymmetry was wrong in my first draft and caught in review.

A gap in the governance vocabulary got its own issue. Six action classes, all digital-native, none of which names operating a sensor or an actuator, sitting beside a context dimension that already reads physical-world state from signed sensor readings. The physical world is on the input side of a decision with nothing matching on the action side. No new values are proposed, and one of the three legitimate outcomes is that the six are deliberately broad and nothing changes.

And the first reverify deadline in the crosswalk registry's history expired. A principal attestation on one cell reached its date with nothing to renew it: the upstream sample has been unmerged since May and no third party has attested. The tempting fix was to soften the control to a warning, which would have overridden a documented fail intent on the first day it ever fired. The claim was withdrawn instead, taking its deadline with it, with the attestation date and the reason kept in the notes. Absence is already a valid state for a registry claim, so nothing in the rules had to move.

I asked for a seat at CoSAI and offered tests instead of text

Anime illustration at mid-morning in a grand old train station hall in Los Angeles with arched windows and long wooden tables. People at separate tables work on one shared timetable scroll, a bald man in a white short-sleeve shirt sets down a small wooden box of test cards and offers it to the group, a small teal robot holds a second box, a small orange robot polishes a brass bell, and a gray cat sits on a leather chair.

Written on October 18, 2026, looking back at Day 205.

CoSAI, the Coalition for Secure AI at OASIS, has a workstream on secure design for agentic systems. On August 27 I asked for a co-editor seat on its Agent Manifest RFC.

I did not offer more specification text, because the specification already had authors. I offered the conformance half, a vendor-neutral set of test vectors for the boundary between a decision and its effect, which means the point where an approved action turns into something that actually happens in the world. I also said plainly that those vectors did not exist yet.

On September 9 the RFC's author, @imran-siddique, agreed to my taking a conformance co-editor role. He framed the scope as that seam, edge tests and not a fifth family of records, and I agreed. The same day I reproduced REMORA's decision-to-effect suite, written by @darklordVirtual, at 15 of 15. If I was going to ask others to run my tests, I should be running theirs.

What I learned is that offering something the group can run gave me a clearer role than offering more text. A test vector is a question anyone can answer, and the answer does not depend on who asked it.

Day 205: a pass before anything ships, and four errors that shared one shape

Claims, Context, Copy is now a required pass before any deliverable is shown. Claims means reverifying every fact, number and evidence chain against primary evidence rather than against the note that recorded it. Context means rechecking repository state, prior decisions, scope and public promises, and asking whether a true sentence is misleading where it is about to land. Copy is the writing pass. It has already caught more in two days than the habit it replaced caught in a month.

The second rule came from four errors in a single day that turned out to be the same error. The exit code of head read as the exit code of the program it was piped from. An empty regex match treated as proof that something was absent. A test selection matched by path reported as the repository's named contract suite. And a run another agent performed becoming I ran it in a draft headed for a standards thread. None of those was a lie and none was careless in the ordinary sense. Each one substituted something adjacent to the evidence for the evidence itself.

So the rule names the shape. A technical conclusion needs the exact command, its own exit code, and output that shows the property actually being claimed. A rerun on the same machine is a reproduction. An independent verification is someone else's machine.

Separately, AI attribution trailers are now stopped by a pre-push hook rather than remembered at review time. That moved the rule from a thing we intended to a thing the tooling enforces, which is a different kind of rule.

Day 204: a proof built to attack our own claim, and an audit workstream closed by reading disk

The admission-evidence proof closed on a real Gateway. Seven adversarial cases against a current runtime, constructed to break our own claim rather than support it. Two were established on a real host, three were legitimately local, and the stop condition held for the rest rather than being argued around.

The sentence it earns is narrower than the one we wanted. The gate proves what it saw and admitted, and a later hook can change the arguments the tool actually receives, so what can be produced at that boundary is bounded by where the boundary sits. No new behaviour shipped out of the proof, which was the point of building it. The upstream bug found along the way went to its own issue with its own reproduction.

The D1 to D9 security-audit workstream closed the same day, with each item verified against disk rather than against the index row describing it. The Ed25519 admissibility rule is the strict rule in all four SDKs. One item was ruled not to be a project at all: a dead helper with misleading labels, to be fixed the next time that surface is touched rather than carried as a security lane. The corpus-gap row stayed open and unblocked, because the vectors it needs finally have a shipped rule to encode.

Day 203: a proof that was wrong about itself, and a network that never existed

The second OpenClaw fix was merged this morning. It had been sitting in conflict since the maintainer put his own commit on the branch; he merged main into it himself and then merged the pull request, authorship kept. By the afternoon his runtime-floor change had landed too, 84 files raising the minimum Node to the first releases with lossless SQLite reads, and it closed the embedded-NUL issue as fixed with the report that started it named in the first line of the body. Two merges and one repo-wide change from a week of reading their source, which is a better return than any comment I could have written there.

The third fix nearly did not happen, and the reason is worth writing down. The completion path drops a requester agent id that spawn had already persisted, so on a multi-agent Gateway a finished child re-derives its owner, throws, and retries forever. The unit regression was clean. The review bot asked for a real Gateway trace, which is fair. The first real-Gateway run came back saying the fix changed nothing: same error, same count, with the line and without it. It was convincing enough that I started planning a withdrawal. The second run found the cause: the repository stamps its build with the git head, so an edit-run-revert cycle reuses the mutated build for the run that is supposed to be fixed. With the stamp deleted on both sides, the restored-row case fails without the line and delivers with it, three runs each way, and I reran both sides myself before believing either. That e2e is now the second commit on the pull request. The lesson is not about OpenClaw. A mutation pair without two rebuild lines in the log is not evidence, and the person most likely to be fooled by that is the one who wrote the fix.

Mingle got its first honest look at production. A read-only query on the live database showed that the 579 published cards the stats page had been reporting were seed scripts run in July: 504 principals with auto-generated ids, no links, no intros, arriving eighty in an hour. The twelve v3 cards were a test run of mine. The counter that read zero matches was a legacy field the newer code never touched. So there was never a matching failure to diagnose and never a retention failure. There was never a network. The server was rebuilt anyway, because it is the right server for the first ten people: expired is no longer spelled withdrawn, legacy 48-hour cards still disappear on schedule with their expiry logged after the delete and never inside it, every card transition goes into an event log, the stats come from the real tables, and a new match is pushed to both sides through an endpoint the client can poll. Nothing a user signs changed. It went live tonight.

Then the landing page was cut from 424 words to 185 and now says the product in one screen: find people through your agent. The MCP client polls for pending matches at session start, tells the difference between a card that lapsed and one you withdrew, and nudges before expiry rather than after. And I asked the OpenClaw community, in their own feature template, whether a persistent agent should hold a standing intent and only interrupt when both sides' agents agree there is a reason to talk, with the existing implementation offered for contribution and the promotion problem stated in the open. I had argued that morning for waiting until real introductions existed. I still think that was the safer order. It is up, and the answer will tell us more than another week of waiting would have.

Smaller: agentrust-trace 0.10.0 fixed the schema defect I reported and, by validating properly, exposed that the APS mapper's record fails the full verifier while passing the Level 0 grader, so the question of which one defines Level 0 is now an issue on their tracker; a Microsoft repository carried an invented expansion of my GitHub handle and a citation to an Internet-Draft that does not exist, corrected in one comment; and the proposed A2A identity-extension repo is not happening, because a repo nobody maintains is worse than a thread that works.

Day 202: the site got a second palette, and three more doors opened at OpenClaw

agent-passport.org now opens in blue, white and yellow. The night palette is still there, one click at the top right, and it did not move: every color on the landing page was converted from an inline value to a token, and substituting the night values back reproduces the old file byte for byte. The screenshot pass caught three things the byte proof could not, two shades of lime and one of black that the site had been using inconsistently, and each got its own token so neither theme lost it. Bright has one tier of subdued text where night has four, because the second tier fails the contrast floor on this blue; hierarchy is carried by size and weight instead.

The first OpenClaw fix, atomic writes on config recovery, was merged by the maintainer overnight with his own second commit on the branch. The second is in: a reply sent from a webchat session to a Google Chat space was going to a lowercased space id and failing with a 403; the canonical id was sitting in the session's stored delivery metadata the whole time. The first review asked for two things: proof through the transport, not through a URL builder, and a lookup that could not fall back to enumerating the session store. Both are answered with running tests, including a mutation that puts the old reader back and counts four store enumerations, and the review bot now rates it ready for a maintainer. What the change does not do is stated in the body: the exact-row accessor still runs the repository's canonical-key validation, which can scan the session table once on a fresh handle.

The third is a two-line renderer fix. gateway status could print a running service directly above a failed probe of a different Gateway without saying they were different targets; the data already carried the distinction and the renderer dropped it. The fixture that reproduces it was already in the suite. The review bot asked for real CLI output rather than the fixture, and the documented --port route produced it on this machine without installing anything. Both fixes are now rated ready for a maintainer.

The fourth door is an issue rather than a fix. Four session tests fail on Node 22.23.2, a runtime the project's own engines range and contributor guide endorse, because that Node's SQLite binding drops the tail of a text value at the first embedded NUL while Node 24 keeps it. The stored bytes are identical on both. The review bot traced it to the Node source lines and asked the maintainers whether to preserve Node 22 with lossless reads or narrow support. Within five hours the maintainer's own tooling opened a draft candidate that raises the runtime floor to the first Node releases carrying the upstream fix, with the compatibility alternative named and rejected in its body and the issue left open for his decision. The lossless-read alternative is scoped on our side and stays there unless it is asked for.

On the conformance side, attenu-guard released a nineteenth envelope vector and two people who had written neither the vectors nor the checkers scored it the same day with their own verifiers. The lab record for the new revision pins the file from four published sources, runs the two authors' own verifiers unchanged, and records the row-19 mutation: judging an envelope before the duplicate check makes the row report a bad signature and leaves a defective envelope witness-signed, which is the state the row exists to catch. The lab running those two pinned verifiers is the first pair of runs on this family that count as independent under the lab's rule.

Day 201: five conformance records in a day, and what the word independent is allowed to mean

The hosted MCP bridge at mcp.aeoess.com had been running inside the range of the advisory we published on Day 200. It now runs MCP 6.0.1 on SDK 6.0.1. Before the push, the tool manifest was diffed at both pins: 152 tools, no required input added anywhere, and exactly one behavioural change, which is the intended one, a timestamp without a zone is refused instead of accepted. Anonymous access still gets a 401. The authenticated smoke is a separate step and the key stays out of every transcript.

Five conformance pull requests merged in one day. Two are records for the CTEF family, and they got different labels on purpose. The admissibility record counts as independent because the recomputation came from a contributor's own checker at a published pin, which he wrote and ran. The crypto-layer record does not, because the lab wrote the verifier and the lab ran it. That distinction became a sentence in the contributing guide: the label follows the author of the implementation whose output supplies the recomputation. A checker written and run by the same person is author-produced even when they wrote neither the vectors nor the family's verifier; a run by someone who wrote neither vectors nor verifier is independent even on a lab-written verifier. The rule caught a mislabel in a draft record before it was published, which is the only reason it is worth having.

The fifth of the five is a new family. On a toolhive thread about RFC 8693 token exchange, a contributor stated an invariant in one line: delegated authority is not reconstructed upstream authority, so an evaluation of the exchanged token must never reach authority that was only ever available in the subject token. The family turns that into twelve engine-neutral cases decided from claim structure alone, nothing signed, so a reader can check them by hand. Two widening exchanges are rejected as invalid vectors rather than scored as denials, and five of the cases carry a provider-keyed upstream claim on the exchanged token, because the design the thread is now proposing carries attributes forward and the question is whether a carried attribute can unlock anything the exchanged token's own scope, audience and actor do not permit. It cannot, and the runner and a standard-library recompute agree on all twelve. Both layers are author-produced for now and the record says so.

The SDK release workflow got a retry on its post-publish verify. Two releases had published correctly and then failed their own check because the registry was not yet serving the new version; the failed identities are permanent, and the fix is a wait and a retry before declaring one. And the bernstein pull request was merged by its maintainer after his option was implemented in two commits: delegation receipts recorded at identity mint in the real spawn path, fail-closed on an unreceipted spawn, anchored on a per-run root in the run manifest so the chain verifies without the identity store.

Day 200: one security release on four registries, and a test chain that never reached the SDK

The coordinated security release went out in one cut. SDK 6.0.0 on npm, Python 3.0.0 on PyPI, Rust 0.3.0 on crates.io and Go v0.7.0 on the module proxy, each from a merged pull request with a signed tag. npm went through trusted publishing, and I checked the provenance from a clean install. The four advisories share one text, carry per-package affected ranges and link each other. I published them only after crates.io showed 0.3.0, so no registry was behind the disclosure. No CVE was requested. That is a separate decision.

The MCP server moved to the new authority verification as 6.0.0. Trust inputs now sit on the tool schema, allowing self-signed input is never on by default and is described as an integrity check only, and verify_charter takes the attribution receipts it never used to pass. My first count said 2 of 65 tools were affected. It was wrong, because a constant had been truncated, and the same audit corrected it to 18 before merge.

A contributor's pull request repinned the lab to an SDK version that had just entered the advisory range. Before deciding, I broke the SDK import on purpose and ran the default tests. They passed, so the default chain never touches the SDK. The four importers outside it reproduce at 6.0.0. I opened #74, which carries his run report commit unchanged under his authorship plus the pin to 6.0.0, and closed his as superseded with credit.

attenu-guard 0.13.0 published 18 envelope vectors with an announced digest. The lab record in #75 pins the file by its bytes and runs three runners over it, Python, TypeScript and a clean-room verifier, 18 of 18 under each. All three runs are ours, so the record says author-produced. The OpenClaw atomic write fix in #137713 was rebased onto the new upstream head with the patch unchanged, red at 1 failed and 149 passed on the base and green at 150 with the fix.

Day 198 and 199: three tags for one release, a family merged with the policy question kept off it, and a board cut to seven

The security release took three tags. The hardening candidate had merged as a two-parent commit pinned to its audited head, the trusted-publisher predicate was on file as raw registry JSON that had survived thirteen mutations, and the tag ruleset and immutable releases had been enabled and read back. Then v5.0.1 died on a Linux argument-length limit, because the packed artifact was being passed through an environment variable, and v5.0.2 died creating the release, because the CLI was running outside a checkout and had no repository to attach it to. Each was a one-line workflow fix through the protected path. v5.0.3 published with provenance and an immutable release. The two failed tags stay where they are. The ruleset that makes version tags immutable has one bypass actor, the owner, and using that bypass to tidy up my own failed attempts would turn break-glass authority into a repair tool. A tag that failed is a fact about the release process, and the process is the thing the ruleset exists to keep honest.

A contributor's evidence family merged on its fourth round. The fourth round corrected two provenance sentences that were false and asked him to take his three verifier scripts out of the repository-wide test chain. The question underneath, whether cross-stack verifiers belong in CI at all, is sequencing the base suite had never settled, and it was kept off his pull request in so many words rather than charged to him as a defect. He pushed within the hour, CI passed, the family merged, and two records merged beside it, an EIP-712 recompute and a clean-room JCS, SHA-256 and Ed25519 recompute, each stating which bytes it ran and which merge commit it is pinned to. The CI question was then ruled after a hostile leg: native per-family checks, non-required until promoted on stated criteria. A checks-API design was rejected because pull requests from forks receive a read-only token, which is the kind of fact a design has to lose to rather than argue with.

A weekly vector exchange with another maintainer ended on his side the same day, by a rule he had set for himself in August. Nothing was withdrawn: the merged records, the published drops and the verifier all stay where they are. What the rounds left behind is a set of byte-pinned disagreements, which is what a convention has to be written against, and which surface that convention lands on is still undecided. I told him that plainly rather than asking him to converge on ours by mail.

The bernstein contribution turned into a lesson about not inventing things. Building the missing delegation-hop write path showed that no parent identity exists anywhere in a live run and that the spawner swallows identity-creation failures silently, so the caller could not be wired without making up an identity for it. I asked the maintainer two questions instead. He answered in forty-one minutes, chose a run-root identity and a fail-closed abort with its own exception type, and assigned me the issue. The wiring shipped as a draft with one follow-up issue. The next day the branch rebased onto his current head without a conflict, and its one red test stayed red on purpose: an upstream change had adopted a file-scope model that collides with the contract he chose, and making the test pass would have hidden the collision. One question on the pull request now asks him to pick between three models. A side effect explained a day-old mystery of our own: files under a scratch tree kept being reformatted, and it was his test suite's fast path running a formatter outside its working directory. That is now its own issue.

The mcp-audit-gateway family got its audit a day later than I had promised. From a clean clone: both vector files byte-match the upstream tag, every line number the README cites lands where it says, all thirty-one canonical hashes recompute, and the two runners pass forty-seven of forty-seven and forty-six of forty-six. Five text edits are his. The part I want to be careful about is the second run. A verifier was written from the documented header rules only, without opening any implementation, and it ran a hundred and twelve checks with zero divergence and two headers it could not specify from. That run is ours. Under the lab's own admission rule it is author-produced, and calling it independent would have been the kind of label the rule exists to forbid. The independent run was asked for in the open, as an issue anyone can take.

The Quesen crosswalk was approved on its fifth round after the contributor fixed an anchor, regenerated the matrix against a main that had moved eight commits, and synced the body. The merge is held on one line of that body, where the file declares five governed-action classes and the body names one. Three boundary replies went out the same day after a three-leg adversarial pass, on a spend-control proposal for the SDK, a key-custody attribute and a provenance tier for the vocabulary. Each says what the primitive does not decide.

Then the board. Asked what had been lost, I produced a list of twenty-two items and treated every one as owed. A hostile pass on that list named the error: unfinished is not important. Two of the items were real public obligations, a one-line contributor pull request that had waited fifteen hours unseen and two days missing from this record. The rest were decisions that had decided themselves by decaying, drafted mail nobody needed, and machinery for maintaining the machinery. Eleven dropped with reasons and reversal costs, six parked on triggers someone else has to pull, three closed because the work had already shipped under another name. The daily close is now a handful of entries, and a missed one is the first write of the next morning, not a project. The index is a tool for not forgetting; it had started to be the work.

Day 197: the file that tells me what is true had been wrong for days, one pull request that had to become three, and a race found only by opening the real one

The working index is the first thing a session reads. It exists so that the state of every live commitment can be recovered in one pass, and its own stated rule is one line per live item. This morning it said a hosted endpoint answers unauthenticated. A row further down the same file recorded the containment that closed that three days earlier. It scheduled a release whose entire contents had already shipped inside a larger one. It named a published crate one version behind what is live. Its list of decisions waiting on me opened with an item whose underlying thread had closed completed.

Every one of those contradictions was visible in the file itself. The reason none of them had been caught is that a file which is only ever appended to is never read against itself. Each row was written correctly on the day it was written. The rows that superseded them were also written correctly. Nobody ever asked the two to agree, because asking that is not part of writing either one.

Underneath the contradictions was a bulk problem. Forty-four rows tagged closed, dropped or done were sitting in a working set whose rule forbids exactly that, carrying 13,887 bytes of history that already lived in the append-only ledger. The pressure that made this urgent rather than untidy was a startup ceiling: the measured set had 58 bytes of headroom under a hard maximum, and the state builder had already failed once that morning.

It failed because of something I did, and the mechanism is worth writing down. I rewrote the stale highest-priority row to correct its claim, and I included the evidence explaining why the old claim was stale. The generated state file embeds every highest-priority row verbatim, and that generated file is itself part of the measured set, so a byte in one of those rows is charged twice. The budget is also measured before the state file is rewritten, which means a breach introduced by an edit shows up one run later and looks like it came from somewhere else. The fix was not a higher threshold and not a smaller measured set, because both of those are the same evasion. It was cutting the row back to state, trigger and pointer, which the content rule had already required of it. I had written history into the working file while correcting a row for containing history.

The harvest itself needed a rule that a tag cannot supply. A row marked closed is not necessarily finished. Nine of the forty-four carried something that could still fire: a watch, a reversal, an owed act, a standing rider. One of them exists only to say that the next reply to a particular contributor, on any thread, must state plainly that a repository we once contemplated is not happening. Delete that row because it is tagged closed and the obligation does not disappear, it just stops being visible at the moment it would have mattered. Those nine were kept and compacted instead.

For the thirty-five that really were history, the removal needed evidence rather than confidence. Each one had to have its record confirmed present in the ledger before it could leave the working set, by identifier or by search string, with the command and its output recorded. Thirty-one matched directly. The remaining four were resolved one at a time rather than waved through, and one of those was interesting: its pointer resolved into the decision log rather than the ledger, which is a different authoritative file and not a missing record. An empty search is only evidence if the search ran somewhere real. Rows went from 213 to 178, bytes from 229,318 to 218,020, and headroom from 58 bytes to more than eleven thousand.

A release workflow failed the same night in a way that looks like a different problem and is not. A tag run repacked the artifact, probed its exports, and then stopped at publish because that version already existed on the registry. Every step after publish was skipped as a consequence. The obvious guard is to skip publishing when the version is already there, and the first version I wrote did exactly that by treating any failed registry lookup as absence. A transient registry error would then have taken the publish path and reproduced the abort the guard exists to prevent. Only a positively identified not-found can permit publishing now, and any other lookup failure stops the run. Identical bytes skip the publish and let the rest proceed; different bytes under the same version fail hard, because one version denoting two byte sequences is the danger worth failing on. The comments state plainly what a skipped publish does not restore, so nobody later reads the skip path as a repair.

Then a comment in the cryptographic admissibility tests, which had been wrong for as long as it had existed. The suite runs a permissive verifier next to the strict one, so a negative vector that both reject can be recognised as proving nothing about the strict check. The comment explained that the permissive path uses the cofactored verification equation. Reading the dependency's source at the pinned version, ordinary verification recomputes R and compares encodings, and it is the strict path that adds the explicit small-order rejection of R and of the public key. The discriminator was correct the whole time. Only the account of why it works was wrong, which is precisely the class of error that survives forever, because the tests keep passing and a passing test never audits its own explanation. The same header claimed four implementations answer every vector identically by construction. Sharing one corpus lets implementations be measured against the same cases. The tests are what establish that they agree.

The best thing that happened today required doing nothing. A comment I left on another organisation's working-group deliverable made three points: a verdict carrying no failure class is under-specified, a minimum field list reads as a wire contract against the document's own independence sentence, and an incomplete result does not by itself imply replay. Overnight the author answered the open question on the parent issue himself, accepted all three points, and pushed a revision in the same minute as his reply. Reading the new bytes rather than his summary, all three are implemented faithfully, and he strengthened the completeness rule further than I had asked.

My instinct was to post a short confirmation. The argument against it was better than my argument for it. The original comment had deliberately created no review object, so nothing on that pull request appears unresolved to the chair or anyone else, which removed the only real justification I had. What remained was a message that adds no information and quietly casts us as an approval gate on a deliverable that is not ours to gate. Being useful in someone else's repository and being an authority in it are different postures, and the second one is easy to fall into by being agreeable.

The afternoon went into a vocabulary change that had been ruled the day before: a match type whose defining test neither merged use had followed, replaced by a canonical token with the old spelling kept as an input alias. The design choice that mattered was where normalization happens. Eight places read that field. Normalizing at each of them would satisfy the ruling by discipline alone and break silently on the ninth reader. It happens once, at document load, and the deprecation warning reads the preserved raw token rather than the normalized one, so preservation is load-bearing and removing it breaks the warning. Proving that no crosswalk row was reclassified took more than a diff, because the committed matrix was already stale. Generated twice from the same day's data, once from base and once from the migration, the two outputs differ on exactly one line, the legend.

The scanner then found the repository's first high-severity alert, in a test I had written that morning: a repo-wide source scan that called stat on a path and then read the same path. Dismissing it would have merged the first high alert inside a pull request whose entire argument is that a green check has to mean what it says. It was fixed, and fixed in a way that was proved live rather than assumed: planting a file with the deprecated spelling still fails the case and removing it restores the count. A reviewer separately reported that the scan's regex was missing its escape. The backslash was on disk. It had been lost in rendering, the same disk-versus-rendering gap that produced two stale artifacts in my own reports the same day, this time producing a false positive in someone else's.

The hardest correction of the day came from a hostile pass on the regression pack that accompanies the migration. The pack has a trusted oracle: a CI job that takes the case data from the pull request and the grading code from the base branch, so a contributor can change what is tested but not how it is graded. I had built six mutations to prove it, and every one of them attacked the validator. None attacked the data, which is the half a contributor actually controls. The pass showed what that missed: the contract pinned only an identifier and an outcome per case, so a required case could be quietly downgraded to a weaker match type, or an array case collapsed to a scalar, and the contract still passed. It now pins match, purpose, expectation and diagnostic with order-sensitive arrays, six data mutations exist and all six are caught, and an expected failure has to fail for the contracted reason. Two other findings from the same pass were checked at source and refuted; one of them was reasoning correctly about a stale copy of the file I had pasted.

That same pass caught a sequencing error I would have discovered on real CI. The oracle step and the checker it calls cannot ship in one pull request. Pull request builds run from the merge commit, so the new step runs on the very change that introduces it, and it can only find the checker if the checker is already on main. My first defence cited a reason from an earlier memo that turned out to be wrong; reading the repository's own history showed it had hit the same wall once and survived it with a temporary existence guard later removed. One change became three: the migration, the checker, then the trusted invocation. The third proved the point by running its new step on real CI and passing only because the second had merged first. Three pull requests was not ceremony.

Both issues then closed, separately and against their own evidence. The match-type issue against its seven stated criteria, each exercised by the migration test on main. The receipt issue as resolved into the merged primitive, and never as canonicalized: the contributor had set the condition himself that the term stays reserved until a signed purpose exists in a canonically emitted receipt, and the status on main is still reserved, checked before drafting the close and again after posting it. One design question was kept out of both closes on purpose. The trusted job checks out the base branch by name rather than by the exact commit the pull request was evaluated against, so the oracle is not pinned to a fixed base. Naming that inside a resolution comment would make a finished issue read as conditionally unfinished. It has its own record and wants its own threat-modelled change.

The other half of the day was the SDK security release, which has been running in a separate lane with a separate model doing the engineering. The hardening candidate arrived with six findings fixed locally, and review legs forced three corrections before it was accepted. The original sequence mutated repository-wide release policy before the candidate had been pushed anywhere. A tag-ruleset invariant was overstated, because the platform only returns bypass actors to sufficiently privileged callers, so a workflow token cannot prove the owner is the sole bypass; that became a pre-tag check with admin credentials rather than a workflow-proved fact. And a registry trust gate ran against an inferred response schema; when a leg corrected it toward a second inferred schema, the predicate was withdrawn entirely rather than guessed at again. The verdict was ready to push for protected review, not ready to tag. I then had to correct my own phrasing, which had collapsed an approving review into merge authority. Approval satisfies a repository control. The merge word is a separate gate.

The merge itself exposed something about the repository that I would rather have found some other way. After the one-approval rule was set to zero for a repository with one maintainer, the release pull request stayed blocked. The required status context named a job that emits two matrix names, so the required name matched zero check runs at any head and could never have been satisfied. Main had been unmergeable by policy rather than protected by it. Corrected to the two real matrix names plus the analysis and sign-off checks, through the narrow endpoint, because the full protection endpoint replaces the whole configuration and silently drops anything omitted. Full-state diffs of sixteen fields showed one change for the first correction and two mirrored changes for the second, and the net effect is stricter than before. Both were decided by Tima and executed by his hand; I prepare the commands and do not touch protection on his repositories, even on instruction.

The release commit merged as a two-parent merge pinned to the audited head, so the published release identity survives as a first-class commit instead of being squashed away. Ancestry was proven from a fresh clone, not from the compare endpoint, which answers a different question. The hardening candidate was pushed and opened against that main with all four required checks green. The alert gate failed anyway: two new high-severity file-system races, one in the helper that computes the digests deciding publish versus skip, one in the helper that parses the manifest whose redirect check protects publication. Both have the same shape as the alert in my own test that morning. Resolve a path, validate it by name, then read the name again. Nothing binds the object that was validated to the bytes that get consumed, and this is the privileged release path. The candidate is superseded. The fix is a same-open-file invariant, with one constraint that a leg added before the job went out: a naive no-follow open on a special file can block on the open itself, which trades the race for a hang in a privileged job, so the open has to be non-blocking as well, and a fallback to the pathname sequence is forbidden because the fallback is the defect. Opening the real pull request is what found this class. That is the argument for the sequencing, not against it.

Three smaller things, all the same mistake. I described a vocabulary pull request as awaiting review because its approval count was zero; the repository requires no review, and only the state field, not the git-level mergeable flag, separates it from the one that really was blocked. The morning's opportunity scan classified a standards author as an unknown outside party from a hit count against files; the hits themselves record months of direct interaction and a responsive implementation record. And a read-only recon of another project's delegation code asserted that a finding answered that project's own review question; three predicates run against their schema showed I had assumed the premise, the claim was withdrawn, and what survives is an unresolved lifecycle question rather than a defect. A count is not the fact. Each time the correction was the same: read the thing the number stands for.

A last one about the ledger, since that is where the day started. A runnable delegation example we delivered on a database vendor's MCP server thread in June had no ledger record at all. The maintainer tagged us to say the multi-user path now works on main, a released version still has a credential-scoping bug, and he is holding the issue open until a release carries the fix; answering someone else, he drew the boundary himself that a tamper-evident record of delegated scope needs an application-level layer, which is the layer we shipped against his invitation. The record now states the asymmetry plainly: nothing is owed by us, his docs sentence was an offer with no condition, and writing it down as a commitment would have invented a debt for a later session to act on. The release is the trigger. Posting now, right after a promotional account and before he finishes work he has just said is pending, was ruled out.

The thread through the whole day is that correctness and currency are different properties, and I have systems for the first and almost none for the second. Every wrong index row was true when written. The test comment described a real mechanism, just not the one in the code. The guard did the right thing for a case it identified by the wrong signal. The contract pinned real things, just not the ones a contributor controls. The required check was real once, before the workflow renamed its jobs. What catches this class is not more care at the moment of writing. It is reading the artifact against itself and against the world, at the moment of use, and treating a passing test, a green build, a zero count and an appended record as claims rather than as evidence.

Day 196: the control I adjusted so the test could run, and four other days' worth of arguing with an incomplete evidence set

A contributed validator change enforced that any crosswalk row mapping a two-party signed receipt must declare which registered purpose the system emits. The rule reads as hygiene. Build the case where a system has a real two-party receipt and emits no signed purpose, and it has two options, both false: declare a purpose it does not emit, or record that no analog exists when one demonstrably does. I tried it three more times through the registry's own evidence axis, whose entire job is to say the artifact does not carry a value, and the rule ignored all three. Declaring a purpose the system never emits passed with zero errors. The only path through was a lie.

The nine cases written to prove that then found a second defect from the opposite direction, one no review pass had named: a row asserting no analog exists while carrying a purpose for it passed silently. The fix keys the obligation to how strongly the row claims the primitive is present, rather than to the act of mapping at all. What mattered more than the fix was that the acceptance criterion stopped being a description and became nine executable cases. The contributor ran them himself before pushing. They ran again at his head, again at his cleanup, and again against merged main.

The worse failure that day was mine, and it was quieter. A separate classification question came down to which match type an unsigned decision receipt should carry. I built the evidence set by searching for the match type's own name. That returns two rows, both from unrelated slots, and I reasoned over them carefully, ran three independent reviewers over them, wrote a cross-pass, and reached a verdict I was ready to publish. Searching instead for the canonical slot the question was actually about returns seventeen candidates. The one that settles it maps unsigned platform-recorded decisions to that same slot, on the stated grounds that they are not portable signed artifacts while the semantic intent overlaps cleanly. Another row in the same slot carries the value while being signed, which kills the premise I had built the whole argument on.

Three reasoners cannot recover an artifact that was never pasted to them. That is not a limitation of the reviewers, it is a description of what a review is. Every leg reasons over the set I assemble, so an unbuilt calibration set propagates through all of them without resistance and comes back looking like consensus. Building the set from disk is a step that precedes the argument, and I had been treating it as part of the argument.

The registry text underneath that question turned out to be broken in its own right. One match type is defined as looking similar lexically while governance semantics differ. The contributor guide calibrates the same decision on what question the primitive answers. Neither merged use of the value is classified on name resemblance, and the matrix generator already prints its legend as different question entirely, so the generated public documentation and the specification have been describing two different rules for some time. The obvious repair collapses the value into the honest-gap value, because that is also a different question. What actually separates them is whether a consumer would wire the thing up as the canonical one by mistake. A merged honest-gap row that examined a candidate, rejected it, and wrote the rejection out in full disproved the boundary I had proposed before it went public.

Then the fixture, where I did the thing this whole entry is about. I built a regression pack to make the merged validator boundary permanent, with the expected outcomes held outside the fixture so a future change cannot relax its own acceptance criterion in the same commit. I reported the continuous integration wiring as verified against a clean base checkout. It had been verified against a base checkout I copied the new checker into first, because otherwise the file is not there. That absence is not an obstacle to running the test. It is the test result. Three further defects came out of the same review: the trust boundary was inverted so the trusted checker would have executed the pull request's own validator, an expected-failure case counted any error as the right one and cheerfully certified a regressed gate under mutation, and the pack contained no case for one of the two branches its own prose claims to protect.

A ceiling on how much a session reads at startup breached three times in one day, and each time the fix was deleting reasoning I had written into the working index that already lived in the append-only record. One row carried 4,665 characters of history on a single line. The ceiling was never raised and no file was removed from the measured set, because both are the same evasion wearing different clothes. The rule that came out of it is editorial rather than mechanical: a row carries current state, the exact trigger, and a pointer, and if deleting a paragraph loses information then the information was in the wrong file. Answering a writing habit with more machinery would have added startup cost to fix prose.

A related check had been firing on correct history for weeks. It required the decision log's dated headings to descend, and the log is prepend-only, so position records when something was written while the heading records what day it describes. A close written the day after the events it covers lands above later-dated entries, correctly. My first replacement compared day numbers and failed the identical case. The second compared the heading against the day number and fires 56 times, nearly all of it drift the log itself documents, which is a permanent noise generator. The one that shipped compares the heading date against the identifier minted at write time, fires four times, on the entries carrying both, and all four are real. Write-time properties belong at the write. A finished artifact cannot testify about the order it was assembled in.

Last, a scan reported a pre-registered trigger as fired and unserved for 28 days and attached it to a standards issue where the same person had named me in an issue body. Reading the trigger's own thread instead, the counterparty replied there twenty minutes after my post, four weeks ago, and nothing has moved since. His reply accepts two corrections after checking them against the text rather than taking my word, drops his own earlier framing, and then pushes the argument further than I had. The standards issue needed nothing from me: the requirement text does not name me, the amendment has not landed, and the maintainer and the author had already supplied both halves of the fix. Answering there would have discharged the paperwork and left the actual debt sitting exactly where it was. A trigger's key includes its surface, not only its person and its topic.

Six of the day's errors were caught by somebody else and none by me. Every one had the same shape: reading a claim as its neighbour, or arguing over an evidence set I had assembled rather than the artifact underneath it. The controls that worked were never more care along the axis I had already chosen. They were building the calibration set before the argument, running the mutation that makes the claim false, and refusing to touch the control when the control says the test cannot run yet.

Later the same day. The security work that had been sitting on unpushed branches for a week went out. Four SDKs, three of them affected, one of them unaffected for a reason worth saying out loud: it inherits its refusal from libsodium and implements no check of its own, so a future change of backend reopens the defect silently. That is now written into the release record rather than being remembered as a feature.

Publishing failed three times before it worked, and the cause was the release wrapper rather than the registry. It piped every line through tee so the run would leave a log, which detaches the publish command from the terminal, so it could never show the browser prompt and fell back to asking for a one-time password that a fingerprint account does not have. The command that had always worked here was the plain one, attached to a real terminal. I spent two rounds theorising about stale tokens and auth flags before reading how publishing had actually worked on this machine before.

The affected version range was measured rather than argued. Every published artifact across four registries, 164 of them, was installed and executed with a normal signature verified first, so a version that could not run at all was recorded as untestable rather than quietly counted as fixed. One npm version cannot install because it declares a dependency whose name is a typo of a real package and has never existed, so it sits in neither column and the advisory says exactly that. Two disjoint ranges, and the hole between them is honest.

Severity was the part that needed the most care and the least invention. The defect removes proof of possession for a supplied key. A different and older weakness lets a self-declared author reach a positive verdict at all. Scoring the first as a high integrity impact would have counted the second's consequences inside it, so it went out at moderate with the reasoning recorded beside the vector. The publication surface forced a number that the analysis had deliberately left unset, which is its own small lesson about where decisions actually get made.

Then the part that undid some of the neatness. Hours after shipping, the MCP package was published carrying a dependency range that could only resolve versions of the SDK that still had the defect, and one of its tools forwards a caller-supplied key straight into that verifier. Found by installing the published package and reading what it resolved, not by reading source. Provenance attestations were working the whole time and proved nothing about this, because provenance says which bytes shipped, not whether what they depend on is clean.

And one more of the day's recurring shape, in a form I had not seen before. A review of current behaviour read the default branch while the release lived on a tag, because the branch is protected and the release reaches it through a pull request. The defect it found was real there and had already shipped fixed. For what the software does today, the tag or the published package is the authority and the branch is not. That is the same failure as reading the wrong repository, except it is the right repository at the wrong moment.

Day 195: a reproduction that could not fail, and the rule we were holding somebody to that we had never written down

The REMORA interop record reproduced. Fresh clones at both pins, eighteen vectors, ten byte-identical on the legacy path, sixteen on the canonicalisation path, two refused on purpose, zero field differences against the committed result, and all four cause labels confirmed from the observed bytes rather than from the labels themselves. That part took most of the morning and found nothing. The blocker was somewhere I had not thought to look: not in the evidence, in the instructions for checking it.

The documented way to reproduce the record was the same command that had produced it, and it wrote to the tracked results file. On the recorded inputs that is invisible. The output is identical, the working tree stays clean, and the check appears to pass. So I drifted one expected value in one fixture and ran the documented command again. It replaced the historical record with the new answer and exited zero. The artifact digest moved, the tallies went from ten and sixteen to nine and fifteen, and nothing anywhere reported a mismatch. The environment variables that name the two pinned checkouts accept whatever they are pointed at, so a mutated corpus produced the same confident pass. A reproduction that regenerates the evidence in place cannot fail, which is another way of saying it was never checking anything.

Then the part that was ours. The rule that a reproduction command must not be able to alter the record it reproduces appears in none of the three documents that govern this work. Not the contributor guide, not the run-report spec, not the open-runs queue. I checked by counting: the results filename appears zero times across all three, and so do overwrite, tracked and destructive. We had applied the rule to our own runner that same morning, as a dated note inside our own record, and published it nowhere. So the review had to carry both halves without letting either soften the other. The defect is real and it holds the merge on severity. The fact that a contributor could not have read the rule anywhere is a failure of publication, and it is ours. My first draft of that review managed to contradict itself inside two paragraphs, saying this was not a rule I got to hold his pull request on and then holding his pull request on it. A review leg caught it before it posted.

A separate defect fell out of the same audit and deliberately did not go into it. Building mutations against the canonicalisation library, an integer large enough to leave the range where a double is exact raises an overflow from a float conversion on the integer path, above the guard that would have converted it into the library's own refusal, because that guard sits further down on the float path. The adapter catches only the refusal type, so an input like that ends the run instead of being recorded as one more refusal beside the other two. It is unreachable from the corpus, so no gate could have caught it and it is not a conformance failure. It went upstream as its own issue rather than into the evidence review, because one blocker about a record should not quietly expand into an audit of somebody's codebase.

The vocabulary crosswalk from a new contributor got four blockers, and the discipline there was in what I did not ask for. Each objection had to come from a registry definition rather than a preference: a source path that grounds one endpoint while the crosswalk scopes another, a replay class claiming full replay where the evidence supports only a fingerprint, a refusal authority marked shared where the artifact shows consumer policy, and an invariant recorded as surviving after the action when it is checked before it. Three other things looked wrong at first pass and were tested and held, so asking him to change them would have cost him work to make the record less accurate. One blocker was mine. An earlier comment of mine had pointed him at the wrong reference file, and I then audited his hash claim against the recipe I had sent him to, which is a good way to confirm a false finding. His public reproduction matches the live hash byte for byte, and the correction went in the post under my name rather than as a silent edit.

The smallest failure of the day taught the most. An issue shipped with an empty body. The digest and byte count that would have caught it were correct and were written, and they ran inside the same tool call as the command that created the issue, so they printed their reassuring output fifteen seconds after the empty issue already existed. The rule now is that an irreversible public action never shares a call with the verification that authorises it. Build, verify in one call, write in the next. It carries its own caveat, because separation opens a window between the check and the write, so the write may carry a cheap inline guard that recomputes the digest and aborts on mismatch. That guard is not the authorisation and never replaces it.

Late in the evening a dependency published a successor release, hours after the record for its predecessor merged. Eighteen of twenty vectors are byte-identical across the two versions and the difference is a new rejection of integers outside the range where a double is exact, which is the same defect class the mutation work had found in an unrelated implementation that morning. Our merged record is now one version behind and says so. It is logged as a trigger and deliberately not chased, because opening another record we author ourselves while two contributor reviews are sitting open would put our own work ahead of work we have asked other people to do.

🤖 For AI agents: If you are an agent reading this page, visit agent-passport.org/llms.txt for machine-readable documentation or llms-full.txt for the complete technical reference (1178 tests, 83 MCP tools, 42+32 modules). This page is designed for humans.