wicked-garden 12.27.0

package/skills/multi-model/refs/codex.md

@@ -0,0 +1,169 @@
+---
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+# Codex CLI — Usage Patterns
+
+OpenAI Codex CLI for AI-assisted coding, code review, and multi-model collaboration.
+Codex excels at code generation, refactoring, and technical analysis.
+
+## Installation and Setup
+
+```bash
+# Check if installed
+which codex
+
+# Install
+brew install codex  # or see https://github.com/openai/codex-cli
+
+# Set API key
+export OPENAI_API_KEY="your-key"  # https://platform.openai.com/api-keys
+```
+
+## Core Usage Patterns
+
+### Non-Interactive (exec)
+
+```bash
+# Simple query
+codex exec "Explain this error: ${error_message}"
+
+# With file context (pipe content)
+cat src/auth.py | codex exec "Review this authentication code for security issues"
+
+# Specific model
+codex exec -m gpt-4o "Analyze this design document" < design.md
+
+# Review a diff
+git diff HEAD~1 | codex exec "What are the risks of these changes?"
+```
+
+### Interactive Session
+
+```bash
+# Start interactive with prompt
+codex "Let's review the checkout flow"
+
+# Resume previous session
+codex resume --last
+
+# Fork a session to explore alternatives
+codex fork --last "What if we used event sourcing instead?"
+```
+
+### Code Review
+
+```bash
+# Built-in code review command
+codex review src/checkout.ts
+
+# Custom review with focus areas
+cat src/checkout.ts | codex exec "Review this code. Focus on:
+1. Error handling
+2. Edge cases
+3. Performance implications"
+
+# Apply Codex's suggested changes
+codex apply
+```
+
+## Multi-Model Collaboration
+
+Use Codex for a second opinion on code and architecture:
+
+```bash
+# Get Codex's take on architecture
+cat design.md | codex exec "Critique this architecture" > codex_review.md
+
+# Compare with Claude's analysis
+# Claude reviews in conversation; Codex via CLI
+
+# Security review from both perspectives
+git diff main | codex exec "Flag security issues in these changes"
+```
+
+## Native Task Tracking
+
+Track Codex insights for team visibility:
+
+```
+# Create a task for the review
+TaskCreate(
+  subject="Code review: auth-service refactor",
+  metadata={
+    "event_type": "task",
+    "chain_id": "auth-service-review.root",
+    "source_agent": "multi-model:codex"
+  }
+)
+
+# Get Codex's review and append via TaskUpdate
+# CODEX_REVIEW=$(cat src/auth.py | codex exec "Security review")
+# TaskUpdate(taskId, description="{previous}\n\nCodex: ${CODEX_REVIEW}")
+```
+
+## Command Reference
+
+| Command | Description |
+|---------|-------------|
+| `codex [PROMPT]` | Interactive session |
+| `codex exec PROMPT` | Non-interactive, one-shot |
+| `codex review [FILE]` | Built-in code review |
+| `codex apply` | Apply latest diff |
+| `codex resume` | Resume previous session |
+| `codex fork` | Fork a previous session |
+
+## Options Reference
+
+| Option | Description |
+|--------|-------------|
+| `-m MODEL` | Model: `gpt-4o`, `o3`, `gpt-5.2-codex` |
+| `-i IMAGE` | Attach image(s) to prompt |
+| `--enable FEATURE` | Enable a feature flag |
+| `--disable FEATURE` | Disable a feature flag |
+
+## Strengths
+
+| Area | Description |
+|------|-------------|
+| Code generation | Excels at producing well-structured code from specifications |
+| Refactoring | Strong at identifying and applying structural improvements |
+| Technical analysis | Deep understanding of code patterns and anti-patterns |
+| Diff review | Effective at reviewing git diffs for risks and issues |
+
+## Best Practices
+
+1. **Use exec for automation** — `codex exec` is ideal for scripted workflows
+2. **Pipe content** — Use stdin for context rather than describing files
+3. **Compare perspectives** — Use Codex alongside Claude for important decisions
+4. **Track via native tasks** — Record AI insights for team visibility through TaskCreate/TaskUpdate
+5. **Resume sessions** — Use `codex resume` to continue complex discussions
+6. **Fork for alternatives** — `codex fork` explores "what if" without losing current thread
+
+## Integration with wicked-crew
+
+In design and review phases, add Codex as a review step:
+
+```bash
+# Design phase: get Codex architecture critique
+cat phases/design/output.md | codex exec "Architecture review: identify risks"
+
+# Build phase: Codex code review on completed work
+git diff main | codex exec "Code review: flag issues before PR"
+```
+
+## Common Prompts
+
+```bash
+# Security-focused
+cat src/auth.py | codex exec "Security review: identify vulnerabilities, missing validation, injection risks"
+
+# Architecture-focused
+cat design.md | codex exec "Architecture critique: SRP violations, missing abstractions, scaling concerns"
+
+# Error analysis
+cat error.log | codex exec "Diagnose this error and suggest root cause + fix"
+
+# Test coverage
+cat src/checkout.ts | codex exec "What test cases are missing for this module?"
+```

