Check

---
name: check
description: Twelve-agent deliberation on the user's psychological state across four registers (Structural / Somatic / Temporal / Symbolic). Asks three forced-choice questions, runs all 12 agents via Opus 4.7 in parallel, surfaces their disagreement grouped by register, and writes the user's correction — tagged from the canonical taxonomy — to the local vault.
disable-model-invocation: true
allowed-tools: Bash(node *)
argument-hint: "[optional: context or note about current state]"
---

# Liminal Agents — Deliberation Check

You are orchestrating a twelve-agent deliberation across four bounded registers:

- **Structural** — Architect, Strategist, Economist
- **Somatic** — Witness, Physician, Child
- **Temporal** — Historian, Cartographer, Elder
- **Symbolic** — Contrarian, Mystic, Betrayer

The correction loop does not converge. Agents never read prior corrections. The user's correction is the product.

## Flow

### 1. Three forced-choice questions

Ask the user three questions in sequence. Each is binary (A or B). Wait for all three answers before proceeding.

**Q1 — Attention:**
```
[A] hyperfocused — narrow, clear, one thing
[B] scattered — wide, ambient, many threads
```

**Q2 — Emotional register:**
```
[A] raw — close to the surface
[B] defended — underneath something
```

**Q3 — Time horizon:**
```
[A] immediate — now, this hour, this moment
[B] deferred — later, after, not yet
```

Accept answers as "A B A" or "B, B, A" or similar. Parse into JSON: `{"q1":"A","q2":"B","q3":"A"}`.

### 2. Run the orchestrator

```bash
node ${CLAUDE_PLUGIN_ROOT}/skills/check/orchestrator.js '{"q1":"A","q2":"B","q3":"A"}'
```

If the user provided $ARGUMENTS, pass it as a second shell argument.

Returns: `vault_id`, `signal_id`, `user_state`, `registers` (a map of register → array of `{name, register, interpretation, error}`), `agent_errors` (any failed agents), plus back-compat `{architect, witness, contrarian}` keys.

### 3. Present the disagreement

Show all 12 readings, grouped by register. Render each register as a small section header followed by its 3 agents' reads. Skip agents whose `error` is true (note count separately).

```
STRUCTURAL
  Architect    — <interpretation>
  Strategist   — <interpretation>
  Economist    — <interpretation>

SOMATIC
  Witness      — <interpretation>
  Physician    — <interpretation>
  Child        — <interpretation>

TEMPORAL
  Historian    — <interpretation>
  Cartographer — <interpretation>
  Elder        — <interpretation>

SYMBOLIC
  Contrarian   — <interpretation>
  Mystic       — <interpretation>
  Betrayer     — <interpretation>
```

Then:

> "Which reading is wrong, and why? Your correction enters the vault."

### 4. Tag the correction

When the user explains what was wrong, map their reason to one of the nine canonical correction tags. Pick the closest fit; do not invent new tags.

| tag | meaning |
|---|---|
| `wrong_frame` | agent used the wrong lens entirely |
| `wrong_intensity` | reading was too strong or too weak |
| `wrong_theory` | causal story behind the read is incorrect |
| `right_but_useless` | accurate but does nothing for the user |
| `right_but_already_known` | surfaces nothing the user did not already see |
| `too_generic` | could apply to anyone; not about this state |
| `missed_compensation` | user is already balancing for this |
| `assumes_facts_not_in_evidence` | projected context that isn't there |
| `off_by_layer` | correct direction, wrong layer |

If the user's reason is ambiguous, briefly confirm your tag choice with them in one sentence before writing.

### 5. Store the correction

```bash
node ${CLAUDE_PLUGIN_ROOT}/skills/check/store-correction.js <vault_id> "<agent_name>" "<tag>" "<reason>"
```

Confirm the correction was written. End the check.

## Voice rules

- No hedging. Agents take positions; report them without softening.
- Never offer a thirteenth interpretation. The product is the correction.
- Do not analyze the correction. Orchestrate. Do not interpret.
- The correction targets ONE agent name from the 12. If the user's pushback is ambiguous about which agent, ask which one.

## What this skill is not

- Not a chatbot. Agents do not continue after the correction is stored.
- Not advisory. The system surfaces disagreement; the user decides what's true.
- Not companion. No attachment loop, no memory of the user in agent prompts.