refactor(toolchain): rename build skill to check

README.md

@@ -47,7 +47,7 @@ Browse and manage with `/plugin`. To refresh after updates: `/plugin marketplace
 - [`actionlint`](plugins/actionlint) — Lint GitHub Actions workflow files on edit via actionlint, surfacing findings as advisory context.
 - [`source-control`](plugins/source-control) — Git and GitHub delivery workflow: /commit (Conventional Commits + Co-Authored-By trailer via safe heredoc mechanics), /pull-request (prep, create, CI monitoring, review-comment triage, merge, multi-PR babysit loop), /worktree (create, status, cleanup, audit for parallel-session isolation), /setup (interview the repo and write the tracked commit-subject / PR-title convention config), and /resolve-conflicts (intent-first merge/rebase conflict resolution with a semantic-conflict sweep — never --abort). The commit-subject / PR-title convention is configurable per repo via a tracked .claude/source-control.md config written by a re-runnable setup skill; Conventional Commits is the default when no convention is declared.
 - [`implementation`](plugins/implementation) — Disciplined implementation stage: execute approved plans inline (`/implementation:implement`) or via orchestrated worker subagents (`/implementation:implement-dispatch`) with incremental validation, TDD-by-default cadence, green-checkpoint commits, scope-fence drift detection, and divergence detection that routes back to planning. Build/test/lint, testing, and outcome verification live in the companion `toolchain`, `testing`, and `verification` plugins, invoked when installed.
-- [`toolchain`](plugins/toolchain) — Repo-agnostic polyglot verification toolchain: build + test + lint for changed files across .NET, Python, TypeScript, Bash, PowerShell, Markdown, YAML, and cross-cutting surfaces (`/toolchain:build`, `/toolchain:lint`), plus a re-runnable `/toolchain:setup` that writes the tracked per-ecosystem command config those skills resolve first.
+- [`toolchain`](plugins/toolchain) — Repo-agnostic polyglot verification toolchain: build + test + lint for changed files across .NET, Python, TypeScript, Bash, PowerShell, Markdown, YAML, and cross-cutting surfaces (`/toolchain:check`, `/toolchain:lint`), plus a re-runnable `/toolchain:setup` that writes the tracked per-ecosystem command config those skills resolve first.
 
 ### Testing
 

docs/conventions/ecosystem-commands/README.md

@@ -11,8 +11,8 @@ This directory is the source of truth: `ecosystem.schema.json` (per-file schema)
 ## Why this contract exists
 
 Before it, the same command truth was encoded independently in at least three places across this
-marketplace — the `toolchain` plugin's `/toolchain:build` reference table, its `/toolchain:lint` reference table
-(already divergent from `/toolchain:build`'s), and the `review` `ecosystem-specialist` agent's inline
+marketplace — the `toolchain` plugin's `/toolchain:check` reference table, its `/toolchain:lint` reference table
+(already divergent from `/toolchain:check`'s), and the `review` `ecosystem-specialist` agent's inline
 defaults — with no consumer-declared source any of them could defer to. The concern is cross-plugin
 by demonstrated fact, so the contract lives here in marketplace conventions (the same reasoning as
 `docs/conventions/hook-telemetry/`), not inside any one plugin.

docs/topics/plugin-organization/PLAN.md

@@ -31,7 +31,7 @@ history; grouping lives in marketplace metadata.
 | D10 | `claude-ops` unchanged as plugin; skills deprefixed: `claude-code-changelog` → `changelog`, `claude-observability` → `observability`, `claude-troubleshooting` → `troubleshoot`. |
 | D11 | `mcp-tool-audit` → `mcp-tools`, skill → `audit` (verified generic-MCP, standalone domain). |
 | D12 | `codebase-audit` → `codebase-health`, skill → `audit`. |
-| D13 | `implementation` splits four ways: `toolchain` (`build`, `lint`, `setup`), `testing` (`plan`, `write`, `e2e`, `diagnose` — was test-*), `verification` (`confirm` — was verify-changes, `measure` — was verify-improvement), `implementation` (`implement`, `implement-dispatch`). Mechanism moves, obligation stays: implement builds via `/toolchain:build` seam; cross-plugin references presence-gated. |
+| D13 | `implementation` splits four ways: `toolchain` (`build` — since renamed `check`, `lint`, `setup`), `testing` (`plan`, `write`, `e2e`, `diagnose` — was test-*), `verification` (`confirm` — was verify-changes, `measure` — was verify-improvement), `implementation` (`implement`, `implement-dispatch`). Mechanism moves, obligation stays: implement builds via `/toolchain:check` seam; cross-plugin references presence-gated. |
 | D14 | `tdd` stays standalone; skill → `principles`. |
 | D15 | `work-items` skill splits five ways: `track` (add/start/done/list/stats/search/due/recheck/audit), `triage`, `work`, `decompose`, `scan`. |
 | D16 | `context7`: skill → `lookup` + new `setup` (absorbs configure, `disable-model-invocation: true`); `update` stays inline maintainer action. |

plugins/implementation/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "implementation",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Disciplined implementation stage: execute approved plans inline (`/implementation:implement`) or via orchestrated worker subagents (`/implementation:implement-dispatch`) with incremental validation, TDD-by-default cadence, green-checkpoint commits, scope-fence drift detection, and divergence detection that routes back to planning. Build/test/lint, testing, and outcome verification live in the companion `toolchain`, `testing`, and `verification` plugins, invoked when installed.",
   "author": {
     "name": "Melodic Software",

plugins/implementation/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to the `implementation` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.6.1]
+
+### Changed
+
+- References to the renamed `/toolchain:build` skill now invoke `/toolchain:check` (toolchain 0.2.0 breaking rename). Version bumped so existing installs pick up the rewritten prompts.
+
 ## [0.6.0]
 
 ### Changed — nine skills extracted into three new plugins (migration required to retain them)

plugins/implementation/README.md

@@ -17,7 +17,7 @@ Build/test/lint, testing, and outcome verification were split out of this plugin
 three companion plugins. This plugin invokes them when installed and degrades
 gracefully when absent — no hard dependencies:
 
-- **`toolchain`** — `/toolchain:build` runs after each logical block and at completion;
+- **`toolchain`** — `/toolchain:check` runs after each logical block and at completion;
   when the plugin is absent this skill runs the project's own build/test command.
 - **`testing`** — `/testing:plan`, `/testing:write`, `/testing:diagnose` for coverage,
   authoring, and failure diagnosis.
@@ -60,7 +60,7 @@ plugins. `implementation` keeps its name, so the marketplace's `renames` map (wh
 renamed or removed plugin automatically) does not apply — install the plugins you relied on:
 
 ```shell
