refactor: consolidate into single RHDH-aware agent-ready skill

- Remove init-agents-md as a standalone skill; AGENTS.md generation
  is now inline within agent-ready, using assessment context (detected
  languages, CI commands, tech stack) rather than re-scanning from scratch
- Add RHDH detection: reads rhdh-repos.md from the rhdh skill to match
  repo remote URLs; pre-fills AGENTS.md and skips inapplicable findings
  when a match is found; degrades gracefully if rhdh skill is not installed
- Add batch mode: when invoked with no path, offers to assess all RHDH
  repos in a local directory, producing a summary table with scores and
  offering to drill into any individual repo
- Update README to reflect consolidated skill

Assisted-by: Claude Sonnet 4.6

Author: johnmcollier

README.md

@@ -73,10 +73,7 @@ Track work across the four RHDH Jira projects.
 
 ### Repository Readiness
 
-Prepare any git repository for effective AI agent use.
-
-- **[agent-ready](./skills/agent-ready/SKILL.md)** — Assess a repository against agentready criteria, then walk through and address each gap interactively. Runs the [agentready](https://github.com/ambient-code/agentready) CLI, presents failing findings by tier, and delegates AGENTS.md creation to `init-agents-md`.
-- **[init-agents-md](./skills/init-agents-md/SKILL.md)** — Bootstrap `AGENTS.md` and `CLAUDE.md` for any repository. Detects build/test commands from config files and CI, asks 3 targeted questions, and writes a minimal draft for human review.
+- **[agent-ready](./skills/agent-ready/SKILL.md)** — Assess RHDH repositories against agentready criteria and address each gap. RHDH-aware: detects the repo from its remote URL, uses `rhdh-repos.md` context to pre-fill `AGENTS.md` and skip inapplicable findings. Supports single-repo and batch modes (assess all RHDH repos in one pass).
 
 ### Meta
 

skills/agent-ready/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-ready
 description: |
-  Assesses a git repository's readiness for use by AI coding agents using the agentready CLI, then walks through and addresses each gap. Use when asked to "assess agent readiness", "run agentready", "check how agent-ready this repo is", "make this repo agent-ready", "improve our agent readiness score", "run the agent ready CLI", "assess this repo for AI agents", or "what's our agentready score".
+  Assesses a git repository's readiness for use by AI coding agents using the agentready CLI, then walks through and addresses each gap. RHDH-aware: detects RHDH repositories and uses rhdh-repos.md context to pre-fill AGENTS.md and skip inapplicable findings. Use when asked to "assess agent readiness", "run agentready", "check how agent-ready this repo is", "make this repo agent-ready", "improve agent readiness score", "assess all RHDH repos", "batch agent readiness", or "onboard this repo for agents".
 ---
 
 ## Prerequisites
@@ -14,123 +14,171 @@ uvx --version
 
 If missing, stop: "`uvx` is required. Install via `pip install uv` or see [uv installation](https://docs.astral.sh/uv/getting-started/installation/)."
 
-## Step 1: Setup
+## Step 1: Mode selection
 
-**Path:** Default to the current working directory. If the user provided a path, use that instead. Validate it is a git repository:
+If no path was provided, present a structured choice:
+
+- **Single repo** — assess the current working directory (default)
+- **Batch** — assess all RHDH repositories (see Batch mode below)
+
+If a path was provided, skip this and proceed to Step 2.
+
+## Step 2: Setup
+
+**Path:** Use the provided path, or `.` for the current directory. Validate it is a git repository:
 
 ```bash
-git -C . rev-parse --is-inside-work-tree  # replace . with the user-provided path if one was given
+git -C . rev-parse --is-inside-work-tree  # replace . with path if provided
 ```
 
 If not a git repository, stop and tell the user.
 
-**Config file:** Only use a config file if the user explicitly provided one. Do not ask. If a path was given, verify it exists before proceeding.
+**RHDH detection:** Check the repo's git remote URL:
+
+```bash
+git -C <path> remote get-url origin 2>/dev/null
+```
+
+Attempt to read `~/.claude/skills/rhdh/references/rhdh-repos.md`. If the file does not exist, skip RHDH detection and proceed with generic assessment — do not stop or warn the user. If found, check whether the remote URL matches any repo's upstream URL. If matched, note the repo name, tech stack, key paths, and conventions — these inform AGENTS.md generation and finding triage. Store as `rhdh_context`.
 
-## Step 2: Run the assessment
+**Config file:** Only use a config file if the user explicitly provided one. Do not ask.
 
-Create a temp directory and run the assessment:
+## Step 3: Run the assessment
 
 ```bash
 REPORT_DIR=$(mktemp -d)  # on Windows: use %TEMP% or Python tempfile
 uvx --from git+https://github.com/ambient-code/agentready agentready -- assess \
   -o "$REPORT_DIR" \
-  .  # replace . with the user-provided path if one was given
+  <path>
 ```
 
-Append `-c <config-path>` to the command if the user provided a config file.
+Append `-c <config-path>` if the user provided a config file.
 
-Note the value of `$REPORT_DIR` — shell variables do not persist across tool calls and Step 5 will need it.
+Note the value of `$REPORT_DIR` — shell variables do not persist across tool calls.
 
 Parse `$REPORT_DIR/assessment-latest.json`. Extract:
 - `overall_score`, `certification_level`
 - `findings` — each with `attribute.id`, `attribute.tier`, `attribute.default_weight`, `attribute.name`, `status`, `score`, `evidence`, `remediation`
 
-## Step 3: Present summary
-
-Show a brief summary before diving into findings:
+## Step 4: Present summary
 
 ```
 Score: <overall_score>/100 — <certification_level>
 Failing: <N> findings (<N1> Tier 1, <N2> Tier 2, ...)
 ```
 
-If there are no failing findings, congratulate the user and stop — do not ask to work through anything.
+If no failing findings, congratulate the user and stop.
 
 Otherwise ask:
 
 > "Fix applicable findings automatically, or review each one individually?
 > **auto** (default) — apply self-contained fixes immediately; prompt only when input is needed
 > **review** — prompt yes/skip/defer/quit for every finding"
 
-Default to **auto** if the user just says yes, presses Enter, or says "fix everything".
+Default to **auto** if the user says yes, presses Enter, or says "fix everything".
+
+## Step 5: Work through findings
 
-## Step 4: Work through findings
+Work only through `status == "fail"` findings. Skip `not_applicable` and `pass` silently.
 
-Work only through findings where `status == "fail"`. Skip `not_applicable` and `pass` findings silently.
+**Sort order:** ascending tier, then descending `attribute.default_weight` within each tier.
 
-**Sort order:** ascending tier (Tier 1 first), then descending `attribute.default_weight` within each tier.
+If `rhdh_context` is set, skip findings that clearly don't apply to the detected tech stack (e.g., lock file checks for a Bash-only repo, `src/` layout for a GitOps YAML repo) — note them in the summary.
 
 ### Auto mode
 
-Apply each fix without prompting **unless** any of the following are true — in which case, pause and prompt:
+Apply each fix without prompting **unless**:
 
-- The fix requires project-specific input (CI platform, package ecosystem, project name, language)
-- The finding might not apply to this repo type (e.g., `src/` layout for a GitOps YAML repo, lock files for a repo with no package dependencies) — present it and ask whether to apply or skip
-- It is the `agent_instructions` finding — always delegate to `init-agents-md` interactively
+- The fix requires project-specific input (CI platform, package ecosystem)
+- The finding might not apply to this repo type — present it and ask whether to apply or skip
 
-**Skip without prompting** findings that require human rationale to be meaningful — ADRs, design intent, and architecture decisions. These cannot be generated without fabricating context the agent doesn't have.
+**Skip without prompting:** ADRs, design intent, architecture decisions — these require human rationale. Note them in the final summary.
 
-After processing all findings, list what was applied, what was prompted, and what was skipped, then proceed to Step 5.
+For the `agent_instructions` finding, follow the inline AGENTS.md generation in the `agent_instructions` section below — this applies in both auto and review modes.
+
+After processing, list what was applied, prompted, and skipped, then proceed to Step 6.
 
 ### Review mode
 
-For each finding, present:
+For each finding:
 
 ```
 [Tier <N>] <attribute.name> — <score>/100
-Evidence: <evidence items, one per line>
+Evidence: <evidence items>
 
 Remediation: <remediation.summary>
 
 Apply this fix? [yes / skip / defer / quit]
 ```
 
-**yes** — apply the fix (see special cases below), then move to the next finding.  
-**skip** — move on; do not revisit. Use this if the finding doesn't apply to this repo.  
-**defer** — note it; present again after the re-run.  
+**yes** — apply the fix, then move to the next finding.
+**skip** — move on; do not revisit. Use this if the finding doesn't apply to this repo.
+**defer** — note it; surface again after re-run.
 **quit** — stop immediately.
 
-**ADR and design intent findings in review mode:** Do not present the JSON remediation. Instead ask:
+**ADR and design intent findings:** Do not use JSON remediation. Ask instead:
+
+> "Do you have any architectural decisions worth capturing? Describe the decision and rationale — I'll write the ADR. Skip to add manually later."
+
+Write only if the user provides input. Never invent rationale.
+
+### `agent_instructions` finding (both modes)
+
+Generate `AGENTS.md` and `CLAUDE.md` inline — do not delegate to another skill.
 
-> "Do you have any architectural decisions worth capturing here? If so, describe the decision and why it was made — I'll write the ADR. Skip if you'd prefer to add these manually later."
+**Scan the repo for commands:**
+- `package.json` → `scripts` entries (build, test, lint, typecheck, dev)
+- `Makefile` / `GNUmakefile` → targets
+- `pyproject.toml` → `[tool.pytest]`, `[tool.ruff]`, `[tool.mypy]`, `[project.scripts]`
+- `.github/workflows/*.yml` → `run:` steps containing test/lint/build/typecheck keywords
 
-If the user provides input, write the ADR or design doc using their rationale. If they skip, move on.
+**If `rhdh_context` is set:** pull key paths, tech stack, conventions, and branching model directly from the matched `rhdh-repos.md` entry — use these to pre-fill AGENTS.md sections and skip generic questions where RHDH context already answers them.
 
-### Special case: `agent_instructions` finding (both modes)
+**If not RHDH (or RHDH context doesn't cover it):** ask these three questions one at a time:
+1. "What are 2-3 conventions an agent couldn't discover by reading the code? Skip if none."
+2. "Any non-obvious architectural decisions or places where things live unexpectedly? Skip if obvious."
+3. "Any commit format, CI checks, or PR conventions agents should know? Skip if standard."
 
-Do not apply the JSON remediation. Instead, invoke the `init-agents-md` skill:
+Write `AGENTS.md`:
 
-> "Invoking the `init-agents-md` skill to create AGENTS.md for this repository."
+```markdown
+# <repo-name>
 
-Use the Skill tool: `init-agents-md`. After it completes, return to this skill and continue with the next finding.
+## Build & Test Commands
+- Build: `<command>`
+- Test all: `<command>`
+- Test single file: `<command>`
+- Lint: `<command>`
+- Type check: `<command>`
 
-### Applying fixes (auto and review modes)
+## Key Conventions
+<from scan + questions/rhdh_context>
 
-Use the `remediation.steps`, `remediation.commands`, and `remediation.examples` from the JSON as the implementation guide. Do not invent steps beyond what the JSON provides.
+## Architecture
+<from questions/rhdh_context — omit if nothing to say>
 
-## Step 5: Re-run and present results
+## PR Conventions
+- Agent-assisted commits should include an `Assisted-by: <model>` footer
+<from questions>
+```
+
+Write `CLAUDE.md` with exactly: `@AGENTS.md`
+
+Omit any section — including its header — where there is nothing to say. Do not invent content.
+
+### Applying other fixes (both modes)
 
-Re-run the assessment (shell variables from Step 2 do not persist — create a new temp dir):
+Use `remediation.steps`, `remediation.commands`, and `remediation.examples` from the JSON. Do not invent steps beyond what the JSON provides.
+
+## Step 6: Re-run and present results
 
 ```bash
 REPORT_DIR=$(mktemp -d)  # on Windows: use %TEMP% or Python tempfile
 uvx --from git+https://github.com/ambient-code/agentready agentready -- assess \
   -o "$REPORT_DIR" \
-  .  # or user-provided path
+  <path>
 ```
 
-Include `-c <config-path>` if the user provided a config file.
-
 Show before/after:
 
 ```
@@ -140,16 +188,37 @@ After:  <new_score>/100 (<new_certification_level>)
 Remaining failures: <N> findings
 ```
 
-If there are remaining failures (including deferred ones), ask:
+If remaining failures (including deferred), ask: "Would you like to continue addressing the remaining findings?" If yes, repeat Step 5.
+
+## Batch mode
+
+When the user selects batch assessment:
 
-> "Would you like to continue addressing the remaining findings?"
+1. Ask: "What directory are your RHDH repos cloned into? (e.g. `~/git`)"
+2. Find subdirectories that are git repos:
+
+```bash
+find <dir> -maxdepth 2 -name ".git" -type d | sed 's|/.git||'
+```
+
+3. For each, check if the remote URL matches a repo in `rhdh-repos.md`. Assess only matching repos.
+4. Run the assessment on each matched repo (Step 3) and collect results.
+5. Present a summary table:
+
+```
+Repo                        Score   Level              Failing
+rhdh                        72/100  Bronze             4
+rhdh-operator               45/100  Needs Improvement  11
+rhdh-plugins                88/100  Silver             1
+```
 
-If yes, repeat Step 4 with the remaining failures. If no, stop.
+6. Ask: "Would you like to address findings for any of these repos?" If yes, the user picks one — run Step 3 (assessment) on that repo to get fresh findings, then run Steps 4–6 for it.
 
 ## Gotchas
 
-- The first `uvx` run fetches and builds agentready from GitHub — this can take 30–60 seconds. Subsequent runs use the cache and are much faster. If the fetch fails (network error, build error), tell the user and stop — do not attempt to proceed without a valid report.
+- The first `uvx` run fetches and builds agentready from GitHub — this can take 30–60 seconds. Subsequent runs use the cache. If the fetch fails, stop — do not proceed without a valid report.
 - Do not output the report to the repository directory — use the temp dir to avoid polluting the working tree.
 - `not_applicable` findings reflect the detected language stack; do not mention them unless the user asks.
-- Deferred findings are not lost — they surface again after the re-run.
-- Never invent rationale for ADRs, design docs, or architecture decisions — these require human context the agent doesn't have. In auto mode, skip them. In review mode, ask the user for the rationale before writing anything.
+- Deferred findings surface again after the re-run.
+- Never invent rationale for ADRs or design docs. In auto mode, skip them. In review mode, ask for rationale before writing anything.
+- In batch mode, only assess repos whose remote URL matches `rhdh-repos.md` — do not assess unrelated repos in the same directory.