@nforma.ai/nforma 0.2.1

package/agents/qgsd-quorum-orchestrator.md

@@ -0,0 +1,628 @@
+<!-- DEPRECATED: This agent is superseded by direct inline dispatch in commands/qgsd/quorum.md as of quick-103. The orchestrator Task-spawn indirection is no longer needed — quorum.md now contains the full R3 protocol inline (with qgsd-quorum-slot-worker for per-slot dispatch). Retained for reference only. Do not spawn this agent. -->
+---
+name: qgsd-quorum-orchestrator
+description: >
+  DEPRECATED — do not spawn. Superseded by direct inline dispatch in
+  commands/qgsd/quorum.md as of quick-103. Retained for reference only.
+tools: Read, Write, Bash, Task, Glob, Grep
+color: purple
+---
+
+<role>
+You are the QGSD quorum orchestrator. When invoked, execute the full R3 quorum protocol
+for the question or bundle passed in `$ARGUMENTS`.
+
+**SEQUENTIAL CALLS ONLY — NO SIBLING TOOL CALLS.**
+Every model call and every Bash call MUST be issued as a separate, standalone message
+turn — never batched or co-submitted as sibling calls. One call → wait → proceed.
+
+**Exception — parallel worker wave:** When dispatching a quorum worker round, ALL worker
+Task spawns for that round ARE issued as sibling calls in one message turn (one Task per
+active slot). This is the only case where sibling tool calls are permitted. All Bash calls
+(including set-availability, merge-wave, and scoreboard updates) remain sequential.
+
+**Two modes** — detect automatically from `$ARGUMENTS`:
+
+- **Mode A — Pure Question**: The input is a question or decision prompt. No execution required.
+- **Mode B — Execution + Trace Review**: The input explicitly requires running a command before a verdict. Triggers when `$ARGUMENTS` contains phrases like "run [command] and tell me if...", "does this pass", "review the output of...", "verify that [thing] works".
+
+**Default: Mode A.**
+
+**Important:** All quorum model calls go through `call-quorum-slot.cjs` via Bash — NOT via
+MCP tool calls. MCP tools are not available in sub-agent sessions. Use the bash pattern in
+the slot worker.
+</role>
+
+---
+
+### Pre-step — Parse $ARGUMENTS extras
+
+Before Step 1, extract optional fields from `$ARGUMENTS` and capture working directory context.
+
+**artifact_path** — scan `$ARGUMENTS` text for a line matching `artifact_path: <value>`.
+
+- If found: use the **Read tool** to read that file path. Store the result as `$ARTIFACT_PATH` (the path string) and `$ARTIFACT_LINE_COUNT` (approximate line count of the file). Do NOT embed the raw contents in worker prompts — workers will read the file themselves using their own Read tool.
+- If not found or Read fails: set `$ARTIFACT_PATH` to empty string and `$ARTIFACT_LINE_COUNT` to 0. No error — artifact injection is optional.
+
+**cwd** — run `Bash(pwd)` and store the result as `$REPO_DIR`.
+
+These two variables (`$ARTIFACT_PATH`, `$REPO_DIR`) are available to all subsequent steps.
+
+---
+
+### Step 1 — Provider pre-flight
+
+Run before any model calls:
+
+```bash
+node "$HOME/.claude/qgsd-bin/check-provider-health.cjs" --json
+```
+
+Parse the JSON output. Build:
+
+1. **`$PROVIDER_STATUS`**: `{ providerName: healthy }` — provider name to up/down.
+2. **`$CLAUDE_MCP_SERVERS`**: flat list of `{ serverName, model, providerName, available }`.
+   A server's `available` is `false` if its provider's `healthy` is `false`.
+
+Any server with `available: false` → mark UNAVAIL immediately — skip inference calls entirely.
+
+3. **`$QUORUM_ACTIVE`**: read from `~/.claude/qgsd.json` (project config takes precedence):
+```bash
+node -e "
+const fs = require('fs'), os = require('os'), path = require('path');
+const globalCfg = path.join(os.homedir(), '.claude', 'qgsd.json');
+const projCfg   = path.join(process.cwd(), '.claude', 'qgsd.json');
+let cfg = {};
+for (const f of [globalCfg, projCfg]) {
+  try { Object.assign(cfg, JSON.parse(fs.readFileSync(f, 'utf8'))); } catch(_){}
+}
+console.log(JSON.stringify(cfg.quorum_active || []));
+"
+```
+If `$QUORUM_ACTIVE` is empty (`[]`), all entries in `$CLAUDE_MCP_SERVERS` participate.
+If non-empty, intersect: only servers whose `serverName` appears in `$QUORUM_ACTIVE` are called.
+A server in `$QUORUM_ACTIVE` but absent from `$CLAUDE_MCP_SERVERS` = skip silently (fail-open).
+
+**Pre-flight slot skip:** After building `$CLAUDE_MCP_SERVERS`, immediately filter:
+- For each server with `available: false`, log: `Pre-flight skip: <serverName> (<providerName> DOWN)`
+- Remove these from the working list for all subsequent steps.
+
+Read `preferSub` and `agent_config` from qgsd.json (project config takes precedence):
+```bash
+node -e "
+const fs = require('fs'), os = require('os'), path = require('path');
+const globalCfg = path.join(os.homedir(), '.claude', 'qgsd.json');
+const projCfg   = path.join(process.cwd(), '.claude', 'qgsd.json');
+let cfg = {};
+for (const f of [globalCfg, projCfg]) {
+  try { Object.assign(cfg, JSON.parse(fs.readFileSync(f, 'utf8'))); } catch(_) {}
+}
+const preferSub  = cfg.quorum && cfg.quorum.preferSub === true;
+const agentCfg   = cfg.agent_config || {};
+console.log(JSON.stringify({ preferSub, agentCfg }));
+"
+```
+Store result as `$PREFER_SUB_CONFIG`.
+
+- **preferSub ordering:** If `$PREFER_SUB_CONFIG.preferSub` is true, read `agent_config` from the same config and sort the working slot list: slots with `auth_type=sub` first, then slots with `auth_type=api` (stable sort, preserving original order within each group). This ensures subscription CLI slots (codex-1, gemini-1, opencode-1, copilot-1) are always attempted before API slots regardless of providers.json discovery order.
+  - If `$PREFER_SUB_CONFIG.preferSub` is false or absent: skip this partition step.
+- **Shuffle within groups:** Shuffle the sub group and the api group independently. Final order when preferSub=true: shuffle(sub), shuffle(api). When preferSub=false: shuffle all slots.
+- Log: `Active slots: <slot1>, <slot2>, ...`
+
+**min_quorum_size check:** Read from `~/.claude/qgsd.json` (project config takes precedence; default: 3 if absent):
+```bash
+node -e "
+const fs = require('fs'), os = require('os'), path = require('path');
+const globalCfg = path.join(os.homedir(), '.claude', 'qgsd.json');
+const projCfg   = path.join(process.cwd(), '.claude', 'qgsd.json');
+let cfg = {};
+for (const f of [globalCfg, projCfg]) {
+  try { Object.assign(cfg, JSON.parse(fs.readFileSync(f, 'utf8'))); } catch(_){}
+}
+console.log(cfg.min_quorum_size ?? 3);
+"
+```
+Count available slots (those not marked UNAVAIL and passing $QUORUM_ACTIVE filter). Include Claude itself as +1.
+If `availableCount < min_quorum_size`:
+  - If $ARGUMENTS contains `--force-quorum`: log warning `[WARN] Quorum below min_quorum_size (N available, min M) — proceeding due to --force-quorum` and continue.
+  - Otherwise: stop with:
+    ```
+    QUORUM BLOCKED: Only N model(s) available (min_quorum_size = M).
+    Available: [list slots]
+    UNAVAIL:   [list skipped slots with reason]
+    Re-run with --force-quorum to override, or wait for providers to recover.
+    ```
+
+**Availability cache check:** After building the provider slot list but before the min_quorum_size check, read the scoreboard availability data:
+
+```bash
+node "$HOME/.claude/qgsd-bin/update-scoreboard.cjs" get-availability \
+  --scoreboard .planning/quorum-scoreboard.json 2>/dev/null || echo '{}'
+```
+
+Store result as `$AVAIL_CACHE` (a JSON object keyed by slot name or model family). For each entry where `is_available: false`:
+- Remove that slot from the working list
+- Mark it DORMANT (separate from provider-DOWN — this is quota/rate-limit state)
+- Log: `Dormant: <slot> (${reason} — available in <remaining_display>, at <available_at_local>)`
+
+If no availability data exists for a slot, it is assumed available (fail-open).
+
+Display (one line):
+```
+Provider pre-flight: <providerName>=✓/✗ ...  (<N> claude-mcp servers found)
+```
+
+If any slots are DORMANT, add a second line:
+```
+Dormant slots:       <slot1> (available in <remaining_display>), <slot2> (available in ...)
+```
+
+---
+
+### Step 2 — Team identity capture
+
+Capture the active team fingerprint (idempotent — run once per session).
+
+Build `TEAM_JSON` directly from `providers.json` and the available slot list — no model calls needed for identity:
+
+```bash
+node -e "
+const fs = require('fs'), path = require('path'), os = require('os');
+
+// Find providers.json
+const searchPaths = [
+  path.join(os.homedir(), '.claude', 'qgsd-bin', 'providers.json'),
+];
+try {
+  const cj = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.claude.json'), 'utf8'));
+  const u1args = cj?.mcpServers?.['unified-1']?.args ?? [];
+  const srv = u1args.find(a => typeof a === 'string' && a.endsWith('unified-mcp-server.mjs'));
+  if (srv) searchPaths.unshift(path.join(path.dirname(srv), 'providers.json'));
+} catch(_) {}
+
+let providers = [];
+for (const p of searchPaths) {
+  try { providers = JSON.parse(fs.readFileSync(p, 'utf8')).providers; break; } catch(_) {}
+}
+
+// Read quorum_active
+const globalCfg = path.join(os.homedir(), '.claude', 'qgsd.json');
+const projCfg   = path.join(process.cwd(), '.claude', 'qgsd.json');
+let cfg = {};
+for (const f of [globalCfg, projCfg]) {
+  try { Object.assign(cfg, JSON.parse(fs.readFileSync(f, 'utf8'))); } catch(_) {}
+}
+const active = cfg.quorum_active || [];
+
+const team = {};
+for (const p of providers) {
+  if (active.length > 0 && !active.includes(p.name)) continue;
+  team[p.name] = { model: p.model };
+}
+console.log(JSON.stringify(team));
+"
+```
+
+Detect Claude model ID: `CLAUDE_MODEL` env → `ANTHROPIC_MODEL` env → session model from context.
+
+```bash
+node "$HOME/.claude/qgsd-bin/update-scoreboard.cjs" init-team \
+  --claude-model "<claude_model_id>" \
+  --team '<TEAM_JSON>'
+```
+
+**Pre-resolve slot timeouts:** Build `$SLOT_TIMEOUTS` by reading `providers.json` using the same search paths as Step 1. For each slot in the active working list, record `quorum_timeout_ms` (fallback: 30000). Store as a map `{ slotName: timeoutMs }`. Workers receive their specific timeout in `timeout_ms:` — they do NOT read `providers.json` themselves.
+
+---
+
+## Mode A — Pure Question
+
+### Parse question
+
+The question is `$ARGUMENTS`. If empty or too short, stop with:
+`"No question provided. Pass question as: Task(subagent_type=qgsd-quorum-orchestrator, prompt='<question>')"`
+
+Display:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► QUORUM: Mode A — Pure Question
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Question: [question]
+```
+
+### Claude's position (state before Round 1)
+
+State own answer and reasoning before dispatching any worker:
+```
+Claude (Round 1): [answer + reasoning — 2–4 sentences]
+```
+Store as `$CLAUDE_POSITION`.
+
+### Round loop — up to 10 rounds with inline synthesis
+
+```
+$MAX_ROUNDS = 10
+$CURRENT_ROUND = 1
+$CROSS_POLL_BUNDLE = ""   (empty on Round 1, populated after each non-consensus round)
+$CONSENSUS_REACHED = false
+$ALL_ROUND_RESULTS = []   (accumulates results across all rounds for scoreboard)
+```
+
+**LOOP** while `$CURRENT_ROUND <= $MAX_ROUNDS` and not `$CONSENSUS_REACHED`:
+
+#### Round banner
+
+Display before dispatching each round:
+```
+─────────────────────────────────────────────
+ QGSD ► QUORUM Round $CURRENT_ROUND / up to $MAX_ROUNDS
+─────────────────────────────────────────────
+```
+
+#### Build `$DISPATCH_LIST` (quorum.md Adaptive Fan-Out: FAN_OUT_COUNT-1 external slots), then dispatch as SIBLING Task calls (one message turn)
+
+All workers for this round are dispatched as parallel sibling Task calls in one message turn:
+
+```
+Task(
+  subagent_type="qgsd-quorum-slot-worker",
+  description="<slotName> quorum R<$CURRENT_ROUND>",
+  prompt="""
+slot: <slotName>
+round: $CURRENT_ROUND
+timeout_ms: <$SLOT_TIMEOUTS[slotName]>
+repo_dir: <$REPO_DIR>
+mode: A
+question: <question text>
+[artifact_path: <$ARTIFACT_PATH>]
+[prior_positions: |
+  <$CROSS_POLL_BUNDLE>]   # Round 2+ only, omit on Round 1
+"""
+)
+```
+
+One Task per active slot — all sibling calls in same message turn.
+
+Collect all worker result blocks → store as `$ROUND_RESULTS`. Append to `$ALL_ROUND_RESULTS`.
+
+#### Process UNAVAIL results (sequential Bash calls)
+
+For each result where `verdict: UNAVAIL`:
+```bash
+node "$HOME/.claude/qgsd-bin/update-scoreboard.cjs" set-availability \
+  --slot <slot> \
+  --message "<unavail_message text>" \
+  --scoreboard .planning/quorum-scoreboard.json
+```
+Log: `[<slot>] UNAVAIL recorded`
+
+#### Tiered fallback dispatch (FALLBACK-01)
+
+After recording all UNAVAIL results, check if replacements are needed:
+
+Classification is determined by runtime `auth_type` from `providers.json` — **not** by slot name. Any slot can be `sub` or `api` depending on config. With `--n` large enough, all `auth_type=sub` slots may be primary, making T1 empty.
+
+1. **T1 — unused sub-CLI slots**: build `$T1_UNUSED` = [working-list slots with `auth_type=sub`] − `$DISPATCH_LIST`. For each UNAVAIL primary, dispatch the next available T1 slot as a replacement (parallel sibling Tasks in one message turn).
+2. **T2 — final fallback slots**: working-list slots with `auth_type≠sub` AND not in `$DISPATCH_LIST`. Slots already dispatched as primary are excluded. Only dispatch T2 if `$T1_UNUSED` is empty or fully exhausted/UNAVAIL.
+
+**Label replacements** as `(T1 fallback)` or `(T2 fallback)` in the display table. Do not modify `$DISPATCH_LIST` — the tiered replacements are additional slots for this round only.
+
+#### Display results table
+
+```
+┌──────────────┬──────────────────────────────────────────────────────────┐
+│ Model        │ Round $CURRENT_ROUND Position                            │
+├──────────────┼──────────────────────────────────────────────────────────┤
+│ Claude       │ [Claude's own position — $CLAUDE_POSITION]              │
+│ <slot>       │ [verdict/reasoning or UNAVAIL]                          │
+└──────────────┴──────────────────────────────────────────────────────────┘
+```
+
+#### INLINE SYNTHESIS (no Task spawn — orchestrator synthesizes directly)
+
+Filter available results (exclude `verdict: UNAVAIL`).
+
+**Mode A consensus check:** Do all available positions point to the same conclusion?
+(Equivalence is your judgment — focus on whether positions share the same recommendation
+or key conclusion, even if worded differently.)
+
+- If YES → set `$CONSENSUS_REACHED = true`. Break loop.
+- If NO → build `$CROSS_POLL_BUNDLE`:
+  ```
+  Prior positions:
+  • Claude: <$CLAUDE_POSITION>
+  • <slot1>: <reasoning from result>
+  • <slot2>: <reasoning from result>
+  [• <slot>: UNAVAIL]
+  ```
+  Increment `$CURRENT_ROUND += 1`. Continue loop.
+
+**End LOOP**
+
+---
+
+### After loop — Consensus output (Mode A)
+
+If `$CONSENSUS_REACHED`:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► QUORUM CONSENSUS REACHED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Question: [question]
+Rounds to consensus: [$CURRENT_ROUND]
+
+CONSENSUS ANSWER:
+[Full consensus answer — detailed and actionable]
+
+Supporting positions:
+• Claude:    [brief]
+• <slot>:    [brief or UNAVAIL]
+[... one line per slot ...]
+```
+
+**Scoreboard update (single merge-wave transaction per round):**
+
+Write per-slot temp vote files to `.planning/scoreboard-tmp/`:
+```bash
+mkdir -p .planning/scoreboard-tmp
+```
+
+Mode A: `result: ''` — no binary ground truth at vote time; score is omitted.
+
+For each slot result in `$ALL_ROUND_RESULTS`:
+```bash
+node -e "
+const fs = require('fs'), path = require('path');
+fs.writeFileSync(
+  '.planning/scoreboard-tmp/vote-<slot>-<taskLabel>-<round>-' + process.pid + '.json',
+  JSON.stringify({
+    slot: '<slotName>',
+    modelId: '<fullModelId from providers.json>',
+    result: '',
+    verdict: '<VERDICT>',
+    taskDescription: '<question first 100 chars>'
+  })
+);
+"
+```
+
+Then apply all votes in one transaction per round:
+```bash
+node "$HOME/.claude/qgsd-bin/update-scoreboard.cjs" merge-wave \
+  --dir .planning/scoreboard-tmp \
+  --task "<taskLabel>" \
+  --round <round> \
+  --scoreboard .planning/quorum-scoreboard.json
+```
+
+Run one merge-wave call per round (in order). Clean up temp dir:
+```bash
+rm -rf .planning/scoreboard-tmp
+```
+
+**Note:** For CLI slots (codex-1, gemini-1, opencode-1, copilot-1) that use --model not --slot, write vote files with `model: "<familyName>"` instead of `slot` + `modelId`.
+
+---
+
+### After loop — Escalate (Mode A) — no consensus after 10 rounds
+
+If loop exhausted without `$CONSENSUS_REACHED`:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► QUORUM ESCALATING — NO CONSENSUS AFTER 10 ROUNDS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Question: [question]
+
+Final positions:
+• Claude:    [position + key reasoning]
+• <slot>:    [position + key reasoning or UNAVAIL]
+[... one line per model ...]
+
+Core disagreement: [1–2 sentences]
+
+Claude's recommendation: [position with rationale]
+```
+
+Update scoreboard using same merge-wave pattern as Consensus output above.
+
+---
+
+## Mode B — Execution + Trace Review
+
+### Parse and run commands
+
+Extract command(s) from `$ARGUMENTS`. Display:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► QUORUM: Mode B — Execution + Trace Review
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Question: [original question]
+Commands: [list]
+
+Running commands...
+```
+
+Run each command via Bash, capturing full stdout + stderr + exit code as `$TRACES`:
+```
+=== Command: [cmd] ===
+Exit code: N
+Output:
+[full output — not summarized]
+```
+
+Claude gives its own verdict before dispatching workers:
+```
+Claude (Round 1): verdict=[APPROVE|REJECT|FLAG] — [reasoning 2–4 sentences]
+```
+Store as `$CLAUDE_POSITION`.
+
+### Round loop — up to 10 rounds with inline synthesis (Mode B)
+
+```
+$MAX_ROUNDS = 10
+$CURRENT_ROUND = 1
+$CROSS_POLL_BUNDLE = ""
+$CONSENSUS_REACHED = false
+$ALL_ROUND_RESULTS = []
+```
+
+**LOOP** while `$CURRENT_ROUND <= $MAX_ROUNDS` and not `$CONSENSUS_REACHED`:
+
+#### Round banner
+
+```
+─────────────────────────────────────────────
+ QGSD ► QUORUM Round $CURRENT_ROUND / up to $MAX_ROUNDS
+─────────────────────────────────────────────
+```
+
+#### Build `$DISPATCH_LIST` (quorum.md Adaptive Fan-Out: FAN_OUT_COUNT-1 external slots), then dispatch as SIBLING Task calls (one message turn)
+
+```
+Task(
+  subagent_type="qgsd-quorum-slot-worker",
+  description="<slotName> quorum R<$CURRENT_ROUND>",
+  prompt="""
+slot: <slotName>
+round: $CURRENT_ROUND
+timeout_ms: <$SLOT_TIMEOUTS[slotName]>
+repo_dir: <$REPO_DIR>
+mode: B
+question: <original question text>
+[artifact_path: <$ARTIFACT_PATH>]
+traces: |
+  <$TRACES — full execution trace output, not summarized>
+[prior_positions: |
+  <$CROSS_POLL_BUNDLE>]   # Round 2+ only
+"""
+)
+```
+
+One Task per active slot — all sibling calls in same message turn.
+
+Collect all worker result blocks → store as `$ROUND_RESULTS`. Append to `$ALL_ROUND_RESULTS`.
+
+#### Process UNAVAIL results (sequential Bash calls)
+
+For each result where `verdict: UNAVAIL`:
+```bash
+node "$HOME/.claude/qgsd-bin/update-scoreboard.cjs" set-availability \
+  --slot <slot> \
+  --message "<unavail_message text>" \
+  --scoreboard .planning/quorum-scoreboard.json
+```
+
+#### Tiered fallback dispatch (FALLBACK-01)
+
+After recording UNAVAIL results, apply the same tiered replacement logic as Mode A:
+Same tiered logic as Mode A — classification by runtime `auth_type`, not slot name:
+1. **T1** — working-list slots with `auth_type=sub` AND not in `$DISPATCH_LIST` (`$T1_UNUSED`)
+2. **T2** — working-list slots with `auth_type≠sub` AND not in `$DISPATCH_LIST`. Only if `$T1_UNUSED` is empty or exhausted.
+
+Label replacements `(T1 fallback)` or `(T2 fallback)` in the display.
+
+#### Display results table
+
+```
+┌──────────────┬──────────────┬──────────────────────────────────────────┐
+│ Model        │ Verdict      │ Reasoning                                │
+├──────────────┼──────────────┼──────────────────────────────────────────┤
+│ Claude       │ [verdict]    │ [summary — $CLAUDE_POSITION]            │
+│ <slot>       │ [verdict]    │ [reasoning or UNAVAIL]                  │
+└──────────────┴──────────────┴──────────────────────────────────────────┘
+```
+
+#### INLINE SYNTHESIS (no Task spawn — orchestrator synthesizes directly)
+
+Filter available results (exclude `verdict: UNAVAIL`).
+
+**Mode B consensus rules:**
+- All available APPROVE → consensus APPROVE
+- Any available REJECT → consensus REJECT (immediate)
+- All available FLAG (no APPROVE, no REJECT) → consensus FLAG
+- Mix of APPROVE and FLAG (no REJECT) → no consensus → DELIBERATION NEEDED
+
+If CONSENSUS:
+- Set `$CONSENSUS_REACHED = true`. Break loop.
+
+If NO CONSENSUS:
+- Build `$CROSS_POLL_BUNDLE`:
+  ```
+  Prior positions:
+  • Claude: verdict=<$CLAUDE_VERDICT> — <$CLAUDE_POSITION>
+  • <slot1>: verdict=<VERDICT> — <reasoning>
+  [• <slot>: UNAVAIL]
+  ```
+- Increment `$CURRENT_ROUND += 1`. Continue loop.
+
+**End LOOP**
+
+---
+
+### After loop — Consensus output (Mode B)
+
+If `$CONSENSUS_REACHED`:
+
+Parse final round results for verdicts. Display:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► QUORUM VERDICT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+┌──────────────┬──────────────┬──────────────────────────────────────────┐
+│ Model        │ Verdict      │ Reasoning                                │
+├──────────────┼──────────────┼──────────────────────────────────────────┤
+│ Claude       │ [verdict]    │ [summary]                                │
+│ <slot>       │ [verdict]    │ [summary or UNAVAIL]                     │
+├──────────────┼──────────────┼──────────────────────────────────────────┤
+│ CONSENSUS    │ [verdict]    │ [N APPROVE, N REJECT, N FLAG, N UNAVAIL] │
+└──────────────┴──────────────┴──────────────────────────────────────────┘
+```
+
+**Scoreboard update (single merge-wave transaction per round):**
+
+Mode B (execution + trace review) — peer-scored: individual verdict vs. final consensus:
+
+| Individual verdict | Consensus verdict | Alternative adopted? | `<voteCode>` |
+|--------------------|-------------------|----------------------|--------------|
+| `APPROVE`          | `APPROVE`         | no                   | `TP`         |
+| `APPROVE`          | `APPROVE`         | yes (improvement)    | `TP+`        |
+| `REJECT`           | `REJECT`          | no                   | `TN`         |
+| `REJECT`           | `REJECT`          | yes (alt. adopted)   | `TN+`        |
+| `APPROVE`          | `REJECT`          | —                    | `FP`         |
+| `REJECT`           | `APPROVE`         | —                    | `FN`         |
+| `FLAG`             | any               | yes (improvement)    | `TP+`        |
+| `UNAVAIL`          | —                 | —                    | `UNAVAIL`    |
+
+Write per-slot temp vote files to `.planning/scoreboard-tmp/` and apply via merge-wave — same pattern as Mode A Consensus output scoreboard update above (per round from `$ALL_ROUND_RESULTS`).
+
+---
+
+### After loop — Escalate (Mode B) — no consensus after 10 rounds
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ QGSD ► QUORUM ESCALATING — NO CONSENSUS AFTER 10 ROUNDS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Question: [original question]
+Commands run: [list]
+
+Final verdicts:
+• Claude:    [verdict + key reasoning]
+• <slot>:    [verdict + key reasoning or UNAVAIL]
+[... one line per model ...]
+
+Core disagreement: [1–2 sentences — what specifically split the models]
+
+Claude's recommendation: [APPROVE / REJECT / FLAG with rationale]
+```
+
+Update scoreboard using the same merge-wave pattern as Mode B Consensus output above (use `TP+` for FLAG verdicts, `FP`/`FN` for models that disagreed with Claude's final recommendation).

package/agents/qgsd-quorum-slot-worker.md

@@ -0,0 +1,41 @@
+---
+name: qgsd-quorum-slot-worker
+description: >
+  Thin passthrough — extracts arguments, calls quorum-slot-dispatch.cjs, emits output verbatim.
+  No prompt construction, no output parsing, no file reads. One Bash call per dispatch.
+tools: Bash
+color: blue
+---
+
+You are a QGSD quorum slot worker. Spawned as a parallel Task.
+Your job: extract args from $ARGUMENTS, call quorum-slot-dispatch.cjs, emit its stdout verbatim.
+Do NOT modify, summarize, or reformat the script output. It IS the structured result block.
+
+```bash
+SLOT=$(echo "$ARGUMENTS"|grep '^slot:'|awk '{print $2}')
+ROUND=$(echo "$ARGUMENTS"|grep '^round:'|awk '{print $2}')
+TIMEOUT_MS=$(echo "$ARGUMENTS"|grep '^timeout_ms:'|awk '{print $2}')
+REPO_DIR=$(echo "$ARGUMENTS"|grep '^repo_dir:'|sed 's/repo_dir: *//')
+MODE=$(echo "$ARGUMENTS"|grep '^mode:'|awk '{print $2}')
+QUESTION=$(echo "$ARGUMENTS"|grep '^question:'|sed 's/question: *//')
+ARTIFACT_PATH=$(echo "$ARGUMENTS"|grep '^artifact_path:'|sed 's/artifact_path: *//')
+REVIEW_CONTEXT=$(echo "$ARGUMENTS"|grep '^review_context:'|sed 's/review_context: *//')
+REQUEST_IMPROVEMENTS=$(echo "$ARGUMENTS"|grep '^request_improvements:'|awk '{print $2}')
+PRIOR_FILE=$(mktemp); TRACES_FILE=$(mktemp)
+echo "$ARGUMENTS"|awk '/^prior_positions:/{f=1;next}/^[a-z]/{f=0}f{sub(/^  /,"");print}' > "$PRIOR_FILE"
+echo "$ARGUMENTS"|awk '/^traces:/{f=1;next}/^[a-z]/{f=0}f{sub(/^  /,"");print}' > "$TRACES_FILE"
+FLAGS=""; [ -n "$ARTIFACT_PATH" ] && FLAGS="$FLAGS --artifact-path $ARTIFACT_PATH"
+[ -n "$REVIEW_CONTEXT" ] && FLAGS="$FLAGS --review-context \"$REVIEW_CONTEXT\""
+[ -s "$PRIOR_FILE" ] && FLAGS="$FLAGS --prior-positions-file $PRIOR_FILE"
+[ -s "$TRACES_FILE" ] && FLAGS="$FLAGS --traces-file $TRACES_FILE"
+[ "$REQUEST_IMPROVEMENTS" = "true" ] && FLAGS="$FLAGS --request-improvements"
+BASH_TIMEOUT=$(( TIMEOUT_MS + 30000 > 120000 ? 120000 : TIMEOUT_MS + 30000 ))
+node "$HOME/.claude/qgsd-bin/quorum-slot-dispatch.cjs" \
+  --slot "$SLOT" --round "$ROUND" --timeout "$TIMEOUT_MS" --cwd "$REPO_DIR" \
+  --mode "$MODE" --question "$QUESTION" $FLAGS
+rm -f "$PRIOR_FILE" "$TRACES_FILE"
+```
+
+Print the script's stdout verbatim to your output. Do not add commentary.
+
+$ARGUMENTS fields: slot, round, timeout_ms, repo_dir, mode (A|B), question, [artifact_path], [review_context], [prior_positions: |], [traces: |], [request_improvements: true]