voidforge-build 23.16.0 → 23.18.0

package/dist/.claude/agents/vin-analytics.md

@@ -3,6 +3,7 @@ name: Vin
 description: "Analytics and attribution specialist — Mistborn who sees through vanity metrics to real patterns"
 heralding: "A Mistborn lands on the rooftop. Vin burns tin — every metric becomes visible."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/vision-data-analysis.md

@@ -3,6 +3,7 @@ name: Vision
 description: "Data analysis specialist — data flow tracing, type inference, computational correctness"
 heralding: "Vision phases through the data layer. Every flow, every type, every transformation — visible."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/wanda-state.md

@@ -3,6 +3,7 @@ name: Wanda
 description: "State management specialist — complex transforms, data flow, state machines, reactive patterns"
 heralding: "Reality bends. Wanda reshapes complex state into something that makes sense."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/wax-paid-ads.md

@@ -3,6 +3,7 @@ name: Wax
 description: "Paid ads specialist — Allomantic Lawman where every dollar counts like a bullet"
 heralding: "The Lawman draws. Every ad dollar will hit its target."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/wayne-ab-testing.md

@@ -3,6 +3,7 @@ name: Wayne
 description: "A/B testing specialist — Master of Disguise who tries every variation"
 heralding: "Wayne shifts his disguise again. Every variation will be tested."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/whis-precision.md

@@ -3,6 +3,7 @@ name: Whis
 description: "Configuration tuning — performance tuning, config optimization, parameter precision, resource efficiency"
 heralding: "Whis adjusts the balance with divine calm. Your configuration will be tuned to perfection."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/windu-input-validation.md

@@ -3,6 +3,7 @@ name: Windu
 description: "Input validation enforcer — injection prevention, schema validation, sanitization at every boundary"
 heralding: "Windu ignites the purple blade. Every malicious input will be deflected at the boundary."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/winry-maintenance.md

@@ -3,6 +3,7 @@ name: Winry
 description: "System repair — broken configurations, degraded services, mechanical fixes, infrastructure healing"
 heralding: "Winry picks up her wrench. Your broken infrastructure is getting a proper repair."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/wonder-woman-truth.md

@@ -3,6 +3,7 @@ name: Wonder Woman
 description: "Truth specialist — cuts through deceptive code, misleading names, hidden assumptions"
 heralding: "The Lasso of Truth wraps around your code. Deceptive naming and hidden assumptions are exposed."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/worf-security-arch.md

@@ -3,6 +3,7 @@ name: Worf
 description: "Security architecture: defensive design, threat modeling, protocol enforcement, attack surface analysis"
 heralding: "Today is a good day to secure your architecture. Worf takes the tactical station."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/yoda-auth.md

@@ -3,6 +3,7 @@ name: Yoda
 description: "Authentication security master — session management, token lifecycle, auth bypass detection"
 heralding: "Strong in authentication, this one must be. Yoda tests your sessions, he will."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/yueh-trust-verify.md

@@ -3,6 +3,7 @@ name: Yueh
 description: "Trust verification auditor — integrity checking and betrayal detection in system dependencies"
 heralding: "The conditioning holds — or does it? Yueh verifies trust where betrayal hides."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/zatanna-impossible.md

@@ -3,6 +3,7 @@ name: Zatanna
 description: "Impossible bug specialist — makes hidden bugs appear, magical edge cases, unexpected interactions"
 heralding: "Zatanna speaks backwards. The impossible bugs materialize before your eyes."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/agents/zechs-rival.md

@@ -3,6 +3,7 @@ name: Zechs
 description: "Rival perspective — adversarial architecture review, competitive analysis, weakness exploitation"
 heralding: "The Lightning Count challenges your architecture. A rival's perspective reveals weakness."
 model: sonnet
+effort: medium
 tools:
   - Read
   - Bash

package/dist/.claude/commands/assemble.md

@@ -67,6 +67,12 @@ Mandatory runtime verification BEFORE code review begins:
 
 **Gate:** All endpoints return expected status codes. No route collisions. No infinite render loops detected. Update assemble-state.
 
+## Workflow Execution — review phases (ADR-067)
+
+The **review-heavy fan-out phases** — Phase 3-5 (engage), 7-8 (sentinel), 12 (crossfire), 13 (council) — run as a **Dynamic Workflow** (`.claude/workflows/assemble-review.workflow.js`) over the mission's working diff, so the 15+-agent fan-out stays out of the lead's context (ADR-067; see `docs/methods/WORKFLOWS.md`). The **build/architecture/devops phases (1-2.5, 9) STAY prose orchestration** — they write code, are sequentially dependent, and need lead judgment + `--interactive` gates between them.
+
+Run the review workflow as **one workflow run per review pass** so an `--interactive` pause sits at the workflow boundary (workflows take no mid-run input). **Gate (ADR-064):** muster the Silver Surfer + `record-roster.sh` *before* invoking, then `Workflow({ scriptPath: '.claude/workflows/assemble-review.workflow.js', args: { diff, roster } })`. The lead applies fixes from the returned report, then re-runs to re-verify. The phase prose below is the canonical description; `--light`/`--solo` use the raw-Agent fallback (with a `bypass.sh`).
+
 ## Phase 3 — Review Round 1 (Full Roster — see Agent Deployment Manifest)
 **Fury:** "Picard's team — first pass. Find everything. Full roster deployed."
 

