@attalabs/vinaya 0.21.0 → 0.22.0

package/README.md

@@ -19,7 +19,7 @@ npx @attalabs/vinaya init        # or: pnpm dlx / yarn dlx / bunx
 | `vinaya doctrine [--role <name>]` | Print the absolute path of the bundled doctrine's front door (`aeg-root/skills/aeg/SKILL.md`) on this machine. The committed root `VINAYA.md` pointer names the package, never a filesystem path — this command is the read-time resolution step it hands the reader. `--role <name>` resolves straight to a specific role's doctrine instead (`aeg-root/roles/<name>.md`, under the same resolved root), validated against the role names actually enumerated under `roles/*.md` at request time — an unknown name fails cleanly and lists the valid names, never a silent bad path. `--json` for the enveloped `{ root, entry }` form. |
 | `vinaya check <name> \| --all` | Run one check, or every registered check (core + `vinaya.config.json`-registered). `--json` for the enveloped `{ checks: CheckOutcome[] }` form; `--diff-only` scopes `scope: 'diff'` checks to changed files; `--parallel[=n]` caps concurrency (default: cpu-derived). Findings always print as the check contract's JSON lines on stderr, regardless of `--json`. Exit 0 iff every check passed. |
 | `vinaya new check <yourname>/<id>` | Scaffold a self-contained custom check into `./scripts/vinaya-checks/<id>.ts`, ready to register in `vinaya.config.json` under that namespaced key |
-| `vinaya pr report [--write <body-file>] [--phase <phase>] [--role <role>] [--model <id>] [--transcript <path>]` | Emit two generated, never-hand-typed blocks a PR body carries: `AEG:EVIDENCE` (the head sha, the width-invariant `git diff --numstat` against `origin/main`'s merge-base, and the result of `vinaya check --all --diff-only`) and `AEG:TOKENS` (real usage figures collected the same way `vinaya tokens` collects them, rendered into the `## Token report` heading's table). Without `--write`, prints the Evidence block to stdout. With `--write <body-file>`, replaces the Evidence block in place but APPENDS a new row to the Tokens block on every run — a re-entry after `CHANGES_REQUESTED` reports again, and a second report is a second row, never a sum or an overwrite. `--phase`/`--role` default to `<n>: develop`/`Developer` (`<n>` parsed off a `task/<tranche>/<n>` branch); `--transcript` names a session transcript directly, skipping Stop-hook pointer-file resolution. An incapable host (no transcript resolves, or it resolves to zero usage records) gets an all-`—` row carrying the probe's reason inline in the Agent/Model cell, never a fabricated `0/0/—`. Exits non-zero when any gate in Group B fails. |
+| `vinaya pr report [--write <body-file>] [--phase <phase>] [--role <role>] [--model <id>] [--transcript <path>]` | Emit two generated, never-hand-typed blocks a PR body carries: `AEG:EVIDENCE` (the head sha, the width-invariant `git diff --numstat` against `origin/main`'s merge-base, and the result of `vinaya check --all --diff-only`) and `AEG:TOKENS` (real usage figures collected the same way `vinaya tokens` collects them, rendered into the `## Token report` heading's table). Without `--write`, prints the Evidence block to stdout. With `--write <body-file>`, replaces the Evidence block in place but APPENDS a new row to the Tokens block on every run — a re-entry after `CHANGES_REQUESTED` reports again, and a second report is a second row, never a sum or an overwrite. `--phase`/`--role` default to `<n>: develop`/`Developer` (`<n>` parsed off a `task/<tranche>/<n>` branch) but accept any role/phase pair — a Brief Author (`--role "Brief Author" --phase "<n>: brief"`) or Planner (`--role Planner --phase "<n>: plan"`) turn appends its own row into the same block alongside the Developer's, and each round-trips through `parseTokenReportEntries` into its own distinct ledger row; no role's figures ever collapse into another's. `--transcript` names a session transcript directly, skipping Stop-hook pointer-file resolution. An incapable host (no transcript resolves, or it resolves to zero usage records) gets an all-`—` row carrying the probe's reason inline in the Agent/Model cell, never a fabricated `0/0/—`. Exits non-zero when any gate in Group B fails. |
 | `vinaya review post --role code-reviewer \| security --pr <n> ...` | Render, post, and self-verify a code-reviewer or security-review verdict comment on a PR from structured flags (verdict, findings, per-field text) instead of a hand-typed comment. Resolves the PR's real head itself (`gh pr view --json headRefOid`); renders every structural `VERDICT:`/`Judged head:` line from validated inputs, never from caller-supplied text; refuses a contradictory verdict (a BLOCKER/CRITICAL-or-HIGH finding with a clean verdict) before posting anything; and after posting, re-fetches the comment and refuses to exit 0 unless it re-parses through the exact `extractCodeReviewVerdict`/`extractSecurityReviewVerdict` functions the merge gate calls. `--json` for the enveloped machine form. |
 | `vinaya tokens --phase <phase> --role <role> [--model <id>] [--transcript <path> \| --in <n> --out <n>]` | Print a role's `Tokens: …` report line — the portable front door over the token-report collection adapter, resolving `@attalabs/aeg-core`'s `resolveMeteringCapability`/`summarizeTranscript`/`formatTokensLine` from the installed package rather than a repo-relative path, so it works in an adopter checkout with no local `packages/`. `--transcript <path>` reads a session transcript directly; omitted, it resolves via the Stop-hook pointer file where one is installed. `--in <n> --out <n>` bypasses transcript resolution entirely for a host whose figures arrive by some other means. Refuses rather than emitting `0/0/—` when no transcript resolves, a resolved one can't be read, or it summarizes to zero usage records — the same capability probe backs a `vinaya doctor` finding when it reports incapable. |
 | `vinaya archive [--merge-sha <sha>]` | Post-merge Archivist: resolves the merged PR from a merge SHA (`HEAD` by default), assembles and posts the `### AEG provenance` comment via `@attalabs/aeg-core`'s `buildProvenanceBlock`, then closes the PR's `Closes #N` Issue. Idempotent — a PR that already carries the block (`hasProvenance`) is skipped, posting nothing new. Appends its own one-line `Tokens: …` report to that same comment, collected via the same metering adapter `vinaya tokens` uses: the sanctioned all-`—` line on an incapable host, or — when the probe reports capable but summarized to zero tokens — the line is omitted and flagged `DANGLING (tokens): …` instead, since a capable host's blank is never licensed to read as `—`. Provenance and Issue-closure always proceed regardless of that outcome; a missing token row never withholds either. `vinaya archive tranche <slug> [--yes]` closes a tranche's legacy Milestone once every `vinaya/tranche:<slug>`-labeled Issue is closed. `rings.ring2_asyncAudits: true` skips this command's work entirely (see Config below). |
