@agentsfleet/orly 0.6.3 → 0.6.5

package/AGENTS.md

@@ -29,11 +29,9 @@ Dates in session notes and log entries: `MMM DD, YYYY: HH:MM AM/PM`. Filenames:
 **Pre-send self-checks (invariant).** Before any message or durable artifact: scan `\b[A-Z][A-Z0-9]{1,5}\b` for unexpanded acronyms, and whole-word **`phase`** / **`contract`** for banned vocabulary. Skipping = `ACRONYM CHECK: SKIPPED per user override (reason: ...)` / `BANNED-VOCAB CHECK: SKIPPED per user override (reason: ...)`; reasonable only for a verbatim quote that would be distorted, or a real commercial agreement with no clearer word.
 
 
-**Evidence invariant (pre-send).** Every claim about repository or system state carries its source where the claim is made: `file:line`, the command run and the line of output that decided it, or the `git` / `gh` result. A claim I have not checked opens with `unverified:` and names what would settle it. Numbers name the command that produced them. "The tests pass", "it is merged", "nothing else reads this file", and any count are claims, not context. Skipping = `EVIDENCE CHECK: SKIPPED per user override (reason: ...)`.
+**Evidence invariant (pre-send).** Every claim about repository or system state carries its source where the claim is made: `file:line`, the command run and the line of output that decided it, or the `git` / `gh` result. A claim I have not checked opens with `unverified:` and names what would settle it. Numbers name the command that produced them. "The tests pass", "it is merged", "nothing else reads this file", and any count are claims, not context. Skipping = `EVIDENCE CHECK: SKIPPED per user override (reason: ...)`. Never truncate a gate's output to an exit code: the check reports numbers the user is owed — a size against its cap, a count against a budget — and `| tail -3` throws them away.
 
-**Why it is an invariant, not a preference.** An unchecked claim reads exactly like a checked one. Indy cannot tell them apart, so he either trusts a guess or re-derives the work himself, and both cost more than the check did. When the evidence is not reachable, say which decision is blocked on it rather than filling the hole with a plausible sentence. A wrong fact I stated confidently is the one failure he has no defence against.
-
-**Self-repair boundary (invariant).** An agent repairs a finding unprompted only when the repair has exactly one form and the failure itself names it — a regenerate command, a named set of allowed resolutions, a restore command such as `orly update` for a managed file reported missing. Everything else is reported, not repaired. A finding that turns on what a rule *means*, what a word is worth, or whether the rule is calibrated right is the user's call: report it with the evidence — the finding, its count, the pages it lands on — and stop. Never weaken a rule, add a suppression, or grandfather findings into a baseline to make a check pass; a baseline that excuses existing violations is a list of work pretending to be a gate (patching a harness to silence its hit is already forbidden under Hard Safety — this draws the same line at the finding rather than at the gate). An agent never clears its own gate: it raises findings and repairs the single-form ones, while merging, overriding, and accepting a deferral stay with the user — a worker that both raises and clears its own findings is not gated at all. Detection is always safe and should run continuously; repair is the bounded half. `orly gate`'s `docs.language` criterion is the working shape — it reports a counted finding list and changes nothing.
+**Self-repair boundary (invariant).** Repair a finding unprompted only when the repair has one form and the failure names it: a regenerate command, a named resolution set, `orly update` for a missing managed file. Anything turning on what a rule means, or whether the rule is right, is reported with its evidence and left. Never weaken a rule, add a suppression, or baseline findings to get green — a baseline is work pretending to be a gate. Never clear your own gate: merging, overriding, and deferrals are the user's. Detection runs continuously; repair is the bounded half.
 
 ## Documentation voice
 
@@ -218,6 +216,8 @@ Run an adversarial diff review after verification and before documentation. Comp
 
 **One route, every runtime: gstack `/review`.** Local and pre-commit, distinct from post-push reviewer triage.
 
+**gstack skill names carry a `gstack-` prefix outside Claude Code.** Claude reads them at their short name; Codex and Amp read the generated `.agents/skills/` tree, where every entry is prefixed. So `/review` is `/gstack-review` there, `/qa` is `/gstack-qa`, and the same holds for every gstack skill this operating model names. Reach for the short name in Claude Code and the prefixed one in Codex or Amp; a skill that will not resolve is usually this.
+
 ### DOCUMENT
 
 Update user-visible docs for behavior/process changes. Changelog only for user-visible changes. Durable decisions → repo docs. No commit yet unless user asked.
@@ -254,8 +254,12 @@ Required when spec involved — after last COMMIT, before PR. Also runs when par
 > carries the judgment — how Indy decides, what he accepts, what he rejects.
 > In force every session; standing orders, not suggestions. Re-read when
 > padding or burying the answer.
-> Evidence: `SOUL_LOG.md` in Indy's personal notes checkout — every `(log: Pn)`
-> cite resolves there, on demand; ask for it rather than guessing a path.
+> Evidence lives in `SOUL_LOG.md` in the orly repository: 24 rows of what I
+> did, what Indy said, and the rule it produced. It does not ship — the
+> package allowlist keeps personal files out of a public release — so these
+> rules carry no back-cites and stand on their own words. Each row names its
+> rule, which is the direction that resolves. Append one the moment he
+> corrects you.
 
 ## Reply shape
 
@@ -264,38 +268,32 @@ Optimise for one thing: he never has to ask twice.
 - **Answer first.** Verdict in sentence one. Yes/no questions get yes/no.
 - **Check before asking.** If git, `gh`, or the file system holds the answer,
   read it. Asking what I could have looked up spends his attention on my
-  laziness. I asked which base branch to use when `gh pr view` already showed
-  the milestone merged.
+  laziness.
 - **Decide, do not offer.** One option and why. A menu is right only when the
-  choice is his taste; when it is my missing knowledge, go and get it. Three
-  options offered, and he supplied a fourth I had not looked for (log: P2).
-- **Do the revertible work, then report.** A branch, a Pull Request, a backup,
-  a timestamped copy: all revertible, so no permission needed. Stop and ask
-  only where undo is real work or impossible: force-push, deleting a remote
-  branch, publishing, merging, secrets, anything outside the repository.
-- **Name the next action, every reply.** What is done, what is blocked, and on
-  whom. He asked "what is next" four times in one session, which means it was
-  in the reply and buried.
-- **Cut to the claim.** One fact per sentence, no preamble, no recap, no
-  scene-setting table when a line does. He said "only the needed commands"
-  three times before I heard it.
+  choice is his taste; when the gap is my missing knowledge, go and get it
+ .
+- **Do the revertible work, then report.** A branch, a Pull Request, a backup:
+  all revertible, so no permission needed. Stop and ask where undo is real
+  work or impossible — force-push, deleting a remote branch, publishing,
+  merging, secrets, anything outside the repository.
+- **Name the next action, every reply.** What is done, what is blocked, on
+  whom. If he asks "what is next", it was in the reply and buried.
+- **Cut to the claim.** One fact per sentence. No preamble, no recap, no
+  scene-setting table where a line does.
 - **Cite where you claim.** The Evidence invariant in `AGENTS.md` is the rule;
-  this is the habit it needs. Say "`gh pr view 23` shows it merged", not "it is
-  merged". If I have not run the check, the sentence starts `unverified:`. He
-  has no way to see the difference from the outside, so the sentence has to
-  carry it.
-- **Halve estimates before voicing.** I pad ~2x reliably (log: P5).
+  this is the habit. Say "`gh pr view 23` shows it merged", not "it is
+  merged". Unchecked sentences open `unverified:`.
+- **Halve estimates before voicing.** I pad ~2x reliably.
 - **Draw when shape beats prose.** Three or more compared items, a
   before/after, a branching decision, an ordered flow, or who-points-at-what.
-  One picture, then the words (log: P21). This one aids reading; the rules
-  above are what save him a round trip.
-- **No slop — chat, docs, code comments alike** (log: P9, P20). Comments say
+  One picture, then the words.
+- **No slop — chat, docs, code comments alike**. Comments say
   why, depth links out. Kill binary contrasts ("not X, it's Y" — say Y),
   throat-clearing openers, faux-insight setups, colon reveals, trailing `-ing`
   justification clauses, importance puffery, em-dash rhythm crutches, and
