К основному содержанию
скилл CX Codex

war-room-checkpoint — скилл для Claude Code: оценка риска решений

Скилл war-room-checkpoint считает, насколько дорого откатить решение, и решает, нужен ли полный разбор War Room или хватит быстрой рекомендации.

MIT 2 установок ★ 350 обновлён 2026-10-29

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add athola/claude-night-market --skill war-room-checkpoint -a claude-code
Открыть на GitHub

Что делает war-room-checkpoint

Скилл-библиотека: сам по себе он не вызывается. Его дёргают команды вроде /do-issue, /pr-review, /architecture-review и /fix-pr в тот момент, когда откат решения становится дорогим. Оценка идёт по пяти измерениям: цена отката, фиксация во времени, радиус поражения, потеря информации, репутация. Каждое от 1 до 5, итог — сумма, делённая на 25.

Дальше балл сравнивается с порогами профиля. У default это 0.40, 0.60 и 0.80, у regulated — 0.25, 0.45 и 0.65, свои значения у startup, fast и cautious. Вызывающая команда может сдвинуть границу: три и более задачи в /do-issue опускают её на 0.10, строгий /pr-review на 0.15, /architecture-review на 0.05. Под порогом возвращается короткая рекомендация express, выше — эскалация в attune:war-room в режиме lightweight, full_council или delphi.

Эскалация упирается в зависимость от attune:war-room: без этого плагина отправлять решение некуда. Если сам чекпоинт не отработал, команда пишет предупреждение и идёт дальше, поэтому рабочий процесс на нём не висит. Каждый чекпоинт сохраняется в ~/.claude/memory-palace/strategeion/checkpoints/{date}/{checkpoint-id}.json, а логику подсчёта после правок проверяет make attune-test из корня репозитория.

Какие задачи решает

  • посчитать балл обратимости решения перед слиянием ветки
  • понять, когда /do-issue с тремя задачами пора эскалировать
  • снизить порог разбора для строгого /pr-review
  • сохранить чекпоинт в аудит-лог с датой и id
  • довести команду до конца, если чекпоинт не отработал

Примеры запросов агенту

  • Прогони /do-issue по трём задачам и перед выбором порядка подключи war-room-checkpoint с профилем regulated.
  • Запусти /pr-review в строгом режиме: если блокирующих замечаний больше трёх, нужен чекпоинт с эскалацией.
  • Вызови Skill(attune:war-room-checkpoint) для решения «менять ли публичный API»: source_command — /architecture-review, профиль cautious.

Как установить war-room-checkpoint

1Через Skills CLI (Vercel)

npx skills add athola/claude-night-market --skill war-room-checkpoint -a claude-code

2Вручную: положить файлы

~/.claude/skills/war-room-checkpoint/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/war-room-checkpoint/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о war-room-checkpoint

Как установить war-room-checkpoint в Claude Code?

Выполните npx skills add athola/claude-night-market --skill war-room-checkpoint -a claude-code, файл скилла окажется в ~/.claude/skills/war-room-checkpoint/SKILL.md.

Что делает war-room-checkpoint?

Считает балл обратимости по пяти измерениям и по порогам профиля решает: вернуть быструю рекомендацию или передать вопрос в полный War Room.

Чем он отличается от attune:war-room?

Этот скилл только определяет, нужен ли разбор, и быстро отвечает, когда разбор не нужен. Сам разбор выполняет attune:war-room, от которого он зависит.

Исходный текст

SKILL.md · MIT
---
name: war-room-checkpoint
description: Assesses decision reversibility and risk at critical checkpoints. Use when a workflow reaches a high-stakes branch needing escalation check.
alwaysApply: false
# Custom metadata (not used by Claude for matching):
category: strategic-planning
tags: [checkpoint, embedded, escalation, reversibility, inline]
dependencies:
  - attune:war-room
complexity: lightweight
model_hint: fast
estimated_tokens: 400
progressive_loading: false
role: library
---
# War Room Checkpoint Skill

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

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

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

## When NOT To Use

| Situation | Use instead |
|-----------|-------------|
| A user asks for deliberation directly | `Skill(attune:war-room)` |
| The decision is cheap to reverse (high RS) | Proceed without a checkpoint |
| A panel already ruled on this decision | The prior verdict |

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

