@rune-kit/rune 2.23.0 → 2.25.0

package/README.md

@@ -5,7 +5,7 @@
 <p align="center">
   <strong>Less skills. Deeper connections.</strong><br>
   A lean, interconnected skill ecosystem for AI coding assistants.<br>
-  65 skills · 204 connections · 43 signals · 13 platforms · MIT
+  66 skills · 206 connections · 45 signals · 13 platforms · MIT
 </p>
 
 <p align="center">
@@ -23,7 +23,7 @@
 
 Most skill ecosystems are either **too many isolated skills** (540+ that don't talk to each other) or **rigid pipelines** (A → B → C, if B fails everything stops).
 
-Rune is a **mesh** — 65 skills with 204 connections + 43 signals across a 5-layer architecture. Skills call each other bidirectionally, forming resilient workflows that adapt when things go wrong.
+Rune is a **mesh** — 66 skills with 206 connections + 45 signals across a 5-layer architecture. Skills call each other bidirectionally, forming resilient workflows that adapt when things go wrong.
 
 ```
 Pipeline:  A → B → C → D         (B fails = stuck)
@@ -83,7 +83,33 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.23.0 — Native Skills)
+## Level Up: Rune Pro
+
+<p align="center">
+  <a href="https://github.com/rune-kit/rune-pro"><img src="assets/pro-upgrade.svg" alt="Rune Pro — Autopilot + Context Intelligence · $49 lifetime" width="100%"></a>
+</p>
+
+Free gives Claude discipline. **Pro** gives it two things the free tier can't:
+
+- **Autopilot** — approve a plan once and walk away. It executes each phase autonomously (self-reviews with zero-HIGH gates, regression-checks against baselines, commits per phase) and **resumes across sessions**. `cook` gets the job done; `autopilot` gets it done while you sleep.
+- **Context Intelligence** — a live **context cockpit** in your statusline (real %, the active skill's mesh layer, cost, predictive "~4m until auto-compaction") that also makes Claude *itself* aware of the pressure, so it saves decisions + progress to `.rune/` **before** compact wipes the session. Zero data loss.
+
+Plus **9 domain packs** (product, sales, data-science, support, growth, media, personal-brand, ecommerce, vietnam). **$49 lifetime, one-time — no subscription.**
+
+<p align="center">
+  <a href="https://github.com/rune-kit/rune-pro"><img src="https://img.shields.io/badge/Unlock_Pro_%2449-lifetime-a855f7?style=for-the-badge" alt="Unlock Rune Pro"></a>
+  <a href="https://rune-kit.github.io/rune#pricing"><img src="https://img.shields.io/badge/See_Pricing-rune--kit.github.io-blue?style=for-the-badge" alt="Pricing"></a>
+</p>
+
+---
+
+## What's New (v2.25.0 — Council)
+
+> **v2.25.0 (2026-07-11):** New **`council`** L3 primitive — genuinely decorrelated multi-perspective gathering. Detects installed AI CLIs, fans a question across distinct model families (external CLIs when present, subagents when not), gates off-topic/malformed voices, normalizes claims (anchor-first + shared-evidence arbiter fallback — prose similarity never counts), and arbitrates inline with an honest `NO_DECORRELATION` stamp when fewer than 2 real model families answered. Wired into 4 consumers: `adversary` (CRITICAL-tier plans), `review` (high-blast-radius diffs), `brainstorm` (Design-It-Twice candidate judgment), `problem-solver` (high-stakes conclusions) — every integration explicitly refuses to launder a same-family run as independent confirmation. **Live-dogfooded same day**: a real 3-voice self-test (external `grok` dispatch + 2 subagent fallbacks) independently converged on a real gap — "confirmed" `model_family` was CLI-brand identity, not verified backend identity, letting two CLIs redirected to the same backend (BYOK/proxy override) defeat the gate — fixed before shipping. **Pro**: `council-cockpit` (separate repo) adds a read-only live panel + cost-aware allocation + history-informed family weighting, PRE-council advisory only — Free never depends on Pro. Mesh now 66 skills / 208 connections / 45 signals.
+
+### Previous (v2.24.0 — Market Refresh)
+
+> **v2.24.0 (2026-07-11):** Model lineup + platform adapters refreshed to the mid-2026 landscape. Claude tiers across the mesh → **Opus 4.8 / Sonnet 5 / Haiku 4.5**; the **Codex** adapter → **GPT-5.6** `sol` / `terra` / `luna` (verified against codex-cli 0.144.1), with a suggested tier→`model_reasoning_effort` mapping in the generated `AGENTS.md`. **Fable 5** is positioned as an API-only frontier **oracle** target rather than a routing tier (opus stays the ceiling). **Windsurf → Devin Desktop** rebrand documented (emission kept on `.windsurf/`, which Devin still reads). New **goal-first advisory** in `plan`/`ba` to leverage native `/goal` + Managed Agents Outcomes. CI 1572/1572.
 
 > **v2.23.0 (2026-07-04):** Seven platform adapters move to the **Agent Skills open standard** (dir-per-skill `SKILL.md`, discovered and lazy-loaded by each platform's native loader). The headline fix: **Codex** dropped `.codex/skills/` from its scan list, so compiled skills were only findable via the AGENTS.md pointer — agents kept "re-finding" the path mid-session. Codex now emits to **`.agents/skills/`** (scanned CWD → repo root). Same treatment across the fleet: **cursor** `.cursor/rules/*.mdc` → `.cursor/skills/` (Cursor 2.4+ Skills, on-demand instead of always-on), **windsurf** → `.windsurf/skills/` (Cascade Skills), **copilot** → `.github/skills/`, **qoder** → `.qoder/skills/`, and **gemini/qwen** drop their all-skills-always-on context bombs (GEMINI.md bundle, QWEN.md `@import` wall) for native `.gemini/skills/` / `.qwen/skills/` + slim pointer files — a big context-window win on those platforms. Runtime hooks intentionally stay on `.cursor/rules` / `.windsurf/rules` (always-on is correct for hook context). Also fixes a YAML double-escaping bug that corrupted compiled frontmatter for skills with quoted descriptions on 6 platforms, and a duplicate `scripts/` copy in dir-per-skill builds. If you previously built for Codex/Cursor/Windsurf/Copilot/Gemini/Qwen/Qoder: re-run `npx @rune-kit/rune build` and delete the old output dirs. CI 1571/1571.
 
@@ -138,7 +164,7 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 - **`adversary` v0.2.0 — Mode: oracle** — when `agent.stuck` fires from `debug` (3 disproved hypotheses) or `fix` (2+ failed attempts), oracle-mode dispatches a stateless second-model pass with explicit "no prior context" framing. Bundle format is regex-validated (`[SYSTEM]` invariant role-priming + `[USER]` template + `### File N`), token-capped (100k bundle, 4k per file, 12 files max), citation-required reply contract. Secrets auto-redacted. Breaks the confirmation-bias loop that scout's zoom-out (structural pivot) cannot.
 - **`session-bridge` v0.8.0 — Detach Mode** — async escalation primitive. Heavy-model second-opinion calls (1-10 min wall time) no longer block the primary agent. `.rune/oracle-pending/<sessionId>.json` is the rendezvous file; idempotent dispatch (bundleHash-keyed); 10min default timeout; 24h orphan cleanup on session start. `cook` Phase 4 and `team` Phase 3 reattach via filesystem poll between adjacent tasks.
 - **`context-engine` v1.1.0 — Mode: preview** — pre-flight cost gate. Caller emits `context.preview` BEFORE bundle build with file list + estimated tokens (chars × 0.25). Per-caller thresholds: adversary 50k/100k, team 30k/80k (per worker), review 40k/100k, audit 60k/120k. Action enum `proceed | warn | block`. Override via `RUNE_CONTEXT_THRESHOLDS_<CALLER>`. Stops `team` parallel workstreams from silently blowing $20 of Opus tokens.
-- **Cross-provider model mapping** — 5 non-Anthropic adapters now translate `model: opus|sonnet|haiku` to provider-correct names. **codex** → gpt-5-pro / gpt-5 / gpt-5-mini. **antigravity** → gemini-3-pro / gemini-3-flash / gemini-3-flash-lite. **opencode / openclaw / generic** → tier:heavy / tier:mid / tier:light (provider-agnostic). claude / cursor / windsurf remain no-op (Anthropic backend understands native names).
+- **Cross-provider model mapping** — 5 non-Anthropic adapters now translate `model: opus|sonnet|haiku` to provider-correct names. **codex** → gpt-5.6-sol / gpt-5.6-terra / gpt-5.6-luna. **antigravity** → gemini-3-pro / gemini-3-flash / gemini-3-flash-lite. **opencode / openclaw / generic** → tier:heavy / tier:mid / tier:light (provider-agnostic). claude / cursor / windsurf remain no-op (Anthropic backend understands native names).
 - **Routing clarity sweep** — all 63 SKILL.md descriptions now double-quoted (YAML safety). 13 ambiguous-name skills got explicit "Use when…" routing hints so skill-router doesn't have to guess: ba, completion-gate, constraint-check, doc-processor, integrity-check, logic-guardian, onboard, preflight, sentinel-env, watchdog, worktree, hallucination-guard, mcp-builder.
 - **4 new mesh signals** — `oracle.dispatched`, `oracle.response`, `oracle.failed`, `context.preview`. All registered in Signal Catalog with full emit/listen mapping. `agent.stuck` listeners updated to include adversary in addition to scout.
 - **1,331 tests** — +71 from v2.14.0 across 5 new test files: adapter-model-mapping (18), oracle-bundle-format (19), oracle-pending-schema (16), context-preview-signal (13), skill-description-quality (5).
@@ -227,7 +253,7 @@ cook ───emit:phase.complete────→ session-bridge
 
 ## What Rune Is (and Isn't)
 
-Rune started as a **Claude Code plugin** and now compiles to **every major AI IDE**. Same 65 skills, same mesh connections, same workflows — zero knowledge loss across platforms.
+Rune started as a **Claude Code plugin** and now compiles to **every major AI IDE**. Same 66 skills, same mesh connections, same workflows — zero knowledge loss across platforms.
 
 | | Rune Provides | Claude Code Provides |
 |---|---|---|
@@ -319,14 +345,14 @@ npx @rune-kit/rune init --platform windsurf
 npx @rune-kit/rune init --platform antigravity
 ```
 
-This compiles all 65 skills into your IDE's rules format. Same knowledge, same workflows.
+This compiles all 66 skills into your IDE's rules format. Same knowledge, same workflows.
 
 ### Platform Comparison
 
 | Feature | Claude Code | Cursor / Windsurf / Others |
 |---------|-------------|---------------------------|
-| Skills available | 64/64 | 64/64 |
-| Mesh connections | 204 sync + 43 signals (programmatic) | 204 sync + 43 signals (rule references) |
+| Skills available | 66/66 | 66/66 |
+| Mesh connections | 206 sync + 45 signals (programmatic) | 206 sync + 45 signals (rule references) |
 | Workflows & HARD-GATEs | Full | Full |
 | Extension packs | 14 | 14 |
 | Subagent parallelism | Native | Sequential fallback |
@@ -595,14 +621,15 @@ Domain-specific skills that plug into the core mesh:
 
 > *Free Rune makes Claude disciplined. Pro makes Claude self-aware.*
 
-**Context Intelligence** — the headline Pro feature. Claude Code auto-compacts at random, wiping your session context. With Pro, Claude **knows** when context is filling up — and proactively saves decisions, progress, and discoveries before compact hits.
+**Context Intelligence** — the headline Pro feature. Claude Code auto-compacts without warning, wiping your session. Pro turns the statusline into a live **context cockpit** and makes Claude *know* when the window is filling — so it saves decisions, progress, and discoveries before compact hits.
 
 ```
-Free:  Claude is blind to context pressure → auto-compact → amnesia
-Pro:   Claude sees real-time context % → saves state → compact → reloads → zero loss
+◈ Opus 4.8 │ ████████░░░ 73% WARM │ ⬡ cook·L1 │ $0.91 │ 5h ██░░ 22%  7d ███░ 61%
 ```
 
-How it works: `rune-pulse` (statusline) reads `context_window.used_percentage` from Claude Code, writes to temp file. `context-inject` hook injects warnings into Claude's context at 70% / 80% / 90%. Claude triggers `session-bridge` + `neural-memory` to persist everything. After `/compact`, `session-start` reloads `.rune/` state — Claude picks up exactly where it left off.
+Three things a blind meter can't do: a **glitch-proof %** (no phantom 0%, no false "100% URGENT" during light work), a **burn-rate ETA** (*"~4m until auto-compaction"*), and **what's eating your context** (*"files 61% · mcp 22%"* → trim the biggest, don't nuke blind). At 70/80/90% real, `context-inject` writes the pressure into Claude's own context → it triggers `session-bridge` + `neural-memory`, you `/compact`, and `session-start` reloads `.rune/`. Zero loss.
+
+Free ships the blind tool-call counter; the real-% cockpit + predictive intelligence is Pro.
 
 **Autopilot** — approve a plan, walk away. Autonomous multi-session execution with zero-HIGH-tolerance quality gates, baseline regression checks, cross-phase coherence review, and structured completion reports. `cook` gets the job done. `autopilot` gets it done while you sleep.
 
@@ -679,7 +706,7 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 | Doc | What's inside |
 |-----|---------------|
 | [`docs/GETTING_STARTED.md`](docs/GETTING_STARTED.md) | Your first 5 minutes with Rune — install to first `/rune cook` |
-| [`docs/SKILLS.md`](docs/SKILLS.md) | All 65 skills, searchable by intent and layer |
+| [`docs/SKILLS.md`](docs/SKILLS.md) | All 66 skills, searchable by intent and layer |
 | [`docs/SIGNALS.md`](docs/SIGNALS.md) | Canonical signal inventory — 25 events, emit/listen graph |
 | [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) | 5-layer mesh architecture reference |
 | [`docs/VISION.md`](docs/VISION.md) | Philosophy — what Rune is and isn't |
@@ -692,10 +719,10 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 ## Numbers
 
 ```
-Core Skills:       64 (L0: 1 │ L1: 5 │ L2: 30 │ L3: 28)
+Core Skills:       66 (L0: 1 │ L1: 5 │ L2: 30 │ L3: 30)
 Extension Packs:   14 free + 9 pro + 4 business
-Mesh Connections:  203 sync calls (rune doctor)
-Mesh Signals:      43 signals · 55 emit/listen edges (rune doctor)
+Mesh Connections:  206 sync calls (rune doctor)
+Mesh Signals:      45 signals · 55 emit/listen edges (rune doctor)
 Connections/Skill: 3.2 avg
 Platforms:         8 (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)
 Compiler:          ~1400 LOC (parser + 8 transforms + 8 adapters + CLI)

package/compiler/__tests__/adapter-model-mapping.test.js

@@ -25,19 +25,19 @@ const baseSkill = {
 describe('codex adapter model mapping', () => {
   const codex = getAdapter('codex');
 
-  test('opus translates to gpt-5-pro', () => {
+  test('opus translates to gpt-5.6-sol', () => {
     const header = codex.generateHeader({ ...baseSkill, model: 'opus' });
-    assert.match(header, /model: gpt-5-pro/);
+    assert.match(header, /model: gpt-5\.6-sol/);
   });
 
-  test('sonnet translates to gpt-5', () => {
+  test('sonnet translates to gpt-5.6-terra', () => {
     const header = codex.generateHeader({ ...baseSkill, model: 'sonnet' });
-    assert.match(header, /model: gpt-5(?!-)/);
+    assert.match(header, /model: gpt-5\.6-terra/);
   });
 
-  test('haiku translates to gpt-5-mini', () => {
+  test('haiku translates to gpt-5.6-luna', () => {
     const header = codex.generateHeader({ ...baseSkill, model: 'haiku' });
-    assert.match(header, /model: gpt-5-mini/);
+    assert.match(header, /model: gpt-5\.6-luna/);
   });
 
   test('omitted model produces no model line', () => {

package/compiler/__tests__/adapters.test.js

@@ -161,6 +161,19 @@ test('codex adapter uses skill directories', () => {
   assert.strictEqual(codex.skillFileName, 'SKILL.md');
 });
 
+test('codex AGENTS.md documents the tier→model + reasoning-effort mapping', async () => {
+  const codex = getAdapter('codex');
+  const extras = await codex.generateExtraFiles({
+    stats: { skillCount: 65, crossRefsResolved: 204, packCount: 14, files: [] },
+  });
+  const agents = extras.find((e) => e.path === 'AGENTS.md');
+  assert.ok(agents, 'codex emits AGENTS.md');
+  // Guards against a MODEL_MAP / REASONING_EFFORT_MAP interpolation swap.
+  assert.match(agents.content, /opus → `gpt-5\.6-sol` \(`model_reasoning_effort = "high"`\)/);
+  assert.match(agents.content, /sonnet → `gpt-5\.6-terra` \(`model_reasoning_effort = "medium"`\)/);
+  assert.match(agents.content, /haiku → `gpt-5\.6-luna` \(`model_reasoning_effort = "low"`\)/);
+});
+
 // --- New v2.18 adapters: shape + generateExtraFiles contract ---
 
 test('qoder adapter targets .qoder/skills (dir-per-skill) and emits AGENTS.md', async () => {

package/compiler/adapters/codex.js

@@ -13,18 +13,33 @@
  * only (config.toml). Repo skills MUST live in .agents/skills/ to be
  * auto-discovered. @see https://developers.openai.com/codex/skills
  *
- * MODEL TIER MAPPING (v2.15+):
+ * MODEL TIER MAPPING (v2.15+, lineup refreshed 2026-07):
  * Skill frontmatter `model: opus|sonnet|haiku` (Anthropic naming) is
  * translated to Codex/OpenAI provider-correct model names so the field
  * is meaningful in the compiled output. Unknown tier values pass through.
+ *
+ * Codex GPT-5.6 tiers (verified against codex-cli 0.144.1 + developers.openai.com/codex/models):
+ *   sol  = flagship/complex → opus
+ *   terra = balanced everyday → sonnet
+ *   luna = fast/affordable → haiku
+ * Codex also exposes `model_reasoning_effort = minimal|low|medium|high|xhigh`
+ * (a config.toml key, not per-skill frontmatter) — Rune surfaces the tier→effort
+ * suggestion in AGENTS.md rather than emitting a speculative per-skill field.
  */
 
 import { BRANDING_FOOTER } from '../transforms/branding.js';
 
 const MODEL_MAP = {
-  opus: 'gpt-5-pro',
-  sonnet: 'gpt-5',
-  haiku: 'gpt-5-mini',
+  opus: 'gpt-5.6-sol',
+  sonnet: 'gpt-5.6-terra',
+  haiku: 'gpt-5.6-luna',
+};
+
+// Suggested config.toml `model_reasoning_effort` per tier (global key, documented in AGENTS.md).
+const REASONING_EFFORT_MAP = {
+  opus: 'high',
+  sonnet: 'medium',
+  haiku: 'low',
 };
 
 const TOOL_MAP = {
@@ -111,6 +126,16 @@ export default {
       '',
       'Skills are located in: .agents/skills/ (auto-discovered by Codex)',
       '',
+      '## Model Tiers',
+      '',
+      'Rune skills carry a tier hint (`opus`/`sonnet`/`haiku`). Suggested Codex mapping:',
+      '',
+      `- opus → \`${MODEL_MAP.opus}\` (\`model_reasoning_effort = "${REASONING_EFFORT_MAP.opus}"\`) — architecture / security / planning`,
+      `- sonnet → \`${MODEL_MAP.sonnet}\` (\`model_reasoning_effort = "${REASONING_EFFORT_MAP.sonnet}"\`) — code / edit / review`,
+      `- haiku → \`${MODEL_MAP.haiku}\` (\`model_reasoning_effort = "${REASONING_EFFORT_MAP.haiku}"\`) — scan / read-only`,
+      '',
+      'Set `model` + `model_reasoning_effort` in `~/.codex/config.toml` to match the tier of the task.',
+      '',
       '---',
       '> Rune Skill Mesh — https://github.com/rune-kit/rune',
       '',

package/compiler/adapters/windsurf.js

@@ -1,14 +1,21 @@
 /**
  * Windsurf Adapter
  *
- * Emits SKILL.md files into .windsurf/skills/{name}/ directories — Windsurf's
- * native Cascade Skills format. Cascade uses progressive disclosure: only the
- * skill's name and description are shown to the model by default; the full
- * SKILL.md is loaded when Cascade invokes the skill (or via @skill-name).
+ * Emits SKILL.md files into .windsurf/skills/{name}/ directories — the native
+ * Cascade Skills format. Cascade uses progressive disclosure: only the skill's
+ * name and description are shown to the model by default; the full SKILL.md is
+ * loaded when Cascade invokes the skill (or via @skill-name).
  *
- * Windsurf skills dir: .windsurf/skills/
- * Windsurf skill format: .windsurf/skills/{name}/SKILL.md
- * @see https://docs.windsurf.com/windsurf/cascade/skills
+ * REBRAND (2026-06-02): Windsurf is now "Devin Desktop" (Cognition), rolled out
+ * over-the-air. Devin Desktop PREFERS `.devin/skills/` + `.devin/rules/` but
+ * still reads `.windsurf/skills/` + `.windsurf/rules/` as a documented fallback
+ * (docs.devin.ai). Rune keeps emitting to `.windsurf/` for maximum compat — it
+ * works on both current Devin and any un-migrated Windsurf install. The CLI flag
+ * stays `--platform windsurf`. Flip the emission dirs to `.devin/` only once
+ * Devin deprecates the `.windsurf/` fallback. @see docs.devin.ai/desktop
+ *
+ * Windsurf/Devin skills dir: .windsurf/skills/  (Devin also reads .devin/skills/)
+ * Skill format: .windsurf/skills/{name}/SKILL.md
  *
  * NOTE: .windsurf/rules/ is still used by the runtime-hooks installer
  * (adapters/hooks/windsurf.js) — rules are the correct vehicle for always-on

package/extensions/ai-ml/skills/llm-architect.md

@@ -64,21 +64,21 @@ interface ModelConfig {
 
 const MODELS: Record<string, ModelConfig> = {
   fast: {
-    id: 'claude-haiku-4-5-20251001',
+    id: 'claude-haiku-4-5',
     provider: 'anthropic',
     costPer1kTokens: 0.001,
     maxTokens: 4096,
     latencyP50Ms: 200,
   },
   balanced: {
-    id: 'claude-sonnet-4-6',
+    id: 'claude-sonnet-5',
     provider: 'anthropic',
     costPer1kTokens: 0.01,
     maxTokens: 8192,
     latencyP50Ms: 800,
   },
   deep: {
-    id: 'claude-opus-4-6',
+    id: 'claude-opus-4-8',
     provider: 'anthropic',
     costPer1kTokens: 0.05,
     maxTokens: 16384,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.23.0",
+  "version": "2.25.0",
   "description": "65-skill mesh for AI coding assistants — runtime auto-discipline via native hooks (Claude/Cursor/Windsurf/Antigravity), 5-layer architecture, 204 connections + 43 signals, multi-platform compiler. converge (L3) scans spec vs code so dead-button/frontend-only implementations can't ship.",
   "type": "module",
   "bin": {

package/skills/adversary/SKILL.md

@@ -3,7 +3,7 @@ name: adversary
 description: "Pre-implementation red-team analysis. Use when a plan is high-risk, critical path, or expensive to reverse. Challenges plans before code is written — finds edge cases, security holes, scalability bottlenecks, error propagation risks, and integration conflicts. Catches flaws at plan time (10x cheaper than post-implementation)."
 metadata:
   author: runedev
-  version: "0.4.0"
+  version: "0.5.0"
   layer: L2
   model: opus
   group: quality
@@ -41,6 +41,7 @@ Every finding MUST reference the specific plan section, file, or assumption it c
 - `hallucination-guard` (L3): verify that APIs, packages, or patterns referenced in the plan actually exist
 - `context-engine` (L3): (oracle-mode) emit `context.preview` before bundle build to gate token cost
 - `session-bridge` (L3): (oracle-mode) detach protocol when target model is opus-class for non-blocking dispatch
+- `council` (L3): Step 0.6 — decorrelated multi-perspective critique for CRITICAL-tier plans (one-way-door decisions, auth/payment/crypto/user-data), mode=critique
 
 ## Called By (inbound)
 
@@ -58,6 +59,7 @@ Every finding MUST reference the specific plan section, file, or assumption it c
 - `adversary` → `perf` — scalability concern raised → perf quantifies the bottleneck
 - `adversary` → `scout` — integration risk flagged → scout finds affected code
 - `adversary` → `plan` — CRITICAL findings → plan revises before implementation
+- `adversary` → `council` — CRITICAL-tier plan (one-way-door decision, or auth/payment/crypto/user-data) → decorrelated critique before red-teaming
 
 ## Execution
 
@@ -93,6 +95,35 @@ produces concrete remediations (likely HARDEN), but maps to REVISE if it exposes
 structural flaw in the chosen approach; Socratic's surfaced assumptions and Pre-mortem's
 narratives become findings.
 
+### Step 0.6: Decorrelated Multi-Perspective Gathering (council, CRITICAL-tier only)
+
+adversary's own single pass is one model's opinion, however rigorous. For the subset of plans
+where being wrong is expensive enough to justify it, call `rune:council` (mode=critique) before
+Steps 1-5, instead of (or in addition to) solo analysis.
+
+**Trigger — call council when ANY of:**
+- Step 0.5 selected the **Dialectic** or **Pre-mortem** lens (one-way-door architecture/vendor
+  decisions, irreversible migrations — exactly the cases where a second architecture's blind
+  spots differing from yours has the highest expected value)
+- The plan touches auth, payment, crypto, or user data at a severity that would otherwise
+  trigger mandatory `sentinel` escalation (Step 2)
+- The user explicitly asks for a second opinion or "gut check" before committing
+
+**Do NOT call council for**: Quick Challenge mode plans, plans under 3 files with no
+auth/payment/data logic, or routine feature work — council is opt-in overhead, not a default
+tax on every adversary run (see council's own Sharp Edges: never auto-fires on every plan).
+
+**Request**: `{ question: <steelmanned thesis + the specific risk being tested>, mode: "critique",
+n: 3, diversity: { prefer_model_families: true }, evidence_required: [reasoning, citation] }`.
+The question MUST be self-contained — council's voices have no access to this conversation.
+
+**Consume**: fold `CouncilResult.agreement.consensus_claims` into the relevant dimension's
+findings below, tagged `[council-verified]`. Fold `agreement.dissent` into that dimension's
+findings too, but tagged `[council-dissent]` — dissent is information, not something to
+resolve by picking a side. If `decorrelation: NO_DECORRELATION`, do not describe the result as
+a second opinion in the report — say plainly that no independent model family was reachable and
+the additional voices were same-family subagents.
+
 ### Step 1: Edge Case Analysis
 
 Challenge the plan's handling of boundary conditions.
@@ -212,6 +243,9 @@ Synthesize all findings into an actionable report.
 - 3+ HIGH findings → **REVISE**
 - HIGH findings with clear remediations → **HARDEN** (add remediations to plan, then proceed)
 - Only MEDIUM/LOW findings → **PROCEED** (note findings for implementation awareness)
+- If council was invoked (Step 0.6) and returned `needs_decision: true` → the verdict cannot be
+  PROCEED regardless of adversary's own findings; surface the unresolved dissent to the user
+  instead of silently picking a side
 
 After reporting:
 - If verdict is REVISE: return to `plan` with findings attached as constraints
@@ -225,6 +259,7 @@ After reporting:
 - **Plan analyzed**: [path to plan file]
 - **Dimensions checked**: [which of the 5 were relevant]
 - **Reasoning lens**: [Red Team | Pre-mortem | Evidence Audit | Dialectic | Socratic — and why]
+- **Council**: [not invoked | MULTI_FAMILY (N families) | NO_DECORRELATION — same-family subagents only]
 - **Findings**: [count by severity]
 - **Verdict**: REVISE | HARDEN | PROCEED
 
@@ -347,6 +382,8 @@ See `references/oracle-mode.md` for the full protocol and integration with `debu
 | (cross-model) External CLI invoked without authorization or in non-interactive run | CRITICAL | Per-call user authorization required; non-interactive → skip + announce. See `references/cross-model-escalation.md` |
 | (cross-model) Bundle interpolated into shell args — embedded `$(...)` executes | CRITICAL | Always pass via stdin from a temp file; read-only sandbox. Never inline `-p "<bundle>"` |
 | (cross-model) Rubber-stamping the external reviewer's verdict | MEDIUM | Reply is data, not ruling — reconcile against the artifact; classify each finding |
+| (council) Reporting council output as consensus when decorrelation is NO_DECORRELATION | CRITICAL | Step 0.6 consume rule: report the decorrelation stamp plainly, never imply independent validation from same-family subagents |
+| (council) Calling council on every plan, not just CRITICAL-tier | MEDIUM | Step 0.6 trigger list is explicit — Dialectic/Pre-mortem lens, auth/payment/crypto/user-data, or explicit user request only |
 
 ## Done When
 
@@ -358,6 +395,7 @@ See `references/oracle-mode.md` for the full protocol and integration with `debu
 - Findings formatted for consumption by cook Phase 3 (if PROCEED) or plan (if REVISE)
 - Strength Notes section acknowledges well-designed aspects of the plan
 - (oracle-mode) If dispatched: response cited file:line for each claim, or `oracle.failed` emitted with rejection reason
+- (council) If CRITICAL-tier trigger matched: council invoked before Steps 1-5, its decorrelation stamp reported plainly, consensus/dissent folded into the relevant dimension findings
 
 ## Returns
 
@@ -371,6 +409,6 @@ See `references/oracle-mode.md` for the full protocol and integration with `debu
 
 ## Cost Profile
 
-~4000-8000 tokens input (plan + codebase context), ~2000-3000 tokens output. Opus model for adversarial depth. Runs once per feature plan — high cost justified by preventing wasted implementation cycles.
+~4000-8000 tokens input (plan + codebase context), ~2000-3000 tokens output. Opus model for adversarial depth. Runs once per feature plan — high cost justified by preventing wasted implementation cycles. When Step 0.6 fires (CRITICAL-tier only): add council's cost profile (~1500-4000 tokens per voice × 2-5 voices) — reserved for the minority of plans where being wrong is expensive.
 
 **Scope guardrail:** adversary reviews THE PLAN only — never audits existing codebase quality or rewrites code.

package/skills/adversary/references/oracle-mode.md

@@ -42,8 +42,9 @@ Emit `oracle.dispatched` carrying `{sessionId, triggerSignal, sourceSkill, targe
 
 | Target model | Protocol |
 |--------------|----------|
-| sonnet-class (gpt-5, gemini-3-flash, claude-sonnet) | Synchronous — block until reply or 60s timeout |
-| opus-class (gpt-5-pro, gemini-3-pro, claude-opus-4-7) | Async — primary agent continues; poll `.rune/oracle-pending/<sessionId>.json` between phases |
+| sonnet-class (gpt-5.6-terra, gemini-3-flash, claude-sonnet-5) | Synchronous — block until reply or 60s timeout |
+| opus-class (gpt-5.6-sol, gemini-3-pro, claude-opus-4-8) | Async — primary agent continues; poll `.rune/oracle-pending/<sessionId>.json` between phases |
+| frontier-class (claude-fable-5, API-only) | Async, heaviest second opinion for the hardest red-team / architecture calls. **API-only** — not available on a subscription runtime, so reach it via an API key or a non-Anthropic CLI, never via the primary Claude Code session's model. Thinking is always on (control depth with `effort`, do not send a `thinking` param) and it can return a `refusal` stop reason — treat a refusal as "no oracle reply", fall back to opus-class. |
 
 ### 5. Validate response
 

package/skills/ba/SKILL.md

@@ -3,7 +3,7 @@ name: ba
 description: "Business Analyst agent. Use when starting a new feature requiring requirements elicitation BEFORE plan or cook. Asks probing questions, identifies hidden requirements, maps stakeholders, defines scope boundaries, and produces a structured Requirements Document that plan and cook consume."
 metadata:
   author: runedev
-  version: "1.2.0"
+  version: "1.2.1"
   layer: L2
   model: opus
   group: creation
@@ -19,6 +19,11 @@ Business Analyst agent — the ROOT FIX for "Claude works a lot but produces not
 
 > Wrong requirements shipped correctly is the most expensive bug. BA's job is to prevent it — measure clarity (Step 2.5), measure completeness (Step 3.5), and measure cross-dimension consistency (Step 3.6) before handoff.
 
+> **Goal-first (advisory, 2026).** The Requirements Document is the goal spec current
+> models want up front. Where the platform has a native goal/outcome command — Claude
+> Code `/goal`, Managed Agents Outcomes (rubric) — seed it from this document's scope
+> boundaries + acceptance criteria so the whole run stays anchored to the agreed WHAT.
+
 <HARD-GATE>
 BA produces WHAT, not HOW. Never write code. Never plan implementation.
 Output is a Requirements Document → hand off to rune:plan for implementation planning.

package/skills/brainstorm/SKILL.md

@@ -3,7 +3,7 @@ name: brainstorm
 description: "Creative ideation and solution exploration. Generates multiple approaches with trade-offs, uses structured frameworks (SCAMPER, First Principles), and hands off to plan for structuring."
 metadata:
   author: runedev
-  version: "0.7.0"
+  version: "0.8.0"
   layer: L2
   model: opus
   group: creation
@@ -57,6 +57,7 @@ Activated when exploring alternative *interface shapes* for a deepening candidat
 3. Diversity score MUST be >= 0.4 before presenting (re-spawn once if below)
 4. Recommendation MUST be opinionated with a concrete hedge condition — "it depends" is BLOCKED
 5. Hybrid synthesis (Step 4.5) is opt-in when 2 designs have complementary strengths
+6. council (Step 3.75) is opt-in per the narrow trigger — MUST NOT fire on every design-it-twice run, and its output MUST NOT replace the diversity-score mechanism, only supplement it
 
 Full doctrine: [references/design-it-twice.md](references/design-it-twice.md).
 
@@ -110,6 +111,7 @@ Direct API call ≠ Wrapper/middleware layer ≠ Reverse engineering ≠ Browser
 - `trend-scout` (L3): market context and trends for product-oriented brainstorming
 - `problem-solver` (L3): structured reasoning frameworks (SCAMPER, First Principles, 6 Hats)
 - `sequential-thinking` (L3): evaluating approaches with many variables
+- `council` (L3): Step 3.75 — decorrelated judgment on which Design-It-Twice candidate is strongest, narrow trigger only (Design-It-Twice Mode)
 
 ## Called By (inbound)
 
@@ -126,6 +128,7 @@ Direct API call ≠ Wrapper/middleware layer ≠ Reverse engineering ≠ Browser
 
 - `brainstorm` ↔ `plan` — bidirectional: brainstorm generates options → plan structures the chosen one, plan needs exploration → brainstorm ideates
 - `brainstorm` → `ba` — a standalone brainstorm that picks an approach for a NEW feature with no requirements spec routes to `ba` first (WHAT before HOW). Suppressed when `ba` is the caller — that direction is `ba` → `brainstorm` and re-invoking would loop.
+- `brainstorm` → `council` — Design-It-Twice candidates ready + high-stakes trigger fires (Step 3.75) → decorrelated judgment on the strongest candidate before Step 4 Recommend
 
 ## Reasoning Frameworks
 
@@ -300,6 +303,21 @@ diversity = 1 - mean(pairwise_jaccard(feature_vectors))
 
 Emit `diversity_score` in chain_metadata.
 
+### Step 3.75 — Decorrelated Judgment (council, Design-It-Twice Mode only)
+
+The diversity score (Step 3.5) measures how DIFFERENT the candidate designs are — it says nothing about which one is BEST. For high-stakes interface decisions, that judgment call benefits from a second architecture's opinion, the same discipline `adversary` Step 0.6 and `review` Step 1.6 already apply.
+
+**Trigger — call council (mode=judge) when ANY of:**
+- N=4 was spawned (dependency category `remote-owned` or `true-external`, per Step 2.5 — the same tier that already signals higher stakes)
+- Diversity landed in the 0.4–0.59 marginal band (Step 3.5) and a re-spawn still didn't clearly separate the candidates
+- User explicitly asks for a second opinion on which design to pick
+
+**Do NOT call council for**: routine Design-It-Twice runs where diversity ≥ 0.6 on an in-process/local-substitutable dependency (N=3) — this is opt-in overhead on top of the existing subagent fan-out, not a default tax on every design-it-twice run.
+
+**Request**: `{ question: <the candidate designs' interface/usage/tradeoffs YAML + "which design is strongest given constraints X">, mode: "judge", n: 3, diversity: { prefer_model_families: true }, evidence_required: [reasoning] }`. Self-contained — council's voices never saw the subagent spawns.
+
+**Consume**: fold `agreement.consensus_claims` into Step 4's recommendation as a `[council-verified]` signal alongside (never instead of) the diversity score. Fold `agreement.dissent` into the hedge condition, tagged `[council-dissent]`. If `decorrelation: NO_DECORRELATION`, say so plainly — do NOT describe the judgment as independent confirmation from same-family subagents; the diversity-score mechanism remains the primary signal in that case.
+
 ### Step 4 — Recommend
 
 Select ONE approach as the recommendation. State:
@@ -419,6 +437,7 @@ If the user rejects the recommendation, return to Step 2 with adjusted constrain
 9. [Design-It-Twice Mode] MUST spawn parallel subagents with one constraint pinned per agent — fake diversity (one agent producing N options) is BLOCKED
 10. [Design-It-Twice Mode] MUST emit `diversity_score` and re-spawn (once) if below 0.4 floor
 11. [Design-It-Twice Mode] MUST NOT produce "it depends" recommendations — pick one design with a concrete hedge condition
+12. [Design-It-Twice Mode] MUST NOT call council on every run — narrow trigger only (N=4 remote/external dependency, marginal diversity band, or explicit user request); when invoked, council output supplements (never replaces) the diversity-score mechanism
 
 ## Output Format
 
@@ -486,6 +505,7 @@ Known failure modes for this skill. Check these before declaring done.
 | [Design-It-Twice] Diversity score below 0.4 ignored | HIGH | Step 3.5 gate — re-spawn once; if still low, present with explicit "low-diversity" warning |
 | [Design-It-Twice] "It depends" recommendation | HIGH | Step 4 — must pick one with a hedge; if genuinely tied, propose hybrid (Step 4.5) and recommend that |
 | [Design-It-Twice] Forgetting to include CONTEXT.md domain terms in subagent prompt | MEDIUM | Step 2.5 spawn template requires domain glossary be passed through |
+| [Design-It-Twice] Reporting council output as consensus when decorrelation is NO_DECORRELATION | CRITICAL | Step 3.75 consume rule: report the decorrelation stamp plainly, never imply independent confirmation from same-family subagents |
 
 ## Done When
 
@@ -496,6 +516,7 @@ Known failure modes for this skill. Check these before declaring done.
 - Constraints for plan phase listed explicitly
 - Step 5 spec-presence gate evaluated — routed to `ba` (new feature, no spec, standalone) or `plan` (spec exists, or ba/cook was the caller, or no new behavior)
 - Next skill (`ba` or `plan`) called with the approved approach and constraints
+- (Design-It-Twice) If council's high-stakes trigger matched (Step 3.75): council invoked before Step 4, decorrelation stamp reported plainly, consensus/dissent folded into the recommendation alongside the diversity score
 
 ## Cost Profile
 

package/skills/brainstorm/references/design-it-twice.md

@@ -107,8 +107,9 @@ diversity = 1 - mean(similarity(d_i, d_j) for all i < j)
    - **Locality** — where change concentrates
    - **Seam placement** — internal vs external; ports yes/no
    - **Common-case trivial-ness** — how much work for the default path
-3. **Opinionated recommendation** — strongest design + concrete hedge condition for when to pick a different one
-4. **Hybrid synthesis (optional Step 4.5)** — if 2 designs have complementary strengths, propose a 4th synthesized option that combines them
+3. **Council check (SKILL.md Step 3.75)** — if the narrow high-stakes trigger fired, note `[council-verified]`/`[council-dissent]` tags inline in the comparison table or as a short addendum. If `decorrelation: NO_DECORRELATION`, say so plainly — never present it as a second opinion.
+4. **Opinionated recommendation** — strongest design + concrete hedge condition for when to pick a different one
+5. **Hybrid synthesis (optional Step 4.5)** — if 2 designs have complementary strengths, propose a 4th synthesized option that combines them
 
 Skip the comparison table if N=2 (just 1 contrast, prose handles it).
 
@@ -152,4 +153,6 @@ chain_metadata:
     constraints_used: [C1, C2, C4]
     recommendation: <design-id>
     hybrid_proposed: <true|false>
+    council_invoked: <true|false>
+    council_decorrelation: <MULTI_FAMILY|NO_DECORRELATION|null>
 ```

package/skills/cook/SKILL.md

@@ -5,7 +5,7 @@ context: fork
 agent: general-purpose
 metadata:
   author: runedev
-  version: "2.6.1"
+  version: "2.7.0"
   layer: L1
   model: sonnet
   group: orchestrator
@@ -379,6 +379,24 @@ If the coder model needs info from other phases, it's in the Cross-Phase Context
 
 **REQUIRED SUB-SKILL**: Use `rune:fix`
 
+### Reuse Ladder (climb before you write)
+
+Before writing the code for each task, climb this ladder and stop at the first rung that holds. Advisory, not a gate — it shapes *what* you write, never blocks the phase. Runs AFTER you understand the change (scout done, plan approved), never as a substitute for tracing the real flow.
+
+1. **Needs to exist at all?** Speculative need → skip it, say so in one line (YAGNI).
+2. **Already in this codebase?** A helper, util, type, or pattern that already lives here → reuse it. Re-implementing what sits a few files over is the most common slop — `Grep` before you write.
+3. **Stdlib does it?** Use it.
+4. **Native platform feature covers it?** DB constraint over app code, CSS over JS, `<input type="date">` over a picker lib.
+5. **Already-installed dependency solves it?** Use it. Never add a new dep for what a few lines cover.
+6. **One line?** Make it one line.
+7. **Only then** — the minimum code that makes the test pass.
+
+Two rungs work → take the higher one and move on. Mark a deliberate shortcut with a `// yagni:` comment naming its ceiling + upgrade path (`// yagni: global lock — per-account locks if throughput matters`) so the De-Sloppify Pass and later readers see intent, not ignorance.
+
+**Bug-fix corollary** — the lazy fix IS the root-cause fix: `Grep` every caller of the function you're about to touch, then fix the shared function once. One guard where all callers route through is a smaller diff than one guard per caller — and patching only the path the ticket names leaves every sibling caller still broken.
+
+**Never lazy about**: understanding the problem, input validation at trust boundaries, error handling that prevents data loss, security, accessibility, anything explicitly requested. The ladder shortens the solution, never the reading — a small diff you don't understand is a confident wrong fix, not laziness.
+
 1. Mark Phase 4 as `in_progress`
 2. **Phase-file execution** — if working from a master plan + phase file:
    - Execute tasks from `## Tasks` section wave-by-wave