AD‑07 [CL] — Closure Budgets & Energy Index (E)

Aliases: None Cluster: Care / Kernel Depends on: AD‑01 [OV], AD‑05 [MRP], AD‑08 [SO], AD‑22 [EC], AD‑23 [EN]

0. For humans

What question does this answer?

"How do we cap reflection and deep loops in a way that respects time, energy, and user load — and make those caps visible instead of arbitrary?"

How do I know it's live?

You can point to:

• A defined Energy Index (E) per session, combining tokens, tool calls, and wall‑clock time.
• Concrete Closure Budgets: per turn, per deep loop / reflection window, per session.
• Behaviour when budgets are hit: the system summarises or exits instead of silently continuing; logs a BUDGET_BREACH event and updates FHR counts.
• UI: a Care / Energy meter that shows cycles used and Energy Index (E), with a one‑tap "Move to options."

Where do I see it?

• UI: Care / Energy meter with E and budget progress; Eco Mode toggle; Decide‑First mode indicator.
• FHR / logs: E_session, E_turn, energy_kwh_est, co2_kg_est (via AD‑23 [EN]), closure_budget_spec, budget_breach_count, budget_breach_last_reason.

Quick checklist

• Implemented if: E computed in production; Closure Budgets at turn/loop/session levels enforced by MRP; care modes change budgets (tighten, never loosen).
• Key artefacts: closure budget profile definitions, E formula coefficients.
• Key FHR fields: E_session, budget_breach_count, closure_budget_spec, cooloff_active.
• Key failure codes: BUDGET_BREACH.
• Escalation path: budget breach → summarise/EXIT → AD‑12 [OP] if repeated.

1. Purpose & scope

AD‑07 [CL] defines:

1. Closure Budgets as formal caps on reflection depth/loops, tokens, wall‑clock time, and energy index E.
2. The Energy Index (E) as a simple, per‑session scalar that ties ambiguity caps to resource cost.
3. The rules for how budgets adjust under care modes (Decide‑First, Eco Mode, care overrides), how they interact with MRP states, and how they are exposed in FHR and UI.

It does not redefine: measurement design (AD‑16 [ME]), carbon accounting detail (AD‑23 [EN]), or care ethics framing (AD‑22 [EC]). It is the mechanical stop protocol for reflection, aligned with ecological and ethical design.

2. Energy Index (E)

2.1 Definition

Session‑level Energy Index:

E_session = α·(tokens_in + tokens_out) + β·tool_calls + γ·wall_time_s

• tokens_in / tokens_out: all text in/out for this session.
• tool_calls: number (or weighted sum) of external tool invocations.
• wall_time_s: wall‑clock seconds of active processing.
• α, β, γ: normalisation coefficients; defaults documented by deployment (AD‑23 [EN] expands calibration).

Per‑turn and per‑loop slices (E_turn, E_loop) drive local decisions.

2.2 Ecological alignment

E enables energy‑tied closure: tie ambiguity caps to cost so that if E grows without constraint adoption, the system stops or compresses rather than chasing endless nuance. E can be mapped to energy_kwh_est, co2_kg_est, co2_ci_band by AD‑23 [EN].

3. Closure Budgets: types & semantics

Three levels:

1. Turn‑level Closure Budget (CB_turn). Caps how much reflection within a single turn: number of internal reflection cycles, tool calls, tokens of explanation/meta. Strongly tied to MRP: Reflect‑Only loops consume CB_turn; once exhausted, the system must summarise or offer options.

2. Loop‑level Closure Budget (CB_loop). Applies to deep loops (extended self‑critique, multi‑step planning, heavy SPD surgery). After a CARE_OVERRIDE, deep loops are blocked for at least one Closure‑Budget cycle (or ≥1 TAW if physio is enabled), to prevent perseveration.

3. Session‑level Closure Budget (CB_session). Coupled directly to E: if E_session > E_max before adopting a new constraint, summarise/exit and log BUDGET_BREACH. Prevents infinite exploration.

Across all levels: budgets bound reflection, not user conversation per se; the user can always ask fresh questions, but deep spirals are capped.

4. Rules: what happens when budgets are hit

4.1 Before hard breach

As E and budgets approach thresholds, the system nudges and simplifies: suggest summarising, narrowing scope, or choosing a concrete path; offer Present‑Options. Adjust its side via Burden Symmetry: auto‑summaries, fewer questions, shorter closure for that turn.

4.2 On breach

If E_session passes E_max before user adopts a new constraint or clear decision: summarise key points, trade‑offs, and any open contradictions; exit the deep loop; move to DECIDE or EXIT; log BUDGET_BREACH with reason and context band; brief UI banner. PEL/EHG always override: closure cannot shortcut ethical obligations.

4.3 Care Override cooldown

When a CARE_OVERRIDE occurs (user overwhelmed, entropy surge, jurisdiction concerns): MRP blocks deep loops for at least one Closure‑Budget cycle. Log CARE_COOLOFF_STARTED and later CARE_COOLOFF_OK when pacing metrics stabilise. FHR flags: cooloff_active, cooloff_reason, cooloff_elapsed_ms.

5. Profiles & modes

5.1 Decide‑First care mode