package/dist/.claude/commands/gauntlet.md

@@ -23,6 +23,18 @@ Opus scans `git diff --stat` and matches changed files against the `description`
 
 **Dispatch control:** `--light` skips dynamic dispatch (core only). `--solo` runs lead agent only.
 
+## Workflow Execution (default — ADR-067)
+
+The Gauntlet's 5-round skeleton runs as a **Dynamic Workflow** — `.claude/workflows/gauntlet.workflow.js` — so the 60–80 agents' intermediate findings live in script variables, not the lead's context (only the final synthesis returns). The rounds below define **what** each round does; the workflow **implements** them (discovery → JS dedupe → 3-lens REFUTE verify → crossfire → council). See `docs/methods/WORKFLOWS.md`.
+
+**Gate-compliant launch sequence (ADR-064 — the gate now covers the Workflow tool):**
+1. Run the **Silver Surfer** (Agent tool — self-launch always allowed) per the gate header above; announce the heralding.
+2. **Record the roster:** `[ -x scripts/surfer-gate/record-roster.sh ] && bash scripts/surfer-gate/record-roster.sh '<roster-json>' || true` — *before* invoking the workflow, or the gate blocks it.
+3. **Invoke the workflow:** `Workflow({ scriptPath: '.claude/workflows/gauntlet.workflow.js', args: { scope, roster: <Surfer roster>, } })`. The gate allows it (roster recorded); the workflow's internal `agent()` calls are that roster.
+4. **The lead applies fixes** from the returned report, then re-invokes the workflow to re-verify (workflows take no mid-run input — fix application + the Debate Protocol + severity re-rating stay lead/prose judgment).
+
+`--light`/`--solo` skip the workflow and use the raw-Agent path below as the fallback (set a `bypass.sh --light`/`--solo` so the gate permits the reduced run). The prose rounds below remain the canonical description of each round.
+
 ## Round 1 — Discovery (parallel)
 
 **Thanos:** "Before I test, I must understand."

package/dist/.claude/workflows/assemble-review.workflow.js

