riskrails 3.2.2 → 4.0.1

package/skills/rr-setup/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: rr-setup
-description: Set up and maintain the .ai/ layer of an existing production codebase. With no flag, scaffold docs/sdlc/, the runtime directory and .ai/, survey the code into .ai/project/ (light or full), write the Verification commands, the weight table's project entries and the constitution — read-only towards application code. --update brings a project's files up to the installed plugin (migrations, three-way merges, the managed block); --adopt moves a foreign AI-tool structure (Spec Kit, Kiro, Cursor, Copilot, AI-DLC, an oversized CLAUDE.md or AGENTS.md) into this layout with nothing lost; --audit scores the repository against the twelve plays and writes docs/ai-sdlc-adoption-plan.md. Use on "/rr-setup", "set up this project", "analyse this project for AI work", "update the rules", "обнови правилата", "audit our AI setup", or when /rr-status says the project is behind.
-argument-hint: [--survey light|full] | --update [--apply] | --adopt [--mode coexist] | --audit [context]
+description: Set up and maintain the .ai/ layer of an existing production codebase. With no flag, scaffold docs/sdlc/, the runtime directory and .ai/, survey the code into .ai/project/ (light or full), write the Verification commands, the weight table's project entries and the constitution — read-only towards application code. --update regenerates a project's files from the installed plugin (a copy that is a shipped version is replaced, an edited one waits for the human, the project's own files are kept); run it right after installing a new riskrails; --audit scores the repository against the twelve plays and writes docs/ai-sdlc-adoption-plan.md. Use on "/rr-setup", "set up this project", "analyse this project for AI work", "update the rules", "обнови правилата", "audit our AI setup", or when /rr-status says the project is behind.
+argument-hint: [--survey light|full] | --update [--apply] | --audit [context]
 ---
 
 # /rr-setup $ARGUMENTS
@@ -17,7 +17,7 @@ UPDATE="python3 $AI_HOME/skills/project-update/update.py $PWD"
 SETUP="python3 $AI_HOME/skills/rr-setup/setup.py"
 ```
 
-`--update`, `--adopt` and `--audit` go to their sections below; anything else
+`--update` and `--audit` go to their sections below; anything else
 is **Setup**. In every mode: no application code changes — not a rename, not a
 formatting fix. Problems you find are written down, never fixed. Never read
 `.env`, secrets, dumps or production logs. Do not commit; suggest the `git add`.
@@ -90,13 +90,13 @@ formatting fix. Problems you find are written down, never fixed. Never read
    that `.claude/settings.json` keeps `"enableAllProjectMcpServers": false` and
    that each server in a checked-in `.mcp.json` sits in `enabledMcpjsonServers`
    only if it earned it, else in `disabledMcpjsonServers`; say what you found.
-6. **Weight table.** Propose this codebase's own paths for
-   `.ai/policies/weight.json`: `domain.modules` (money, identity, personal
-   data), `domain.customer_visible`, `scope.hot_paths`,
+6. **Weight table.** The plugin ships the table; this codebase's own paths go in
+   `.ai/policies/weight.project.json`, laid over it: `domain.modules` (money,
+   identity, personal data), `domain.customer_visible`, `scope.hot_paths`,
    `reversibility.needs_step` and `irreversible`, and one or two `examples` per
-   mode. The JSON is the human's to edit (the path guard refuses yours); once
-   they have, `$STATE weight --mirror` regenerates `weight.md`. The thresholds
-   are not this skill's to move.
+   mode. The JSON is the human's to edit (the path guard refuses yours);
+   `--update` renders `weight.md` from the table and the overlay. The
+   thresholds are not this skill's to move.
 7. **Constitution.** Fill `docs/sdlc/constitution.md`: C1–C5 ship prefilled;
    C6 onwards are one line each, drawn from what the code and tests already
    enforce. Leave a slot empty rather than write a platitude; at most fifteen.
@@ -108,7 +108,7 @@ formatting fix. Problems you find are written down, never fixed. Never read
    security observations, missing documentation, areas agents must not touch
    casually, the weight-table entries you chose, recommended next improvements —
    recommendations only, none implemented. When the survey found a toolbox,
-   offer **--adopt**'s own-toolbox path.
+   name each toolbox item the project keeps using; they stay where they are.
 9. **Report.** Files created (a tree from the scaffold output), surprising
    findings, the modes and what puts a change in each, the safety restrictions
    in force (hooks versus policy), the tooling the workflows reuse, assumptions,
@@ -120,27 +120,39 @@ formatting fix. Problems you find are written down, never fixed. Never read
 
 ## --update
 
-The script does the update; you show it, confirm what is owed, and merge what
-it cannot.
+The script regenerates; you show it, confirm what is owed, and merge what it
+cannot. It converts nothing but the one split. A tree that still holds an old
+shape it detects (the pre-3.4b task state without `state.json`, the risk-tier
+policy without a weight table, a pre-3.4b block marker) is refused with `KEPT_UNREADABLE` (exit 6); a
+project last updated before 3.1.0 goes through `npx riskrails@3.1.0` first. Run it right after a new
+riskrails is installed: until then the project's old shapes are not read.
 
 1. `$STATE status`: with a task in flight, say that updating policies mid-task
    can change what the rest of it needs, and ask whether to finish it first.
 2. `$UPDATE` — the dry run; show it as is. Up to date and no hint: say so, stop.
-   `schema N -> M` means migrations run first; `[NNNN]` marks their lines; a
-   `move` carries edits to the new path and keeps the original under
-   `.ai/reports/project-update-<date>/`; `delete?` is a proposal (step 4).
-3. Lines marked `policy` change `.ai/policies/*.json`, which humans own: explain
-   each in one plain sentence and ask, unless `$ARGUMENTS` holds `--apply`.
+   A `regenerate` is a file that matches a version the plugin once shipped and is
+   replaced; a `regenerate?` or `delete?` is a proposal for the human (step 4); a
+   `create` is a file the project lacks. A project that still has the mixed
+   `testing.md` and `weight.json` gets `verification.md` and `weight.project.json`
+   split out of them once.
+3. A `split` row writes `verification.md` or `weight.project.json`, which humans
+   own from then on: say in one plain sentence what it carries out of
+   `testing.md` or `weight.json`, and ask, unless `$ARGUMENTS` holds `--apply`.
 4. `$UPDATE --apply`. Exit 3 stopped on a changed, non-regular or unwritable
    file and names it; nothing after it was written — run the dry run again.
-   **A `delete?` is the human's.** Never pass `--confirm-delete` or `--confirm-cleanup`, not even with
+   Exit 6 (`KEPT_UNREADABLE`): a file the update keeps cannot be read; nothing was
+   written — name it, the human fixes or removes it, then run again.
+   **A `regenerate?` and a `delete?` are the human's.** Never pass `--confirm-delete` or `--confirm-cleanup`, not even with
    `--apply`. Give them, with `$AI_HOME` and `$PWD` substituted, for their own
    terminal (the `!` prefix is refused):
    `python3 "<home>/skills/project-update/update.py" "<project>" --apply --confirm-delete "<your name>"`.
-   The schema stays put until it is settled — that command, or deleting the
-   file by hand; there is no third way. Two kinds are housekeeping, not
-   migrations: `[sdlc]` — an unedited `docs/sdlc/*/TEMPLATE.md`, which the plugin
-   now supplies (an edited one stays as the project's override); `[cleanup]` —
+   Exit 5 (`CONFIRM_REFUSED`) means an agent session ran it; it wrote nothing.
+   Every file replaced or deleted that way is first copied under
+   `.ai/reports/project-update-<date>/original/`. Two kinds are housekeeping:
+   `[rules]` — every rule source `.ai/rules/<slug>.md` (an update does not keep
+   them; confirming deletes the source and its rendered blocks with it) and a
+   rendered rule file whose source is gone or no longer sets `paths:`, both
+   settled by `--confirm-delete`; `[cleanup]` —
    the `*.log` files of closed tasks, and the report and log files of an
    abandoned task (its `state.json` stays) or of one unclosed for more than seven
    days (never the task in flight; and none when `.ai/state/state.json` is unreadable).
@@ -151,16 +163,15 @@ it cannot.
    commit `.ai/` first (the hint says so), and an `original/` copy is kept as for any
    other deletion. They have their own command, the human's too, never passed by the agent:
    `python3 "<home>/skills/project-update/update.py" "<project>" --apply --confirm-cleanup "<your name>"`.
-   Show both groups as printed. For 0006 (shared files) the order is:
-   `install.sh` for every runtime used, commit `.ai/`, read the `delete?` list,
-   then the command with no task in flight. Rollback is git:
+   Show both groups as printed. Rollback is git:
    `git restore --source=<commit before> --staged --worktree -- .ai`, before
    the plugin itself is rolled back.
-5. A `conflict` line: the project file was edited here and changed upstream.
-   Markdown, or the managed block (inside the markers only): read both, keep
-   everything project-specific, take the plugin's rules and structure, edit the
-   project file, delete the copy. A JSON policy: show both values for each
-   listed path and say which the plugin expects and why; the human edits it.
+5. A `regenerate?` row: the project edited a file the plugin generates. Read
+   its reason; anything project-specific in it belongs in a file the update keeps
+   (`.ai/project/`, `weight.project.json`, `verification.md`, the instruction
+   file outside the managed block — not `.ai/rules/`, whose sources are `[rules]`
+   rows too) — say where, the human moves it,
+   then confirms. Never edit the generated file to dodge the row.
 6. Hints. `verify_command is empty`: show `$SETUP survey`'s proposal, ask for
    the one command and what a green run ends with, write it with
    `$SETUP verify --set`, and fill the rest of the Verification block. `the managed block is N B`:
@@ -169,8 +180,7 @@ it cannot.
    fifteen principles or 4096 B: offer to move policy into `.ai/policies/`.
    `that rule is not rendered`: name the `.ai/rules/` file and what it lacks
    (`paths:` and a body). `overrides the plugin's shared copy`: offer to diff
-   each and delete those that add nothing. `foreign structure detected`: offer
-   **--adopt**. `tracked by git but ignored`: show the line as printed and give
+   each and delete those that add nothing. `tracked by git but ignored`: show the line as printed and give
    the human the command it prints, exactly as printed, plus a commit, for their
    own terminal (never rebuilt from the path; only the xargs form untracks every
    such file under `.ai/state`, a printed `rm --cached -- <path>` one file; a
@@ -180,55 +190,6 @@ it cannot.
    and what is the human's. Suggest `git add -A .ai docs/sdlc .gitignore` plus
    the runtime directories and instruction files.
 
-## --adopt
-
-**A project's own toolbox** — its `.claude/` skills, commands, rules, agents
-and hooks, `.codex/*`, `bin/*.sh`, Makefile targets — is production behaviour
-(C1), not a foreign structure: it is inventoried in place, never copied or
-moved. `$SETUP adopt` shows `.ai/policies/toolbox.md` (one line per item: link,
-purpose, KNOWN FACT `file:line` or UNKNOWN) and the router rows it appends to
-`.ai/AGENTS.md` — one per skill or command, naming its job and its `/<name>`. A
-project hook doing a plugin guard's job is kept and noted; a guard with none is
-reported. Ask "apply?", then `$SETUP adopt --apply`; it is idempotent. Exit 3:
-`toolbox.md` differs from the inventory (a human edited it) — show both, never
-overwrite. A foreign tool's structure, below, can be present as well.
-
-Every command is `$UPDATE --adopt …`, with `--mode coexist` on each when the team
-still uses the other tool (router rows only, nothing moves). Exit 5
-`ADOPT_REFUSED`: show the first line and stop. Exit 2: the routing table or a
-migration could not be read (reason on stderr, prefixed `project-update:`),
-nothing written. Exit 4 `ADOPT_INCOMPLETE`:
-`unmapped` files and a `split?` are yours to settle, then dry-run again; a
-`conflict` or a check `FAIL` left after that is the human's — never edit a
-destination or a source to make it pass.
-
-1. Preconditions: no task in flight (`$STATE status`), `git status` clean,
-   `$UPDATE --check` exits 0. Otherwise stop and say which failed.
-2. `$UPDATE --adopt`; show it as is.
-3. Each `unmapped` file: ask the human (drop with a reason, or copy to a named
-   destination) and write the answers to `.ai/reports/adopt-<date>/decisions.json`
-   as `{"version": 1, "unmapped": {"<path>": {"action": "drop", "why": "…"}}}`.
-   A glob key settles a directory (`drop` or `ignore` only); an exact path wins
-   over a glob, a longer glob over a shorter one.
-4. A `split?` (an instruction file too large to keep): on a `pro` or `plus` plan
-   (`jq -r .plan "$AI_HOME/riskrails/profile.json"`), when that fails, or
-   under `AI_UNATTENDED`, use `--split fallback` — every line outside the managed
-   block moves verbatim to `.ai/policies/adopted/`. Otherwise run
-   `--split-request` and write the proposal yourself, once, to the `proposal`
-   path the request names: line ranges, destinations from `allowed_dest`,
-   headings from its `outline` — never text (the tool refuses that). A proposal
-   for the same file sha is reused.
-5. `$UPDATE --adopt --diff`; show it and ask "apply?".
-6. `$UPDATE --adopt --apply` (with `--split fallback` if step 4 chose it); show
-   the two `check` lines and read out each `no-dangling` warning. On a FAIL read
-   `dropped.jsonl`, amend the proposal or decisions, run again.
-7. Point at `.ai/reports/adopt-<date>/report.md`; suggest `git add` of the new
-   structure and the report directory, and a commit.
-8. Cleanup is the human's: show `$UPDATE --adopt --cleanup`, then give the full
-   command with both paths absolute for their own terminal —
-   `python3 "<home>/skills/project-update/update.py" "<project>" --adopt --cleanup --apply --confirm-delete "<your name>"`.
-   Setting `AI_UNATTENDED` to pass it is the same act as typing their name.
-
 ## --audit
 
 The only file written is `docs/ai-sdlc-adoption-plan.md`; everything else is

package/skills/rr-setup/scaffold_ai.py

@@ -27,8 +27,9 @@ import sys
 NAME = "scaffold-ai"
 # The directory the shell script ran from: templates and the runtime it was installed for.
 HERE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "ai-init"))
