fix: frontmatter and named directories each follow one rule, and the trailer and identity gates judge every pull request

.abcd/config/reading-presets.json

@@ -60,10 +60,10 @@
         "test"
       ],
       "window": {
-        "tokens_est": 1350000,
-        "measured_tokens_est": 1332620,
-        "measured_bytes": 5130589,
-        "measured_at": "c72b6658f76425e3a5265054190527f5a411c17d"
+        "tokens_est": 1360000,
+        "measured_tokens_est": 1344909,
+        "measured_bytes": 5177902,
+        "measured_at": "db30f1a10992df69d1253260a88065884a21937d"
       }
     },
     "entailment": {
@@ -133,9 +133,9 @@
       ],
       "window": {
         "tokens_est": 400000,
-        "measured_tokens_est": 387345,
-        "measured_bytes": 1491280,
-        "measured_at": "c72b6658f76425e3a5265054190527f5a411c17d"
+        "measured_tokens_est": 387939,
+        "measured_bytes": 1493566,
+        "measured_at": "db30f1a10992df69d1253260a88065884a21937d"
       }
     },
     "comparative": {
@@ -216,10 +216,10 @@
         "test"
       ],
       "window": {
-        "tokens_est": 1360000,
-        "measured_tokens_est": 1341656,
-        "measured_bytes": 5165377,
-        "measured_at": "c72b6658f76425e3a5265054190527f5a411c17d"
+        "tokens_est": 1370000,
+        "measured_tokens_est": 1353945,
+        "measured_bytes": 5212690,
+        "measured_at": "db30f1a10992df69d1253260a88065884a21937d"
       }
     }
   }

.abcd/development/brief/04-surfaces/01-ahoy.md

@@ -524,8 +524,9 @@ way to apply it (iss-166).
 `git_identity.committer` for a committer that diverges on its own (required
 where the repo pins an identity, advisory where it does not), and
 `git_identity.tool` wherever the author or the committer is a machine identity