@@ -0,0 +1,117 @@
+// assemble-review.workflow.js — the REVIEW-heavy phases of /assemble, re-platformed.
+//
+// /assemble's build/architecture/devops phases STAY prose orchestration (they write
+// code, are sequentially dependent, and need lead judgment + --interactive gates
+// between them). Only the read-heavy fan-out phases move here (ADR-067): the 3x code
+// review (engage), 2x security (sentinel), crossfire, and council — run over a single
+// mission's working diff. Run this as ONE workflow per review pass so an --interactive
+// pause sits at the workflow boundary, not mid-run (workflows take no mid-run input).
+//
+// GATE (ADR-064): muster the Surfer + record-roster BEFORE invoking (see assemble.md).
+// Invoke: Workflow({ scriptPath: '.claude/workflows/assemble-review.workflow.js',
+//                    args: { diff, roster: [{id,name,key,lens}] } })
+
+export const meta = {
+  name: 'assemble-review',
+  description: 'Per-mission review fan-out: engage (code) + sentinel (security) → 3-lens verify → crossfire → council, over the working diff',
+  phases: [
+    { title: 'Review', detail: 'engage + sentinel lenses over the diff' },
+    { title: 'Verify', detail: '3-lens adversarial REFUTE on each claim' },
+    { title: 'Crossfire', detail: 'adversaries hunt NEW issues in the diff' },
+    { title: 'Council', detail: 'synthesize survivors by severity' },
+  ],
+}
+
+const input = typeof args === 'string' ? JSON.parse(args) : (args || {})
+const diff = input.diff || 'the working-tree diff for this mission (git diff)'
+const roster = Array.isArray(input.roster) && input.roster.length
+  ? input.roster
+  : [
+      { id: 'picard-architecture', name: 'Picard', key: 'arch', lens: 'architecture & pattern compliance' },
+      { id: 'stark-backend', name: 'Stark', key: 'backend', lens: 'API/DB/service correctness' },
+      { id: 'galadriel-frontend', name: 'Galadriel', key: 'ux', lens: 'UX/a11y of changed surfaces' },
+      { id: 'kenobi-security', name: 'Kenobi', key: 'sec', lens: 'auth/injection/secrets/data' },
+      { id: 'maul', name: 'Maul', key: 'redteam', lens: 'red-team the new attack surface' },
+    ]
+
+const FINDINGS = {
+  type: 'object', additionalProperties: false,
+  required: ['agent', 'findings'],
+  properties: {
+    agent: { type: 'string' },
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['title', 'severity', 'file', 'evidence'],
+        properties: {
+          title: { type: 'string' },
+          severity: { type: 'string', enum: ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'WARN'] },
+          file: { type: 'string' },
+          evidence: { type: 'string', description: '≥1 quoted changed line or concrete repro' },
+        },
+      },
+    },
+  },
+}
+const VOTE = { type: 'object', additionalProperties: false, required: ['confirm', 'reason'], properties: { confirm: { type: 'boolean' }, reason: { type: 'string' } } }
+const key = (f) => `${(f.file || '').toLowerCase()}::${(f.title || '').toLowerCase().slice(0, 60)}`
+
+// ── Review: engage + sentinel lenses over the DIFF only ───────────────────────
+phase('Review')
+const reviews = (await parallel(roster.map((a) => () =>
+  agent(
+    `You are ${a.name}. Review ONLY ${diff} through the ${a.lens} lens (do not review unchanged code). Evidence-backed findings only — file:line + a quoted CHANGED line or a real repro. For any access/permission/contract finding, name the governing SSOT and reconcile the fix direction (field report #349).`,
+    { label: `${a.name} · review:${a.key}`, phase: 'Review', schema: FINDINGS, agentType: a.id },
+  )
+))).filter(Boolean)
+
+const seen = new Map()
+for (const r of reviews) for (const f of (r.findings || [])) { const k = key(f); if (!seen.has(k)) seen.set(k, f) }
+const claims = [...seen.values()]
+log(`Review: ${reviews.length} lenses → ${claims.length} distinct claims over the diff.`)
+
+// ── Verify: 3-lens adversarial REFUTE (default-to-refuted; verify the FIX too) ─
+phase('Verify')
+const LENSES = ['correctness', 'reachability', 'refutation']
+const verdicts = await parallel(claims.map((c) => () =>
+  parallel(LENSES.map((lens) => () =>
+    agent(
+      `Adversarially verify via the ${lens} lens, reproducing through the REAL execution path (not a library in isolation): "${c.title}" [${c.severity}] at ${c.file}. Evidence: ${c.evidence}. REFUTE unless you cannot. On the refutation lens, also confirm the implied fix adds no new failure mode (wedge/loop/orphan/double-send/TOCTOU).`,
+      { label: `verify:${lens}:${(c.file || '').slice(0, 24)}`, phase: 'Verify', schema: VOTE },
+    )
+  )).then((votes) => { const v = votes.filter(Boolean); return { claim: c, confirmVotes: v.filter((x) => x.confirm).length } })
+))
+const confirmed = verdicts.filter(Boolean).filter((v) => v.confirmVotes >= 2).map((v) => v.claim)
+log(`Verify: ${confirmed.length}/${claims.length} survived the 3-lens refute.`)
+
+// ── Crossfire: adversaries hunt NEW issues the review cleared ─────────────────
+phase('Crossfire')
+const confirmedKeys = new Set(confirmed.map(key))
+const crossRaw = (await parallel([
+  { id: 'deathstroke', name: 'Deathstroke', key: 'pentest' },
+  { id: 'loki', name: 'Loki', key: 'chaos' },
+].map((a) => () =>
+  agent(
+    `You are ${a.name}, crossfire adversary over ${diff}. The review already ran — find NEW issues it cleared (bypasses, edge/chaos cases). Evidence-backed only.`,
+    { label: `${a.name} · crossfire:${a.key}`, phase: 'Crossfire', schema: FINDINGS, agentType: a.id },
+  )
+))).filter(Boolean)
+const crossNew = []
+for (const r of crossRaw) for (const f of (r.findings || [])) if (!confirmedKeys.has(key(f))) crossNew.push(f)
+const crossConfirmed = (await parallel(crossNew.map((c) => () =>
+  agent(`Adversarially verify (default-to-refuted), real execution path: "${c.title}" [${c.severity}] at ${c.file}. ${c.evidence}`,
+    { label: `verify:crossfire:${(c.file || '').slice(0, 20)}`, phase: 'Crossfire', schema: VOTE })
+    .then((v) => (v && v.confirm ? c : null))
+))).filter(Boolean)
+log(`Crossfire: ${crossNew.length} new → ${crossConfirmed.length} confirmed.`)
+
+// ── Council: synthesize (JS); the lead applies fixes, then re-runs to re-verify ─
+phase('Council')
+const all = [...confirmed, ...crossConfirmed]
+const sev = (s) => all.filter((f) => f.severity === s)
+return {
+  diff,
+  counts: { claims: claims.length, confirmed: confirmed.length, crossfireConfirmed: crossConfirmed.length },
+  critical: sev('CRITICAL'), high: sev('HIGH'), medium: sev('MEDIUM'), low: [...sev('LOW'), ...sev('WARN')],
+}

package/dist/.claude/workflows/gauntlet.workflow.js