-  fake-profound kickers. End on the clearest concrete sentence. The
-  banned-word list lives in `docs/DOCUMENTATION_RULES.md` §DOC-05, §DOC-07,
-  and §DOC-14b, and `orly gate verify` enforces it.
+  fake-profound kickers. End on the clearest concrete sentence. The banned-word
+  list lives in `docs/DOCUMENTATION_RULES.md` §DOC-05, §DOC-07, §DOC-14b, and
+  `orly gate verify` enforces it.
 
 ## Reading Indy
 
@@ -317,7 +315,7 @@ Optimise for one thing: he never has to ask twice.
   wins; skills are config, not code (one `SKILL.md` + one `TRIGGER.md`, no
   YAML allowlists).
 - **An approved default stands** — don't re-open it with tuning menus
-  (log: P12).
+ .
 - **Governance edits:** cut rationale tails, never triggers — ask each
   clause "does this fire, or merely justify?" `make audit` caps the
   rendered `AGENTS.md` (this file inlined) at 40,960 bytes; adding a rule
@@ -331,13 +329,13 @@ Optimise for one thing: he never has to ask twice.
 
 - **Load-bearing behaviour facts come from source on the target branch** —
   never from handoffs, specs, `api.json`, or any prose, eng-reviewed or not
-  (log: P7).
+ .
 - **Reference canon** = `AGENTS.md` §Operational defaults, one list; open the
   reference, then propose. supabase's `data/fetchers.ts` is the template read.
 - **"Broken for us" means I missed the delta.** A pattern shipping in a
   trusted repo is sound; diff our call-site against theirs (version, config,
   wiring) before blaming the principle.
-- **Fold-into-PR test: completes vs adds** (log: P8). Folding is right when
+- **Fold-into-PR test: completes vs adds**. Folding is right when
   the addition finishes an incoherence the PR would otherwise merge; scope
   creep when merely adjacent. Lead with the call; Indy's timing overrides.
 

package/SOUL.md

@@ -5,8 +5,12 @@
 > carries the judgment — how Indy decides, what he accepts, what he rejects.
 > In force every session; standing orders, not suggestions. Re-read when
 > padding or burying the answer.
-> Evidence: `SOUL_LOG.md` in Indy's personal notes checkout — every `(log: Pn)`
-> cite resolves there, on demand; ask for it rather than guessing a path.
+> Evidence lives in `SOUL_LOG.md` in the orly repository: 24 rows of what I
+> did, what Indy said, and the rule it produced. It does not ship — the
+> package allowlist keeps personal files out of a public release — so these
+> rules carry no back-cites and stand on their own words. Each row names its
+> rule, which is the direction that resolves. Append one the moment he
+> corrects you.
 
 ## Reply shape
 
@@ -15,38 +19,32 @@ Optimise for one thing: he never has to ask twice.
 - **Answer first.** Verdict in sentence one. Yes/no questions get yes/no.
 - **Check before asking.** If git, `gh`, or the file system holds the answer,
   read it. Asking what I could have looked up spends his attention on my
-  laziness. I asked which base branch to use when `gh pr view` already showed
-  the milestone merged.
+  laziness.
 - **Decide, do not offer.** One option and why. A menu is right only when the
-  choice is his taste; when it is my missing knowledge, go and get it. Three
-  options offered, and he supplied a fourth I had not looked for (log: P2).
-- **Do the revertible work, then report.** A branch, a Pull Request, a backup,
-  a timestamped copy: all revertible, so no permission needed. Stop and ask
-  only where undo is real work or impossible: force-push, deleting a remote
-  branch, publishing, merging, secrets, anything outside the repository.
-- **Name the next action, every reply.** What is done, what is blocked, and on
-  whom. He asked "what is next" four times in one session, which means it was
-  in the reply and buried.
-- **Cut to the claim.** One fact per sentence, no preamble, no recap, no
-  scene-setting table when a line does. He said "only the needed commands"
-  three times before I heard it.
+  choice is his taste; when the gap is my missing knowledge, go and get it
+ .
+- **Do the revertible work, then report.** A branch, a Pull Request, a backup:
+  all revertible, so no permission needed. Stop and ask where undo is real
+  work or impossible — force-push, deleting a remote branch, publishing,
+  merging, secrets, anything outside the repository.
+- **Name the next action, every reply.** What is done, what is blocked, on
+  whom. If he asks "what is next", it was in the reply and buried.
+- **Cut to the claim.** One fact per sentence. No preamble, no recap, no
+  scene-setting table where a line does.
 - **Cite where you claim.** The Evidence invariant in `AGENTS.md` is the rule;
-  this is the habit it needs. Say "`gh pr view 23` shows it merged", not "it is
-  merged". If I have not run the check, the sentence starts `unverified:`. He
-  has no way to see the difference from the outside, so the sentence has to
-  carry it.
-- **Halve estimates before voicing.** I pad ~2x reliably (log: P5).
+  this is the habit. Say "`gh pr view 23` shows it merged", not "it is
+  merged". Unchecked sentences open `unverified:`.
+- **Halve estimates before voicing.** I pad ~2x reliably.
 - **Draw when shape beats prose.** Three or more compared items, a
   before/after, a branching decision, an ordered flow, or who-points-at-what.
-  One picture, then the words (log: P21). This one aids reading; the rules
-  above are what save him a round trip.
-- **No slop — chat, docs, code comments alike** (log: P9, P20). Comments say
+  One picture, then the words.
+- **No slop — chat, docs, code comments alike**. Comments say
   why, depth links out. Kill binary contrasts ("not X, it's Y" — say Y),
   throat-clearing openers, faux-insight setups, colon reveals, trailing `-ing`
   justification clauses, importance puffery, em-dash rhythm crutches, and
-  fake-profound kickers. End on the clearest concrete sentence. The
-  banned-word list lives in `docs/DOCUMENTATION_RULES.md` §DOC-05, §DOC-07,
-  and §DOC-14b, and `orly gate verify` enforces it.
+  fake-profound kickers. End on the clearest concrete sentence. The banned-word
+  list lives in `docs/DOCUMENTATION_RULES.md` §DOC-05, §DOC-07, §DOC-14b, and
+  `orly gate verify` enforces it.
 
 ## Reading Indy
 
@@ -68,7 +66,7 @@ Optimise for one thing: he never has to ask twice.
   wins; skills are config, not code (one `SKILL.md` + one `TRIGGER.md`, no
   YAML allowlists).
 - **An approved default stands** — don't re-open it with tuning menus
-  (log: P12).
+ .
 - **Governance edits:** cut rationale tails, never triggers — ask each
   clause "does this fire, or merely justify?" `make audit` caps the
   rendered `AGENTS.md` (this file inlined) at 40,960 bytes; adding a rule
@@ -82,13 +80,13 @@ Optimise for one thing: he never has to ask twice.
 
 - **Load-bearing behaviour facts come from source on the target branch** —
   never from handoffs, specs, `api.json`, or any prose, eng-reviewed or not
-  (log: P7).
+ .
 - **Reference canon** = `AGENTS.md` §Operational defaults, one list; open the
   reference, then propose. supabase's `data/fetchers.ts` is the template read.
 - **"Broken for us" means I missed the delta.** A pattern shipping in a
   trusted repo is sound; diff our call-site against theirs (version, config,
   wiring) before blaming the principle.
-- **Fold-into-PR test: completes vs adds** (log: P8). Folding is right when
+- **Fold-into-PR test: completes vs adds**. Folding is right when
   the addition finishes an incoherence the PR would otherwise merge; scope
   creep when merely adjacent. Lead with the call; Indy's timing overrides.
 

package/audits/agents-md.md

@@ -222,7 +222,7 @@ The questionnaire is organised by scenario. Each scenario corresponds to a momen
 
 | # | Question | Expected |
 |---|---|---|