+SHIPPED_WEIGHT = ".ai/policies/weight.json"
 RUNTIMES = ("claude", "codex", "gemini", "junie")
-BLOCK = re.compile(rb"<!-- (riskrails|claude-agentic|[Cc]odex-agentic):start -->")
+BLOCK = re.compile(rb"<!-- riskrails:start -->")
 
 
 class Exit(Exception):
@@ -212,15 +213,14 @@ def main(argv):
         root = stdin_cwd()
     root = logical_cd(root or logical_pwd())
     project = os.fsencode("/" if root == "/" else os.path.basename(root))
-    tpl = env("RISKRAILS_TEMPLATES") or env("CLAUDE_AGENTIC_TEMPLATES") or os.path.join(HERE, "templates")
+    tpl = env("RISKRAILS_TEMPLATES") or os.path.join(HERE, "templates")
     if not os.path.isdir(os.path.join(tpl, ".ai")):
         raise Exit(1, "%s: templates not found at %s (run riskrails/install.sh)" % (NAME, tpl))
     on = runtimes(runtime, root)
     created = []
 
     # A project that already has .ai/ carries a schema version this scaffold must not
-    # invent: writing .ai/VERSION here would tell /project-update that every migration
-    # has already run. Only a fresh tree starts at the shipped schema.
+    # invent: only a fresh tree starts at the shipped schema.
     had_ai = os.path.isdir(os.path.join(root, ".ai"))
 
     # Copy the .ai/ tree, file by file, skipping anything that already exists.
