wm

Plugin wm in popoffvg/dotfiles. Commands read from the repo's manifest — 4 days ago.

Skills (18)

• wm

  Run WM spec, implementation, research, or review workflows when the user requests WM or invokes a WM operation.

• arch

  Design the work before any code exists — the spec corpus and the component taxonomy. Owns the spec pipeline (new, todo, revise, prototype), the spec contract and its artifacts (spec.md, the ledger, adr/, the todos/ TODO-N.md + TODO-N.agent.md pair, GLOSSARY.md), and the brick roster: the closed set

• capture-gotcha

  Append a repeatable trap of this project to `<notes-dir>/GOTCHAS.md` — a convention missed, a wrong assumption, a command that fails in a non-obvious way. Load it when `impl:sub-squash.md` distills a fixup, when `impl:sub-auto.md` closes a round, or when a wm subcommand learns a trap the next TODO w

• code

  Manage spec writing, implementation, and bug fixing.

• commit-message

  Write the message of one commit — the subject line, and above all the body: the cause that forced the change, the goal the change reaches, and the decision it took when a real choice existed. Load it before every `git commit`, amend, or message rewrite in the wm flow (`impl`, `auto`, `fix`, `squash`

• distributed-patterns

  distributed-patterns: how many writers share one store with no compare and swap and no shared lock — unique names, write-once objects, the child before its link, a fixed winner rule, and a housekeeper with a grace period. Use when you design or review a write path that several processes or instances

• dive-docs

  The `docs` route of `/dive` — write markdown research artifacts, one per entry point, graded against the 6-step chain, and converge until nothing new surfaces. Loaded by the `dive` router; it fans out `explorer` agents to write and `explore-critic` agents to grade.

• dive

  Research phase before implementation — subcommand router. Given entry points (files, symbols, urls), spawn one subagent per entry point in parallel and write refactor-oriented research artifacts into `<notes-dir>/research/`. Use when the user says "dive", "explore", "research these entry points", or

• impl-background

  Run `/code impl` for one TODO whose `approve` key resolves to `none`, in a background fork, so the calling session stays free and gets a notification when the TODO is done. Load it when the `code` skill routes to impl and `approve` resolves to `none`.

• impl

  The coding half of the wm flow — every operation that writes source or git history: execute one TODO increment by increment (impl), run the whole ledger unattended (auto), close a gap in the ADR and then the code (fix), distill a fixup trail and squash-merge (squash), and the commit rules all three

• mutation

  Find the unit and table tests a change can delete — apply one small behavior-changing edit at a time (a **mutant**) to the code the tests cover, record which tests and table rows each mutant fails, and mark a test that kills nothing, or only what E2E or a kept test already kills. E2E tests are the r

• pedant

  Attack every name in the code — variables, types, functions, methods, parameters, fields, constants — and reject any that reads unclearly without surrounding context or leans on technical/implementation terms instead of domain (DDD ubiquitous) language. Use during code review, before approving a dif

• red-green-refactor

  Red-Green-Refactor cycle for bug fixes. Before fixing a bug, first write a failing test that reproduces it (Red), then make the minimal change to pass (Green), then clean up the code (Refactor). Use on any bug fix, error correction, failing test repair, or when user says "fix this bug".

• review

  The judging half of the wm flow — subcommand router. Every operation that reads code and rules on it without writing any: the gate chain over one implemented TODO (todo), and the same gates over a loose diff, branch, PR, or working tree with no TODO pair (diff). Owns which gate judges what, which ag

• searchable-names

  Use when choosing a name that a person or a grep must land on later — a type, function, method, field, constant, file, module, package, test, metric, event, feature flag, error code, or the name of an app or directory being renamed — and when writing the doc line under a new public symbol or buildin

• teach

  Build and measure the human's understanding of a codebase and a branch change, step by step across sessions. Owns the stateful workspace `<notes-dir>/teach/` — the mission, the numbered HTML lessons, the reference sheets, the learning records that set the level of the next session — and the graded q

• test-suite

  One entry point for all testing work. Use when the user wants to design a test strategy (pairwise tiering across unit/integration/manual), enumerate scenarios before implementation, audit/score an existing test set for missed cases and readability, apply black-box techniques (equivalence partitionin

• trace

  Answer "why is it this way?" about anything a spec corpus produced — an Outcome, a Components split, a Surface shape, a constraint row, an Autotest level set to none, a line of shipped code. Spawns one subagent that searches the ADRs in `<notes-dir>/adr/` and returns a short decision trace. Load it

Slash commands (34)

• /wm:code:auto

  Run the whole ledger unattended: arm the `/goal` Stop hook, then loop every open TODO through read `LESSONS.md` → implement → the review gate chain → `squash` the round's fixups → append `LESSONS.md`…

• /wm:code:code-map

  Produce a single-panel planned-architecture HTML map (package or component/type) for the spec — via `/dive explain`.

• /wm:code:commit

  When to commit and how a correction lands (fixups) — shared by `impl`, `auto`, `fix`.

• /wm:code:diff

  Show what changed as one self-contained HTML page (opened): before/after architecture panels + interfaces/signatures rendered as diffs.

• /wm:code:fix

  Close a gap — bug, missing part, or adjustment.

• /wm:code:help

  Show all /code subcommands with one-line descriptions.

• /wm:code:impl

  Execute one TODO — read context, replan guard, apply the increments and show them for approval as the `approve` key asks, autotest, commit, report.

• /wm:code:new

  Spec pipeline: init the corpus (`CLAUDE.md`, `RULES.md` — ask the three rule questions plus the spec's `approve` depth — `PATTERNS.md`), write `spec.md` (if missing) → grill until `QUESTIONS.md` has…

• /wm:code:prototype

  Settle an open question of `QUESTIONS.md` with a small, visible demonstrative diff.

• /wm:code:quiz

  Test the human's understanding — build a multiple-choice quiz over the spec (`status` init/review) or the code changes (`status` impl), grade the answers, report a score.

• /wm:code:review

  Alias for `/review` — full list `/review:help`.

• /wm:code:revise

  Settle drift from a delta manifest, patching only stale ADRs and spec sections; resets the spec `status` to `review`.

• /wm:code:squash

  Analyze the fixup commits → distill gotchas into `GOTCHAS.md` (`capture-gotcha`) → `git` fold each fixup into the commit it fixes, one commit per `### Commit` section, and merge one TODO branch back…

• /wm:code:teach

  Teach the human this codebase step by step, across sessions.

• /wm:code:todo

  Author the self-contained `todos/TODO-N.md` + `TODO-N.agent.md` pair — human half (frontmatter — including `approve`, `inherit` unless this TODO needs its own review depth — Outcome, Components, Flow…

• /wm:code:verify

  Audit the spec before impl in a separate read-only `spec-verifier` agent — contradictions, missing parts, edge cases, plus the completeness / test-honesty floor.

• /wm:dive:docs

  Write the markdown research write-ups + question lists.

• /wm:dive:explain-diff

  Draw a two-panel architecture diff comparing two solutions — `current` beside `planned` (or option A beside B) — as a self-contained HTML a reviewer reads in 30 seconds: what changed, removed, new, h…

• /wm:dive:explain

  Draw a single-panel planned architecture as a self-contained HTML a reviewer reads in 30 seconds — the components, their edge relations, and the load-bearing decisions (tagged with decision ids).

• /wm:dive:help

  Show all /dive subcommands with one-line descriptions.

• /wm:dive:unknowns

  Guided quadrant walk with the user — map known knowns / known unknowns / unknown knowns / unknown unknowns one stage at a time, ending with a four-quadrant map (`<slug>.unknowns.md`) in the user's ha…

• /wm:dive:workflow

  Write the typed TS pseudocode + path bindings into `<notes-dir>/workflows/<flow-name>/` — one folder per flow (`<ep-slug>.workflow.ts`, `<ep-slug>.bindings.json`), plus shared `components/*.d.ts`, `_…

• /wm:review:diff

  Judge a loose target against the rule files — the working tree, `last`, a branch, a sha or range, or a PR url.

• /wm:review:help

  Show all /review modes and the gates they run, with one-line descriptions.

• /wm:review:todo

  Judge an implemented TODO against the same rule files, plus the TODO's ADR Properties as `ADR-NNNN/Pn` rules.

• /wm:test-suite:bdd

  Shape integration/e2e cases as Cucumber Given/When/Then.

• /wm:test-suite:case-design

  Derive cases systematically — equivalence partitioning, boundary values, decision tables, state transition, state-combination, property-based.

• /wm:test-suite:create

  Size a test set for a TODO/task with pairwise across unit / integration / manual tiers, and ship it as big cases.

• /wm:test-suite:harness

  Test a harness plugin in isolation — MCP server, unit tests, typecheck, Claude plugin loading.

• /wm:test-suite:help

  Show all /test-suite subcommands with one-line descriptions.

• /wm:test-suite:review

  Run the verify phase — present results, let the user review an implementation against acceptance criteria.

• /wm:test-suite:tdd

  Drive a feature or bug-fix spec-before-code with Red-Green-Refactor.

• /wm:test-suite:verify

  Audit an existing test set for missed cases and readability — Ready / Not Ready verdict.

• /wm:test-suite:write

  Enumerate the scenarios before implementation — a readable `.md` test set plus Gherkin feature files.

Subagents (20)

• architector

  Planning agent — produces `.notes/spec.md`, the `.notes/todos/TODO-N.md` + `TODO-N.agent.md` pairs, and the `.notes/adr/` ADRs whose Properties generate the rules those pairs obey.

• codebase-analyzer
• correctness-critic

  Opus correctness gate for one diff — hunts the inputs that make the changed code give a wrong result: off-by-one, nil / empty / zero, a swallowed error path, a wrong boundary, a race on a new shared value, a caller left unmigrated after a signature change. Writes each suspect as one yes/no hypothesi

• explore-critic

  Grades one finished research artifact against the 6-step chain and reports the entry points it references but nobody explored. Read-only — writes no files, edits nothing. The judge half of the `dive-docs` convergence loop, spawned in parallel, one per `<ep-slug>.md`.

• explorer

  Writes one refactor-oriented research artifact for one entry point. Reads the code, answers the entry point's grill questions, and emits `<ep-slug>.md` graded against the 6-step chain. Read-only on source — it writes only into the research dir. Spawned in parallel, one per entry point, by the `dive-

• hypothesis-checker

  Answers one hypothesis about a diff or a spec — a yes/no question whose yes is a defect at one file:line. The `correctness-critic` gate raises the diff hypotheses; `/code verify` raises the missed-change hypotheses of a spec. Reads only what the question needs: the lines, their callers, the types, t

• idiom-critic

  Language gate for one diff — the only gate that judges the language itself: whether each changed line is written the way its language and standard library expect, in the version the repo pins. Returns PASS | FAIL with the file:line, the idiom broken, the guide that states it, and the idiomatic rewri

• implementer

  Implementation agent. Implements medium and complex tasks. Ends every run with a markdown diff report at `<notes-dir>/diff-TODO-N.md` and returns its path.

• lint-tester

  Fast lint gate for one implemented TODO. Reads the diff and the TODO pair (Files from the agent half, Autotest from `TODO-N.test.md`), runs the project linter over the changed files, and reads the Autotest outcome from the caller's `toolchain.json` instead of running it — returns PASS | FAIL with th

• mutation-tester

  Mutation gate for one batch of candidate tests — the unit tests and table rows a diff adds or changes. Applies one behavior-changing edit at a time to the code they call, records which tests and rows each mutant fails, and marks every candidate that kills nothing, or only what E2E or a kept test alr

• name-critic

  Naming gate for the names a spec corpus mints — runs the `pedant` smell table over the `## New terms` rows, the created `## Components` symbols, and the symbols the `## Increments` diffs add, and returns PASS | FAIL with the file:line, the smell, the bug it can hide, and the rename. Read-only; it pr

• researcher

  Research teammate — explores codebase, gathers context, writes the research artifacts of the `dive` docs route. Cannot edit source code.

• reuse-critic

  Reuse gate for one diff — the only gate that asks whether the changed code does again a job the repo or its dependencies already do: a hand-written retry, poll loop, state machine, worker pool, client, or helper beside the one that exists. Returns PASS | FAIL with the file:line, the job, the existin

• rule-checker

  Map step of the `rules` gate — checks one batch: up to twelve rules and the hunks of the changed files they cover, which `wm-rule-batches.py plan` cut from the rule files in `<notes-dir>/rules/` and `~/.notes/rules/`. Returns PASS, FAIL, or N/A per rule, and for each FAIL the verbatim hunk lines tha

• rule-reducer

  Reduce step of the `rules` gate — merges every `rule-checker` result of one review round into the gate report. Runs `wm-rule-batches.py check` first, so a batch with no verdict fails the gate as UNCHECKED. Re-reads each FAIL at the tip, drops the false hits, merges duplicates, and buckets each findi

• simplify-critic

  Simplify gate for one diff — the read-only check of the Simplification, Efficiency, and Altitude angles of the `simplify-code` skill: needless complexity, wasted work, and a fix at the wrong depth. Returns PASS | FAIL with the file:line, the angle, the cost, and the simpler form. Read-only on source

• spec-verifier

  Adversarial spec auditor — reads `.notes/spec.md` + each `.notes/todos/TODO-N.md` + `TODO-N.agent.md` pair and the rules generated from the `.notes/adr/` Properties before implementation and hunts contradictions, missing parts, and edge cases. Independent of the architector who wrote the spec. Read-

• tester

  Autonomous tester — runs the `test-suite` skill over a diff, PR, TODO, or feature description, executes what it can, and writes the report to the path the caller names. The skill owns every method; this agent owns the run.

• tracer

  Answers one "why is it this way?" question against the ADRs of a wm notes dir. Searches `<notes-dir>/adr/` from the `wm-adr-index.py` index down, reads only the ADRs that bear on the anchor, walks their markdown links and changelogs, with their `Superseded by` lines, and returns a decision trace of

• verifier

  Adversarial spec-verification agent — checks an implemented TODO against its spec independently of the implementer. Reads the `.notes/todos/TODO-N.md` + `TODO-N.agent.md` pair (Outcome, Increments) and `TODO-N.test.md` (Autotest), inspects the real diff/commit, re-runs the Autotest itself, and write

Hooks (17)

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/bin/notes-jj-init.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/bin/code-mode-session.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/bin/spec-focus.sh

• PreCompact

  ${CLAUDE_PLUGIN_ROOT}/bin/spec-focus.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/bin/notes-locate.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/bin/todo-session.sh prompt

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/adr-status-guard.py

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/guard.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/code-mode-mark.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/todo-session.sh skill

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/adr-archive.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/format-todo.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/budget-check.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/verify-naming-reminder.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/bin/todo-session.sh commit

• SessionEnd

  ${CLAUDE_PLUGIN_ROOT}/bin/adr-tactical-check.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/bin/notes-commit-reminder.sh

Language servers (1)

• wm-lsp