War Room Checkpoint Skill

Lightweight inline assessment for determining whether a decision point within a command warrants War Room escalation.

Table of Contents

1. [Purpose](#purpose)
2. [When Commands Should Invoke This](#when-commands-should-invoke-this)
3. [Invocation Pattern](#invocation-pattern)
4. [Checkpoint Flow](#checkpoint-flow)
5. [Confidence Calculation](#confidence-calculation)
6. [Profile Thresholds](#profile-thresholds)
7. [Output Format](#output-format)
8. [Examples](#examples)

Verification

Run make attune-test from the repository root to verify checkpoint logic still works after changes.

Purpose

This skill is not invoked directly by users. It is called by other commands (e.g., /do-issue, /pr-review) at critical decision points to:

1. Calculate Reversibility Score (RS) for the current context
2. Determine if full War Room deliberation is needed
3. Return either a quick recommendation (express) or escalate to full War Room

When Commands Should Invoke This

When NOT To Use

This skill decides whether deliberation is warranted and returns fast when it is not. A command that checkpoints every decision pays the scoring cost to be told to proceed almost every time, and re-checkpointing a settled call re-litigates it.

Invocation Pattern

Skill(attune:war-room-checkpoint) with context:
  - source_command: "{calling_command}"
  - decision_needed: "{human_readable_question}"
  - files_affected: [{list_of_files}]
  - issues_involved: [{issue_numbers}] (if applicable)
  - blocking_items: [{type, description}] (if applicable)
  - conflict_description: "{summary}" (if applicable)
  - profile: "default" | "startup" | "regulated" | "fast" | "cautious"

Checkpoint Flow

Step 1: Context Analysis

Analyze the provided context to extract:

• Scope of change (files, modules, services affected)
• Stakeholders impacted
• Conflict indicators
• Time pressure signals

Step 2: Reversibility Assessment

Calculate RS using the 5-dimension framework:

Score each 1-5, calculate RS = Sum / 25.

Step 3: Mode Selection

Apply profile thresholds to determine mode:

if RS <= profile.express_ceiling:
    mode = "express"
elif RS <= profile.lightweight_ceiling:
    mode = "lightweight"
elif RS <= profile.full_council_ceiling:
    mode = "full_council"
else:
    mode = "delphi"

Step 4: Response Generation

Express Mode (RS <= threshold)

Return immediately with recommendation:

response:
  should_escalate: false
  selected_mode: "express"
  reversibility_score: {rs}
  decision_type: "Type 2"
  recommendation: "{quick_recommendation}"
  rationale: "{brief_explanation}"
  confidence: 0.9
  requires_user_confirmation: false

Escalate Mode (RS > threshold)

Invoke full War Room and return results:

response:
  should_escalate: true
  selected_mode: "{lightweight|full_council|delphi}"
  reversibility_score: {rs}
  decision_type: "{Type 1B|1A|1A+}"
  war_room_session_id: "{session_id}"
  orders: ["{order_1}", "{order_2}"]
  rationale: "{war_room_rationale}"
  confidence: {calculated_confidence}
  requires_user_confirmation: {true_if_confidence_low}

Confidence Calculation

For escalated decisions, calculate confidence for auto-continue:

confidence = 1.0
- 0.10 * dissenting_view_count
- 0.20 if voting_margin < 0.3
- 0.15 if RS > 0.80
- 0.10 if novel_domain
- 0.10 if compound_decision
+ 0.20 if unanimous (cap at 1.0)

requires_user_confirmation = (confidence <= 0.8)

Profile Thresholds

Command-Specific Adjustments

Output Format

For Calling Command

Return a structured response that the calling command can act on:

## Checkpoint Response

**Source**: {source_command}
**Decision**: {decision_needed}

### Assessment
- **RS**: {reversibility_score} ({decision_type})
- **Mode**: {selected_mode}
- **Escalated**: {yes|no}

### Recommendation
{recommendation_or_orders}

### Control Flow
- **Confidence**: {confidence}
- **Auto-continue**: {yes|no}
{user_prompt_if_needed}

Integration Notes

Calling Commands Should

1. Check checkpoint response's requiresuserconfirmation
2. If true: present confirmation prompt and wait
3. If false: continue with orders or recommendation
4. Log checkpoint to audit trail

Failure Handling

If checkpoint invocation fails:

• Log warning with context
• Continue command execution without checkpoint
• Do NOT block the user's workflow

Audit Trail

Checkpoints are logged to:

~/.claude/memory-palace/strategeion/checkpoints/{date}/{checkpoint-id}.json

Each file contains a CheckpointEntry with: checkpointid, sessionid, phase, action, reversibilityscore, dimensions, confidence, filesaffected, and requiresuserconfirmation.

After a war room session completes and persist_session() is called, an audit report is written automatically to:

~/.claude/memory-palace/strategeion/war-table/{session-id}/audit-report.json

The report consolidates: all checkpoints for the session, the expert panel, voting summary with unanimity score, escalation history, final decision and rationale, and a Merkle-DAG integrity verification block. The verification recomputes every node hash against the stored values so any tampering with deliberation content is detectable.

Use AuditTrailManager from scripts.warroom.audittrail to query checkpoints or generate reports programmatically:

from scripts.war_room.audit_trail import AuditTrailManager
manager = AuditTrailManager()
checkpoints = manager.get_checkpoints("war-room-20260303-100000")
audited = manager.list_audited_sessions()

Examples

Example 1: Low RS (Express)

Input:

source_command: "do-issue"
decision_needed: "Execution order for issues #101, #102"
issues_involved: [101, 102]
files_affected: ["src/utils/helper.py", "tests/test_helper.py"]

Assessment:

• Reversal Cost: 1 (can revert commits)
• Time Lock-In: 1 (no deadline)
• Blast Radius: 1 (single utility module)
• Information Loss: 1 (all options preserved)
• Reputation Impact: 1 (internal)

RS: 0.20 (Type 2)

Response:

should_escalate: false
selected_mode: "express"
recommendation: "Execute in parallel - no dependencies detected"
confidence: 0.95
requires_user_confirmation: false

Example 2: High RS (Escalate)

Input:

source_command: "pr-review"
decision_needed: "Review verdict for PR #456"
blocking_items:
  - {type: "architecture", description: "New service without ADR"}
  - {type: "breaking", description: "API contract change"}
  - {type: "security", description: "Auth flow modification"}
  - {type: "scope", description: "Unrelated payment refactor"}
files_affected: ["src/auth/", "src/api/", "src/payment/", "src/services/new/"]

Assessment:

• Reversal Cost: 4 (multi-service impact)
• Time Lock-In: 3 (PR deadline pressure)
• Blast Radius: 4 (cross-team impact)
• Information Loss: 3 (some paths closing)
• Reputation Impact: 2 (internal review)

RS: 0.64 (Type 1A)

Response:

should_escalate: true
selected_mode: "full_council"
war_room_session_id: "war-room-20260125-143025"
orders:
  - "Split PR: auth changes separate from payment refactor"
  - "Require ADR for new service before merge"
  - "API change: add migration path, not blocking"
confidence: 0.75
requires_user_confirmation: true

Related Skills

• Skill(attune:war-room) - Full War Room deliberation
• Skill(attune:war-room)/modules/reversibility-assessment.md - RS framework

Related Commands

• /attune:war-room - Standalone War Room invocation
• /do-issue - Issue implementation (uses this checkpoint)
• /pr-review - PR review (uses this checkpoint)
• /architecture-review - Architecture review (uses this checkpoint)
• /fix-pr - PR fix (uses this checkpoint)

Exit Criteria

• A structured checkpoint response is returned with all required fields: reversibility_score

(0.0-1.0), selectedmode (express / lightweight / fullcouncil / delphi), should_escalate (boolean), and recommendation or orders.

• Any response with reversibilityscore > profile threshold has shouldescalate: true

and triggers the full War Room via Skill(attune:war-room) before returning.

• Any response with confidence <= 0.8 sets requiresuserconfirmation: true and presents

a confirmation prompt to the user rather than auto-continuing.

• The checkpoint is logged to

~/.claude/memory-palace/strategeion/checkpoints/{date}/{checkpoint-id}.json; if this write fails, the calling command proceeds and logs a warning rather than blocking the workflow.