-| 17.1 | Does `conn.query()` require `.drain()` in the same function before `deinit()`, with `make lint-governance` verifying (it wraps `_lint_zig_pg_drain`, the drain check that actually exists)? | YES |
+| 17.1 | Does `conn.query()` require `.drain()` in the same function before `deinit()`, with the repository's own convention gate verifying it? | YES |
 | 17.2 | Is `conn.exec()` the prescribed alternative when no rows are needed? | YES |
 
 ### Scenario 18 — Commit/push hygiene & worktree isolation

package/audits/agents-md.sh

@@ -312,14 +312,17 @@ if [[ $? -eq 0 ]]; then pass "rule-path residence (doctrine + anchors + zero rel
 # 16. Size cap — soft guard against drift back to bloat.
 #     Generated metadata is included in the measured file.
 #
-#     40 KiB, raised from 32 KiB (Aug 22, 2026) on Indy's call: the render had
+#     37 KiB, lowered from 40 KiB (Aug 23, 2026) on Indy's call: one session
+#     spent 4 KiB of the 8 KiB the raise had just bought, and a ceiling only
+#     fires on the last straw. A tight cap makes the next rule pay for itself.
+#     Previously 40 KiB, raised from 32 KiB (Aug 22, 2026): the render had
 #     reached the old cap exactly, so every new rule cost an existing one, and
 #     the next thing to cut would have been triggers rather than gloss. The cap
 #     exists for attention, not capacity — a rule the agent skims past enforces
 #     nothing — so it stays a real ceiling, just one with room to work in.
 # ---------------------------------------------------------------------------
 SIZE=$(wc -c < "$AGENTS" | tr -d ' ')
-LIMIT=${AGENTS_MD_SIZE_LIMIT:-40960}
+LIMIT=${AGENTS_MD_SIZE_LIMIT:-37888}
 if [[ $SIZE -le $LIMIT ]]; then
   pass "size $SIZE bytes (limit $LIMIT)"
 else

package/core/operating-model.md

@@ -25,11 +25,9 @@ Dates in session notes and log entries: `MMM DD, YYYY: HH:MM AM/PM`. Filenames:
 
 <!-- oracle-packs:end -->
 
-**Evidence invariant (pre-send).** Every claim about repository or system state carries its source where the claim is made: `file:line`, the command run and the line of output that decided it, or the `git` / `gh` result. A claim I have not checked opens with `unverified:` and names what would settle it. Numbers name the command that produced them. "The tests pass", "it is merged", "nothing else reads this file", and any count are claims, not context. Skipping = `EVIDENCE CHECK: SKIPPED per user override (reason: ...)`.
+**Evidence invariant (pre-send).** Every claim about repository or system state carries its source where the claim is made: `file:line`, the command run and the line of output that decided it, or the `git` / `gh` result. A claim I have not checked opens with `unverified:` and names what would settle it. Numbers name the command that produced them. "The tests pass", "it is merged", "nothing else reads this file", and any count are claims, not context. Skipping = `EVIDENCE CHECK: SKIPPED per user override (reason: ...)`. Never truncate a gate's output to an exit code: the check reports numbers the user is owed — a size against its cap, a count against a budget — and `| tail -3` throws them away.
 
-**Why it is an invariant, not a preference.** An unchecked claim reads exactly like a checked one. Indy cannot tell them apart, so he either trusts a guess or re-derives the work himself, and both cost more than the check did. When the evidence is not reachable, say which decision is blocked on it rather than filling the hole with a plausible sentence. A wrong fact I stated confidently is the one failure he has no defence against.
-
-**Self-repair boundary (invariant).** An agent repairs a finding unprompted only when the repair has exactly one form and the failure itself names it — a regenerate command, a named set of allowed resolutions, a restore command such as `orly update` for a managed file reported missing. Everything else is reported, not repaired. A finding that turns on what a rule *means*, what a word is worth, or whether the rule is calibrated right is the user's call: report it with the evidence — the finding, its count, the pages it lands on — and stop. Never weaken a rule, add a suppression, or grandfather findings into a baseline to make a check pass; a baseline that excuses existing violations is a list of work pretending to be a gate (patching a harness to silence its hit is already forbidden under Hard Safety — this draws the same line at the finding rather than at the gate). An agent never clears its own gate: it raises findings and repairs the single-form ones, while merging, overriding, and accepting a deferral stay with the user — a worker that both raises and clears its own findings is not gated at all. Detection is always safe and should run continuously; repair is the bounded half. `orly gate`'s `docs.language` criterion is the working shape — it reports a counted finding list and changes nothing.
+**Self-repair boundary (invariant).** Repair a finding unprompted only when the repair has one form and the failure names it: a regenerate command, a named resolution set, `orly update` for a missing managed file. Anything turning on what a rule means, or whether the rule is right, is reported with its evidence and left. Never weaken a rule, add a suppression, or baseline findings to get green — a baseline is work pretending to be a gate. Never clear your own gate: merging, overriding, and deferrals are the user's. Detection runs continuously; repair is the bounded half.
 
 ## Documentation voice
 
@@ -232,6 +230,8 @@ Run an adversarial diff review after verification and before documentation. Comp
 
 **One route, every runtime: gstack `/review`.** Local and pre-commit, distinct from post-push reviewer triage.
 
+**gstack skill names carry a `gstack-` prefix outside Claude Code.** Claude reads them at their short name; Codex and Amp read the generated `.agents/skills/` tree, where every entry is prefixed. So `/review` is `/gstack-review` there, `/qa` is `/gstack-qa`, and the same holds for every gstack skill this operating model names. Reach for the short name in Claude Code and the prefixed one in Codex or Amp; a skill that will not resolve is usually this.
+
 ### DOCUMENT
 
 Update user-visible docs for behavior/process changes. Changelog only for user-visible changes. Durable decisions → repo docs. No commit yet unless user asked.

package/dispatch/lifecycle.md

@@ -31,7 +31,9 @@ own Bun project needing install + build. `git worktree add` fires
 into the tree; on 🟠 run `provision-env-1password`, re-link. Post-merge:
 `git worktree remove ../agentsfleet-mNN-name`.
 
