aiwg 2026.8.2 → 2026.8.4

package/README.md

@@ -6,7 +6,7 @@
 
 **Multi-agent AI framework for Claude Code, Copilot, Cursor, Warp, and 6 more platforms**
 
-200+ agents, 109+ CLI commands, 400+ deployable agent/skill/command/rule artifacts, 8 core frameworks, 27 addons, and a training marketplace package. SDLC workflows, digital forensics, research management, marketing operations, media curation, ops infrastructure, knowledge base, and fine-tuning dataset curation — all deployable with one command.
+200+ agents, 109+ CLI commands, 400+ deployable agent/skill/command/rule artifacts, 8 core frameworks, 32 addons, and a 40-plugin Claude Code marketplace. SDLC workflows, digital forensics, research management, marketing operations, media curation, ops infrastructure, knowledge base, and fine-tuning dataset curation — all deployable with one command.
 
 The simplest setup is to paste this into a supported AI provider:
 
@@ -527,7 +527,8 @@ The orchestration pattern: **Primary Author → Parallel Reviewers → Synthesiz
 - **334 artifact templates** — progressive disclosure templates for requirements, architecture, testing, security, deployment, and more
 - **8 platform support** — deploy to Claude Code, Copilot, Cursor, Warp, Factory AI, OpenCode, Codex, and Windsurf
 - **8 core frameworks + training marketplace package** — SDLC, Digital Forensics, Marketing Operations, Research Management, Media Curation, Ops Infrastructure, Knowledge Base, Security Engineering, plus [`aiwg-training`](https://github.com/jmagly/aiwg-training) for fine-tuning dataset curation (corpus-to-dataset pipeline with DPO/KTO/ORPO/SimPO export)
-- **31 addons** — compound memory, line memory, llm-wiki (Obsidian-native knowledge base), RLM recursive decomposition, fleet operations, browser control, testing quality, and more
+- **32 addons** — compound memory, line memory, llm-wiki (Obsidian-native knowledge base), RLM recursive decomposition, fleet operations, browser control, testing quality, and more
+- **40 Claude Code plugins** — the complete framework and addon catalog is installable independently from the AIWG marketplace
 - **Agent Loop** — iterative task execution with automatic error recovery and crash resilience (6-8 hour sessions)
 - **RLM addon** — recursive context decomposition for processing 10M+ tokens via sub-agent delegation
 - **YAML metalanguage** — declarative schema-validated workflow definitions (JSON Schema 2020-12)
@@ -609,8 +610,13 @@ The bundle is **byte-identical** in shape to its upstream form, so
 ```bash
 /plugin marketplace add jmagly/ai-writing-guide
 /plugin install sdlc@aiwg
+/plugin install agent-loop@aiwg
+/plugin install compound-memory@aiwg
 ```
 
+The marketplace contains all 40 packaged frameworks and addons, so you can
+install only the capabilities a Claude Code workspace needs.
+
 ### Multi-Platform Deployment
 
 ```bash

package/agentic/code/addons/aiwg-utils/skills/install-plugin/SKILL.md

@@ -2,7 +2,7 @@
 namespace: aiwg
 name: install-plugin
 platforms: [all]
-description: Install Claude Code marketplace plugins with registry lookup, download, and local deployment
+description: Install Claude Code marketplace plugins or route local/Git wrappers through the supported package workflow
 ---
 
 # Install Plugin
@@ -28,6 +28,8 @@ Alternate expressions and non-obvious activations (primary phrases are matched a
 | Claude Code plugin | "install claude code plugin utils" | Run `aiwg install-plugin utils@aiwg` |
 | Dry run | "show me what installing sdlc would do" | Run `aiwg install-plugin sdlc@aiwg --dry-run` |
 | Specific version | "install sdlc version 2026.3.0" | Run `aiwg install-plugin sdlc@aiwg@2026.3.0` |
+| Local wrapper | "install this local plugin wrapper" | Run `aiwg install <path> --dry-run`, then `aiwg use <plugin-id>` |
+| Git wrapper | "install this plugin Git URL" | Run `aiwg install <git-url> --dry-run`, then `aiwg use <plugin-id>` |
 
 ## Behavior
 
@@ -55,6 +57,12 @@ When triggered:
 
    # Force reinstall even if already installed
    aiwg install-plugin sdlc@aiwg --force
+
+   # Standalone local/Git wrappers use the package installer, not the legacy
+   # manifest-only install-plugin backend.
+   aiwg install ./path/to/wrapper --dry-run
+   aiwg install https://example.invalid/owner/wrapper.git --dry-run
+   aiwg use <plugin-id>
    ```
 
 3. **Report the result** — name the installed marketplace wrapper and confirm which agents, skills, commands, and rules were deployed and where.

package/agentic/code/frameworks/research-complete/skills/corpus-snapshot/SKILL.md

@@ -213,12 +213,12 @@ The default template uses markers for computed vs analyzed sections:
 
 ## Fortemi Core Migration Note
 
-During the Fortemi Core index migration preview, corpus snapshots remain
-AIWG-rendered from corpus sidecars, corpus views, and the local `.aiwg/.index`
-artifacts. Do not use `--backend fortemi-core` as the source of truth for
-snapshot metrics until #1690 explicitly accepts a Fortemi-projected snapshot
-contract and #1691 parity fixtures prove identical REF/PROF, citation,
-profile, radar, discovery, and quality metrics.
+By the #1690 boundary decision, corpus snapshots remain AIWG-rendered from
+corpus sidecars, corpus views, and the local `.aiwg/.index` artifacts. Fortemi
+v2 projects the underlying research and KB records for search and traversal;
+it does not replace the snapshot renderer. The golden corpus-view fixtures
+remain the parity contract for REF/PROF, citation, profile, radar, discovery,
+and quality metrics.
 
 ## Examples
 

package/agentic/code/frameworks/research-complete/skills/research-query/SKILL.md

@@ -46,13 +46,20 @@ Save the synthesized answer as a new artifact in `.aiwg/research/synthesis/`.
 ### `--sources-only` (optional)
 List matching sources without synthesizing an answer.
 
+### `--include-diagnostics` (optional)
+Include quarantine and generated integrity/artifact scan records in source
+selection. They are excluded by default because diagnostics are not research
+evidence. Scan severity or confidence labels never become GRADE evidence
+quality; only an explicit GRADE declaration or grade tag is accepted.
+
 ### `--max-sources` (optional)
 Maximum number of sources to read and synthesize from. Default: 10.
 
 ## Execution Flow
 
 The executable CLI wrapper `aiwg research-query` performs deterministic source
-selection and can emit JSON for tests and automation. It does not replace the
+selection from synced Fortemi record text/chunks without rereading source files
+and can emit JSON for tests and automation. It does not replace the
 skill's synthesis responsibilities; agents still write the final answer with
 GRADE-aware hedging, contradictions, gaps, and inline REF citations.
 

package/agentic/code/plugins/agent-loop/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "agent-loop",
+  "version": "2026.8.3",
+  "description": "Iterative AI coding loops with automatic recovery - iteration beats perfection",
+  "author": {
+    "name": "AIWG Contributors",
+    "email": "support@aiwg.io"
+  },
+  "homepage": "https://aiwg.io",
+  "repository": "https://github.com/jmagly/aiwg",
+  "license": "MIT",
+  "keywords": [
+    "al",
+    "agent-loop",
+    "ralph",
+    "iteration",
+    "loop",
+    "autonomous",
+    "batch",
+    "refactor",
+    "migration"
+  ]
+}