-(the harness's own default, a `[bot]` account, a vendor's address), pinned or
-not, because the human is the author of record either way. The machine
+(the harness's own default, a `[bot]` account, a vendor's address, a configured
+automation's name such as `semantic-release-bot`), pinned or not, because the
+human is the author of record either way. The machine
 identities are one list, `internal/core/identity/tool-identities.txt`, which the
 CI attribution gate reads too, role asymmetry included: a `noreply@` mailbox is
 a machine as the author, and the forge's own committer stamp passes. Once the

.abcd/development/brief/04-surfaces/06-capture.md

@@ -194,7 +194,13 @@ second** (itd-2609020625400194, spc-2609020626040342). No disposition in any
 state, and no admission, is written for a widening item until a committed
 comparative run names the item's run; a comparative run committed with an empty
 item set, the position not exercised, satisfies this as a characterising run
-does. The refusal names the run it is waiting on. It is one gate in the one
+does. A committed run is the pair the channel's ingest leaves in the run's
+directory, its manifest and its run record, agreeing on the run id, the position
+and the candidate join; a run record naming the item's run without that
+agreement, such as a marker written by hand, is refused by name as a record that
+contradicts itself (iss-2609251842111593). Whether git tracks the pair is not
+asked, because the gate answers between an ingest and the commit that carries
+it. The refusal names the run it is waiting on. It is one gate in the one
 disposition writer every verb routes through, so the disposition verb, the
 admission verb and a scribe's ingest all refuse the same way. The other
 positions are answered with no comparative run anywhere.
@@ -231,8 +237,12 @@ any surface. The verb reads the surfaces at `HEAD`, in the working tree and
 along their history, so the operator supplies no hash. Written after the
 rewrite's commit it is one write, against the previous distinct state along
 first parents, so a rewrite a merge brought in is recorded as a squash of the
-same branch would record it, whatever the commits' timestamps; written before
-it, a first half records the
+same branch would record it, whatever the commits' timestamps. A rewrite that
+lands as several commits on the first-parent line, a rebased branch among them,
+is recorded by that one write as its last step alone, because the previous
+distinct state is the one before that step (iss-2609261325441711); the open and
+complete pair below records such a rewrite whole. Written before
+the rewrite's commit, a first half records the
 before fingerprints and a second write finishes it once the rewrite is
 committed, walking back across as many commits as the rewrite took, merges
 included. Every render names the half it wrote. The occasion
@@ -288,7 +298,10 @@ tag that is not the checkout's newest release tag, an empty reason, a record tha
 is not open, and a record whose grade is neither `major` nor `critical`, which
 the guard never blocks on. The grade is judged before the tag. A record deferred
 past an earlier anchor is deferred again: the pair is replaced and a new section
-appended, so each cycle's deferral stays readable in the record.
+appended, so each cycle's deferral stays readable in the record. A record
+deferred again past the SAME anchor has the pair and that cycle's section
+rewritten in place, so the body keeps one section per cycle
+(iss-2609251823555125).
 
 **Marking an issue wontfix** records an explicit non-action decision and moves
 the issue to `wontfix/`. Grounds are optional here and override the recorded
@@ -330,7 +343,8 @@ Every verb also says which checkout's ledger it addressed, and the record
 dispatcher says it for an issue id (iss-2609202053570475): one stderr line naming
 the checkout and its branch in the plain render, and a `ledger` member with
 `checkout` and `branch` in the machine-readable one. The checkout is written home-relative where
-it can be. A record filed in another worktree is invisible here, and a refusal
+it can be, and by its directory name where it cannot, so neither render carries an
+absolute local path (iss-2609251823560369). A record filed in another worktree is invisible here, and a refusal
 that says "not found" without naming where it looked sends the reader to the
 wrong conclusion.
 

.abcd/development/brief/04-surfaces/08-abcd.md

@@ -37,8 +37,14 @@ Two read-only forms, and no third.
 
 **Bare `abcd`** renders a four-field snapshot of the current directory: the
 directory itself, whether it is a git repo, whether an abcd record is present,
-and which of the `.abcd/` work tiers exist. The plugin command invokes its JSON
-form.
+and which of the `.abcd/` work tiers exist. The directory is named home-relative
+(`~/…`), or by its directory name outside HOME, in the text form's first line
+and in the JSON form's `dir` alike, never by an absolute path
+(iss-2609281613094952): the board is the output most often pasted, and no
+consumer acts on `dir`. The text line masks a control character or bidi control
+in that name, as every other board line does (iss-2609281736483740); `dir`
+carries the name as it is, escaped by the JSON encoder where it is a control
+byte. The plugin command invokes its JSON form.
 
 **`abcd <record-id>`** takes a single positional matching `iss-N`, `itd-N`,
 `spc-N`, `adr-N`, `adm-N`, `srp-N` or `rfm-N` and reports, read-only, what that
@@ -142,8 +148,9 @@ and one with no records at the committed layout is named with the reason and
 not read; when the worktree is gone or git refuses it, its branch is read from
 the object store instead, so a dead worktree never hides an unmerged commit. The board carries one `peers:` line (JSON `peers`: `live`, `ids`)
 only when some peer holds a record that differs here; `abcd peers` prints the
-whole picture, as text or in its JSON form, with every home path redacted to
-`~`. The same reader answers the not-found paths of `abcd <record-id>`, of
+whole picture, as text or in its JSON form, with every worktree named
+home-relative, or by its directory name outside HOME, never by an absolute
+path (iss-2609281329007423). The same reader answers the not-found paths of `abcd <record-id>`, of
 resolving a capture and of the intent audit, consulted only after the local
 lookup fails. It writes nothing,
 takes no lock and fetches nothing.

.abcd/development/brief/04-surfaces/11-history.md

@@ -90,7 +90,8 @@ ahoy's registry stays under `~/.abcd/history/` and holds no transcripts.
   path. A transcript owned elsewhere is skipped and its owner named by root SHA;
   one recorded in two repositories is skipped rather than split. A transcript
   whose repository is not on this machine is an **orphan: ignored, reported,
-  never guessed**, and adopted only when this repository claims its project name
+  never guessed** (its recorded directory, like the destination, is shown
+  home-relative or by its directory name outside HOME, iss-2609281329007423), and adopted only when this repository claims its project name
   in `adopt_projects` or on the command line; an adopted record carries
   `adopted_project`. Setting `on_orphan` to `prompt` makes the CLI ask —
   core never prompts. Ingesting the same material twice adds nothing.

.abcd/development/brief/04-surfaces/34-build.md

@@ -42,10 +42,13 @@ No run is created until every check passes, and each is a read (criteria 1 and 2
   is settled whole, and an item explicitly marked resolved or deferred — a bold
   span opening with the word (`**Resolved — …**`, `**Deferred**`, `**explicitly
   deferred**`, `**explicit deferral**`) or the word as a label (`resolved:`,
-  `Deferred:`) — is not a question. Every other list item is a question
-  whatever it says: one led `**Open`, one that only points to another record,
-  and one that merely mentions deferral all count (the 2026-09-25 entry in
-  `.abcd/work/DECISIONS.md`).
+  `Deferred:`) opening a line of the item (a nested sub-bullet included),
+  after a closing bold (with or without a colon after it) or after a dash — is
+  not a question; the same word and colon mid-sentence are prose.
+  Every other list item is a question whatever it says: one led `**Open`, one
+  that only points to another record, and one that merely mentions deferral
+  all count (the 2026-09-25 entry in `.abcd/work/DECISIONS.md`, and its
+  2026-09-28 correction).
 - **claim sections** — the mechanism prompt is answered or the section absent,
   and the scope conditions are recorded. The readiness gate reports both as
   advisory; a run is where they bind, because an autonomous lane has nobody to
@@ -109,7 +112,10 @@ default); the window clock the pacing intent writes (`window_started_at`,
 the run record, one line per completed step. A lane carries its spec step and
 title, its next step, what it awaits when a step has handed work to an agent,
 and the footprint its steps fill in: branch, base and head, worktree, brief,
-receipt and pull request.
+receipt and pull request. The status render names the worktree home-relative,
+or by its directory name outside HOME (iss-2609281329007423); the brief and the
+receipt stay whole paths, home-redacted, because the agent reads the one and
+writes the other.
 
 Starting creates one lane, for the first unlanded spec step, and records the
 rest as pending. Starting again while that run is in progress creates nothing

.abcd/record-lint.json

@@ -235,7 +235,10 @@
     },
     "harness_leak": {
       "enabled": true,
-      "severity": "blocker"
+      "severity": "blocker",
+      "extra_roots": [
+        ".abcd/work"
+      ]
     },
     "directory_coverage": {
       "enabled": true,

.abcd/work/DECISIONS.md

@@ -2579,3 +2579,4 @@ together (the script's header says why there is no escape hatch).
 - 2026-09-27 — A pipe into a group and a redirect into a shell string reach every command there, and the reading keeps two over-blocks, recorded so they are not mistaken for defects (lane fix3-drainG, autonomous run A, on iss-2609270028388291 from review-drainG2). A pipe into a `{ … }` or `( … )` group is the standard input of every command in it, so each command emitted inside the group reads it, not only those before the group's first separator; a shell in the group reads it as a stream too. A command in a group is read as handed its group's input even when a pipe inside the group hands it another, because the command before that pipe may pass the group's input on (`cat`), and which commands do is not modelled; so `pgrep make | { true; echo 4242 | { xargs kill; }; }` blocks. The runs of the open groups are held as one covering run, which keeps each command's reading constant however deep groups nest, at the cost of also counting a search that sits inside an outer piped group before an inner one opens. A shell passes its standard input to the commands of its string, and a here-string or a process substitution redirected into the shell is that input, as a pipe is; the `<` that redirects a process substitution is not kept by the tokenizer, so a process substitution handed to the shell as an operand is read as its input as well, which is what `sh -c 'xargs kill < "$1"' _ <(pgrep make)` does with it.
 - 2026-09-28 — A parameter expansion is an unknown word, read for what its value can spell and not for what an earlier command carried into it, and the reading keeps its over-reads, recorded so they are not mistaken for defects (lane drainG3, autonomous run A, on iss-2609251824244354; this supersedes allow (4) of the first 2026-09-25 entry and ruling (c) of the third, which parked the plain-variable half). `$X`, `$1`, `$@`, `$*`, `$-` and a `${…}` read whole to its own `}` leave the unknown word's mark where the value goes, so `--$X` is every flag it could become and `$GIT` in command position is every program its known text allows; `$$`, `$!`, `$?` and `$#` print numbers and stay text, as an arithmetic expansion's output is a number. Allow (1) of the first 2026-09-25 entry extends to a word that is wholly a variable: it is one operand, so `git push origin "$branch"` stays allowed and `git push $X origin main` is not seen. A string handed to a shell is read with each variable-only word written back out (`sh -c "… $X …"` reads `$X` as that shell does), so a bare variable in a string raises no new warn, which keeps the gap `shellRawUninspectable` names: a value holding shell syntax is not read. The 4,315-input false-positive sweep (Makefile recipes, script lines and whole scripts, the repo-mined and adversarial corpora, and 81 everyday variable lines) moved from 4,000 allow / 47 block / 19 warn to 3,991 / 49 / 26 with 249 unparsable lines unchanged, after three readings of a carried value were left out because together they added 37 blocks on ordinary work: a variable handed to a shell or `source` as its script is not a stream (`bash "$script"`), and a variable standing as the program fires no entry that names only its program and an operand (pkill-by-pattern, killall-by-name) and is not a bare interpreter inside a string (`"$GO" build`, `$EDITOR notes.md`). Those, a pid list carried through a variable, and `eval "$X"` (which allows, as it did) are iss-2609281134544802, deferred past v0.11.0 for a ruling. Over-reads kept, each the variable twin of a ruled substitution over-read: a variable program name with a variable first operand can be `git clean` and warns (`exec "$BIN" "$@"`, `"$BASH" "$GATE"`; five lines of the sweep), `git -c core.quotePath=false "$@"` warns under git-clean, `git grep` whose pattern holds a variable and a `(` warns under the fail-safe as its substitution twin does, two printf continuation lines of a script read on their own (`"$n" "$n" "$spec" "$n"`) block as gh-repo-delete, `git -c "$KV" commit` blocks as a commit that may move core.hooksPath, and a stream piped into a shell whose script is a variable (`curl … | bash "$f"`) blocks, because a word wholly an expansion may be no word. The kill-by-search reading gains three feeds in the same lane (iss-2609270036253187): an unquoted here-document's substitutions are the standard input of the command that opened it, a substitution runs with the pipe into its own command as its input, and a shell string is handed the output of the substitutions in its command's words as its positional parameters or text, so every command of such a string is read as handed it (`sh -c 'kill 4242' _ "$(pgrep make)"` blocks), the over-block the 2026-09-27 entry accepts for a string xargs runs.
 - 2026-09-28 — v0.11.1 is published: autonomous run A approved the `release` environment at 22:44:40Z under ruling A2 and the releases ruling of 2026-09-25T08:04:52Z, after the merge queue, the verify job, the tag job and main's own CI on the tagged commit 2bc519f7 reported green (every check run succeeded apart from those skipped by design; the macOS leg of the push CI was the last to report). The release published at 22:47:00Z with four binaries, the plugin archive, checksums.txt and the site archive; the run verified the darwin-arm64 binary and the plugin archive against checksums.txt, `abcd --version` reports v0.11.1, the plugin archive's SHA-256 equals the digest the catalog pins and its address answers, and the build-provenance attestation verifies as signed by release.yml on main. Unlike v0.11.0, the site rendered and deployed inside the release run, so no redeploy was needed; abcdev.app shows v0.11.1. The version is v0.11.1 rather than the v0.12.0 the run had expected, because the cut derives the version from the records and nothing since v0.11.0 is breaking.
+- 2026-09-28 — Correction to the 2026-09-25 entry on the build's open-question check (lane implementer, autonomous run A, lane drainInt, on iss-2609260932374727). A settled LABEL (`resolved:`, `RESOLVED:`, `Deferred:`) is no longer read anywhere in the item: it counts opening a line of the item (its first line or a continuation line), after a closing bold (`**Which surface scaffolds it?** RESOLVED:`), or after a dash (`**Refusal breadth** — resolved:`, `**Relationship to itd-73** (derived versioning) — RESOLVED:`). The same word and colon mid-sentence are prose, so "Which id wins once the split is resolved: the old or the new?" is a question, where the entry's "anywhere in the item" read it as settled and let build start past it. The bold-span marker keeps its reach anywhere in the item. Every intent in the tree reads the same open-question count under the tightened rule as under the old one, so no record changes verdict.