war-room

---
name: deferred-capture
description: Capture rejected COAs and dissenting-view items
  after Phase 5 voting.
category: integration
---

# Deferred Capture

After Phase 5 (Voting and Narrowing), capture rejected COAs and
any future-work items from the Dissenting Views section so
nothing valuable is lost.

## When to Run

Run this module immediately after the Supreme Commander
publishes the final decision document and before the war-room
session closes.

## Capturing Rejected COAs

For every COA that was eliminated during voting, check whether
it received at least one Borda vote.
If it did, capture it as a deferred item:

```bash
python3 scripts/deferred_capture.py \
  --title "COA: <coa-title>" \
  --source war-room \
  --context "<rejection rationale from Supreme Commander>" \
  --artifact-path "<path to coa file in strategeion>" \
  --session-id "<war-room-session-id>"
```

A COA that received zero Borda votes across all expert roles
does not need to be captured.

## Capturing Dissenting-View Items

After capturing rejected COAs, scan the "Dissenting Views"
section of the Supreme Commander decision document.
For each item that describes future work (identified by phrases
such as "should revisit", "worth exploring", "consider in
phase N"), capture it using the same script:

```bash
python3 scripts/deferred_capture.py \
  --title "COA: <coa-title>" \
  --source war-room \
  --context "<rejection rationale from Supreme Commander>" \
  --artifact-path "<path to coa file in strategeion>" \
  --session-id "<war-room-session-id>"
```

Use the dissenting view text as the `--context` value.
Omit `--artifact-path` if no coa file corresponds to the item.

## Behavior Rules

- Capture is automatic: do not prompt the user for
  confirmation.
- Capture every qualifying COA in a single pass before
  closing the session.
- If `scripts/deferred_capture.py` is not present in the
  repository, log a warning and skip capture rather than
  blocking the war-room close.
- The session ID must match the ID stored in
  `.attune/war-room-session.json`.

---
name: deliberation-protocol
description: Phase definitions and flow control for War Room deliberation sessions
category: war-room-module
tags: [protocol, phases, workflow]
dependencies: []
estimated_tokens: 800
---

# Deliberation Protocol

## Session Lifecycle

```
Initialize
    |
    v
+------------------------+
| Phase 0: Reversibility |  <-- Chief Strategist (immediate)
| Assessment             |
+------------------------+
    |
    +---> [RS ≤ 0.40: EXPRESS MODE - skip to Phase 7]
    |
    v
+-------------------+
| Phase 1: Intel    |  <-- Scout + Intel Officer (parallel)
+-------------------+
    |
    v
+-------------------+
| Phase 2: Assess   |  <-- Chief Strategist
+-------------------+
    |
    v
+-------------------+
| Phase 3: COA Dev  |  <-- Multiple experts (parallel, anonymized)
+-------------------+
    |
    v
+-------------------+
| Escalation Check  |  <-- Supreme Commander decides
+-------------------+
    |
    +---> [Escalate to Full Council if needed]
    |
    v
+-------------------+
| Phase 4: Red Team |  <-- Red Team Commander
+-------------------+
    |
    v
+-------------------+
| Phase 5: Voting   |  <-- All active experts
+-------------------+
    |
    v
+-------------------+
| Phase 6: Premortem|  <-- All active experts (parallel)
+-------------------+
    |
    v
+-------------------+
| Phase 7: Synthesis|  <-- Supreme Commander
+-------------------+
    |
    v
Persist to Strategeion
```

## Phase Definitions

### Phase 0: Reversibility Assessment

**Purpose**: Determine appropriate deliberation intensity before committing resources.

**Expert**: Chief Strategist (Sonnet)

**Execution**: Immediate, before any other phases

**Inputs**:
- Problem statement
- Initial context

**Step 0a: Threshold Configuration** (optional)

Prompt user for custom thresholds:
```
Reversibility Thresholds (Enter for defaults):
  Express ceiling    [0.40]: _
  Lightweight ceiling [0.60]: _
  Full Council ceiling [0.80]: _
```

If user presses Enter, use defaults. Otherwise, apply custom thresholds for session.

**Step 0b: Dimension Scoring**

Score five dimensions (1-5 each):
1. **Reversal Cost** - Effort to undo the decision
2. **Time Lock-In** - How quickly decision crystallizes
3. **Blast Radius** - Scope of systems/people affected
4. **Information Loss** - Options closed by deciding
5. **Reputation Impact** - External visibility and trust implications

**Outputs**:
- Reversibility Score (RS) = Sum / 25
- Decision Type classification (Type 2, 1B, 1A, 1A+)
- Recommended deliberation mode (using configured thresholds)
- Justification for classification

**Duration Target**: 15-30 seconds (including threshold prompt)

**Routing Logic** (using configured or default thresholds):
```
# t = user thresholds or defaults {express: 0.40, lightweight: 0.60, full_council: 0.80}

if RS <= t.express:
    mode = "express"  # Skip to Phase 7 (Synthesis only)
elif RS <= t.lightweight:
    mode = "lightweight"  # Standard 2-round protocol
elif RS <= t.full_council:
    mode = "full_council"  # Invoke all experts
else:
    mode = "full_council_delphi"  # Iterative convergence
```

**Express Mode Fast Path**:
For Type 2 decisions (RS ≤ 0.40):
- Skip Phases 1-6
- Chief Strategist provides immediate recommendation
- Supreme Commander ratifies or overrides
- Total time: < 2 minutes

---

### Phase 1: Intelligence Gathering

**Purpose**: Gather context and identify terrain before strategy.

**Experts**: Scout (Qwen Turbo), Intelligence Officer (Gemini Pro)

**Execution**: Parallel

**Inputs**:
- Problem statement
- Context files (if provided)

**Outputs**:
- Scout Report (quick terrain overview)
- Intelligence Report (deep analysis)

**Duration Target**: 30-60 seconds

### Phase 2: Situation Assessment

**Purpose**: Synthesize intelligence into a concrete assessment.

**Expert**: Chief Strategist (Sonnet)

**Execution**: Sequential (after Phase 1)

**Inputs**:
- All intelligence reports from Phase 1

**Outputs**:
- Refined problem statement
- Prioritized constraints
- Strategic opportunities
- COA development guidance

**Duration Target**: 15-30 seconds

### Phase 3: COA Development

**Purpose**: Generate diverse courses of action.

**Experts**: Variable (based on mode)
- Lightweight: Chief Strategist only
- Full Council: Strategist + Tactician + Logistics Officer

**Execution**: Parallel, anonymized

**Inputs**:
- Situation assessment from Phase 2

**Outputs**:
- 3-5 distinct COAs
- Each with pros, cons, risks, effort estimate

**Duration Target**: 60-120 seconds

**Anonymization**: Responses labeled as "Response A, B, C..."

### Escalation Check

**Purpose**: Supreme Commander validates Phase 0 classification or overrides.

**Automatic Escalation** (based on RS from Phase 0):
- RS > 0.60 → Full Council activated
- RS > 0.80 → Delphi mode enabled

**Manual Escalation Triggers**:
1. High complexity (multiple architectural trade-offs)
2. Significant expert disagreement (conflicting COAs)
3. Novel problem domain (uncertain reversibility)
4. Precedent-setting decision (future decisions follow pattern)
5. User explicitly requested full council

**De-escalation Opportunity**:
If Phase 0 classified as Type 1 but evidence suggests Type 2:
- Challenge the RS assessment
- Document false irreversibility claim
- Recommend express mode

**If Escalated**:
- Invoke additional experts (Intel Officer, Tactician, Logistics)
- Gather additional COAs
- Merge with existing COAs
- Update RS assessment with new information

### Phase 4: Red Team and Wargaming

**Purpose**: Challenge assumptions and identify weaknesses.

**Expert**: Red Team Commander (Gemini Flash)

**Execution**: Sequential (after all COAs)

**Inputs**:
- All COAs (anonymized)
- Situation assessment

**Outputs**:
- Challenge report per COA
- Hidden assumptions identified
- Failure scenarios
- Cross-cutting concerns

**Duration Target**: 30-60 seconds

### Phase 5: Voting and Narrowing

**Purpose**: Aggregate expert rankings to identify top approaches.

**Experts**: All active experts

**Execution**: Parallel

**Inputs**:
- All COAs with Red Team challenges

**Outputs**:
- Expert rankings
- Aggregate scores (Borda count)
- Top 2-3 finalists

**Voting Method**: Borda count (rank-based scoring)

**Duration Target**: 30-45 seconds

### Phase 6: Premortem Analysis

**Purpose**: Imagine failure to identify risks.

**Experts**: All active experts

**Execution**: Parallel

**Inputs**:
- Selected COA(s) from voting

**Outputs**:
- Failure mode catalog
- Early warning signs
- Prevention strategies
- Contingency plans

**Duration Target**: 45-90 seconds

### Phase 7: Supreme Commander Synthesis

**Purpose**: Make final decision with full rationale.

**Expert**: Supreme Commander (Opus)

**Execution**: Sequential (final phase)

**Inputs**:
- All deliberation artifacts
- Full attribution (unsealed)

**Outputs**:
- Selected approach
- Detailed rationale
- Implementation orders
- Watch points
- Dissenting views acknowledged

**Duration Target**: 30-60 seconds

## Delphi Extension

For high-stakes decisions, iterate until convergence:

```
Round N:
  - Experts revise positions based on Red Team feedback
  - Re-vote
  - Check convergence score

Convergence Formula:
  score = 1 - (std_dev(rankings) / max_possible_std_dev)

Threshold: 0.85 (configurable)
Max Rounds: 5 (configurable)
```

## Error Handling

### Expert Failure

If an expert fails to respond:
1. Log the failure with reason
2. Continue with remaining experts
3. Note gap in synthesis
4. Do not block deliberation

### Timeout Handling

Default timeouts:
- External experts: 120 seconds
- Synthesis phases: 180 seconds

On timeout:
1. Use partial response if available
2. Log timeout event
3. Continue deliberation

### Session Recovery

Sessions are persisted after each phase:
- Can resume from last completed phase
- Use `--resume <session-id>` to continue

## Agent Teams Execution Path

When `--agent-teams` is active (Full Council / Delphi only), phases execute through persistent teammates instead of one-shot delegations:

### Phase Mapping

| Phase | Standard (Conjure) | Agent Teams |
|-------|-------------------|-------------|
| Phase 0: RS Assessment | Chief Strategist direct call | Lead agent computes directly (no team needed yet) |
| Phase 1: Intel | Parallel delegation to Scout and Intel | Lead sends inbox tasks to `scout` and `intel-officer` teammates |
| Phase 2: Assessment | Sequential delegation | Lead's `chief-strategist` teammate processes intel reports |
| Phase 3: COA Dev | Parallel delegation, anonymized | Teammates develop COAs independently; can send clarifying questions via inbox |
| Phase 4: Red Team | Sequential delegation | `red-team` teammate receives COAs; **can message authors for clarification** |
| Phase 5: Voting | Parallel delegation | Lead broadcasts ballot; teammates respond via inbox messages |
| Phase 6: Premortem | Parallel delegation | Teammates post failure scenarios; **can build on each other's analysis** |
| Phase 7: Synthesis | Supreme Commander call | Lead agent synthesizes (teammates shut down after) |

### Key Differences

**Bidirectional messaging** (Phases 3-6): In standard mode, experts produce one-shot responses. In agent teams mode, experts can exchange messages mid-phase: the Red Team can ask a COA author to clarify assumptions, and premortem participants can chain failure scenarios.

**Delphi persistence**: In standard mode, each Delphi round re-invokes all experts from scratch. In agent teams mode, teammates persist across rounds, retaining prior context and positions. This reduces token waste and enables more nuanced position evolution.

**Anonymization**: Agent teams still uses anonymized COA labeling (Response A, B, C) during Phases 3-5. Attribution is revealed in Phase 7 by the lead agent after de-anonymization.

### Graceful Shutdown

After Phase 7, the lead sends `shutdown_request` to all teammates. Teammates acknowledge and exit. Lead cleans up team config and tmux panes.

## Metrics

Track per session:
- **Reversibility Score** (from Phase 0)
- **Decision Type** (Type 2, 1B, 1A, 1A+)
- **Mode match** (did actual mode match RS recommendation?)
- Total duration
- Per-phase duration
- Token usage per expert
- Expert failure count
- Escalation occurred (y/n)
- De-escalation occurred (y/n)
- Convergence rounds (if Delphi)
- **Over-deliberation rate** (sessions where RS suggested lighter mode)

# Discussion Publishing

Publish completed war room deliberations to GitHub Discussions for cross-session discovery.

## When This Module Applies

This module activates **after Phase 7 (Supreme Commander Synthesis)** completes. It is an additional publication channel: the local strategeion archive continues as the primary record.

## Prerequisites

- GitHub platform detected (check `git_platform` session context)
- `gh` CLI authenticated (`gh auth status` succeeds)
- Repository has Discussions enabled with a "Decisions" category
- Leyline command-mapping Discussion templates available

## Publishing Flow

### Step 1: Confirm Publication (Default: Publish)

After the Supreme Commander Decision document is finalized,
announce the publication and give the user a chance to opt out:

```
Publishing this decision to GitHub Discussions. [Y/n]
```

Publishing is the default action. If the user explicitly
declines ("n"), skip all subsequent steps. The local
strategeion workflow continues unchanged.

### Step 2: Resolve Repository and Category IDs

```bash
# Get repository node ID
REPO_INFO=$(gh api graphql -f query='
query($owner: String!, $repo: String!) {
  repository(owner: $owner, name: $repo) {
    id
    hasDiscussionsEnabled
    discussionCategories(first: 25) {
      nodes { id name slug }
    }
  }
}' -f owner="OWNER" -f repo="REPO")
```

Extract `repositoryId` and find the category nodeID where `slug` equals `"decisions"`.

If Discussions are not enabled or the "Decisions" category doesn't exist, warn the user and skip publishing:
```
⚠ Discussions not available (feature disabled or "Decisions" category missing). Skipping publication.
```

### Step 3: Create the Discussion

Create a Discussion in the "Decisions" category:

```bash
gh api graphql -f query='
mutation($repoId: ID!, $categoryId: ID!, $title: String!, $body: String!) {
  createDiscussion(input: {
    repositoryId: $repoId,
    categoryId: $categoryId,
    title: $title,
    body: $body
  }) {
    discussion { number id url }
  }
}' -f repoId="$REPO_ID" -f categoryId="$CATEGORY_ID" \
   -f title="[War Room] $TOPIC" \
   -f body="$BODY"
```

**Title format**: `[War Room] <topic from session invocation>`

**Body structure**:
```markdown
## Context

<Context from the Supreme Commander Decision document>

## Decision

**Selected Approach**: <selected approach name>

<Decision rationale>

## Consequences

<Positive, negative, and neutral consequences>

## Reversibility Assessment

| Dimension | Score | Rationale |
|-----------|-------|-----------|
| Reversal Cost | X/5 | ... |
| Time Lock-In | X/5 | ... |
| Blast Radius | X/5 | ... |
| Information Loss | X/5 | ... |
| Reputation Impact | X/5 | ... |

**RS: 0.XX | Type: [1A+/1A/1B/2] | Mode: [delphi/full_council/lightweight/express]**

## Alternatives Considered

<Brief summary of each COA that was not selected>

## Expert Panel

| Role | Model | Key Contribution |
|------|-------|-----------------|
| Supreme Commander | ... | ... |
| Chief Strategist | ... | ... |
| Red Team | ... | ... |

---
*Session: <session_id> | Strategeion: `<local_file_path>`*
```

### Step 4: Post Deliberation Phases as Comments

Post each major phase as a threaded comment on the Discussion. This preserves the deliberation trail without overwhelming the Discussion body.

**Comments to post** (in order):
1. **Intelligence Report**: key findings from Phase 1
2. **Situation Assessment**: Phase 2 analysis summary
3. **COA Summary**: brief of each Course of Action (Phase 3)
4. **Red Team Challenges**: key challenges and responses (Phase 4)
5. **Supreme Commander Synthesis**: the final decision rationale (Phase 7)

> Phases 5-6 (War Game execution and Decision Briefing) are internal deliberation artifacts that don't warrant separate comments. Their outputs are incorporated into the Red Team Challenges and Supreme Commander Synthesis.

For each comment:
```bash
gh api graphql -f query='
mutation($discussionId: ID!, $body: String!) {
  addDiscussionComment(input: {
    discussionId: $discussionId,
    body: $body
  }) {
    comment { id url }
  }
}' -f discussionId="$DISCUSSION_ID" -f body="### Phase N: <Phase Name>

<Phase summary — keep under 500 words per comment>

*Full details in strategeion: \`<local_file_path>\`*"
```

### Step 5: Mark Synthesis as Answer (Q&A Categories Only)

> **Skip this step for the "Decisions" category.** It uses Announcement format, which does not support answers. The synthesis is already the last comment, so no further marking is needed.

For Q&A-format categories (e.g., "Knowledge"), mark the synthesis comment as the answer:

```bash
gh api graphql -f query='
mutation($commentId: ID!) {
  markDiscussionCommentAsAnswer(input: {
    id: $commentId
  }) {
    discussion { id answerChosenAt }
  }
}' -f commentId="$SYNTHESIS_COMMENT_ID"
```

If the mutation fails (wrong category format), log a warning and continue.

### Step 6: Apply Labels

Apply labels to the Discussion for discoverability. Labels must already exist on the repository.

Recommended labels:
- `war-room`: always applied
- `type-1a`, `type-1b`, or `type-2`: matching the decision type from RS assessment
- Topic-relevant labels (e.g., `architecture`, `performance`, `security`)

Label application requires a separate mutation:
```bash
gh api graphql -f query='
mutation($labelableId: ID!, $labelIds: [ID!]!) {
  addLabelsToLabelable(input: {
    labelableId: $labelableId,
    labelIds: $labelIds
  }) {
    labelable { ... on Discussion { id } }
  }
}'
```

If label application fails (labels don't exist), log a warning and continue.

### Step 7: Update Local Strategeion

Add the Discussion URL to the local strategeion session file:

```yaml
discussion_url: https://github.com/OWNER/REPO/discussions/NUMBER
discussion_number: NUMBER
published_at: YYYY-MM-DDTHH:MM:SSZ
```

This cross-reference allows future sessions to move from local artifact to the published Discussion and vice versa.

## Error Handling

- **Network failure during publishing**: Log warning, preserve local artifacts. Do not retry automatically: the user can re-publish manually.
- **Rate limiting**: If GitHub returns 429, warn the user and skip. Do not block the session.
- **Missing category**: Warn and skip. Do not auto-create categories.
- **`gh` not authenticated**: Skip with message: "GitHub CLI not authenticated. Run `gh auth login` to enable Discussion publishing."

## Token Conservation

- Discussion body: max 2000 words (NFR-005)
- Phase comments: max 500 words each
- Link to strategeion files for full details rather than duplicating content
- Total published content should be a readable summary, not a transcript

## Prior Decision Check

Before starting a new war room session, search for prior decisions on the same topic. See the "Prior Decision Check" section below.

---

## Prior Decision Check

When a war room session starts (before Phase 1), search existing Discussions for prior decisions in the same area.

### Search Flow

1. Extract topic keywords from the war room invocation argument
2. Search Discussions:

```bash
gh api graphql -f query='
query($searchQuery: String!) {
  search(query: $searchQuery, type: DISCUSSION, first: 5) {
    discussionCount
    nodes {
      ... on Discussion {
        number
        title
        url
        createdAt
        body
        answer { body }
      }
    }
  }
}' -f searchQuery="repo:OWNER/REPO category:Decisions TOPIC_KEYWORDS"
```

3. If matches found, present to user:

```
Found prior decisions on this topic:
  #42 [War Room] Database migration strategy (2026-02-15)
  #38 [War Room] API versioning approach (2026-02-10)

Review before proceeding? [Y/n/skip]
```

### User Responses

- **Y (review)**: Display the prior decision summary. Then ask:
  - "Does this prior decision still apply? [Y/n]"
    - **Y**: Skip war room. Record a note: "Reaffirmed Decision #42. No new deliberation needed."
    - **N**: Proceed with war room. New Discussion will reference the prior: `Supersedes: #42`
- **n (proceed)**: Start war room without reviewing prior decisions
- **skip**: Disable prior decision check for this session

### No Matches

If no matching Discussions are found, proceed directly to Phase 1 without delay.

---
name: expert-roles
description: Configuration and invocation patterns for War Room expert panel members
category: war-room-module
tags: [experts, delegation, multi-llm]
dependencies: [conjure:delegation-core]
estimated_tokens: 600
---

# Expert Roles Configuration

## Expert Registry

```python
EXPERT_CONFIGS = {
    "supreme_commander": {
        "role": "Supreme Commander",
        "service": "native",
        "model": "claude-opus-5",
        "description": "Final decision authority and synthesis",
        "phases": ["synthesis"],
        "dangerous": False,
    },
    "chief_strategist": {
        "role": "Chief Strategist",
        "service": "native",
        "model": "claude-sonnet-5",
        "description": "Approach generation and trade-off analysis",
        "phases": ["assessment", "coa_development"],
        "dangerous": False,
    },
    "intelligence_officer": {
        "role": "Intelligence Officer",
        "service": "gemini",
        "model": "gemini-3-pro",
        "command": ["gemini", "--model", "gemini-3-pro", "-p"],
        "description": "Deep context analysis with 1M+ token window",
        "phases": ["intel"],
        "dangerous": True,
    },
    "field_tactician": {
        "role": "Field Tactician",
        "service": "glm",
        "model": "glm-5.2",
        "command_resolver": "get_glm_command",
        "preferred_alias": "ccgd",
        "fallback_command": ["claude-glm", "--dangerously-skip-permissions", "-p"],
        "description": "Implementation feasibility assessment",
        "phases": ["coa_development"],
        "dangerous": True,
    },
    "scout": {
        "role": "Scout",
        "service": "qwen",
        "model": "qwen-turbo",
        "command": ["qwen", "--model", "qwen-turbo", "-p"],
        "description": "Rapid reconnaissance and data gathering",
        "phases": ["intel"],
        "dangerous": True,
    },
    "prosecution_counsel": {
        "role": "Prosecution Counsel",
        "service": "native",
        "model": "claude-sonnet-5",
        "description": "Challenges every addition using additive-bias-defense scrutiny questions",
        "phases": ["red_team", "coa_development"],
        "dangerous": False,
    },
    "red_team": {
        "role": "Red Team Commander",
        "service": "gemini",
        "model": "gemini-3-flash",
        "command": ["gemini", "--model", "gemini-3-flash", "-p"],
        "description": "Adversarial challenge and failure mode identification",
        "phases": ["red_team", "premortem"],
        "dangerous": True,
    },
    "logistics_officer": {
        "role": "Logistics Officer",
        "service": "qwen",
        "model": "qwen-max",
        "command": ["qwen", "--model", "qwen-max", "-p"],
        "description": "Resource estimation and dependency analysis",
        "phases": ["coa_development"],
        "dangerous": True,
    },
}
```

## Prosecution Counsel Role

The Prosecution Counsel is a mandatory panelist when
reviewing implementation plans. Their sole job is to
argue against additions using the scrutiny questions
from `leyline:additive-bias-defense`:

1. Is this a deviation from the current priority?
2. Is it critical to implement at this juncture?
3. Does a simpler or more elegant solution exist?
4. What evidence proves this is needed?
5. What breaks if we do not add this?

**Prompt template for Prosecution Counsel:**

> You are the Prosecution Counsel. Your job is to
> challenge every proposed addition in this plan.
> For each new component, abstraction, or capability,
> apply the 5 scrutiny questions. If the proposer
> cannot provide concrete evidence for questions 4
> and 5, recommend removal.
>
> Default stance: this addition should not exist.
> Prove me wrong.

**When active:** Always active for plan reviews.
Optional for other war-room sessions (activated when
`leyline:additive-bias-defense` findings are provided
as input).

## Panel Configurations

### Lightweight Panel

For quick decisions with lower complexity:

```python
LIGHTWEIGHT_PANEL = [
    "supreme_commander",
    "chief_strategist",
    "prosecution_counsel",
    "red_team",
]
```

### Full Council

For complex, high-stakes decisions:

```python
FULL_COUNCIL = [
    "supreme_commander",
    "chief_strategist",
    "intelligence_officer",
    "prosecution_counsel",
    "field_tactician",
    "scout",
    "red_team",
    "logistics_officer",
]
```

## GLM-5.2 Command Resolution

```python
def get_glm_command() -> list[str]:
    """
    Resolve GLM-5.2 invocation command with fallback.

    Priority:
    1. ccgd (alias) - if available in PATH
    2. claude-glm --dangerously-skip-permissions - explicit fallback
    3. ~/.local/bin/claude-glm - direct path fallback
    """
    import shutil
    from pathlib import Path

    # Check for alias
    if shutil.which("ccgd"):
        return ["ccgd", "-p"]

    # Check for script in PATH
    if shutil.which("claude-glm"):
        return ["claude-glm", "--dangerously-skip-permissions", "-p"]

    # Direct path fallback
    local_bin = Path.home() / ".local" / "bin" / "claude-glm"
    if local_bin.exists():
        return [str(local_bin), "--dangerously-skip-permissions", "-p"]

    raise RuntimeError(
        "GLM-5.2 not available. Install claude-glm or configure ccgd alias.\n"
        "Add to ~/.bashrc: alias ccgd='claude-glm --dangerously-skip-permissions'"
    )
```

## Expert Capabilities

| Expert | Context | Speed | Reasoning | Best For |
|--------|---------|-------|-----------|----------|
| Opus | Standard | Slow | Highest | Final synthesis, complex reasoning |
| Sonnet | Standard | Medium | High | Strategy, analysis |
| Gemini Pro | 1M+ | Medium | High | Large codebase analysis |
| GLM-5.2 | Standard | Medium | High | Implementation details |
| Qwen Turbo | Standard | Fast | Medium | Quick data gathering |
| Gemini Flash | Standard | Fast | Medium | Rapid challenges |
| Qwen Max | Standard | Medium | Medium-High | Thorough estimation |

## Phase-to-Expert Mapping

| Phase | Primary Expert(s) | Secondary |
|-------|-------------------|-----------|
| Intelligence | Scout, Intel Officer | - |
| Assessment | Chief Strategist | - |
| COA Development | Strategist, Tactician, Logistics | All available |
| Red Team | Red Team Commander | - |
| Voting | All active experts | - |
| Premortem | All active experts | - |
| Synthesis | Supreme Commander | - |

## Agent Teams Member Mapping

When using `--agent-teams`, experts map to Claude Code teammates. External LLM diversity is traded for real-time inter-expert messaging.

```python
AGENT_TEAMS_MEMBERS = {
    "supreme_commander": {
        "agent_name": "supreme-commander",
        "model": "opus",
        "role": "Lead agent (not spawned — IS the lead)",
    },
    "chief_strategist": {
        "agent_name": "chief-strategist",
        "model": "sonnet",
        "color": "#4ECDC4",
    },
    "intelligence_officer": {
        "agent_name": "intel-officer",
        "model": "sonnet",
        "color": "#45B7D1",
    },
    "field_tactician": {
        "agent_name": "field-tactician",
        "model": "sonnet",
        "color": "#96CEB4",
    },
    "scout": {
        "agent_name": "scout",
        "model": "haiku",
        "color": "#FFEAA7",
    },
    "red_team": {
        "agent_name": "red-team",
        "model": "sonnet",
        "color": "#FF6B6B",
    },
    "logistics_officer": {
        "agent_name": "logistics",
        "model": "haiku",
        "color": "#DDA0DD",
    },
}
```

### Model Selection Rationale

- **Opus** for Supreme Commander: highest reasoning for final synthesis
- **Sonnet** for Strategist, Intel, Tactician, Red Team: strong reasoning at moderate cost
- **Haiku** for Scout, Logistics: speed-critical roles with simpler reasoning needs

### Spawning Example

```bash
# Lead spawns chief-strategist teammate
tmux split-window -h "CLAUDECODE=1 CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 \
  claude --agent-id chief-strategist@war-room-20260208 \
         --agent-name chief-strategist \
         --team-name war-room-20260208 \
         --agent-color '#4ECDC4' \
         --parent-session-id $SESSION_ID \
         --model sonnet"
```

## Invocation Safety

All external experts are invoked using `asyncio.create_subprocess_exec` which:
- Does NOT use shell interpretation (no injection risk)
- Passes arguments as a list (safe)
- Captures stdout/stderr separately
- Handles timeouts gracefully

Agent teams teammates are invoked via `tmux split-window` with CLI identity flags: the same safety model applies (no shell interpretation of user input).

---
name: merkle-dag
description: Anonymization and version tracking for War Room deliberation using Merkle-DAG structure
category: war-room-module
tags: [anonymization, merkle, versioning, audit]
dependencies: []
estimated_tokens: 500
---

# Merkle-DAG Anonymization

## Purpose

Research shows LLMs exhibit "self-preference bias" - favoring their own outputs or outputs from the same model family. The Merkle-DAG structure:

1. **Anonymizes** contributions during deliberation
2. **Tracks versions** across rounds
3. **Verifies integrity** via cryptographic hashes
4. **Reveals attribution** only after decision

## Data Structure

```python
from dataclasses import dataclass, field
from datetime import datetime
from hashlib import sha256
from typing import Optional


@dataclass
class DeliberationNode:
    """A single contribution in the deliberation graph."""

    node_id: str  # Short hash (first 16 chars)
    parent_id: Optional[str]  # Previous version (for revisions)
    round_number: int  # Which deliberation round
    phase: str  # intel, coa, red_team, vote, premortem, synthesis

    # Anonymized during deliberation
    anonymous_label: str  # "Response A", "Expert 2", etc.
    content: str  # The actual contribution

    # Revealed after decision (sealed until then)
    expert_role: str  # "Intelligence Officer", "Red Team", etc.
    expert_model: str  # "gemini-3-pro", "qwen-turbo", etc.

    # Merkle linkage
    content_hash: str  # SHA-256 of content only
    metadata_hash: str  # SHA-256 of role + model
    combined_hash: str  # SHA-256 of content_hash + metadata_hash

    timestamp: str  # ISO format


@dataclass
class MerkleDAG:
    """Directed Acyclic Graph tracking deliberation history."""

    session_id: str
    sealed: bool = True  # Attribution hidden until unsealed
    root_hash: Optional[str] = None
    nodes: dict[str, DeliberationNode] = field(default_factory=dict)
    label_counter: dict[str, int] = field(default_factory=dict)

    def add_contribution(
        self,
        content: str,
        phase: str,
        round_number: int,
        expert_role: str,
        expert_model: str,
        parent_id: Optional[str] = None,
    ) -> DeliberationNode:
        """Add a contribution and compute hashes."""

        # Compute hashes
        content_hash = sha256(content.encode()).hexdigest()
        metadata_hash = sha256(f"{expert_role}:{expert_model}".encode()).hexdigest()
        combined_hash = sha256(f"{content_hash}:{metadata_hash}".encode()).hexdigest()

        # Generate anonymous label
        label = self._generate_label(phase)

        node = DeliberationNode(
            node_id=combined_hash[:16],
            parent_id=parent_id,
            round_number=round_number,
            phase=phase,
            anonymous_label=label,
            content=content,
            expert_role=expert_role,
            expert_model=expert_model,
            content_hash=content_hash,
            metadata_hash=metadata_hash,
            combined_hash=combined_hash,
            timestamp=datetime.now().isoformat(),
        )

        self.nodes[node.node_id] = node
        self._update_root_hash()
        return node

    def _generate_label(self, phase: str) -> str:
        """Generate anonymous label for phase."""
        if phase not in self.label_counter:
            self.label_counter[phase] = 0
        self.label_counter[phase] += 1
        count = self.label_counter[phase]

        # Use letters for COAs, numbers for others
        if phase == "coa":
            return f"Response {chr(64 + count)}"  # A, B, C...
        return f"Expert {count}"

    def _update_root_hash(self) -> None:
        """Update root hash from all leaf nodes."""
        if not self.nodes:
            self.root_hash = None
            return

        # Combine all node hashes
        combined = ":".join(sorted(n.combined_hash for n in self.nodes.values()))
        self.root_hash = sha256(combined.encode()).hexdigest()

    def get_anonymized_view(self) -> list[dict]:
        """Return contributions with attribution masked."""
        return [
            {
                "label": node.anonymous_label,
                "content": node.content,
                "phase": node.phase,
                "round": node.round_number,
                "hash": node.node_id,  # Verifiable but not attributable
            }
            for node in self.nodes.values()
        ]

    def unseal(self) -> list[dict]:
        """Reveal full attribution after decision is made."""
        self.sealed = False
        return [
            {
                "label": node.anonymous_label,
                "content": node.content,
                "phase": node.phase,
                "round": node.round_number,
                "expert_role": node.expert_role,
                "expert_model": node.expert_model,
                "hash": node.node_id,
                "verified": self._verify_node(node),
            }
            for node in self.nodes.values()
        ]

    def _verify_node(self, node: DeliberationNode) -> bool:
        """Verify node hash integrity."""
        expected_content = sha256(node.content.encode()).hexdigest()
        expected_meta = sha256(
            f"{node.expert_role}:{node.expert_model}".encode()
        ).hexdigest()
        expected_combined = sha256(
            f"{expected_content}:{expected_meta}".encode()
        ).hexdigest()
        return expected_combined[:16] == node.node_id
```

## Version Tracking

When experts revise their positions (Delphi mode):

```mermaid
flowchart LR
    subgraph Round1["Round 1"]
        A["COA-A (v1)<br/>hash: abc123<br/>parent: null"]
    end

    subgraph Round2["Round 2"]
        B["COA-A (v2)<br/>hash: def456<br/>parent: abc123"]
    end

    subgraph Round3["Round 3"]
        C["COA-A (v3)<br/>hash: ghi789<br/>parent: def456"]
    end

    A -->|revises| B
    B -->|revises| C

    C --> Root["Root Hash (Round 3)<br/>SHA256(all_leaf_hashes)"]
```

## Serialization

```python
def to_json(self) -> dict:
    """Serialize DAG for persistence."""
    return {
        "session_id": self.session_id,
        "sealed": self.sealed,
        "root_hash": self.root_hash,
        "nodes": {
            nid: {
                "node_id": n.node_id,
                "parent_id": n.parent_id,
                "round_number": n.round_number,
                "phase": n.phase,
                "anonymous_label": n.anonymous_label,
                "content": n.content,
                "expert_role": n.expert_role if not self.sealed else "[SEALED]",
                "expert_model": n.expert_model if not self.sealed else "[SEALED]",
                "content_hash": n.content_hash,
                "metadata_hash": n.metadata_hash,
                "combined_hash": n.combined_hash,
                "timestamp": n.timestamp,
            }
            for nid, n in self.nodes.items()
        },
    }
```

## Usage in Deliberation

### During COA Development (sealed)

```python
# Expert contributions are anonymized
dag.add_contribution(
    content=coa_response,
    phase="coa",
    round_number=1,
    expert_role="Field Tactician",
    expert_model="glm-5.2",
)

# Present to Red Team anonymized
anonymized = dag.get_anonymized_view()
# Returns: [{"label": "Response A", "content": "...", ...}]
```

### During Synthesis (unsealed)

```python
# Supreme Commander sees full attribution
revealed = dag.unseal()
# Returns: [{"label": "Response A", "expert_role": "Field Tactician", ...}]
```

## Integrity Verification

After session, verify no tampering:

```python
def verify_session_integrity(dag: MerkleDAG) -> bool:
    """Verify all nodes hash correctly."""
    for node in dag.nodes.values():
        if not dag._verify_node(node):
            return False
    return True
```

---
name: reversibility-assessment
description: Framework for evaluating decision reversibility and mapping to appropriate deliberation intensity
category: war-room-module
tags: [reversibility, type-1, type-2, decision-making, bezos-framework]
dependencies: []
estimated_tokens: 900
references:
  - https://fs.blog/reversible-irreversible-decisions/
  - https://tapandesai.com/one-way-two-way-doors-decision-making/
  - https://ashikuzzaman.com/2025/03/03/amazons-type-1-vs-type-2-decisions-a-framework-for-effective-decision-making/
---

# Reversibility Assessment Framework

Evaluate decision reversibility to calibrate deliberation intensity. Based on Amazon's Type 1/Type 2 framework with quantified scoring.

## Core Principle

> "Make reversible decisions as soon as possible and make irreversible decisions as late as possible."
> (Jeff Bezos)

**The Problem**: Organizations tend to apply heavyweight Type 1 processes to all decisions, stifling speed and innovation. This framework ensures resources match stakes.

## Reversibility Score (RS)

### Five Dimensions

Score each dimension on a 1-5 scale:

| Dimension | 1 (Highly Reversible) | 3 (Moderate) | 5 (Irreversible) |
|-----------|----------------------|--------------|------------------|
| **Reversal Cost** | Trivial (<1 day effort) | Significant (1-2 weeks) | Prohibitive (months+, major rework) |
| **Time Lock-In** | Can reverse anytime | Window narrows over weeks | Decision crystallizes immediately |
| **Blast Radius** | Single component/person | Team/subsystem affected | Organization/customer-wide |
| **Information Loss** | All options preserved | Some paths closed | Critical options eliminated |
| **Reputation Impact** | Internal only | Limited external visibility | Public commitment, trust at stake |

### Calculation

```
Reversibility Score (RS) = Sum of Dimensions / 25

RS Range: 0.04 (most reversible) to 1.0 (least reversible)
```

### Decision Type Classification

**Default Thresholds** (can be overridden at session start):

| RS Range | Type | Door Metaphor | Deliberation Mode |
|----------|------|---------------|-------------------|
| 0.04 - 0.40 | **Type 2** | Two-way door | Express (single expert) |
| 0.41 - 0.60 | **Type 1B** | Heavy door | Standard (lightweight panel) |
| 0.61 - 0.80 | **Type 1A** | One-way door | Full Council |
| 0.81 - 1.00 | **Type 1A+** | Locked vault | Full Council and Delphi |

> **Note**: These thresholds are defaults calibrated for general use. Teams with different risk tolerances can adjust at session initialization.

## Scoring Guide

### Reversal Cost

| Score | Description | Examples |
|-------|-------------|----------|
| 1 | Trivial - flip a switch | Feature flag, config change, UI tweak |
| 2 | Minor - hours of work | Revert a PR, rollback deployment |
| 3 | Moderate - days of work | Refactor a module, change API internally |
| 4 | Significant - weeks | Database migration rollback, contract renegotiation |
| 5 | Prohibitive - months+ | Rewrite architecture, undo public API, M&A |

### Time Lock-In

| Score | Description | Examples |
|-------|-------------|----------|
| 1 | No deadline pressure | Internal tool improvement |
| 2 | Soft deadline, flexible | Quarterly planning decision |
| 3 | Decision hardens over weeks | Hiring, vendor selection |
| 4 | Short window before lock | Product launch timing |
| 5 | Immediate crystallization | Crisis response, public announcement |

### Blast Radius

| Score | Description | Examples |
|-------|-------------|----------|
| 1 | Single file/component | Utility function implementation |
| 2 | Single module/service | Internal service refactor |
| 3 | Multiple modules/team | API contract change |
| 4 | Cross-team/system | Platform architecture |
| 5 | Organization/customers | Pricing model, security policy |

### Information Loss

| Score | Description | Examples |
|-------|-------------|----------|
| 1 | All options preserved | A/B test, experiment |
| 2 | Minor path closure | Choosing one of many equivalent libs |
| 3 | Some alternatives eliminated | Tech stack component selection |
| 4 | Significant option reduction | Monorepo vs polyrepo |
| 5 | Critical paths closed forever | Open source vs proprietary, cloud provider |

### Reputation Impact

| Score | Description | Examples |
|-------|-------------|----------|
| 1 | Internal, easily corrected | Internal process change |
| 2 | Internal, visible to leadership | Team restructuring |
| 3 | Limited external visibility | Beta feature to select customers |
| 4 | Moderate external impact | Public roadmap commitment |
| 5 | High visibility, trust at stake | Security incident response, pricing change |

## Example Assessments

### Example 1: Add retry logic to API client

| Dimension | Score | Rationale |
|-----------|-------|-----------|
| Reversal Cost | 1 | Can revert PR |
| Time Lock-In | 1 | No deadline |
| Blast Radius | 2 | Single service |
| Information Loss | 1 | All options preserved |
| Reputation Impact | 1 | Internal only |

**RS = 6/25 = 0.24 → Type 2 (Express)**

*Recommendation*: Chief Strategist can decide alone. Execute quickly.

---

### Example 2: Migrate from PostgreSQL to MongoDB

| Dimension | Score | Rationale |
|-----------|-------|-----------|
| Reversal Cost | 5 | Months of rework |
| Time Lock-In | 4 | Migration path hardens quickly |
| Blast Radius | 5 | All services affected |
| Information Loss | 4 | Query patterns, ACID guarantees |
| Reputation Impact | 2 | Internal (unless downtime) |

**RS = 20/25 = 0.80 → Type 1A (Full Council)**

*Recommendation*: Convene full council. Extensive Red Team review required.

---

### Example 3: Change public API pricing model

| Dimension | Score | Rationale |
|-----------|-------|-----------|
| Reversal Cost | 4 | Contract/billing rework |
| Time Lock-In | 5 | Announcement locks commitment |
| Blast Radius | 5 | All customers affected |
| Information Loss | 4 | Pricing flexibility reduced |
| Reputation Impact | 5 | Public trust at stake |

**RS = 23/25 = 0.92 → Type 1A+ (Full Council + Delphi)**

*Recommendation*: Maximum deliberation. Delphi convergence required. Consider external advisors.

## Integration with War Room

### Threshold Configuration

At session initialization, the War Room prompts for threshold customization:

```
War Room Session Initialization
═══════════════════════════════
Problem: [User's decision statement]

Reversibility Thresholds (press Enter for defaults):
  Express ceiling    [0.40]: _
  Lightweight ceiling [0.60]: _
  Full Council ceiling [0.80]: _

Using: express ≤0.40 | lightweight ≤0.60 | full_council ≤0.80 | delphi >0.80
```

**Common Adjustments:**

| Team Profile | Express | Lightweight | Full Council | Rationale |
|--------------|---------|-------------|--------------|-----------|
| **Default** | 0.40 | 0.60 | 0.80 | Balanced |
| **Move Fast** | 0.50 | 0.70 | 0.90 | Higher risk tolerance, faster decisions |
| **Risk Averse** | 0.30 | 0.50 | 0.70 | Lower thresholds, more deliberation |
| **Startup** | 0.55 | 0.75 | 0.90 | Speed over process |
| **Regulated** | 0.25 | 0.45 | 0.65 | Compliance-heavy, thorough review |

### Automatic Mode Selection

```python
def select_deliberation_mode(
    reversibility_score: float, thresholds: dict | None = None
) -> str:
    """Map RS to war room mode with configurable thresholds."""
    # Defaults (can be overridden at session start)
    t = thresholds or {
        "express": 0.40,
        "lightweight": 0.60,
        "full_council": 0.80,
    }

    if reversibility_score <= t["express"]:
        return "express"  # Single expert, immediate
    elif reversibility_score <= t["lightweight"]:
        return "lightweight"  # Default panel
    elif reversibility_score <= t["full_council"]:
        return "full_council"  # All experts
    else:
        return "full_council_delphi"  # Iterative convergence
```

### Escalation Override

Supreme Commander may override automatic classification when:
1. Novel domain with uncertain reversibility
2. Precedent-setting decision (future decisions will follow)
3. Compound decisions (multiple sub-decisions with varying RS)
4. Political/organizational sensitivity beyond technical scope

### Resource Allocation by Type

| Type | Experts | Rounds | Target Duration | Token Budget |
|------|---------|--------|-----------------|--------------|
| Express | 1 | 1 | < 2 min | 500 |
| Lightweight | 3 | 2 | 5-10 min | 2,500 |
| Full Council | 7 | 2 | 15-30 min | 8,000 |
| Full Council and Delphi | 7 | 3-5 | 30-60 min | 15,000 |

## Quick Assessment Heuristics

For rapid classification without full scoring:

### Likely Type 2 (Two-Way Door)
- Can be A/B tested
- Affects only internal systems
- Has natural rollback mechanism
- No public announcement required
- Team-level decision authority

### Likely Type 1 (One-Way Door)
- Requires data migration
- Changes external contracts/APIs
- Involves personnel decisions (hiring/firing)
- Requires public commitment
- Affects security/compliance posture
- Closes off future architectural options

## Anti-Patterns

### Over-Classification (Most Common)

**Symptom**: Treating everything as Type 1
**Impact**: Slow decisions, missed opportunities, innovation stagnation
**Fix**: Default to Type 2 unless specific irreversibility criteria met

### Under-Classification

**Symptom**: Rushing irreversible decisions
**Impact**: Costly mistakes, rework, reputation damage
**Fix**: When uncertain, score the dimensions explicitly

### False Reversibility

**Symptom**: "We can always change it later" without considering cost
**Impact**: Technical debt accumulation, stranded investments
**Fix**: Explicitly score Reversal Cost dimension

## STOP-LOP-KNOW Triggers

For Type 1 decisions, finalize when:

1. **STOP**: Information gathering has plateaued (diminishing returns)
2. **LOP**: Losing meaningful opportunities by waiting
3. **KNOW**: Clarity has emerged about the right choice

Do NOT wait for 100% certainty on Type 1 decisions: wait for the right moment.

## Audit Trail

All reversibility assessments are logged:

```yaml
assessment:
  session_id: war-room-20260122-143022
  decision: "Database migration strategy"
  dimensions:
    reversal_cost: 5
    time_lock_in: 4
    blast_radius: 5
    information_loss: 4
    reputation_impact: 2
  reversibility_score: 0.80
  decision_type: "Type 1A"
  deliberation_mode: "full_council"
  assessor: "Chief Strategist"
  override: null
  timestamp: "2026-01-22T14:30:22Z"
```