---
paths: ".claude/**, devforgeai/**"
---

# Defer Classification Policy

**Purpose:** Define how DevForgeAI consumer projects should classify and accept sanctioned-defer items, to prevent defer entries from themselves becoming the ceremonial-prose pathology the framework's hooks/gates exist to fix.

**Scope:** Applies to any DevForgeAI consumer project when a session closes with one or more "sanctioned-defer" items — work items the user has explicitly decided to postpone (vs. abandon vs. ship now).

**Reference:** ADR-076 (ceremony-to-hook policy — defers follow the same discipline recursively).

---

## Why this rule exists

When closing a session with sanctioned-defer items, the temptation is to write the defer in a note ("memory entry", "TODO file", "follow-up doc") and move on. This is itself the same pathology the modernization arc has been fighting: prose Claude may ignore.

A defer that depends solely on "remember this note" is **ceremonial**. The framework's enforcement layers (hooks, CLI gates) exist because prose-only enforcement is empirically unreliable under token pressure. Defers must follow the same discipline — otherwise the framework's enforcement-grade work is undermined by ceremonial follow-up scheduling.

This rule defines the 2-axis taxonomy to apply before accepting any defer.

---

## Two-axis taxonomy

Every sanctioned defer should be classified along TWO axes before being accepted:

### Axis 1 — Trigger condition enforcement

| Strength | What it means |
|----------|---------------|
| **HOOK-BACKED** | A PreToolUse / PostToolUse hook fires (with `exit 2`) when the trigger condition is met. Genuinely redirects Claude regardless of what is or isn't in any note. |
| **CLI-GATE-BACKED** | A `devforgeai-validate <subcommand>` call exits non-zero at the moment the condition matters. Same enforcement weight as HOOK-BACKED. |
| **PROSE-IN-FRAMEWORK** | The trigger condition is stated in a file that ships with the framework (`.claude/rules/`, `.claude/agents/`, ADR, etc.). Claude *should* read it; may not honor it. |
| **PROSE-IN-NOTE** | The trigger condition is only in a session-local note, project-local memory, or other artifact that does not ship with the framework. Future Claude in the same project might see it; new sessions / community installs definitely won't. |

### Axis 2 — Portability

| Reach | What it means |
|-------|---------------|
| **FRAMEWORK-PORTABLE** | Record lives in a path that ships with the framework: `.claude/rules/`, `.claude/skills/`, `.claude/agents/`, `.claude/commands/`, `.claude/hooks/`, `devforgeai/specs/adrs/`, `devforgeai/specs/context/`, or `src/claude/...`. Community installs inherit the record. |
| **PROJECT-LOCAL** | Record lives in a path that does NOT ship to community installs (project-local memory, session notes, working-tree-only docs). |

---

## The 4-corner matrix

| Axis 1 ↓ \ Axis 2 → | FRAMEWORK-PORTABLE | PROJECT-LOCAL |
|---|---|---|
| **HOOK-BACKED / CLI-BACKED** | **STRONG** — community installs honor it; deterministic | Rare (a note adds no value when the hook itself is the enforcement) |
| **PROSE-IN-FRAMEWORK** | **MEDIUM** — community sees the prose; Claude may or may not honor | Inconsistent (prose ships but key context only here) |
| **PROSE-IN-NOTE** | N/A (notes are by definition project-local) | **WEAK 2x** — ceremonial trigger that community Claude never even reads |

---

## When to use each strength

- **STRONG** — appropriate for any defer that should fire reliably in community installs. Cost: writing a hook or CLI gate. Use when the trigger condition is observable in the tool-call stream (file paths, command strings, exit codes).
- **MEDIUM** — appropriate when the trigger involves judgment that a hook can't make (e.g., "if reviewer flags X, do Y"). Documentation-style accept-and-document patterns land here. Acceptable for community installs but not enforcement-grade.
- **WEAK 2x (PROSE-IN-NOTE / PROJECT-LOCAL)** — appropriate ONLY for project-internal dogfood work that genuinely doesn't apply to community installs. If a defer touches framework-shipped behavior, this strength is the wrong tool — raise the question of whether the defer should become a hook PR instead.

---

## Forward-pointer policy for any DevForgeAI consumer project

For any sanctioned defer in any DevForgeAI consumer project, the record (wherever it lives) should explicitly carry:

1. **Enforcement Backing** — one of: `HOOK` / `CLI` / `PROSE-FRAMEWORK` / `PROSE-NOTE`.
2. **Community Install Impact** — one of: `N/A-project-internal` / `FRAMEWORK-PORTABLE-PROSE` / `FRAMEWORK-PORTABLE-HOOK`.
3. **Decision check** — if both axes are WEAK and the defer touches framework-shipped behavior, raise the question: should this be a hook PR instead of a defer?

These three fields make the classification explicit at the time of acceptance, so the defer can be audited later without re-deriving its strength.

---

## Strategic implication

The "ceremony is not enforcement" critique applies recursively. A defer recorded only in a note IS ceremony — it depends on a future Claude reading the note and honoring it. A defer recorded only as prose IN the framework IS still ceremony — it depends on Claude reading agent/rule files and honoring them. A defer mechanized as a hook IS enforcement — Claude has no choice.

The framework's modernization arc has been systematically converting Axis-1 prose to hooks (ADR-076 codifies this). Defers should follow the same discipline:

1. **Before accepting a defer**, ask "what makes a future Claude (this project's OR a community install's) act on this?"
2. **If the answer is "remember the note"**, the defer is purely ceremonial — same pathology being fixed in the main work.
3. **If the answer is "the hook / CLI exit-2's when the condition is met"**, the defer has real teeth.
4. **If the trigger genuinely cannot be hooked** (subjective judgment, project-internal dogfood), then a note is acceptable BUT the entry should explicitly state "this defer applies to THIS project only; community installs are not affected" — so future readers don't mistake it for portable guidance.

---

## References

- **ADR-076** — Ceremony-to-hook policy. Defines the parent classification framework (COVERED / HOOK-GAP / CLI-GATE-GAP / NOT-DETERMINISTIC) this rule applies recursively to defers.
- **`.claude/rules/core/anti-skip-behavior.md`** — The behavioral-admonition file that owns NOT-DETERMINISTIC residue (parent class of WEAK-2x defers).
- **Sibling ceremony-to-hook conversions** — ADR-092, ADR-093, ADR-096, ADR-098, ADR-099 (the framework's own examples of defer-graduation: each was once a prose admonition that became a hook / CLI gate).

---

**Version:** 1.0 | **Created:** 2026-05-25 | **Source:** Ported from project-local memory entry surfacing the ceremonial-defer critique
