help

## EXECUTE NOW

**Target: $ARGUMENTS**

Parse immediately:
- If target contains `--compact`: force compact mode regardless of vault state
- If target contains a skill name (e.g., "help reduce" or "help reflect"): show detailed help for that specific skill
- If target is empty: determine mode from vault state

**Execute these steps:**

1. Gather vault state (Step 1)
2. Resolve domain vocabulary (Step 2)
3. Determine mode (Step 3)
4. Discover commands dynamically (Step 4)
5. Render the appropriate mode (Step 5)

**START NOW.** Reference below defines each step.

---

## Step 1: Gather Vault State

Determine the **notes folder** by checking which domain-named directory exists (notes/, reflections/, concepts/, ideas/, decisions/, memories/, or any custom name from derivation-manifest.md). Then gather counts:

- **Note count:** `.md` files in the notes folder, excluding MOCs (files with `type: moc` in frontmatter)
- **Inbox count:** `.md` files in the inbox folder (inbox/, journal/, encounters/, etc.)
- **Observation count:** `.md` files in `ops/observations/` or `ops/methodology/`
- **Tension count:** `.md` files in `ops/tensions/`
- **Connection density:** count wiki links (`[[`) across notes folder; sparse if fewer than 2x note count
- **Queue state:** pending tasks in `ops/queue/queue.yaml` or `ops/queue/queue.json`
- **Health warnings:** check latest report in `ops/health/` if it exists
- **Tutorial state:** check `ops/tutorial-state.yaml` for incomplete tutorial
- **Session count:** estimate from `ops/sessions/` file count (indicates usage maturity)

```bash
# Quick state gathering
note_count=$(ls -1 {vocabulary.notes}/*.md 2>/dev/null | wc -l | tr -d ' ')
inbox_count=$(ls -1 {vocabulary.inbox}/*.md 2>/dev/null | wc -l | tr -d ' ')
obs_count=$(ls -1 ops/observations/*.md ops/methodology/*.md 2>/dev/null | wc -l | tr -d ' ')
tension_count=$(ls -1 ops/tensions/*.md 2>/dev/null | wc -l | tr -d ' ')
```

## Step 2: Resolve Domain Vocabulary

Read `ops/derivation-manifest.md` (or fall back to `ops/derivation.md` Vocabulary Mapping section). Extract domain-native names for: reduce, reflect, reweave, verify, rethink, note, MOC, inbox. If neither file exists, use universal names.

For display, show domain name with universal in parentheses when they differ:
```
  /{domain:reduce} (reduce)   Extract patterns from journal entries
```

If domain name equals universal name, show just the name:
```
  /reduce   Extract insights from source material
```

## Step 3: Determine Mode

| Condition | Mode |
|-----------|------|
| `--compact` in arguments | Compact |
| Specific skill name in arguments | Skill detail |
| Note count < 5 | Narrative |
| Note count >= 5 | Contextual |

## Step 4: Discover Commands

Scan `${CLAUDE_PLUGIN_ROOT}/skills/` dynamically:
- Subdirectories containing `SKILL.md` (e.g., `reduce/SKILL.md`)

Extract `name:` and `description:` from each frontmatter. Do NOT hardcode the command list.

**Command categories:**

| Category | Commands | When to Show |
|----------|----------|-------------|
| Core | /ask, /learn, /next, /help | Always |
| Processing | /reduce, /reflect, /reweave, /verify | Always (all skills from day one) |
| Maintenance | /health, /rethink, /remember | Always |
| Evolution | /architect, /reseed, /add-domain, /upgrade | Always |
| Meta | /tutorial, /graph, /stats | Always |

## Step 5: Render

### NARRATIVE MODE (note count < 5)

This is the first impression. The user is new or nearly new. Explain what the system IS before listing what it DOES.

**What narrative mode communicates:**
1. What Ars Contexta is (one sentence)
2. What THEIR system was built to do (read from ops/derivation.md if available)
3. What they can do RIGHT NOW (concrete actions, not abstract possibilities)
4. How the system grows with them

```
--=={ ars contexta : help }==--

Your knowledge system is ready. It turns thoughts
into a connected graph where every note compounds
the value of every other note.

[If ops/derivation.md exists:]
Your system: [domain description from derivation]

Getting started:

  Tell me a thought, observation, or question.
  I will turn it into a note and show you what
  the system does with it.

  Or try one of these:

  /ask [question]    Ask about [domain] -- I will
                     answer from your graph
  /learn [topic]     Research [topic] and grow
                     your graph with findings
  /tutorial          Walk through the system
                     step by step (5 minutes)

As your graph grows, you will use:
  /reduce [source]   Extract insights from articles,
                     notes, or any raw material
  /reflect           Find connections between notes
  /health            Check your system's health

Your system also learns from experience:
  /remember             Capture when something goes wrong
                        (your system remembers corrections)
  /ask [question]       Ask about [domain] -- answers draw
                        from 249 methodology notes AND your
                        system's own methodology notes

Type /help anytime for guidance.
```

**Manual reference (if manual/ exists):**
If the vault contains a `manual/` directory, add to the narrative output:
```
  For a deeper guide, read manual/getting-started.md
  or explore the full manual in manual/manual.md.
```

**Key principles for narrative mode:**
- Conversational, not list-like
- Show the easiest entry point first ("tell me a thought")
- Group commands by when the user would need them, not alphabetically
- Reference the user's actual domain when possible
- If tutorial is incomplete, mention: "You have an unfinished tutorial (step N of 5). Resume with /tutorial"

### CONTEXTUAL MODE (note count >= 5)

The user has been working. Show them what is happening NOW and what would be most valuable NEXT.

**What contextual mode communicates:**
1. Current system state (brief metrics)
2. What needs attention right now (state-aware)
3. Suggested next action (the single most