Trades reflection for speed, all gates intact, with tighter Closure Budget and "safe" attunement governor. MRP profile: skip Reflect‑Only loops where possible; go quickly to OPTIONS or DECIDE with concise rationales. CL integration: CB_turn and CB_loop compressed. Logged as care_mode = decide_first.

5.2 Eco Mode

Tighter Closure Budgets, leaner summaries, deferred non‑urgent deep reflection; default in Regulatory Mode. Effects: lower E_max, aggressive compression (T1/T2 summaries, archival/anchors over keeping everything live). In Regulatory Mode: Eco Mode defaults ON; deployers can hide CO₂ display, but FHR still records values.

5.3 Burden Symmetry & closure

When the system asks for holding (Reflect‑Only, Freeze‑Reflect), it reduces user burden by auto‑summaries, fewer queries, shorter Closure Budget for that turn. Encoded as per‑turn tightening of CB_turn during system‑initiated holds.

6. Interactions with MRP & other layers

• AD‑05 [MRP]: MRP uses Closure Budgets to bound HOLD/TEST loops. If CB_turn exhausted in HOLD → OPTIONS or DECIDE with summary. In care cool‑down windows, MRP cannot re‑enter deep reflective loops until CARE_COOLOFF_OK.
• AD‑06 [DG]: drift may consume budget faster; when drift + high E + care flags coincide, the system is pushed toward summarise/options/exit.
• AD‑29 [PLG]: PLG's closure budget binding (AD‑29 §6.2) uses Closure Budgets as the mechanical stop for cumulative scope‑adjacent drift; after N scope‑adjacent moves, forces Pin Review and emits BUDGET_BREACH with reason = scope_adjacent_cumulative.
• AD‑22 [EC]: defines care modes, cooldowns, equity lenses; Closure Budgets provide the mechanical substrate.
• AD‑23 [EN]: maps E → energy_kwh_est → co2_kg_est with method provenance.
• AD‑24 [CC]: introduces CLB (cognitive load budget) with clb_throttled flags; CLB breaches can tighten Closure Budgets.
• AD‑30 [SC]: memory write restrictions during high‑resonance states interact with closure budget state; high E + high resonance without reflection checkpoint → memory writes blocked.
• AD‑31 [HS]: integrity prompts may be offered at closure budget thresholds; human‑initiated pause maps to MRP HOLD with budget accounting.

7. FHR fields & events

7.1 Fields

Per session: E_session, energy_kwh_est, co2_kg_est, co2_ci_band (from AD‑23 [EN]), closure_budget_spec (struct with cb_turn_default, cb_loop_default, cb_session_default, cb_profile), budget_breach_count, budget_breach_last_reason.

Per turn/loop: E_turn, optionally E_loop, closure_budget_turn_used, closure_budget_turn_limit, loop_id, closure_budget_loop_used, closure_budget_loop_limit.

Care/cooldown overlap: cooloff_active, cooloff_reason, cooloff_elapsed_ms.

7.2 Events

• BUDGET_BREACH{type, reason, E_session, cb_used}
• CLOSURE_BUDGET_UPDATE{profile_change, cb_spec_before, cb_spec_after}
• CARE_COOLOFF_STARTED{ts, reason, budget_spec}
• CARE_COOLOFF_OK{ts, ri_band_ok, erg_trend_ok}

8. Invariants vs configurable degrees of freedom

Hard invariants:

• There is a session‑level Energy Index (E) of the form E = α·(tokens_in + tokens_out) + β·tool_calls + γ·wall_time_s (coefficients may differ, but the structure is respected).
• There are Closure Budgets at least at per‑turn, per‑loop, per‑session levels.
• Exceeding E_max before constraint adoption forces a summarise/exit pattern and logs BUDGET_BREACH.
• After a CARE_OVERRIDE, deep loops are blocked for at least one Closure‑Budget cycle, with explicit cooldown events and FHR flags.
• Eco Mode and Decide‑First modes tighten Closure Budgets (never loosen them) relative to the standard profile.

Configurable degrees of freedom:

• Concrete numerical values: α, β, γ, CB_turn, CB_loop, CB_session, Eco/Decide‑First multipliers.
• Exact conditions for offering more options vs direct summary vs exit.
• UI copy and visual design for meters and hints (as long as they remain honest and non‑performative).

9. Acceptance: when can you say "AD‑07 is implemented"?

You can confidently claim AD‑07 [CL] is live if:

1. Energy Index (E) is computed in production, logged per session, and used to cap reflection via E_max.
2. Closure Budgets exist at turn/loop/session levels and: are enforced by MRP (loops actually stop); trigger summaries/exits and BUDGET_BREACH events when breached.
3. Care modes (Decide‑First, Eco Mode, Care Override cooldowns) actually change the budgets: tighter, not looser; recorded in FHR.
4. UI surfaces some representation of E / cycles used and a "move to options / shorten / stop" control.
5. FHR and events provide enough granularity for RA and ops to inspect E distributions, see how often budgets breach, and cross‑reference care overrides/cooldowns.

If E is computed but not used; or if budgets exist but never alter behaviour; or if care/eco modes are pure copy with no changes to caps; then AD‑07 is not actually implemented — you have observability without bounded reflection.