@@ -231,6 +231,8 @@ def main(argv):
         dst = os.path.join(root, rel)
         if os.path.exists(dst) or (rel == ".ai/VERSION" and had_ai):
             continue
+        if rel == SHIPPED_WEIGHT:   # A2: the plugin's table is read from the plugin, never copied
+            continue
         os.makedirs(os.path.dirname(dst), exist_ok=True)
         # cp: the source's permission bits, less the umask.
         shutil.copyfile(src, dst)
@@ -253,9 +255,7 @@ def main(argv):
         created.append(".gitignore (appended)")
 
     # The instruction file: create a minimal one if absent, then append the managed
-    # block once. An existing file is never replaced — only appended to. A legacy
-    # Codex-agentic pair is the block under its old name: nothing is appended beside
-    # it; /project-update renames it.
+    # block once. An existing file is never replaced — only appended to.
     def instruction_file(name, minimal, block):
         md = os.path.join(root, name)
         os.makedirs(os.path.dirname(md), exist_ok=True)

package/skills/rr-setup/setup.py

@@ -3,19 +3,17 @@
 and whether superpowers is on (spec R9, R28, SQ5, SQ12 variant B).
 
   setup.py survey [--root DIR]              the toolbox, the proposed verify_command, the superpowers line
-  setup.py check  [--root DIR]              exit 1 VERIFY_COMMAND_MISSING unless testing.md names one
-  setup.py adopt  [--root DIR] [--apply]    .ai/policies/toolbox.md and router rows in .ai/AGENTS.md
-  setup.py verify [--root DIR] --set CMD    write verify_command into testing.md (after the human confirmed)
-
-survey and check write nothing. adopt is a dry run without --apply. The
-toolbox is production behaviour (C1): it is inventoried in place, with links,
-never copied or moved; what to inventory comes from the `own` section of
-skills/project-update/adopt-map.json, which update.py --adopt does not read.
+  setup.py check  [--root DIR]              exit 1 VERIFY_COMMAND_MISSING unless verification.md names one
+  setup.py verify [--root DIR] --set CMD    write verify_command into verification.md (after the human confirmed)
+
+survey and check write nothing. The toolbox is production behaviour (C1): it is
+inventoried in place, never copied or moved; what to inventory is the constants
+FOREIGN_ROOTS and OWN_* below.
 The enabledPlugins line is printed, never written: .claude/settings.json is the
 human's.
 
