agentic-qe 3.13.2 → 3.13.4

package/.claude/skills/dual-mode/dual-collect.md

@@ -0,0 +1,103 @@
+---
+name: dual-collect
+description: Collect results from headless Codex workers
+---
+
+# Dual Collect Skill
+
+Collect and aggregate results from headless Codex workers stored in shared memory.
+
+## Usage
+
+```
+/dual-collect [--namespace <namespace>] [--format <format>]
+```
+
+## Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `--namespace` | results | Memory namespace to search |
+| `--format` | summary | Output format: summary, detailed, json |
+| `--filter` | none | Filter by key pattern |
+
+## Examples
+
+### Collect All Results
+```
+/dual-collect
+```
+
+### Collect from Specific Namespace
+```
+/dual-collect --namespace patterns
+```
+
+### Detailed Output
+```
+/dual-collect --format detailed
+```
+
+### Filter by Worker
+```
+/dual-collect --filter "worker-auth-*"
+```
+
+## How It Works
+
+1. Queries the memory system for entries in specified namespace
+2. Aggregates results from all workers
+3. Formats output according to specified format
+4. Displays summary of completed/failed workers
+
+## Generated Commands
+
+```bash
+# List all results
+npx claude-flow@v3alpha memory list --namespace {{namespace}}
+
+# Search for specific patterns
+npx claude-flow@v3alpha memory search -q "{{filter}}" -n {{namespace}}
+
+# Get detailed entries
+{{#each results}}
+npx claude-flow@v3alpha memory get -k "{{this.key}}" -n {{namespace}}
+{{/each}}
+```
+
+## Output Formats
+
+### Summary (default)
+```
+Workers Completed: 4/4
+├─ worker-auth-core: ✅ Complete (auth.service.ts)
+├─ worker-auth-api: ✅ Complete (auth.controller.ts)
+├─ worker-tests: ✅ Complete (15 tests passing)
+└─ worker-docs: ✅ Complete (API.md updated)
+```
+
+### Detailed
+```
+┌─────────────────────────────────────────────────┐
+│ Worker: worker-auth-core                        │
+│ Status: Complete                                │
+│ Duration: 45s                                   │
+│ Files: auth.service.ts, auth.types.ts           │
+│ Result: Implemented JWT authentication          │
+└─────────────────────────────────────────────────┘
+```
+
+### JSON
+```json
+{
+  "workers": [
+    {"id": "worker-auth-core", "status": "complete", "result": "..."}
+  ],
+  "summary": {"total": 4, "completed": 4, "failed": 0}
+}
+```
+
+## Related Skills
+
+- `/dual-spawn` - Spawn headless workers
+- `/dual-coordinate` - Full hybrid workflow

package/.claude/skills/dual-mode/dual-coordinate.md

@@ -0,0 +1,85 @@
+---
+name: dual-coordinate
+description: Coordinate hybrid Claude Code + Codex workflows
+---
+
+# Dual Coordinate Skill
+
+Coordinate hybrid workflows that use Claude Code for interactive reasoning and Codex for parallel background execution.
+
+## Usage
+
+```
+/dual-coordinate --workflow <workflow-name> --task "<task-description>"
+```
+
+## Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `--workflow` | hybrid_development | Workflow template to use |
+| `--task` | required | Task description |
+| `--interactive-first` | true | Start with interactive phase |
+
+## Available Workflows
+
+### hybrid_development
+Design interactively, implement in parallel, review interactively.
+
+```
+/dual-coordinate --workflow hybrid_development --task "Build user authentication"
+```
+
+### parallel_feature
+Spawn multiple Codex workers for parallel implementation.
+
+```
+/dual-coordinate --workflow parallel_feature --task "Implement REST API"
+```
+
+### design_and_execute
+Interactive design phase, then batch execution.
+
+```
+/dual-coordinate --workflow design_and_execute --task "Refactor auth module"
+```
+
+## How It Works
+
+1. **Routing Decision**: Analyzes task to determine optimal platform split
+2. **Interactive Phase**: Complex reasoning in Claude Code
+3. **Parallel Phase**: Spawns Codex workers for execution
+4. **Review Phase**: Returns to Claude Code for quality review
+5. **Result Collection**: Aggregates worker results from memory
+
+## Generated Commands
+
+```bash
+# Phase 1: Interactive (Claude Code)
+# [Current session handles design/planning]
+
+# Phase 2: Parallel (Codex)
+{{#each workers}}
+claude -p "{{this.task}}" --session-id {{this.id}} &
+{{/each}}
+wait
+
+# Phase 3: Review (Claude Code)
+npx claude-flow@v3alpha memory list --namespace results
+```
+
+## Example: Full Hybrid Workflow
+
+```
+/dual-coordinate --workflow hybrid_development --task "Build user profile API"
+```
+
+This will:
+1. **Design Phase** (Interactive): Discuss requirements, design endpoints, plan implementation
+2. **Implement Phase** (Headless): Spawn coders, testers, docs writers in parallel
+3. **Review Phase** (Interactive): Review implementation, discuss improvements
+
+## Related Skills
+
+- `/dual-spawn` - Spawn headless workers only
+- `/dual-collect` - Collect results from workers

