Skills war-room-checkpoint

install

source · Clone the upstream repo

git clone https://github.com/openclaw/skills

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/openclaw/skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/athola/nm-attune-war-room-checkpoint" ~/.claude/skills/clawdbot-skills-war-room-checkpoint && rm -rf "$T"

manifest: skills/athola/nm-attune-war-room-checkpoint/SKILL.md

source content

Night Market Skill — ported from claude-night-market/attune. For the full experience with agents, hooks, and commands, install the Claude Code plugin.

War Room Checkpoint Skill

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

Purpose
When Commands Should Invoke This
Invocation Pattern
Checkpoint Flow
Confidence Calculation
Profile Thresholds
Output Format
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:

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

When Commands Should Invoke This

Command	Trigger Conditions
`/do-issue`	3+ issues, dependency conflicts, overlapping files
`/pr-review`	>3 blocking issues, architecture changes, ADR violations
`/architecture-review`	ADR violations, high coupling, boundary violations
`/fix-pr`	Major 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:

Dimension	Assessment Question
Reversal Cost	How hard to undo this decision?
Time Lock-In	Does this crystallize immediately?
Blast Radius	How many components/people affected?
Information Loss	Does this close off future options?
Reputation Impact	Is 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

Profile	Express	Lightweight	Full Council	Use Case
default	0.40	0.60	0.80	Balanced
startup	0.55	0.75	0.90	Move fast
regulated	0.25	0.45	0.65	Compliance
fast	0.50	0.70	0.90	Speed priority
cautious	0.30	0.50	0.70	Higher stakes

Command-Specific Adjustments

Command	Adjustment	Rationale
do-issue (3+ issues)	-0.10	Higher risk with multiple issues
pr-review (strict mode)	-0.15	Strict mode = higher scrutiny
architecture-review	-0.05	Architecture 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

Check checkpoint response's
```
requires_user_confirmation
```
If true: present confirmation prompt and wait
If false: continue with
```
orders
```
or
```
recommendation
```
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:

checkpoint_id

session_id

phase

action

reversibility_score

dimensions

confidence

files_affected

, and

requires_user_confirmation

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.war_room.audit_trail

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)