aw-ecc 1.4.21

package/.opencode/commands/instinct-export.md

@@ -0,0 +1,93 @@
+---
+description: Export instincts for sharing
+agent: build
+---
+
+# Instinct Export Command
+
+Export instincts for sharing with others: $ARGUMENTS
+
+## Your Task
+
+Export instincts from the continuous-learning-v2 system.
+
+## Export Options
+
+### Export All
+```
+/instinct-export
+```
+
+### Export High Confidence Only
+```
+/instinct-export --min-confidence 0.8
+```
+
+### Export by Category
+```
+/instinct-export --category coding
+```
+
+### Export to Specific Path
+```
+/instinct-export --output ./my-instincts.json
+```
+
+## Export Format
+
+```json
+{
+  "instincts": [
+    {
+      "id": "instinct-123",
+      "trigger": "[situation description]",
+      "action": "[recommended action]",
+      "confidence": 0.85,
+      "category": "coding",
+      "applications": 10,
+      "successes": 9,
+      "source": "session-observation"
+    }
+  ],
+  "metadata": {
+    "version": "1.0",
+    "exported": "2025-01-15T10:00:00Z",
+    "author": "username",
+    "total": 25,
+    "filter": "confidence >= 0.8"
+  }
+}
+```
+
+## Export Report
+
+```
+Export Summary
+==============
+Output: ./instincts-export.json
+Total instincts: X
+Filtered: Y
+Exported: Z
+
+Categories:
+- coding: N
+- testing: N
+- security: N
+- git: N
+
+Top Instincts (by confidence):
+1. [trigger] (0.XX)
+2. [trigger] (0.XX)
+3. [trigger] (0.XX)
+```
+
+## Sharing
+
+After export:
+- Share JSON file directly
+- Upload to team repository
+- Publish to instinct registry
+
+---
+
+**TIP**: Export high-confidence instincts (>0.8) for better quality shares.

package/.opencode/commands/instinct-import.md

@@ -0,0 +1,88 @@
+---
+description: Import instincts from external sources
+agent: build
+---
+
+# Instinct Import Command
+
+Import instincts from a file or URL: $ARGUMENTS
+
+## Your Task
+
+Import instincts into the continuous-learning-v2 system.
+
+## Import Sources
+
+### File Import
+```
+/instinct-import path/to/instincts.json
+```
+
+### URL Import
+```
+/instinct-import https://example.com/instincts.json
+```
+
+### Team Share Import
+```
+/instinct-import @teammate/instincts
+```
+
+## Import Format
+
+Expected JSON structure:
+
+```json
+{
+  "instincts": [
+    {
+      "trigger": "[situation description]",
+      "action": "[recommended action]",
+      "confidence": 0.7,
+      "category": "coding",
+      "source": "imported"
+    }
+  ],
+  "metadata": {
+    "version": "1.0",
+    "exported": "2025-01-15T10:00:00Z",
+    "author": "username"
+  }
+}
+```
+
+## Import Process
+
+1. **Validate format** - Check JSON structure
+2. **Deduplicate** - Skip existing instincts
+3. **Adjust confidence** - Reduce confidence for imports (×0.8)
+4. **Merge** - Add to local instinct store
+5. **Report** - Show import summary
+
+## Import Report
+
+```
+Import Summary
+==============
+Source: [path or URL]
+Total in file: X
+Imported: Y
+Skipped (duplicates): Z
+Errors: W
+
+Imported Instincts:
+- [trigger] (confidence: 0.XX)
+- [trigger] (confidence: 0.XX)
+...
+```
+
+## Conflict Resolution
+
+When importing duplicates:
+- Keep higher confidence version
+- Merge application counts
+- Update timestamp
+
+---
+
+**TIP**: Review imported instincts with `/instinct-status` after import.

package/.opencode/commands/instinct-status.md

@@ -0,0 +1,29 @@
+---
+description: Show learned instincts (project + global) with confidence
+agent: build
+---
+
+# Instinct Status Command
+
+Show instinct status from continuous-learning-v2: $ARGUMENTS
+
+## Your Task
+
+Run:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" status
+```
+
+If `CLAUDE_PLUGIN_ROOT` is unavailable, use:
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py status
+```
+
+## Behavior Notes
+
+- Output includes both project-scoped and global instincts.
+- Project instincts override global instincts when IDs conflict.
+- Output is grouped by domain with confidence bars.
+- This command does not support extra filters in v2.1.