-Exit codes: 0 done; 1 VERIFY_COMMAND_MISSING; 2 usage or an unreadable table;
-3 refused (a file exists and differs, or the line is already set).
+Exit codes: 0 done; 1 VERIFY_COMMAND_MISSING; 2 usage;
+3 refused (the line is already set).
 """
 import argparse
 import json
@@ -25,10 +23,7 @@ import shutil
 import sys
 
 HERE = os.path.dirname(os.path.abspath(__file__))
-MAP_FILE = os.path.join(os.path.dirname(HERE), "project-update", "adopt-map.json")
-TESTING = os.path.join(".ai", "policies", "testing.md")
-TOOLBOX = os.path.join(".ai", "policies", "toolbox.md")
-ROUTER_FILE = os.path.join(".ai", "AGENTS.md")
+VERIFICATION = os.path.join(".ai", "policies", "verification.md")
 SUPERPOWERS_KEY = "superpowers@superpowers-marketplace"
 SKIP_DIRS = {".git", ".ai", "vendor", "node_modules", "__pycache__", ".venv"}
 PURPOSE_MAX = 120
@@ -36,6 +31,72 @@ UNKNOWN = "UNKNOWN — no description and no leading comment"
 VERIFY_RE = re.compile(r"(?m)^verify_command:[ \t]*(.*)$")
 MAKE_TARGET_RE = re.compile(r"^([A-Za-z0-9][A-Za-z0-9_. \t-]*?)\s*:(?![=:])(.*)$")
 BLOCK_SCALAR_RE = re.compile(r"^[|>][-+]?$")
+# Paths a foreign AI tool owns (Spec Kit, Kiro, AI-DLC, Cursor, Copilot): no part of the project's own toolbox.
+FOREIGN_ROOTS = [
+    ".specify/",
+    "specs/",
+    ".claude/commands/speckit*",
+    ".claude/skills/speckit-*",
+    ".github/prompts/speckit*",
+    ".github/skills/speckit-*",
+    ".github/agents/speckit*",
+    ".codex/prompts/speckit*",
+    ".agents/skills/speckit-*",
+    ".gemini/commands/speckit*",
+    ".cursor/commands/speckit*",
+    ".cursor/skills/speckit-*",
+    ".kiro/",
+    "aidlc-docs/",
+    ".amazonq/rules/aws-aidlc-rules/",
+    ".amazonq/aws-aidlc-rule-details/",
+    ".cursorrules",
+    ".cursor/",
+    ".github/copilot-instructions.md",
+    ".github/instructions/",
+]
+# What `survey` inventories in place (SQ5): globs by kind, the guards' name words, the verify-command sources.
+OWN_INVENTORY = [
+    {"glob": ".claude/skills/*/SKILL.md", "kind": "skill", "router": "skill"},
+    {"glob": ".claude/commands/**/*.md", "kind": "command", "router": "command"},
+    {"glob": ".claude/rules/**/*.md", "kind": "rule"},
+    {"glob": ".claude/agents/*.md", "kind": "agent"},
+    {"glob": ".claude/hooks/*", "kind": "hook"},
+    {"glob": ".agents/skills/*/SKILL.md", "kind": "skill", "router": "skill"},
+    {"glob": ".codex/skills/*/SKILL.md", "kind": "skill", "router": "skill"},
+    {"glob": ".codex/prompts/*.md", "kind": "command", "router": "command"},
+    {"glob": ".codex/agents/*", "kind": "agent"},
+    {"glob": ".codex/hooks/*", "kind": "hook"},
+    {"glob": "bin/*.sh", "kind": "script"},
+    {"glob": "Makefile", "kind": "make"},
+]
+OWN_GUARDS = {
+    "ai-git-guard": [
+        "git",
+        "commit",
+        "push",
+        "merge"
+    ],
+    "ai-path-guard": [
+        "path",
+        "protect",
+        "protected",
+        "secret",
+        "secrets",
+        "dotenv"
+    ],
+    "ai-scope-guard": [
+        "scope"
+    ]
+}
+OWN_VERIFY = [
+    {"file": "Makefile", "make_target": ["test", "tests", "check", "qa"], "command": "make {name}"},
+    {"file": "composer.json", "script": ["test", "tests", "qa", "check"], "command": "composer {name}"},
+    {"file": "package.json", "script": ["test"], "command": "npm test"},
+    {"file": "bin/*.sh", "stem": ["test", "tests", "run-tests", "check"], "command": "bin/{name}.sh"},
+    {"file": "phpunit.xml.dist", "command": "vendor/bin/phpunit"},
+    {"file": "phpunit.xml", "command": "vendor/bin/phpunit"},
+    {"file": "pytest.ini", "command": "python3 -m pytest"},
+]
 
 
 def die(message, code=2):
@@ -60,20 +121,8 @@ def is_crlf(path):
         return False
 
 
-def load_map():
-    try:
-        with open(MAP_FILE, encoding="utf-8") as fh:
-            table = json.load(fh)
-    except (OSError, ValueError) as exc:
-        die("%s: %s" % (MAP_FILE, exc))
-    own = table.get("own")
-    if not isinstance(own, dict) or not isinstance(own.get("inventory"), list):
-        die("%s: needs an own section with an inventory list" % MAP_FILE)
-    return table
-
-
 def glob_re(pattern):
-    """The adopt.py dialect: `*` stops at `/`, `**` crosses it, `**/` may match nothing."""
+    """The glob dialect: `*` stops at `/`, `**` crosses it, `**/` may match nothing."""
     out, i = [], 0
     while i < len(pattern):
         if pattern.startswith("**/", i):
@@ -91,12 +140,6 @@ def glob_re(pattern):
     return re.compile("".join(out) + r"\Z")
 
 
-def foreign_roots(table):
-    """Paths a foreign tool owns (Spec Kit skills under .claude/ and the like):
-    update.py --adopt handles those, so they are no part of the own toolbox."""
-    return [r for spec in (table.get("tools") or {}).values() for r in spec.get("roots") or []]
-
-
 def under_root(path, root):
     if root.endswith("/"):
         return path.startswith(root)
@@ -218,13 +261,11 @@ def make_targets(root, rel="Makefile"):
 
 # ---------------------------------------------------------------- inventory
 
-def inventory(root, table):
+def inventory(root):
     """[{path, kind, line, purpose, name, router}] in table order, then path order."""
-    own = table["own"]
-    skip = foreign_roots(table)
-    paths = [p for p in walk(root) if not any(under_root(p, r) for r in skip)]
+    paths = [p for p in walk(root) if not any(under_root(p, r) for r in FOREIGN_ROOTS)]
     items, seen = [], set()
-    for row in own["inventory"]:
+    for row in OWN_INVENTORY:
         pattern = glob_re(row["glob"])
         for rel in paths:
             if rel in seen or not pattern.match(rel):
@@ -255,15 +296,14 @@ def command_name(rel, row):
     return os.path.basename(rel)
 
 
-def guard_overlap(items, table):
+def guard_overlap(items):
     """{guard: [hook paths doing its job]} by the hook file name's words."""