package/.claude/skills/dual-mode/dual-spawn.md

@@ -0,0 +1,81 @@
+---
+name: dual-spawn
+description: Spawn headless Codex workers from Claude Code for parallel execution
+---
+
+# Dual Spawn Skill
+
+Spawn multiple headless Codex workers to run tasks in parallel while you continue working interactively.
+
+## Usage
+
+```
+/dual-spawn "<task>" --workers <count> [--type <worker-type>]
+```
+
+## Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `task` | required | Task description for workers |
+| `--workers` | 3 | Number of parallel workers |
+| `--type` | coder | Worker type: coder, tester, docs, reviewer |
+| `--wait` | false | Wait for completion |
+
+## Examples
+
+### Spawn Implementation Workers
+```
+/dual-spawn "Implement user authentication" --workers 2 --type coder
+```
+
+### Spawn Test Writers
+```
+/dual-spawn "Write comprehensive tests for auth module" --workers 2 --type tester
+```
+
+### Spawn Documentation Workers
+```
+/dual-spawn "Document all API endpoints" --workers 1 --type docs
+```
+
+## How It Works
+
+1. Initializes shared swarm coordination
+2. Spawns headless Codex workers with `claude -p`
+3. Each worker searches memory for relevant patterns
+4. Workers execute in parallel
+5. Results stored in shared memory
+
+## Generated Commands
+
+```bash
+# Initialize coordination
+npx claude-flow swarm init --topology hierarchical --max-agents {{workers}}
+
+# Spawn workers
+{{#each workers}}
+claude -p "
+You are worker-{{@index}}.
+TASK: {{task}}
+
+1. Search: memory_search(query='{{task_keywords}}')
+2. Execute your assigned work
+3. Store: memory_store(key='result-{{@index}}', namespace='results', upsert=true)
+" --session-id task-{{@index}} &
+{{/each}}
+
+echo "Spawned {{workers}} headless workers"
+```
+
+## After Spawning
+
+Use `/dual-collect` to gather results:
+```
+/dual-collect --namespace results
+```
+
+Or check manually:
+```bash
+npx claude-flow memory list --namespace results
+```

package/.claude/skills/qe-court/SKILL.md

@@ -62,7 +62,7 @@ budget caps and cost receipts apply automatically.
 
 | Step | Default provider / tier | Why |
 |------|------------------------|-----|
-| **Defense** | `cognitum-low` or `claude-code` (may equal writer) | Cheap; states the case, never grades |
+| **Defense** | `claude-code` (default) or `cognitum-low` (may equal writer) | Cheap; states the case, never grades. Must differ in vendor from the jury |
 | Prosecutor — devils-advocate | `cognitum-mid` | Gap/assumption hunting |
 | Prosecutor — brutal-honesty | `claude-code` (Opus/Sonnet) | Rigor lens, different family from jury |
 | Prosecutor — sherlock | `cognitum-high` | Deductive/root-cause needs a strong model |
@@ -83,8 +83,15 @@ when you explicitly want to name several different models.
 **Enforced invariants** (defaults; do not weaken without reason):
 1. **≥2 distinct vendors** across the panel — Claude / Cognitum / GPT-via-Codex — not just tiers.
 2. **Jury provider ∉ {writer, defense}** — no model grades its own or its writer's output.