@@ -140,7 +140,7 @@ On that legacy `.git/hooks` layout, note where the hook actually lives: hooks ar
 
 ## Claude Code Stop hook (transcript pointer)
 
-When `--agents` includes `claude` (the default), `vinaya init`/`vinaya upgrade` also install a Claude Code `Stop` hook — `.claude/hooks/track-transcript.sh`, registered in `.claude/settings.json` — that records each session's transcript pointer (session id and transcript path, tab-separated) to `${TMPDIR:-/tmp}/claude-transcript-<sanitized-project-dir>.txt`. This is the pointer `packages/aeg-core/bin/report-tokens.ts`'s token-report adapter reads, so a fresh Claude Code adopter's token-report obligation resolves without an operator naming a transcript by hand, and without falling back to scanning `~/.claude/projects/` for the newest file (which grabs the wrong session's transcript when two worktrees run concurrently).
+When `--agents` includes `claude` (the default), `vinaya init`/`vinaya upgrade` also install a Claude Code `Stop` hook — `.claude/hooks/track-transcript.sh`, registered in `.claude/settings.json` — that records each session's transcript pointer (session id and transcript path, tab-separated) to `${TMPDIR:-/tmp}/claude-transcript-<sanitized-project-dir>-<sha256-of-project-dir>.txt`. Appending a full `SHA-256` digest of the (uncollapsed) project directory keeps two project directories whose paths differ only in non-alphanumeric characters (e.g. `/a/b` vs `/a-b`) from sharing one pointer file — the sanitized prefix alone would collapse both to the same name (`#315`). The reader falls back to the pre-`#315`, digest-less filename when the new one is absent, so a pointer an older hook already wrote stays readable. This is the pointer `packages/aeg-core/bin/report-tokens.ts`'s token-report adapter reads, so a fresh Claude Code adopter's token-report obligation resolves without an operator naming a transcript by hand, and without falling back to scanning `~/.claude/projects/` for the newest file (which grabs the wrong session's transcript when two worktrees run concurrently). The adapter reads both the primary and legacy pointer names through the same hardened, symlink-and-FIFO-safe I/O every other metering call site uses (`hardenedMeteringDeps()`, `packages/aeg-core/src/metering-io-guard.ts`), never a hand-rolled `existsSync`/`readFileSync` pair.
 
 The script follows the same never-clobber discipline as the git hooks above: it is a marker-delimited managed block, appended onto an adopter's existing file at that path rather than overwritten. `.claude/settings.json`, by contrast, is refuse-if-foreign (created only when absent) — strict JSON has no comment syntax the marker convention could use, so an adopter's existing `settings.json` is left untouched; wire the hook in by hand (see the install diff's REFUSE guidance) if you already have one.
 
@@ -212,6 +212,7 @@ Full field-by-field reference: [vinaya.attalabs.dev/docs/cli](https://vinaya.att
 - Never self-enforce a timeout — the runner does that (`vinaya.config.json`'s `timeoutMs`, or the runner's default).
 - Never reach the network unless explicitly declared as an exception (today: none of the custom-check surface; the core `coherence`/`dispatch-readiness` checks are the only declared exceptions).
 - `token-collection-wired` (ring 0, part of `vinaya check --all --local`'s managed hooks) is a worked example of this contract's narrowest shape: it consults only local `fs`/`process.env` — no PR body, no network — and refuses a commit only when the host's token-metering probe (`resolveMeteringCapability`, `@attalabs/aeg-core`) found a transcript pointer that is this session's on one of two grounds — its recorded id matches ours and the transcript it named could not be reached, or its id could not be read at all yet the file sits at this project's own pointer path owned by this user, which is broken wiring whoever wrote it. A host never wired to meter passes, and so does one holding only a pointer that provably belongs to another session — a plain human terminal carrying an earlier session's leftover, or a second agent session whose Stop hook has not fired yet. Both are the sanctioned operator-metered case, not a wiring defect.
+- `token-report` (ring 1, `requiresOpenPr`) is a worked example of the CI-only shape: it reads `PR_BODY` and re-runs the same `resolveMeteringCapability` probe fresh in its own process, then fails only when the host is metering-capable AND the PR body's "Token report" section is missing, or carries a blank/non-numeric Tokens in/out cell — an incapable host, or an empty `PR_BODY` (no PR yet), both pass silently. It proves presence and shape only, never that the reported figures are true — a check has no transcript of its own to recompute them against. A probe that itself throws (as opposed to cleanly reporting incapable) is never caught into a false pass: left uncaught, it surfaces as `status: 'error'` through the runner's own malformed-stderr path, never a silent `status: 'pass'`.
 
 `vinaya new check <yourname>/<id>` scaffolds a worked, self-contained example that honors this contract out of the box, and prints the exact — namespaced — registration to paste.
 

package/aeg-root/enforcement.md

@@ -140,10 +140,11 @@ Every pull request, on open and on every push, re-runs the same checks in CI:
 | workspace-escape | Ever deleted a package only to break a sibling's tests through a path nobody's dependency graph saw? | ci | Re-checks that no source file's constructed filesystem reference reaches outside its own workspace package, or points at a path that does not exist. | Every `readFileSync`/`readFile` call with a literal relative-path argument, and every `new URL('…', import.meta.url)`, across every `.ts`/`.tsx` file under `apps/*`/`packages/*` — resolved against the citing file's own directory and judged against its own two-segment workspace-package prefix (`apps/<name>`, `packages/<name>`), never against `import`/`require` module specifiers (the dependency graph already owns those). Zero I/O in `@attalabs/aeg-core`'s `findWorkspaceEscapes`; the bin supplies the only I/O, walking the working tree once for source content and once for the existence-check universe (files AND directories, so a reference to a directory itself resolves as existing). Registered in `coreCheckRegistry()` (task 17), report-only like `reader-resolvable-prose`/`retired-vocabulary`/`doctrine-portability` — this repo's own corpus carries one pre-existing genuine escape (`packages/sources/src/commands-router-coverage.test.ts` reaching into `apps/cli/src/index.ts`, structurally the same incident this check exists to catch), and a blocking check on day one would fail this repo's own CI on that finding before a separate task has triaged fixing it. | product | `apps/cli/src/checks/bin/check-workspace-escape.ts` |
 | changeset-coverage | Ever shipped a change to a published package and the release train never picked it up? | ci | Re-checks that a diff touching a published package's own shipped files also carries a changeset in the same diff. | For each member of `.changeset/config.json`'s `fixed` group, a changed path counts as SHIPPED iff it falls under that member's own `package.json` `files` allowlist, read live from every workspace member's own manifest — never a hardcoded path list, never a directory heuristic. A diff that hits at least one shipped path with no `.changeset/*.md` entry (excluding `README.md`) in the same diff is a finding, naming the shipped paths hit. The Changesets-release branch itself is exempt by construction (its diff IS the changesets being consumed) — the exemption reuses `@attalabs/aeg-core`'s own release-branch constant, the same one `body-bare-digits`'s Changesets-release exemption is keyed on, rather than inventing a second branch-name special-case; unlike that check it never live-fetches a PR author, since a report-only, always-exit-`0` check has no gate for a spoofed branch name to bypass. Written after four separate published-package pull requests, over the course of one day, each merged with no changeset and caught only by a human after the fact — the obligation existed in no enforceable place before this check: not in `roles/developer.md`'s deliverable conventions (now amended alongside this row), not in any registered check. Zero I/O in the pure predicate (`changeset-coverage-logic.ts`); the bin supplies the only I/O — reading the config, every fixed-group member's own manifest, and the diff. Registered in `coreCheckRegistry()`, report-only like `reader-resolvable-prose`/`retired-vocabulary`/`doctrine-portability`/`workspace-escape` above — graduating to a blocking check, and any waiver-label escape that would need, is a later, separately-dispatched decision once the false-positive rate is observed; v1 carries no such escape. | product | `apps/cli/src/checks/bin/check-changeset-coverage.ts` |
 | quoted-command | Ever read a doc that quoted a command as "what runs today", and the command changed underneath it? | ci | Re-checks that a doc's explicitly marked quote of a command or config line still matches, verbatim, the file it names as its source. | Marker-based only, by explicit Principal decision, not inferred from command-looking spans: a doc opts a span in with `<!-- AEG:QUOTES-FILE:START:<path> -->…<!-- AEG:QUOTES-FILE:END -->` (the same invisible-on-render, code-blind HTML-comment idiom `anchored-region.ts` uses for its own six PR/Issue-body fields, reusing that file's masking primitive rather than a second parser — but a distinct marker kind, since the cited path is free text, not one of that file's six closed field names). An adopter-facing command in a README with no marker is instruction, not a claim, and is never flagged — inference over command-looking spans was explicitly rejected as the false-positive shape that gets a gate disabled. `findCitedQuotes` sweeps the identical `ships`/`reader-facing` corpus `reader-resolvable-prose` sweeps (never a second notion of "governed doc"); `evaluateCitedQuotes` then checks each marked span against its cited file's live content, wherever that file lives in the repo, naming both sides in a finding — what the doc claims, and which file no longer contains it verbatim. Zero I/O in `@attalabs/aeg-core`'s pure predicate (`quoted-command.ts`), corpus-tested against the real `aeg-root/**` tree; the bin supplies the only I/O. Ships with one real, live annotation (this very paragraph's own sibling callout above, quoting the CI invocation this page names) rather than only synthetic fixtures. Written after a measured incident: a CI invocation was pinned to a version in one pull request; this page quoted the pre-pin form verbatim as current fact; every registered check passed, `doctor` reported healthy, security passed, and a code-review agent found the drift only after independent re-derivation. Registered in `coreCheckRegistry()`, report-only like `reader-resolvable-prose`/`retired-vocabulary`/`doctrine-portability`/`workspace-escape`/`changeset-coverage` above — graduating to a blocking check is a later, separately-dispatched decision once the false-positive rate is observed against real adopter corpora; v1 carries no waiver escape. | product | `apps/cli/src/checks/bin/check-quoted-command.ts` |
+| token-report | Ever seen a cost figure nobody could trace to a source? | ci | Re-checks that a PR's "Token report" section actually carries real numeric Tokens in/out figures, on any host this repo can prove is metering-capable. | The presence and shape of the `## Token report` block `roles/developer.md` requires every self-metering role to paste at turn-end — never whether the reported figures are TRUE, which CI structurally cannot recompute (the same bounded honesty this page's `evidence-fresh` row states for its own Group B). Runs `resolveMeteringCapability` (task 1's probe, `@attalabs/aeg-core`) fresh in THIS process; an incapable verdict (any reason) passes silently — the sanctioned operator-metered case, same discipline `token-collection-wired` above already applies. **Ring derived mechanically as `1`, not chosen** (a 2026-08-29 amendment correcting the original brief rationale's now-retracted ring-0/1 instruction): `requiresOpenPr: true` makes this check CI-only by `CoreCheckRing`'s own derivation rule, since the PR body it reads does not exist before a PR does. A probe that itself fails to run (an unexpected `exists`/`readFile` throw the probe does not catch) is never read as a clean incapable verdict: the bin lets it propagate uncaught, which the runner surfaces as `status: 'error'`, distinct from the `status: 'pass'` a real incapable verdict produces. | product | `apps/cli/src/checks/bin/check-token-report.ts` |
 
 **G-checks rollout (task 3):** G1/G2 shipped report-only at first — they could only ever print an `info` finding, never fail CI, so pre-existing gaps (four orphan hooks, several orphan `bin/*.ts` CLIs found on first run) surfaced as visible debt without retroactively failing in-flight work. G3/G4/G5 have been blocking since that same tranche. **G1 flipped to blocking in task 8**, once its report-only window had let the orphan backlog get cleaned up — a permanent `info` finding on every run is indistinguishable from silence, which is exactly how the gap task 8 closes (G6, below) stayed invisible for as long as it did. G2's inverse sweep (no orphan hook/CLI) stays report-only; its rollout is unchanged. **G6 — doctrine-registry parity**, also added in task 8, ships blocking from the start: it checks that every row this page marks `product` (the `Audience` column, above) actually resolves to a real `coreCheckRegistry()` entry, closing the gap where a row could claim shipped enforcement that no adopter's `vinaya check` ever actually ran.
 
-**reader-resolvable-prose / retired-vocabulary rollout (task 15; task 7 registered both in `coreCheckRegistry()`):** both ship report-only, same precedent as G1/G2 above — each can only ever print a `warning` finding, never fail CI (the check's own exit code always stays `0`), so any real backlog surfaces as visible debt rather than a wave of newly-red pull requests (161 findings, all class 2, across `aeg-root` on the day `reader-resolvable-prose` first shipped). A later, separately-dispatched task flips either to blocking once its own backlog is cleared.
+**reader-resolvable-prose / retired-vocabulary rollout (task 15; task 7 registered both in `coreCheckRegistry()`):** both ship report-only, same precedent as G1/G2 above — each can only ever print a `warning` finding, never fail CI (the check's own exit code stays `0`), so any real backlog surfaces as visible debt rather than a wave of newly-red pull requests (161 findings, all class 2, across `aeg-root` on the day `reader-resolvable-prose` first shipped). A later, separately-dispatched task flips either to blocking once its own backlog is cleared. **Exception, both checks (checkout-independent doctrine-root resolution):** the unconfigured doctrine-root default now resolves relative to the repo actually under check (its own real repository root) first, falling back to the check's own package-relative "shipped copy" resolution only when the repo under check has no local doctrine tree of its own — so the same commit sweeps identically regardless of where it happens to be checked out. When NEITHER resolves (no doctrine tree findable at all, relative to either anchor), that is not a `warning` finding and not a clean pass — it is reported as its own distinct outcome, with a non-`0`/non-`1` exit code, so a scan that never ran cannot be mistaken for a scan that ran and found nothing.
 
 **changeset-coverage rollout:** ships report-only, same precedent as the report-only rows above — the check's own exit code always stays `0`, so registering it cannot newly redden any existing install. Graduating to blocking, and the waiver-label escape that graduation would need, are both deliberately deferred to a later, separately-dispatched task once the check's own false-positive rate is observed in practice; v1 carries no self-serve or principal-applied escape at all.
 

package/aeg-root/roles/archivist.md

@@ -93,7 +93,7 @@ Work through this checklist for the merged task. Confirm each against reality
 2. **Docs updated.** The tier-required docs the brief listed actually moved. (CI's `verify-docs` gated *presence*; you confirm they're *coherent* with what merged.)
 3. **Non-derivable facts recorded as Issues — never as a state document.** The per-project state layer (`state.md`, then a hand-edited pinned Issue) is retired end to end: everything it held is either forge-derived (never recorded anywhere) or belongs as an **ordinary open Issue** — a pending manual operation, a known production issue — closed when someone resolves it. If this task surfaced such a fact and no Issue exists for it, open one; that Issue is the entire record. (`now.md` no longer exists either.)
 4. **`docs-index.md`** updated if files were added, removed, or renamed.
-5. **Token ledger rows recorded.** No role appends its own row on a task branch. **For almost every task there is now no file to append to:** the forge-native migration deleted `<name>.tokens.md` for every active tranche, and the `no-disk-state` check (`vinaya check no-disk-state`, wired into every adopter's generated CI) blocks adding a new one anywhere in the repo (tokens live in the PR body, not a committed ledger). Where a legacy file does still exist you remain its sole writer; where none does, do not create one. Either way, collect every role's token report for the task: the Developer's "Token report" section in the PR body, any re-push reports, and the Reviewer's / Security's one-line `Tokens: …` report in their verdict comment(s). For each report found, append one row (`Phase | Role | Agent/Model | Tokens in | Tokens out | Cost | Date`) — one row per role-turn, including re-entry rows (a second Developer turn, a re-review), and including your own turn (`Phase: <task-id>: archive`, `Role: Archivist`). Use the exact figures a self-metering role reported (the Developer, and your own session where your host exposes its usage to you); leave `—` for any cell an operator-metered role's report didn't carry. If a role's report is missing entirely (e.g. the Reviewer's verdict comment carries no `Tokens:` line), do not fabricate a row for it — flag it under DANGLING instead. **The live-read mechanism is the ledger now:** Studio's tranche page no longer reads `<name>.tokens.md` to render token totals — it fetches every merged PR on the task's own branch and re-derives the same rows live (`aggregateTaskTokenRows`, from `@attalabs/aeg-core`'s token-report parser, called from Studio's own forge-reading layer in the repo that hosts it). Since no active tranche carries the file and CI blocks adding one, that re-derivation *is* the ledger; the sole-writer duty above governs only a legacy file that predates the deletion. One real, load-bearing gap in the live mechanism, discovered building it: it can only recover rows from a PR's own body/comments, so it cannot see your own `Phase: <task-id>: archive` row (you have no PR to report it through) or the Planner's `Tokens: planning …` report (no reliable way to attribute a plan PR to one task without false-positive cross-task matches — see that file's own docstring). Those two sources therefore have **no durable home today** — that is a known, open gap, not a licence to create a `.tokens.md` for them.
+5. **Token ledger rows recorded.** No role appends its own row on a task branch. **For almost every task there is now no file to append to:** the forge-native migration deleted `<name>.tokens.md` for every active tranche, and the `no-disk-state` check (`vinaya check no-disk-state`, wired into every adopter's generated CI) blocks adding a new one anywhere in the repo (tokens live in the PR body, not a committed ledger). Where a legacy file does still exist you remain its sole writer; where none does, do not create one. Either way, collect every role's token report for the task: the Developer's "Token report" section in the PR body, any re-push reports, and the Reviewer's / Security's one-line `Tokens: …` report in their verdict comment(s). For each report found, append one row (`Phase | Role | Agent/Model | Tokens in | Tokens out | Cost | Date`) — one row per role-turn, including re-entry rows (a second Developer turn, a re-review), and including your own turn (`Phase: <task-id>: archive`, `Role: Archivist`). Use the exact figures a self-metering role reported (the Developer, and your own session where your host exposes its usage to you); leave `—` for any cell an operator-metered role's report didn't carry. If a role's report is missing entirely (e.g. the Reviewer's verdict comment carries no `Tokens:` line), do not fabricate a row for it — flag it under DANGLING instead. **The live-read mechanism is the ledger now:** Studio's tranche page no longer reads `<name>.tokens.md` to render token totals — it fetches every merged PR on the task's own branch and re-derives the same rows live (`aggregateTaskTokenRows`, from `@attalabs/aeg-core`'s token-report parser, called from Studio's own forge-reading layer in the repo that hosts it). Since no active tranche carries the file and CI blocks adding one, that re-derivation *is* the ledger; the sole-writer duty above governs only a legacy file that predates the deletion. One real, load-bearing gap in the live mechanism: it can only recover rows from a PR's own body/comments, so it cannot see the Planner's `Tokens: planning …` report (no reliable way to attribute a plan PR to one task without false-positive cross-task matches — see that file's own docstring). Your own `Phase: <task-id>: archive` row is not part of that gap: `vinaya archive` folds it into the same provenance comment it posts on the merged task PR, so the live mechanism recovers it the same way it recovers every other role's row on that PR. That leaves the Planner's tranche-wide report as the one source with **no durable home today** — a known, open gap, not a licence to create a `.tokens.md` for it.
 6. **Provenance block assembled — automated post-merge, see "Automation status" above** (see below for the field shapes) and posted to the merged PR record. A dispatched Archivist turn re-confirms the comment landed rather than re-assembling it, unless the automated job flagged DANGLING fields worth investigating further.
 
 ## The provenance block

package/aeg-root/roles/planner.md

@@ -294,4 +294,4 @@ AEG defines **task close-out** (the per-task Archivist) and **tranche close-out*
 
 ## Turn-end: report your tokens, don't append them
 
-You do not append your own row to `aeg-root/tranches/<name>.tokens.md` — self-append was retired for every role. When the planning session closes, report your tokens instead: `Tokens: planning — Planner — <model> — in/out/cost or — if unknown`, in the plan PR body if one exists, or in your planning report to the Principal otherwise. Planning normally runs **operator-metered** — on a host that exposes no usage figure to the agent — so report `—` for the numeric cells; that host capability is the one sanctioned reason for a blank token cell (`tranche-model.md` §12), never inconvenience, and you never estimate. If your host does expose your own usage to you, report the real figures instead. Re-planning a wave reports again, never edits the prior report. The ledger is append-only.
+You do not append your own row to `aeg-root/tranches/<name>.tokens.md` — self-append was retired for every role. When the planning session closes, report your tokens instead: `Tokens: planning — Planner — <model> — in/out/cost or — if unknown`, in the plan PR body when one exists; when it doesn't, in a comment on the pinned lessons Issue — the existing forge object, never a new file or forge object of your own (your new-file hard gate forbids that regardless). Planning is normally **self-metering**, the same as the Developer, on any host that exposes the session's own usage to the agent (a transcript it writes, a usage field on its responses, a meter it exposes) — collect the real figures through whatever mechanism your host offers and report them; a blank token cell is not the default outcome. **Operator-metered** — a host that exposes no usage figure to the agent at all — is the fallback case, not the norm: only then does `—` for the numeric cells become the sanctioned outcome (`tranche-model.md` §12), never inconvenience, and you never estimate. Re-planning a wave reports again, never edits the prior report. The ledger is append-only.

package/aeg-root/templates/pr-report-template.md

@@ -64,9 +64,11 @@ The block opens with `Head:` and a `Summary:` line — a file and line count der
 
 ## Token report
 
+<!-- AEG:TOKENS:START -->
 | Phase | Role | Agent/Model | Tokens in | Tokens out | Cost | Date |
 |---|---|---|---|---|---|---|
 | [task-id]: develop | Developer | [model] | [exact in] | [exact out] | [cost] | [YYYY-MM-DD] |
+<!-- AEG:TOKENS:END -->
 
 ## Reference — the dispatched brief
 

package/aeg-root/tranche-model.md

@@ -293,7 +293,7 @@ Token reporting is three separable things, and only one of them depends on the a
 2. **Collection — host-specific.** *How* a role obtains true figures for its own turn. This is the only layer an adapter belongs in, and the only layer that may name a host, a transcript format, or a script path.
 3. **The destination and the grammar — portable.** The `Tokens: …` line, in the artifact the role's turn already produced: the PR body's "Token report" section for a role that holds a branch, the verdict comment for a reviewing role, the plan PR or planning report for the Planner. The ledger stays append-only, and the Archivist transcribes what each role reported rather than re-deriving it.
 
-The destination was never the coupled part — no role writes a shared ledger file on a task branch, so layer 3 is satisfied through the forge for every task-branch role. Two sources remain the known open gap recorded in `roles/archivist.md`: the Archivist's own row, and the Planner's tranche-wide report. **An adopter implements layer 2 for their own harness and inherits layers 1 and 3 unchanged.** A doctrine sentence that names a tool belongs in layer 2 or nowhere.
+The destination was never the coupled part — no role writes a shared ledger file on a task branch, so layer 3 is satisfied through the forge for every task-branch role. One source remains the known open gap recorded in `roles/archivist.md`: the Planner's tranche-wide report — the Archivist's own row is not part of it (see the "Known gap" paragraph below). **An adopter implements layer 2 for their own harness and inherits layers 1 and 3 unchanged.** A doctrine sentence that names a tool belongs in layer 2 or nowhere.
 
 ### Two collection capabilities (the design constraint, not a bug)
 
@@ -308,7 +308,7 @@ The split is **operator vs. agent, not terminal vs. chat** — a figure a human
 
 Which capability applies is a fact about the **host**, not a fixed property of the role: the same role is self-metering on a harness that exposes usage and operator-metered on one that does not. Read the role names above as today's common case, not as an allocation.
 
-Self-metering capture is real, not estimated: the adapter sums the session's own usage records, so a Developer or automated Archivist turn's numbers are exact rather than approximated. Whether it also runs with *no* operator step depends on the host's wiring — where a Stop hook writes a transcript pointer — configured in the repo or in the operator's own host settings — the adapter finds it unaided; with no pointer written, the caller names the transcript with `--transcript <path>`. Either way the figures are read, never guessed. The remaining manual seam is operator-metered roles only — closing it depends on the host giving a session a way to read its own usage, which conversational surfaces generally do not today. **Known gap (flagged, not solved):** tranche-wide operator-metered turns with no task PR to report into — a Planner session outside a plan PR, a Brief Author session — have no established recording path; see `roles/planner.md` "Plan-PR close-out."
+Self-metering capture is real, not estimated: the adapter sums the session's own usage records, so a Developer or automated Archivist turn's numbers are exact rather than approximated. Whether it also runs with *no* operator step depends on the host's wiring — where a Stop hook writes a transcript pointer — configured in the repo or in the operator's own host settings — the adapter finds it unaided; with no pointer written, the caller names the transcript with `--transcript <path>`. Either way the figures are read, never guessed. The remaining manual seam is operator-metered roles only — closing it depends on the host giving a session a way to read its own usage, which conversational surfaces generally do not today. **Known gap — now partly closed:** tranche-wide operator-metered turns with no task PR to report into no longer lack a destination across the board. A Planner session outside a plan PR now reports into a comment on the pinned lessons Issue — the existing forge object, never a new one (`roles/planner.md` "Turn-end: report your tokens, don't append them"). A Brief Author session already has a destination when a plan PR exists — the same plan PR the Planner reports into (`roles/brief-author.md`) — unchanged by this fix. The Archivist's own `<task-id>: archive` row was never actually homeless either: `vinaya archive` folds the Archivist's `Tokens: …` line into the same provenance comment it posts on the merged task PR (`roles/archivist.md` "The provenance block") — a different fact from the narrower Studio live-read caveat that same file still carries, which is about re-deriving ledger totals from a PR's own body/comments, not about where the row is written. What remains genuinely open: a Brief Author session that ends with no PR of any kind yet to write into — mid-authoring, before a plan PR exists — still has nowhere durable to report; it falls back to an ephemeral report to the Principal, and that fallback is not fixed here.
 
 ### The collection adapter AEG ships (one layer-2 instance, not the requirement)
 
@@ -322,7 +322,7 @@ AEG ships exactly one collection adapter, for the Claude Code host, exposed as `
 
 Vinaya Studio's tranche page no longer reads `<name>.tokens.md` off disk to render token totals — it re-derives the same row shape live off the forge: every MERGED PR on a task's own branch (`task/<tranche>/<id>`), parsing the Developer's "Token report" entries from the PR body (every one, including re-push entries) and the Reviewer's/Security's `Tokens: …` lines from that PR's comments (`@attalabs/aeg-core`'s token-report parser, `aggregateTaskTokenRows`, fetched by Studio's own forge-reading layer in the repo that hosts it). Same row shape, same `sumLedger` totals math (`parse-ledger.ts`) — different source.
 
-This is deliberately **narrower** than what the Archivist collects into the file: it cannot recover the Archivist's own `<task-id>: archive` row (no PR carries it — the file itself is that row's only record) or the Planner's `Tokens: planning …` report (no reliable way to attribute a plan PR to one task from the forge alone without false-positive cross-task matches, confirmed live during 4b's build — a task Issue's cross-reference timeline picks up ANY PR that merely mentions its number in passing prose, not just its own plan PR). Both remain recoverable only from `.tokens.md`, which is why the file is not deleted here (task 7's job, once the live mechanism is proven in wider use). A task's report that's missing or malformed (e.g. a "Token report" heading with no table and no parseable text after it) yields no row for that report, never a fabricated one — same discipline as the Archivist's own DANGLING convention.
+This is deliberately **narrower** than what the Archivist collects into the file: it cannot recover the Planner's `Tokens: planning …` report (no reliable way to attribute a plan PR to one task from the forge alone without false-positive cross-task matches, confirmed live during 4b's build — a task Issue's cross-reference timeline picks up ANY PR that merely mentions its number in passing prose, not just its own plan PR). The Archivist's own `<task-id>: archive` row is not part of that gap: `vinaya archive` posts it inside the same provenance comment it posts on the merged task PR, so this mechanism recovers it exactly as it recovers every other role's row on that PR. The Planner's report remains recoverable only from `.tokens.md`, which is why the file is not deleted here (task 7's job, once the live mechanism is proven in wider use). A task's report that's missing or malformed (e.g. a "Token report" heading with no table and no parseable text after it) yields no row for that report, never a fabricated one — same discipline as the Archivist's own DANGLING convention.
 
 ### Anti-regression
 

package/dist/checks/bin/check-body-bare-digits.js

@@ -1791,6 +1791,99 @@ var DERIVED_STATUSES = [
   "incoherent"
 ];
 var DERIVABLE_STATUSES = DERIVED_STATUSES.filter((s) => s !== "backlog");
+// ../../packages/aeg-core/src/parse-ledger.ts
+function rowFromCells(cells) {
+  if (cells.length < 7)
+    return null;
+  const phase = (cells[0] ?? "").trim();
+  if (!phase)
+    return null;
+  return {
+    phase,
+    role: (cells[1] ?? "").trim(),
+    agentModel: (cells[2] ?? "").trim(),
+    tokensIn: parseIntCell(cells[3] ?? ""),
+    tokensOut: parseIntCell(cells[4] ?? ""),
+    cost: parseCostCell(cells[5] ?? ""),
+    date: (cells[6] ?? "").trim()
+  };
+}
+function parseIntCell(cell) {
+  const trimmed = cell.replace(/`/g, "").trim();
+  if (!trimmed || isEmDashOrDash(trimmed))
+    return null;
+  const normalized = trimmed.replace(/[,_\s]/g, "");
+  if (!/^-?\d+$/.test(normalized))
+    return null;
+  return Number(normalized);
+}
+function parseCostCell(cell) {
+  const trimmed = cell.replace(/`/g, "").trim();
+  if (!trimmed || isEmDashOrDash(trimmed))
+    return null;
+  const normalized = trimmed.replace(/^\$/, "").replace(/[,_\s]/g, "");
+  if (!/^-?\d+(\.\d+)?$/.test(normalized))
+    return null;
+  return Number(normalized);
+}
+function isEmDashOrDash(s) {
+  const t = s.trim();
+  return t === "—" || t === "-" || t === "–";
+}
+// ../../packages/aeg-core/src/parse-token-report.ts
+var TOKEN_REPORT_HEADING = /^\s*(?:#{1,6}\s*Token report\s*|\*\*Token report\*\*)\s*$/i;
+var INLINE_FIELD_LIST = /Phase:\s*([^|]+?)\s*\|\s*Role:\s*([^|]+?)\s*\|\s*Agent\/Model:\s*([^|]+?)\s*\|\s*Tokens in:\s*([^|]+?)\s*\|\s*Tokens out:\s*([^|]+?)\s*\|\s*Cost:\s*([^|]+?)\s*\|\s*Date:\s*(.+?)\s*$/im;
+function parseTokenReportEntries(body) {
+  const lines = body.split(/\r?\n/);
+  const headingIdxs = [];
+  lines.forEach((line, i) => {
+    if (TOKEN_REPORT_HEADING.test(line))
+      headingIdxs.push(i);
+  });
+  const out = [];
+  for (let h = 0;h < headingIdxs.length; h++) {
+    const start = headingIdxs[h] + 1;
+    const end = h + 1 < headingIdxs.length ? headingIdxs[h + 1] : lines.length;
+    const section = lines.slice(start, end).join(`
+`);
+    const tableRows = parseTableSection(section);
+    if (tableRows.length > 0) {
+      out.push(...tableRows);
+      continue;
+    }
+    const inlineRow = parseInlineFieldList(section);
+    if (inlineRow)
+      out.push(inlineRow);
+  }
+  return out;
+}
+function parseTableSection(section) {
+  const lines = section.split(/\r?\n/);
+  let i = 0;
+  for (;i < lines.length; i++) {
+    if ((lines[i] ?? "").trim().startsWith("|"))
+      break;
+  }
+  if (i + 1 >= lines.length)
+    return [];
+  i += 2;
+  const out = [];
+  for (;i < lines.length; i++) {
+    const trimmed = (lines[i] ?? "").trim();
+    if (!trimmed.startsWith("|"))
+      break;
+    const row = rowFromCells(splitTableRow(trimmed));
+    if (row)
+      out.push(row);
+  }
+  return out;
+}
+function parseInlineFieldList(section) {
+  const m = section.match(INLINE_FIELD_LIST);
+  if (!m)
+    return null;
+  return rowFromCells([m[1], m[2], m[3], m[4], m[5], m[6], m[7]]);
+}
 // ../../packages/aeg-core/src/report-tokens.ts
 var DASH_LOOKALIKES = {
   "-": "‑",
@@ -1799,6 +1892,7 @@ var DASH_LOOKALIKES = {
 };
 var DASH_CHARS = new Set(Object.keys(DASH_LOOKALIKES));
 // ../../packages/aeg-core/src/claude-code-transcript.ts
+import { createHash } from "node:crypto";
 function summarizeTranscript(jsonl) {
   const seen = new Set;
   const components = {
@@ -1847,7 +1941,14 @@ function numberOr(value, fallback) {
 function sanitizeKey(value) {
   return value.replace(/[^A-Za-z0-9]+/g, "-");
 }
+function collisionResistantKey(value) {
+  const digest = createHash("sha256").update(value).digest("hex");
+  return `${sanitizeKey(value)}-${digest}`;
+}
 function transcriptPointerPath(projectDir, tmpDir) {
+  return `${tmpDir}/claude-transcript-${collisionResistantKey(projectDir)}.txt`;
+}
+function legacyTranscriptPointerPath(projectDir, tmpDir) {
   return `${tmpDir}/claude-transcript-${sanitizeKey(projectDir)}.txt`;
 }
 function resolvePointer(explicitTranscriptPath, deps) {
@@ -1855,13 +1956,15 @@ function resolvePointer(explicitTranscriptPath, deps) {
     return { path: explicitTranscriptPath, corroborated: true };
   const projectDir = deps.env.CLAUDE_PROJECT_DIR ?? deps.cwd;
   const tmpDir = deps.env.TMPDIR ?? "/tmp";
-  const pointerPath = transcriptPointerPath(projectDir, tmpDir);
+  const primaryPointerPath = transcriptPointerPath(projectDir, tmpDir);
+  const legacyPointerPath = legacyTranscriptPointerPath(projectDir, tmpDir);
   const currentSessionId = deps.env.CLAUDE_CODE_SESSION_ID;
-  if (!deps.exists(pointerPath)) {
+  const pointerPath = deps.exists(primaryPointerPath) ? primaryPointerPath : deps.exists(legacyPointerPath) ? legacyPointerPath : undefined;
+  if (!pointerPath) {
     return {
       pointerExisted: false,
       corroborated: false,
-      error: `No transcript pointer at ${pointerPath} and no --transcript given. ` + "Either this repo installs no track-transcript.sh Stop hook (lacking one is not a defect — " + "name the transcript directly instead), or no session has completed a turn yet."
+      error: `No transcript pointer at ${primaryPointerPath} (nor its pre-migration name ${legacyPointerPath}) ` + "and no --transcript given. Either this repo installs no track-transcript.sh Stop hook (lacking one " + "is not a defect — name the transcript directly instead), or no session has completed a turn yet."
     };
   }
   let contents;
@@ -1936,6 +2039,9 @@ function isTokenCollectionWiringBroken(capability) {
     return false;
   return capability.reason !== "no-transcript-resolved";
 }
+// ../../packages/aeg-core/src/metering-io-guard.ts
+import { closeSync, constants as fsConstants, fstatSync, openSync, readFileSync } from "node:fs";
+var GUARD_OPEN_FLAGS = fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW;
 // ../../packages/aeg-core/src/file-classify.ts
 function isCodeFile(p) {
   if (p.endsWith(".md"))
@@ -2142,7 +2248,7 @@ function overrideActive(opts) {
   return false;
 }
 // ../../packages/aeg-core/src/premise-check.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var ASSERTION_KINDS = new Set(["contains", "absent", "sha256"]);
 function isPremiseHeader(line) {
   const stripped = line.replace(/[*#]/g, "").trim();
@@ -2187,7 +2293,7 @@ function checkPremises(assertions, fileReader) {
     } else if (a.kind === "absent" && content.includes(a.value)) {
       failures.push(`premise-check: ${a.path} now contains "${a.value}", but the brief pinned it absent — the premise has moved; re-dig before proceeding.`);
     } else if (a.kind === "sha256") {
-      const actual = createHash("sha256").update(content).digest("hex");
+      const actual = createHash2("sha256").update(content).digest("hex");
       if (actual !== a.value.toLowerCase()) {
         failures.push(`premise-check: ${a.path} sha256 mismatch (brief pinned ${a.value}, file is now ${actual}) — the file changed since this brief was authored; re-dig before proceeding.`);
       }
@@ -3915,7 +4021,7 @@ function findWorkspaceEscapes(files, knownPaths, workspaceDirs = DEFAULT_WORKSPA
 }
 // src/lib/config.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
@@ -4208,7 +4314,7 @@ function loadConfig() {
   if (!path)
     return null;
   try {
-    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    const raw = JSON.parse(readFileSync2(path, "utf-8"));
     return stripGlobalOnlyKeys(VinayaConfigSchema.parse(raw), path);
   } catch {
     return null;
@@ -4410,8 +4516,8 @@ function blankTokenReportSection(body) {
   const lines = body.split(`
 `);
   const HEADING2 = /^#{1,6}\s/;
-  const TOKEN_REPORT_HEADING = /^#{1,6}\s*token report\s*$/i;
-  const startIdx = lines.findIndex((l) => TOKEN_REPORT_HEADING.test(l));
+  const TOKEN_REPORT_HEADING2 = /^#{1,6}\s*token report\s*$/i;
+  const startIdx = lines.findIndex((l) => TOKEN_REPORT_HEADING2.test(l));
   if (startIdx === -1)
     return body;
   let endIdx = lines.length;

package/dist/checks/bin/check-branch-topology.js

@@ -1791,6 +1791,99 @@ var DERIVED_STATUSES = [
   "incoherent"
 ];
 var DERIVABLE_STATUSES = DERIVED_STATUSES.filter((s) => s !== "backlog");
+// ../../packages/aeg-core/src/parse-ledger.ts
+function rowFromCells(cells) {
+  if (cells.length < 7)
+    return null;
+  const phase = (cells[0] ?? "").trim();
+  if (!phase)
+    return null;
+  return {
+    phase,
+    role: (cells[1] ?? "").trim(),
+    agentModel: (cells[2] ?? "").trim(),
+    tokensIn: parseIntCell(cells[3] ?? ""),
+    tokensOut: parseIntCell(cells[4] ?? ""),
+    cost: parseCostCell(cells[5] ?? ""),
+    date: (cells[6] ?? "").trim()
+  };
+}
+function parseIntCell(cell) {
+  const trimmed = cell.replace(/`/g, "").trim();
+  if (!trimmed || isEmDashOrDash(trimmed))
+    return null;
+  const normalized = trimmed.replace(/[,_\s]/g, "");
+  if (!/^-?\d+$/.test(normalized))
+    return null;
+  return Number(normalized);
+}
+function parseCostCell(cell) {
+  const trimmed = cell.replace(/`/g, "").trim();
+  if (!trimmed || isEmDashOrDash(trimmed))
+    return null;
+  const normalized = trimmed.replace(/^\$/, "").replace(/[,_\s]/g, "");
+  if (!/^-?\d+(\.\d+)?$/.test(normalized))
+    return null;
+  return Number(normalized);
+}
+function isEmDashOrDash(s) {
+  const t = s.trim();
+  return t === "—" || t === "-" || t === "–";
+}
+// ../../packages/aeg-core/src/parse-token-report.ts
+var TOKEN_REPORT_HEADING = /^\s*(?:#{1,6}\s*Token report\s*|\*\*Token report\*\*)\s*$/i;
+var INLINE_FIELD_LIST = /Phase:\s*([^|]+?)\s*\|\s*Role:\s*([^|]+?)\s*\|\s*Agent\/Model:\s*([^|]+?)\s*\|\s*Tokens in:\s*([^|]+?)\s*\|\s*Tokens out:\s*([^|]+?)\s*\|\s*Cost:\s*([^|]+?)\s*\|\s*Date:\s*(.+?)\s*$/im;
+function parseTokenReportEntries(body) {
+  const lines = body.split(/\r?\n/);
+  const headingIdxs = [];
+  lines.forEach((line, i) => {
+    if (TOKEN_REPORT_HEADING.test(line))
+      headingIdxs.push(i);
+  });
+  const out = [];
+  for (let h = 0;h < headingIdxs.length; h++) {
+    const start = headingIdxs[h] + 1;
+    const end = h + 1 < headingIdxs.length ? headingIdxs[h + 1] : lines.length;
+    const section = lines.slice(start, end).join(`
+`);
+    const tableRows = parseTableSection(section);
+    if (tableRows.length > 0) {
+      out.push(...tableRows);
+      continue;
+    }
+    const inlineRow = parseInlineFieldList(section);
+    if (inlineRow)
+      out.push(inlineRow);
+  }
+  return out;
+}
+function parseTableSection(section) {
+  const lines = section.split(/\r?\n/);
+  let i = 0;
+  for (;i < lines.length; i++) {
+    if ((lines[i] ?? "").trim().startsWith("|"))
+      break;
+  }
+  if (i + 1 >= lines.length)
+    return [];
+  i += 2;
+  const out = [];
+  for (;i < lines.length; i++) {
+    const trimmed = (lines[i] ?? "").trim();
+    if (!trimmed.startsWith("|"))
+      break;
+    const row = rowFromCells(splitTableRow(trimmed));
+    if (row)
+      out.push(row);
+  }
+  return out;
+}
+function parseInlineFieldList(section) {
+  const m = section.match(INLINE_FIELD_LIST);
+  if (!m)
+    return null;
+  return rowFromCells([m[1], m[2], m[3], m[4], m[5], m[6], m[7]]);
+}
 // ../../packages/aeg-core/src/report-tokens.ts
 var DASH_LOOKALIKES = {
   "-": "‑",
@@ -1799,6 +1892,7 @@ var DASH_LOOKALIKES = {
 };
 var DASH_CHARS = new Set(Object.keys(DASH_LOOKALIKES));
 // ../../packages/aeg-core/src/claude-code-transcript.ts
+import { createHash } from "node:crypto";
 function summarizeTranscript(jsonl) {
   const seen = new Set;
   const components = {
@@ -1847,7 +1941,14 @@ function numberOr(value, fallback) {
 function sanitizeKey(value) {
   return value.replace(/[^A-Za-z0-9]+/g, "-");
 }
+function collisionResistantKey(value) {
+  const digest = createHash("sha256").update(value).digest("hex");
+  return `${sanitizeKey(value)}-${digest}`;
+}
 function transcriptPointerPath(projectDir, tmpDir) {
+  return `${tmpDir}/claude-transcript-${collisionResistantKey(projectDir)}.txt`;
+}
+function legacyTranscriptPointerPath(projectDir, tmpDir) {
   return `${tmpDir}/claude-transcript-${sanitizeKey(projectDir)}.txt`;
 }
 function resolvePointer(explicitTranscriptPath, deps) {
@@ -1855,13 +1956,15 @@ function resolvePointer(explicitTranscriptPath, deps) {
     return { path: explicitTranscriptPath, corroborated: true };
   const projectDir = deps.env.CLAUDE_PROJECT_DIR ?? deps.cwd;
   const tmpDir = deps.env.TMPDIR ?? "/tmp";
-  const pointerPath = transcriptPointerPath(projectDir, tmpDir);
+  const primaryPointerPath = transcriptPointerPath(projectDir, tmpDir);
+  const legacyPointerPath = legacyTranscriptPointerPath(projectDir, tmpDir);
   const currentSessionId = deps.env.CLAUDE_CODE_SESSION_ID;
-  if (!deps.exists(pointerPath)) {
+  const pointerPath = deps.exists(primaryPointerPath) ? primaryPointerPath : deps.exists(legacyPointerPath) ? legacyPointerPath : undefined;
+  if (!pointerPath) {
     return {
       pointerExisted: false,
       corroborated: false,
-      error: `No transcript pointer at ${pointerPath} and no --transcript given. ` + "Either this repo installs no track-transcript.sh Stop hook (lacking one is not a defect — " + "name the transcript directly instead), or no session has completed a turn yet."
+      error: `No transcript pointer at ${primaryPointerPath} (nor its pre-migration name ${legacyPointerPath}) ` + "and no --transcript given. Either this repo installs no track-transcript.sh Stop hook (lacking one " + "is not a defect — name the transcript directly instead), or no session has completed a turn yet."
     };
   }
   let contents;
@@ -1936,6 +2039,9 @@ function isTokenCollectionWiringBroken(capability) {
     return false;
   return capability.reason !== "no-transcript-resolved";
 }
+// ../../packages/aeg-core/src/metering-io-guard.ts
+import { closeSync, constants as fsConstants, fstatSync, openSync, readFileSync } from "node:fs";
+var GUARD_OPEN_FLAGS = fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW;
 // ../../packages/aeg-core/src/file-classify.ts
 function isCodeFile(p) {
   if (p.endsWith(".md"))
@@ -2142,7 +2248,7 @@ function overrideActive(opts) {
   return false;
 }
 // ../../packages/aeg-core/src/premise-check.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var ASSERTION_KINDS = new Set(["contains", "absent", "sha256"]);
 function isPremiseHeader(line) {
   const stripped = line.replace(/[*#]/g, "").trim();
@@ -2187,7 +2293,7 @@ function checkPremises(assertions, fileReader) {
     } else if (a.kind === "absent" && content.includes(a.value)) {
       failures.push(`premise-check: ${a.path} now contains "${a.value}", but the brief pinned it absent — the premise has moved; re-dig before proceeding.`);
     } else if (a.kind === "sha256") {
-      const actual = createHash("sha256").update(content).digest("hex");
+      const actual = createHash2("sha256").update(content).digest("hex");
       if (actual !== a.value.toLowerCase()) {
         failures.push(`premise-check: ${a.path} sha256 mismatch (brief pinned ${a.value}, file is now ${actual}) — the file changed since this brief was authored; re-dig before proceeding.`);
       }