gate-select

Files (1)

• SKILL.md

SKILL.md (first lines)

> [← Skills index](../../README.md)

## What it does

Single pane of glass + dispatch surface for three gate dimensions the rest of
dev-kit fragments across separate pickers. The project dimension is now
JSON-driven (issue TBD): `.dev-kit/gates.json` is the SSOT for which judge
workflows are on, and `gate-select` is its canonical writer. Workflows
read `vars.GATES_<NAME>_ENABLED` at runtime — toggling a gate is a JSON
edit + `gate-select sync`, not a YAML edit + isolation-hook bypass.

| Dimension | SSOT file | Picker today | What gate-select does |
|---|---|---|---|
| **Project** (CI workflow gates) | `.dev-kit/gates.json` (NEW) + `.dev-kit/ci-config.json` | `/dev-kit:ci-setup` (install) | Reads gates.json + marker; `enable/disable/sync/init` write gates.json; dispatches ci-setup to install based on it. |
| **Session** (local-hook gates) | `.dev-kit/harness-mode.session.json` | `/dev-kit:harness-mode` | Reads mode + per-gate values; dispatches to `harness-mode` to change. |
| **AI-judge** (LLM-judge skills) | (skill-shipped; CI wiring in `.github/workflows/{review,security,maintenance}.yml`) | `/dev-kit:review`, `/dev-kit:security`, `/dev-kit:maintenance` | Reports which judge skills are enabled and whether their CI workflow is wired; dispatches to the right skill. |
| **Optional integrations** | Integration-specific config (Linear: `.dev-kit/linear-config.json`) | `/dev-kit:linear` | Shows and toggles integrations without adding them to `gates.json` or CI workflow installation. |

## Sub-commands

Special-case `linear` aliases take precedence over the generic `<gate>` rows
below; they delegate to `tools/linear_sync.py` and never touch `gates.json`.

| Sub-command | Effect |
|---|---|
| `show` (default) | Read gates.json + marker; print the 3 dimensions. No edits. |
| `classify` | Run `python -m lib.actor_classifier` for the current HEAD; print the actor type + recommended gate. Read-only. |
| `route [--json]` | Run `classify` + write `.dev-kit/.pr-route.json` (the breadcrumb `hooks/pr-create-route.sh` consumes on every `gh pr create`). |
| `pick` | Legacy 6-question picker; threads writes to gates.json + ci-setup. Kept as compat for the original AI-judge picker UX. |
| `enable <gate>` | `python -m lib.gates_state enable <gate>` — flips `gates.<gate>.enabled` to true. |
| `disable <gate>` | `python -m lib.gates_state disable <gate>` — flips `gates.<gate>.enabled` to false. |
| `set <gate> <key> <value>` | Generic field writer (for `enabled`, `workflow`, `var`, or the v1.1.0 dynamic-skip fields `dynamic_eligible`, `scope_globs`, `forced_run`). |
| `enable linear` | `python3 tools/linear_sync.py on` — explicitly opt in to Linear auto-sync. |
| `disable linear` | `python3 tools/linear_sync.py off` — keep the optional Linear integration off. |
| `set linear enabled <true\|false>` | Maps `true` to `python3 tools/linear_sync.py on` and `false` to `python3 tools/linear_sync.py off`; does not write `gates.json`. |
| `sync` | Push enabled flags to `gh variable set GATES_<NAME>_ENABLED`. |
| `init` | Synthesize `.dev-kit/gates.json` from the current `marker.runners` so a consumer that previously used `--exclude security.yml` upgrades in one step. |
| `install-project` | Dispatch to `/dev-kit:ci-setup` (idempotent marker-driven install). |
| `install-session <fast\|full\|custom>` | Dispatch to `/dev-kit:harness-mode`. |
| `eval-dynamic [--head-sha SHA]` | Run the LLM judge (`lib/gate_dynamic.select_gates`) and print the per-gate skip recommendation. Read-only. |
| `apply-dynamic [--head-sha SHA]` | Apply the judge's recommendation (writes `forced_run: true` overrides per gate where `skip=false` survives hard rules). |
| `audit-dynamic [--head-sha SHA]` | Show past decisions from `.dev-kit/gate-dynamic/`. |