-/plugin install toolchain@melodic-software      # build, lint, setup
+/plugin install toolchain@melodic-software      # check (was build), lint, setup
 /plugin install testing@melodic-software        # test-plan, test-write, test-e2e, test-diagnose
 /plugin install verification@melodic-software   # verify-changes, verify-improvement
 ```

plugins/implementation/skills/implement-dispatch/SKILL.md

@@ -33,7 +33,7 @@ Run the `/implementation:implement` "Step 1: Prerequisite Check" preflight first
 1. **Compose the brief** — an explicit scope fence (ALLOWED files/actions and FORBIDDEN files/actions, enumerated), a divergence-escalation clause (verbatim in every brief: "if an assumption in this brief proves wrong or the task requires touching anything FORBIDDEN, STOP and report — do not improvise"), the project invariants the task touches (from the consuming project's `CLAUDE.md` / rules), the phase's acceptance criteria, and any model routing the plan specifies
 2. **Dispatch** the worker
 3. **Verify the return against direct evidence before accepting edits** — worker returns are synthesis, not ground truth; promote their claims to direct evidence (diff read, grep, file Read) before building on them
-4. **Build/test main-side** — invoke `/toolchain:build` from the main window when the `toolchain` plugin is installed, otherwise run the project's own build/test command main-side; never accept a worker's green claim as the build signal
+4. **Build/test main-side** — invoke `/toolchain:check` from the main window when the `toolchain` plugin is installed, otherwise run the project's own build/test command main-side; never accept a worker's green claim as the build signal
 5. **Route worker divergence reports into `/implementation:implement` "Step 3: Divergence Detection"** — a worker STOPping per the divergence-escalation clause is a divergence signal, severity-assessed the same way; the orchestrator revises the brief or routes back to the planning skill (`/planning:architect review` when installed)
 
 ## Divergence in non-interactive runs
@@ -63,19 +63,19 @@ Any criterion fails → clear + resume from the emitted prompt. **The phase-boun
 | Phase is inline-routed (main-window), interactive mode | Hand back to `/implementation:implement` classic cadence |
 | Phase is inline-routed or routing table absent, autonomous mode | Synthesize a worker row and dispatch — the orchestrator never does volume edits |
 | Worker divergence report | Severity-assess per `/implementation:implement` "Step 3: Divergence Detection"; Major → the planning skill (`/planning:architect review` when installed) |
-| Every worker return | Verify against direct evidence, then `/toolchain:build` main-side (when the `toolchain` plugin is installed; else the project's own build) |
+| Every worker return | Verify against direct evidence, then `/toolchain:check` main-side (when the `toolchain` plugin is installed; else the project's own build) |
 | Phase sanity check passes | `/implementation:implement` "Step 4" ritual (its item-1 verifier gate applies in every mode; orchestrated runs dispatch it — see Phase boundaries) |
 | All phases complete | `/implementation:implement` "Step 5: Completion and Handoff" |
 
 ## What this skill does NOT do
 
 - **Does not edit inline** — inline execution cadence, commit discipline, and mode context files (feature/bugfix/refactor) are `/implementation:implement`'s
 - **Does not create or revise plans** — a planning pass produces plans; this skill executes routing tables
-- **Does not replace `/toolchain:build`** — the `toolchain` plugin's build skill (when installed) is the SSOT; this skill invokes it main-side at the right moments, falling back to the project's own build command when that plugin is absent
+- **Does not replace `/toolchain:check`** — the `toolchain` plugin's check skill (when installed) is the SSOT; this skill invokes it main-side at the right moments, falling back to the project's own build command when that plugin is absent
 
 ## Gotchas
 
-- **Never accept a worker's green claim as the build signal.** Workers report synthesis; the main window runs `/toolchain:build` (or the project's own build when the `toolchain` plugin is absent) itself after every accepted return
+- **Never accept a worker's green claim as the build signal.** Workers report synthesis; the main window runs `/toolchain:check` (or the project's own build when the `toolchain` plugin is absent) itself after every accepted return
 - **A worker STOP is a divergence signal, not a failure.** Route it through the `/implementation:implement` Step 3 severity ladder; revising the brief is the cheap fix, a plan review the escalation
 - **Surface subagent results before ending the turn.** Results left unsurfaced at turn end are lost to the user
 - **Scope-fence drift applies to agent returns.** Every worker return is a decision boundary — classify proposed follow-ups per `/implementation:implement` "Step 3.5: Scope-fence drift detector (run at every decision boundary)" before announcing them

plugins/implementation/skills/implement-dispatch/evals/evals.json

@@ -30,12 +30,12 @@
       "id": 3,
       "name": "verifies-worker-return-against-direct-evidence",
       "prompt": "/implementation:implement-dispatch phase-2 — the worker for phase 2 reported back: 'Done, all files updated and the build is green.' Accept the phase and move on.",
-      "expected_output": "Treats the worker return as synthesis, not ground truth: promotes its claims to direct evidence (diff read, grep, file Read) and runs /toolchain:build itself main-side before accepting the edits — it never accepts the worker's green claim as the build signal.",
+      "expected_output": "Treats the worker return as synthesis, not ground truth: promotes its claims to direct evidence (diff read, grep, file Read) and runs /toolchain:check itself main-side before accepting the edits — it never accepts the worker's green claim as the build signal.",
       "files": [],
       "expectations": [
         "Does NOT accept the worker's 'build is green' claim as the authoritative build signal",
         "Verifies the worker's claims against direct evidence (reads the diff / greps / reads files) before building on them",
-        "Runs /toolchain:build itself from the main window rather than trusting the worker's report"
+        "Runs /toolchain:check itself from the main window rather than trusting the worker's report"
       ]
     },
     {

plugins/implementation/skills/implement/SKILL.md

@@ -63,7 +63,7 @@ Core execution loop. Key discipline: **validate after each logical block, not ju
 ### Execution cadence
 
 1. **Implement one logical block** — a single concern, function, class, or feature slice. Not the entire plan at once
-2. **Build check** — invoke `/toolchain:build` (via Skill tool) for the affected ecosystem after each block when the `toolchain` plugin is installed; otherwise run the project's own build/test command directly. Catch compilation errors immediately, not after 5 files of changes. In non-interactive runs, tier the in-loop cost: typecheck/compile and the touched test files run per block; the broader affected-ecosystem test suite runs at phase boundaries and Step 5 — early detection stays, redundant full-suite passes go
+2. **Build check** — invoke `/toolchain:check` (via Skill tool) for the affected ecosystem after each block when the `toolchain` plugin is installed; otherwise run the project's own build/test command directly. Catch compilation errors immediately, not after 5 files of changes. In non-interactive runs, tier the in-loop cost: typecheck/compile and the touched test files run per block; the broader affected-ecosystem test suite runs at phase boundaries and Step 5 — early detection stays, redundant full-suite passes go
 3. **Test (TDD by default)** — when the `tdd` plugin is installed, invoke `/tdd:principles` via Skill tool **before writing the first test** for authoritative guidance on what to test, which testing style fits (output/state/communication), and when to mock. Then follow Red-Green-Refactor **one test at a time**: write a single failing test for the smallest slice of behavior, confirm it fails (red), implement the minimum to pass (green), refactor — then move to the next slice. **Do not write all tests upfront** — writing one at a time keeps each red signal observable (proving the test can fail before code makes it pass) and stops you over-fitting code to tests written against a design that doesn't exist yet. TDD is the default — skip only when genuinely impractical (e.g., pure infrastructure wiring with no testable logic, or UI rendering with no logic behind the seam). Honor the consuming project's own testing conventions (its `CLAUDE.md` / rules)
 4. **Commit checkpoint** — commit after tests pass. Each commit should represent a green state. See below for commit discipline
 5. **Repeat** until the plan is complete
@@ -172,7 +172,7 @@ In orchestrated runs, the orchestrator may stay resident across phase boundaries
 
 When all planned work is done:
 
-1. **Final build check** — invoke `/toolchain:build` via the Skill tool for all affected ecosystems when the `toolchain` plugin is installed; otherwise run the project's own build/test command
+1. **Final build check** — invoke `/toolchain:check` via the Skill tool for all affected ecosystems when the `toolchain` plugin is installed; otherwise run the project's own build/test command
 2. **Run all affected tests** — not just the ones you wrote, but tests that could be impacted by your changes
 3. **Self-review (a floor, not the final verdict)** — the producing context converges on approval, so this catches slips but does not render the outcome verdict (step 5 hands to `/verification:confirm`, which renders it from outside the producing loop). Read through changes (`git diff HEAD~N`) looking for:
    - Consistency with existing patterns
@@ -187,7 +187,7 @@ When all planned work is done:
 | Condition | Action |
 |-----------|--------|
 | Before writing first test | Invoke `/tdd:principles` via Skill tool (when installed) for test design guidance |
-| After each logical block | Invoke `/toolchain:build` via Skill tool (when the `toolchain` plugin is installed; else the project's own build) |
+| After each logical block | Invoke `/toolchain:check` via Skill tool (when the `toolchain` plugin is installed; else the project's own build) |
 | At every phase boundary | Run the Step 4 ritual (plan marks + handoff entry + status + commit + resume prompt) |
 | Worker-routed phase or autonomous orchestration | Invoke `/implementation:implement-dispatch` via Skill tool |
 | Divergence detected (major) | Route back to the planning skill (`/planning:architect review` when installed) |
@@ -201,7 +201,7 @@ When all planned work is done:
 - **Does not auto-execute plans** — guides execution with checkpoints and validation. Code changes are still judgment calls
 - **Does not replace `/verification:confirm`** — the `verification` plugin's outcome-verification skill (a separate plugin, when installed) does comprehensive build + test + lint + outcome verification. This skill does incremental validation during implementation
 - **Does not produce plans** — a planning pass does. If the plan needs revision, this skill routes back to it
-- **Does not replace `/toolchain:build`** — the `toolchain` plugin's build skill (a separate plugin, when installed) is the SSOT for build commands; this skill invokes it at the right moments and falls back to the project's own build command when that plugin is absent
+- **Does not replace `/toolchain:check`** — the `toolchain` plugin's check skill (a separate plugin, when installed) is the SSOT for build commands; this skill invokes it at the right moments and falls back to the project's own build command when that plugin is absent
 - **Does not orchestrate workers** — `/implementation:implement-dispatch` owns the orchestrated dispatch cadence for worker-routed phases and autonomous runs. This skill detects the routing and chains to it
 
 ## Gotchas

plugins/source-control/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "source-control",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Git and GitHub delivery workflow: /commit (Conventional Commits + Co-Authored-By trailer via safe heredoc mechanics), /pull-request (prep, create, CI monitoring, review-comment triage, merge, multi-PR babysit loop), /worktree (create, status, cleanup, audit for parallel-session isolation), /setup (interview the repo and write the tracked commit-subject / PR-title convention config), and /resolve-conflicts (intent-first merge/rebase conflict resolution with a semantic-conflict sweep — never --abort). The commit-subject / PR-title convention is configurable per repo via a tracked .claude/source-control.md config written by a re-runnable setup skill; Conventional Commits is the default when no convention is declared.",
   "author": {
     "name": "Melodic Software",

plugins/source-control/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to the `source-control` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.5.1]
+
+### Changed
+
+- References to the renamed `/toolchain:build` skill now invoke `/toolchain:check` (toolchain 0.2.0 breaking rename). Version bumped so existing installs pick up the rewritten prompts.
+
 ## [0.5.0]
 
 ### Added