Get the FREE Ultimate OpenClaw Setup Guide →
npx machina-cli add skill athola/claude-night-market/war-room-checkpoint --openclaw
Files (1)
SKILL.md
8.2 KB

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
  2. When Commands Should Invoke This
  3. Invocation Pattern
  4. Checkpoint Flow
  5. Confidence Calculation
  6. Profile Thresholds
  7. Output Format
  8. Examples

Verification

Run make test-checkpoint to verify checkpoint logic works correctly 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

CommandTrigger Conditions
/do-issue3+ issues, dependency conflicts, overlapping files
/pr-review>3 blocking issues, architecture changes, ADR violations
/architecture-reviewADR violations, high coupling, boundary violations
/fix-prMajor scope, conflicting reviewer feedback

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:

DimensionAssessment Question
Reversal CostHow hard to undo this decision?
Time Lock-InDoes this crystallize immediately?
Blast RadiusHow many components/people affected?
Information LossDoes this close off future options?
Reputation ImpactIs this visible externally?

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

ProfileExpressLightweightFull CouncilUse Case
default0.400.600.80Balanced
startup0.550.750.90Move fast
regulated0.250.450.65Compliance
fast0.500.700.90Speed priority
cautious0.300.500.70Higher stakes

Command-Specific Adjustments

CommandAdjustmentRationale
do-issue (3+ issues)-0.10Higher risk with multiple issues
pr-review (strict mode)-0.15Strict mode = higher scrutiny
architecture-review-0.05Architecture inherently consequential

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 requires_user_confirmation
  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

All checkpoints are logged to:

~/.claude/memory-palace/strategeion/checkpoints/{date}/{session-id}.yaml

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)

Source

git clone https://github.com/athola/claude-night-market/blob/master/plugins/attune/skills/war-room-checkpoint/SKILL.mdView on GitHub

Overview

War Room Checkpoint is a lightweight inline assessment that decides whether a command should escalate to War Room. It computes a Reversibility Score (RS) across five dimensions at critical decision points and then returns a quick recommendation or triggers full War Room deliberation. It is invoked by other commands (not directly by users) to manage escalation risk at decision points.

How This Skill Works

When invoked, you supply context such as source_command, decision_needed, files_affected, issues_involved, blocking_items, conflict_description, and profile. The skill scores five dimensions (Reversal Cost, Time Lock-In, Blast Radius, Information Loss, Reputation Impact) on a 1-5 scale, calculates RS = Sum/25, and selects a mode using profile thresholds (express, lightweight, full_council, delphi). It then returns either a quick express recommendation or a full War Room escalation payload with session details and orders if escalation is warranted.

When to Use It

  • In /do-issue when there are 3+ issues, dependency conflicts, or overlapping files to decide escalation needs.
  • In /pr-review when there are more than 3 blocking issues, architecture changes, or ADR violations requiring higher oversight.
  • In /architecture-review when ADR violations, high coupling, or boundary violations trigger a strategic check.
  • In /fix-pr when the change scope is major or reviewer feedback is conflicting, necessitating escalation.
  • At any critical decision point where a reversible outcome must be weighed and a War Room deliberation may be needed.

Quick Start

  1. Step 1: Gather context from the calling command (source_command, decision_needed, files_affected, issues_involved, blocking_items, profile).
  2. Step 2: Invoke Skill(attune:war-room-checkpoint) with the prepared context and review the returned mode and recommendation.
  3. Step 3: If express or lightweight, act on the quick recommendation; if escalation is indicated, follow the War Room payload (session_id, orders).

Best Practices

  • Always provide complete context fields: source_command, decision_needed, files_affected, issues_involved, blocking_items, conflict_description, and profile.
  • Ensure the five RS dimensions are meaningfully populated (1-5) to avoid skewed results.
  • Choose an appropriate profile (default, startup, regulated, fast, cautious) based on risk tolerance and project context.
  • Prefer express mode for low RS and escalate to War Room for higher RS to prevent risky reversals.
  • Do not use this for standalone strategic decisions; it is designed for embedded escalation at decision points within commands.

Example Use Cases

  • A /do-issue run with 4 issues and a couple of dependency conflicts returns an express recommendation (no War Room) when RS is low.
  • A /pr-review with multiple blocking issues and architecture changes yields a lightweight mode suggestion, prompting targeted quick fixes.
  • An /architecture-review with ADR violations and high coupling triggers full_council mode and a War Room session with session_id and orders.
  • A /fix-pr involving major scope and conflicting reviewer feedback escalates to delphi for comprehensive War Room deliberation.
  • An embedded decision point detects significant risk across components and escalates to War Room with a session and ordered actions for remediation.

Frequently Asked Questions

Add this skill to your agents

Related Skills

Sponsor this space

Reach thousands of developers