@techgoblin/gobstack 0.5.0-beta.7 → 0.6.0-alpha.1

package/CHANGELOG.md

@@ -3,6 +3,44 @@
 One line per released version. `goblin-install --upgrade` prints the delta between the
 version recorded in a target's `.goblin/installed.json` and the source `VERSION`.
 
+## 0.6.0-alpha.1
+
+The v2 breaking release: rules-first. The rules a repo is judged by move from a config file the
+installer generated into the file a new session already reads, the folder the engine is vendored
+into gets a name that cannot collide with the global one, and every command a reader could not
+reach is cut from the surface rather than shipped half-wired. Nothing here is additive — a repo
+on 0.5.x does not silently keep working through this version; run `gob init` again in the repo.
+
+- **`goblin.yaml` is gone. AGENTS.md frontmatter is the single source of truth.** The gates, the
+  bans enablement and the model mapping all read the frontmatter block of the root `AGENTS.md`
+  (flat `gate_<name>_cmd:` keys beside the prose a teammate reads anyway). There is no second
+  config file to drift out of sync with the prose, and the file a new session reads first is the
+  file the rules live in. `gob init` prints the agent brief plus a proposal schema and the agent
+  fills the frontmatter; `--write` installs the validated result.
+- **`.goblin/` is renamed `.gob/`.** The vendored engine payload (`.gob/bin/`,
+  `.gob/manifest/`, `.gob/installed.json`) sits one level deep under a short name, and the
+  global `~/.goblin` tree no longer shares a prefix with it.
+- **The CI lane is cut.** No shipped workflow file, no CI toggle in the config — the gate hook
+  and `gob verify` are the enforcement paths.
+- **The surface is six verbs: `init`, `map`, `verify`, `bans`, `mcp`, `uninstall`.** The dispatcher
+  refuses everything else with exit 2 — `doctor`, `audit`, `upgrade`, `emit`, `sync` and
+  `install` are unwired (their code is deleted or unreachable; see `docs/LIMITS.md` #54 for the
+  engine-dir decision the upgrade command used to serve). `gob init` replaces `gob install`
+  entirely.
+- **npx-first, no global install.** The documented entry is
+  `npx @techgoblin/gobstack init`; `uninstall` is the npm one-liner. Nothing asks for `-g`.
+- **Remedy per FAIL.** A `FAIL` row prints its one-line `remedy:` at the point of failure and
+  again under the summary payload, so a red run says what to do next without a docs trip. The
+  mascot sign-off is a GREEN-run line only: a red run ends on
+  `start with the first FAIL above — its remedy line says the fix.` — the verdict IS the FAIL
+  list, and mascot noise on the run's one actionable moment is noise.
+- **Framed for the new teammate.** The docs lead with what a person joining the repo reads
+  first (`AGENTS.md`, `HANDOFF.md`), not with the toolchain that maintains them.
+
+`VERSION`, `package.json` and all six `GOBLIN_*_VERSION` constants in `bin/` are this version.
+No id, verdict or matrix cell moved in this release; the counts the docs quote are the ones
+measured on this tree.
+
 ## 0.4.4
 
 The five findings an independent verification of 0.4.3 left open (AB3). The blocker is the species

package/README.md