package/skills/multi-model/refs/context.md

@@ -0,0 +1,306 @@
+---
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+# Context: Maintaining AI Conversation State
+
+How to maintain context across AI sessions, manage context windows, and decide when to continue vs. start fresh.
+
+## The Context Challenge
+
+Each AI CLI has its own session management:
+- **Claude Code**: Persistent within session, summarizes on overflow
+- **Gemini**: Can resume sessions with `-r`
+- **Codex**: Has `resume` and `fork` commands
+- **OpenCode**: Session IDs with `-c` and `-s`
+
+Cross-AI context requires external coordination.
+
+## Context Layers
+
+```
+┌─────────────────────────────────────────┐
+│  Shared Context (native task)           │  ← All AIs can reference
+├─────────────────────────────────────────┤
+│  Per-AI Session State                   │  ← CLI-specific memory
+├─────────────────────────────────────────┤
+│  Prompt Context (files, snippets)       │  ← What you send each time
+└─────────────────────────────────────────┘
+```
+
+## Strategy 1: Native Task as Shared Memory
+
+Use a native task as the source of truth all AIs reference.
+
+### Setup
+
+```
+TaskCreate(
+  subject="Design discussion: Auth system",
+  description="{paste or link the design doc here}",
+  metadata={
+    "event_type": "task",
+    "chain_id": "auth-design.root",
+    "source_agent": "multi-model-context",
+    "priority": "P1",
+    "initiative": "auth-design"
+  }
+)
+```
+
+### Cross-AI Workflow
+
+```bash
+# When querying any AI, reference the task description (source of truth)
+CONTEXT=$(cat docs/auth-design.md)
+PRIOR_COMMENTS=$(# read the task's description for accumulated AI perspectives)
+
+# Gemini with full context
+echo "$CONTEXT
+
+Prior AI feedback:
+$PRIOR_COMMENTS
+
+Your task: Build on the prior feedback. What's missing?" | gemini
+
+# Same pattern for Codex, OpenCode
+```
+
+### Why This Works
+
+- Single source of truth
+- All perspectives visible in one place
+- Humans can inject corrections
+- Natural audit trail
+
+## Strategy 2: Context Documents
+
+For longer discussions, maintain a context document.
+
+### Structure
+
+```markdown
+# Context: Auth System Design
+
+## Current State
+[Latest version of design]
+
+## Constraints
+- Must support SSO
+- Max 100ms auth latency
+- HIPAA compliant
+
+## AI Feedback Summary
+
+### Round 1 (2026-01-25)
+- **Claude**: Flagged token expiry concerns
+- **Gemini**: Suggested rate limiting
+- **Codex**: Recommended repository pattern
+
+### Open Questions
+1. Token refresh strategy?
+2. Session invalidation approach?
+
+## Decisions Made
+- Use JWT with 15min/7day expiry (per Claude's recommendation)
+```
+
+### Usage
+
+```bash
+# Each AI gets the context doc
+cat context-auth.md | gemini "Address the open questions"
+
+# Update context doc with responses
+# Repeat with next AI
+```
+
+## Strategy 3: Session Continuity
+
+Use each CLI's native session management for deep dives.
+
+### Gemini
+
+```bash
+# Start a session
+gemini -i "Let's review the auth design"
+
+# ... interactive discussion ...
+
+# Later, resume
+gemini -r  # Resumes last session
+```
+
+### Codex
+
+```bash
+# Interactive session
+codex "Review the payment flow"
+
+# ... discussion ...
+
+# Resume later
+codex resume --last
+
+# Or fork to explore alternatives
+codex fork --last "What if we used event sourcing instead?"
+```
+
+### OpenCode
+
+```bash
+# Non-interactive with continuation
+opencode run "Review auth design" -f design.md
+
+# Continue the conversation
+opencode run -c "What about the token refresh?"
+
+# Or specify session ID
+opencode run -s abc123 "Follow up question"
+```
+
+## When to Start Fresh vs. Continue
+
+### Start Fresh When
+
+- Switching topics entirely
+- Previous context is misleading
+- Context window is polluted with irrelevant discussion
+- You want an unbiased perspective
+
+### Continue When
+
+- Building on prior analysis
+- Multi-step reasoning needed
+- AI needs to remember constraints discussed earlier
+- Iterating on a design
+
+### Reset Signals
+
+Watch for these signs that you should start fresh:
+- AI references things you didn't discuss
+- Responses become repetitive or circular
+- AI seems confused about the current state
+- You've pivoted significantly from original topic
+
+## Context Window Management
+
+### The Problem
+
+Each AI has limited context. Too much history = lost important details.
+
+### Solutions
+
+**Summarize periodically:**
+```bash
+# Ask the AI to summarize before context overflow
+echo "Summarize our discussion so far in 5 bullet points" | gemini
+
+# Save summary, start new session with summary as context
+```
+
+**Prioritize recent + key decisions:**
+```markdown
+# Context for new session
+
+## Key Decisions (from prior sessions)
+1. Using JWT with 15min expiry
+2. Rate limiting at API gateway
+3. Repository pattern for auth
+
+## Current Focus
+[Only the relevant recent context]
+```
+
+**Use refs for stable context:**
+```bash
+# Don't repeat stable context every time
+# Reference a file that all AIs can read
+cat refs/architecture-decisions.md docs/current-design.md | gemini "Given these constraints, review X"
+```
+
+## Cross-AI Context Handoff
+
+When handing context from one AI to another:
+
+### Pattern: Explicit Handoff
+
+```bash
+# Get Claude's analysis
+CLAUDE_ANALYSIS="[Claude's response from the conversation]"
+
+# Hand off to Gemini with context
+echo "Prior analysis from Claude:
+$CLAUDE_ANALYSIS
+
+Build on this analysis. What did Claude miss? What would you add?" | gemini
+```
+
+### Pattern: Neutral Handoff
+
+```bash
+# Don't bias the second AI
+echo "Review this design for security concerns.
+
+Note: Another AI has already reviewed this. After your independent review,
+I'll share their feedback for comparison." | codex exec
+
+# Then compare independently-generated perspectives
+```
+
+### Pattern: Adversarial Handoff
+
+```bash
+# Explicitly ask for critique
+echo "Another AI recommended using JWT with 15min expiry.
+Argue against this recommendation. What are the downsides?" | gemini
+```
+
+## Quick Reference
+
+| Situation | Approach |
+|-----------|----------|
+| Multi-AI on same topic | Native task description as shared context |
+| Deep dive with one AI | Use native session management |
+| Long-running discussion | Context document with summaries |
+| Unbiased second opinion | Start fresh, neutral handoff |
+| Building on prior work | Continue session or explicit handoff |
+| Context getting stale | Summarize, start fresh with summary |
+
+## Anti-Patterns
+
+### Context Pollution
+
+```bash
+# BAD: Accumulating irrelevant context
+echo "$ENTIRE_CODEBASE
+$ALL_PRIOR_DISCUSSIONS
+$UNRELATED_DOCS
+Review the login function" | gemini
+
+# GOOD: Focused context
+echo "$LOGIN_FUNCTION
+$AUTH_REQUIREMENTS
+Review for security issues" | gemini
+```
+
+### Assumption Leakage
+
+```bash
+# BAD: AI assumes context it doesn't have
+# "As we discussed..." (but you didn't discuss it)
+
+# GOOD: Always provide explicit context
+# Don't assume AI remembers prior sessions
+```
+
+### Echo Chamber
+
+```bash
+# BAD: Telling AI what other AIs said before independent review
+echo "Claude said X, Gemini said Y. What do you think?" | codex
+
+# GOOD: Get independent opinion first
+echo "Review this design" | codex
+# THEN share and compare perspectives
+```