+   Vendor is compared **coarsely**: `cognitum-low` and `cognitum-high` are the same
+   vendor, so pairing them across defense and jury is a violation, not a diverse panel.
 3. All calls routed through `ProviderManager` → ADR-123 budget cap + receipts.
 
+Invariants 1–2 are machine-checked by `validateCourtConfig()` in `referee.ts`, which
+the court MUST call before seating a panel (see *How to run it*). The `options` block
+below binds directly to that check — `minDistinctVendors` and `writerIsNeverJuror` are
+read, not decorative.
+
 ## The protocol
 
 ```
@@ -150,7 +157,20 @@ composing existing agents/skills — there is no monolithic binary yet (a thin
 `aqe court` CLI wrapper is planned as ADR-124 Phase 1; the hosted `/v1/qe/verdict`
 is Phase 2). To run a court now:
 
-1. Read `config.json` for the panel + `routing` + `overturnDepth`.
+1. Read `config.json` for the panel + `routing` + `overturnDepth`, then **validate
+   the panel before seating it** — this step is not optional:
+
+   ```ts
+   import { validateCourtConfig } from 'src/skills/qe-court/referee';
+   const violations = validateCourtConfig(config);   // [] == valid
+   if (violations.length) throw new Error(`Cannot convene: ${violations.join(', ')}`);
+   ```
+
+   A non-empty result means the panel cannot render a trustworthy verdict
+   (colluding jury, too few vendors, no jury at all). **ABORT the court and tell
+   the user which invariant failed** — do not proceed with a degraded panel and
+   do not silently re-route around it. A court that convenes an invalid panel
+   produces exactly the false SHIP it exists to catch.
 2. Spawn the prosecutors **in one message, in parallel** (`Task`/`Agent`,
    `run_in_background: true`), each with its routed provider; run
    `codex exec review` for the cross-vendor lens via Bash.
@@ -172,7 +192,9 @@ Durable, attestable evidence — the "jury waiting for everything you ship."
 (`src/skills/qe-court/referee.ts`) and covered by an oracle suite
 (`tests/unit/skills/qe-court/referee.test.ts`) that the acceptance eval
 (`evals/qe-court.yaml`, command-eval mode) runs through the `aqe eval` CLI —
-6/6 green as of 2026-07-18. The keystone oracle: a seeded mutant a shallow panel
+15/15 green as of 2026-07-29. That suite now validates the **shipped `config.json`
+itself**, so a routing edit that seats a colluding panel fails in CI rather than in
+a user's court (issue #576). The keystone oracle: a seeded mutant a shallow panel
 rated SHIP is overturned to BLOCK when the overturn round is active, and MUST
 regress to SHIP at `overturnDepth: 0` — proving the mechanic carries its weight.
 Run it yourself: `aqe eval run --skill qe-court --model cognitum-low`.

package/.claude/skills/qe-court/config.json

@@ -6,7 +6,7 @@
   "emitScore": false,
   "routing": {
     "_note": "provider ids: claude-code | cognitum-{low,mid,high} | openrouter | codex | claude | openai | gemini | ollama. Cognitum resolves multiple models behind its tiers; use openrouter when you want to name several distinct models for breadth.",
-    "defense": { "provider": "cognitum-low" },
+    "defense": { "provider": "claude-code" },
     "prosecutor.devils-advocate": { "provider": "cognitum-mid" },
     "prosecutor.brutal-honesty": { "provider": "claude-code", "model": "sonnet" },
     "prosecutor.sherlock": { "provider": "cognitum-high" },

package/.claude/skills/skills-manifest.json

@@ -940,7 +940,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.13.2",
+    "fleetVersion": "3.13.4",
     "manifestVersion": "1.4.0",
     "lastUpdated": "2026-04-13T00:00:00.000Z",
     "contributors": [

package/.codex/hooks/aqe-codex-hook.cjs

@@ -26,14 +26,39 @@ const codexShim = path.join(root, '.codex', 'hooks', 'aqe-runtime.cjs');
 const shim = require('node:fs').existsSync(codexShim)
   ? codexShim
   : path.join(root, '.claude', 'hooks', 'aqe-hook.cjs');
-const result = spawnSync(process.execPath, [shim, subcommand, '--json'], {
-  cwd: root,
-  env: { ...process.env, CLAUDE_PROJECT_DIR: root },
-  input: JSON.stringify(input),
-  encoding: 'utf8',
-  timeout: Number(process.env.AQE_CODEX_HOOK_TIMEOUT_MS) || 20000,
-  maxBuffer: 4 * 1024 * 1024,
-});
+const adapterTimeout = Number(process.env.AQE_CODEX_HOOK_TIMEOUT_MS) || 25000;
+const runtimeTimeout = Number(process.env.AQE_HOOK_TIMEOUT_MS)
+  || Math.max(1000, adapterTimeout - 3000);
+
+function runAqe(command, extraArgs = []) {
+  return spawnSync(process.execPath, [shim, command, ...extraArgs, '--json'], {
+    cwd: root,
+    env: {
+      ...process.env,
+      CLAUDE_PROJECT_DIR: root,
+      AQE_HOOK_TIMEOUT_MS: String(runtimeTimeout),
+    },
+    input: JSON.stringify(input),
+    encoding: 'utf8',
+    timeout: adapterTimeout,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+}
+
+// Stop closes the current route-learning sentinel before session cleanup.
+// Both AQE commands emit internal telemetry, so return no Codex JSON.
+if (subcommand === 'stop') {
+  runAqe('post-route', ['--success', 'true']);
+  runAqe('session-end', ['--save-state']);
+  process.exit(0);
+}
+
+const result = runAqe(subcommand);
+
+// These commands produce AQE/Claude hook response shapes. Codex treats an
+// empty successful response as continue, which preserves their side effects
+// without forwarding unsupported permissionDecision or telemetry fields.
+if (subcommand !== 'route') process.exit(0);
 
 if (!result.stdout) process.exit(0);
 
@@ -46,7 +71,7 @@ try {
 
 // AQE route results are useful context but are not themselves a Codex hook
 // response. Wrap them in the supported additional-context envelope.
-if (subcommand === 'route' && !output.hookSpecificOutput) {
+if (!output.hookSpecificOutput) {
   const agent = output.recommendedAgent || 'unspecified';
   const confidence = Number.isFinite(output.confidence)
     ? ` (${Math.round(output.confidence * 100)}% confidence)`

package/.codex/hooks.json

@@ -8,7 +8,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" session-start",
-            "timeout": 25,
+            "timeout": 30,
             "statusMessage": "Loading AQE learning context"
           },
           {
@@ -26,7 +26,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" route",
-            "timeout": 20,
+            "timeout": 30,
             "statusMessage": "Routing through the AQE fleet"
           },
           {
@@ -45,7 +45,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" pre-command",
-            "timeout": 20,
+            "timeout": 30,
             "statusMessage": "Applying AQE command guardrails"
           },
           {
@@ -62,7 +62,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" pre-edit",
-            "timeout": 20,
+            "timeout": 30,
             "statusMessage": "Applying AQE edit guardrails"
           },
           {
@@ -81,7 +81,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" post-command",
-            "timeout": 20,
+            "timeout": 30,
             "statusMessage": "Recording AQE command outcome"
           },
           {
@@ -98,7 +98,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" post-edit",
-            "timeout": 20,
+            "timeout": 30,
             "statusMessage": "Recording AQE edit outcome"
           },
           {
@@ -152,9 +152,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" session-end",
-            "timeout": 20,
-            "statusMessage": "Saving AQE session state"
+            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/aqe-codex-hook.cjs\" stop",
+            "timeout": 60,
+            "statusMessage": "Closing AQE learning outcome and saving session state"
           },
           {
             "type": "command",

package/CHANGELOG.md

@@ -5,6 +5,91 @@ All notable changes to the Agentic QE project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.13.4] - 2026-08-02
+
+Codex users now receive a complete, upgradeable Agentic QE workflow instead of
+an MCP entry and partial instructions that could drift from the installed
+hooks and skills.
+
+### Added
+
+- **A curated Codex-native QE workflow fleet** ([#587]). New research,
+  dependency-aware planning, and lightweight Ruflo orchestration skills join
+  the existing quality-planning, testing, and review workflows. Ruflo remains
+  optional development-time guidance, enabled explicitly with `--with-ruflo`,
+  and is not a runtime dependency.
+- **End-to-end Codex installation verification.** `aqe platform verify codex`
+  now checks MCP configuration, AQE instructions, lifecycle hooks, adapters,
+  runtimes, and every required skill, with a failing exit code when the install
+  is incomplete.
+- **A package-boundary release gate.** `npm run verify:codex-package` verifies
+  the actual npm tarball contains all curated skills and hooks, excludes the
+  vendored Ruflo tree and dependencies, and confirms every MCP tool named in
+  generated Codex guidance is registered.
+
+### Fixed
+
+- **`--no-mcp` now applies to Codex installs.** Previously the Claude phase
+  honored the flag but the Codex asset phase still wrote `.codex/config.toml`.
+- **Codex upgrades now refresh AQE-owned configuration safely.** Existing MCP
+  blocks can switch memory backends, generated `AGENTS.md` guidance updates
+  inside explicit ownership markers, and user TOML, instructions, and hook
+  groups remain intact.
+- **Partial Codex installs are diagnosable.** MCP, rules, hooks, and skills now
+  report independent outcomes, so a malformed hooks file no longer hides the
+  components that succeeded or prevents later skill installation.
+
+### Changed
+
+- Removed the unused duplicate init command implementation. The active CLI
+  continues through the modular init handler, eliminating a second stale help
+  and option surface.
+
+[#587]: https://github.com/proffesor-for-testing/agentic-qe/issues/587
+
+## [3.13.3] - 2026-07-29
+
+Two independent quality-of-evidence fixes: learning capture could stop silently
+for days on a filesystem where WAL is disabled, and QE-Court shipped a default
+review panel that violated its own anti-collusion rule.
+
+### Fixed
+
+- **Learning capture no longer stops silently when `AQE_DISABLE_WAL` is set.**
+  With that flag on, AQE tried to switch the database journal mode on *every*
+  writable connection. That switch needs exclusive access, so any other process
+  holding the database open — a stray MCP server, for example — made the attempt
+  fail and take the whole persistence layer down with it. Hooks kept reporting
+  success while nothing was being recorded, which hid the outage for days.
+
+  AQE now only changes the journal mode when it is actually wrong (so normal
+  operation never needs the exclusive lock), refuses to write in a mode you have
+  declared unsafe rather than risking corruption, and — when something really is
+  holding the database — tells you the exact command that finds it instead of
+  guessing which process to blame.
+
+- **QE-Court's shipped default panel violated `writerIsNeverJuror`** ([#576]).
+  The bundled `config.json` seated the defense and the jury on two tiers of the
+  same vendor, which is exactly what the court's core anti-collusion rule
+  forbids — so a brand-new project got an invalid panel with no user action.
+  Worse, the rule could never have caught it: nothing turned the configured
+  routing into a panel, so validation never ran outside its own unit test, and
+  the config's `options` block was not wired to anything.
+
+  The default panel is now genuinely cross-vendor (and keeps the deeper-review
+  round on a different vendor from the jury, so escalation stays independent),
+  validation is a required step before a court convenes, the `options` block
+  actually takes effect, and the shipped config files are checked in CI so this
+  cannot regress unnoticed. Reported by @pacphi.
+
+### Changed
+
+- The bundled statusline refreshes every 60 seconds instead of every 5. It
+  reopened the learning database on every tick, adding constant pressure to the
+  same lock the fix above depends on.
+
+[#576]: https://github.com/proffesor-for-testing/agentic-qe/issues/576
+
 ## [3.13.2] - 2026-07-24
 
 Stops short-lived learning hooks from repeatedly producing

package/assets/skills/qe-court/SKILL.md

@@ -62,7 +62,7 @@ budget caps and cost receipts apply automatically.
 
 | Step | Default provider / tier | Why |
 |------|------------------------|-----|
-| **Defense** | `cognitum-low` or `claude-code` (may equal writer) | Cheap; states the case, never grades |
+| **Defense** | `claude-code` (default) or `cognitum-low` (may equal writer) | Cheap; states the case, never grades. Must differ in vendor from the jury |
 | Prosecutor — devils-advocate | `cognitum-mid` | Gap/assumption hunting |
 | Prosecutor — brutal-honesty | `claude-code` (Opus/Sonnet) | Rigor lens, different family from jury |
 | Prosecutor — sherlock | `cognitum-high` | Deductive/root-cause needs a strong model |
@@ -83,8 +83,15 @@ when you explicitly want to name several different models.
 **Enforced invariants** (defaults; do not weaken without reason):
 1. **≥2 distinct vendors** across the panel — Claude / Cognitum / GPT-via-Codex — not just tiers.
 2. **Jury provider ∉ {writer, defense}** — no model grades its own or its writer's output.
+   Vendor is compared **coarsely**: `cognitum-low` and `cognitum-high` are the same
+   vendor, so pairing them across defense and jury is a violation, not a diverse panel.
 3. All calls routed through `ProviderManager` → ADR-123 budget cap + receipts.
 
+Invariants 1–2 are machine-checked by `validateCourtConfig()` in `referee.ts`, which
+the court MUST call before seating a panel (see *How to run it*). The `options` block
+below binds directly to that check — `minDistinctVendors` and `writerIsNeverJuror` are
+read, not decorative.
+
 ## The protocol
 
 ```