package/.opencode/commands/learn.md

@@ -0,0 +1,61 @@
+---
+description: Extract patterns and learnings from current session
+agent: build
+---
+
+# Learn Command
+
+Extract patterns, learnings, and reusable insights from the current session: $ARGUMENTS
+
+## Your Task
+
+Analyze the conversation and code changes to extract:
+
+1. **Patterns discovered** - Recurring solutions or approaches
+2. **Best practices applied** - Techniques that worked well
+3. **Mistakes to avoid** - Issues encountered and solutions
+4. **Reusable snippets** - Code patterns worth saving
+
+## Output Format
+
+### Patterns Discovered
+
+**Pattern: [Name]**
+- Context: When to use this pattern
+- Implementation: How to apply it
+- Example: Code snippet
+
+### Best Practices Applied
+
+1. [Practice name]
+   - Why it works
+   - When to apply
+
+### Mistakes to Avoid
+
+1. [Mistake description]
+   - What went wrong
+   - How to prevent it
+
+### Suggested Skill Updates
+
+If patterns are significant, suggest updates to:
+- `skills/coding-standards/SKILL.md`
+- `skills/[domain]/SKILL.md`
+- `rules/[category].md`
+
+## Instinct Format (for continuous-learning-v2)
+
+```json
+{
+  "trigger": "[situation that triggers this learning]",
+  "action": "[what to do]",
+  "confidence": 0.7,
+  "source": "session-extraction",
+  "timestamp": "[ISO timestamp]"
+}
+```
+
+---
+
+**TIP**: Run `/learn` periodically during long sessions to capture insights before context compaction.

package/.opencode/commands/loop-start.md

@@ -0,0 +1,32 @@
+# Loop Start Command
+
+Start a managed autonomous loop pattern with safety defaults.
+
+## Usage
+
+`/loop-start [pattern] [--mode safe|fast]`
+
+- `pattern`: `sequential`, `continuous-pr`, `rfc-dag`, `infinite`
+- `--mode`:
+  - `safe` (default): strict quality gates and checkpoints
+  - `fast`: reduced gates for speed
+
+## Flow
+
+1. Confirm repository state and branch strategy.
+2. Select loop pattern and model tier strategy.
+3. Enable required hooks/profile for the chosen mode.
+4. Create loop plan and write runbook under `.claude/plans/`.
+5. Print commands to start and monitor the loop.
+
+## Required Safety Checks
+
+- Verify tests pass before first loop iteration.
+- Ensure `ECC_HOOK_PROFILE` is not disabled globally.
+- Ensure loop has explicit stop condition.
+
+## Arguments
+
+$ARGUMENTS:
+- `<pattern>` optional (`sequential|continuous-pr|rfc-dag|infinite`)
+- `--mode safe|fast` optional

package/.opencode/commands/loop-status.md

@@ -0,0 +1,24 @@
+# Loop Status Command
+
+Inspect active loop state, progress, and failure signals.
+
+## Usage
+
+`/loop-status [--watch]`
+
+## What to Report
+
+- active loop pattern
+- current phase and last successful checkpoint
+- failing checks (if any)
+- estimated time/cost drift
+- recommended intervention (continue/pause/stop)
+
+## Watch Mode
+
+When `--watch` is present, refresh status periodically and surface state changes.
+
+## Arguments
+
+$ARGUMENTS:
+- `--watch` optional

package/.opencode/commands/model-route.md

@@ -0,0 +1,26 @@
+# Model Route Command
+
+Recommend the best model tier for the current task by complexity and budget.
+
+## Usage
+
+`/model-route [task-description] [--budget low|med|high]`
+
+## Routing Heuristic
+
+- `haiku`: deterministic, low-risk mechanical changes
+- `sonnet`: default for implementation and refactors
+- `opus`: architecture, deep review, ambiguous requirements
+
+## Required Output
+
+- recommended model
+- confidence level
+- why this model fits
+- fallback model if first attempt fails
+
+## Arguments
+
+$ARGUMENTS:
+- `[task-description]` optional free-text
+- `--budget low|med|high` optional