package/agentic/code/plugins/agent-loop/README.md

@@ -0,0 +1,201 @@
+# Agent Loop
+
+Iterative AI task execution with automatic recovery - **iteration beats perfection**.
+
+## Overview
+
+Al transforms single-pass AI execution into iterative completion loops. Instead of hoping a task succeeds on the first try, Al keeps iterating until verifiable completion criteria are met.
+
+```
+┌──────────────────────────────────────────┐
+│            RALPH LOOP                    │
+│                                          │
+│   Execute → Verify → Learn → Iterate     │
+│      ↑                          │        │
+│      └──────────────────────────┘        │
+│                                          │
+│   Until: criteria met OR limits reached  │
+└──────────────────────────────────────────┘
+```
+
+## Installation
+
+```bash
+# Via AIWG CLI
+aiwg use ralph
+
+# Or install plugin
+aiwg install-plugin ralph
+```
+
+## Quick Start
+
+### Fix All Tests
+
+```bash
+/ralph "Fix all failing tests" --completion "npm test passes"
+```
+
+### TypeScript Migration
+
+```bash
+/ralph "Convert src/ to TypeScript" --completion "npx tsc --noEmit passes" --max-iterations 20
+```
+
+### Coverage Target
+
+```bash
+/ralph "Add tests until 80% coverage" --completion "npm run coverage shows >= 80%"
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/ralph` | Start iterative task loop |
+| `/ralph-status` | Check current loop status |
+| `/ralph-abort` | Abort running loop |
+| `/ralph-resume` | Resume interrupted loop |
+
+## Natural Language
+
+Al also responds to:
+- "ralph this: [task]"
+- "keep trying until [condition]"
+- "loop until [criteria]"
+- "iterate on [task] until [done]"
+
+## Parameters
+
+```
+/ralph "<task>" --completion "<criteria>" [options]
+
+Options:
+  --max-iterations N    Safety limit (default: 10)
+  --timeout M           Minutes before timeout (default: 60)
+  --interactive         Ask setup questions first
+  --no-commit           Disable auto-commits
+  --branch <name>       Create feature branch
+```
+
+## Provider Routing
+
+On Codex and Claude Code, in-session Al/agent-loop requests delegate to the native `/goal` primitive instead of running a parallel AIWG emulation loop. AIWG still owns completion inference, safety gates, and audit output, then maps the work to:
+
+```text
+/goal "<task>; completion: <criteria>"
+```
+
+External Al remains AIWG-native because it is detached and crash-resilient; `/goal` is an in-session primitive.
+
+## How It Works
+
+### 1. Define Task
+Provide a clear, actionable task description.
+
+### 2. Set Completion Criteria
+Specify how to verify success (must be objectively checkable).
+
+### 3. Execute Loop
+Al attempts the task, verifies criteria, learns from failures, and iterates.
+
+### 4. Track Progress
+Each iteration is committed to git, creating clear history.
+
+### 5. Report Results
+Generates completion report with full iteration history.
+
+## Completion Criteria Examples
+
+**Good** (verifiable):
+- `"npm test passes"`
+- `"npx tsc --noEmit exits with code 0"`
+- `"npm run lint passes"`
+- `"coverage report shows >= 80%"`
+
+**Poor** (subjective):
+- `"code is good"`
+- `"feature is complete"`
+
+## State & Artifacts
+
+Al stores state in `.aiwg/ralph/`:
+
+```
+.aiwg/ralph/
+├── current-loop.json       # Loop state (for resume)
+├── iterations/             # Iteration history
+│   ├── iteration-1.md
+│   ├── iteration-2.md
+│   └── ...
+└── completion-*.md         # Final reports
+```
+
+## Best Practices
+
+1. **Be specific** - "Fix auth tests" > "Fix tests"
+2. **Use verifiable criteria** - Commands with exit codes work best
+3. **Set reasonable limits** - 10-20 iterations for most tasks
+4. **Enable auto-commit** - Track progress via git history
+5. **Learn from iterations** - Each failure teaches the next attempt
+
+## Examples
+
+See `docs/examples/` for detailed walkthroughs:
+- [Test Fixes](docs/examples/test-fix.md)
+- [Migrations](docs/examples/migration.md)
+- [Coverage](docs/examples/coverage.md)
+- [Greenfield](docs/examples/greenfield.md)
+
+## Philosophy
+
+> "Iteration beats perfection" - errors become learning data within the loop rather than session-ending failures.
+
+Al inverts traditional AI optimization from "unpredictable success" to "predictable failure with automatic recovery."
+
+## Important: When to Use Al
+
+**Al is a power tool.** Used correctly, it delivers overnight. Used incorrectly, it burns tokens producing junk.
+
+| Situation | Use Al? | Instead |
+|-----------|------------|---------|
+| Greenfield with no docs | **NO** | Use AIWG intake/flows first |
+| Vague requirements | **NO** | Write use cases first |
+| Clear spec, need implementation | **YES** | - |
+| Tests failing, need fixes | **YES** | - |
+| Migration with clear rules | **YES** | - |
+
+**The key insight**: Al excels at HOW to build, but thrashes on WHAT to build. Define your requirements first, then let Al implement.
+
+See [When to Use Al](docs/when-to-use-ralph.md) for detailed guidance on avoiding the token-burning trap.
+
+## External Al
+
+For long-running tasks (6-8 hours) that need crash recovery and cross-session persistence, see **External Al**:
+
+```bash
+/ralph-external "Migrate codebase to TypeScript" \
+  --completion "npx tsc --noEmit exits 0" \
+  --max-iterations 20 \
+  --checkpoint-interval 20
+```
+
+External Al provides:
+- Pre/post session snapshots
+- Periodic checkpoints during execution
+- Two-phase state assessment
+- Crash recovery and resume
+
+See [Al Guide](../../../../docs/ralph-guide.md) for full documentation on both internal and external Al.
+
+## Related
+
+- [Al Guide](../../../../docs/ralph-guide.md) - **Complete documentation** for both internal and external Al
+- [When to Use Al](docs/when-to-use-ralph.md) - Understanding Al's sweet spot
+- [Quickstart Guide](docs/quickstart.md) - Getting started
+- [Best Practices](docs/best-practices.md) - Writing effective tasks
+- [Troubleshooting](docs/troubleshooting.md) - Common issues
+
+## Credits
+
+Based on the [iterative agent loop methodology](https://dev.to/ibrahimpima/the-ralf-wiggum-breakdown-3mko).

package/agentic/code/plugins/agent-loop/agents/mc-conductor.md

@@ -0,0 +1,150 @@
+---
+name: mc-conductor
+description: Mission Control conductor — orchestrates parallel background missions, handles completions and failures, reports to the user
+model: haiku
+tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+  - Write
+  - Agent
+skills:
+  - mission-control
+  - project-awareness
+category: orchestration
+model-role: efficiency
+model-tier: economy
+---
+
+# MC Conductor
+
+You are the **MC Conductor** — the live orchestrator inside a Mission Control session. You dispatch missions, monitor their progress, handle completions and failures, and report status to the user. You are calm under pressure, precise in your tracking, and proactive about resolving blockers.
+
+## Your Role
+
+1. **Start** Mission Control sessions with clear names and appropriate limits
+2. **Dispatch** missions from work items, assigning priorities and completion criteria
+3. **Monitor** all running missions and react to state changes
+4. **Handle failures** by retrying, adjusting approach, or escalating
+5. **Report** aggregate progress in structured dashboard format
+6. **Coordinate** mission dependencies — start dependent missions when prerequisites complete
+
+## CLI Toolset
+
+You MUST use these CLI commands for all Mission Control operations.
+
+| Command | Purpose |
+|---------|---------|
+| `aiwg mc start` | Create a new Mission Control session |
+| `aiwg mc dispatch <id> "<obj>"` | Add a mission to the session |
+| `aiwg mc status [<id>]` | View mission dashboard |
+| `aiwg mc status <id> --json` | Machine-readable status for parsing |
+| `aiwg mc watch [<id>]` | Live monitoring |
+| `aiwg mc abort <session> <mission>` | Abort a specific mission |
+| `aiwg mc pause [<id>]` | Pause all running missions |
+| `aiwg mc resume [<id>]` | Resume paused session |
+| `aiwg mc stop [<id>]` | Shut down session |
+| `aiwg mc stop [<id>] --drain` | Let running finish, cancel queued |
+| `aiwg mc list` | List all sessions |
+| `aiwg ralph-external "<task>"` | Underlying loop engine |
+| `aiwg ralph-status` | Check individual loop status |
+
+## Decision Logic
+
+```
+1. INTAKE    → Parse user request into discrete missions with completion criteria
+2. SESSION   → Start session with descriptive name and appropriate max-missions
+3. PRIORITIZE → Order missions: blockers first, then dependencies, then parallel work
+4. DISPATCH  → Send each mission with --completion and --priority flags
+5. MONITOR   → Poll status periodically, react to completions/failures
+6. HANDLE    → On failure: retry once, then escalate. On completion: check dependents
+7. REPORT    → Summarize progress at milestones and on completion
+8. CLEANUP   → Stop session when all missions done or user requests stop
+```
+
+## LFD Loop Controls
+
+Mission Control missions inherit the AIWG LFD loop contract for long-running,
+budgeted, or eval-driven work:
+
+1. Before dispatch, each mission needs a measurable completion criterion, a
+   mechanical verifier, and declared limits for iterations plus observable
+   wall-clock/token/tool/spend budgets.
+2. Each retry cycle records a hypothesis, expected failure mode,
+   distinguishing diagnostic, and whether the next attempt is a structural
+   variant rather than a repeated local adjustment.
+3. Flat or non-improving cycles consume the exploration quota. Once the quota
+   is exhausted, require a structurally different approach or stop with the
+   current best output.
+4. Budget exhaustion is a terminal condition. Stop the mission, preserve the
+   best output, and report quality-per-1K-token and quality-per-minute when
+   analytics are available.
+5. Eval/holdout missions expose only aggregate score/probe/status or VOID to
+   workers. Holdout answers, detailed lint findings, and private diagnostics
+   stay outside optimizer-readable output.
+
+## Invocation Patterns
+
+| User Says | You Do |
+|-----------|--------|
+| "Run these 5 features in parallel" | Start session, dispatch 5 missions, monitor |
+| "Orchestrate the elaboration phase" | Break phase into missions, dispatch sequentially |
+| "Background: fix tests, update docs, deploy" | Start session, dispatch 3 missions |
+| "How's the background work going?" | `aiwg mc status --json`, summarize |
+| "Stop everything" | `aiwg mc stop` |
+| "The auth fix failed, skip it" | `aiwg mc abort <session> <mission>` |
+| "Add another task to the session" | `aiwg mc dispatch` to existing session |
+
+## Output Format
+
+When reporting status, use this format:
+
+```
+MISSION CONTROL — [Session Name]
+────────────────────────────────
+  #  Mission                    Status      Loop   Started
+────────────────────────────────
+  1  Fix auth service           ✓ DONE      4/10   14:22
+  2  Add pagination             ⏳ RUNNING  3/10   14:25
+  3  Write integration tests    ⏺ QUEUED    —      —
+────────────────────────────────
+  3 missions | 1 done | 1 running | 1 queued | 0 failed
+```
+
+## Examples
+
+### Example 1: Parallel feature construction
+
+**User**: "Build these features in parallel: user profiles, search pagination, and rate limiting"
+
+**You**:
+```bash
+aiwg mc start --name "Feature Sprint"
+aiwg mc dispatch mc-xxx "Implement user profile CRUD" --completion "profile tests pass" --priority high
+aiwg mc dispatch mc-xxx "Add pagination to search" --completion "search returns paginated results" --priority normal
+aiwg mc dispatch mc-xxx "Implement rate limiting middleware" --completion "rate limit tests pass" --priority normal
+```
+
+Then monitor and report: "Started 'Feature Sprint' with 3 missions. I'll monitor progress and report when missions complete."
+
+### Example 2: Sequential with dependencies
+
+**User**: "First fix the database migration, then run the test suite, then deploy"
+
+**You**: Dispatch migration first as high priority. When it completes, dispatch test suite. When tests pass, dispatch deployment. Use `aiwg mc status --json` to detect completions programmatically.
+
+### Example 3: Handling failure
+
+A mission fails after max iterations. You:
+1. Check the failure details via `aiwg mc status --json`
+2. Post a summary of what went wrong
+3. Ask the user: "Mission 'Fix auth' failed after 10 iterations. Should I retry with adjusted approach, skip it, or do you want to handle it manually?"
+
+## Guardrails
+
+1. **Never exceed --max-missions** without asking the user
+2. **Always set completion criteria** — missions without criteria run indefinitely
+3. **Report failures immediately** — don't let failed missions go unnoticed
+4. **Respect session state** — don't dispatch to paused/stopped sessions
+5. **Clean up sessions** — stop sessions when all work is done