Embed badge
Show
Style
[](https://versuz.dev/claude-md/jongwony-epistemic-protocols)A CLAUDE.md is just a markdown file at the root of your repo. Copy the content below into your own project's CLAUDE.md to give your agent the same context.
npx versuz@latest install jongwony-epistemic-protocols --kind=claude-mdcurl -o CLAUDE.md https://raw.githubusercontent.com/jongwony/epistemic-protocols/HEAD/CLAUDE.md# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Northstar
Epistemic Protocols is a domain-free metalanguage of structured types and morphisms for human-AI collaboration: it constrains AI attention without bias, elicits unknowns into utterance, and reflexively re-forms misalignment within the loop — the loop dissolves compounding cost before it forces whole-system refactoring.
## Project Overview
In this repository, that machinery is realized as a Claude Code plugin marketplace for epistemic dialogue — each protocol structures a specific decision point: **FrameworkAbsent → FramedInquiry** (Prothesis), **GapUnnoticed → AuditedDecision** (Syneidesis), **ResultUngrasped → VerifiedUnderstanding** (Katalepsis), **BoundaryUndefined → DefinedBoundary** (Horismos), **ContextInsufficient → InformedExecution** (Aitesis), **MappingUncertain → ValidatedMapping** (Analogia), **AbstractionInProcess → CrystallizedAbstraction** (Periagoge), **AbstractAporia → ResolvedEndpoint** (Euporia), **ExecutionBlind → SituatedExecution** (Prosoche), **ApplicationDecontextualized → ContextualizedExecution** (Epharmoge), **ContextSuspect → VettedContext** (Elenchus), **RecallAmbiguous → RecalledContext** (Anamnesis) during human-AI interaction.
## Architecture
```
epistemic-protocols/
├── .claude-plugin/marketplace.json # Marketplace manifest
├── .claude/skills/verify/ # Project-level verification skill
│
│ # Each protocol plugin: .claude-plugin/plugin.json + skills/<verb>/SKILL.md
├── prothesis/ (/frame) # multi-perspective investigation
├── syneidesis/ (/gap) # gap surfacing
├── katalepsis/ (/grasp) # comprehension verification
├── horismos/ (/bound) # epistemic boundary definition
├── aitesis/ (/inquire) # context insufficiency inference
├── analogia/ (/ground) # structural mapping validation
├── periagoge/ (/induce) # in-process abstraction crystallization
├── euporia/ (/elicit) # Extended-Mind reverse induction
├── prosoche/ (/attend) # execution-time risk evaluation
├── epharmoge/ (/contextualize) # application-context mismatch (conditional)
├── elenchus/ (/sublate) # dialectical context vetting (pre-execution)
├── anamnesis/ (/recollect) # vague recall → recognized context
│ ├── hooks/hooks.json # SessionEnd hook: hypomnesis store writer
│ └── scripts/hypomnesis-write.mjs # mjs harness + claude -p haiku extraction
├── epistemic-cooperative/ # Utility skills + agents
│ ├── agents/ # project-scanner, session-analyzer, coverage-scanner, dimension-profiler
│ └── skills/ # report, onboard, dashboard, introspect, catalog, compose, sophia, curses, write, comment-review, review-ensemble, goal-research, steer, misuse, dispatch
└── src/ # Landing page (independent sub-project; React + Vite + Tailwind; EN/KO SPA)
```
**Component Types**:
- **Skills** (`skills/*/SKILL.md`): Full protocol/workflow definitions with YAML frontmatter; user-invocable by default (v2.1.0+)
- **Agents** (`agents/*.md`): Subagents for parallel task execution (epistemic-cooperative)
**Conventions**:
- Subagent naming: `plugin-name:agent-name` (e.g., `epistemic-cooperative:session-analyzer`)
- References directory: `skills/*/references/` for detailed documentation (optional per plugin)
- No external dependencies; Node.js standard library only (plugin code). `src/` landing page is an independent sub-project with its own `package.json`
**Plugin Encapsulation**: Runtime users interact with the packaged runtime contract: `Skill.md` (normative user contract) plus plugin description metadata (discovery/routing only, not full semantics). `.claude/rules/` prescriptive changes affecting protocol behavior must be compiled into `Skill.md` Rules sections. `Skill.md` must be self-contained — no external references (axiom identifiers, rule file paths, design-philosophy concepts, mission/vision docs) that require reading contributor documentation. Claim-strength boundaries for each runtime surface are tracked in [docs/runtime-dependency-ledger.md](docs/runtime-dependency-ledger.md).
**SKILL.md Formal Block Anatomy**: FLOW, MORPHISM, TYPES, PHASE TRANSITIONS, LOOP, TOOL GROUNDING, MODE STATE, COMPOSITION (and optional blocks). Details: [docs/structural-specs.md](docs/structural-specs.md#skillmd-formal-block-anatomy)
## Plugins
| Protocol | Slash | Deficit → Resolution |
|----------|-------|----------------------|
| Prothesis | `/frame` | FrameworkAbsent → FramedInquiry |
| Syneidesis | `/gap` | GapUnnoticed → AuditedDecision |
| Katalepsis | `/grasp` | ResultUngrasped → VerifiedUnderstanding |
| Horismos | `/bound` | BoundaryUndefined → DefinedBoundary |
| Aitesis | `/inquire` | ContextInsufficient → InformedExecution |
| Analogia | `/ground` | MappingUncertain → ValidatedMapping |
| Periagoge | `/induce` | AbstractionInProcess → CrystallizedAbstraction |
| Euporia | `/elicit` | AbstractAporia → ResolvedEndpoint |
| Prosoche | `/attend` | ExecutionBlind → SituatedExecution |
| Epharmoge | `/contextualize` | ApplicationDecontextualized → ContextualizedExecution |
| Elenchus | `/sublate` | ContextSuspect → VettedContext |
| Anamnesis | `/recollect` | RecallAmbiguous → RecalledContext |
**Utility skills**: Epistemic Cooperative (`/catalog`, `/report`, `/onboard`, `/probe`, `/dashboard`, `/compose`, `/introspect`, `/sophia`, `/curses`, `/write`, `/comment-review`, `/review-ensemble`, `/goal-research`, `/steer`, `/realign`, `/misuse`, `/dispatch`), Verify (`/verify`). Triggers, flows, and detailed descriptions in each plugin's SKILL.md.
**Probe utility (deficit recognition fit review)**: `/probe` (epistemic-cooperative) surfaces multiple candidate deficit hypotheses with reverse-evidence conditions when the user is uncertain which protocol fits the present situation. Probe is a utility skill, not a 13th core protocol — it is intentionally absent from `graph.json`. Coexistence over Mirroring applies: `/probe` may enrich scans with prior `misfit.md` records via opt-in cross-session read (default scope is current session; cross-session recall requires explicit user confirmation) and routes the user's recognized choice to the selected core protocol; the relationship is prose-level, not a graph.json edge. Probe stands in structural homology with Anamnesis (RECOGNIZE operation family — past context recognition vs present-situation deficit recognition) but the homology is descriptive, not enforced as advisory edges. **Architectural inscription** (new core protocol, new `graph.json` edge, category-level promotion) is deferred pending accumulated use evidence. **Type-level realization** of an already-inscribed `── COMPOSITION ──` product within an existing protocol's operational scope is internal iteration and does not require deferral framing — the distinction prevents the false-positive gating pattern recorded in issue #295. Verification framework limitations (drop-in feasibility vs endpoint well-defined-ness — two-axis distinction) tracked in [docs/probe-verification-framework.md](docs/probe-verification-framework.md) — instance L4a (PR #288), corroboration pending.
**Steer utility (project profile recalibration via calibration drift audit)**: `/steer` (epistemic-cooperative) is a Periagoge family specialization — it audits a target session for Cognitive Partnership Move calibration drift (Constitution overapplication, Extension misapplication, existing-profile drift), surfaces per-cluster evidence for user-constituted verdict, then writes an updated user-global (`~/.claude/rules/project-profile.md`) or project-local (`.claude/rules/project-profile.md`) project-profile rule file via Circular Return. Steer is a utility skill, not a 13th core protocol — intentionally absent from `graph.json`. Specializes `/induce` along two axes (instances constrained to session calibration moves; output constrained to writable rule inscription) without modifying base `/induce` semantics. The triple structure with `/probe` (prospective fit) and retrospective contract-integrity utilities — prose-level, not a graph.json edge — is described in the skill's Distinction section. Architectural inscription (advisory edges, formal lineage to `/induce`) is deferred pending accumulated use evidence. Self-referential meta-circle: Steer recalibrates the project profile (1st-order Circular Return) and is itself subject to subsequent evolution (2nd-order Circular Return). Pre-write timestamped backup is mandatory — rollback is a single `mv` command.
**Misuse utility (retrospective contract violation detector)**: `/misuse` (epistemic-cooperative) scans past sessions for retrospective protocol contract violations across `/ground` (Sₐ confabulation) and `/induce` (stereotype misconflation) invocations, surfaces structured violation records, and routes the user's constituted verdict via per-invocation recognition. Misuse is a utility skill, not a 14th core protocol — intentionally absent from `graph.json`. Default scope is current session; cross-session and cross-project scans require explicit user confirmation in Phase 0. Phase 4 recognition is verification-category (Anamnesis Phase 2 homologous, past-identity synthesis) — excluded from Differential Future Requirement; the option set encodes a 1-correct verdict structure (was-violation / was-legitimate) by purpose. Observation-only artifact: no auto-rewrite, no auto-reroute (Rule 6); calibration metadata in the emitted ViolationReview is for future live-nudge design only. Pairs with `/probe` as time-axis dual (probe = prospective fit recognition; misuse = retrospective contract audit) and shares the opt-in `misfit.md` substrate as auxiliary evidence. Architectural inscription deferred pending accumulated use evidence.
**Realign utility (project guide direction line via three-horizon fusion)**: `/realign` (epistemic-cooperative) is a Periagoge family extension — it surfaces three horizons (the project guide's currently inscribed direction line, externally surfaced direction signals from a configured channel set whose default is `{ open issues, pull-request reviews including bot reviews, closed disposition trajectory, current session utterances }`, and the user's present pre-understanding elicited as a separate Constitution sub-step), composes a fusion candidate with a per-horizon transformation trace marking what was preserved, transformed, or dropped in each horizon, shapes the candidate through the dialectical widen / narrow / fuse / reorient / confirm / dismiss vocabulary inherited from `/induce`, and on user confirmation writes the fused line back to the project guide direction line (rollback through the project's version control). Realign is a utility skill, not a 13th core protocol — intentionally absent from `graph.json`. Specializes `/induce` along two axes (instances constrained to three named horizons; output constrained to a single project-guide line write) without modifying base `/induce` semantics. Horizon-fusion discipline: an additive paste appending one horizon's content to another's as a clause is not a fusion, and the per-horizon trace is the verifier that surfaces silent preservation. Pre-understanding elicitation discipline: the user's pre-understanding is a separate horizon, not a derivation from the channel attribute list. Self-referential fixed point: when the project guide's direction line prescribes principles this skill's own prose must satisfy, the user's act of confirming the fused candidate is what guarantees consistency. Architectural inscription (advisory edges, formal lineage to `/induce`) is deferred pending accumulated cross-session use evidence.
**Dispatch utility (delegated parallel issue resolution)**: `/dispatch` (epistemic-cooperative) crystallizes a delegated multi-issue workflow into a categorical-decomposition + per-category-PR pipeline with rejection-trace inscription. Composes `/bound` (Phase 1) for delegation contract setup, then autonomously enumerates open issues, classifies them by project mission/direction (northstar) and evidence-accumulation status, fans out per-category sub-branches with per-category PRs, and post-PR routes per-PR feedback to either Phase 6 (rejection-trace inscription on linked issues — verbatim quote enforced to prevent fresh-context re-derivation loops) or Phase 7 (compliant minor-fix loop with out-of-scope non-expansion). Universal workflow + personal-config separation: SKILL.md inscribes only universal pipeline structure; project-specific values (profile-derived Extension/Constitution defaults, northstar, editing conventions, harness branch rules) are read at activation, never hardcoded. Dispatch is a utility skill, not a 13th core protocol — intentionally absent from `graph.json`. Implicitly invokes `/induce` (Periagoge) for Phase 3 categorization without a separate gate; optional Phase 0 enrichment via `/recollect` (Anamnesis) for prior cycle's rejected feedback context. Pairs with `/steer` and `/realign` as the read/write boundary on the project profile rule and the project guide direction line respectively (dispatch reads both; steer writes the profile, realign writes the direction line). Architectural inscription (graph.json edges, formal lineage to `/induce`, core protocol promotion) is deferred pending accumulated cross-session use evidence.
## Axioms
A1-A6 operational summaries auto-loaded via `.claude/rules/axioms.md`. Full definitions with rationale in the same file. Adversarial Anticipation (formerly A7) reclassified to Safeguard tier per audit-2026-04-11 #241 — see `.claude/rules/safeguards.md`.
## Design Philosophy
Prescriptive principles partition along Tier Factorization's o-tier (operational invocation frequency) into `.claude/rules/` (T1, auto-loaded per-session) and `.claude/principles/` (T2-T3, lazy-loaded via Read/Grep at authoring/verify time):
- `.claude/rules/axioms.md` — A1-A6 foundational principles (MORE important as models improve)
- `.claude/rules/derived-principles.md` — principles derived from axiom combinations
- `.claude/rules/architectural-principles.md` — Epistemic Cost Topology + Epistemic Completeness Boundary + Tier Factorization (T1, per-turn); other architectural principles live in `.claude/principles/architectural-principles.md` (T2-T3)
- `.claude/rules/safeguards.md` — Safeguard-tier principles (LESS important as models improve)
- `.claude/rules/project-profile-calibration.md` — Cognitive Partnership Move calibration mechanism (six profile variables → Extension/Constitution default)
- `.claude/rules/project-profile.md` — this project's profile declaration
- `.claude/principles/` — demotion zone for T2-T3 prose; see `.claude/principles/README.md` for index and demotion ledger.
## Protocol Precedence
### Epistemic Concern Clusters
Protocols grouped by primary concern, ordered by activation sequence within each cluster. Simultaneous activation follows cluster order; users can override. Information flow: `graph.json` (authoritative source).
| Concern | Protocols |
|---------|-----------|
| Planning | `/inquire` (Aitesis), `/elicit` (Euporia) |
| Analysis | `/frame` (Prothesis), `/ground` (Analogia), `/induce` (Periagoge) |
| Decision | `/gap` (Syneidesis) |
| Execution | `/attend` (Prosoche) |
| Verification | `/contextualize` (Epharmoge), `/sublate` (Elenchus) |
| Cross-cutting | `/bound` (Horismos), `/recollect` (Anamnesis), `/grasp` (Katalepsis) |
**Cross-cutting**: `/bound` (Horismos) — BoundaryMap narrows scope for 5 downstream protocols via DAG-downstream advisory. `/recollect` (Anamnesis) — recalled context enriches downstream protocols via advisory-only edges (no precondition weight). `/grasp` (Katalepsis) — requires all to complete.
**Key graph relationships**:
- Preconditions (DAG-enforced): * → Katalepsis (includes Anamnesis and Periagoge via wildcard). Horismos has no precondition source; Euporia → Horismos remains advisory.
- Advisory hubs: Anamnesis → {Aitesis, Prothesis, Syneidesis, Horismos, Prosoche, Analogia, Periagoge, Epharmoge, Euporia, Elenchus}, Horismos → {Aitesis, Prothesis, Prosoche, Analogia, Syneidesis, Euporia, Elenchus}, Prothesis → {Syneidesis, Aitesis, Analogia}, Euporia → {Horismos, Aitesis, Periagoge}, Aitesis → Elenchus, Elenchus → {Syneidesis, Prosoche, Epharmoge, Horismos}
- Suppression: Syneidesis ⊣ Aitesis (same scope), Aitesis ⊣ Epharmoge (pre+post stacking)
**Initiator taxonomy** (2-layer model):
- **Layer 1**: All protocols are user-invocable (slash command or description match). No AI detection at this layer.
- **Layer 2** (in-protocol heuristics): Behavior varies by initiator type:
- **AI-guided**: AI evaluates condition and guides the process (Prothesis, Syneidesis, Horismos, Aitesis, Analogia, Periagoge, Epharmoge, Anamnesis)
- **Hybrid**: Both user signal and AI detection can initiate; AI-detected trigger path requires user confirmation (Euporia)
- **User-initiated**: User signals awareness of a deficit; no AI-guided activation (Katalepsis, Prosoche, Elenchus)
- **User-invoked**: Deliberate practice; no deficit awareness required (Write)
## Development
- **Node.js 22+** required (`zlib.crc32` used in packaging; CI pins Node 22)
- **Plugin code: Node.js standard library only** — no runtime dependencies. Root `package.json` carries husky as the only devDependency (pre-commit activation); `src/package.json` for landing page.
- Static checks: `node .claude/skills/verify/scripts/static-checks.js .`
- Tests: `node --test scripts/package.test.js`
- Packaging: `node scripts/package.js [--dry-run]` — produces `dist/*.zip` + `dist/release-notes.md`
- Changelog: `node scripts/generate-changelog.js` — git conventional commit parser between tags
- Installer: `scripts/install.sh` — curl-based marketplace installer (README.md is source of truth for install set)
- Pre-commit hook: `.husky/pre-commit` runs tests + static checks + packaging dry-run when staged paths touch the runtime contract (per-protocol `SKILL.md`, `plugin.json`, `references/`, verify scripts, package scripts). Activated automatically by `npm install` via husky's prepare script.
## CI/CD
Three GitHub Actions workflows (`.github/workflows/`):
| Workflow | Trigger | Purpose |
|----------|---------|---------|
| `release.yml` | Tag push (`v*`) | Package → ZIP integrity → `gh release create --draft` |
| `claude-code-review.yml` | PR opened/ready | 3-stage pipeline: Sonnet review → jq extraction → Haiku comment |
| `claude-epistemic-review.yml` | PR with protocol changes | Multi-perspective analysis (Category Theory, Type Theory, Operational Semantics) + gap scan |
Details: [docs/ci-review-pipeline.md](docs/ci-review-pipeline.md)
### graph.json
Protocol dependency graph at `.claude/skills/verify/graph.json`. Validated by static check `graph-integrity`.
```
Edge types (allowlist):
precondition — must complete before target (DAG-checked for cycles)
advisory — provides useful context but not required
suppression — prevents stacking of similar protocols
Wildcard: "source": "*" = all nodes except target
Descriptions: "satisfies" field in Korean
```
## Verification
Run `/verify` before commits. Static checks via:
```bash
node .claude/skills/verify/scripts/static-checks.js .
```
22 static checks: json-schema, notation, directive-verb, xref, structure, tool-grounding, version-staleness, graph-integrity, spec-vs-impl, morphism-anatomy, cross-ref-scan, onboard-sync, precedence-linear-extension, partition-invariant, catalog-sync, gate-type-soundness, artifact-self-containment, emit-load-discipline, single-axis-soundness, agents-symlinks-sync, workflow-paths-sync, language-purity. `artifact-self-containment` validates the packaged runtime contract view (`Skill.md` + plugin description metadata + packaged support entries) rather than source prose alone. `emit-load-discipline` verifies compiled-copy coverage for Context-Question Separation, Plain emit discipline, and Round-local salience bundling across core protocol SKILL.md files. `single-axis-soundness` enforces `TOOL GROUNDING`'s `(constitution)`/`(extension)` markers as the sole runtime annotation axis across live `*.md` files. `agents-symlinks-sync` verifies the `.agents/skills/` Agent Skills cross-tool view (Cursor / GitHub Copilot / Devin / OpenCode / Codex / Gemini per [agentskills.io](https://agentskills.io)) stays in sync with plugin sources (repair: `scripts/sync-agents-symlinks.sh`). `workflow-paths-sync` verifies `.github/workflows/claude-epistemic-review.yml` `paths` declares every protocol plugin so new protocols cannot silently miss the multi-perspective epistemic review trigger. `language-purity` surfaces Korean characters in project text files at warn-level under a Stage 1 surface posture; whitelist preserves intentional Korean regions (Korean READMEs, release notes, landing-page i18n, repo docs, Korean commit conventions, `graph.json` `satisfies` field, plugin-level `docs/`/`references/`). Details: [docs/verification.md](docs/verification.md)
## Delegation Constraint
- **Prothesis**: See SKILL.md for phase-specific delegation rules (Phase 0-2 main agent, Phase 3-4 agent team incl. routing)
- **Syneidesis/Katalepsis**: No Task delegation—must run in main agent (user-facing gates require main agent context)
- **Horismos**: No Task delegation—must run in main agent (user-facing gates require main agent context)
- **Aitesis**: No Task delegation—must run in main agent (user-facing gates require main agent context)
- **Epharmoge**: No Task delegation—must run in main agent (user-facing gates require main agent context)
- **Elenchus**: No Task delegation—must run in main agent (user-facing gates require main agent context). Phase 1 Step 1 (provenance tagging) uses Read/Grep for read-only source verification only.
- **Analogia**: No Task delegation—must run in main agent (user-facing gates require main agent context)
- **Periagoge**: No Task delegation—must run in main agent (user-facing gates require main agent context)
- **Euporia**: No Task delegation—must run in main agent (user-facing gates require main agent context). Phase 1 substrate access uses Read/Grep/Bash for read-only scan only.
- **Prosoche**: Phase -1 (Sub-A0 upstream routing, Sub-A materialization, Sub-B team coordination) and Phases 1-3 (Gate path) run in main agent (gate interaction, Skill). Phase 0 delegates p=Low tasks to prosoche-executor subagent or team agents via Agent tool.
- **Anamnesis**: No Task delegation—must run in main agent (user-facing gates require main agent context). SessionEnd + PreCompact hooks (`anamnesis/scripts/hypomnesis-write.mjs`) operate outside protocol flow, extracting session recall index via `claude -p haiku` harness.
- **Report**: Phase 1 delegates to project-scanner subagent (single). Phase 2: Path A delegates session-analyzer in targeted mode, Path B in full mode. Main agent handles Phases 3-5.
- **Onboard**: All paths use inline Quick Scan (no subagents) for Phase 1. Deep pattern extraction belongs in Report. Main agent handles all phases. Quick path: Phases 0-1, 2a-2b, 4 (Trial triggers actual protocol execution in-session). Targeted path: Phases 0-6 (full learning experience).
- **Dashboard**: Phase 2 delegates to coverage-scanner subagent (single) for batch aggregation. Main agent handles Phases 1, 3, 4.
- **Introspect**: Phase 1 launches 3 ad-hoc inline Task(general-purpose) invocations in parallel (rules/config collection, usage stats collection, session behavior collection). Main agent handles Phase 2 (5-dimension analysis, Strength-Shadow, normative-descriptive conflict surface) — emits analysis as text output with a visible red-line discovery line; corrections via free response at subsequent turns regenerate affected downstream sections. Phase 3 main agent optionally composes `/analogia:ground`. Phase 4 main agent generates HTML output; `references/report-guide.md` used for CSS/component templates.
- **Catalog**: No delegation—text-only output, main agent handles all. Read tool for scenarios.md detail mode only.
- **Compose**: No delegation—main agent handles all phases. Read/Grep for graph.json and TOOL GROUNDING extraction, Write for template generation.
- **Sophia**: Phase 1 delegates to coverage-scanner then dimension-profiler subagents (serial chain). Main agent handles Phases 2-4 (matching, presentation, report).
- **Curses**: Phase 1 delegates to coverage-scanner then dimension-profiler subagents (serial chain). Main agent handles Phases 2-4 (analysis, recommendations, report).
- **Write**: No delegation—main agent handles all phases. Composes /frame (Prothesis) for perspective analysis; the composed protocol's delegation rules apply when invoked.
- **Comment Review**: No delegation—main agent handles all pipeline phases. Composes /inquire × /sublate × /gap × /contextualize; sub-protocol delegation rules apply when invoked. Channel-loop runs as a background Bun process (not Task delegation). Round modes are `apply + scan` (apply queued JSONL comments now + scan to materialize sub-protocol findings into the next round's TaskList-backed sidepanel) or `apply` (apply only); per-finding Constitution judgment relocates from in-round chat to next-round response popup (click finding → response auto-tagged `[task: <id>]`) or chat (TaskUpdate). Round-mode decisions stay in chat — modality cleanliness preserved.
- **Review Ensemble**: Main agent handles all phases. Phase 2 launches Codex CLI in background (Bash run_in_background) and invokes `prothesis:frame` foreground via Skill(); composed protocol's delegation rules apply when invoked. Fallback mode spawns two inline Agent subagents in parallel when `prothesis:frame` is unavailable.
- **Goal Research**: No delegation—main agent handles all phases. Codex CLI invocation via Bash run_in_background (Phase 2); trace presentation at Phase 4. Failure modes exposed as raw errors per GoalContract.
- **Realign**: No delegation—main agent handles all phases (Phase 0-3). User-facing Constitution interactions at Phase 0 (scope confirmation), Phase 1 (user pre-understanding elicitation as a separate sub-step), Phase 2 (dialectical shaping per step), and Phase 3 (final approval) require main agent context. Phase 1 horizon surfacing uses Read for the project guide and per-channel substrate tools (Bash for `gh` issue/PR queries, Read/Grep for closed disposition trajectory, current-session utterances inspected in conversation context); Phase 3 inscription uses Edit / Write on the project guide direction line. Rollback through the project's version control. No auto-hooks.
- **Dispatch**: No Task delegation—main agent handles all phases (Phase 0-7). User-facing Constitution interactions at Phase 1 (delegation contract via composed `/bound`) and Phase 3 (contested-partition gate) require main agent context. Phase 1 composes `/bound` via Skill(); composed protocol's delegation rules apply when invoked. Phase 4 per-category execution may invoke any protocol the per-issue work requires; those compositions' delegation rules apply when nested under the category's branch context. Bash for `gh` issue/PR I/O, `git` branch/commit/push, and verify scripts; Read/Grep for project profile and editing-convention rules; Edit/Write for per-issue work artifacts. No auto-hooks.
## Conventions
Git and editing rules auto-loaded via `.claude/rules/editing-conventions.md`.
Co-change patterns tracked in [docs/co-change.md](docs/co-change.md). Key: any protocol change requires plugin.json version bump + `/verify`.