@@ -0,0 +1,176 @@
+// gauntlet.workflow.js — Thanos's Comprehensive Review as a Dynamic Workflow.
+//
+// Re-platforms /gauntlet's hand-fanned 60-80 agent rounds onto the Workflow tool
+// (ADR-067) so intermediate findings live in script variables, not the lead's
+// context. The lead's context only sees the final synthesis.
+//
+// GATE (ADR-064): the Workflow launch is gated. /gauntlet must muster the Silver
+// Surfer + record-roster BEFORE invoking this script (see gauntlet.md). The roster
+// is passed in via `args`; this script does NOT re-select it.
+//
+// What stays PROSE / lead judgment (NOT in this script): severity re-rating debate,
+// the Agent Debate Protocol, and the application of fixes. This script SCHEDULES the
+// find → dedupe → 3-lens-verify → crossfire → council skeleton and returns confirmed
+// findings; the lead applies fixes between runs (workflows take no mid-run input).
+//
+// Invoke: Workflow({ scriptPath: '.claude/workflows/gauntlet.workflow.js',
+//                     args: { scope, roster: [{id,name,key,domain}], rounds } })
+
+export const meta = {
+  name: 'gauntlet',
+  description: 'Comprehensive review: discovery → strike → 3-lens adversarial verify → crossfire → council (schema-validated)',
+  phases: [
+    { title: 'Discovery', detail: 'core domain leads map the surface' },
+    { title: 'Strike', detail: 'Surfer-selected specialists fan out' },
+    { title: 'Verify', detail: '3-lens adversarial REFUTE on every distinct claim' },
+    { title: 'Crossfire', detail: 'adversaries hunt NEW issues' },
+    { title: 'Council', detail: 'synthesize survivors by severity' },
+  ],
+}
+
+const input = typeof args === 'string' ? JSON.parse(args) : (args || {})
+const scope = input.scope || 'the working tree / full codebase per gauntlet.md'
+// Surfer-selected specialists (gate-recorded upstream). Fall back to the canonical
+// core leads if no roster was passed (e.g. --light).
+const roster = Array.isArray(input.roster) && input.roster.length
+  ? input.roster
+  : [
+      { id: 'picard-architecture', name: 'Picard', key: 'architecture', domain: 'architecture' },
+      { id: 'stark-backend', name: 'Stark', key: 'backend', domain: 'code/backend' },
+      { id: 'galadriel-frontend', name: 'Galadriel', key: 'ux', domain: 'UX/a11y' },
+      { id: 'kenobi-security', name: 'Kenobi', key: 'security', domain: 'security' },
+      { id: 'kusanagi-devops', name: 'Kusanagi', key: 'devops', domain: 'infra/deploy' },
+    ]
+
+const FINDINGS = {
+  type: 'object', additionalProperties: false,
+  required: ['agent', 'findings'],
+  properties: {
+    agent: { type: 'string' },
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['title', 'severity', 'file', 'evidence'],
+        properties: {
+          title: { type: 'string' },
+          severity: { type: 'string', enum: ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'WARN'] },
+          file: { type: 'string', description: 'path:line, or "n/a"' },
+          evidence: { type: 'string', description: '≥1 quoted code line or a concrete repro; no vibes' },
+        },
+      },
+    },
+  },
+}
+
+const VERDICT = {
+  type: 'object', additionalProperties: false,
+  required: ['survives', 'confirmVotes', 'finalSeverity', 'rationale'],
+  properties: {
+    survives: { type: 'boolean', description: 'true only if ≥2 of the 3 lenses confirm AND the fix would not introduce a new failure mode' },
+    confirmVotes: { type: 'integer', description: '0-3' },
+    finalSeverity: { type: 'string', enum: ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'WARN', 'REFUTED'] },
+    rationale: { type: 'string' },
+  },
+}
+
+const key = (f) => `${(f.file || '').toLowerCase()}::${(f.title || '').toLowerCase().slice(0, 60)}`
+
+// ── Round 1: Discovery + Round 2/3: Strike ────────────────────────────────────
+phase('Discovery')
+const discovery = (await parallel(roster.slice(0, 5).map((a) => () =>
+  agent(
+    `You are ${a.name} (${a.domain}). GAUNTLET discovery pass over ${scope}. Map your domain and report concrete, evidence-backed findings only — every finding needs a file:line and a quoted line or a real repro (no speculation). Rate severity honestly.`,
+    { label: `${a.name} · discovery:${a.key}`, phase: 'Discovery', schema: FINDINGS, agentType: a.id },
+  )
+))).filter(Boolean)
+
+phase('Strike')
+const strikeRoster = roster.length > 5 ? roster.slice(5) : roster
+const strike = (await parallel(strikeRoster.map((a) => () =>
+  agent(
+    `You are ${a.name} (${a.domain}). GAUNTLET strike pass over ${scope}. Deep, adversarial domain review — find what discovery missed. Evidence-backed findings only (file:line + quoted line/repro).`,
+    { label: `${a.name} · strike:${a.key}`, phase: 'Strike', schema: FINDINGS, agentType: a.id },
+  )
+))).filter(Boolean)
+
+// ── Dedupe across all domains (plain JS — no agent) ───────────────────────────
+const seen = new Map()
+for (const r of [...discovery, ...strike]) {
+  for (const f of (r.findings || [])) {
+    const k = key(f)
+    if (!seen.has(k)) seen.set(k, { ...f, raisedBy: [r.agent] })
+    else seen.get(k).raisedBy.push(r.agent)
+  }
+}
+const claims = [...seen.values()]
+log(`Discovery+Strike: ${discovery.length + strike.length} agents → ${claims.length} distinct claims (deduped).`)
+
+// ── Step 4.5: 3-lens adversarial REFUTE on every distinct claim ───────────────
+// Default-to-refuted. Keep only claims ≥2/3 lenses confirm AND whose fix adds no
+// new failure mode. (Verify-the-FIX, field report #348 #4.)
+phase('Verify')
+const LENSES = ['correctness', 'reachability', 'refutation']
+const verified = await parallel(claims.map((c) => () =>
+  parallel(LENSES.map((lens) => () =>
+    agent(
+      `Adversarially verify this GAUNTLET claim through the ${lens} lens. Claim: "${c.title}" [${c.severity}] at ${c.file}. Evidence: ${c.evidence}. Your job is to REFUTE it — confirm ONLY if you cannot, citing the exact code. For the refutation lens, also check the implied FIX introduces no new failure mode (wedge/loop/orphan/double-send/TOCTOU). Reproduce through the REAL execution path, not a library in isolation (ADR/field report #356).`,
+      { label: `verify:${lens}:${(c.file || '').slice(0, 24)}`, phase: 'Verify', schema: { type: 'object', additionalProperties: false, required: ['confirm', 'reason'], properties: { confirm: { type: 'boolean' }, reason: { type: 'string' } } } },
+    )
+  )).then((votes) => {
+    const v = votes.filter(Boolean)
+    const confirmVotes = v.filter((x) => x.confirm).length
+    return { claim: c, survives: confirmVotes >= 2, confirmVotes, lensReasons: v.map((x) => x.reason) }
+  })
+))
+const confirmed = verified.filter(Boolean).filter((v) => v.survives).map((v) => ({ ...v.claim, confirmVotes: v.confirmVotes }))
+const refuted = verified.filter(Boolean).filter((v) => !v.survives).map((v) => ({ title: v.claim.title, confirmVotes: v.confirmVotes, why: v.lensReasons }))
+log(`Verify: ${confirmed.length} survived 3-lens refute, ${refuted.length} refuted (logged, dropped).`)
+
+// ── Round 4: Crossfire — adversaries hunt NEW issues the review cleared ────────
+phase('Crossfire')
+const ADVERSARIES = [
+  { id: 'maul', name: 'Maul', key: 'red-team' },
+  { id: 'deathstroke', name: 'Deathstroke', key: 'pentest' },
+  { id: 'loki', name: 'Loki', key: 'chaos' },
+]
+const crossfireRaw = (await parallel(ADVERSARIES.map((a) => () =>
+  agent(
+    `You are ${a.name}, a GAUNTLET crossfire adversary over ${scope}. The domain review already ran — hunt NEW issues it cleared (bypasses, chaos/edge cases, exploit chains). Evidence-backed only (file:line + repro).`,
+    { label: `${a.name} · crossfire:${a.key}`, phase: 'Crossfire', schema: FINDINGS, agentType: a.id },
+  )
+))).filter(Boolean)
+// New crossfire claims (not already confirmed) get the same one-pass refute.
+const confirmedKeys = new Set(confirmed.map(key))
+const crossNew = []
+for (const r of crossfireRaw) for (const f of (r.findings || [])) if (!confirmedKeys.has(key(f))) crossNew.push(f)
+const crossVerified = await parallel(crossNew.map((c) => () =>
+  agent(
+    `Adversarially verify (default-to-refuted) this crossfire claim, reproducing through the real execution path: "${c.title}" [${c.severity}] at ${c.file}. Evidence: ${c.evidence}.`,
+    { label: `verify:crossfire:${(c.file || '').slice(0, 24)}`, phase: 'Crossfire', schema: VERDICT },
+  ).then((v) => (v && v.survives ? { ...c, finalSeverity: v.finalSeverity } : null))
+))
+const crossfireConfirmed = crossVerified.filter(Boolean)
+log(`Crossfire: ${crossNew.length} new claims → ${crossfireConfirmed.length} confirmed.`)
+
+// ── Round 5: Council — synthesize survivors by severity (JS; lead applies fixes) ─
+phase('Council')
+const all = [...confirmed, ...crossfireConfirmed]
+const bySeverity = (sev) => all.filter((f) => (f.finalSeverity || f.severity) === sev)
+const report = {
+  scope,
+  rosterSize: roster.length,
+  counts: {
+    distinctClaims: claims.length,
+    confirmed: confirmed.length,
+    refuted: refuted.length,
+    crossfireConfirmed: crossfireConfirmed.length,
+  },
+  critical: bySeverity('CRITICAL'),
+  high: bySeverity('HIGH'),
+  medium: bySeverity('MEDIUM'),
+  low: [...bySeverity('LOW'), ...bySeverity('WARN')],
+  refutedLog: refuted, // dropped, but never silently — logged per SUB_AGENTS.md
+}
+log(`Council: ${report.critical.length} Critical · ${report.high.length} High · ${report.medium.length} Medium · ${report.low.length} Low/Warn. Lead applies fixes (workflow takes no mid-run input), then re-runs to re-verify.`)
+return report

