@jmylchreest/aide-plugin 0.0.26 → 0.0.28

package/skills/ralph/SKILL.md

@@ -35,39 +35,43 @@ You are now in **Ralph Wiggum mode** - an iterative development methodology that
 All state is managed through aide. Use MCP tools for reads, CLI for writes:
 
 ### Reads (MCP Tools)
-| Tool | Purpose |
-|------|---------|
-| `mcp__plugin_aide_aide__state_get` | Get phase, objective |
-| `mcp__plugin_aide_aide__state_list` | List all state |
-| `mcp__plugin_aide_aide__decision_get` | Get decisions |
-| `mcp__plugin_aide_aide__decision_list` | List all decisions |
-| `mcp__plugin_aide_aide__memory_search` | Search discoveries |
+
+| Tool                                   | Purpose              |
+| -------------------------------------- | -------------------- |
+| `mcp__plugin_aide_aide__state_get`     | Get phase, objective |
+| `mcp__plugin_aide_aide__state_list`    | List all state       |
+| `mcp__plugin_aide_aide__decision_get`  | Get decisions        |
+| `mcp__plugin_aide_aide__decision_list` | List all decisions   |
+| `mcp__plugin_aide_aide__memory_search` | Search discoveries   |
 
 ### Writes (CLI via Bash)
+
 ```bash
 # Phase tracking
-aide state set ralph:phase planning   # or "building"
+./.aide/bin/aide state set ralph:phase planning   # or "building"
 
 # Task management (use Claude's native TaskCreate/TaskUpdate/TaskList)
 
 # Decisions
-aide decision set <topic> "<decision>" --rationale="<why>"
+./.aide/bin/aide decision set <topic> "<decision>" --rationale="<why>"
 
 # Gap analysis / discoveries
-aide memory add --category=discovery --tags=ralph "Gap found: <description>"
+./.aide/bin/aide memory add --category=discovery --tags=ralph "Gap found: <description>"
 ```
 
+**Binary location:** The aide binary is at `.aide/bin/aide`. If it's on your `$PATH`, you can use `aide` directly.
+
 ---
 
 ## Phase 1: Planning Mode
 
-When starting a new task or when `aide state get ralph:phase` is empty/planning:
+When starting a new task or when `./.aide/bin/aide state get ralph:phase` is empty/planning:
 
 ### Step 1: Set Phase
 
 ```bash
-aide state set ralph:phase planning
-aide state set ralph:objective "<what we're building>"
+./.aide/bin/aide state set ralph:phase planning
+./.aide/bin/aide state set ralph:objective "<what we're building>"
 ```
 
 ### Step 2: Gap Analysis (Don't Assume!)
@@ -83,8 +87,9 @@ rg "describe.*feature\|it.*should" --type ts
 ```
 
 Record findings:
+
 ```bash
-aide memory add --category=discovery --tags=ralph,gap-analysis "Searched for X: <results>"
+./.aide/bin/aide memory add --category=discovery --tags=ralph,gap-analysis "Searched for X: <results>"
 ```
 
 Only after confirming gaps exist, proceed to task creation.
@@ -94,12 +99,13 @@ Only after confirming gaps exist, proceed to task creation.
 Create atomic, testable tasks:
 
 ```bash
-aide task create "Implement user model" --tags=ralph,task-1
-aide task create "Add validation to user model" --tags=ralph,task-2
-aide task create "Write user model tests" --tags=ralph,task-3
+./.aide/bin/aide task create "Implement user model" --tags=ralph,task-1
+./.aide/bin/aide task create "Add validation to user model" --tags=ralph,task-2
+./.aide/bin/aide task create "Write user model tests" --tags=ralph,task-3
 ```
 
 Each task should be:
+
 - Small enough to complete in one iteration
 - Independently testable
 - Clearly defined acceptance criteria
@@ -107,19 +113,20 @@ Each task should be:
 ### Step 4: Record Key Decisions
 
 ```bash
-aide decision set ralph:test-framework "vitest" --rationale="Already configured in project"
-aide decision set ralph:approach "<approach>" --rationale="<why>"
+./.aide/bin/aide decision set ralph:test-framework "vitest" --rationale="Already configured in project"
+./.aide/bin/aide decision set ralph:approach "<approach>" --rationale="<why>"
 ```
 
 ### Step 5: Exit Planning
 
 ```bash
