Features

---
description: Configure GOAT-CEO optional features — opens an interactive numbered menu to see, toggle, and run feature actions (rubric standards, external research). Typed verbs also work.
argument-hint: "(no args → interactive menu) | status | enable <feature> [repo] | disable <feature> [repo] | set-default <feature> on|off | unset <feature> [repo] | <feature> <action>"
allowed-tools: Read, Write, Edit, Bash(cat:*), Bash(jq:*), Bash(ls:*), Bash(git:*), Bash(rubric:*), Bash(python:*), Bash(cp:*), Bash(grep:*), Task, WebSearch, WebFetch
disable-model-invocation: true
---

# /goat-ceo:features — control GOAT-CEO's optional capabilities

The single entry point to **see, toggle, and drive** GOAT-CEO's OPTIONAL features. The always-on
enforcement layer (the `git add` sweep deny, secret-file denies, the core fail-open gates) is NOT
managed here — that is unconditional; see `/goat-ceo:rules` and `/goat-doctor`.

User input: `$ARGUMENTS`

## How this command runs

- **No arguments → INTERACTIVE MENU MODE (the default, and the normal way to use it).** Present every
  choice with the **`AskUserQuestion` tool** — Claude Code's native selectable-options picker: the
  operator clicks an option or types their own via the auto-added **"Other"**. They drill into a
  feature, then an action, and the loop continues until they quit; they should NEVER need to know verb
  syntax. CONSTRAINT: `AskUserQuestion` allows at most **4 options per question** (plus the automatic
  "Other" free-text), so when a list exceeds 4 (the 8-feature menu, rubric's ~11 actions), **group it
  into ≤4 buckets and drill down** — never hide a feature; "Other" covers anything not shown. Fall back
  to a plain numbered-text menu only if the tool is unavailable.
- **Arguments given → FAST PATH.** Treat the first token as a verb (see the Fast-path table) and
  execute it directly, then offer to drop into the menu. Power-user shortcut; identical effects.

## Live state (read first, every time, before drawing any menu)

Default layer — the shipped baseline (`.claude/goat-features.json`, committed, all-off) overlaid with
YOUR personal overrides (`.claude/goat-features.local.json`, gitignored, local-only):
!`echo 'shipped baseline:'; cat .claude/goat-features.json 2>/dev/null | jq '.defaults' 2>/dev/null || echo '{} (missing — treat as all off)'; echo 'your local overrides:'; cat .claude/goat-features.local.json 2>/dev/null | jq '.defaults' 2>/dev/null || echo '(none)'`

Per-repo activation — `repo-registry.json` (local-only, never published):
!`cat repo-registry.json 2>/dev/null | jq '(.repos // {}) | map_values({access, rubricStatus, researchKbStatus, indexStatus})' 2>/dev/null || echo '(no registry yet)'`

Session toggles — `agent-workspace/` sentinels + env (this session only):
!`( ls agent-workspace/ 2>/dev/null | grep -E '^(STRICT_MODE|AUTONOMOUS-ACTIVE|INTAKE-ACTIVE|STOP|READONLY-PATHS\.json)$' || echo '(no session sentinels)' ); echo "GOAT_CEO_STRICT=${GOAT_CEO_STRICT:-unset}"`

---

## INTERACTIVE MENU MODE  ← do this when `$ARGUMENTS` is empty

Drive the whole flow with the **`AskUserQuestion`** tool so the operator selects from clickable options
(or types their own via "Other"). Loop until they quit. Use the **Feature registry**, **Feature
actions**, and **`rubric seed`** sections below as your reference for each feature's state,
applicability, and what each action does. `AskUserQuestion` caps at **4 options/question** — group
longer lists into ≤4 buckets and drill down; never hide a feature.

### A. Main menu — pick a feature
1. From the live state above, compute each feature's **effective state + source scope** (precedence
   below) and its **applicability** to the current/active repo.
2. Call `AskUserQuestion` ("Which optional feature do you want to configure?") with the features
   GROUPED into ≤4 selectable options so none are hidden — put the current effective state in each
   option's description. A good grouping:
   - **rubric** — standards grounding + RUBRIC.GATE + Reviewer-C (`<state>`)
   - **research-kb** — capture/verify external research KB (`<state>`)
   - **Session modes** — strict-mode / unattended (`<states>`)
   - **Per-repo & manual** — codebase-index / rubric-heal-gate / read-only-ref / destructive-db
   In the question text, tell the operator the **"Other"** box accepts a feature name directly, or
   `status` (full per-tier status) / `quit`.
3. Route: a single-feature option → its **Feature submenu** (B). A group → a second `AskUserQuestion`
   listing that group's features (each ≤4). `status` → print full per-tier status, then re-ask.
   `quit` → summarize changes and stop.

### B. Feature submenu — pick an action
1. Show the feature's state across **all tiers** (built-in / Tier-1 global / Tier-2 per-repo / Tier-3
   session) + applicability in one short block, so the operator sees what overrides what.
2. Call `AskUserQuestion` with that feature's ACTIONS. If it has ≤4, list them directly. If more (e.g.
   rubric), ask the CATEGORY first, then the specific action in a follow-up `AskUserQuestion`:
   - **Toggle** — enable / disable (per-repo) · set personal default · unset override
   - **Inspect** — `status` (what's enforced) · `measure` · `log` (enforcement trail)
   - **Run** — `seed` · `gate <files>` · `verify <file>` · `codify <files>`
   - **Self-heal** — `heal on/off`
   For features with only toggles (`strict-mode`, `unattended`, `codebase-index`), present those
   directly (≤4). For manual/user-scope features (`rubric-heal-gate`, `destructive-db`), the "enable"
   action PRINTS the exact copy/wiring steps and confirms — it never silently edits another repo or
   user settings. Use the question text to offer Back / quit (or rely on "Other").
3. The operator's selection routes to **Acting** (C).

### C. Acting on a choice
- **State changes** (enable/disable/set-default/unset, heal on/off): make the binary/scope decision
  itself an `AskUserQuestion` where natural — `on | off`; **which repo** (off