package/dist/CHANGELOG.md

@@ -6,6 +6,51 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 
 ---
 
+## [23.18.0] - 2026-06-13
+
+### Workflow re-platform of `/gauntlet` + `/assemble` (ADR-067)
+
+The opportunity ADR-064 unblocked. The heavy review commands' deterministic skeletons now run as Dynamic Workflows, so 60–80 agents' intermediate findings live in script variables instead of the lead's context.
+
+### Added
+
+- **`.claude/workflows/gauntlet.workflow.js`** — the 5-round Gauntlet as a workflow: discovery (parallel core leads) → **plain-JS dedupe** → **3-lens adversarial REFUTE** per claim (schema-validated votes, default-to-refuted, keep ≥2/3, verify-the-FIX, reproduce-through-real-path) → crossfire (adversaries hunt NEW issues) → council (JS synthesis by severity). Refuted claims logged, never silently dropped.
+- **`.claude/workflows/assemble-review.workflow.js`** — the review-heavy `/assemble` phases (engage + sentinel + crossfire + council) over a mission's working diff; one run per pass so `--interactive` pauses at the boundary. Build/architecture/devops phases **stay prose orchestration**.
+- **`docs/methods/WORKFLOWS.md`** — the authoring standard: when-to-use, API (`phase`/`parallel`/`pipeline`/`agent({schema})`), the `args`-as-JSON-string (#363) + label-leading-character (#348) gotchas, the 16/1000 caps (ADR-059), and the **ADR-064 gate-launch sequence** (Surfer → record-roster → Workflow). Added to the CLAUDE.md Docs Reference.
+- **ADR-067** decision record.
+
+### Changed
+
+- **`gauntlet.md` / `assemble.md`** gain "Workflow Execution" sections: the gate-compliant launch (muster Surfer → record roster → invoke the workflow with the roster in `args`), what's workflow-backed vs prose, and the `--light`/`--solo` raw-Agent fallback. Personas, the Agent Debate Protocol, severity re-rating, and **fix application** stay lead/prose judgment (the lead applies fixes from the returned report, then re-runs to re-verify).
+- **Distribution (Phase 12.75 gate):** `.claude/workflows/` is a new shared file category — added to `prepack.sh` (npm package) and `copy-assets.sh` (CLI `init`) so the scripts reach consumers (they were referenced by the command docs but would not have shipped otherwise — the #297 class).
+
+### Validation
+
+Both workflow scripts pass `node --check` (ESM, async-wrapped to match the Workflow runtime). The **live end-to-end gauntlet run is the acceptance test** (it launches 30+ real review agents through the now-gated Workflow path); the raw-Agent prose path remains the fallback and canonical description. Dogfooded pre-tag `npm test` (1390/1390) + publish-gate. Dep range `^23.17.0` → `^23.18.0` (ADR-062).
+
+---
+
+## [23.17.0] - 2026-06-13
+
+### Effort-tiering fleet edit (ADR-054) — verified + applied
+
+Closes the M2 deferral from v23.16.0.
+
+### Verified
+
+- Confirmed against the **official Claude Code sub-agents docs** that `effort` is a supported sub-agent frontmatter field — values `low`/`medium`/`high`/`xhigh`/`max`, "available levels depend on the model" (so Haiku is omitted). It is a recognized key (the docs enumerate the full frontmatter set including `effort`), so adding it cannot break agent loading — the safety concern that justified deferring the fleet edit.
+
+### Changed
+
+- **All 264 agent definitions** now carry an `effort` tier (frontmatter-only, inserted after `model:`): **20 leads (`model: inherit`) → `effort: xhigh`**, **201 Sonnet specialists → `effort: medium`**, **43 Haiku scouts → omitted**. This is a per-agent reasoning-spend lever independent of model tier — the largest cost lever in the fleet, since ~200 read-and-report specialists no longer run at lead-level reasoning. Idempotent insert; `validate-agent-refs` + full suite **1390/1390** green; frontmatter integrity preserved. (Agent files ship in the methodology package via prepack, so the tiers reach consumers automatically.)
+- Updated **ADR-054** (status → fleet-applied + verification record), **SUB_AGENTS.md** Model Tiering, **COMPATIBILITY.md** effort row (verify-pending → applied).
+
+### Pipeline
+
+Dogfooded pre-tag `npm test` + publish-gate alignment. Notably the v23.16.0 gate fix was confirmed **live in production this session** — a Workflow launch was correctly BLOCKED until a documented `--light` bypass was set (a reap-vs-fresh-bypass timing race was observed and noted for a future field report). Dep range `^23.16.0` → `^23.17.0` (ADR-062).
+
+---
+
 ## [23.16.0] - 2026-06-13
 
 ### Platform-alignment campaign — ADR-064/065/066 implemented (+ ADR-050/051/054 amended)

package/dist/CLAUDE.md

@@ -256,6 +256,7 @@ See `/docs/methods/MUSTER.md` for the full Muster Protocol.
 | **Time Vault** | `/docs/methods/TIME_VAULT.md` | Seldon — when preserving session intelligence for transfer |
 | **Patterns** | `/docs/patterns/` | When writing code (37 reference implementations) |
 | **Lessons** | `/docs/LESSONS.md` | Cross-project learnings |
+| **Workflows** | `/docs/methods/WORKFLOWS.md` | Dynamic Workflow authoring standard (ADR-067) — when to use, API, gotchas, the ADR-064 gate-launch sequence |
 | **Native Capabilities** | `/docs/NATIVE_CAPABILITIES.md` | Command × native-skill collision tracker (ADR-066) — re-audit each release |
 | **Compatibility** | `/docs/COMPATIBILITY.md` | Node + Claude Code platform floor & feature maturity tags (ADR-065) |
 

package/dist/VERSION.md

@@ -1,6 +1,6 @@
 # Version
 
-**Current:** 23.16.0
+**Current:** 23.18.0
 
 ## Versioning Scheme
 
@@ -14,6 +14,8 @@ This project uses [Semantic Versioning](https://semver.org/):
 
 | Version | Date | Summary |
 |---------|------|---------|
+| 23.18.0 | 2026-06-13 | **Workflow re-platform of `/gauntlet` + `/assemble` (ADR-067)** — the opportunity ADR-064 unblocked. New `.claude/workflows/gauntlet.workflow.js` (discovery → JS dedupe → 3-lens adversarial REFUTE → crossfire → council, schema-validated) and `assemble-review.workflow.js` (engage+sentinel over a mission diff; build/arch/devops stay prose). New **`docs/methods/WORKFLOWS.md`** authoring standard (API, the #348/#363 gotchas, 16/1000 caps, and the ADR-064 gate-launch sequence: Surfer→record-roster→Workflow). `gauntlet.md`/`assemble.md` gain workflow-execution sections; personas + fix-application + Debate Protocol stay prose. **Distribution gate (Phase 12.75):** `.claude/workflows/` is a new shared category — added to `prepack.sh` (npm) + `copy-assets.sh` (init) so the scripts ship to consumers. Both scripts `node --check`-validated (ESM async-wrapped); the live end-to-end gauntlet run is the acceptance test. Dep `^23.17.0` → `^23.18.0`. |
+| 23.17.0 | 2026-06-13 | **Effort-tiering fleet edit (ADR-054) — verified + applied.** Verified against the official Claude Code sub-agents docs that `effort` is a supported sub-agent frontmatter field (values `low`/`medium`/`high`/`xhigh`/`max`; "available levels depend on the model"). Applied across all 264 agent definitions: **20 leads (`model: inherit`) → `effort: xhigh`, 201 Sonnet specialists → `effort: medium`, 43 Haiku scouts → omitted** (Haiku doesn't support the parameter). Per-agent reasoning-spend lever, independent of model tier — the largest cost lever in the fleet (200 specialists no longer pay lead-level reasoning for read-and-report review). Frontmatter-only, idempotent insert after the `model:` line; `validate-agent-refs` + full suite (1390/1390) green; integrity preserved. Closes the M2 deferral from v23.16.0. Updated ADR-054 (status→fleet-applied), SUB_AGENTS.md, COMPATIBILITY.md. Dep `^23.16.0` → `^23.17.0`. (Aside: confirmed the v23.16.0 gate fix live — a Workflow launch was correctly BLOCKED this session until a `--light` bypass was set; noted a reap-vs-fresh-bypass timing race for a future field report.) |
 | 23.16.0 | 2026-06-13 | Platform-alignment campaign — implements the ADR set from `/architect --plan` (→ `/campaign`). **ADR-064 (gate↔Workflow) IMPLEMENTED:** the Silver Surfer `PreToolUse` hook matcher is now `Agent\|Workflow` and `check.sh` gates the **Workflow tool launch** on a recorded roster (closes the proven bypass where workflow-spawned agents skipped the gate); `test.sh` gains 3 Workflow cases (**23/23**), mirrored to the methodology package. **Behavior change:** a Workflow run now requires a recorded roster or a `--light`/`--solo` bypass — build/apply/research workflows should set a bypass. **ADR-065 (platform floor):** `docs/COMPATIBILITY.md` gains a Claude Code platform-floor + per-feature maturity table; informational `claudeCodeFloor` field; semver rule (raising the floor = breaking) + release-checklist item. **ADR-066 (native-capability tracker):** new `docs/NATIVE_CAPABILITIES.md` audits all commands vs native skills with dispositions (`/qa`,`/test` coexist+document; `/git` keep) — realizes ADR-050's deferred follow-up; release re-audit item added. Amended **ADR-051** (workflow-exemption→closure), **ADR-054** (effort tiers + Haiku 200K/no-effort). M2 effort fleet-edit deferred per ADR-054 precondition (runtime `effort:`-frontmatter honoring unverified). Dep `^23.15.0` → `^23.16.0`. |
 | 23.15.0 | 2026-06-13 | Platform-alignment build (`/architect --plan` → `/build` b+a). **P0:** empirically confirmed the Silver Surfer `PreToolUse` gate is **blind to Workflow-tool-spawned agents** (this session: 60+ workflow agents → 2 gate events; controlled probe BEFORE=2/AFTER=2) and wrote **ADR-064** (gate↔Workflow interop — extend matcher to `Agent\|Workflow`, gate the workflow launch; implementation tracked for the campaign). **P1-B near-free batch:** fixed a **live runtime bug** — `anthropic.ts` fell back to the non-existent `claude-sonnet-4-7` (404 on the exact degraded path the fallback exists for) → `claude-sonnet-4-6`, plus the bug-asserting test (now 6/6) and 4 docs; purged stale model IDs (`claude-sonnet-4-20250514`→`claude-sonnet-4-6` in 6 pattern files; `Opus 4.7`→`4.8` across SUB_AGENTS + 4 ADRs); added the **effort-tiering policy** (leads `xhigh` / specialists `medium` / Haiku omit-no-effort+200K ceiling) to SUB_AGENTS.md + CLAUDE.md flag-taxonomy mapping; **amended ADR-059** with the real platform caps (~16 concurrent / ~1,000 per run) and fixed GAUNTLET.md's contradicting "waves of 3". Dogfooded the pre-tag `npm test` gate (ADR from v23.13.1) + the publish-gate alignment (v23.14.0). Dep `^23.14.0` → `^23.15.0`. Follow-on (operator-directed): `/architect --plan` ADR-065/066 + amend ADR-051/054 → `/campaign` to build all. |
 | 23.14.0 | 2026-06-12 | Field Report Triage — 2 reports closed (#362, #363) via `/debrief --inbox`, 8 fixes across 9 files. **#363** (self-filed last session): release flow now runs the test suite as Step 5's first action before any tag (`git.md`, since tag-push arms an irreversible publish); **Numeric constant migration checklist** generalizing the error-shape rule (`TESTING.md`); **Registry-Derived Fan-Out** coverage rule — enumerate the accepted `(fixId,targetFile)` tuple set, diff-check after appliers (`SUB_AGENTS.md` + `debrief.md` Step 6); **Chronically-Red Check Policy** (red ≥2 releases → fix/informational/remove) + **Publish-gate alignment** (publish must `needs:` the full E2E+a11y suite, not unit-only) (`DEVOPS_ENGINEER.md` + `RELEASE_MANAGER.md`); Workflow `args`-as-JSON-string defensive parse + `gh workflow` scope note (`SUB_AGENTS.md` + `RELEASE_MANAGER.md`). **#362** (enhancements): a named, right-sized **Pre-Deploy Review Gate** (diff-scoped N lenses + mandatory adversarial-verify) documented in `SUB_AGENTS.md` and realized as a new `/engage --pre-deploy --diff` mode; atomic-visual **render-harness screenshot carve-out** (`QA_ENGINEER.md` + `PRODUCT_DESIGN_FRONTEND.md`). Dogfooded #363 in its own release: ran the coverage diff-check (9/9 files) and `npm test` (1390/1390) before tagging. Dep `^23.13.1` → `^23.14.0` (ADR-062). |

package/dist/docs/methods/SUB_AGENTS.md

@@ -276,7 +276,7 @@ Each file is a standalone subagent definition that Claude Code's native subagent
 
 Leads inherit the main session's model (Opus). Specialists run on Sonnet for cost efficiency without sacrificing analysis quality. Scouts run on Haiku for fast, cheap reconnaissance.
 
-**Effort tiering (per-agent spend lever).** Claude Code exposes an `effort:` level (`low`/`medium`/`high`/`xhigh`/`max`) that controls reasoning depth *independently* of the model tier. Apply by role: **Leads → `xhigh`** (the recommended start for agentic work on Opus 4.8); **Specialists → `medium`** (read-and-report review rarely needs full `high` spend across ~200 agents); **Scouts → OMIT** — **Haiku 4.5 does not support the effort parameter and errors if it is passed.** Haiku also has a **200K context ceiling (not 1M)**: the Surfer pre-scan and scout prompts must fit within it — read agent frontmatter (name/description/tags), not full bodies, on large rosters. Verify the runtime honors agent-frontmatter `effort:` before a fleet edit; the tier *policy* stands regardless. (Platform research 2026-06; the ADR-054 amendment + the 264-file fleet edit are tracked as a campaign mission.)
+**Effort tiering (per-agent spend lever).** Claude Code exposes an `effort:` level (`low`/`medium`/`high`/`xhigh`/`max`) that controls reasoning depth *independently* of the model tier. Apply by role: **Leads → `xhigh`** (the recommended start for agentic work on Opus 4.8); **Specialists → `medium`** (read-and-report review rarely needs full `high` spend across ~200 agents); **Scouts → OMIT** — **Haiku 4.5 does not support the effort parameter and errors if it is passed.** Haiku also has a **200K context ceiling (not 1M)**: the Surfer pre-scan and scout prompts must fit within it — read agent frontmatter (name/description/tags), not full bodies, on large rosters. **Verified + applied 2026-06-13:** the official sub-agents docs confirm `effort` is a supported frontmatter field; the fleet edit is live — all 20 leads carry `effort: xhigh`, all 201 Sonnet specialists `effort: medium`, the 43 Haiku scouts omit it (ADR-054). New agents should follow the same tiering.
 
 ### Tool Restrictions