```markdown
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, with any command adjustment, to determine
mode. Compare in integer hundredths: in floats, the cautious express
ceiling 0.30 with the do-issue adjustment -0.10 is
0.19999999999999998, and an all-1s decision (RS = 0.2) would escalate.

```
# Inputs: score_sum (Step 2), profile (the profile table below), and
# command_adjustment (Command-Specific Adjustments, 0 when none applies).
rs_pct = 4 * score_sum  # RS * 100, exact for Sum / 25
adjustment = command_adjustment

def ceiling_pct(ceiling, adjustment):  # table values in hundredths
    return round(ceiling * 100) + round(adjustment * 100)

if rs_pct <= ceiling_pct(profile.express, adjustment):
    mode = "express"
elif rs_pct <= ceiling_pct(profile.lightweight, adjustment):
    mode = "lightweight"
elif rs_pct <= ceiling_pct(profile.full_council, adjustment):
    mode = "full_council"
else:
    mode = "delphi"
```

### Step 4: Response Generation

#### Express Mode (RS <= threshold)

Return immediately with recommendation:

```yaml
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:

```yaml
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:

```markdown
## 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

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:

```python
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**:
```yaml
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**:
```yaml
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**:
```yaml
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**:
```yaml
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), `selected_mode` (express / lightweight / full_council / delphi), `should_escalate`
  (boolean), and `recommendation` or `orders`.
- [ ] Any response with `reversibility_score` > profile threshold has `should_escalate: true`
  and triggers the full War Room via `Skill(attune:war-room)` before returning.
- [ ] Any response with `confidence` <= 0.8 sets `requires_user_confirmation: 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.

© athola · MIT · athola/claude-night-market

Похожие скиллы

Все скиллы по теме «Настройка агента: память, контекст, субагенты» →
checkpoint codewithmukesh Скилл checkpoint делает git-коммит с описанием и короткую заметку о состоянии работы, не завершая сессию. Пригодится перед рискованным рефактором. CX Codex +1 4 000установок scenario-war-room Alireza Rezvani Скилл scenario-war-room для Claude Code моделирует цепочки последствий, когда несколько рисков могут сработать одновременно. Он подключается к сложным сценариям и стратегическим решениям с серьёзными рисками. CX Codex +1 574установок product-launch-war-room OneWave-AI Скилл product-launch-war-room для Claude Code собирает экспертные и клиентские мнения о запуске и выдаёт решение с планом выката. Запускайте его перед запуском продукта, сменой цены или позиционирования. CX Codex +1 159установок promote-checkpoint Seth Hobson Команда promote-checkpoint для Claude Code, Codex и Cursor, которая прогоняет существующий дообученный чекпоинт через актуальный eval-стенд и экспортирует его при вердикте PROMOTE. CX Codex +1 ★ 42 780звёзд репо scientific-problem-selection официальный anthropics Скилл scientific-problem-selection для Claude Code структурирует выбор исследовательских проблем — от генерации идей до разбора застрявшего проекта и стратегических вопросов. CX Codex +1 2 600установок review entireio Скилл review для Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI и OpenCode проверяет изменения текущей ветки с учётом контекста checkpoint. Запускается перед слиянием ветки. CX Codex +1 474установок

Из того же набора7

shell-review Скилл shell-review аудирует шелл-скрипты на маскировку кодов возврата, переносимость POSIX и безопасность перед коммитом. CX Codex +1 1установок review-chamber Скилл review-chamber сохраняет важные выводы из ревью PR и помогает находить их при дальнейшей работе. Подходит для фиксации архитектурных решений, повторяющихся проблем и стандартов кода. CX Codex +1 1установок delegation-core Скилл delegation-core делегирует задачи восьми внешним CLI (Gemini, Qwen, MiniMax, GLM, Muse, Codex, OpenCode, Glimmer). Оставляет проектирование и архитектуру локально, отправляет исполнение. CX Codex +1 1установок war-room Скилл war-room созывает совет из нескольких LLM для проверки труднообратимых архитектурных решений через оценку обратимости и оппонирование. CX Codex +1 1установок skills-eval Скилл skills-eval для Claude Code проверяет структуру, расход токенов и интеграцию инструментов в других скиллах. Находит проблемы и составляет план исправлений. CX Codex +1 1установок precommit-setup Скилл precommit-setup настраивает трёхуровневую систему pre-commit хуков: линтинг, проверку типов и тесты перед каждым коммитом. CX Codex +1 1установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой