wicked-garden 12.27.0

package/skills/multi-model/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: wicked-garden-multi-model
+context: fork
+description: |
+  Multi-model AI collaboration: discover installed LLM CLIs and orchestrate
+  council sessions, cross-model reviews, and diverse perspective gathering.
+  Detects 20+ agentic/chat/local CLIs at runtime from a machine-readable
+  registry (scripts/jam/agentic_cli_registry.py) and usability-probes them
+  (scripts/jam/detect_clis.py --probe) so auth-revoked / unconfigured /
+  daemon-down CLIs are excluded.
+  Decisions stored in wicked-brain:memory. Transcripts persisted via jam scripts.
+
+  Use when: running a council session across multiple LLM CLIs, getting a
+  second opinion from a different model on a decision, or doing a cross-model
+  code or architecture review.
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+
+# Multi-Model Collaboration Skill
+
+Orchestrate multi-model AI collaboration using external LLM CLIs.
+Each council member is a different model provider for genuine perspective diversity.
+
+## How It Works
+
+The multi-model system uses **external LLM CLIs** discovered + probed at runtime
+from the registry — never a hand-maintained `which` list:
+
+1. **Detect + Probe** — `detect_clis.py --probe` reads the registry, `shutil.which`-es
+   each binary, then runs each detected CLI's headless form (with registry trust
+   flags) on a trivial prompt to classify **usable** vs **installed-but-unusable**
+   (auth revoked / no provider / daemon down). Captures version strings to
+   disambiguate binary collisions (`grok`, `agent`, `forge`, `q`).
+2. **Quorum Check** — Council requires 2+ **usable external** CLIs; below that,
+   fill seats with `Task()` subagents so a real council always convenes.
+3. **Question Scaffold** — All models answer the same fixed 4-question set
+4. **Parallel Dispatch** — Each usable CLI is invoked per its registry `input_mode`,
+   isolated + sandboxed + timeboxed, runs independently
+5. **Synthesis** — Claude synthesizes all perspectives with model attribution
+
+## Quick Start
+
+```bash
+# Council mode — dispatches to external CLIs in parallel
+/jam:council "Should we use JWT or sessions for auth?"
+
+# Quick jam — single model, 4 personas, fast
+/jam:quick "How should we improve the visual design?"
+
+# Full brainstorm — single model, 4-6 personas, 2-3 rounds
+/jam:brainstorm "Architecture for the notification system"
+```
+
+## Supported CLIs
+
+The supported-CLI list is **not maintained here** — it lives in the registry
+(`scripts/jam/agentic_cli_registry.py`), one record per CLI with its headless
+invocation, input mode, model-flag style, trust flags, auth hint, and install
+commands. Run `detect_clis.py --list` to dump it. This is the de-drift source
+of truth; do not re-list flags in prose.
+
+The registry currently covers **20+ CLIs** across three categories:
+
+- **agentic-coder** — `claude`, `codex`, `gemini`, `agy` (Antigravity), `pi`,
+  `opencode`, `aider`, `copilot`, `goose`, `cursor-agent`, `amp`, `droid`,
+  `qwen`, `crush`, `openhands`, `gptme`, `interpreter` (+ confirm-on-probe:
+  `grok`, `forge`, `continue`, `cline`).
+- **chat** — `llm`, `aichat`, `mods`, `sgpt`, `q` (Amazon Q / `kiro-cli`).
+- **local-runner** — `ollama` (needs a running daemon + a pulled model).
+
+Records flagged `confirm-on-probe` have an uncertain headless flag — the probe
+verifies them before the council relies on them. Deprecated / winding-down
+tools (`cody`, `plandex`) ship `enabled_for_council=False`.
+
+Claude always participates as a council member (in-process host) alongside the
+usable external CLIs.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│  /jam:council Command                                │
+│  - Parses topic, options, criteria                   │
+│  - Dispatches to council agent                       │
+├─────────────────────────────────────────────────────┤
+│  Council Agent (agents/jam/council.md)               │
+│  - detect_clis.py --probe (registry-driven)          │
+│  - Builds question scaffold (4 fixed questions)      │
+│  - Renders each usable CLI per its input_mode        │
+│  - Claude answers the same scaffold independently    │
+├─────────────────────────────────────────────────────┤
+│  Detect + Probe (scripts/jam/detect_clis.py)         │
+│  - registry → shutil.which → headless usability probe│
+│  - usable vs installed-but-unusable (auth/provider/  │
+│    daemon); version strings for collision disambig   │
+│  - <2 usable external → Task() subagent fallback tier│
+├─────────────────────────────────────────────────────┤
+│  Synthesis (3-stage)                                 │
+│  - Stage 1: Raw responses per model                  │
+│  - Stage 2: Synthesis matrix + risk convergence      │
+│  - Stage 3: Verdict (consensus or fault lines)       │
+└─────────────────────────────────────────────────────┘
+```
+
+## Synthesis Framework
+
+After gathering perspectives from different models, synthesize using:
+
+| Signal | Meaning | Action |
+|--------|---------|--------|
+| **Consensus** (2+ models agree) | High confidence issue | Address immediately |
+| **Unique insight** | One model caught it | Evaluate carefully |
+| **Disagreement** | Genuine tradeoff | Human decides |
+| **Silence** | No model flagged it | Lower priority |
+
+## Persistence
+
+### Automatic (via save_transcript.py)
+
+Council responses are persisted as transcript entries:
+- Each model's response stored with `persona_type: council`
+- Synthesis appended as `entry_type: synthesis`
+- Retrievable via `wicked-brain:query` for past session context
+
+### Manual (via wicked-brain:memory)
+
+Store decisions with full attribution:
+
+```
+Skill(skill="wicked-brain:memory", args="store \"Auth: JWT with 15min/7day expiry.\nConsensus: Claude, Gemini, Codex (idempotency critical).\nUnique: Gemini flagged session store scaling concern.\nDissent: none.\" --type decision --tags auth,multi-model-review")
+```
+
+## When to Use Multi-Model
+
+| Situation | Recommendation |
+|-----------|----------------|
+| Architecture decisions | Yes — high impact, catch blind spots |
+| Security review | Yes — different models flag different risks |
+| Important PRs | Yes — diverse review perspectives |
+| Visual/UX design | Yes — different aesthetic sensibilities |
+| Quick bug fix | No — overhead not worth it |
+| Routine code | No — single AI sufficient |
+
+## Fallback Behavior
+
+Quorum is counted over **usable external** CLIs (post-probe), not raw
+detections. When fewer than 2 are usable, council fills the empty seats with
+`Task()` subagents (distinct framing personas, isolated + parallel) so a real
+council always convenes — these in-harness seats are weaker diversity than
+external vendors and are labelled as such in the synthesis. With exactly 1
+usable external CLI it runs as "single external guest" (optionally topped up
+with subagent seats). Only if neither external CLIs nor subagents are available
+does it suggest `/jam:brainstorm` (single-model, multi-persona).
+
+## References
+
+**Orchestration:**
+- [Orchestration Patterns](refs/orchestration.md) — CLI dispatch, parallel execution, synthesis
+- [Context Management](refs/context.md) — Session state, cross-AI handoffs, context windows
+
+**CLI Providers:**
+- [Codex](refs/codex.md) | [Copilot](refs/copilot.md) | [Gemini](refs/gemini.md) | [OpenCode](refs/opencode.md) | [Pi](refs/pi.md)
+- [Aider](refs/aider.md) | [llm](refs/llm.md) | [aichat](refs/aichat.md) | [Goose](refs/goose.md)
+
+**Quality:**
+- [Auditability](refs/auditability.md) — Audit trails, compliance, decision tracking
+- [Examples](refs/examples.md) — ADR templates, synthesis patterns, review templates

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

@@ -0,0 +1,119 @@
+---
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+# aichat CLI — Usage Patterns
+
+`aichat` is an all-in-one LLM CLI written in Rust — fast, pipe-native, multi-provider. Covers OpenAI, Anthropic, Gemini, Mistral, Groq, Ollama, and more via a single YAML config.
+
+## Installation and Setup
+
+```bash
+# Install
+brew install aichat
+
+# Interactive config wizard (writes ~/.config/aichat/config.yaml)
+aichat --info                # inspects current config
+aichat                       # first run opens setup
+
+# Configure providers by editing ~/.config/aichat/config.yaml
+# clients:
+#   - type: openai
+#     api_key: ...
+#   - type: claude
+#     api_key: ...
+#   - type: ollama
+#     api_base: http://localhost:11434/v1
+```
+
+## Core Usage Patterns
+
+### Non-Interactive (pipe-native)
+
+```bash
+# Simple stdin
+cat scaffold.md | aichat
+
+# Pipe + system prompt
+cat scaffold.md | aichat -S "Answer the 4 questions precisely and concisely."
+
+# Pick a model for this call
+cat scaffold.md | aichat -m claude:claude-sonnet-4-5 "Evaluate"
+cat scaffold.md | aichat -m openai:gpt-4o "Evaluate"
+cat scaffold.md | aichat -m ollama:llama3.1:70b "Evaluate"
+
+# Disable streaming for clean capture
+cat scaffold.md | aichat -S "Evaluate" -m openai:gpt-4o
+```
+
+### Include Files / URLs
+
+```bash
+# -f attaches files, directories, or URLs
+aichat -f scaffold.md "Answer the 4 questions in the attached file."
+aichat -f spec.pdf -f diagram.png "Critique this design."
+aichat -f https://example.com/rfc.html "Summarize this RFC."
+```
+
+### Roles, Sessions, RAG (NOT used for council)
+
+```bash
+# Role — reusable system prompt
+aichat --role security-reviewer "Review this snippet"
+
+# Session — keeps context across invocations
+aichat -s design-review "Initial take"
+aichat -s design-review "Now add the security angle"
+
+# RAG — retrieval over a corpus
+aichat --rag my-docs "What does the spec say about retries?"
+```
+
+## aichat's Distinct Role in Multi-Model Sessions
+
+`aichat` is a lightweight, fast alternative to `llm` when plugin churn isn't wanted. Config is a single YAML file; providers live there side by side. Good for picking one model per council run without the overhead of `llm`'s plugin system.
+
+```bash
+# Provider diversity in one CLI
+cat "$SCAFFOLD" | aichat -m claude:claude-sonnet-4-5 "Evaluate"
+cat "$SCAFFOLD" | aichat -m gemini:gemini-2.0-flash "Evaluate"
+cat "$SCAFFOLD" | aichat -m groq:llama-3.3-70b "Evaluate"
+```
+
+## Strengths
+
+| Area | Description |
+|------|-------------|
+| Single-binary | Rust executable, no Python / node runtime dependency |
+| Multi-provider | OpenAI, Anthropic, Gemini, Mistral, Groq, Ollama, Azure, Bedrock |
+| RAG + sessions | Built-in retrieval and threaded sessions when needed |
+| Shell integration | `-e` shell assistant, `-c` code output mode |
+| Config unified | One YAML — no plugins to install |
+
+## Important Flags for Council Use
+
+| Flag | Purpose |
+|------|---------|
+| `-m MODEL` | `client:model` — e.g. `claude:claude-sonnet-4-5`, `openai:gpt-4o` |
+| `--prompt TEXT` | System prompt |
+| `-S` | Disable streaming; return one block |
+| `-f PATH\|URL` | Include file, directory, or URL |
+| `--empty-session` | Force a fresh context |
+| `--dry-run` | Show the assembled prompt without sending |
+
+## Caveats
+
+1. **Model selection uses `client:model` syntax.** `-m claude-sonnet-4-5` is wrong; `-m claude:claude-sonnet-4-5` is right.
+2. **Default model is implicit.** Council dispatches should pin the model explicitly.
+3. **Session files persist.** `~/.config/aichat/sessions/` accumulates — `--empty-session` or `-r ''` avoids carry-over.
+
+## Command Reference (council subset)
+
+| Command | Description |
+|---------|-------------|
+| `aichat "PROMPT"` | One-shot with default model |
+| `cat FILE \| aichat "PROMPT"` | Pipe content as input |
+| `aichat -m CLIENT:MODEL "PROMPT"` | Pick a specific model |
+| `aichat -f FILE "PROMPT"` | Include a file |
+| `aichat --list-models` | List configured models |
+| `aichat --info` | Show current config |

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

@@ -0,0 +1,100 @@
+---
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+# Aider CLI — Usage Patterns
+
+Aider is an AI pair-programmer designed to edit code inside a git repo. For council use it runs in a restricted one-shot mode: no git, no commits, no file edits — just an answer to the scaffold prompt.
+
+## Installation and Setup
+
+```bash
+# Install
+brew install aider
+# or: pipx install aider-chat
+
+# Configure a provider (reads env vars)
+export ANTHROPIC_API_KEY="..."     # claude models
+export OPENAI_API_KEY="..."        # gpt models
+export DEEPSEEK_API_KEY="..."      # deepseek
+```
+
+## Core Usage Patterns
+
+### Non-Interactive (one-shot, no git, answer only)
+
+```bash
+# Preferred form for council — read scaffold from file
+aider --message-file scaffold.md \
+  --no-git --yes-always --no-auto-commits --no-stream --no-analytics
+
+# Ad-hoc question without a file
+aider --message "Evaluate Option A vs Option B for JWT session storage." \
+  --no-git --yes-always --no-auto-commits --no-stream --no-analytics
+
+# Pick a specific model
+aider --model sonnet --message-file scaffold.md \
+  --no-git --yes-always --no-auto-commits --no-stream
+aider --model gpt-4o --message-file scaffold.md \
+  --no-git --yes-always --no-auto-commits --no-stream
+aider --model deepseek/deepseek-reasoner --message-file scaffold.md \
+  --no-git --yes-always --no-auto-commits --no-stream
+```
+
+### Interactive (NOT used for council)
+
+```bash
+aider                                    # interactive repo-editing session
+aider path/to/file.py                    # with file attached
+aider --architect                        # architect mode
+```
+
+## Aider's Distinct Role in Multi-Model Sessions
+
+Aider's native orientation is code-editor, so it tends to answer from an *engineering-in-the-repo* lens rather than a purely architectural one. That produces concrete, diff-aware trade-offs — complementary to Gemini's broad analysis or Pi's human-factor framing.
+
+```bash
+# Council context: three models, three framings
+cat "$SCAFFOLD" | codex exec "Architectural review"
+cat "$SCAFFOLD" | gemini "Scalability + risk framing"
+aider --message-file "$SCAFFOLD" --no-git --yes-always \
+  --no-auto-commits --no-stream --no-analytics
+```
+
+## Strengths
+
+| Area | Description |
+|------|-------------|
+| Code-grounded trade-offs | Reasons about diffs, edits, migration steps |
+| Repo-awareness | Knows how changes will land in an actual codebase |
+| Model flexibility | Supports OpenAI, Anthropic, DeepSeek, OpenRouter, Ollama, Bedrock, Azure |
+| Architect + editor split | `--architect` mode for planning; editor for fine-grained diffs |
+
+## Important Flags for Council Use
+
+| Flag | Purpose |
+|------|---------|
+| `--message-file FILE` | Read the prompt from a file (use this for the scaffold) |
+| `--message TEXT` | Inline prompt — escape carefully |
+| `--no-git` | Do not initialize or require a git repo |
+| `--yes-always` | Auto-accept any confirmation prompts |
+| `--no-auto-commits` | Never commit in this run |
+| `--no-stream` | Disable token streaming; return one block |
+| `--no-analytics` | Disable anonymous usage reporting |
+| `--model NAME` | Override the default model |
+
+## Caveats
+
+1. **Aider expects a writable cwd.** It will create `.aider.*` cache/history files. Call it from a scratch tempdir if that matters.
+2. **Answers may be diff-flavored.** If aider drifts into proposing SEARCH/REPLACE blocks, treat them as code-ready annotations, not a council verdict.
+3. **Interactive escape.** `--yes-always` is required — without it, aider will pause for input the moment a confirmation would normally fire.
+4. **Streaming off is deliberate.** Council synthesis runs after all CLIs finish; streamed output wastes buffer and complicates transcript capture.
+
+## Command Reference (council subset)
+
+| Command | Description |
+|---------|-------------|
+| `aider --message TEXT` | One-shot prompt |
+| `aider --message-file FILE` | One-shot prompt from a file |
+| `aider --model MODEL` | Override model |
+| `aider --architect` | Split planner/editor reasoning (interactive) |

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

@@ -0,0 +1,238 @@
+---
+phase_relevance: ["clarify", "design"]
+archetype_relevance: ["*"]
+---
+# Auditability: Tracking AI Conversations
+
+How to maintain audit trails for multi-AI conversations. Essential for compliance, team visibility, and learning from past decisions.
+
+## Why Auditability Matters
+
+1. **Compliance**: Some domains require documentation of AI-assisted decisions
+2. **Team visibility**: Others can see what AI perspectives informed a decision
+3. **Learning**: Review past AI conversations to improve prompts and workflows
+4. **Accountability**: Know which AI said what, when
+
+## The Audit Trail Stack
+
+```
+┌─────────────────────────────────────────┐
+│  wicked-brain:memory (long-term decisions)     │  ← Persist important decisions
+├─────────────────────────────────────────┤
+│  Native tasks (conversation tracking)   │  ← Track active discussions
+├─────────────────────────────────────────┤
+│  Local logs (session artifacts)         │  ← Raw AI outputs
+└─────────────────────────────────────────┘
+```
+
+## Level 1: Local Logging
+
+Capture raw AI outputs for immediate reference.
+
+### Simple File Logging
+
+```bash
+# Log each AI response with timestamp
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+LOG_DIR="./ai-logs/$(date +%Y-%m)"
+mkdir -p "$LOG_DIR"
+
+# Gemini
+cat design.md | gemini "Review for security" | tee "$LOG_DIR/gemini_${TIMESTAMP}.md"
+
+# Codex
+cat design.md | codex exec "Review for architecture" | tee "$LOG_DIR/codex_${TIMESTAMP}.md"
+```
+
+### Structured Logging
+
+```bash
+#!/bin/bash
+# log-ai-response.sh
+
+MODEL=$1
+PROMPT=$2
+RESPONSE=$3
+CONTEXT_FILE=$4
+
+LOG_FILE="./ai-logs/$(date +%Y-%m-%d).jsonl"
+
+jq -n \
+  --arg ts "$(date -Iseconds)" \
+  --arg model "$MODEL" \
+  --arg prompt "$PROMPT" \
+  --arg response "$RESPONSE" \
+  --arg context "$CONTEXT_FILE" \
+  '{timestamp: $ts, model: $model, prompt: $prompt, response: $response, context: $context}' \
+  >> "$LOG_FILE"
+```
+
+## Level 2: Native Task Tracking
+
+Use TaskCreate/TaskUpdate for active conversations that need team visibility.
+
+### Creating an Auditable Task
+
+```
+TaskCreate(
+  subject="Design review: Payment API",
+  metadata={
+    "event_type": "task",
+    "chain_id": "payment-api-review.root",
+    "source_agent": "multi-model-review",
+    "priority": "P1",
+    "initiative": "payment-api-review"
+  }
+)
+```
+
+### Adding AI Perspectives as Comments
+
+Each AI response becomes a comment with attribution:
+
+```markdown
+## Gemini Analysis (2026-01-25 14:32 UTC)
+
+**Prompt**: Review for security vulnerabilities
+
+**Response**:
+[Gemini's full response here]
+
+---
+Model: gemini-2.0-flash | Context: docs/payment-api.md
+```
+
+### Comment Template
+
+```bash
+# Function to add attributed AI comment
+add_ai_comment() {
+  local TASK_ID=$1
+  local MODEL=$2
+  local PROMPT=$3
+  local RESPONSE=$4
+
+  COMMENT="## ${MODEL} Analysis ($(date -u +"%Y-%m-%d %H:%M UTC"))
+
+**Prompt**: ${PROMPT}
+
+**Response**:
+${RESPONSE}
+
+---
+Model: ${MODEL} | Logged by: $(whoami)"
+
+  # Append to the native task description via TaskUpdate
+  # TaskUpdate(taskId=$TASK_ID, description="{previous}\n\n${COMMENT}")
+}
+```
+
+## Level 3: Decision Persistence (wicked-brain:memory)
+
+For decisions that matter long-term, persist to wicked-brain:memory.
+
+### What to Store
+
+| Type | Store When | Example |
+|------|------------|---------|
+| **Decision** | AI consensus led to architectural choice | "Use Stripe based on multi-model security review" |
+| **Dissent** | One AI flagged something others missed | "Gemini flagged rate limiting gap" |
+| **Pattern** | Discovered effective prompt pattern | "Security review prompt that catches edge cases" |
+| **Lesson** | AI was wrong, corrected later | "Codex suggested X, but Y was correct because..." |
+
+### Storage Patterns
+
+```
+# Store a decision with full attribution
+Skill(skill="wicked-brain:memory", args="store \"Payment API: Use webhook-based async processing.\nConsensus from Claude, Gemini, Codex (2026-01-25).\nKey factors: idempotency, retry handling, audit trail.\nDissent: None.\nTask: task-123\" --type decision --tags payments,architecture,ai-consensus")
+
+# Store a dissent/unique insight
+Skill(skill="wicked-brain:memory", args="store \"Auth review: Gemini uniquely flagged JWT refresh token rotation.\nOther models missed this. Added to security checklist.\" --type procedural --tags security,auth,gemini-insight")
+
+# Store a lesson learned
+Skill(skill="wicked-brain:memory", args="store \"AI code review limitation: All models missed SQL injection in dynamic query builder. Add explicit SQL injection check to review prompts.\" --type episodic --tags lesson-learned,security,ai-limitation")
+```
+
+## Audit Record Template
+
+For formal audits, use this structure:
+
+```markdown
+# AI-Assisted Decision Record
+
+## Metadata
+- **Decision ID**: ADR-2026-001
+- **Date**: 2026-01-25
+- **Decision Maker**: [Human who approved]
+- **AI Models Consulted**: Claude, Gemini, Codex
+
+## Context
+[What problem were we solving?]
+
+## AI Consultation
+
+### Claude (via Claude Code)
+- **Timestamp**: 2026-01-25 14:00 UTC
+- **Prompt**: [exact prompt used]
+- **Key Points**: [summary of response]
+- **Full Response**: [link or inline]
+
+### Gemini (via gemini CLI)
+- **Timestamp**: 2026-01-25 14:05 UTC
+- **Prompt**: [exact prompt used]
+- **Key Points**: [summary of response]
+- **Full Response**: [link or inline]
+
+### Codex (via codex CLI)
+- **Timestamp**: 2026-01-25 14:10 UTC
+- **Prompt**: [exact prompt used]
+- **Key Points**: [summary of response]
+- **Full Response**: [link or inline]
+
+## Synthesis
+[How human synthesized AI inputs]
+
+## Decision
+[Final decision made]
+
+## Rationale
+[Why this decision, including which AI inputs were influential]
+
+## Dissenting Views
+[Any AI perspectives that were noted but not followed, and why]
+```
+
+## Compliance Patterns
+
+### Healthcare/HIPAA
+
+```bash
+# Never include PHI in AI prompts
+# Log that AI was consulted without logging content
+echo "$(date -Iseconds) | AI_CONSULT | gemini | code-review | NO_PHI" >> audit.log
+```
+
+### Financial/SOX
+
+```
+# Include decision chain
+Skill(skill="wicked-brain:memory", args="store \"Trade algorithm change approved.\nAI review: Claude, Gemini confirmed no regression risk.\nHuman approval: [Name] on [Date].\nChange ticket: JIRA-456\" --type decision --tags sox-audit,trading,ai-review")
+```
+
+### General Best Practices
+
+1. **Always log the prompt** - What you asked matters as much as the answer
+2. **Attribute clearly** - Which model, which version, when
+3. **Human in the loop** - Record who made the final decision
+4. **Store dissent** - Minority AI opinions may be valuable later
+5. **Link artifacts** - Connect logs to native task IDs to mem entries
+
+## Quick Reference
+
+| Need | Solution |
+|------|----------|
+| Raw AI outputs | Local file logging |
+| Team visibility | Native task description appends via TaskUpdate |
+| Long-term decisions | wicked-brain:memory storage |
+| Formal compliance | Audit record template |
+| Cross-reference | Link task ID in all artifacts |