e22-plugins

Scaffold an autonomous loop for a managed repo — a scheduled GitHub Actions workflow that wakes on its own, triages work (CI failures, open issues, drift) via /steer:audit + /steer:next, drafts fixes in isolated worktrees reviewed by steer-reviewer, and opens draft PRs. Wired to stop at every human gate (rule 53): it delivers up to the PR, it never merges/deploys. Instantiates templates/github/workflows/steer-loop.yml and lands it via the normal autonomous branch-push + PR (Commit autonomy — the merge review is the gate).

Adopt an existing repo that never went through bootstrap (a "vibe-coded" app) into the standards — reverse-engineer the /spec from the code, triage productionization (Keep/Refactor/Rewrite/Reject per area), and sync the plugin's bundled scaffolding without clobbering working code.

Guided flow for a non-technical product owner — idea → interview → approved spec → working local app → handoff for dev review, with Claude driving all tooling.

One-time setup for a new managed repo — bootstrap the /spec spine + repo scaffolding from the plugin's bundled scaffold (the plugin replaces the old static repository-template as the bootstrap source), or resolve placeholders in a legacy template fork. In both cases pin the toolchain and leave the repo working spec-first.

Absorb a PO-supplied spec/roadmap document (docx/pptx/xlsx/pdf) into the /spec spine — version-stamp and commit the binary plus a normalized Markdown extraction under spec/sources/ — relocating the dropped file into that canonical home so it does not linger where it was uploaded — git-diff it against the prior version, and surface a structured what-changed report. Then route the real changes into intent/contract/vision/roadmap and the tracker via the relevant skills, never clobbering human-authored prose (conflicts become Open questions). Idempotent on an unchanged document. In clarify mode, absorbs a client clarification document instead: it segments the extraction, maps each unit against open questions and the feature list, and sorts them into a three-bucket worklist — answers routed to /steer:questions, new scope to the reconcile rows, unmatched surfaced for the human.

Make GitHub branch protection — the real gate against direct-push-to-main — reliable on a managed repo: read policy/branch-protection.yml, diff it against the repo's live protection, and on explicit confirmation apply the missing settings via gh api (branch protection, secret scanning, Dependabot alerts). Verify by default; configures the GitHub-side gate only — steer is advisory in the local session (rule 95) and cannot block local pushes.

Bring an already-bootstrapped managed repo up to date with the current plugin — apply pending structural migrations from the ledger, reconcile the spec spine + scaffold against current templates, repair missing or mis-wired capability-critical wiring, re-stamp /spec/.version, and land a PR. Supports a read-only --check mode; read-then-propose, never clobbers, never commits to main.

Execute a GitHub issue end-to-end from local Claude Code — claim, branch, load linked specs, implement, test, open the PR, and transition lifecycle state; the execution counterpart to /steer:issues, routing all tracker-metadata I/O through /steer:tracker-sync. Pass --reviewed to wrap execution in independent plan- and code-review gates, --hotfix for the production-incident fast path.

Human-facing capabilities menu — renders the router's intent→skill table in plain language, grouped by workflow, so a user can browse what steer can do without knowing any skill name. Read-only; sources the live router table so it can never drift from actual routing.

Sweep loose files out of the repo root into their correct home — source/research materials (incl. spec/requirements PDFs and docs) to /spec/reference, diagrams to /spec/design. Moves confidently-classified strays immediately; proposes renames and deletes and ambiguous cases for a yes.

Sweep every open question across the /spec spine — each feature's intent.md and vision.md — and walk the PO/dev through answering each one, folding the decision back into the spec. In bundle mode, render the PO-answerable open questions across the whole spine as a shareable, fillable Claude Code Artifact (with a Markdown fallback) so a Product Owner with no repo or Claude Code access can answer them in a browser and send the result back through /steer:intake clarify.

The GitHub Issues tracker-metadata gateway for the /spec spine — the single low-level layer /steer:issues and /steer:work call for all issue read/write (search, find-or-create, update, label, set-type, milestone, transition, link, close) plus the PULL/PUSH spec flows. MCP-first with gh CLI fallback; moves tracker metadata, never the spec or git/PR delivery, and never invents tracker state.

Render a high-level, stakeholder-readable view of one feature spec as a shareable Claude Code Artifact — a private, hosted page on claude.ai, built around at-a-glance visuals (a status pipeline, an acceptance meter, a clickable user-journey, scope and open-question boards) so it reads in seconds instead of pages — with a Markdown fallback where Artifacts are unavailable. A read-only, derived view: the /spec and tracker item stay canonical; every visual encodes a real spec value, never fabricates status, dates, or acceptance criteria, never auto-generates per feature, and never writes into /spec, /apps, or /packages.

High-level GitHub Issues lifecycle for the /spec spine — capture, triage, brainstorm, materialize, decompose, epic grouping, status, a ranked relationship-aware board view, and bounded reconcile. A thin orchestrator: it delegates product/spec reasoning to /steer:spec, audit findings to /steer:audit, drift to /steer:audit spec, and question promotion to /steer:questions, and routes GitHub reads/writes through /steer:tracker-sync (MCP-first, gh fallback, manual floor) — with one sanctioned exception, the bootstrap-labels mode's inline label creation. Agent-authored issues follow the machine-readable contract (stable headings + hidden markers + managed blocks). /spec stays product truth; the issue is the work/decision layer.