-    guards = table["own"].get("guards") or {}
-    found = {g: [] for g in guards}
+    found = {g: [] for g in OWN_GUARDS}
     for item in items:
         if item["kind"] != "hook":
             continue
         words = set(re.split(r"[^a-z0-9]+", os.path.basename(item["path"]).lower()))
-        for guard, keys in guards.items():
+        for guard, keys in OWN_GUARDS.items():
             if words & set(keys):
                 found[guard].append(item["path"])
     return found
@@ -271,10 +311,10 @@ def guard_overlap(items, table):
 
 # ------------------------------------------------------------------- verify
 
-def verify_candidates(root, table):
+def verify_candidates(root):
     """[(command, source)] in table order; the first is the proposal. Nothing is run."""
     out = []
-    for row in table["own"].get("verify") or []:
+    for row in OWN_VERIFY:
         pattern = row["file"]
         if "*" in pattern:
             regex = glob_re(pattern)
@@ -305,9 +345,9 @@ def verify_candidates(root, table):
 
 
 def verify_value(root):
-    """None when testing.md is missing or has no verify_command line; else the
+    """None when verification.md is missing or has no verify_command line; else the
     value, '' for the template's comment-only line (sensors.read_commands' rule)."""
-    text = read_text(os.path.join(root, TESTING))
+    text = read_text(os.path.join(root, VERIFICATION))
     if text is None:
         return None
     match = VERIFY_RE.search(text)
@@ -344,76 +384,6 @@ def superpowers_line(root):
             "\"enabledPlugins\": {\"%s\": true}" % (" (disabled in %s)" % where if where else "", SUPERPOWERS_KEY))
 
 
-# ----------------------------------------------------------------- rendering
-
-def toolbox_text(items, overlap):
-    lines = ["# Toolbox — this project's own skills, rules, agents, hooks and scripts", "",
-             "<!-- Written by `setup.py adopt` (/rr-setup --adopt). An inventory, not copies: each line links",
-             "     the file in place, which stays the source of truth (C1). Edit freely; adopt never",
-             "     overwrites a toolbox.md that differs from what it would write. -->", ""]
-    kinds = [("skill", "Skills"), ("command", "Commands"), ("rule", "Rules"), ("agent", "Agents"),
-             ("hook", "Hooks"), ("script", "Scripts"), ("make", "Make targets")]
-    for kind, title in kinds:
-        rows = [i for i in items if i["kind"] == kind]
-        if not rows:
-            continue
-        lines += ["## %s" % title, ""]
-        for item in rows:
-            label = item["name"] if kind in ("skill", "command", "make") else item["path"]
-            if kind in ("skill", "command"):
-                label = "/" + label
-            elif kind == "make":
-                label = "make " + label
-            purpose = ("%s — KNOWN FACT `%s:%d`" % (clip(item["purpose"]), item["path"], item["line"])
-                       if item["purpose"] else UNKNOWN)
-            lines.append("- [%s](../../%s) — %s" % (label, item["path"], purpose))
-        lines.append("")
-    if overlap:
-        lines += ["## Guards", ""]
-        for guard, paths in overlap.items():
-            if paths:
-                lines.append("- `%s`: this project's %s does the same job — kept; the plugin's guard is not "
-                             "installed into the project" % (guard, ", ".join("`%s`" % p for p in paths)))
-            else:
-                lines.append("- `%s`: no project hook does its job — the plugin's guard applies" % guard)
-        lines.append("")
-    if not items:
-        lines += ["No skills, rules, agents, hooks, scripts or Make targets found.", ""]
-    return "\n".join(lines)
-
-
-def router_rows(items):
-    """One row per `/name`: a skill mirrored under .claude/ and .agents/ or
-    .codex/, or a command of the same name, is one route (the first found)."""
-    rows = ["| this project's own skills, hooks, agents and scripts | policies/toolbox.md |"]
-    named = set()
-    for item in items:
-        if not item["router"] or item["name"] in named:
-            continue
-        named.add(item["name"])
-        job = clip(item["purpose"] or "the project's %s" % item["name"]).replace("|", "\\|")
-        rows.append("| %s | `/%s` |" % (job, item["name"]))
-    return rows
-
-
-def last_cell(row):
-    cells = row.rstrip().rstrip("|").rsplit("|", 1)
-    return cells[-1].strip() if len(cells) == 2 else None
-
-
-def add_rows(text, rows):
-    """Rows appended after the last table row; a row whose target cell is
-    already some table row's last cell is skipped, so a human's rewording of the
-    job survives and prose that mentions `/<name>` does not count."""
-    lines = text.split("\n")
-    last = max((i for i, l in enumerate(lines) if l.startswith("|")), default=None)
-    if last is None:
-        return None, []
-    targets = {last_cell(l) for l in lines if l.startswith("|")}
-    new = [r for r in rows if last_cell(r) not in targets]
-    return "\n".join(lines[:last + 1] + new + lines[last + 1:]), new
-
-
 def write(path, text):
     """In place through a symlink, keeping the file's mode and a CRLF file's
     line ends; a failed write leaves no temporary file behind."""
@@ -435,19 +405,18 @@ def write(path, text):
 # ----------------------------------------------------------------- commands
 
 def cmd_survey(root):
-    table = load_map()
-    items = inventory(root, table)
+    items = inventory(root)
     print("toolbox: %d item(s)" % len(items))
     for item in items:
         where = "%s:%d" % (item["path"], item["line"]) if item["line"] else item["path"]
         name = " %s" % item["name"] if item["kind"] == "make" else ""
         print("  %-8s %s%s — %s" % (item["kind"], where, name, clip(item["purpose"]) if item["purpose"] else UNKNOWN))
-    for guard, paths in guard_overlap(items, table).items():
+    for guard, paths in guard_overlap(items).items():
         print("  guard    %s: %s" % (guard, ", ".join(paths) + " (same job, kept)" if paths else "no project hook"))
     current = verify_value(root)
-    candidates = verify_candidates(root, table)
+    candidates = verify_candidates(root)
     if current:
-        print("verify_command: %s (testing.md)" % current)
+        print("verify_command: %s (verification.md)" % current)
     elif candidates:
         print("verify_command: proposed `%s` (from %s) — write it with `setup.py verify --set` once the human "
               "confirms" % candidates[0])
@@ -463,71 +432,36 @@ def cmd_check(root):
     value = verify_value(root)
     if not value or value.lower() == "none":
         print("VERIFY_COMMAND_MISSING: %s names no verify_command — propose one with `setup.py survey`, "
-              "write it with `setup.py verify --set \"<command>\"` after the human confirms" % TESTING)
+              "write it with `setup.py verify --set \"<command>\"` after the human confirms" % VERIFICATION)
         return 1
     print("verify_command: %s" % value)
     return 0
 
 
-def cmd_adopt(root, apply):
-    table = load_map()
-    router = os.path.join(root, ROUTER_FILE)
-    router_text = read_text(router)
-    if router_text is None:
-        die("%s not found — scaffold .ai/ first (/rr-setup)" % ROUTER_FILE)
-    items = inventory(root, table)
-    text = toolbox_text(items, guard_overlap(items, table))
-    toolbox = os.path.join(root, TOOLBOX)
-    existing = read_text(toolbox)
-    new_router, added = add_rows(router_text, router_rows(items))
-    if new_router is None:
-        die("%s has no table to add router rows to" % ROUTER_FILE)
-    if existing is not None and existing != text:
-        print("refused: %s exists and differs from the inventory — compare by hand, or delete it and run "
-              "again" % TOOLBOX)
-        return 3
-    print("%s %s (%d item(s))" % ("unchanged" if existing == text else "write", TOOLBOX, len(items)))
-    for row in added:
-        print("router   %s" % row)
-    if not added:
-        print("router   no new row")
-    if not apply:
-        print("dry run — --apply writes it")
-        return 0
-    if existing != text:
-        write(toolbox, text)
-    if added:
-        write(router, new_router)
-    print("applied")
-    return 0
-
-
 def cmd_verify(root, command):
     command = (command or "").strip()
     if not command or "\n" in command or command.startswith("#"):
         die("--set needs one command on one line")
-    path = os.path.join(root, TESTING)
+    path = os.path.join(root, VERIFICATION)
     text = read_text(path)
     if text is None or not VERIFY_RE.search(text):
-        die("%s has no verify_command line — run /rr-setup --update first" % TESTING)
+        die("%s has no verify_command line — run /rr-setup --update first" % VERIFICATION)
     current = verify_value(root)
     if current and current.lower() != "none":
-        print("refused: verify_command is already `%s` — the human edits %s" % (current, TESTING))
+        print("refused: verify_command is already `%s` — the human edits %s" % (current, VERIFICATION))
         return 3
     match = VERIFY_RE.search(text)
     write(path, text[:match.start()] + "verify_command:      " + command + text[match.end():])
-    print("verify_command: %s (written to %s)" % (command, TESTING))
+    print("verify_command: %s (written to %s)" % (command, VERIFICATION))
     return 0
 
 
 def main(argv=None):
     parser = argparse.ArgumentParser(prog="setup.py", description=__doc__.split("\n\n", 1)[0])
     sub = parser.add_subparsers(dest="cmd", required=True)
-    for name in ("survey", "check", "adopt", "verify"):
+    for name in ("survey", "check", "verify"):
         p = sub.add_parser(name)
         p.add_argument("--root", default=".")
-        if name == "adopt":
-            p.add_argument("--apply", action="store_true")
         if name == "verify":
             p.add_argument("--set", dest="command", required=True)
     args = parser.parse_args(argv)
@@ -538,8 +472,6 @@ def main(argv=None):
         return cmd_survey(root)
     if args.cmd == "check":
         return cmd_check(root)
-    if args.cmd == "adopt":
-        return cmd_adopt(root, args.apply)
     return cmd_verify(root, args.command)