@@ -150,7 +157,20 @@ composing existing agents/skills — there is no monolithic binary yet (a thin
 `aqe court` CLI wrapper is planned as ADR-124 Phase 1; the hosted `/v1/qe/verdict`
 is Phase 2). To run a court now:
 
-1. Read `config.json` for the panel + `routing` + `overturnDepth`.
+1. Read `config.json` for the panel + `routing` + `overturnDepth`, then **validate
+   the panel before seating it** — this step is not optional:
+
+   ```ts
+   import { validateCourtConfig } from 'src/skills/qe-court/referee';
+   const violations = validateCourtConfig(config);   // [] == valid
+   if (violations.length) throw new Error(`Cannot convene: ${violations.join(', ')}`);
+   ```
+
+   A non-empty result means the panel cannot render a trustworthy verdict
+   (colluding jury, too few vendors, no jury at all). **ABORT the court and tell
+   the user which invariant failed** — do not proceed with a degraded panel and
+   do not silently re-route around it. A court that convenes an invalid panel
+   produces exactly the false SHIP it exists to catch.
 2. Spawn the prosecutors **in one message, in parallel** (`Task`/`Agent`,
    `run_in_background: true`), each with its routed provider; run
    `codex exec review` for the cross-vendor lens via Bash.
@@ -172,7 +192,9 @@ Durable, attestable evidence — the "jury waiting for everything you ship."
 (`src/skills/qe-court/referee.ts`) and covered by an oracle suite
 (`tests/unit/skills/qe-court/referee.test.ts`) that the acceptance eval
 (`evals/qe-court.yaml`, command-eval mode) runs through the `aqe eval` CLI —