```bash
/dev-kit:gate-select                       # = show
/dev-kit:gate-select show                  # explicit read-only
/dev-kit:gate-select classify              # one-shot: actor_type + recommended_gate
/dev-kit:gate-select route --json          # same, plus writes .dev-kit/.pr-route.json
/dev-kit:gate-select enable review         # turn review gate on
/dev-kit:gate-select disable security      # turn security gate off
/dev-kit:gate-select set review enabled true
/dev-kit:gate-select enable linear         # explicitly opt in to Linear auto-sync
/dev-kit:gate-select disable linear        # default/recommended: keep Linear off
/dev-kit:gate-select set linear enabled false
/dev-kit:gate-select sync                  # push to gh variable set
/dev-kit:gate-select init                  # synthesize gates.json from marker
/dev-kit:gate-select pick                  # legacy 6-question picker
/dev-kit:gate-select install-project       # = /dev-kit:ci-setup
/dev-kit:gate-select install-session full  # = /dev-kit:harness-mode full
```

## `show` output

```text
ACTOR ROUTE (lib/actor_classifier, deterministic — never calls gh)
  actor_type:        consumer_fork
  repo_kind:         dev_harness_kit
  recommended_gate:  fork_pr_review_environment
  head_branch:       feat/actor-route-gate-select
  base_branch:       main
  remote:            eve/dev-harness-kit
  reason:            fork PR without maintainer signal — route via
                     fork-pr-review.yml Environment gate (manual approval required)

PROJECT GATES (.dev-kit/gates.json + .dev-kit/ci-config.json marker)
  review.yml     enabled=true   var=GATES_REVIEW_ENABLED
  security.yml   enabled=false  var=GATES_SECURITY_ENABLED   # disabled via gates.json
  maintenance.yml enabled=true  var=GATES_MAINTENANCE_ENABLED
  marker.runners: [ci.yml, auto-fix-pr.yml, review.yml, maintenance.yml]
  marker.gates_source: gates.json

SESSION GATES (.dev-kit/harness-mode.session.json, reset every SessionStart)
  mode: full
  optional (picker-toggled):
    slop_detector, pre_commit_review,
    maintenance, security_owasp, babysit_pr
  correctness (always on): stop_verify, secret_scan, intent_integrity, gh_ci_required

AI-JUDGE GATES (skills shipped with the plugin; scheduled by .github/workflows/*.yml)
  /dev-kit:review        enabled (CI: review.yml,  if: vars.GATES_REVIEW_ENABLED    != 'false')
  /dev-kit:security      enabled (CI: security.yml, if: vars.GATES_SECURITY_ENABLED  != 'false' — but gates.json says disabled; CI gate job SKIPPED)
  /dev-kit:maintenance   enabled (CI: maintenance.yml, if: vars.GATES_MAINTENANCE_ENABLED != 'false')

OPTIONAL INTEGRATIONS (integration-specific SSOT; not part of gates.json)
  Linear API  enabled=false by default in gate-select
  disable     python3 tools/linear_sync.py off
  enable      python3 tools/linear_sync.py on (explicit operator opt-in)
  status      python3 tools/linear_sync.py status
```

### Linear integration policy

Linear remains available for future use, but its API request and complexity
quotas make it unsuitable as an always-on correctness gate. The gate-select
default is therefore **off**. `enable linear` and `disable linear` delegate to
the existing `tools/linear_sync.py` CLI, whose per-worktree
`.dev-kit/linear-config.json` remains the source of truth. This preserves the
four automatic Linear hooks and the manual `/dev-kit:linear` skill without
mixing Linear state into the CI-only `.dev-kit/gates.json` schema.

When Linear is disabled, implicit hooks stay non-blocking and stop before API
sync. To use it later, run `/dev-kit:gate-select enable linear` (or the
explicit `/dev-kit:linear on`) and inspect `/dev-kit:linear status`.

### How `show` reads each dimension

```bash
# Actor route — deterministic; never calls gh.
python3 -m lib.actor_classifier --root . --json

From sh-ai-x/dev-harness-kit, MIT.

More from sh-ai-x/dev-harness-kit