@@ -1,141 +1,140 @@
 # gobstack
 
 **gobstack** (npm: [`@techgoblin/gobstack`](https://www.npmjs.com/package/@techgoblin/gobstack))
-installs an **executable rule manifest**, a set of **project-local skills**, and an
-**installer/verifier pair** into any project — so that an AI coding session never re-improvises,
-and a rule that cannot be checked is counted rather than asserted.
+installs an **executable rule manifest**, a **vendored verifier**, and an **AGENTS.md-frontmatter
+config** into any project — so that an AI coding session never re-improvises, and a rule that
+cannot be checked is counted rather than asserted.
 
-Install it from npm — globally; it is a CLI, not a library:
+Start here — `init` is the first verb, and it needs no global install:
 
-    npm install -g @techgoblin/gobstack@beta   # gives you the `gob` CLI (`goblin` remains as a legacy alias)
-    npx @techgoblin/gobstack@beta init         # or the one-shot: run the wizard, install nothing globally
+    npx @techgoblin/gobstack init        # the agent brief + proposal schema; --write installs it
 
-## Install
-
-**Global, not local.** gobstack is a CLI with zero runtime dependencies. Install it once per
-machine:
-
-    npm install -g @techgoblin/gobstack@beta
+or install the CLI globally (it is a CLI, not a library):
 
-or run a single command without installing:
+    npm install -g @techgoblin/gobstack  # gives you the `gob` CLI (`goblin` remains as a legacy alias)
 
-    npx @techgoblin/gobstack@beta init
-
-**Do NOT add it to an app project's `package.json`.** A `npm install @techgoblin/gobstack` (or a
-`package.json` dependency) inside your app pollutes the app's lockfile with a package the app
-never imports, and can fail resolution outright with `ERESOLVE` when the app's own peer
-dependencies disagree with npm's. If you see `ERESOLVE` after a local install, remove the
-dependency from `package.json` and install globally instead.
+## Install
 
-**The two-layer model.** The global install gives you the CLI only. `gob init` (or
-`gob install --target <dir> --class software`) then vendors a self-contained engine into the target
-repo under `.goblin/` — verifier, manifest, ban probes, skills, all of it. That second layer is
-why an initialized repo keeps working on machines with **no gobstack installed at all**: the
-engine lives in the repo, not in your `node_modules`, and `bash .goblin/bin/goblin-verify` (or a
-plain `git` + `bash` box) is the only runtime the repo's gate needs.
+**The v2 flow is `init`-first.** `gob init` prints an AGENT BRIEF — a structured prompt telling
+whichever agent is already running in the repo exactly what to scan (package.json, routes, tests,
+CI configs) and what to decide (class, branch, owner email, the first gate command) — plus the
+schema of the proposal file the agent writes back. `gob init --write <proposal>` validates the
+proposal and installs. The heuristic detector (`--heuristic`) is a fallback that appends
+pre-scanned hints to the brief; it never decides.
 
-Then, from any project:
+    npx @techgoblin/gobstack init              # print the brief + schema (the agent does the scan)
+    npx @techgoblin/gobstack init --write .gob-init-proposal.md --yes
+                                               # validate + install
 
-    gob install --target /path/to/repo --class software
+`--write` installs into the repo: AGENTS.md (a rendered body plus the `<!-- gob:begin --> …
+<!-- gob:end -->` config block in its frontmatter), `.gob/` (the vendored engine — verifier,
+manifest, ban probes), `HANDOFF.md`, the `checks/` scaffold and the `.gitignore` block. That
+vendored layer is why an initialized repo keeps working on machines with **no gobstack installed
+at all**: the engine lives in the repo, and `bash .gob/bin/goblin-verify` on a plain `git` +
+`bash` box is the only runtime the repo's gate needs.
 
 The installer writes only paths it records, hash-compares before writing, and prints `no-op` on a
 second run with the same arguments. It never overwrites `HANDOFF.md`, `AGENTS.md`, a `*-SPEC.md`,
-`reviews/`, the `.gitignore` block or `.goblin/goblin.yaml`. Full option list and the three kinds
+`reviews/`, or the `.gitignore` block. Full option list and the three kinds
 of file it manages: `docs/CONTRACTS.md`.
 
 A repo that already has its own `HANDOFF.md` exits 1 on the refusal. That is the contract, not a
 failure: reconcile the file rather than forcing over it — `docs/ADOPTION.md`.
 
-`--class` picks the preset: **software** (the default — shipped features, PRs, review gates),
+**The config is the AGENTS.md frontmatter.** There is no separate config file in v2: every knob
+the harness reads — class, branch, gates, ratchet, bans, replay, opt-outs — is a `key: value`
+line inside the `<!-- gob:begin --> … <!-- gob:end -->` marker block at the top of `AGENTS.md`.
+Edit it in place; the parser reads only that block, and the installer never rewrites it after the
+first install.
+
+**`class:` picks the preset**: **software** (the default — shipped features, PRs, review gates),
 **service** (backend jobs, config, unattended runs), **game** (playable builds, perf budgets),
 **research** (specs, replays, reference corpora) and **fleet** (config-of-the-agent repos).
 The single letters `A`–`E` are accepted aliases. What each preset turns on is the matrix in
-`docs/ADOPTION.md`; the older names still resolve (see `docs/CONTRACTS.md`).
+`docs/ADOPTION.md`.
 
 After installing, in this order:
 
     cd <target> && git add -A && git commit   # the install is a change like any other
-    gob verify                             # or .goblin/bin/goblin-verify, inside the target
-    gob sync --platform <p>                   # optional, per platform: the agent skills are an opt-in (gob emit is the same verb)
-    gob audit                              # once, deliberately: the ONLY network step (SC-07)
-
-**A default software-class install (no agent skills — those are `gob emit`'s job) verifies green —
-`38 passed, 0 failed, 11 advisory, 33 skipped`, exit 0 — once
-`HANDOFF.md` names a commit that exists. Before that edit the scaffold's `0000000` placeholder is
-the one expected red: `37 passed, 1 failed`, `HP-05`. Both numbers measured at the 0.5.0 neutral-first
-revision (see `docs/RECORD-NOTES.md`, V3);
-the run and the fix are step 2 of `docs/GUIDE.md`.**
-Thirty-three rows skip — the five skill rows (`SK-01`..`SK-04`, `AU-04`) skip on the `playbooks`
-opt-out a skills-free install records, then the not-yet rows (`HS-02` has no pinned pre-change
-commit yet, so the REPLAY is not provable;
-`AU-02` and `AU-03` have no report to audit; `SC-06`, `SC-07` and `SC-08` have no dependency
-manifest, no lockfile and no audit record to read; `PF-01` has no measured perf baseline;
-`BN-01`/`BN-02`/`BN-05` have no `src/` for a ban to read, and `BN-03` plus the four electron bans
-`BN-06`/`BN-07`/`BN-08`/`BN-09` are not in this class's `bans:` list (`bans: [BN-01, BN-02, BN-05]`),
-so they skip as *not enabled* rather than as *unread*; `FM-01`/`FM-02`/`VA-01`
-have no feature map and no declared `verify_doctor:` yet; `RC-01`..`RC-04` have no reference corpus
-declared and no lab `manifests/` to read; and `JG-01` with `LP-01`..`LP-05`
-have no loop record, because no loop has run in this repo yet). **Two** rows do **not** skip: `PG-05`
-and `PG-06`, the CI lane's. This class installs `.github/workflows/goblin-gate.yml`, so the two of
-them read it and pass. Two, not four — the four electron bans named above are among the skips. Two of
-the eleven advisories
-are new with the judge lane: `JG-02` reports that the judge lane resolves to no profile on this
-fleet (it prints the one-line remedy and never fails a repo for a fleet's routing), and `JG-03`
-is the counted row the advisory ceiling had left for it. The parts
+    .gob/bin/goblin-verify                    # or gob verify, anywhere in the target
+
+**A default software-class install verifies green — `37 passed, 0 failed, 11 advisory,
+34 skipped`, exit 0 — once `HANDOFF.md` names a commit that exists. Before that edit the
+scaffold's `0000000` placeholder is the one expected red.** Thirty-four rows skip: the five
+skill rows (`SK-01`..`SK-04`, `AU-04`) skip on the `playbooks` opt-out a skills-free install
+records, then the not-yet rows (`HS-02` has no pinned pre-change commit yet; `AU-02`/`AU-03`
+have no report to audit; `SC-06`–`SC-08` have no dependency manifest to read; `PF-01` has no
+measured perf baseline; `BN-01`/`BN-02`/`BN-05` have no `src/` for a ban to read, and the four
+electron bans `BN-06`–`BN-09` are not in this class's `bans:` list
+(`bans: [BN-01, BN-02, BN-05]`), so they skip as *not enabled* rather than as *unread*;
+`FM-01`/`FM-02`/`VA-01` have no feature map; `RC-01`..`RC-04` have no reference corpus; `JG-01`
+with `LP-01`..`LP-05` have no loop record, because no loop has run in this repo yet; and
+`PG-06` — v2 installs no CI, so there is no workflow for its probe to read). The parts
 that only a round can produce — a first review note, a gate that is not the shipped floor — pass
 *vacuously* rather than failing, and `P8` (`goblin-bootstrap`) still walks them as work to do.
 The measurement and the vacuous-pass reading are in `docs/CONTRACTS.md`.
 
 ## The `gob` CLI
 
+The v2 surface is six verbs. Everything else — audit, doctor, emit/sync, upgrade, install —
+is unwired in this alpha: the shim refuses the verb by name and prints the usage.
+
 | command | what it does |
 |---|---|
+| `gob init` | the first step: print the AGENT BRIEF + proposal schema; `--heuristic` appends scanned hints as a fallback; `--write <proposal> [--yes]` validates the proposal and installs; `--target <dir>` aims elsewhere; `--dry-run` validates without writing |
+| `gob map` | the feature-map prompt + schema (`--heuristic [target]` runs the starter scanner); `--write <dir> [--force]` validates an agent-written map and installs it; never clobbers — an existing map refuses until `--force` |
 | `gob verify` | run the rule matrix against the current repo — `PASS`/`FAIL`/`SKIP` per row, exit 0 pass · 1 a check failed · 2 could not run · 3 the manifest is broken |
 | `gob bans` | run the ban list (per-pattern red lines over the source tree) |
-| `gob audit` | check recorded dependency claims against live advisory feeds — the only command that touches the network |
-| `gob install` | install the harness into a target repo: manifest, verifier, gates, HANDOFF — no agent skills (those are an opt-in: `gob sync --platform <p>`, or `--skills yes`); `--ci-gate yes|no` opts the CI lane in or out (default: the class decides) |
+| `gob mcp` | serve the harness to your coding agent over MCP stdio — three tools (`gob_verify`, `gob_map_status`, `gob_init_status`), local only, no SDK, no network |
 | `gob uninstall` | remove everything an install wrote, byte-exactly (`gob install --target <dir> --uninstall` is the same job) |
-| `gob upgrade` | migrate a repo to the shared global engine at `~/.goblin/engine` — 8 steps, two commits, one report |
-| `gob doctor` | one run across the platforms below: DETECTED / NOT-DETECTED / DRIFT per platform |
-| `gob emit` | write the skills + context block for one platform (`--scope project` or `global`); `--unshadow` removes a hermes project skill whose hash equals the source; `gob sync` is the same command under its friendlier name — both spellings work |
-| `gob sync` | the emit verb, renamed (wizard v2): same engine, same flags, same exit contract; `gob emit --help` and `gob sync --help` are byte-identical apart from the verb name |
-| `gob init` | the first-run wizard: detect → class → identity → health check → ci → sync → done, one screen per question; every question has a flag (`--class software --branch main --email a@b.c --gate 'cmd' --emit hermes`), so CI runs it with zero prompts; the ci step defaults to no — nothing under .github/ unless you opt in (`--ci-gate yes|no` overrides); `--no-verify` skips the closing health check; `--dry-run` prints the plan and writes nothing |
 
 `goblin` remains as a legacy alias for every command above — existing scripts keep working, but
 new commands and docs use `gob`.
 
-## Platforms
+## Register the harness with your agent (MCP)
 
-`gob emit` and `gob doctor` cover seven agent platforms, each detected via its own anchor:
+`gob mcp` is a **local MCP tool server**: JSON-RPC 2.0 over stdin/stdout, hand-rolled, no SDK
+and no network — it calls no API and spawns nothing but the repo's vendored verifier. It
+exposes three tools:
 
-| platform | what emit writes there |
+| tool | what it does |
 |---|---|
-| `claude` | skills + context block under `~/.claude` (or `--target`'s project scope) |
-| `hermes` | skills + context block under `~/.hermes` |
-| `copilot` | skills + context block under `~/.copilot` |
-| `cursor` | skills + context block under `~/.cursor` |
-| `opencode` | skills + context block under `~/.config/opencode` |
-| `codex` | skills + context block under `~/.codex` (partial: some commands blocked, `docs/LIMITS.md` #47) |
-| `gemini` | skills + context block under `~/.gemini` (partial: some commands blocked, `docs/LIMITS.md` #47) |
-
-One run of `gob emit --platform <p> --scope project` writes the skills and the context block a
-session of that platform reads; `--scope global` writes to the machine-level anchor. `--dry-run`
-prints the full write plan first.
-
-**Agent skills are opt-in.** A `gob install` writes the neutral harness only — `.goblin/`,
-`HANDOFF.md`, `AGENTS.md`, the checks and the `.gitignore` block; no skills directory, and no
-files belonging to any coding agent. The guided path is `gob init`'s sync screen; the one-shot
-path is `gob sync --platform <p>` after installing (`gob emit --platform <p>` is the same
-command under its original name — both work byte-identically). Repos whose install predates the
-opt-in default keep their skills through `gob upgrade` (the install record names them; only an
-explicit `--skills no`, or `--uninstall`, removes them).
+| `gob_verify` | run the project discipline gate in the repo the agent has open — `PASS`/`FAIL` per row, each FAIL carrying its remedy line. The description is the trigger: *call this before reporting any coding task complete* |
+| `gob_map_status` | read `features/` and the `feature_map:` key: which features exist, their `verified:` dates, and whether each declared entry path still resolves (the read-only half of `FM-02`) |
+| `gob_init_status` | is this repo under the harness — the `AGENTS.md` gob block, its class and gates, the engine version |
+
+Register it one of three ways:
+
+    # 1. per-user, Claude Code:
+    claude mcp add gob -- npx -y @techgoblin/gobstack mcp
+
+    # 2. per-user, Cursor — .cursor/mcp.json:
+    { "mcpServers": { "gob": { "command": "npx", "args": ["-y", "@techgoblin/gobstack", "mcp"] } } }
+
+    # 3. repo-distributed (Claude Code and Cursor auto-detect a repo-root .mcp.json):
+    gob init --with-mcp-config
+
+`--with-mcp-config` is ask-once: it writes the generated `.mcp.json`, states a no-op if the
+generated bytes are already there, and **refuses** a file that carries anything else — a
+registration you customized is the project's, never overwritten. `gob uninstall` removes it
+only when it still matches the generated bytes, by the same hash-compare the decision records
+get.
+
+## Agent skills
+
+**Agent skills are opt-in, and the per-platform emit surface returns in a later alpha.** An
+`init --write` installs the neutral harness only — `.gob/`, `AGENTS.md`, `HANDOFF.md`, the
+checks and the `.gitignore` block; no skills directory, and no files belonging to any coding
+agent. The proposal schema's `sync_platforms:` line is where the platform choice is recorded
+when that surface lands.
 
 ## What it is not
 
 Not a rules document (every rule carries a runnable check or is explicitly counted as
 advisory). Not a Cursor-plugin port (`subagent_type`, `/loop`, `/goal`, cloud agents and
 vendored plugin paths do not exist here). Not a replacement for a project standard — it
-**references** one by path and pins its hash, and carries none of its text.
+**references** one by path and pins its hash, and carries none of its text. And in this alpha,
+not a CI product: nothing is installed under `.github/`, ever.
 
 ## Read this on GitHub
 
@@ -145,7 +144,7 @@ below is the reference material the guide points into, so the two do not compete
 
 | file | what it decides |
 |---|---|
-| `docs/GUIDE.md` | **read this first**: the first week, in order — install, the first verify, the REPLAY habit |
+| `docs/GUIDE.md` | **read this first**: the first week, in order — init, the first verify, the REPLAY habit |
 | `docs/DESIGN.md` | the thesis, the three load-bearing decisions, and every rejected alternative |
 | `docs/FLOWS.md` | the 15 playbooks, with the 11 cuts and a reason for each |
 | `docs/GUARDRAILS.md` | the security and perf rows (`SC-01`..`SC-09`, `PF-01`), the rung ladder, and what they cannot see |
@@ -154,10 +153,9 @@ below is the reference material the guide points into, so the two do not compete
 | `docs/CONTRACTS.md` | the installer/verifier interface, exit codes, idempotency, uninstall |
 | `docs/INTEGRATION.md` | the board, cron, the skills precedence order, the referenced standard |
 | `docs/RISKS.md` | the risk register, the advisory rows named, the non-goals |
-| `docs/CI.md` | the CI lane: what makes a workflow a gate, the four settings a repository cannot set, and the electron opt-in |
 | `docs/LOOP.md` | the judge role and the loop contract: what a goal-mode loop actually does, the record, and what neither can see |
 | `docs/RECORD-NOTES.md` | the wave codes the changelog and the matrix parentheticals use, one line each |
-| `docs/GLOSSARY.md` | every term of art in one table (rendered from the shipped `.goblin/manifest/glossary.tsv`) |
+| `docs/GLOSSARY.md` | every term of art in one table (rendered from the shipped `.gob/manifest/glossary.tsv`) |
 | `docs/ADOPTION.md` | the five classes, the preset matrix, the adoption order |
 | `docs/LIMITS.md` | where this is weaker than its sources, and what is unproven |
 
@@ -177,60 +175,51 @@ run · `3` the manifest is broken. Every run prints what it cannot see.
     bash tests/run-tests.sh
 
 Runs the source-scope rules (PR-01..PR-05) and the test scripts, including `t-verify-red.sh` —
-one control per target-scope row (172 over 82 target rows), each required to go RED and then
-restored, plus `t-audit.sh` for the SC-07 producer. **A verifier that only ever prints GREEN is a
-failure**, so that file is the one that matters most.
+one control per target-scope row (156 over 80 target rows), each required to go RED and then
+restored. **A verifier that only ever prints GREEN is a failure**, so that file is the one that
+matters most.
 
 ## Uninstall
 
-gobstack lives in three layers. Each is removed by its own command, and removing one never
+gobstack lives in layers. Each is removed by its own command, and removing one never
 touches the others.
 
 **(a) The global CLI** — the npm package itself:
 
     npm uninstall -g @techgoblin/gobstack
 
-This removes the `gob` (and legacy `goblin`) commands from the machine and nothing else: no project, no
-repo, no `.goblin/` directory anywhere is touched. Repos you already initialized keep working
-fully — the engine is vendored into each repo's `.goblin/`, so the CLI's absence removes no
-capability (you lose the installer/upgrade/emit entry points, not the gate; see layer (c) for
-the machine-level skills the CLI wrote).
+This removes the `gob` (and legacy `goblin`) commands from the machine and nothing else: no
+project, no repo, no `.gob/` directory anywhere is touched. Repos you already initialized keep
+working fully — the engine is vendored into each repo's `.gob/`, so the CLI's absence removes no
+capability.
 
-**(b) A project's harness** — the `.goblin/` tree an install created in one repo:
+**(b) A project's harness** — the `.gob/` tree an install created in one repo:
 
     gob uninstall --target .
 
 (equivalently `gob install --target . --uninstall` — through the legacy alias, spell it `goblin`
 instead of `gob`). The uninstall is **byte-exact**: it removes exactly the files
 `installed.json` records — hash-compared preimages, so a file you edited after install is
-reported and kept, never clobbered — then every directory that leaves empty. After it, the repo
-has zero goblin files; only the project's own record (`HANDOFF.md`, `AGENTS.md`, `reviews/`, the
-`.gitignore` block) survives, because that is the project's, not the harness's to delete. And
-because the engine is vendored, the repo needs no gobstack installed to run this — it is
-self-contained until the moment you remove it.
-
-**(c) Global agent skills** — the machine-level skills an `emit --scope global` wrote outside any
-repo:
-
-    gob emit --undo --platform <p> --scope global
-
-(`--undo` is the same byte-exact reversal as `--uninstall`, under its friendlier name). By hand,
-the same job is deleting the platform's anchor entries: `~/.claude/skills/goblin-*` (and the
-equivalents under `~/.hermes`, `~/.copilot`, `~/.cursor`, `~/.config/opencode`, `~/.codex`,
-`~/.gemini` — `gob doctor` lists which platforms were detected).
+reported and kept, never clobbered — then every directory that leaves empty, and it strips the
+`<!-- gob:begin --> … <!-- gob:end -->` block out of `AGENTS.md` (the body prose stays). After
+it, the repo has zero harness files; only the project's own record (`HANDOFF.md`, `AGENTS.md`'s
+prose, `reviews/`, the `.gitignore` block) survives, because that is the project's, not the
+harness's to delete. And because the engine is vendored, the repo needs no gobstack installed to
+run this — it is self-contained until the moment you remove it.
 
-The short version, for a full removal from a machine and its repos: (c) first, then (b) in each
-initialized repo, then (a).
+The short version, for a full removal from a machine and its repos: (b) in each initialized
+repo, then (a).
 
 ## Re-pin the referenced standard
 
     gob install --target <dir> --re-pin
 
-`practice_sha256:` pins the referenced standard and `IN-02` re-checks it, so editing that standard
-— a legitimate, intended edit — reds `IN-02` in every installed repo. `--re-pin` re-records that
-one line and prints the old and new hash; `IN-02` then reports `practice pin ok`. Nothing re-pins
-automatically, not even `--upgrade`, and the `practice EDITED` failure prints this command. The
-whole contract: `docs/CONTRACTS.md`, "An edited standard is not a dead end".
+`practice_sha256:` in the AGENTS.md gob block pins the referenced standard and `IN-02`
+re-checks it, so editing that standard — a legitimate, intended edit — reds `IN-02` in every
+installed repo. `--re-pin` re-records that one line and prints the old and new hash; `IN-02`
+then reports `practice pin ok`. Nothing re-pins automatically, not even a re-install, and the
+`practice EDITED` failure prints this command. The whole contract: `docs/CONTRACTS.md`,
+"An edited standard is not a dead end".
 
 ## Dependencies
 

package/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0-alpha.1

package/automations/drift-audit.sh

@@ -72,17 +72,17 @@ DETAIL=""
 for d in $ROOT_GLOB; do
   [ -d "$d" ] || continue
   TARGETS=$((TARGETS + 1))
-  if [ ! -f "$d/.goblin/goblin.yaml" ]; then
+  if [ ! -f "$d/.gob/goblin.yaml" ] && [ ! -f "$d/AGENTS.md" ]; then
     SKIPPED="$SKIPPED $(basename "$d")"
     continue
   fi
-  if [ ! -f "$d/.goblin/bin/goblin-verify" ]; then
+  if [ ! -f "$d/.gob/bin/goblin-verify" ]; then
     SKIPPED="$SKIPPED $(basename "$d")(no-verifier)"
     continue
   fi
   # --only IN-02,HP-05 rather than a full run: both are builtins that write no runtime state,
   # so the audit never edits the tree it is auditing (design rule 2 of the honesty section).
-  OUT=$( cd "$d" && bash .goblin/bin/goblin-verify --json --only IN-02,HP-05 2>/dev/null )
+  OUT=$( cd "$d" && bash .gob/bin/goblin-verify --json --only IN-02,HP-05 2>/dev/null )
   RC=$?
   case "$RC" in
     0|1) ;;
@@ -91,7 +91,7 @@ for d in $ROOT_GLOB; do
   FAILED=$(printf '%s' "$OUT" | grep -o '"id":"[A-Z][A-Z0-9-]*","status":"FAIL"' | sed 's/"id":"//; s/","status":"FAIL"//')
   for id in $FAILED; do
     DRIFT="$DRIFT $d/$id"
-    DETAIL="$DETAIL$d	$id	cd $d && bash .goblin/bin/goblin-verify --only $id
+    DETAIL="$DETAIL$d	$id	cd $d && bash .gob/bin/goblin-verify --only $id
 "
   done
 done

package/bans/layer-check.sh

@@ -10,16 +10,18 @@
 
 set -uo pipefail
 SELF_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-ROOT=$(cd "$SELF_DIR/../.." && pwd)          # .goblin/bans/ -> repo root
-CONFIG="$ROOT/.goblin/goblin.yaml"
+ROOT=$(cd "$SELF_DIR/../.." && pwd)          # .gob/bans/ -> repo root
+CONFIG="$ROOT/AGENTS.md"
 [ -f "$CONFIG" ] || { echo "layer-check: no $CONFIG" >&2; exit 2; }
 
-layers=$(awk '
-  $0 ~ /^layers:[[:space:]]*$/ { inb = 1; next }
-  inb && /^[^ ]/ { inb = 0 }
-  inb && /^  - / { v = $0; sub(/^  - /, "", v); print v }
-' "$CONFIG")
-[ -n "$layers" ] || { echo "no layers declared in $CONFIG - declare a from/to pair to turn BN-05 on"; exit 3; }
+# v2 config shape: the `layers:` flat key INSIDE the `<!-- gob:begin --> ... <!-- gob:end -->`
+# marker block, one `[from1 to1, from2 to2]` array (each item a from/to pair). The block-bounded
+# sed is the same reader g_agents_gates uses in goblin-lib.sh; a line outside the markers is
+# prose and is never read.
+block=$(sed -n "/^<!-- gob:begin/,/^<!-- gob:end/p" "$CONFIG" | sed '1d;$d')
+layers=$(printf '%s\n' "$block" | sed -n 's/^layers:[[:space:]]*//p' | tr ',' '\n' \
+  | sed 's/^[[:space:]]*//; s/[[:space:]]*$//; s/^\[//; s/\]$//' | grep -v '^$' || true)
+[ -n "$layers" ] || { echo "no layers declared in $CONFIG - declare layers: in the gob block to turn BN-05 on"; exit 3; }
 
 bad=""
 while read -r from to; do