-aide state set ralph:phase building
+./.aide/bin/aide state set ralph:phase building
 ```
 
 Report the plan:
-- List tasks: `aide task list`
-- List decisions: `aide decision list`
+
+- List tasks: `./.aide/bin/aide task list`
+- List decisions: `./.aide/bin/aide decision list`
 
 **DO NOT implement during planning phase.**
 
@@ -127,7 +134,7 @@ Report the plan:
 
 ## Phase 2: Building Mode
 
-When `aide state get ralph:phase` returns "building":
+When `./.aide/bin/aide state get ralph:phase` returns "building":
 
 ### Iteration Loop
 
@@ -137,26 +144,34 @@ Each iteration follows this exact sequence:
 
 ```bash
 # Check current phase and objective
-aide state get ralph:phase
-aide state get ralph:objective
+./.aide/bin/aide state get ralph:phase
+./.aide/bin/aide state get ralph:objective
 
 # List tasks to find next one
-aide task list
+./.aide/bin/aide task list
 
 # Check existing decisions
-aide decision list
+./.aide/bin/aide decision list
 ```
 
 #### 2. Select Next Task
 
 Find the first pending task:
+
 ```bash
-aide task list  # Look for [pending] status
+./.aide/bin/aide task list  # Look for [pending] status
 ```
 
 Claim it:
+
 ```bash
-aide task claim <task-id> --agent=ralph
+./.aide/bin/aide task claim <task-id> --agent=ralph
+```
+
+Claim it:
+
+```bash
+./.aide/bin/aide task claim <task-id> --agent=ralph
 ```
 
 #### 3. Verify Gap Still Exists (Don't Assume!)
@@ -169,8 +184,9 @@ rg "featureName" --type ts
 ```
 
 If gap no longer exists:
+
 ```bash
-aide task complete <task-id>
+./.aide/bin/aide task complete <task-id>
 # Proceed to next task
 ```
 
@@ -198,6 +214,7 @@ npm test -- path/to/test.test.ts
 ```
 
 **BLOCKING RULE**: If tests fail, you MUST:
+
 1. Analyze the failure
 2. Fix the issue
 3. Re-run tests
@@ -208,7 +225,7 @@ npm test -- path/to/test.test.ts
 #### 7. Complete Task
 
 ```bash
-aide task complete <task-id>
+./.aide/bin/aide task complete <task-id>
 ```
 
 #### 8. Atomic Commit
@@ -221,7 +238,7 @@ git commit -m "feat: <task description> - tests passing"
 #### 9. Check Completion
 
 ```bash
-aide task list
+./.aide/bin/aide task list
 ```
 
 If more pending tasks: continue to next iteration (step 2)
@@ -241,16 +258,19 @@ When tests fail during backpressure checkpoint:
 4. **DO** fix and re-run until passing
 
 Record blockers:
+
 ```bash
-aide memory add --category=blocker --tags=ralph "Test failure: <description>"
+./.aide/bin/aide memory add --category=blocker --tags=ralph "Test failure: <description>"
 ```
 
 ### Stuck Conditions
 
 If blocked for more than 3 attempts:
+
 ```bash
-aide memory add --category=blocker --tags=ralph,needs-help "Stuck on: <description>"
+./.aide/bin/aide memory add --category=blocker --tags=ralph,needs-help "Stuck on: <description>"
 ```
+
 Then ask user for guidance. **DO NOT** proceed without resolution.
 
 ---
@@ -261,7 +281,7 @@ Before claiming completion, ALL must pass:
 
 ```bash
 # 1. All tasks complete
-aide task list  # Should show all [done]
+./.aide/bin/aide task list  # Should show all [done]
 
 # 2. All tests
 npm test