package/.opencode/commands/orchestrate.md

@@ -0,0 +1,88 @@
+---
+description: Orchestrate multiple agents for complex tasks
+agent: planner
+subtask: true
+---
+
+# Orchestrate Command
+
+Orchestrate multiple specialized agents for this complex task: $ARGUMENTS
+
+## Your Task
+
+1. **Analyze task complexity** and break into subtasks
+2. **Identify optimal agents** for each subtask
+3. **Create execution plan** with dependencies
+4. **Coordinate execution** - parallel where possible
+5. **Synthesize results** into unified output
+
+## Available Agents
+
+| Agent | Specialty | Use For |
+|-------|-----------|---------|
+| planner | Implementation planning | Complex feature design |
+| architect | System design | Architectural decisions |
+| code-reviewer | Code quality | Review changes |
+| security-reviewer | Security analysis | Vulnerability detection |
+| tdd-guide | Test-driven dev | Feature implementation |
+| build-error-resolver | Build fixes | TypeScript/build errors |
+| e2e-runner | E2E testing | User flow testing |
+| doc-updater | Documentation | Updating docs |
+| refactor-cleaner | Code cleanup | Dead code removal |
+| go-reviewer | Go code | Go-specific review |
+| go-build-resolver | Go builds | Go build errors |
+| database-reviewer | Database | Query optimization |
+
+## Orchestration Patterns
+
+### Sequential Execution
+```
+planner → tdd-guide → code-reviewer → security-reviewer
+```
+Use when: Later tasks depend on earlier results
+
+### Parallel Execution
+```
+┌→ security-reviewer
+planner →├→ code-reviewer
+└→ architect
+```
+Use when: Tasks are independent
+
+### Fan-Out/Fan-In
+```
+         ┌→ agent-1 ─┐
+planner →├→ agent-2 ─┼→ synthesizer
+         └→ agent-3 ─┘
+```
+Use when: Multiple perspectives needed
+
+## Execution Plan Format
+
+### Phase 1: [Name]
+- Agent: [agent-name]
+- Task: [specific task]
+- Depends on: [none or previous phase]
+
+### Phase 2: [Name] (parallel)
+- Agent A: [agent-name]
+  - Task: [specific task]
+- Agent B: [agent-name]
+  - Task: [specific task]
+- Depends on: Phase 1
+
+### Phase 3: Synthesis
+- Combine results from Phase 2
+- Generate unified output
+
+## Coordination Rules
+
+1. **Plan before execute** - Create full execution plan first
+2. **Minimize handoffs** - Reduce context switching
+3. **Parallelize when possible** - Independent tasks in parallel
+4. **Clear boundaries** - Each agent has specific scope
+5. **Single source of truth** - One agent owns each artifact
+
+---
+
+**NOTE**: Complex tasks benefit from multi-agent orchestration. Simple tasks should use single agents directly.

package/.opencode/commands/plan.md

@@ -0,0 +1,49 @@
+---
+description: Create implementation plan with risk assessment
+agent: planner
+subtask: true
+---
+
+# Plan Command
+
+Create a detailed implementation plan for: $ARGUMENTS
+
+## Your Task
+
+1. **Restate Requirements** - Clarify what needs to be built
+2. **Identify Risks** - Surface potential issues, blockers, and dependencies
+3. **Create Step Plan** - Break down implementation into phases
+4. **Wait for Confirmation** - MUST receive user approval before proceeding
+
+## Output Format
+
+### Requirements Restatement
+[Clear, concise restatement of what will be built]
+
+### Implementation Phases
+[Phase 1: Description]
+- Step 1.1
+- Step 1.2
+...
+
+[Phase 2: Description]
+- Step 2.1
+- Step 2.2
+...
+
+### Dependencies
+[List external dependencies, APIs, services needed]
+
+### Risks
+- HIGH: [Critical risks that could block implementation]
+- MEDIUM: [Moderate risks to address]
+- LOW: [Minor concerns]
+
+### Estimated Complexity
+[HIGH/MEDIUM/LOW with time estimates]
+
+**WAITING FOR CONFIRMATION**: Proceed with this plan? (yes/no/modify)
+
+---
+
+**CRITICAL**: Do NOT write any code until the user explicitly confirms with "yes", "proceed", or similar affirmative response.