package/skills/multi-model/refs/copilot.md

@@ -0,0 +1,161 @@
+---
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+# Copilot CLI — Usage Patterns
+
+GitHub Copilot CLI for AI-assisted coding, code review, and multi-model collaboration.
+Copilot supports multiple backend models and excels at codebase-aware analysis.
+
+> **Registry is source of truth.** The council's headless invocation + trust
+> flags for copilot live in `scripts/jam/agentic_cli_registry.py`
+> (`copilot -p "{PROMPT}" --allow-all-tools`). For headless/council use,
+> `--allow-all-tools` is **required** — without it copilot blocks on tool
+> approval. Prefer the registry form over the older `--available-tools=""`
+> examples below.
+
+## Installation and Setup
+
+```bash
+# Check if installed
+which copilot
+
+# Install
+brew install copilot-cli          # macOS (Homebrew)
+winget install GitHub.Copilot     # Windows (WinGet)
+npm install -g @github/copilot   # all platforms (npm)
+curl -fsSL https://gh.io/copilot-install | bash  # macOS/Linux (curl)
+
+# Authenticate
+copilot  # launches interactive login flow on first run
+```
+
+## Core Usage Patterns
+
+### Non-Interactive (prompt mode)
+
+```bash
+# Simple query
+copilot -p "Explain this error: ${error_message}" --output-format text
+
+# With file context (pipe content)
+cat src/auth.py | copilot -p "Review this authentication code for security issues" --output-format text
+
+# Specific model
+copilot -p "Analyze this design document" --model gpt-5.2 --output-format text < design.md
+
+# Review a diff
+git diff HEAD~1 | copilot -p "What are the risks of these changes?" --output-format text
+
+# Text-only (no tool use) — best for council dispatch
+cat scaffold.md | copilot -p "Answer the questions" --output-format text --available-tools=""
+```
+
+### Interactive Session
+
+```bash
+# Start interactive
+copilot
+
+# Start with a specific model
+copilot --model claude-sonnet-4
+
+# With full permissions (no confirmation prompts)
+copilot --allow-all
+```
+
+### Code Review
+
+```bash
+# Review with piped content
+cat src/checkout.ts | copilot -p "Review this code. Focus on:
+1. Error handling
+2. Edge cases
+3. Performance implications" --output-format text
+
+# Review a PR diff
+git diff main | copilot -p "Flag security issues in these changes" --output-format text
+```
+
+## Multi-Model Collaboration
+
+Use Copilot for a second opinion on code and architecture:
+
+```bash
+# Get Copilot's take on architecture
+cat design.md | copilot -p "Critique this architecture" --output-format text > copilot_review.md
+
+# Security review
+git diff main | copilot -p "Flag security issues in these changes" --output-format text
+
+# Council dispatch — registry form (headless requires --allow-all-tools)
+copilot -p "You are evaluating options for a technical decision. Answer the 4 questions below precisely and concisely. <scaffold>" --allow-all-tools
+```
+
+## Command Reference
+
+| Flag | Description |
+|------|-------------|
+| `-p, --prompt <text>` | Non-interactive mode (exits after completion) |
+| `--output-format <fmt>` | Output format: `text` (default) or `json` |
+| `--model <model>` | Backend model selection |
+| `--available-tools <tools>` | Restrict available tools (empty string = none) |
+| `--allow-all` | Enable all permissions (tools, paths, URLs) |
+| `--allow-all-tools` | Allow all tools without confirmation |
+| `--reasoning-effort <lvl>` | Reasoning effort: `low`, `medium`, `high`, `xhigh` |
+| `--add-dir <dir>` | Add directory to allowed file access list |
+| `--quiet` | Suppress non-essential output |
+
+## Model Options
+
+| Model | Description |
+|-------|-------------|
+| `claude-sonnet-4` | Anthropic Claude Sonnet 4 |
+| `gemini-3-pro-preview` | Google Gemini 3 Pro |
+| `gpt-5.4` | OpenAI GPT-5.4 |
+| `gpt-5.2-codex` | OpenAI Codex (code-optimized) |
+
+## Strengths
+
+| Area | Description |
+|------|-------------|
+| Codebase awareness | Deep understanding of project structure and context |
+| Multi-model backend | Switch between Claude, GPT, and Gemini models |
+| GitHub integration | Native access to GitHub APIs, PRs, issues |
+| Tool orchestration | Built-in MCP server support for extensibility |
+
+## Best Practices
+
+1. **Use `-p` for automation** — non-interactive mode is ideal for scripted workflows
+2. **Pipe content** — use stdin for context rather than describing files
+3. **Disable tools for council** — `--available-tools=""` ensures text-only responses
+4. **Use `--output-format text`** — cleaner output for parsing and synthesis
+5. **Choose models intentionally** — `--model` lets you pick the best backend for the task
+
+## Integration with wicked-crew
+
+In design and review phases, add Copilot as a review step:
+
+```bash
+# Design phase: get Copilot architecture critique
+cat phases/design/output.md | copilot -p "Architecture review: identify risks" --output-format text
+
+# Build phase: Copilot code review on completed work
+git diff main | copilot -p "Code review: flag issues before PR" --output-format text
+```
+
+## Common Prompts
+
+```bash
+# Security-focused
+cat src/auth.py | copilot -p "Security review: identify vulnerabilities, missing validation, injection risks" --output-format text
+
+# Architecture-focused
+cat design.md | copilot -p "Architecture critique: SRP violations, missing abstractions, scaling concerns" --output-format text
+
+# Error analysis
+cat error.log | copilot -p "Diagnose this error and suggest root cause + fix" --output-format text
+
+# Test coverage
+cat src/checkout.ts | copilot -p "What test cases are missing for this module?" --output-format text
+```