/realize

name: realize
description: This skill should be used when the user asks to "run the eval", "test whether the protocol actually works at runtime", "check type realization", "measure protocol fulfillment", "run the type-realization suite", "does the gate actually stop", or wants runtime evidence that a protocol's formal transition contract is realized rather than an assessment of downstream artifact quality. Invoke explicitly with /realize and a skill argument.
allowed-tools: Read, Grep, Glob, Bash

Type Realization

Measure whether one named protocol skill's declared contract is realized during an actual run. The first argument is required; `/realize inquire` selects only the registered `inquire` cases and graders. An unknown or omitted target fails before setup.

Purpose

A protocol's formal blocks are runtime-normative: TYPES, PHASE TRANSITIONS, TOOL GROUNDING and the Rules type the prose and carry the operational contract. Static checks establish that a `SKILL.md` contains those blocks and enforce a bounded set of structural invariants. Nothing establishes that a run follows their transitions.

This skill supplies evidence for that gap. It drives Claude Code or Codex across a matrix of models and treatments, captures the JSONL trace, grades the deterministically observable subset, and names the transcript judgments still owed. A complete automatic cell can establish that collection occurred, the declared branch reached `Stop`, or the zero-uncertainty branch reached `Proceed`; semantic ordering and rendered type coverage remain manual until their specified judges are built.

Judgment boundary

The object of judgment is the formal transition trace:

X → context sufficiency → evidence collection as needed → residual deficit
  → formal branch → Stop | Proceed

Every score attaches to a node or edge in that trace. Once the selected branch is observable, judgment ends. A plan, implementation, analysis, or other downstream artifact is evidence that `Proceed` occurred; its quality, correctness, completeness, and usefulness are outside `/realize`. Likewise, an unchanged substrate is evidence of `Stop` only where the case granted the capability to proceed and the formal branch required stopping. `references/grader-design.md` carries the witness design and the separate oracle that artifact-quality evaluation would require.

When it applies

Reach for this after changing a protocol's phase structure, terminal conditions, gate definition, or answer types — the places where a contract can become unrealizable without any static check noticing. Reach for it also when adopting a new model, where the question is whether the contract still holds on it.

Do not reach for it to check that a file is well-formed. That is `/verify`, it is free, and it runs on every commit.

Workflow

cd .claude/skills/realize/scripts

./setup.sh inquire                           # default Claude runner
export CLAUDE_CODE_OAUTH_TOKEN="$(...)" && ./run.sh inquire

REALIZE_RUNNER=codex ./setup.sh inquire      # no credential consumed or stored
REALIZE_RUNNER=codex ./run.sh inquire        # borrows this machine's codex login
REALIZE_RUNNER=codex ./teardown.sh inquire

./teardown.sh inquire                        # Claude volatile state

For Claude, `setup.sh` prints the one interactive step — obtaining a token against the target-specific isolated config directory. For Codex, setup creates bare/protocol homes and installs the local protocol plugin only into the protocol home without reading or writing a credential. `run.sh` authenticates each `codex exec` child with the codex login already on this machine (`codex login --device-auth` signs one in; the harness never calls `codex login`), symlinked into the arm's disposable home only for the span of each `codex exec` — never copied, because a ChatGPT login rotates its refresh token and a copy would strand the real one. `references/runbook.md` carries why that keeps the homes isolated.

Read `references/runbook.md` before the first run. It records where runner isolation lives, where the budget floor sits, and what each column of the report asserts.

From CI

`.github/workflows/type-realization.yml` runs the Claude path on manual dispatch and comments the report on the PR. Codex remains local-only until the matrix can run behind the official action's credential proxy; repository-controlled harness code does not receive an OpenAI key in Actions.

Configuration

`harness.config.json` carries shared runner settings and a target registry. Each target owns its plugin directory, skill id, invocation, and case set. `REALIZE_RUNNER=codex` selects the committed Luna xhigh profile. Results are keyed by target, runner, the case's subject-facing files (prompt and replies after frontmatter, case.yaml, the scaffold script), and a hash of the actual protocol/style treatment — for protocol arms, the skill's `references/` too — so one skill, ablation, or edited case cannot reuse another's cache.

Prefer a capable model for the primary measurement. The weakest available one exercises the safeguards but not the protocol, so a failure there cannot separate a defect in the contract from a limit of the model.

Arms

Claude has four arms crossing the protocol against the Epistemic Ink output style, and one that removes the protocol's formal blocks. The style ships in the cc-plugin marketplace's `ink-figure` plugin; `styleSource` in `harness.config.json` names the file the style arms read, so those arms need that marketplace installed:

| arm | protocol | style | answers | |---|---|---|---| | `bare` | — | — | baseline | | `style` | — | ✓ | sham — is the structure coming from form alone? | | `protocol` | ✓ | — | is the `SKILL.md` self-contained, as required? | | `protocol+style` | ✓ | ✓ | the deployed configuration | | `protocol-prose` | ✓, every ```` ```lean ```` block removed | — | what the formal blocks add over the same `SKILL.md` prose |

`protocol-p