@entelligentsia/forgecli 0.21.0 → 1.0.2

package/dist/forge-payload/commands/calibrate.md

@@ -1,356 +1,10 @@
 ---
 name: calibrate
-description: Detect drift between the knowledge base and agent definitions, propose surgical regeneration patches, and apply approved patches
+description: REMOVED in v1.0 — use /forge:health --fix instead
 ---
 
-# /forge:calibrate
+# /forge:calibrate — Removed
 
-Detect drift between the knowledge base and agent definitions, categorize drift
-by type, propose typed surgical patches as structured regeneration targets,
-gate on explicit Architect approval, and write approved patches to the
-calibration history.
+× `/forge:calibrate` was removed in v1.0. KB drift detection and repair is now handled by `/forge:health --fix` (implemented in T04).
 
-## Locate the Forge plugin
-
-```
-FORGE_ROOT: !`echo "${CLAUDE_PLUGIN_ROOT}"`
-```
-
-Read `.forge/config.json`. If it does not exist, stop and tell the user to run
-`/forge:init` first.
-
-Resolve tools from the plugin:
-```
-FORGE_ROOT: !`echo "${CLAUDE_PLUGIN_ROOT}"`
-```
-
-All tool invocations in this command use `node "$FORGE_ROOT/tools/<tool>.cjs"`.
-
-## Arguments
-
-$ARGUMENTS
-
-| Argument | Purpose |
-|----------|---------|
-| `--path <dir>` | Run calibration against a different project directory instead of the current working directory. Accepts an absolute path or a path relative to the current directory. |
-
----
-
-## Step 0 — Structural-element readiness check
-
-Before the KB drift check, verify that installed structural elements are current
-with the active plugin version. This check is advisory — it does not block the
-existing KB-level drift detection in Steps 2–8.
-
-1. Read current plugin version from `$FORGE_ROOT/.claude-plugin/plugin.json` → `currentVersion`.
-
-2. Check for `.forge/structure-versions.json` (relative to `PROJECT_ROOT` — defer
-   `PROJECT_ROOT` resolution to Step 1; for this step, assume current working directory
-   if `--path` was not yet parsed):
-
-   - **File present**: Read `basePackVersion` and `currentSnapshot` from the file.
-
-     - If `basePackVersion === currentVersion`, emit:
-       > 〇 Structural elements current — snapshot {currentSnapshot} (plugin v{basePackVersion})
-
-     - If `basePackVersion !== currentVersion`, emit:
-       > △ Structural element drift detected — installed elements were generated from plugin v{basePackVersion}; current plugin is v{currentVersion}. Run `/forge:update` to refresh structural elements.
-
-   - **File absent**: emit:
-     > ◇ structure-versions.json absent — project predates snapshot versioning. Run `/forge:update` to install the versioning system.
-
-3. Continue to Step 1 regardless of the readiness check result. The check is informational only.
-
----
-
-## Step 1 — Locate plugin root and config
-
-Resolve `$FORGE_ROOT` from `$CLAUDE_PLUGIN_ROOT`.
-
-Parse `$ARGUMENTS` for `--path <dir>`:
-- If present, `PROJECT_ROOT = <dir>` (absolute or relative to the current working directory — resolve to absolute).
-- If absent, `PROJECT_ROOT = .` (current working directory).
-
-All file paths below are relative to `PROJECT_ROOT`. All shell tool invocations
-must be run from `PROJECT_ROOT`:
-```sh
-cd "$PROJECT_ROOT" && node "$FORGE_ROOT/tools/..."
-```
-
-Read `$PROJECT_ROOT/.forge/config.json`. If absent, emit:
-> △ No Forge instance found — run `/forge:init` to create one.
-
-Exit early.
-
-## Step 2 — Establish or verify calibration baseline
-
-Read `calibrationBaseline` from `$PROJECT_ROOT/.forge/config.json`.
-
-### If absent — auto-initialize
-
-When `calibrationBaseline` is missing, compute and write the initial baseline
-using the same algorithm as `/forge:init` Phase 5/6-b:
-
-1. Read `$FORGE_ROOT/.claude-plugin/plugin.json` → `version`.
-2. Resolve KB path:
-   ```sh
-   cd "$PROJECT_ROOT" && node -e "const cfg=JSON.parse(require('fs').readFileSync('.forge/config.json','utf8')); console.log((cfg.paths&&cfg.paths.engineering)||'engineering')"
-   ```
-3. Compute `MASTER_INDEX.md` hash (strip blank lines + `<!--` lines, SHA-256):
-   ```sh
-   cd "$PROJECT_ROOT" && node -e "const crypto=require('crypto'),fs=require('fs'); const cfg=JSON.parse(fs.readFileSync('.forge/config.json','utf8')); const engPath=(cfg.paths&&cfg.paths.engineering)||'engineering'; const lines=fs.readFileSync(engPath+'/MASTER_INDEX.md','utf8').split('\n').filter(l=>l.trim()&&!l.trim().startsWith('<!--')); console.log(crypto.createHash('sha256').update(lines.join('\n')).digest('hex'))"
-   ```
-4. List completed sprint IDs from `.forge/store/sprints/`:
-   ```sh
-   cd "$PROJECT_ROOT" && node -e "const fs=require('fs'),p='.forge/store/sprints'; try{const files=fs.readdirSync(p).filter(f=>f.endsWith('.json')); const done=files.map(f=>JSON.parse(fs.readFileSync(p+'/'+f,'utf8'))).filter(s=>['done','retrospective-done'].includes(s.status)).map(s=>s.sprintId); console.log(JSON.stringify(done));}catch(e){console.log('[]')}"
-   ```
-5. Get current date: `date -u +"%Y-%m-%d"`
-6. Write `calibrationBaseline` to config:
-   ```sh
-   cd "$PROJECT_ROOT" && node -e "
-   const fs = require('fs');
-   const cfgPath = '.forge/config.json';
-   const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-   cfg.calibrationBaseline = {
-     lastCalibrated: '<date>',
-     version: '<plugin version>',
-     masterIndexHash: '<hash>',
-     sprintsCovered: <sprint IDs array>
-   };
-   fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
-   "
-   ```
-
-Emit:
-
-> 〇 Baseline established — calibration baseline written to config (version: `{version}`, sprints covered: {N})
-
-Exit. The next `/forge:calibrate` run will use this baseline for drift detection.
-
-### If present — proceed to drift detection
-
-Continue to Step 3.
-
-## Step 3 — Detect drift
-
-Compute current `MASTER_INDEX.md` hash using the same algorithm as
-`/forge:init` Phase 5:
-
-```sh
-cd "$PROJECT_ROOT" && node -e "const crypto=require('crypto'),fs=require('fs'); const cfg=JSON.parse(fs.readFileSync('.forge/config.json','utf8')); const engPath=(cfg.paths&&cfg.paths.engineering)||'engineering'; const lines=fs.readFileSync(engPath+'/MASTER_INDEX.md','utf8').split('\n').filter(l=>l.trim()&&!l.trim().startsWith('<!--')); console.log(crypto.createHash('sha256').update(lines.join('\n')).digest('hex'))"
-```
-
-Compare against `calibrationBaseline.masterIndexHash` in config:
-
-- **Match** — emit:
-
-  > 〇 KB calibrated — no drift since last calibration (last: `{calibrationBaseline.lastCalibrated}`, version: `{calibrationBaseline.version}`)
-
-  Exit. No further steps needed.
-
-- **Mismatch** — proceed to Step 4.
-
-## Step 4 — Categorize drift
-
-Read `$PROJECT_ROOT/engineering/MASTER_INDEX.md` and identify which sections
-changed by comparing content areas against the calibration baseline's
-`sprintsCovered`. Read sprint task records from
-`$PROJECT_ROOT/.forge/store/tasks/` and `$PROJECT_ROOT/.forge/store/sprints/`
-to determine what changed since the last calibration.
-
-Categorize each detected drift into one of four categories:
-
-| Category | Detection Trigger | Regeneration Targets |
-|---|---|---|
-| **Technical** | Changes in stack, routing, database, deployment, processes, architecture, schemas, conventions, stack-checklist sections | `personas:engineer`, `skills:engineer-skills`, `skills:supervisor-skills` |
-| **Business** | Changes in entity-model, domain, features, business-domain sections | `personas` (full rebuild — all personas need contextual awareness) |
-| **Retrospective** | Iron-law learnings from completed sprints since last calibration | `personas:<role>` where role had the gap (user specifies at prompt) |
-| **Acceptance criteria** | New acceptance criteria patterns from sprint outcomes | `personas:product-manager`, `skills:qa-engineer` |
-
-For each detected category, build a structured patch entry:
-
-```json
-{
-  "category": "technical",
-  "detectedAt": "<ISO date>",
-  "targets": ["personas:engineer", "skills:engineer-skills", "skills:supervisor-skills"],
-  "evidence": "<brief description of what changed>"
-}
-```
-
-## Step 5 — Propose patches
-
-Present all detected drift categories and their proposed regeneration targets
-to the user. Format:
-
-```
-## Calibration Drift Report
-
-△ Drift detected — {N} categories since last calibration ({lastCalibrated})
-
-### Category 1: Technical
-  Evidence: {what changed}
-  Proposed regeneration:
-    · personas:engineer
-    · skills:engineer-skills
-    · skills:supervisor-skills
-
-### Category 2: Business
-  ...
-
-Apply patches? [Y] Apply all  [r] Review individually  [n] Skip
-```
-
-If no drift categories are detected (hash mismatch but no identifiable
-section-level changes), emit:
-
-> △ Drift detected in MASTER_INDEX.md but no specific category changes identified. Run `/forge:regenerate` to do a full rebuild.
-
-Exit.
-
-### Enhancement agent delegation (structural-element drift)
-
-After presenting the KB-level patch proposals above, also offer enhancement agent Phase 3
-for structural-element drift detection. This is an opt-in upgrade path:
-
-```
-── Enhancement agent available: run structural-element drift detection?
-   This compares .forge/ personas, skills, and workflows against the current codebase state.
-   [E] Run enhancement agent (Phase 3)  [n] Skip
-```
-
-If the user selects `[E]`, read and follow `$FORGE_ROOT/meta/workflows/meta-enhance.md`
-with `--phase 3` explicitly (do not rely on the default). Pass `$PROJECT_ROOT` context.
-The enhancement workflow handles its own approval gate and snapshot creation — return
-to this calibrate flow after it completes.
-
-If `meta-enhance.md` is absent (older plugin version), emit:
-
-> ◇ Enhancement agent not available — run `/forge:update` to install it.
-
-## Step 6 — Architect approval gate
-
-For each proposed patch, require explicit approval before any regeneration.
-No changes are applied without Architect sign-off.
-
-- **`[Y]`**: Approve all patches and proceed to Step 7.
-- **`[r]`**: Walk through each patch, approve or skip individually.
-- **`[n]`**: Exit without changes.
-
-Build the list of approved patches (targets the user confirmed) and the list
-of skipped patches (targets the user declined). Both lists are recorded in
-Step 8.
-
-## Step 7 — Execute approved patches
-
-For each approved patch target, invoke `/forge:regenerate <category> <sub-target>`
-by reading and following `$FORGE_ROOT/commands/regenerate.md`.
-
-Execute in this order (matching the update command's regeneration order):
-1. Personas (full rebuild or single file)
-2. Skills (full rebuild or single file)
-
-If any `/forge:regenerate` invocation fails:
-- Record the patch as `applied: false` in the calibration history (Step 8).
-- Emit: `△ Regeneration failed for <target> — skipping.`
-- Continue with remaining approved patches.
-
-After all patches are applied (or failed), run the generation manifest check:
-
-```sh
-cd "$PROJECT_ROOT" && node "$FORGE_ROOT/tools/check-structure.cjs" --path "$PROJECT_ROOT"
-```
-
-If the tool is absent (file not found), skip this check silently.
-
-## Step 8 — Update calibration state
-
-Recompute the calibration baseline (same algorithm as `/forge:init` Phase 5):
-
-1. Compute new `MASTER_INDEX.md` hash:
-   ```sh
-   cd "$PROJECT_ROOT" && node -e "const crypto=require('crypto'),fs=require('fs'); const cfg=JSON.parse(fs.readFileSync('.forge/config.json','utf8')); const engPath=(cfg.paths&&cfg.paths.engineering)||'engineering'; const lines=fs.readFileSync(engPath+'/MASTER_INDEX.md','utf8').split('\n').filter(l=>l.trim()&&!l.trim().startsWith('<!--')); console.log(crypto.createHash('sha256').update(lines.join('\n')).digest('hex'))"
-   ```
-2. List completed sprint IDs from `.forge/store/sprints/`:
-   ```sh
-   cd "$PROJECT_ROOT" && node -e "const fs=require('fs'),p='.forge/store/sprints'; try{const files=fs.readdirSync(p).filter(f=>f.endsWith('.json')); const done=files.map(f=>JSON.parse(fs.readFileSync(p+'/'+f,'utf8'))).filter(s=>['done','retrospective-done'].includes(s.status)).map(s=>s.sprintId); console.log(JSON.stringify(done));}catch(e){console.log('[]')}"
-   ```
-3. Get current date: `date -u +"%Y-%m-%d"`
-4. Get current plugin version: read `$FORGE_ROOT/.claude-plugin/plugin.json` → `version`
-
-Update `$PROJECT_ROOT/.forge/config.json`:
-1. Replace `calibrationBaseline` with the newly computed values:
-   ```json
-   {
-     "lastCalibrated": "<ISO date>",
-     "version": "<plugin version>",
-     "masterIndexHash": "<new SHA-256 hash>",
-     "sprintsCovered": ["<sprint IDs>"]
-   }
-   ```
-2. Append the calibration run entry to the `calibrationHistory` array. If the
-   array does not exist yet, create it:
-
-   ```json
-   {
-     "calibrationHistory": [
-       {
-         "date": "<ISO date>",
-         "version": "<plugin version>",
-         "categories": ["technical", "business"],
-         "patches": [
-           {"target": "personas:engineer", "type": "regenerate", "applied": true},
-           {"target": "skills:supervisor-skills", "type": "regenerate", "applied": true},
-           {"target": "skills:engineer-skills", "type": "regenerate", "applied": false}
-         ]
-       }
-     ]
-   }
-   ```
-
-   Each patch entry records:
-   - `target`: the regeneration target (e.g. `personas:engineer`, `skills:supervisor-skills`)
-   - `type`: always `"regenerate"` (the only supported patch type)
-   - `applied`: `true` if the patch was approved and regeneration succeeded, `false` if skipped or failed
-
-Write the updated config using the established pattern:
-```sh
-cd "$PROJECT_ROOT" && node -e "
-const fs = require('fs');
-const cfgPath = '.forge/config.json';
-const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-cfg.calibrationBaseline = { /* new values */ };
-if (!cfg.calibrationHistory) cfg.calibrationHistory = [];
-cfg.calibrationHistory.push({ /* new entry */ });
-fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
-"
-```
-
-Alternatively, use `node "$FORGE_ROOT/tools/manage-config.cjs" set` if available.
-
-## Step 9 — Summary
-
-Emit the final summary:
-
-```
-## 〇 Calibration Complete
-
-  Patches applied: {N} of {M}
-  Regenerated: {list of successfully applied targets}
-  Baseline updated: {new lastCalibrated date}
-
-── Run /forge:health to verify knowledge base currency.
-```
-
-If any patches failed, add:
-
-```
-△ Failed patches: {list of failed targets}
-── Re-run /forge:calibrate or manually /forge:regenerate the failed targets.
-```
-
-## On error
-
-If any step above fails unexpectedly, describe what went wrong and ask:
-
-> "This looks like a Forge bug. Would you like to file a report to help improve it? Run `/forge:report-bug` — I'll pre-fill the report from this conversation."
+Run `/forge:health` to check overall knowledge base status.

package/dist/forge-payload/commands/check-agent.md

@@ -0,0 +1,38 @@
+---
+name: check-agent
+description: Verify an agent has loaded and understood the project knowledge base — run a short factual quiz before starting high-stakes tasks
+---
+
+# /forge:check-agent
+
+Verify that the active agent has correctly read and understood this project's
+knowledge base before beginning a high-stakes task (schema changes, migrations,
+release engineering, significant refactors).
+
+## Locate plugin root
+
+```
+FORGE_ROOT: !`echo "${CLAUDE_PLUGIN_ROOT}"`
+```
+
+## Arguments
+
+$ARGUMENTS
+
+## How to Run
+
+Read `.forge/workflows/quiz_agent.md` and follow it exactly.
+
+Pass `$ARGUMENTS` to the workflow so the agent can include task context in its
+responses if provided.
+
+## On error
+
+If `.forge/workflows/quiz_agent.md` does not exist, tell the user:
+
+> △ The quiz_agent workflow is missing. Run `/forge:rebuild workflows` to
+> regenerate it, then retry.
+
+If any other step fails unexpectedly, describe what went wrong and ask:
+
+> "This looks like a Forge bug. Would you like to file a report to help improve it? Run `/forge:report-bug` — I'll pre-fill the report from this conversation."

package/dist/forge-payload/commands/config.md

@@ -1,12 +1,11 @@
 ---
 name: config
-description: Inspect or change Forge project configuration. Owns the mode field — the explicit verb for promoting a fast-mode install to full.
+description: Inspect Forge project configuration.
 ---
 
 # /forge:config
 
-Read or change `.forge/config.json` values that are user-facing decisions
-(currently: `mode`). Other config keys remain managed by their respective
+Read `.forge/config.json` values that are user-facing. Other config keys remain managed by their respective
 commands (e.g. `paths.forgeRoot` is refreshed by `/forge:update`).
 
 ## Locate the Forge plugin
@@ -33,14 +32,10 @@ Parse the argument:
 
 ```
 /forge:config                    # Print summary of .forge/config.json
-/forge:config mode               # Print current mode
-/forge:config mode full          # Promote fast → full
-/forge:config mode fast          # Refused (one-way transition)
 ```
 
 The command shape is reserved for future expansion (e.g. `/forge:config kb
-<path>`, `/forge:config paths <key> <value>`). Only the subcommands above
-are implemented today.
+<path>`, `/forge:config paths <key> <value>`).
 
 ---
 
@@ -52,10 +47,6 @@ For all subcommands, open with a single `north` badge (config = bearings):
 node "$FORGE_ROOT/tools/banners.cjs" --badge north
 ```
 
-Subcommands that change state (`mode full`) also render a `forge` badge
-inside the promotion sequence; subcommands that are read-only just print
-the summary after the badge.
-
 `banners.cjs` strips ANSI in `NO_COLOR` / non-tty / `--plain` contexts.
 
 ---
@@ -66,7 +57,6 @@ Read `.forge/config.json`. Emit a summary block:
 
 ```
 ━━━ Forge Configuration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  mode:        {mode | "unset"}
   version:     {version}
   project:     {project.name} ({project.prefix})
 
@@ -85,7 +75,6 @@ Read `.forge/config.json`. Emit a summary block:
 Use these tool invocations:
 
 ```sh
-node "$FORGE_ROOT/tools/manage-config.cjs" get mode 2>/dev/null || echo "unset"
 node "$FORGE_ROOT/tools/manage-config.cjs" get version
 node "$FORGE_ROOT/tools/manage-config.cjs" get project
 node "$FORGE_ROOT/tools/manage-config.cjs" get paths
@@ -96,105 +85,6 @@ This subcommand is **read-only** — it never writes to disk.
 
 ---
 
-## Subcommand: `/forge:config mode` — print current mode
-
-Read the `mode` field. Print one of:
-
-```
-fast
-full
-unset
-```
-
-Use:
-```sh
-node "$FORGE_ROOT/tools/manage-config.cjs" get mode 2>/dev/null || echo "unset"
-```
-
-Read-only.
-
----
-
-## Subcommand: `/forge:config mode full` — promote fast → full
-
-Promote the project from fast mode to full mode. This is a one-way
-transition: it materialises every deferred artifact and refreshes everything
-that was already materialised, then writes `mode: full`.
-
-### Promotion sequence
-
-1. **Read current mode**:
-   ```sh
-   CURRENT_MODE=$(node "$FORGE_ROOT/tools/manage-config.cjs" get mode 2>/dev/null || echo "unset")
-   ```
-
-2. **Short-circuit if already full**:
-   - If `CURRENT_MODE == "full"`: emit `〇 Already in full mode. Nothing to do.` and exit 0.
-   - If `CURRENT_MODE == "unset"`: treat as `full` (the project predates the
-     mode field — it is already a full install). Emit
-     `〇 mode is unset (legacy full install). Writing mode: full.`, then jump
-     to Step 5 (skip materialize + regenerate, just write the field).
-
-3. **Emit promotion banner** (forge badge + em-dash separator):
-   ```sh
-   node "$FORGE_ROOT/tools/banners.cjs" --badge forge
-   ```
-   ```
-   ━━━ Promoting to Full Mode ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   ```
-
-4. **Run materialize-all**: read `$FORGE_ROOT/commands/materialize.md` and
-   follow the **Full warm-up** branch (no arguments). This fills any
-   missing or stubbed personas, skills, templates, and workflows.
-
-   This step is intentionally invoked by reading the rulebook — do not
-   inline its logic. If materialize errors, surface the error and stop;
-   do not write `mode: full`.
-
-5. **Run default regenerate**: read `$FORGE_ROOT/commands/regenerate.md`
-   and follow the **Default (no argument)** branch. With everything now
-   materialised, every artifact gets refreshed against the current
-   meta-definitions.
-
-   If regenerate errors, surface the error and stop; do not write
-   `mode: full`.
-
-6. **Write `mode: full`**:
-   ```sh
-   node "$FORGE_ROOT/tools/manage-config.cjs" set mode full
-   ```
-
-7. **Emit completion**:
-   ```
-   〇 Promoted to full mode.
-   ```
-
-### Invariant
-
-This is the only code path in the Forge plugin that writes `mode: full`
-after initial install. `regenerate` and `materialize` are
-mode-neutral — they read mode but never write it.
-
----
-
-## Subcommand: `/forge:config mode fast` — refused
-
-Read the current mode.
-
-- If `CURRENT_MODE == "fast"` (or `unset`): emit
-  `〇 Already in fast mode.` and exit 0.
-- Otherwise: emit and exit non-zero (status 1):
-  ```
-  × Cannot downgrade full → fast. Use /forge:remove and re-init to reset.
-  ```
-
-There is no automatic full → fast transition — the artefacts that were
-materialised in full mode are real files with content; "demoting" them
-would mean deleting work without telling the user what was lost. The
-remove-and-re-init path is the explicit, observable way to reset.
-
----
-
 ## On error
 
 If any step above fails unexpectedly, describe what went wrong and ask:

package/dist/forge-payload/commands/enhance.md

@@ -1,38 +1,11 @@
 ---
 name: enhance
-description: Run the enhancement agent to fill placeholders, propose persona enrichments, or detect drift
+description: REMOVED in v1.0 — use /forge:rebuild --enrich instead
 ---
 
-# /forge:enhance
+# /forge:enhance — Removed
 
-Run the Enhancement Agent to improve installed `.forge/` structural elements. The agent
-operates in three modes selected by the `--phase` flag.
+× `/forge:enhance` was removed in v1.0. Enhancement is now a flag on `/forge:rebuild`:
 
-## Locate the Forge plugin
-
-```
-FORGE_ROOT: !`echo "${CLAUDE_PLUGIN_ROOT}"`
-```
-
-Read `$FORGE_ROOT/meta/workflows/meta-enhance.md` and follow it. Pass `$ARGUMENTS` through
-so the workflow receives the phase flag and any other options.
-
-## Arguments
-
-$ARGUMENTS
-
-| Flag | Purpose |
-|------|---------|
-| `--phase 1` | Auto-apply: fill unsubstituted `{{KEY}}` placeholders using codebase signals (post-init mode) |
-| `--phase 2` | Propose diffs: scan sprint artifacts and friction events; propose persona/skill enrichments for user review |
-| `--phase 3` | Drift detection: full codebase vs structural-element comparison; propose targeted patches |
-| `--auto`    | Synonym for `--phase 1` — used by the post-init hook (T09) |
-
-Default: `--phase 3` when no flag is provided.
-
-## On error
-
-If the enhancement workflow is not found at `$FORGE_ROOT/meta/workflows/meta-enhance.md`,
-emit:
-
-> △ meta-enhance.md not found — your installed Forge version may predate the enhancement agent. Run `/forge:update` to upgrade.
+- `/forge:rebuild --enrich` — runs the full enhancement workflow (Phase 2 KB enrichment + Phase 3 drift detection)
+- Enhancement hooks (post-init `--auto`, post-sprint `--phase 2`) continue to fire automatically — no action needed