@@ -284,14 +304,14 @@ When all tasks complete and verification passes:
 ### Update State
 
 ```bash
-aide state set ralph:phase complete
-aide state set ralph:result "success"
+./.aide/bin/aide state set ralph:phase complete
+./.aide/bin/aide state set ralph:result "success"
 ```
 
 ### Record Session
 
 ```bash
-aide memory add --category=session --tags=ralph,implementation "
+./.aide/bin/aide memory add --category=session --tags=ralph,implementation "
 ## <Feature Name> Complete
 
 Implemented using Ralph Wiggum methodology.
@@ -338,21 +358,21 @@ Implemented using Ralph Wiggum methodology.
 
 ```
 PLANNING PHASE:
-1. aide state set ralph:phase planning
+1. ./.aide/bin/aide state set ralph:phase planning
 2. Search code (don't assume!)
-3. aide memory add findings
-4. aide task create (atomic tasks)
-5. aide decision set (key decisions)
-6. aide state set ralph:phase building
+3. ./.aide/bin/aide memory add findings
+4. ./.aide/bin/aide task create (atomic tasks)
+5. ./.aide/bin/aide decision set (key decisions)
+6. ./.aide/bin/aide state set ralph:phase building
 
 BUILDING PHASE (per task):
-1. aide task list (find next)
-2. aide task claim <id>
+1. ./.aide/bin/aide task list (find next)
+2. ./.aide/bin/aide task claim <id>
 3. Re-verify gap exists
 4. Write failing tests
 5. Implement
 6. BACKPRESSURE: Tests MUST pass
-7. aide task complete <id>
+7. ./.aide/bin/aide task complete <id>
 8. Atomic commit
 9. Repeat or verify completion
 ```
@@ -362,10 +382,11 @@ BUILDING PHASE (per task):
 ## Swarm Compatibility
 
 This skill is **swarm-compatible**. Multiple ralph agents can:
+
 - Work on different tasks in parallel
-- Share discoveries via `aide memory`
-- Check decisions via `aide decision get`
-- Claim tasks atomically via `aide task claim`
+- Share discoveries via `./.aide/bin/aide memory`
+- Check decisions via `./.aide/bin/aide decision get`
+- Claim tasks atomically via `./.aide/bin/aide task claim`
 
 No file conflicts because all state is in aide's database.
 
@@ -390,8 +411,9 @@ Instead, independently verify the implementation against the original objective.
 The QA agent must:
 
 #### a) Load the Objective (not the task list)
+
 ```bash
-aide state get ralph:objective
+./.aide/bin/aide state get ralph:objective
 ```
 
 #### b) Independent Verification
@@ -411,39 +433,42 @@ aide state get ralph:objective
 #### c) Find & Fix Gaps
 
 If gaps are found:
+
 ```bash
 # Record the gap
-aide memory add --category=discovery --tags=ralph,qa "QA found gap: <description>"
+./.aide/bin/aide memory add --category=discovery --tags=ralph,qa "QA found gap: <description>"
 
 # Create fix task
-aide task create "QA fix: <description>" --tags=ralph,qa-fix
+./.aide/bin/aide task create "QA fix: <description>" --tags=ralph,qa-fix
 
 # Implement the fix (follow standard backpressure rules)
 # ...
 
 # Mark complete
-aide task complete <id>
+./.aide/bin/aide task complete <id>
 ```
 
 #### d) Final Sign-off
 
 Only when QA agent confirms:
+
 - All tests passing
 - Build clean
 - Lint clean
 - Objective fully met (not just tasks)
 
 ```bash
-aide state set ralph:qa "passed"
-aide state set ralph:phase complete
+./.aide/bin/aide state set ralph:qa "passed"
+./.aide/bin/aide state set ralph:phase complete
 ```
 
 ### Step 3: QA Failure Handling
 
 If QA finds unfixable issues:
+
 ```bash
-aide state set ralph:qa "failed"
-aide memory add --category=blocker --tags=ralph,qa "QA failed: <reason>"
+./.aide/bin/aide state set ralph:qa "failed"
+./.aide/bin/aide memory add --category=blocker --tags=ralph,qa "QA failed: <reason>"
 ```
 
 Report to user with specific failures. **DO NOT** mark complete.

package/skills/swarm/SKILL.md

@@ -87,6 +87,7 @@ If no plan exists, break the work into independent stories/features:
 ```
 
 Each story should be:
+
 - Independent (can be developed in parallel)
 - Complete (has clear boundaries)
 - Testable (has acceptance criteria)
@@ -102,17 +103,20 @@ git worktree add .aide/worktrees/story-dashboard -b feat/story-dashboard
 ```
 
 **Automatic Integration:**
+
 - Worktrees in `.aide/worktrees/` are **auto-discovered** by AIDE hooks
 - When agents spawn, their worktree path is **auto-injected** into context
 - When agents complete, worktrees are marked as **"agent-complete"** (ready for merge)
 - Worktree state is tracked in `.aide/state/worktrees.json`
 
 **Naming Convention:**
+
 - Use `story-<name>` as worktree directory name
 - Use matching `agent-<name>` as agent_id when spawning
 - Example: `story-auth` worktree → spawn with `agent_id` containing "auth"
 
 **If worktree creation fails:**
+
 1. Check if branch exists: `git branch -a | grep feat/story-auth`
 2. Remove stale worktree: `git worktree remove .aide/worktrees/story-auth --force`
 3. Prune refs: `git worktree prune`
@@ -123,6 +127,7 @@ git worktree add .aide/worktrees/story-dashboard -b feat/story-dashboard
 Launch agents using the Task tool with `subagent_type: "general-purpose"` (required for Edit/Write access).
 
 **IMPORTANT: Task Ownership**
+
 - The ORCHESTRATOR does NOT create SDLC tasks
 - Each SUBAGENT creates and manages its OWN tasks
 - Orchestrator only monitors via `TaskList`
@@ -201,8 +206,10 @@ Use native Claude Code task tools to track your progress:
 
 **Shared state (MCP + CLI):**
 - Check decisions: \`mcp__plugin_aide_aide__decision_get\` (MCP read)
-- Record decisions: \`aide decision set <topic> "<decision>"\` (CLI write)
-- Share discoveries: \`aide memory add --category=discovery "<finding>"\` (CLI write)
+- Record decisions: \`./.aide/bin/aide decision set <topic> "<decision>"\` (CLI write)
+- Share discoveries: \`./.aide/bin/aide memory add --category=discovery "<finding>"\` (CLI write)
+
+**Binary location:** The aide binary is at \`.aide/bin/aide\`. If it's on your \`$PATH\`, you can use \`aide\` directly.
 
 ## Completion
 When all 5 stages are complete:
@@ -223,6 +230,7 @@ TaskList
 ```
 
 Example output:
+
 ```
 #10 [completed] [story-auth][DESIGN] Design auth module (agent-auth)
 #11 [completed] [story-auth][TEST] Write auth tests (agent-auth)
@@ -249,13 +257,13 @@ mcp__plugin_aide_aide__memory_list with category=blocker
 
 ## SDLC Stage Reference
 
-| Stage | Skill | Creates | Depends On |
-|-------|-------|---------|------------|
-| DESIGN | `/aide:design` | Interfaces, decisions, acceptance criteria | - |
-| TEST | `/aide:test` | Failing tests | DESIGN |
-| DEV | `/aide:implement` | Passing implementation | TEST |
-| VERIFY | `/aide:verify` | Quality validation | DEV |
-| DOCS | `/aide:docs` | Updated documentation | VERIFY |
+| Stage  | Skill             | Creates                                    | Depends On |
+| ------ | ----------------- | ------------------------------------------ | ---------- |
+| DESIGN | `/aide:design`    | Interfaces, decisions, acceptance criteria | -          |
+| TEST   | `/aide:test`      | Failing tests                              | DESIGN     |
+| DEV    | `/aide:implement` | Passing implementation                     | TEST       |
+| VERIFY | `/aide:verify`    | Quality validation                         | DEV        |
+| DOCS   | `/aide:docs`      | Updated documentation                      | VERIFY     |
 
 ### VERIFY → BUILD-FIX Loop
 
@@ -277,6 +285,7 @@ mcp__plugin_aide_aide__memory_list with category=blocker
 ```
 
 If VERIFY fails:
+
 1. `/aide:build-fix` to fix issues
 2. Re-run `/aide:verify`
 3. Repeat until passing
@@ -290,11 +299,13 @@ When spawning story agents, include:
 You are story agent [AGENT-ID] working in worktree [PATH].
 
 ## Story
+
 [Story name and description]
 
 ## SDLC Pipeline
 
 Execute these stages in order. For each stage:
+
 1. Create task with TaskCreate (set blockedBy for dependencies)
 2. Claim task with TaskUpdate (owner=your-id, status=in_progress)
 3. Execute stage using appropriate skill
@@ -303,60 +314,64 @@ Execute these stages in order. For each stage:
 ### Stage Tasks to Create
 
 TaskCreate({
-  subject: "[STORY-ID][DESIGN] Design [feature]",
-  description: "Technical design with interfaces and acceptance criteria",
-  activeForm: "Designing [feature]"
+subject: "[STORY-ID][DESIGN] Design [feature]",
+description: "Technical design with interfaces and acceptance criteria",
+activeForm: "Designing [feature]"
 })
 
 TaskCreate({
-  subject: "[STORY-ID][TEST] Write tests for [feature]",
-  description: "Failing tests based on acceptance criteria",
-  activeForm: "Writing tests"
+subject: "[STORY-ID][TEST] Write tests for [feature]",
+description: "Failing tests based on acceptance criteria",
+activeForm: "Writing tests"
 })
 // ... set blockedBy to DESIGN task ID
 
 TaskCreate({
-  subject: "[STORY-ID][DEV] Implement [feature]",
-  description: "Make tests pass with minimal code",
-  activeForm: "Implementing [feature]"
+subject: "[STORY-ID][DEV] Implement [feature]",
+description: "Make tests pass with minimal code",
+activeForm: "Implementing [feature]"
 })
 // ... set blockedBy to TEST task ID
 
 TaskCreate({
-  subject: "[STORY-ID][VERIFY] Verify [feature]",
-  description: "Full test suite, lint, type check",
-  activeForm: "Verifying [feature]"
+subject: "[STORY-ID][VERIFY] Verify [feature]",
+description: "Full test suite, lint, type check",
+activeForm: "Verifying [feature]"
 })
 // ... set blockedBy to DEV task ID
 
 TaskCreate({
-  subject: "[STORY-ID][DOCS] Document [feature]",
-  description: "Update documentation",
-  activeForm: "Documenting [feature]"
+subject: "[STORY-ID][DOCS] Document [feature]",
+description: "Update documentation",
+activeForm: "Documenting [feature]"
 })
 // ... set blockedBy to VERIFY task ID
 
 ## Coordination
 
 **Messaging (MCP tools):**
+
 - Send status: `message_send` with from=[AGENT-ID], type="status", content="[STAGE] complete"
 - Send blocker: `message_send` with from=[AGENT-ID], type="blocker", content="description"
 - Check inbox: `message_list` with agent_id=[AGENT-ID]
 - Acknowledge: `message_ack` with message_id=N, agent_id=[AGENT-ID]
 
 **At each stage transition:**
+
 1. Check messages via `message_list`
 2. Acknowledge and act on any requests
 3. Send `status` message with new stage name
 
 **Shared state:**
+
 - Check existing decisions: `mcp__plugin_aide_aide__decision_get` (MCP read)
-- Record new decisions: `aide decision set <topic> "<decision>"` (CLI write)
-- Share discoveries: `aide memory add --category=discovery "<finding>"` (CLI write)
+- Record new decisions: `./.aide/bin/aide decision set <topic> "<decision>"` (CLI write)
+- Share discoveries: `./.aide/bin/aide memory add --category=discovery "<finding>"` (CLI write)
 
 ## VERIFY Failure Handling
 
 If VERIFY stage fails:
+
 1. DO NOT proceed to DOCS
 2. Invoke /aide:build-fix to address failures
 3. Re-run /aide:verify
@@ -366,6 +381,7 @@ If VERIFY stage fails:
 ## Completion
 
 All stages must complete. When done:
+
 1. All 5 tasks show [completed]
 2. VERIFY must have passed (not skipped)
 3. All changes committed to your worktree branch
@@ -386,6 +402,7 @@ This uses the original task-grabbing model without SDLC stages.
 ## Coordination via aide
 
 **Messages** (MCP tools — primary coordination mechanism):
+
 ```
 # Send status update (broadcast)
 message_send: from="agent-auth", type="status", content="[DESIGN] complete, starting TEST"
@@ -401,16 +418,24 @@ message_ack: message_id=42, agent_id="agent-auth"
 ```
 
 **Decisions** (shared across agents):
+
 ```bash
 # Write (CLI)
-aide decision set "auth-strategy" "JWT with refresh tokens"
+./.aide/bin/aide decision set "auth-strategy" "JWT with refresh tokens"
 
 # Read (MCP) - use mcp__plugin_aide_aide__decision_get with topic="auth-strategy"
 ```
 
 **Memory** (shared discoveries):
+
+```bash
+./.aide/bin/aide memory add --category=discovery "User model needs email validation"
+```
+
+**Memory** (shared discoveries):
+
 ```bash
-aide memory add --category=discovery "User model needs email validation"
+./.aide/bin/aide memory add --category=discovery "User model needs email validation"
 ```
 
 ## OpenCode Mode
@@ -418,11 +443,13 @@ aide memory add --category=discovery "User model needs email validation"
 OpenCode does not have native subagent support. For multi-agent swarms with OpenCode:
 
 **Setup:**
+
 1. Create worktrees as normal (one per story)
 2. Launch separate OpenCode terminal sessions, one per story
 3. Each session works in its assigned worktree directory
 
 **Coordination:**
+
 - **No TaskList** — OpenCode sessions don't share a task system
 - **Use aide messages** as the primary coordination mechanism:
   - Each session uses `message_send` to report status, blockers, and completion
@@ -430,12 +457,13 @@ OpenCode does not have native subagent support. For multi-agent swarms with Open
   - The orchestrator monitors all agents via `message_list` with their own agent_id
 - **Use aide state** for progress tracking:
   ```bash
-  aide state set "agent-auth:stage" "TEST"
-  aide state set "agent-auth:status" "running"
+  ./.aide/bin/aide state set "agent-auth:stage" "TEST"
+  ./.aide/bin/aide state set "agent-auth:status" "running"
   ```
 - Monitor all agents: `mcp__plugin_aide_aide__state_list`
 
 **Orchestrator role (human or primary session):**
+
 1. Decompose stories (use `/aide:plan-swarm` first)
 2. Create worktrees
 3. Launch terminal sessions with instructions
@@ -447,35 +475,47 @@ OpenCode does not have native subagent support. For multi-agent swarms with Open
 Swarm completion checklist - ALL REQUIRED:
 
 ### Step 1: Verify All Stories Complete
+
 ```
 TaskList  # All story tasks must show [completed]
 ```
+
 - Every story must have completed all 5 SDLC stages
 - No tasks should be [pending] or [in_progress]
 
 ### Step 2: Check for Blockers
+
 Use `mcp__plugin_aide_aide__memory_list` with category=blocker
+
 - If blockers exist, resolve them before proceeding
 - Use `/aide:build-fix` for any remaining build/test issues
 
 ### Step 3: Final Verification
+
 Run verification on each worktree:
+
 ```bash
 cd .aide/worktrees/story-X && npm test && npm run build
 ```
+
 - If any fail, invoke `/aide:build-fix` and re-verify
 
 ### Step 4: Merge Worktrees (MANDATORY)
+
 **YOU MUST invoke `/aide:worktree-resolve`** - this is not optional.
+
 ```
 /aide:worktree-resolve
 ```
+
 This skill will:
+
 - Merge each story branch into main
 - Handle any merge conflicts
 - Clean up worktrees
 
 ### Step 5: Record Session
+
 Only after successful merge, record the swarm session (see Orchestrator Memory below).
 
 ## Orchestrator Memory
@@ -483,7 +523,7 @@ Only after successful merge, record the swarm session (see Orchestrator Memory b
 After swarm completes, record the session using the CLI:
 
 ```bash
-aide memory add --category=session --tags=swarm,sdlc,session:${CLAUDE_SESSION_ID:0:8} "## Swarm: [Brief Description]
+./.aide/bin/aide memory add --category=session --tags=swarm,sdlc,session:${CLAUDE_SESSION_ID:0:8} "## Swarm: [Brief Description]
 
 ### Stories Completed
 - Story A: [outcome]