package/.opencode/commands/projects.md

@@ -0,0 +1,23 @@
+---
+description: List registered projects and instinct counts
+agent: build
+---
+
+# Projects Command
+
+Show continuous-learning-v2 project registry and stats: $ARGUMENTS
+
+## Your Task
+
+Run:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" projects
+```
+
+If `CLAUDE_PLUGIN_ROOT` is unavailable, use:
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py projects
+```
+

package/.opencode/commands/promote.md

@@ -0,0 +1,23 @@
+---
+description: Promote project instincts to global scope
+agent: build
+---
+
+# Promote Command
+
+Promote instincts in continuous-learning-v2: $ARGUMENTS
+
+## Your Task
+
+Run:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" promote $ARGUMENTS
+```
+
+If `CLAUDE_PLUGIN_ROOT` is unavailable, use:
+
+```bash
+python3 ~/.claude/skills/continuous-learning-v2/scripts/instinct-cli.py promote $ARGUMENTS
+```
+

package/.opencode/commands/quality-gate.md

@@ -0,0 +1,29 @@
+# Quality Gate Command
+
+Run the ECC quality pipeline on demand for a file or project scope.
+
+## Usage
+
+`/quality-gate [path|.] [--fix] [--strict]`
+
+- default target: current directory (`.`)
+- `--fix`: allow auto-format/fix where configured
+- `--strict`: fail on warnings where supported
+
+## Pipeline
+
+1. Detect language/tooling for target.
+2. Run formatter checks.
+3. Run lint/type checks when available.
+4. Produce a concise remediation list.
+
+## Notes
+
+This command mirrors hook behavior but is operator-invoked.
+
+## Arguments
+
+$ARGUMENTS:
+- `[path|.]` optional target path
+- `--fix` optional
+- `--strict` optional

package/.opencode/commands/refactor-clean.md

@@ -0,0 +1,102 @@
+---
+description: Remove dead code and consolidate duplicates
+agent: refactor-cleaner
+subtask: true
+---
+
+# Refactor Clean Command
+
+Analyze and clean up the codebase: $ARGUMENTS
+
+## Your Task
+
+1. **Detect dead code** using analysis tools
+2. **Identify duplicates** and consolidation opportunities
+3. **Safely remove** unused code with documentation
+4. **Verify** no functionality broken
+
+## Detection Phase
+
+### Run Analysis Tools
+
+```bash
+# Find unused exports
+npx knip
+
+# Find unused dependencies
+npx depcheck
+
+# Find unused TypeScript exports
+npx ts-prune
+```
+
+### Manual Checks
+
+- Unused functions (no callers)
+- Unused variables
+- Unused imports
+- Commented-out code
+- Unreachable code
+- Unused CSS classes
+
+## Removal Phase
+
+### Before Removing
+
+1. **Search for usage** - grep, find references
+2. **Check exports** - might be used externally
+3. **Verify tests** - no test depends on it
+4. **Document removal** - git commit message
+
+### Safe Removal Order
+
+1. Remove unused imports first
+2. Remove unused private functions
+3. Remove unused exported functions
+4. Remove unused types/interfaces
+5. Remove unused files
+
+## Consolidation Phase
+
+### Identify Duplicates
+
+- Similar functions with minor differences
+- Copy-pasted code blocks
+- Repeated patterns
+
+### Consolidation Strategies
+
+1. **Extract utility function** - for repeated logic
+2. **Create base class** - for similar classes
+3. **Use higher-order functions** - for repeated patterns
+4. **Create shared constants** - for magic values
+
+## Verification
+
+After cleanup:
+
+1. `npm run build` - builds successfully
+2. `npm test` - all tests pass
+3. `npm run lint` - no new lint errors
+4. Manual smoke test - features work
+
+## Report Format
+
+```
+Dead Code Analysis
+==================
+
+Removed:
+- file.ts: functionName (unused export)
+- utils.ts: helperFunction (no callers)
+
+Consolidated:
+- formatDate() and formatDateTime() → dateUtils.format()
+
+Remaining (manual review needed):
+- oldComponent.tsx: potentially unused, verify with team
+```
+
+---
+
+**CAUTION**: Always verify before removing. When in doubt, ask or add `// TODO: verify usage` comment.