-6/6 green as of 2026-07-18. The keystone oracle: a seeded mutant a shallow panel
+15/15 green as of 2026-07-29. That suite now validates the **shipped `config.json`
+itself**, so a routing edit that seats a colluding panel fails in CI rather than in
+a user's court (issue #576). The keystone oracle: a seeded mutant a shallow panel
 rated SHIP is overturned to BLOCK when the overturn round is active, and MUST
 regress to SHIP at `overturnDepth: 0` — proving the mechanic carries its weight.
 Run it yourself: `aqe eval run --skill qe-court --model cognitum-low`.

package/assets/skills/qe-court/config.json

@@ -6,7 +6,7 @@
   "emitScore": false,
   "routing": {
     "_note": "provider ids: claude-code | cognitum-{low,mid,high} | openrouter | codex | claude | openai | gemini | ollama. Cognitum resolves multiple models behind its tiers; use openrouter when you want to name several distinct models for breadth.",
-    "defense": { "provider": "cognitum-low" },
+    "defense": { "provider": "claude-code" },
     "prosecutor.devils-advocate": { "provider": "cognitum-mid" },
     "prosecutor.brutal-honesty": { "provider": "claude-code", "model": "sonnet" },
     "prosecutor.sherlock": { "provider": "cognitum-high" },

package/assets/skills/skills-manifest.json

@@ -940,7 +940,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.13.2",
+    "fleetVersion": "3.13.4",
     "manifestVersion": "1.4.0",
     "lastUpdated": "2026-04-13T00:00:00.000Z",
     "contributors": [