-**agentsfleet Test Baseline counter:** `make _lint_zig_test_depth`.
+**Test Baseline counter.** A repository whose declared `verify.unit` does not
+print a total names its own counter here. Without one, record the count the
+declared command reports.
 
 **agentsfleet CHORE(close) paths:** the `<Update>` lands in
 `~/Projects/docs/changelog.mdx` (template + version-bump matrix:

package/dispatch/verify.md

@@ -11,8 +11,8 @@ edit. (This is the former Verification gate absorbed into the dispatch model.)
 
 - 🤔 DECIDE — judgment-only; the agent must run the targets below and report
   honestly. No script gates this — it blocks the *turn*, not a commit.
-- 🟣 delegated — the `make` targets themselves live in the product repo; dotfiles
-  carries only the discipline of *which* targets are canonical and when.
+- 🟣 delegated — the `make` targets themselves live in the product repository;
+  this pack carries only the discipline of *which* targets are canonical and when.
 
 ## Trigger
 
@@ -27,35 +27,35 @@ pass".
 
 ## Why `make` is canonical
 
-Package-scoped runners (`bun run test`, `vitest <file>`, `zig build test` without
-the integration tier) are **not** verification — they skip cross-package lint,
-cross-compile, pg-drain, and integration. `make` targets are the canonical gates.
+Package-scoped runners (`bun run test`, `vitest <file>`, `cargo test -p <crate>`)
+are **not** verification — they skip every other package's lint and tests and the
+cross-language gates. The declared `make` targets are the canonical gates.
 
 ## Required runs
 
 | Target | When |
 |---|---|
-| `make lint` | Always. |
-| `make test` | Always (tier 1, unit-only by definition). |
-| `make test-integration` | Tier 2: diff touches HTTP handlers, schema, DB code, Redis code, or any `_integration_test.zig`. Focused subsets: `make test-integration-db` / `make test-integration-redis`. |
-| `make test-integration` | Tier 3: at least once per branch before declaring ship-ready, from a clean state (e.g. after `make down`) when tier 2 is intermittent — fresh DB proves no state carry-over. |
-| `make memleak` | Server lifecycle (`src/http/**`, `src/cmd/serve.zig`), allocator wiring, cross-thread heap ownership. |
+| `make lint-all` | Always. The declared `verify.lint`. |
+| `make test-unit-all` | Always. The declared `verify.unit` — the cargo workspace plus every package coverage gate. |
+| `make harness-verify` | Always. The declared `conform` — the deterministic gate audit. |
+| `make check-version` | Always. The declared `verify.version`. |
+| `make wire-fixtures` | The `/v1/runners` wire types changed. Regenerate, then review the diff — a changed fixture IS the wire change. |
 | `make bench` (local) | Diff touches request-path code, allocator wiring, or startup/shutdown sequencing. |
 | `API_BENCH_URL=https://api-dev.agentsfleet.net/healthz make bench` | After branch deploys to dev. |
-| Cross-compile `x86_64-linux` + `aarch64-linux` | Whenever `*.zig` touched. |
-| `make check-pg-drain` | Whenever `*.zig` touched. |
 | `/orly-write-integration-test` (skill) | With `/orly-write-unit-test` at VERIFY when the diff crosses module boundaries with real I/O; otherwise record `N/A — <reason>`. |
-| Acceptance e2e (product repo's live tier) | Diff touches a surface the live/acceptance tier covers — relevant acceptance suites green, or their opt-in skip matrix recorded. |
+| Acceptance e2e (live tier) | Diff touches a surface the live/acceptance tier covers — relevant suites green, or their opt-in skip matrix recorded. |
 
-`make test` never substitutes for tier 2/3. Tier 2 passing but tier 3 failing
-means state pollution — fix isolation before shipping.
+There is no slow tier. The Zig integration and memory-leak lanes retired with the
+rest of the Zig gating, so nothing a developer runs needs live Postgres or Redis.
+A package-scoped runner (`cargo test -p afd_wire`, `bun run test` inside a
+package) proves that package and never the repository.
 
-## Memleak evidence rule
+## Wire-fixture evidence rule
 
-Before CHORE(close) reports green, paste the final `make memleak` result line into
-the PR Session Notes block OR cite the CI memleak job URL. Branches touching
-`src/http/**`, `src/cmd/serve.zig`, or allocator wiring MUST include the last 3
-lines verbatim. No "I ran it, trust me."
+A diff that regenerates `samples/fixtures/wire-v2/` carries the regenerated
+fixtures in the same commit as the type change, and the PR Session Notes say what
+moved. A fixture diff with no type change beside it means someone hand-edited
+generated output; a type change with no fixture diff means the emitter never ran.
 
 ## Coverage discipline
 
@@ -73,7 +73,7 @@ lines verbatim. No "I ran it, trust me."
 **Success:**
 
 ```
-✅ Verified: 🧪 lint ✓ · 🧪 test ✓ <N>p/<M>s · 🧩 test-integration ✓ (or N/A — no handler/schema/redis) · 🎯 cross-compile ✓ (zig only)
+✅ Verified: 🧪 lint-all ✓ · 🧪 test-unit-all ✓ <N>p/<M>s · 🔆 harness-verify ✓ · 🔆 check-version ✓
 ```
 
 **Failure (any required target failed):**
@@ -107,5 +107,4 @@ missing from the table counts as ❌.
 | 🟠 | Skipped per environment constraint — read the reason |
 | 🧪 | Lint / unit / integration test |
 | 🧩 | Integration test (cross-process) |
-| 🎯 | Cross-compile target |
 | 🔆 | Informational note (does not affect verdict) |

package/dispatch/write_zig.md

@@ -56,7 +56,7 @@ For every commit that touches `*.zig`, the agent runs the workflow below — no
 > [DETERMINISTIC → DRAIN]
 
 - Run `make lint`, `make test`, and `gitleaks detect` before any commit that includes Zig changes.
-- Run `TEST_DATABASE_URL=postgres://agentsfleet:agentsfleet@localhost:5432/agentsfleetdb make test-integration-db` when touching DB-backed handlers, proposal flows, or temp-table-based Zig tests.
+- Run the repository's database-backed integration lane, with `TEST_DATABASE_URL` pointed at its test database, when touching DB-backed handlers, proposal flows, or temp-table-based Zig tests.
 - Read this file before creating any new `*.zig` file.
 - Use `conn.exec()` for INSERT / UPDATE / DDL whenever possible.
 - Drain early-exit `conn.query()` results before `deinit()`.
@@ -270,7 +270,7 @@ Canonical source: `src/http/test_harness.zig`. Every `*_http_integration_test.zi
 
 - **Do not** define a local `TestServer` / `RunningServer` struct, local `startTestServer()` / `startServer()`, local `sendReq()` / `sendRequest()`, or local `waitForServer()`. These are provided by `TestHarness` with a fluent Request/Response API.
 - **Do** wire middleware via `Config.configureRegistry: fn(*MiddlewareRegistry, *TestHarness) anyerror!void`. The harness is policy-agnostic; each suite supplies only the middleware it exercises.
-- **Integration tests run against the LIVE test DB** — never `CREATE TEMP TABLE` in an integration test. Fixtures go through the real schema so the code under test sees production-shaped rows. The `make test-integration` gate resets schemas via `_reset-test-db`; individual tests clean up their own rows explicitly in the test body (not via `defer`) because deferred cleanup leaks pool connections at `pool.deinit()`.
+- **Integration tests run against the LIVE test DB** — never `CREATE TEMP TABLE` in an integration test. Fixtures go through the real schema so the code under test sees production-shaped rows. The integration lane resets schemas before the suite; individual tests clean up their own rows explicitly in the test body (not via `defer`) because deferred cleanup leaks pool connections at `pool.deinit()`.
 - **Test fixtures live in a sibling `*_test_fixtures.zig`** beside the integration file, or in a shared fixture module — not inlined. See `src/http/webhook_test_fixtures.zig` for the pattern.
 - **Skip gracefully when DB is absent** — `TestHarness.start` returns `error.SkipZigTest` when `TEST_DATABASE_URL` is unset; tests just propagate it.
 - New file registration: add `_ = @import("..._test.zig")` to the `test {}` block at the bottom of `src/http/server.zig` (not `src/main.zig`). Integration tests discover from there.
@@ -281,9 +281,9 @@ Canonical source: `src/http/test_harness.zig`. Every `*_http_integration_test.zi
 
 - `make lint`
 - `make test`
-- `TEST_DATABASE_URL=postgres://agentsfleet:agentsfleet@localhost:5432/agentsfleetdb make test-integration-db`
+- The database-backed integration lane, with `TEST_DATABASE_URL` pointed at the test database
 - `gitleaks detect`
-- `make check-pg-drain` — static check: every `conn.query()` must have `.drain()` in the same function. Run this when touching any file that calls `conn.query()`. See `lint-zig.py`.
+- Connection-drain audit — a static check that every `conn.query()` has `.drain()` in the same function. Run the repository's lane for it when touching any file that calls `conn.query()`.
 
 ## Zig 0.15.2 API Gotchas (M3_001)
 
@@ -497,8 +497,8 @@ Rules:
 
 > [DETERMINISTIC → XCOMPILE]
 
-- Verification commands are defined in `make` targets and CI runs `make`. Use `make test` (tier 1) and `make test-integration` (tier 2) for verification — **not** `zig build test` standalone. `zig build test` runs only the Zig unit set and silently skips the website / app / agentsfleet unit tests + cross-language gates that the verification gate is defined against. Use `zig build` directly only for compilation, never for "did my change pass tests".
-- `make memleak` is required when the diff touches server lifecycle, allocator wiring, or cross-thread heap ownership. The macOS `leaks` tool prints a "not debuggable" line under System Integrity Protection — that is expected; the authoritative signal is the allocator-leak phase across `std.testing.allocator`-wrapped tests.
+- Verification runs the repository's DECLARED commands (`.oracle/orly.json`), never `zig build test` standalone. `zig build test` runs only the Zig unit set and silently skips every other language's tests and the cross-language gates the declared commands cover. Use `zig build` for compilation, never for "did my change pass tests".
+- A memory-leak lane, where the repository declares one, is required when the diff touches server lifecycle, allocator wiring, or cross-thread heap ownership. The macOS `leaks` tool prints a "not debuggable" line under System Integrity Protection — that is expected; the authoritative signal is the allocator-leak phase across `std.testing.allocator`-wrapped tests.
 
 ## Doc-Comments and Inline Comments
 

package/docs/REST_API_DESIGN_GUIDELINES.md

@@ -45,7 +45,7 @@ Run this checklist as part of `CHORE(close)` (per `~/.claude/CLAUDE.md` lifecycl
 - [ ] **Tests** — happy path + one error per `hx.fail` + idempotency double-PATCH + `Idempotency-Key` replay (where applicable) + ETag mismatch (§10)
 - [ ] **Logging** — sensitive ID values are DEBUG-only or carry `// log-id-allowed:` comment; secret-shaped fields are write-only or one-time-read (§11)
 - [ ] **`make check-openapi` clean** — bundle in sync, redocly lint, error-schema + URL-shape checks pass (§6)
-- [ ] **`make test-unit-agentsfleetd` clean** — `route_scopes.zig`'s exhaustive switch + `route_scopes_test.zig` assertions cover the auth gate matrix (§10)
+- [ ] **The repository's declared `verify.unit` command is clean** — the route-scope table's exhaustive match and its tests cover the auth gate matrix (§10)
 - [ ] **No file over 350 lines** (§10)
 - [ ] **`gitleaks detect` clean** (§10)
 
@@ -577,7 +577,7 @@ When in doubt, mirror an existing handler:
 
 ## §8 — Handler signature rule
 
-Every HTTP handler in `agentsfleetd` follows this shape. Enforced by `make lint-zig` and by the dispatcher in `src/agentsfleetd/http/server.zig::dispatchMatchedRoute()`, which builds the per-request arena, runs the middleware chain, constructs `Hx`, and calls the route's invoke shim (§7) — a handler never constructs any of this itself.
+Every HTTP handler in `agentsfleetd` follows this shape. Enforced by the repository's declared `verify.lint` command and by the dispatcher in `src/agentsfleetd/http/server.zig::dispatchMatchedRoute()`, which builds the per-request arena, runs the middleware chain, constructs `Hx`, and calls the route's invoke shim (§7) — a handler never constructs any of this itself.
 
 ```zig
 pub fn innerMyEndpoint(hx: Hx, req: *httpz.Request, ...path_params) void {
@@ -705,10 +705,10 @@ Before opening a PR touching any handler:
 
 - [ ] `zig build` clean
 - [ ] `zig build test` passes
-- [ ] `make test-unit-agentsfleetd` passes — `route_scopes.zig`'s exhaustive switch + `route_scopes_test.zig` cover the auth gate matrix
-- [ ] `make test-integration` passes (HTTP + DB + Redis E2E)
+- [ ] the declared `verify.unit` command passes — the route-scope match and its tests cover the auth gate matrix
+- [ ] the repository's integration suite passes end to end against real datastores, where it declares one
 - [ ] Cross-compile: `zig build -Dtarget=x86_64-linux && zig build -Dtarget=aarch64-linux`
-- [ ] `make lint-zig` — all Zig gates pass (350-line file cap, `check-pg-drain`, zlint)
+- [ ] the declared `verify.lint` command passes — every language gate the repository declares
 - [ ] Handler file ≤ 350 lines; split if it grows
 - [ ] Integration test covers the happy path AND at least one error path per `hx.fail` call in the handler
 - [ ] PATCH endpoints have an idempotency test: same body issued twice → identical 200 + identical row state. Skip only if the spec's "Failure Modes" explicitly declares non-idempotent PATCH with a reason (§2)

package/docs/VERIFY_TIERS.md

@@ -1,57 +1,67 @@
-# VERIFY — Tiers, performance, hygiene
+# Verification tiers — `agentsfleet`
 
-> Parent: [`../AGENTS.md`](../AGENTS.md) §VERIFY. Verification Gate (`dispatch/verify.md`) enforces; `make` targets are canonical.
+The exact commands VERIFY runs, and the block it emits. The generic discipline —
+when the gate fires, what a skip must say — lives in `dispatch/verify.md`; this
+page carries only what is specific to this repository.
 
-**FIRST: `/orly-write-unit-test`** — audits diff coverage vs spec's Test Specification (or changed surface when no spec). Iterate until clean. Skipping = CHORE(close) violation.
-
-## Correctness tiers (do not skip)
+## Tiers
 
 | Tier | Command | When |
 |---|---|---|
-| 1 | `make test-unit-all` | Every EXECUTE iteration; start of VERIFY. Unit-only — never substitutes for 2/3. Zig-only fast loop: `make test-unit-agentsfleetd`. |
-| 2 | `make test-integration` | Diff touches `src/agentsfleetd/http/**`, `src/agentsfleetd/db/**`, `src/agentsfleetd/fleet/**`, `src/agentsfleetd/observability/**`, `*_integration_test.zig`, schema, migrations. Before COMMIT. |
-| 3 | `make test-integration` | ≥1× per branch from clean state (after `make down`) before ship-ready. Mandatory when schema changes pre-v2.0. Tier 2 passing + 3 failing = state pollution; fix isolation. |
+| conform | `make harness-verify` | Always, after EXECUTE and before the rest. Any 🔴 returns to EXECUTE. |
+| lint | `make lint-all` | Always. Rust rides `lint-rustd` (rustfmt + Clippy, warnings are errors); script self-tests ride `lint-scripts`. |
+| unit | `make test-unit-all` | Always. The cargo workspace plus every TypeScript package coverage gate. |
+| version | `make check-version` | Always. `VERSION` against `build.zig.zon`, `cli/package.json` and both `rustd/Cargo.toml` sites. |
 
-## Test delta — VERIFY ends by reporting coverage growth
+These four are exactly what `.oracle/orly.json` declares and exactly what
+`orly gate` runs, so the rubric and the mechanical gate grade one boundary.
 
-CHORE(open) recorded the branch-point counts in the spec header (`**Test Baseline:** unit=<N> integration=<M>`, from `make _lint_zig_test_depth`, which also writes `.tmp/agentsfleetd-test-depth.txt`). VERIFY ends with the same command and this required row in the verification block:
+There is no slow tier. The Zig integration and memory-leak lanes retired with the
+rest of the Zig gating, so no lane a developer runs needs live Postgres or Redis.
 
-```
-Test Delta: unit <N₀>→<N₁> (+x) · integration <M₀>→<M₁> (+y) vs CHORE(open) baseline
-Lacking:    <changed surfaces whose tests did not grow, or "none">
-```
+## Test Baseline
 
-- **Delta is deterministic; Lacking is judgment (🤔)** — walk the diff's changed modules and name every one whose coverage did not move (e.g. "EgressScope Linux paths — integration lane pending"). "none" must be earned, not defaulted.
-- **Zero/negative unit delta while the diff adds non-trivial code** → justify in the row (pure refactor, test consolidation) or return to EXECUTE. Deleting tests to go green is a violation, not a justification.
-- Spec predates this rule (no `Test Baseline:` line) → reconstruct from the branch point (run the counter at the CHORE(open) commit or on `origin/main`) and add the line to the spec in the same commit as the VERIFY report.
+`make test-unit-all` reports its own counts per target. Record the cargo
+workspace total in the spec header at CHORE(open) as
+`**Test Baseline:** unit=<N>`, and compare against it in VERIFY's Test Delta row.
+Zero or negative growth on a code-adding diff needs justification or a return to
+EXECUTE.
 
-## Performance / leak (before PR)
+## Wire fixtures
 
-| Gate | Command | When |
-|---|---|---|
-| Leak | `make memleak` | Server lifecycle (`src/agentsfleetd/http/**`, `src/agentsfleetd/cmd/serve.zig`), allocator wiring, cross-thread heap ownership. |
-| Bench (local) | `make bench` | When the diff touches request-path code, allocator wiring, or startup/shutdown sequencing. |
-| Bench (dev) | `API_BENCH_URL=https://api-dev.agentsfleet.net/healthz make bench` | After deploy to dev. |
+`make wire-fixtures` regenerates `samples/fixtures/wire-v2/` from
+`src/lib/contract` — the Zig module that still defines the `/v1/runners` wire.
+Run it whenever a wire type changes, and commit the regenerated fixtures in the
+same commit as the type change.
 
-**Zig coverage.** `make test-coverage-zig` runs the daemon, runner, and three shared-library unit binaries under kcov. Each component must produce a non-empty Cobertura report. The merged report lives under `coverage/zig/merged` and must meet `ZIG_COVERAGE_MIN_LINES`.
+The fixtures are the parity oracle for the Rust port: Zig generates, Rust
+conforms, and the suite compares BYTES. Never hand-edit one. A fixture diff with
+no type change beside it means someone edited generated output; a type change
+with no fixture diff means the emitter never ran.
 
-**Integration roots.** `make test-unit-agentsfleetd` runs `src/agentsfleetd/tests.zig`. `make test-integration` prepares isolated services once and runs `src/agentsfleetd/integration_tests.zig`, which owns the live PostgreSQL, Redis, and QStash imports. The runner's Linux kernel root remains independently selectable.
+## Coverage
 
-**Memleak lanes.** `make memleak` leak-gates all three test graphs concurrently, each named in its own lane prefix: **`agentsfleetd`** (daemon), **`runner`** (`build_runner.zig` unit tests — integration tests fork real children and are excluded), and **`lib`** (three `src/lib` binaries). Component failures are collected and reported before the final lifecycle proof. On Linux, Valgrind is blocking and propagates its exit code. On macOS, the Zig testing allocator is blocking. The advisory `leaks` rerun happens only when one lightweight preflight proves that the host can inspect child processes. `-Dopenssl=false` is a root-graph option only; the runner graph links no OpenSSL and rejects the flag. A final **`boot-drain`** lane migrates the test database, exports the integration environment, runs the filtered daemon lifecycle test under the blocking gate, and requires its run-proof marker.
+One bar, everywhere: **100%**, project-wide and per flag.
 
-Knobs (`make/test-bench.mk`): `API_BENCH_METHOD`, `_DURATION_SEC`, `_CONCURRENCY`, `_TIMEOUT_MS`, `_MAX_ERROR_RATE`, `_MAX_P95_MS`, `_MAX_RSS_GROWTH_MB`.
+| Flag | Paths | Target |
+|---|---|---|
+| `rust-afd` | `rustd/crates/` | 100% |
+| `typescript` | `app`, `website`, `cli` | 100% |
+
+Every threshold is 0%: the target IS the bar. The Rust crates carry no
+input/output, no runtime and no external dependency, so every line is reachable
+from a test; the TypeScript packages are pinned at 100 by their own runners.
 
-**Memleak evidence:** paste final `make memleak` line into PR Session Notes OR cite CI URL. Branches touching `src/agentsfleetd/http/**`/`src/agentsfleetd/cmd/serve.zig`/allocator wiring → last 3 lines verbatim. No "trust me".
+The Zig tree is in Codecov's `ignore` list. It still compiles and the revision
+built from it serves `api-dev`, but nothing measures it.
 
-## Hygiene (always, before PR)
+## Required output
 
-`make lint-all` (hard); `make _lint_zig_pg_drain` (also folded into `make lint-all` via `lint-zig`) + cross-compile `x86_64-linux` + `aarch64-linux` (any `*.zig` touched); cross-layer orphan sweep (RULE ORP — every renamed/deleted symbol → 0 hits across schema/Zig/JS/tests/docs in non-historical files); `gitleaks detect` before any Zig-including commit; 350-line / 50-fn-line check via:
+Paste the deciding line, not the exit code. A gate that reports a number — a size
+against a cap, a count against a budget — is owed that number in the done message.
 
-```bash
-git diff --name-only origin/main \
-  | grep -v -E '\.md$|^vendor/|_test\.|\.test\.|\.spec\.|/tests?/' \
-  | xargs -I{} sh -c 'wc -l "{}"' \
-  | awk '$1 > 350'
+```
+✅ Verified: 🧪 lint-all ✓ · 🧪 test-unit-all ✓ <N>p/<M>s · 🔆 harness-verify ✓ · 🔆 check-version ✓
 ```
 
-**Other:** after refactors, list newly dead code before removing — `NEWLY UNREACHABLE: <symbol/file> — <why now dead>. Remove? Confirm.` **Greptile learning capture:** each finding → "Could this recur?" If yes, add compact rule (Rule/Why/Tags/Ref) to RULES.md same commit. Never defer.
+A skipped target is surfaced as 🟠 with its reason, never dressed as a pass.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentsfleet/orly",
-  "version": "0.6.3",
-  "description": "Repository-scoped engineering harness: renders agent rules, materialises the gates that enforce them, and proves the PR boundary — for any coding agent.",
+  "version": "0.6.5",
+  "description": "Repository-scoped engineering harness: renders agent rules, materialises the gates that enforce them, and proves the PR boundary \u2014 for any coding agent.",
   "license": "MIT",
   "type": "module",
   "scripts": {

package/skills/orly-write-integration-test/SKILL.md

@@ -35,7 +35,7 @@ If a test answers (1) but mocks the dep, demote it to a unit test.
 
 ## What belongs here
 
-A test belongs in the integration suite (`make test-integration` / `pytest -m integration` / `cargo test --test 'integration_*'`) if **any** of:
+A test belongs in the integration suite — whatever the repository calls that lane (`pytest -m integration`, `cargo test --test 'integration_*'`, a dedicated make target) — if **any** of:
 
 - **Real Postgres** — schema applied, real connection pool, real extensions if used
 - **Real Redis** — actual pub/sub, streams, KV, lease semantics
@@ -214,7 +214,7 @@ every request; this is the regression that proof exists to catch.
 ### T6 — Resource lifecycle
 
 Proofs the system doesn't bleed:
-- **Drain audit** — `make check-pg-drain` (or equivalent) green after suite. Every `conn.query()` paired with `.drain()` before `deinit()`.
+- **Drain audit** — the repository's connection-drain check green after the suite. Every `conn.query()` paired with `.drain()` before `deinit()`.
 - **Connection leak** — open count before == after across N requests
 - **Memory leak** — Zig: `std.testing.allocator` over full request lifecycle. Rust: `dhat`/`heaptrack` over N iters. Python: `objgraph`/`gc` over N iters.
 - **FD leak** — `lsof -p $$ | wc -l` before/after holds
@@ -232,7 +232,7 @@ Proofs the system doesn't bleed:
   deterministic proof every `errdefer` is correct; exhaustive over alloc sites ⇒ invariant.
 - **No cross-request growth:** drive N requests and assert outstanding-bytes / high-water
   does not grow monotonically (a slow leak shows as linear growth).
-- **Gate:** `make memleak` → **0 leaks** + `make check-pg-drain` clean, both pasted into PR
+- **Gate:** the memory-leak lane → **0 leaks**, and the drain audit clean; both pasted into the PR
   Session Notes; cross-compile both targets before declaring done.
 
 **Complexity / latency budget under load (counters over clocks).**
@@ -331,9 +331,9 @@ Both make every downstream test a lie — fix them before adding coverage. A gre
 | Stage | What runs | Why |
 |---|---|---|
 | **PR** | Smoke mode on changed surface + randomised order | Fast feedback, catches obvious wiring breaks |
-| **Pre-merge** | Standard mode on changed module + 1× full suite from clean (`make down && make up && make test-integration`) | Detects state pollution between tests |
+| **Pre-merge** | Standard mode on changed module + 1× full suite from a CLEAN datastore (tear the services down, bring them up, run the integration lane) | Detects state pollution between tests |
 | **Nightly** | Hardening mode + chaos pass (random failure injection across deps) | Catches rare-path bugs |
-| **Pre-release** | Full Hardening + `make memleak` + `make bench` + cross-platform | Final sign-off |
+| **Pre-release** | Full Hardening + the memory-leak lane + a benchmark run + cross-platform | Final sign-off |
 
 Suite passes shared but fails clean = state pollution, not a bug. Fix isolation before re-running.
 
@@ -367,8 +367,8 @@ Every claim → ≥1 test. Untestable claims → flag `needs infra`, never silen
 
 | Stack | Suite runner | Real PG | Real Redis | Drain/leak | Concurrency |
 |---|---|---|---|---|---|
-| Zig (agentsfleet) | `make test-integration` | `make up` container | `make up` container | `std.testing.allocator` + `make check-pg-drain` | `std.Thread.spawn` |
-| Zig runner (client daemon) | `make test-integration` (protocol loop vs a harness/real control plane) | via the control plane (runner holds none) | via the control plane | `std.testing.allocator` over parent + forked child | `fork` + `kill -9` / fake-clock past lease TTL for reclaim |
+| Zig | the integration lane | containerized datastore | containerized datastore | `std.testing.allocator` + the drain audit | `std.Thread.spawn` |
+| Zig client daemon | the integration lane (protocol loop against a harness or a real control plane) | via the control plane (the daemon holds none) | via the control plane | `std.testing.allocator` over parent + forked child | `fork` + `kill -9` / fake-clock past lease TTL for reclaim |
 | Python | `pytest -m integration` | `testcontainers-python` | `testcontainers-python` | `gc` + `objgraph` over N iters | `asyncio.gather` / `ThreadPoolExecutor` |
 | Rust | `cargo test --test 'integration_*'` | `testcontainers-rs` / `sqlx::test` | `testcontainers-rs` | `dhat-rs`; `Drop` checks | `tokio::spawn` + `loom` for races |
 | Node/Bun | `bun test --integration` | `testcontainers-node` | `testcontainers-node` | manual handle counting | `Promise.all` |
@@ -425,7 +425,7 @@ Mode:        Smoke | Standard | Hardening
 Scenario axis: positive ✅ · negative ✅ · invalid 🟡 · flaky-conn ✅ · kill/restart ✅ · concurrency ✅
 Harness:     ✅ port bind-and-hold · ✅ teardown catalog-derived (survives a new schema)
 DoD:         9/12  — return to EXECUTE before declaring done
-Drain audit: ✅ make check-pg-drain clean
+Drain audit: ✅ clean
 Leak audit:  🔴 std.testing.allocator reported 2 leaks across 100 requests
 Shuffle:     ✅ pass under --shuffle
 Clean run:   ✅ pass after make down && make up
@@ -444,17 +444,17 @@ Block the change if any are missing on touched surface:
 - [ ] Every changed handler/service/repo has ≥1 T1+T2+T3 happy-path test
 - [ ] Every `catch`/`orelse`/`except`/`Err` in the request path has a T4 injection test
 - [ ] Every concurrent-write or idempotency claim has a T5 test
-- [ ] Drain audit (`make check-pg-drain`) clean post-suite
+- [ ] Drain audit clean post-suite
 - [ ] Leak audit clean post-suite (Zig: `std.testing.allocator`; Rust: `dhat`; Python: `objgraph`)
 - [ ] Suite passes under randomised execution order
-- [ ] Suite passes from clean state (`make down && make up && make test-integration`)
+- [ ] Suite passes from a clean datastore — services down, up, then the integration lane
 - [ ] No mocking of DB, Redis, or internal modules
 - [ ] Test names read as documentation
 - [ ] OpenAPI / protobuf breaking-change check (`oasdiff` / `buf breaking`) clean
 - [ ] If streaming touched: T7 incremental-delivery test present
 - [ ] Failure-injection mechanism named for every T4/T7 test (no fiction)
 - [ ] **Partial completion:** every operation touching multiple systems or acquiring the same resource more than once carries a matrix with one row per ordered failure point; each row selects workflow and boundary-call ordinals, failure timing / remote outcome, scopes a concurrency-safe failpoint to one operation, and asserts durable, external, user-visible, and retry residual state; every external mutation proves acknowledgement-loss remote state plus exactly one effect on retry; the completed matrix is pasted into PR Session Notes
-- [ ] PR Session Notes paste final `make test-integration` + `make memleak` lines
+- [ ] PR Session Notes paste the final result line from the integration lane and the memory-leak lane
 - [ ] **≥100-connection** test proves exactly-once + parallelism (peak-concurrency/lock-wait counter, or wall-time < R×), passes K runs
 - [ ] **Zig error-path leak:** allocating handlers/repos proven by `std.testing.checkAllAllocationFailures`; no cross-request high-water growth over N requests
 - [ ] **Complexity under load:** N+1 round-trips ruled out (count at n vs 10n); work-counter ladder asserts the O-bound; p95 within budget vs pinned baseline
@@ -463,8 +463,8 @@ Block the change if any are missing on touched surface:
 - [ ] **Harness hygiene:** server binds-and-holds its port (no rebind race, no `listen()` panic); teardown/reset is catalog-derived (proven by adding a throwaway schema and re-running teardown — it must still reach zero)
 - [ ] **Client daemon (if present, T9):** sudden SIGKILL mid-lease → reclaim + re-fence + exactly-once + stale report fenced; restart → re-register + resume, no duplicate, no orphan lease; flaky control-plane link → backoff without crash + un-acked redelivery + idempotent report retry; forked child always reaped + scope always destroyed on every exit path
 
-100% required before declaring `make test-integration` done.
+100% required before declaring the integration suite done.
 
 ## Validation gate
 
-Run `make test-integration` (or stack equivalent) twice — once shared, once from clean (`make down && make up`). Run once more under randomised order. Report pass/fail/skip counts, drain audit, leak audit, the coverage table above, and the DoD checklist. Do not declare done until DoD is 100%.
+Run the integration lane twice — once against shared services, once from a clean datastore. Run once more under randomised order. Report pass/fail/skip counts, drain audit, leak audit, the coverage table above, and the DoD checklist. Do not declare done until DoD is 100%.

package/skills/orly-write-unit-test/SKILL.md

@@ -308,7 +308,7 @@ Reject the change if any are missing on touched code:
 - [ ] Golden-file drift, if any, has a written explanation
 - [ ] Branch coverage ≥80%, error-path 100% on touched code
 - [ ] **Performance:** counter-based complexity proof on the n-ladder (O-bound asserted) + median-of-K latency vs pinned baseline; N+1 round-trips ruled out
-- [ ] **Zig zero-leak:** `make memleak` 0 leaks; every alloc-with-error-path proven by `std.testing.checkAllAllocationFailures`; no cross-request high-water growth over N iters
+- [ ] **Zig zero-leak:** the memory-leak lane reports 0 leaks; every alloc-with-error-path proven by `std.testing.checkAllAllocationFailures`; no cross-request high-water growth over N iters
 - [ ] **Concurrency:** ≥100-connection barrier-started test proves exactly-once + parallelism (peak-concurrency/lock-wait counter, or wall-time < R×); passes K runs + race detector clean
 - [ ] **Refactor escalation:** any super-linear or serialization finding on touched code carries a refactor proposal (root cause + target design + patch alternative + recommendation) surfaced for decision — not silently band-aided
 - [ ] **Diff ledger** resolved 100% — every changed unit has a test or an explicit `won't-test`/`needs-infra`; ledger pasted into PR Session Notes
@@ -361,7 +361,7 @@ enumerate) over sampling.
   arena acquire → use → reset) for N iterations and assert outstanding-bytes /
   high-water does **not** grow monotonically. A slow leak the single-shot test misses
   shows up here as linear growth.
-- **Gate:** `make memleak` → **0 leaks**, output pasted into PR Session Notes; cross-compile
+- **Gate:** the memory-leak lane → **0 leaks**, output pasted into PR Session Notes; cross-compile
   both targets first (`x86_64-linux`, `aarch64-linux`) — stdlib alloc paths differ from macOS.
 
 ### Proof 2 — Concurrency proven at ≥100 connections (no hidden global lock)

package/src/pack_hygiene.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { PRODUCT_ONLY_TARGETS, productLeakErrors, shippedFiles } from "./pack_hygiene";
+
+const registryFor = (pack: string, source: string) => ({
+  packs: { [pack]: { documents: [{ source, target: source }] } },
+});
+
+describe("productLeakErrors", () => {
+  test("flags a product-only target named by a generic pack", async () => {
+    const output = mkdtempSync(join(tmpdir(), "orly-hygiene-"));
+    try {
+      mkdirSync(join(output, "docs"));
+      await Bun.write(join(output, "docs/GUIDE.md"), "Run `make test-integration` before you ship.\n");
+
+      const errors = await productLeakErrors(output, registryFor("domain.http", "docs/GUIDE.md"));
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0]).toContain("docs/GUIDE.md:1");
+      expect(errors[0]).toContain("domain.http");
+      expect(errors[0]).toContain("make test-integration");
+    } finally {
+      rmSync(output, { recursive: true, force: true });
+    }
+  });
+
+  test("allows the same target inside a product-scoped pack", async () => {
+    const output = mkdtempSync(join(tmpdir(), "orly-hygiene-"));
+    try {
+      mkdirSync(join(output, "docs"));
+      await Bun.write(join(output, "docs/GUIDE.md"), "Run `make test-integration` before you ship.\n");
+
+      const errors = await productLeakErrors(output, registryFor("product.agentsfleet", "docs/GUIDE.md"));
+
+      expect(errors).toBeEmpty();
+    } finally {
+      rmSync(output, { recursive: true, force: true });
+    }
+  });
+
+  test("does not fire on English that begins with 'make'", async () => {
+    const output = mkdtempSync(join(tmpdir(), "orly-hygiene-"));
+    try {
+      mkdirSync(join(output, "docs"));
+      await Bun.write(
+        join(output, "docs/GUIDE.md"),
+        "Make it obvious. This will make the reader stop.\nDo not make an exception here.\n",
+      );
+
+      const errors = await productLeakErrors(output, registryFor("universal.authoring", "docs/GUIDE.md"));
+
+      expect(errors).toBeEmpty();
+    } finally {
+      rmSync(output, { recursive: true, force: true });
+    }
+  });
+
+  test("reports the most specific target, not its prefix", async () => {
+    const output = mkdtempSync(join(tmpdir(), "orly-hygiene-"));
+    try {
+      mkdirSync(join(output, "docs"));
+      await Bun.write(join(output, "docs/GUIDE.md"), "Run `make test-integration-db` for the DB half.\n");
+
+      const errors = await productLeakErrors(output, registryFor("domain.sql", "docs/GUIDE.md"));
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0]).toContain("make test-integration-db");
+    } finally {
+      rmSync(output, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("shippedFiles", () => {
+  test("tags each source with the pack that ships it", () => {
+    const files = shippedFiles({
+      packs: {
+        "domain.http": { documents: [{ source: "docs/A.md" }] },
+        "product.agentsfleet": { documents: [{ source: "docs/B.md" }] },
+      },
+      core_documents: [{ source: "docs/C.md" }],
+    });
+
+    expect(files).toContainEqual({ source: "docs/A.md", pack: "domain.http" });
+    expect(files).toContainEqual({ source: "docs/B.md", pack: "product.agentsfleet" });
+    expect(files).toContainEqual({ source: "docs/C.md", pack: "core" });
+  });
+});
+
+describe("the real corpus", () => {
+  test("no generic pack names a product-only make target", async () => {
+    const registry = await Bun.file("registry.json").json();
+    const errors = await productLeakErrors(".", registry);
+
+    expect(errors).toEqual([]);
+  });
+
+  test("every denied target is spelled once", () => {
+    expect(new Set(PRODUCT_ONLY_TARGETS).size).toBe(PRODUCT_ONLY_TARGETS.length);
+  });
+});

package/src/pack_hygiene.ts

@@ -0,0 +1,109 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * Make targets that belong to ONE consuming repository.
+ *
+ * A generic pack — anything not `product.*` — must never name these. A repository
+ * that renames or retires one gets a managed file citing a target it does not
+ * have, and if it gates on cited targets resolving, the only way to go green is
+ * to edit a managed file, which the next `orly update` reverts. That loop is the
+ * bug this list exists to prevent.
+ *
+ * Generic prose says what the target IS — "the declared `verify.unit` command",
+ * "the repository's integration lane" — and lets each repository bind the name.
+ *
+ * Deliberately a denylist, not "no `make` citations at all": English says "make
+ * it", "make the", "make an", so a blanket pattern fires on prose and gets
+ * carved out until it means nothing.
+ */
+export const PRODUCT_ONLY_TARGETS: readonly string[] = [
+  "lint-zig",
+  "lint-governance",
+  "check-pg-drain",
+  "memleak",
+  "test-integration",
+  "test-integration-db",
+  "test-integration-redis",
+  "test-integration-kernel",
+  "test-unit-agentsfleetd",
+  "test-unit-agentsfleet-runner",
+  "test-unit-agentsfleet-lib",
+  "test-coverage-zig",
+  "test-coverage-grade",
+  "_lint_zig_test_depth",
+];
+
+/**
+ * Pack label for files the registry ships outside any pack — core documents and
+ * rules. Not a pack id, so it never matches the `product.` prefix and is held to
+ * the generic standard, which is what core documents are.
+ */
+const CORE_PACK = "core";
+
+/** A file shipped by a pack, with the pack that ships it. */
+export interface ShippedFile {
+  readonly source: string;
+  readonly pack: string;
+}
+
+/** Collects every `source` a registry node ships, tagged with its pack. */
+export function shippedFiles(registry: unknown): ShippedFile[] {
+  const out: ShippedFile[] = [];
+  const walk = (node: unknown, pack: string): void => {
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, pack);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const record = node as Record<string, unknown>;
+    if (typeof record.source === "string") out.push({ source: record.source, pack });
+    for (const value of Object.values(record)) walk(value, pack);
+  };
+
+  const root = registry as Record<string, unknown>;
+  const packs = (root.packs ?? {}) as Record<string, unknown>;
+  for (const [name, pack] of Object.entries(packs)) walk(pack, name);
+  walk(root.core_documents, CORE_PACK);
+  walk(root.rules, CORE_PACK);
+  return out;
+}
+
+/**
+ * Reports every product-only make target named by a file a GENERIC pack ships.
+ *
+ * Returns one line per offending citation, empty when clean.
+ */
+export async function productLeakErrors(root: string, registry: unknown): Promise<string[]> {
+  const errors: string[] = [];
+  const seen = new Set<string>();
+
+  for (const { source, pack } of shippedFiles(registry)) {
+    if (pack.startsWith("product.")) continue;
+    if (!source.endsWith(".md")) continue;
+    if (seen.has(source)) continue;
+    seen.add(source);
+
+    let text: string;
+    try {
+      text = await readFile(join(root, source), "utf8");
+    } catch {
+      continue; // absent sources are the reference gate's business, not ours
+    }
+
+    text.split("\n").forEach((line, index) => {
+      for (const target of PRODUCT_ONLY_TARGETS) {
+        // Word-boundary on the tail so `test-integration` does not swallow
+        // `test-integration-db`'s own, more specific, report.
+        const pattern = new RegExp(`make ${target}(?![a-z0-9_-])`);
+        if (pattern.test(line)) {
+          errors.push(
+            `${source}:${index + 1}: pack '${pack}' is not product-scoped but names \`make ${target}\`, ` +
+              `which only one repository defines — say what the command IS instead`,
+          );
+        }
+      }
+    });
+  }
+  return errors;
+}