gsd-plugin — плагин для Claude Code: что делает и как установить

<p align="center">
  <a href="https://buildomator.com"><img src="assets/buildomator-logo-big.png" alt="Buildomator" width="320" /></a>
</p>

# Buildomator for Claude Code

**Plugin version:** `4.1.0`

**Buildomator** (formerly [gsd-plugin](https://github.com/jnuyens/gsd-plugin)) is a Claude Code plugin that plans, executes, and verifies your work. It asks you only about the real design and architecture decisions that need your judgment, then carries out the rest on its own. Each step runs in its own focused subcontext, so token use stays low even on long projects.

Buildomator is a performance-optimized evolution of GSD for Claude Code: it cuts per-turn token overhead by ~92%, keeps project state in an MCP-backed store, and auto-resumes across `/compact` so a compaction never loses your place.

Project home and docs: [buildomator.com](https://buildomator.com).

## Installation

GSD Plugin installs *inside* a Claude Code session, not from your host shell. If you have never used Claude Code plugins before, follow these steps in order.

### No prerequisites

As of **v2.42.0** the plugin bundles its own copy of the GSD SDK at `sdk/dist/cli.js` and ships a `bin/bm-sdk` wrapper (plus a `bin/gsd-sdk` alias) that Claude Code automatically puts on `PATH` for plugin Bash calls. `bm-sdk` is the primary command name; `gsd-sdk` keeps working as a fully equivalent alias, and the retirement once planned for v5.0 is deferred, so both continue to work. You no longer need to `npm install -g get-shit-done-cc` (or its successor `get-shit-done-redux`). Closes [#4](https://github.com/buildomator/buildomator/issues/4).

### Pre-install: remove any pre-v2.42.0 global SDK install

If you previously installed `get-shit-done-cc` / `get-shit-done-redux` or `@gsd-build/sdk` / `@gsd-redux/sdk` via `npm -g` (or `npx`), the global binary at `/opt/homebrew/bin/gsd-sdk` (Apple Silicon) or `/usr/local/bin/gsd-sdk` (Intel macOS / Linux) takes precedence in `$PATH` over the plugin's bundled wrapper. The npm package now maps both `bm-sdk` and `gsd-sdk` to the same CLI, so a shadowing global can hijack either name. The global SDK does NOT honor `CLAUDE_PLUGIN_ROOT`, so every plugin workflow that calls bare `bm-sdk` (or `gsd-sdk`) for init queries, agent-skill lookups, or config reads reports `agents_installed: false`, and skills like `/bm:new-project` silently degrade by skipping the parallel research path. The plugin's wrapper-env-export patch only fires when the wrapper itself is invoked, so a shadowing global bypasses it.

Check whether you have a shadowing install:

```bash
which bm-sdk gsd-sdk
```

If either name resolves to anything OTHER than a path under `~/.claude/plugins/cache/` (typical bad outputs are `/opt/homebrew/bin/gsd-sdk` or `/usr/local/bin/gsd-sdk`), uninstall it from your host shell before going further:

```bash
npm uninstall -g @gsd-build/sdk
npm uninstall -g get-shit-done-cc
npm uninstall -g @gsd-redux/sdk
npm uninstall -g @opengsd/get-shit-done-redux
npm uninstall -g get-shit-done-redux   # if you tried the unscoped name (404s on npm; v2.43.x docs incorrectly referenced this form, fixed in v2.44.6)
```

Re-run `which bm-sdk gsd-sdk`. The expected post-uninstall output is either a path under `~/.claude/plugins/cache/` (after the plugin is installed in Step 3) or not found (before installation). Both are correct.

If you skip this step and install the plugin anyway, v2.43.1+ ships a `gsd-shadowing-sdk-detector` SessionStart hook that will detect the conflict at the start of every Claude Code session and emit a one-time advisory pointing back to this section.

### Step 1: Trust GitHub's SSH host key (first time only on a new machine)

`/plugin marketplace add` clones over SSH. On a fresh machine GitHub's host key is unknown, which makes the non-interactive `git clone` Claude Code runs fail silently. Prime `known_hosts` once from your host shell:

```bash
ssh -T [email protected]
```

Type `yes` at the *"Are you sure you want to continue connecting?"* prompt. The follow-up *"Permission denied (publickey)"* message is expected for a public-repo clone via SSH and harmless; you only needed the host key fingerprint to land in `~/.ssh/known_hosts`. Skip this step if you have used `[email protected]` from this machine before.

### Step 2: Launch Claude Code

From your host shell (Terminal, iTerm, etc.), in any directory:

```bash
claude --dangerously-skip-permissions
```

The `--dangerously-skip-permissions` flag is recommended for the install flow: it lets the plugin marketplace add, plugin install, and MCP server bootstrap run without a wall of permission prompts. You can launch with plain `claude` later if you prefer to approve each tool use.

### Step 3: Add the marketplace and install the plugin

You should now be inside a Claude Code session (you'll see the Claude Code prompt, not your shell prompt). Type these three commands at the Claude Code prompt:

```
/plugin marketplace add buildomator/marketplace
/plugin install bm@buildomator
/reload-plugins
```

That's it. This installs everything: slash commands, agent definitions, hooks, and an MCP server for project state. The `/reload-plugins` step activates the freshly installed plugin in your current session; without it the slash commands and hooks aren't loaded until you restart Claude Code. Enable auto-update for the marketplace in Claude Code settings to receive updates automatically.

`bm@buildomator` is the Buildomator plugin; its commands are all `/bm:*`. That is the only install you need. Coming from an older version that used a different command prefix? See [Migrating](#migrating-from-gsd) below.

## Quick start

Assumes you have already completed the Installation section above (Claude Code is running with the plugin installed). All commands below are typed at the Claude Code prompt, not in your shell.

1. Start a new project: `/bm:new-project`
2. Plan your first phase: `/bm:plan-phase`
3. Execute: `/bm:execute-phase`
4. Verify: `/bm:verify-work`

## Migrating from gsd

Buildomator used to answer to the `gsd` command prefix, and now it answers to `/bm:`. Nothing about the plugin itself changed with the rename, only the name it goes by.

Every `/bm:` command runs the same code its gsd counterpart ran, with the same arguments and output. `/bm:new-project` is the old new-project command, `/bm:plan-phase` is the old plan-phase command, and so on for the whole set. If you knew the old commands you already know the `/bm:` ones: swap the prefix and everything else stays put.

If you installed a previous version under the old prefix, install `bm@buildomator` (see [Installation](#installation)) and point your scripts and aliases at `/bm:`. The old prefix still resolves for now so nothing breaks mid-migration, but `/bm:` is the name going forward.

Why the rename? "Buildomator" is a name we can put on a homepage and say out loud; the behavior underneath is the same plugin you already use.

## Updating

Enable auto-update for the marketplace in Claude Code settings and updates will be applied automatically at startup. To update manually:

1. **Refresh the plugin on disk.** Run `/plugins`, open **Marketplace**, and select **buildomator** to refresh it. Then exit the marketplace by pressing **Esc twice**. This updates the plugin on the filesystem.
2. **Activate it in your open sessions.** Run `/reload-plugins` in **each** Claude Code session you already have open, so they pick up the new version without restarting.

Note: the marketplace step (1) updates the plugin on disk; `/reload-plugins` (2) is what makes an already-running session use the new version. Sessions you start after the update load the new version automatically.

To check the active version in a session, run `/bm:version` (it also checks GitHub for the latest release and prints the update steps when you are behind).

**Do I run `/reload-plugins` in all open sessions or just one?** In all of them. `/reload-plugins` is per-session: each Claude Code session loads its own copy of the plugin, so reloading in one session does not refresh the others. Run it once per session you have open. Sessions you start **after** the update load the new version automatically, with no reload needed (so only your already-open sessions need the command). No `/exit` or restart is required. Buildomator ships an MCP server, but its tools load on demand via tool search, so the reload applies cleanly; on Claude Code v2.1.163+ in the rare case a reload would force a full context re-read, `/reload-plugins` prints a warning and you re-run it as `/reload-plugins --force`.

## What's New

**v4.0.0**: **Consistency and code-integrity safeguards, and a second upstream.** GSD now derives a project's naming and architectural conventions and gates changes against them (`verify conventions`, wired into pattern-mapper and code-review), and ships native drift detection that finds duplicated logic, phantom/placeholder scaffolding, and structural near-clones across the repo (`verify drift`, `/bm:scan --drift`, plus an opt-in `audit-milestone` integrity gate). All detection is 100% native with zero runtime dependency. This release also formalizes **[VibeDrift](https://www.npmjs.com/package/@vibedrift/cli) as a second upstream**: GSD never runs it, but ports its drift-detection heuristics natively and watches its releases to cherry-pick future ones. The major bump to 4.0 marks Buildomator as its own version line, signaling how far it has diverged from upstream GSD (see [Upstream projects](#upstream-projects) and [Versioning](#versioning)).

**v3.7.2**: `/bm:autonomous` no longer stops to ask you to re-confirm before kicking off. The workflow had no confirm-scope step, so the orchestrator improvised one out of caution: it printed the phase plan, then waited for you to say "go" again, which defeats an autonomous command. A new explicit contract makes the rule plain (show the plan, then continue into execution in the same turn; surface a discovered constraint, like a migration-chain collision, as a one-line notice it acts on, not a gate that waits). The only pauses left are the real decision points: human verification, gaps after one auto-retry, audit gaps/tech-debt, and blockers.

**v3.7.1**: fixes `/bm:version` reporting `Error: Exit code 1` when you are up to date (the update-hint chain exited non-zero; it printed correctly but Claude Code flagged it), and trims its bash. Extends the resilience sweep to `/bm:validate-phase` and `/bm:secure-phase` so the fix-it action is recommended (not a neutral menu).

**v3.7.0**: **Improved resilience when sessions are broken.** When a session drops and resumes, phases can be left partially delivered, and GSD used to either lose the thread or confront you with hard-to-read internals questions. Now it heals instead:
- **Interrupted UATs are never lost.** If you detour mid-verification (a bug to `/bm:quick`, ideas to `/bm:add-phase` / `/bm:explore`), an unfinished UAT becomes a hard invariant in `/bm:next` (resumed before any forward routing) and the detour itself leaves a "↩ resume UAT" breadcrumb.
- **Coverage gates auto-heal instead of interrogating.** When the decision/requirements-coverage gates find a plan that implements a decision but didn't literally tag it, GSD now backfills the `(D-NN)`/REQ-ID tags and proceeds silently (the plan-checker already confirmed the work is covered). Only decisions implemented in *no* plan surface, in plain language with the fix recommended.
- **Leaner `/bm:version`**, inlined and node-free, so it works even when node is broken.

**v3.6.3**: the UI-SPEC gate now honors `auto_advance` (default on). A manual `plan-phase` on a frontend phase auto-generates the UI design contract and continues, instead of dead-ending with a "run `/bm:ui-phase` then re-run" gate. `--no-auto` / `--skip-ui` keep the manual paths, and `/bm:ui-phase` is still there for an interactive design session.

**v3.6.2**: corrects the "how to update" instructions (the `/plugins` Marketplace refresh flow, in the README and in `/bm:version`), and makes `/bm:version` leaner and node-independent so it works even when node is broken.

**v3.6.1**: fixes `/bm:profile-user` and dev-preferences failing with "Template not found" in installs (the bundled SDK resolved templates at a stale nested path), and aligns the `commit_docs` new-project default between the CJS and SDK resolvers.

**v3.6.0**: **Less GSD housekeeping prompts.** GSD now interrupts you only for decisions about what you're building, not its own plumbing.
- **No more rubber-stamp prompts.** Process prompts that just confirmed a recommendation now auto-follow it (announced, with a per-run escape): the "Research first (Recommended)?" gate, the discuss-phase "ready for context?" gate, and the ~8-question new-project setup gauntlet (first run now offers a single "use recommended defaults" gate). Build and design prompts stay interactive.
- **Auto-advance on by default, context-aware.** `auto_advance` now defaults on: cheap phases (<=2 plans) flow plan to execute hands-free; big phases pause for a `/clear` hand-off (clean context plus live wave checkpoints). discuss to plan stays interactive. `--no-auto` opts out per run.
- **Gaps auto-route by severity.** Verification gaps that break the phase goal auto-escalate to gap-closure; minor-only gaps auto-park to backlog, with no "how should these gaps be handled?" prompt.

Recent: v4.0.0 added the convention conformance gate, native drift detection, and a second upstream (VibeDrift), and moved the plugin to its own version line; v3.7.0 added session-resilience healing. Full history in [CHANGELOG.md](./CHANGELOG.md).

> ### Upstream change (May 2026)
>
> In May 2026 the original GSD maintainer TÂCHES (Lex Christopherson) became unreachable, deleted his social accounts, and the associated `$GSD` Solana token was publicly linked to a rug-pull (see external coverage: [intellectia.ai](https://intellectia.ai/news/crypto/gsd-token-allegedly-rugpulled-after-founder-exit), [ourcryptotalk](https://ourcryptotalk.com/news/bags-hackathon-winner-gsd-cloud-rug-pull)).
>
> On 2026-05-22, GSD collaborator [trek-e](https://github.com/trek-e) launched a community continuation at [open-gsd/get-shit-done-redux](https://github.com/open-gsd/get-shit-done-redux): same MIT-licensed code, all 394 branches and 229 tags mirrored bit-for-bit, no token references. The [migration announcement](https://github.com/open-gsd/get-shit-done-redux/discussions/109) details what changed for downstream consumers. The original `gsd-build/get-shit-done` is now locked and auto-closes new issues and PRs.
>
> This plugin treats `open-gsd/get-shit-done-redux` as upstream from `v2.43.6` onward. No code changed at the cutover (the redux is bit-perfect with the pre-rug tree); only URLs and npm package names moved. See [Versioning](#versioning) and [Credits](#credits) for the historical relationship.

## What GSD Plugin provides

- **82 slash commands** (`/bm:*`) for project planning, execution, debugging, and verification
- **33 agent definitions** for specialized workflow roles (planner, executor, researcher, verifier, etc.)
- **85 workflow bodies** in `workflows/`: operational logic that skills delegate to via `@${CLAUDE_PLUGIN_ROOT}/workflows/<name>.md`
- **MCP server** exposing project state as queryable resources and mutation tools
- **Hooks** for session-start context loading, workflow enforcement, checkpoint on compact, and tool-use monitoring
- **Auto-resume across `/compact`**: PreCompact hook writes `.planning/HANDOFF.json`; on the next session, SessionStart auto-invokes `/bm:resume-work` so Claude continues at the same phase/plan/task with zero manual intervention
- **Execution context profiles** (dev, research, review) for role-specific behavior
- **Templates and references** for planning artifacts, summaries, verification checklists, and thinking-model guidance
- **Memory integration**: phase outcomes persist across sessions via Claude Code's memdir

## Session continuity + drift resilience

**Session continuity.** When Claude Code runs `/compact` (manual or automatic), this plugin's PreCompact hook captures the current session state to `.planning/HANDOFF.json`: phase, plan position, uncommitted files, recent decisions, and a resumption hint. On the next session start, the SessionStart hook detects the handoff and auto-invokes `/bm:resume-work` with zero user intervention. CLAUDE.md carries the same instruction as a fallback for CLIs where hooks don't fire. The handoff file is deleted after a successful resume so stale state doesn't trigger phantom resume attempts.

A PostToolUse hook also writes a fresh checkpoint after most tool calls (`Bash`, `Edit`, `Write`, `MultiEdit`, `NotebookEdit`, `Read`, `Grep`, `Glob`, `WebFetch`, `WebSearch`), throttled to at most once per 60 seconds via mtime. This bridges Claude Code's *microcompact* path, which silently strips stale tool outputs without firing PreCompact, AND covers read-heavy research phases that don't write files: the periodic checkpoint keeps `HANDOFF.json` at most ~60s stale at any point during an active session, so resume after an unexpected session end (usage cap, kill, network drop) reflects recent state.

**Drift resilience.** The plugin sits downstream of [upstream GSD](https://github.com/open-gsd/get-shit-done-redux), which ships frequent feature releases. To catch structural drift before it reaches users, three detectors run in CI on every push: a **file-layout drift detector** flags dangling `@~/.claude/get-shit-done/*` references (e.g. skill files delegating to workflow bodies that don't exist in the plugin); a **HANDOFF schema validator** confirms `checkpoint.cjs` output matches the committed JSON Schema; and a **namespace drift check** fires if any `/gsd-<skill>` dash-style command refs have been reintroduced. Each detector has a committed ratchet baseline; regressions hard-fail. After each upstream sync, an additional **upstream schema drift detector** (`check-upstream-schema.cjs`) compares upstream's `pause-work` output against our schema to catch format divergence early.

## Added features beyond upstream

This plugin starts from upstream GSD's source tree but adds Claude-Code-native capabilities that aren't possible in upstream's CLI-only design. If you're scanning for "what does this give me that upstream doesn't", these are the headliners:

| Feature | What it does | Command / hook |
|---------|--------------|----------------|
| **Superpowers skills in the catalog** (v5.0.0) | Five skills from `obra/superpowers` (test-driven development, writing plans, verification before completion, root-cause debugging, and brainstorming), curated as catalog entries: MIT-licensed, pinned to a reviewed commit, proposed on fit through the same trust gate as every other entry, never copied in and never run. Three more propose-on-fit lanes route them to the planner, debugger, and verifier agents, and a CI guard checks the wiring across all nine surfaces. | `sdk/shared/craft-skill-catalog.json`, `references/craft-skill-propose-on-fit.md` |
| **Trusted roots for symlinked global skills** | A global skill whose directory is a symlink to a location outside the runtime skills dir is refused by default; listing that location in `agent_skills_security.trusted_global_roots` accepts it, while the filesystem root and your home directory are never accepted. | `.planning/config.json` |
| **Craft-skill catalog with a trust gate** (v4.9.0) | A curated catalog of external craft skills that holds metadata and pinned commits only (nothing copied into the plugin) that `gsd-tools craft-skill` or `bm-sdk query craft-skill.*` can list, assess and insert into one agent type's `agent_skills` after a structural safety check (publisher allowlist, pinned commit, bundled-scripts review) and a license check (permissive allowed; copyleft and source-available flagged; unlicensed, non-commercial and proprietary blocked), with the human approval recorded in `.planning/craft-skills/pins.json`. Ephemeral by default (`craft-skill release`), sticky with `--sticky`. | `sdk/shared/craft-skill-catalog.json` |
| **Propose-on-fit craft skills** (v4.9.2) | When a quick task, a discussed phase, or an autonomous phase has a scope that hits a catalog trigger, `craft-skill match` (both `gsd-tools craft-skill match` and `bm-sdk query craft-skill.match`) shortlists the candidate deterministically and the model only decides whether it is relevant. Interactive runs show one accept prompt carrying the publisher, the license obligation and the trust tier before an ephemeral insert; autonomous runs auto-insert only when the trust gate returns allow and log the pin. Document deliverables (docx, pdf, pptx) skip the catalog entirely and go to Claude Code's built-in document skills. | `references/craft-skill-propose-on-fit.md` |
| **Propose-on-fit across six specialist surfaces** (v4.9.3) | Propose-on-fit also runs in the UI, security, and code-review flows, not only quick, discuss, and autonomous. Every surface routes matched candidates to the agent it spawns through each catalog entry's `target_agents`: a UI accessibility-audit skill reaches the UI agents, a security-review skill reaches the auditor, a code-review skill reaches the reviewer, and quick, discuss, and autonomous stay on `bm-executor`. The catalog ships eight skills across these lanes. | `references/craft-skill-propose-on-fit.md` |
| **SKILL.md conformance gate + Agent Skills spec watch** (v4.9) | The plugin's own skills are checked against a native subset of the Agent Skills spec (name and description required, allowed-tools well-formed, optional license/compatibility/metadata reported as advisories), a fixed ceiling of 90 skills with a warning from 88, and a description-length ratchet frozen at the longest current description. It runs in CI and the pre-commit hook and fails loudly instead of regenerating its baseline. The spec and its reference linter are watched by a cron script, never vendored or run at startup. `craft-skill assess <id> --validate-external <dir>` optionally runs the pinned upstream linter (`[email protected]` via npx) against an external candidate directory and blocks the verdict on any error. | `node bin/maintenance/check-skill-conformance.cjs`, `bin/check-agentskills-release.sh` |
| **Ship preflight flags a stale verification** (v4.9.2) | `/bm:ship` compares the commit that last wrote the phase VERIFICATION.md against HEAD and warns, with the commit count and a `git log` hint, when the tree has moved on since verification passed. Read-only and advisory: it never blocks and never re-runs verification. | `/bm:ship`, `workflows/ship.md` |
| **Buildomator identity, `/bm:` command surface** (v4.1.0) | The project is Buildomator and every command is `/bm:`. Installs as the `bm` plugin from the `buildomator` marketplace, running the same code an existing install already ran, so migrating is just a prefix swap (the old prefix still resolves during the transition). | `/bm:*` (all commands), `dist/bm/`, [buildomator.com](https://buildomator.com) |
| **Community-health advisory for public repos** (v4.3.0) | On a public GitHub repo missing a LICENSE and/or SECURITY.md, the health check proposes adding them: it reconciles a declared-but-fileless license mechanically, presents the copyleft-vs-permissive tradeoff when nothing is declared, and offers a private-disclosure SECURITY.md. Always proposes, never auto-writes; fails soft on private or non-GitHub repos. | `/gsd:health`, `references/community-health-advisory.md` |
| **Native drift detection** (v4.0.0) | Repo-wide, zero-dep detection of duplicate logic, structural near-clones, and phantom/stub code, with an auditable allowlist. Ranked report plus an opt-in milestone gate. | `gsd-tools verify drift`, `/bm:scan --drift` |
| **Per-language import-habit drift** (v4.9.0) | The convention gate flags Python wildcard and relative imports, Rust glob imports, and Go import ordering by majority vote, alongside the casing and module-system axes. Advisory, directory-scoped, test files excluded. | `gsd-tools verify conventions`, `bin/lib/conventions.cjs` |
| **Convention and architectural conformance gate** (v4.0.0) | Derives your project's naming and architecture conventions by majority vote and flags changed files that deviate, in the existing review path. Never blocks. | `gsd-tools verify conventions`, wired into pattern-mapper + code-review |
| **Weekly plugin self-update watch** (v4.0.0) | Weekly cron emails you when your install is behind the latest tag (Claude Code auto-update is unreliable). Never fails cron. | `bin/check-plugin-update.sh` (cron, not a GSD command) |
| **VibeDrift second-upstream watch** (v4.0.0) | Watches `@vibedrift/cli` releases so its drift heuristics can be ported natively over time. Cron notifier only; vibedrift is never run. | `bin/check-vibedrift-release.sh` (cron, not a GSD command) |
| **Improved resilience when sessions are broken** (v3.7.0) | On a dropped/resumed session, interrupted UATs are never lost and coverage-tagging gaps auto-heal instead of interrogating you. | `/bm:next`, `workflows/plan-phase.md`, `workflows/verify-work.md`, `references/continuation-format.md` |
| **Less GSD housekeeping prompts** (v3.6.0) | Rubber-stamp process prompts auto-follow their recommendation; `auto_advance` is on and context-aware; gaps auto-route by severity. Build/design prompts stay interactive. | `workflows/plan-phase.md`, `workflows/discuss-phase/`, `workflows/execute-phase.md`, `workflow.auto_advance`, `--no-auto` |
| **Reliable default-branch resolution (no more main-vs-master drift)** (v3.4.11; fixed ahead of upstream) | One resolver for the default branch (config, origin/HEAD, `git remote show`, local), so GSD stops forking off a non-existent `main` on `master` repos. | `gsd-tools.cjs base-branch` |
| **Token-overhead reduction across all instruction docs** (v3.4.10) | Trimmed ~1,810 lines of pure overhead from 173 instruction files, behavior unchanged (verified by a multi-agent compact-then-refute pipeline). | (all of `workflows/`, `skills/`, `agents/`, `references/`) |
| **`/bm:version` command** (v3.4.9) | Prints the installed version and checks GitHub tags for the latest, showing update steps only when you are behind. Read-only, never fails the command. | `/bm:version` |
| **Ultracode orchestration signal** (v3.4.8) | A signal that runs fan-out-friendly commands (map-codebase, code-review, review) at maximum multi-agent depth instead of their default. | `workflow.ultracode`, `references/ultracode-mode.md` |
| **Claude Fable model tier** (v3.4.4; `claude-fable-5-1` as of v4.6.0) | A first-class `fable` model tier that the quality profile assigns to the heaviest agents. Anthropic-compatible runtimes resolve it to `claude-fable-5-1`; non-Claude runtimes alias it to their top model. | `sdk/shared/model-catalog.json` |
| **Auto-capture durable decisions in ad-hoc work** (v3.4.1) | `/bm:quick`, `/bm:debug`, `/bm:fast` save durable decisions to Claude Code memory at close-out, so context survives between milestones. Conservative by default. | `workflow.auto_memory_capture` |
| **Gaps auto-route by blocking severity** (v2.45.9; made automatic in v3.6.0) | Verifier `gaps_found` auto-routes by severity: goal-breaking gaps escalate to a follow-up phase, minor gaps park to backlog. No prompt. | `workflows/execute-phase.md`, `agents/bm-verifier.md` |
| **Amend docs into work commit** (v2.45.7) | `/bm:quick` folds PLAN/SUMMARY/STATE into the preceding work commit (one commit per task, not two), falling back to a separate commit when unsafe. | `workflows/quick.md` |
| **Executor self-test bias** (v2.45.6) | Nudges the executor toward automated self-checks instead of `human-verify` prompts that interrupt you. | `agents/bm-executor.md` |
| **User-docs jargon ratchet** (v2.45.4) | Catches GSD-jargon leaks (raw paths, plan IDs, "phase N" prose) in user-facing docs at commit time and in CI, against a baseline. | `bin/maintenance/check-user-docs-jargon.cjs` |
| **User-docs prose ratchet** (v4.7.0) | Catches prose slop (em-dash and en-dash characters, filler marketing words, cliche openers) in the plugin's own README and CHANGELOG at commit time and in CI, against a frozen baseline that fails only on growth. Ported from the ASD-STE100 aerospace writing standard. | `bin/maintenance/check-user-docs-prose.cjs` |
| **Opus tier tracks the latest Claude flagship** (v2.45.1, `claude-opus-5-5` as of v4.9.1) | Resolves `opus` to `claude-opus-5-5` across the Anthropic-compatible runtimes (claude, opencode, copilot, hermes). Sonnet and Haiku follow the same pattern; non-Anthropic runtimes are unchanged. | `sdk/shared/model-catalog.json` |
| **Documentation-Driven Development mode** (v2.44.0) | Sibling to new-project: write a user-facing `docs/SPEC.md`, validate it, then derive phases from its sections. Best for CLIs, libraries, APIs. | `/bm:new-ddd` |
| **Auth-recipe memory** (v2.44.5) | Detects auth commands (gh/aws/ssh, credential env vars) via a hook with secret redaction; promote them to reusable per-project or cross-project recipes. | `/bm:remember-access` |
| **Auto-approve non-critical artifacts** (v2.44.4) | Drops AFK-blocking prompts on ROADMAP/SPEC drafts (logged for review); real risks like verification gaps still prompt. | `workflow.auto_approve_non_critical` |
| **Scheduled resume** | Schedule a future Claude Code session to auto-run a GSD command at a set time (`HH:MM`, ISO, or `+2h`). Handy for quota windows. | `/bm:resume-at <time>` |
| **Auto-resume across `/compact`** | On compaction a `HANDOFF.json` is written and the next session auto-runs `/bm:resume-work` with zero manual input. | PreCompact + SessionStart hooks |
| **Mid-session checkpoints** | A PostToolUse hook writes a fresh checkpoint after most tool calls (throttled), covering Claude Code's silent microcompact gap. | PostToolUse hook |
| **Plugin-version-churn fallback** | If the plugin upd...