Spec-only brainstorm for a feature — author and iterate intent.md (and contract.md where behavior demands it) and drive open questions to resolution, WITHOUT writing any code. The no-build counterpart to /steer:build. Also runs `/steer:spec validate [feature-id|--all]`: a local, GitHub-independent structural check over the open-question contract that blocks approval while a blocking question gated at intent-approval is open (later-gated questions block their own gate). Never touches /apps or /packages; ends at an approved intent, not a build.

Load one of steer's full reference prose documents by topic — `conventions` (versioning, mise toolchain & lockfiles, backend placement, local services, monorepo, pnpm/uv, Biome/Ruff, Vitest/pytest, commit messages, baseline patterns), `traceability` (natural-language-to-spec routing, action history, app knowledge docs, client-agnostic tracker integration, drift gates, SOC 2 / ISO 27001-aligned delivery), `design-sources` (Claude Design URL vs local export, where artifacts live, what to read vs not invent, DESIGN.md vs intent.md), `context-hygiene` (delegating heavy runs to subagents, keeping durable state in files so it survives compaction), or `architecture-diagrams` (the global system diagram: Mermaid by default vs an opt-in LikeC4 C4 model, which diagram types, and keeping it current). A read-only loader: it points at the bundled reference file and answers from it.

Cut a steer plugin release — first run a deep, read-only pre-release audit of the plugin codebase (deterministic gate + strict docs build + judgment-based coherence review + deployed-docs freshness) and BLOCK on any release-stopping finding; then pick the semver bump from the accumulated CHANGELOG [Unreleased] entries, rename that heading to the new version, bump every manifest, re-gate, and open the release PR. Repo-local dev helper for e22-plugins; does not ship.

Cut a steer plugin release on the fast path — run only the deterministic, machine-checkable pre-release gates (full CI gate + strict docs build + the cheap deployed-docs freshness check) and BLOCK on any red gate, then cut the release exactly as /release Phase B does (pick the bump, rename the CHANGELOG heading, bump every manifest, re-gate, open the PR). Skips the judgment-based coherence and documentation-accuracy subagent fan-out that /release runs — use it for small, well-understood patch/minor cuts (a hotfix, a one-feature release); use /release for substantive or multi-feature cuts where coherence drift is plausible. Repo-local dev helper for e22-plugins; does not ship.

Load the always-on operating manual on demand. In Claude Code the rules are already injected, so this only repeats them.

File a bug report about the steer plugin ITSELF upstream in element22llc/e22-plugins — gather the defect, scrub secrets/absolute-paths/product-code, dedupe against existing upstream issues, and auto-file it via gh (no confirmation — the scrub redacts or omits anything unredactable rather than asking). For steer's own defects, not product-code bugs (those go to the product tracker via /steer:issues).

Detect and install the local prerequisites a managed repo needs before init/build/dev — git, mise (and the pnpm/uv/node it manages), and Docker — with per-OS guidance and confirmation-gated installs.

Create a feature's spec (intent.md + contract.md) from the bundled templates.

Generate a release timeline for the /spec spine and make it viewable as a GitHub Projects v2 roadmap — turn intended-but-unshipped work into GitHub issues grouped under release milestones with due dates. A thin orchestrator over /steer:issues, /steer:audit spec, and /steer:tracker-sync; the issue + /spec stay canonical, the Project is a derived view, and it never fabricates dates.

Repeatable, read-only audits of a managed repo: `code` mode (default) sweeps the whole repo against the standards dimensions, ranks findings by leverage, and files them in the tracker; `spec` mode compares the as-built /spec against the intended spec from the tracker and surfaces drift; `all` runs both. Repository-read-only — proposes spec changes and files issues but never edits code/spec or commits; defers correctness to /code-review and security to /security-review.

Read-only workspace navigator — reconstructs the whole workspace state cold (branch/PR, /spec feature status, open questions, Proposed ADRs, tracker issues, work claims, version drift) and arbitrates the single best next action across all workflows using the shared categories + safety precedence. Never edits, commits, publishes, merges, or advances state; defers how to resolve each state to the owning skill.

One front door for getting a repo onto the standards — detect the repo's /spec spine state and route to the right bootstrap path (greenfield init, brownfield adopt, or steady-state sync), installing prerequisites first if the toolchain is missing. A thin dispatcher that decides which path applies and hands off — it does not duplicate their logic.

Scaffold a new steer plugin skill with correct frontmatter for its invocation tier, plus a CHANGELOG [Unreleased] stub. Repo-local dev helper for e22-plugins; does not ship. Use when adding a skill under plugins/steer/skills/.

Create a numbered ADR from the bundled template.

Scaffold a new always-on rule under plugins/steer/rules/ — list taken numeric prefixes, propose the next free gap slot, create a lean imperative NN-slug.md stub, and add a CHANGELOG [Unreleased] entry. Repo-local dev helper for e22-plugins; does not ship.

Reconcile the Zensical documentation site under docs/ with the plugin's source of truth — refresh the generated reference pages (skills, hooks, rules) from plugins/steer/, flag stale concept/workflow prose, run the docs validator, and optionally serve the site. Delegates deep accuracy review to the documentation-reviewer subagent. Repo-local dev helper for e22-plugins; does not ship.

Run the e22-plugins verification gates and report a per-gate pass/fail summary, with the single re-run command for any failure. Repo-local dev helper; a thin wrapper over the existing mise tasks — no new validation.